haiku: updated for Haiku

src/video/haiku/SDL_BApp.h

@@ -0,0 +1,431 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef SDL_BAPP_H
+#define SDL_BAPP_H
+
+#include <Path.h>
+#include <InterfaceKit.h>
+#include <LocaleRoster.h>
+#if SDL_VIDEO_OPENGL
+#include <OpenGLKit.h>
+#endif
+
+#include "../../video/haiku/SDL_bkeyboard.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../../SDL_internal.h"
+
+#include "SDL_video.h"
+
+/* Local includes */
+#include "../../events/SDL_events_c.h"
+#include "../../video/haiku/SDL_bframebuffer.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <vector>
+
+
+
+
+/* Forward declarations */
+class SDL_BWin;
+
+/* Message constants */
+enum ToSDL {
+    /* Intercepted by BWindow on its way to BView */
+    BAPP_MOUSE_MOVED,
+    BAPP_MOUSE_BUTTON,
+    BAPP_MOUSE_WHEEL,
+    BAPP_KEY,
+    BAPP_REPAINT,           /* from _UPDATE_ */
+    /* From BWindow */
+    BAPP_MAXIMIZE,          /* from B_ZOOM */
+    BAPP_MINIMIZE,
+    BAPP_RESTORE,           /* TODO: IMPLEMENT! */
+    BAPP_SHOW,
+    BAPP_HIDE,
+    BAPP_MOUSE_FOCUS,       /* caused by MOUSE_MOVE */
+    BAPP_KEYBOARD_FOCUS,    /* from WINDOW_ACTIVATED */
+    BAPP_WINDOW_CLOSE_REQUESTED,
+    BAPP_WINDOW_MOVED,
+    BAPP_WINDOW_RESIZED,
+    BAPP_SCREEN_CHANGED
+};
+
+
+
+/* Create a descendant of BApplication */
+class SDL_BApp : public BApplication {
+public:
+    SDL_BApp(const char* signature) :
+        BApplication(signature) {
+#if SDL_VIDEO_OPENGL
+        _current_context = NULL;
+#endif
+    }
+
+
+    virtual ~SDL_BApp() {
+    }
+
+
+	virtual void RefsReceived(BMessage* message) {
+		char filePath[512];
+		entry_ref entryRef;
+		for (int32 i = 0; message->FindRef("refs", i, &entryRef) == B_OK; i++) {
+			BPath referencePath = BPath(&entryRef);
+			SDL_SendDropFile(NULL, referencePath.Path());
+		}
+		return;
+	}
+
+        /* Event-handling functions */
+    virtual void MessageReceived(BMessage* message) {
+        /* Sort out SDL-related messages */
+        switch ( message->what ) {
+        case BAPP_MOUSE_MOVED:
+            _HandleMouseMove(message);
+            break;
+
+        case BAPP_MOUSE_BUTTON:
+            _HandleMouseButton(message);
+            break;
+
+        case BAPP_MOUSE_WHEEL:
+            _HandleMouseWheel(message);
+            break;
+
+        case BAPP_KEY:
+            _HandleKey(message);
+            break;
+
+        case BAPP_REPAINT:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_EXPOSED);
+            break;
+
+        case BAPP_MAXIMIZE:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_MAXIMIZED);
+            break;
+
+        case BAPP_MINIMIZE:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_MINIMIZED);
+            break;
+
+        case BAPP_SHOW:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_SHOWN);
+            break;
+
+        case BAPP_HIDE:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_HIDDEN);
+            break;
+
+        case BAPP_MOUSE_FOCUS:
+            _HandleMouseFocus(message);
+            break;
+
+        case BAPP_KEYBOARD_FOCUS:
+            _HandleKeyboardFocus(message);
+            break;
+
+        case BAPP_WINDOW_CLOSE_REQUESTED:
+            _HandleBasicWindowEvent(message, SDL_WINDOWEVENT_CLOSE);
+            break;
+
+        case BAPP_WINDOW_MOVED:
+            _HandleWindowMoved(message);
+            break;
+
+        case BAPP_WINDOW_RESIZED:
+            _HandleWindowResized(message);
+            break;
+
+        case B_LOCALE_CHANGED:
+            SDL_SendLocaleChangedEvent();
+            break;
+
+        case BAPP_SCREEN_CHANGED:
+            /* TODO: Handle screen resize or workspace change */
+            break;
+
+        default:
+           BApplication::MessageReceived(message);
+           break;
+        }
+    }
+
+    /* Window creation/destruction methods */
+    int32 GetID(SDL_Window *win) {
+        int32 i;
+        for(i = 0; i < _GetNumWindowSlots(); ++i) {
+            if( GetSDLWindow(i) == NULL ) {
+                _SetSDLWindow(win, i);
+                return i;
+            }
+        }
+
+        /* Expand the vector if all slots are full */
+        if( i == _GetNumWindowSlots() ) {
+            _PushBackWindow(win);
+            return i;
+        }
+
+        /* TODO: error handling */
+        return 0;
+    }
+
+    /* FIXME: Bad coding practice, but I can't include SDL_BWin.h here.  Is
+       there another way to do this? */
+    void ClearID(SDL_BWin *bwin); /* Defined in SDL_BeApp.cc */
+
+
+    SDL_Window *GetSDLWindow(int32 winID) {
+        return _window_map[winID];
+    }
+
+#if SDL_VIDEO_OPENGL
+    BGLView *GetCurrentContext() {
+        return _current_context;
+    }
+    
+    void SetCurrentContext(BGLView *newContext) {
+        if(_current_context)
+            _current_context->UnlockGL();
+        _current_context = newContext;
+        if (_current_context)
+            _current_context->LockGL();
+    }
+#endif
+
+private:
+    /* Event management */
+    void _HandleBasicWindowEvent(BMessage *msg, int32 sdlEventType) {
+        SDL_Window *win;
+        int32 winID;
+        if(
+            !_GetWinID(msg, &winID)
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        SDL_SendWindowEvent(win, sdlEventType, 0, 0);
+    }
+
+    void _HandleMouseMove(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        int32 x = 0, y = 0;
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindInt32("x", &x) != B_OK || /* x movement */
+            msg->FindInt32("y", &y) != B_OK    /* y movement */
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+
+        // Simple relative mode support for mouse.
+        if (SDL_GetMouse()->relative_mode) {
+            int winWidth, winHeight, winPosX, winPosY;
+            SDL_GetWindowSize(win, &winWidth, &winHeight);
+            SDL_GetWindowPosition(win, &winPosX, &winPosY);
+            int dx = x - (winWidth / 2);
+            int dy = y - (winHeight / 2);
+            SDL_SendMouseMotion(win, 0, SDL_GetMouse()->relative_mode, dx, dy);
+            set_mouse_position((winPosX + winWidth / 2), (winPosY + winHeight / 2));
+            if (!be_app->IsCursorHidden())
+                be_app->HideCursor();
+        } else {
+            SDL_SendMouseMotion(win, 0, 0, x, y);
+            if (SDL_ShowCursor(-1) && be_app->IsCursorHidden())
+                be_app->ShowCursor();
+        }
+    }
+
+    void _HandleMouseButton(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        int32 button, state;    /* left/middle/right, pressed/released */
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindInt32("button-id", &button) != B_OK ||
+            msg->FindInt32("button-state", &state) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        SDL_SendMouseButton(win, 0, state, button);
+    }
+
+    void _HandleMouseWheel(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        int32 xTicks, yTicks;
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindInt32("xticks", &xTicks) != B_OK ||
+            msg->FindInt32("yticks", &yTicks) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        SDL_SendMouseWheel(win, 0, xTicks, -yTicks, SDL_MOUSEWHEEL_NORMAL);
+    }
+
+    void _HandleKey(BMessage *msg) {
+        int32 scancode, state;  /* scancode, pressed/released */
+        if(
+            msg->FindInt32("key-state", &state) != B_OK ||
+            msg->FindInt32("key-scancode", &scancode) != B_OK
+        ) {
+            return;
+        }
+
+        /* Make sure this isn't a repeated event (key pressed and held) */
+        if(state == SDL_PRESSED && HAIKU_GetKeyState(scancode) == SDL_PRESSED) {
+            return;
+        }
+        HAIKU_SetKeyState(scancode, state);
+        SDL_SendKeyboardKey(state, HAIKU_GetScancodeFromBeKey(scancode));
+
+        if (state == SDL_PRESSED && SDL_EventState(SDL_TEXTINPUT, SDL_QUERY)) {
+            const int8 *keyUtf8;
+            ssize_t count;
+            if (msg->FindData("key-utf8", B_INT8_TYPE, (const void**)&keyUtf8, &count) == B_OK) {
+                char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];
+                SDL_zeroa(text);
+                SDL_memcpy(text, keyUtf8, count);
+                SDL_SendKeyboardText(text);
+            }
+        }
+    }
+
+    void _HandleMouseFocus(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        bool bSetFocus; /* If false, lose focus */
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindBool("focusGained", &bSetFocus) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        if(bSetFocus) {
+            SDL_SetMouseFocus(win);
+        } else if(SDL_GetMouseFocus() == win) {
+            /* Only lose all focus if this window was the current focus */
+            SDL_SetMouseFocus(NULL);
+        }
+    }
+
+    void _HandleKeyboardFocus(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        bool bSetFocus; /* If false, lose focus */
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindBool("focusGained", &bSetFocus) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        if(bSetFocus) {
+            SDL_SetKeyboardFocus(win);
+        } else if(SDL_GetKeyboardFocus() == win) {
+            /* Only lose all focus if this window was the current focus */
+            SDL_SetKeyboardFocus(NULL);
+        }
+    }
+
+    void _HandleWindowMoved(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        int32 xPos, yPos;
+        /* Get the window id and new x/y position of the window */
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindInt32("window-x", &xPos) != B_OK ||
+            msg->FindInt32("window-y", &yPos) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        SDL_SendWindowEvent(win, SDL_WINDOWEVENT_MOVED, xPos, yPos);
+    }
+
+    void _HandleWindowResized(BMessage *msg) {
+        SDL_Window *win;
+        int32 winID;
+        int32 w, h;
+        /* Get the window id ]and new x/y position of the window */
+        if(
+            !_GetWinID(msg, &winID) ||
+            msg->FindInt32("window-w", &w) != B_OK ||
+            msg->FindInt32("window-h", &h) != B_OK
+        ) {
+            return;
+        }
+        win = GetSDLWindow(winID);
+        SDL_SendWindowEvent(win, SDL_WINDOWEVENT_RESIZED, w, h);
+    }
+
+    bool _GetWinID(BMessage *msg, int32 *winID) {
+        return msg->FindInt32("window-id", winID) == B_OK;
+    }
+
+
+
+    /* Vector functions: Wraps vector stuff in case we need to change
+       implementation */
+    void _SetSDLWindow(SDL_Window *win, int32 winID) {
+        _window_map[winID] = win;
+    }
+
+    int32 _GetNumWindowSlots() {
+        return _window_map.size();
+    }
+
+
+    void _PopBackWindow() {
+        _window_map.pop_back();
+    }
+
+    void _PushBackWindow(SDL_Window *win) {
+        _window_map.push_back(win);
+    }
+
+
+    /* Members */
+    std::vector<SDL_Window*> _window_map; /* Keeps track of SDL_Windows by index-id */
+
+#if SDL_VIDEO_OPENGL
+    BGLView      *_current_context;
+#endif
+};
+
+#endif

src/video/haiku/SDL_bframebuffer.cc

@@ -35,10 +35,6 @@
 extern "C" {
 #endif
 
-#ifndef DRAWTHREAD
-static int32 HAIKU_UpdateOnce(SDL_Window *window);
-#endif
-
 static SDL_INLINE SDL_BWin *_ToBeWin(SDL_Window *window) {
     return ((SDL_BWin*)(window->driverdata));
 }
@@ -56,11 +52,11 @@ int HAIKU_CreateWindowFramebuffer(_THIS, SDL_Window * window,
         return -1;
     }
 
-    while(!bwin->Connected()) { snooze(100); }
-    
     /* Make sure we have exclusive access to frame buffer data */
     bwin->LockBuffer();
 
+    bwin->CreateView();
+
     /* format */
     display_mode bmode;
     bscreen.GetMode(&bmode);
@@ -91,8 +87,6 @@ int HAIKU_CreateWindowFramebuffer(_THIS, SDL_Window * window,
     /* pitch = width of window, in bytes */
     *pitch = bitmap->BytesPerRow();
 
-    bwin->SetBufferExists(true);
-    bwin->SetTrashBuffer(false);
     bwin->UnlockBuffer();
     return 0;
 }
@@ -106,81 +100,11 @@ int HAIKU_UpdateWindowFramebuffer(_THIS, SDL_Window * window,
 
     SDL_BWin *bwin = _ToBeWin(window);
 
-#ifdef DRAWTHREAD    
+    bwin->PostMessage(BWIN_UPDATE_FRAMEBUFFER);
-    bwin->LockBuffer();
-    bwin->SetBufferDirty(true);
-    bwin->UnlockBuffer();
-#else
-    bwin->SetBufferDirty(true);
-    HAIKU_UpdateOnce(window);
-#endif
 
     return 0;
 }
 
-int32 HAIKU_DrawThread(void *data) {
-    SDL_BWin *bwin = (SDL_BWin*)data;
-    
-    BScreen bscreen;
-    if(!bscreen.IsValid()) {
-        return -1;
-    }
-
-    while(bwin->ConnectionEnabled()) {
-        if( bwin->Connected() && bwin->BufferExists() && bwin->BufferIsDirty() ) {
-            bwin->LockBuffer();
-            BBitmap *bitmap = NULL;
-            bitmap = bwin->GetBitmap();
-            int32 windowPitch = bitmap->BytesPerRow();
-            int32 bufferPitch = bwin->GetRowBytes();
-            uint8 *windowpx;
-            uint8 *bufferpx;
-
-            int32 BPP = bwin->GetBytesPerPx();
-            int32 windowSub = bwin->GetFbX() * BPP +
-                          bwin->GetFbY() * windowPitch;
-            clipping_rect *clips = bwin->GetClips();
-            int32 numClips = bwin->GetNumClips();
-            int i, y;
-
-            /* Blit each clipping rectangle */
-            bscreen.WaitForRetrace();
-            for(i = 0; i < numClips; ++i) {
-                /* Get addresses of the start of each clipping rectangle */
-                int32 width = clips[i].right - clips[i].left + 1;
-                int32 height = clips[i].bottom - clips[i].top + 1;
-                bufferpx = bwin->GetBufferPx() + 
-                    clips[i].top * bufferPitch + clips[i].left * BPP;
-                windowpx = (uint8*)bitmap->Bits() + 
-                    clips[i].top * windowPitch + clips[i].left * BPP -
-                    windowSub;
-
-                /* Copy each row of pixels from the window buffer into the frame
-                   buffer */
-                for(y = 0; y < height; ++y)
-                {
-
-                    if(bwin->CanTrashWindowBuffer()) {
-                        goto escape;    /* Break out before the buffer is killed */
-                    }
-
-                    memcpy(bufferpx, windowpx, width * BPP);
-                    bufferpx += bufferPitch;
-                    windowpx += windowPitch;
-                }
-            }
-
-            bwin->SetBufferDirty(false);
-escape:
-            bwin->UnlockBuffer();
-        } else {
-            snooze(16000);
-        }
-    }
-    
-    return B_OK;
-}
-
 void HAIKU_DestroyWindowFramebuffer(_THIS, SDL_Window * window) {
     SDL_BWin *bwin = _ToBeWin(window);
 
@@ -190,66 +114,12 @@ void HAIKU_DestroyWindowFramebuffer(_THIS, SDL_Window * window) {
     BBitmap *bitmap = bwin->GetBitmap();
     delete bitmap;
     bwin->SetBitmap(NULL);
-    bwin->SetBufferExists(false);
+
+    bwin->RemoveView();
+
     bwin->UnlockBuffer();
 }
 
-
-/*
- * TODO:
- * This was written to test if certain errors were caused by threading issues.
- * The specific issues have since become rare enough that they may have been
- * solved, but I doubt it- they were pretty sporadic before now.
- */
-#ifndef DRAWTHREAD
-static int32 HAIKU_UpdateOnce(SDL_Window *window) {
-    SDL_BWin *bwin = _ToBeWin(window);
-    BScreen bscreen;
-    if(!bscreen.IsValid()) {
-        return -1;
-    }
-
-    if(bwin->ConnectionEnabled() && bwin->Connected()) {
-        bwin->LockBuffer();
-        int32 windowPitch = window->surface->pitch;
-        int32 bufferPitch = bwin->GetRowBytes();
-        uint8 *windowpx;
-        uint8 *bufferpx;
-
-        int32 BPP = bwin->GetBytesPerPx();
-        uint8 *windowBaseAddress = (uint8*)window->surface->pixels;
-        int32 windowSub = bwin->GetFbX() * BPP +
-                          bwin->GetFbY() * windowPitch;
-        clipping_rect *clips = bwin->GetClips();
-        int32 numClips = bwin->GetNumClips();
-        int i, y;
-
-        /* Blit each clipping rectangle */
-        bscreen.WaitForRetrace();
-        for(i = 0; i < numClips; ++i) {
-            /* Get addresses of the start of each clipping rectangle */
-            int32 width = clips[i].right - clips[i].left + 1;
-            int32 height = clips[i].bottom - clips[i].top + 1;
-            bufferpx = bwin->GetBufferPx() + 
-                clips[i].top * bufferPitch + clips[i].left * BPP;
-            windowpx = windowBaseAddress + 
-                clips[i].top * windowPitch + clips[i].left * BPP - windowSub;
-
-            /* Copy each row of pixels from the window buffer into the frame
-               buffer */
-            for(y = 0; y < height; ++y)
-            {
-                memcpy(bufferpx, windowpx, width * BPP);
-                bufferpx += bufferPitch;
-                windowpx += windowPitch;
-            }
-        }
-        bwin->UnlockBuffer();
-    }
-    return 0;
-}
-#endif
-
 #ifdef __cplusplus
 }
 #endif

src/video/haiku/SDL_bopengl.cc

@@ -84,16 +84,21 @@ void *HAIKU_GL_GetProcAddress(_THIS, const char *proc)
 }
 
 
-
-
 int HAIKU_GL_SwapWindow(_THIS, SDL_Window * window) {
     _ToBeWin(window)->SwapBuffers();
     return 0;
 }
 
 int HAIKU_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context) {
-    SDL_BWin* win = (SDL_BWin*)context;
+    BGLView* glView = (BGLView*)context;
-    _GetBeApp()->SetCurrentContext(win ? win->GetGLView() : NULL);
+    // printf("HAIKU_GL_MakeCurrent(%llx), win = %llx, thread = %d\n", (uint64)context, (uint64)window, find_thread(NULL));
+    if (glView != NULL) {
+        if ((glView->Window() == NULL) || (window == NULL) || (_ToBeWin(window)->GetGLView() != glView)) {
+            SDL_SetError("MakeCurrent failed");
+            return -1;
+        }
+    }
+    _GetBeApp()->SetCurrentContext(glView);
     return 0;
 }
 
@@ -102,6 +107,11 @@ SDL_GLContext HAIKU_GL_CreateContext(_THIS, SDL_Window * window) {
     /* FIXME: Not sure what flags should be included here; may want to have
        most of them */
     SDL_BWin *bwin = _ToBeWin(window);
+    // printf("HAIKU_GL_CreateContext, win = %llx, thread = %d\n", (uint64)window, find_thread(NULL));
+    if (bwin->GetGLView() != NULL) {
+        SDL_SetError("Context already creaded");
+        return NULL;
+    }
     Uint32 gl_flags = BGL_RGB;
     if (_this->gl_config.alpha_size) {
         gl_flags |= BGL_ALPHA;
@@ -123,13 +133,25 @@ SDL_GLContext HAIKU_GL_CreateContext(_THIS, SDL_Window * window) {
             _this->gl_config.accum_alpha_size) {
         gl_flags |= BGL_ACCUM;
     }
+#if __GNUC__ > 3
+    if (_this->gl_config.share_with_current_context) {
+        gl_flags |= BGL_SHARE_CONTEXT;
+    }
+#endif
     bwin->CreateGLView(gl_flags);
-    return (SDL_GLContext)(bwin);
+    _GetBeApp()->SetCurrentContext(bwin->GetGLView());
+    return (SDL_GLContext)(bwin->GetGLView());
 }
 
 void HAIKU_GL_DeleteContext(_THIS, SDL_GLContext context) {
-    /* Currently, automatically unlocks the view */
+    // printf("HAIKU_GL_DeleteContext(%llx), thread = %d\n", (uint64)context, find_thread(NULL));
-    ((SDL_BWin*)context)->RemoveGLView();
+    BGLView* glView = (BGLView*)context;
+    SDL_BWin *bwin = (SDL_BWin*)glView->Window();
+    if (bwin == NULL) {
+        delete glView;
+    } else {
+        bwin->RemoveGLView();
+    }
 }
 
 

src/video/haiku/SDL_bvideo.cc

@@ -94,6 +94,7 @@ HAIKU_CreateDevice(int devindex)
     device->SetWindowGammaRamp = HAIKU_SetWindowGammaRamp;
     device->GetWindowGammaRamp = HAIKU_GetWindowGammaRamp;
     device->SetWindowMouseGrab = HAIKU_SetWindowMouseGrab;
+    device->SetWindowMinimumSize = HAIKU_SetWindowMinimumSize;
     device->DestroyWindow = HAIKU_DestroyWindow;
     device->GetWindowWMInfo = HAIKU_GetWindowWMInfo;
     device->CreateWindowFramebuffer = HAIKU_CreateWindowFramebuffer;
@@ -190,6 +191,31 @@ HAIKU_FreeCursor(SDL_Cursor * cursor)
     SDL_free(cursor);
 }
 
+static SDL_Cursor *
+HAIKU_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
+{
+    SDL_Cursor *cursor;
+    SDL_Surface *converted;
+
+    converted = SDL_ConvertSurfaceFormat(surface, SDL_PIXELFORMAT_ARGB8888, 0);
+    if (!converted) {
+        return NULL;
+    }
+
+	BBitmap *cursorBitmap = new BBitmap(BRect(0, 0, surface->w - 1, surface->h - 1), B_RGBA32);
+	cursorBitmap->SetBits(converted->pixels, converted->h * converted->pitch, 0, B_RGBA32);
+    SDL_FreeSurface(converted);
+
+    cursor = (SDL_Cursor *) SDL_calloc(1, sizeof(*cursor));
+    if (cursor) {
+        cursor->driverdata = (void *)new BCursor(cursorBitmap, BPoint(hot_x, hot_y));
+    } else {
+        return NULL;
+    }
+
+    return cursor;
+}
+
 static int HAIKU_ShowCursor(SDL_Cursor *cursor)
 {
 	SDL_Mouse *mouse = SDL_GetMouse();
@@ -222,7 +248,7 @@ HAIKU_SetRelativeMouseMode(SDL_bool enabled)
 
 	bewin->Lock();
 	if (enabled)
-		_SDL_GLView->SetEventMask(B_POINTER_EVENTS | B_KEYBOARD_EVENTS, B_NO_POINTER_HISTORY);
+		_SDL_GLView->SetEventMask(B_POINTER_EVENTS, B_NO_POINTER_HISTORY);
 	else
 		_SDL_GLView->SetEventMask(0, 0);
 	bewin->Unlock();
@@ -235,6 +261,7 @@ static void HAIKU_MouseInit(_THIS)
 	SDL_Mouse *mouse = SDL_GetMouse();
 	if (!mouse)
 		return;
+	mouse->CreateCursor = HAIKU_CreateCursor;
 	mouse->CreateSystemCursor = HAIKU_CreateSystemCursor;
 	mouse->ShowCursor = HAIKU_ShowCursor;
 	mouse->FreeCursor = HAIKU_FreeCursor;

src/video/haiku/SDL_bwindow.cc

@@ -205,6 +205,13 @@ int HAIKU_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp) {
 }
 
 
+void HAIKU_SetWindowMinimumSize(_THIS, SDL_Window * window){
+    BMessage msg(BWIN_MINIMUM_SIZE_WINDOW);
+    msg.AddInt32("window-w", window->w -1);
+    msg.AddInt32("window-h", window->h -1);
+    _ToBeWin(window)->PostMessage(&msg);
+}
+
 void HAIKU_SetWindowMouseGrab(_THIS, SDL_Window * window, SDL_bool grabbed) {
     /* TODO: Implement this! */
 }

src/video/haiku/SDL_bwindow.h

@@ -32,6 +32,7 @@ extern void HAIKU_SetWindowTitle(_THIS, SDL_Window * window);
 extern void HAIKU_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon);
 extern void HAIKU_SetWindowPosition(_THIS, SDL_Window * window);
 extern void HAIKU_SetWindowSize(_THIS, SDL_Window * window);
+extern void HAIKU_SetWindowMinimumSize(_THIS, SDL_Window * window);
 extern void HAIKU_ShowWindow(_THIS, SDL_Window * window);
 extern void HAIKU_HideWindow(_THIS, SDL_Window * window);
 extern void HAIKU_RaiseWindow(_THIS, SDL_Window * window);