Add support for _MOUSEWHEEL and _MOUSEMOVEMENTx on macOS

Makefile

@@ -155,7 +155,7 @@ ifeq ($(OS),win)
 endif
 
 ifeq ($(OS),osx)
-	CXXLIBS += -framework OpenGL -framework IOKit -framework GLUT -framework Cocoa
+	CXXLIBS += -framework OpenGL -framework IOKit -framework GLUT -framework Cocoa -framework ApplicationServices
 
 	# OSX doesn't strip using objcopy, so we're using `-s` instead
 	ifneq ($(STRIP_SYMBOLS),n)

internal/c/libqb.cpp

@@ -15,15 +15,15 @@
 #include "audio.h"
 #include "bitops.h"
 #include "cmem.h"
-#include "completion.h"
 #include "command.h"
+#include "completion.h"
 #include "compression.h"
 #include "datetime.h"
-#include "event.h"
 #include "error_handle.h"
+#include "event.h"
+#include "file-fields.h"
 #include "filepath.h"
 #include "filesystem.h"
-#include "file-fields.h"
 #include "font.h"
 #include "game_controller.h"
 #include "gfs.h"
@@ -32,9 +32,10 @@
 #include "http.h"
 #include "image.h"
 #include "keyhandler.h"
-#include "qblist.h"
+#include "mac-mouse-support.h"
 #include "mem.h"
 #include "mutex.h"
+#include "qblist.h"
 #include "qbs.h"
 #include "rounding.h"
 #include "shell.h"
@@ -29587,6 +29588,10 @@ void GLUT_MOTION_FUNC(int x, int y) {
     int32 i, last_i;
     int32 handle;
     int32 xrel, yrel;
+
+    // This is used to save the last mouse position which is then paired with the mouse wheel event on macOS
+    macMouseUpdatePosition(x, y);
+
     handle = mouse_message_queue_first;
     mouse_message_queue_struct *queue = (mouse_message_queue_struct *)list_get(mouse_message_queue_handles, handle);
 
@@ -29601,12 +29606,14 @@ void GLUT_MOTION_FUNC(int x, int y) {
             nextIndex = 0;
         queue->current = nextIndex;
     }
-#    ifdef QB64_WINDOWS
+
+#    if defined(QB64_WINDOWS) || defined(QB64_MACOSX)
     // Windows calculates relative movement by intercepting WM_INPUT events
-    // instead
+    // macOS uses the Quartz Event Services to get relative movements
     xrel = 0;
     yrel = 0;
 #    else
+    // TODO: This needs to be correctly implemented on Linux
     xrel = x - queue->queue[queue->last].x;
     yrel = y - queue->queue[queue->last].y;
 #    endif
@@ -29694,7 +29701,7 @@ void GLUT_MOTION_FUNC(int x, int y) {
 void GLUT_PASSIVEMOTION_FUNC(int x, int y) { GLUT_MOTION_FUNC(x, y); }
 
 void GLUT_MOUSEWHEEL_FUNC(int wheel, int direction, int x, int y) {
-#    ifdef QB64_GLUT
+#ifdef QB64_GLUT
     // Note: freeglut specific, limited documentation existed so the following
     // research was done:
     //  qbs_print(qbs_str(wheel),NULL); <-- was always 0 [could 1 indicate
@@ -29709,7 +29716,7 @@ void GLUT_MOUSEWHEEL_FUNC(int wheel, int direction, int x, int y) {
         GLUT_MouseButton_Down(5, x, y);
         GLUT_MouseButton_Up(5, x, y);
     }
-#    endif
+#endif
 }
 
 #endif
@@ -32409,67 +32416,71 @@ extern "C" void qb64_os_event_linux(XEvent *event, Display *display, int *qb64_o
 }
 #endif
 
+void qb64_custom_event_relative_mouse_movement(int deltaX, int deltaY) {
+    int32_t handle = mouse_message_queue_first;
+    mouse_message_queue_struct *queue = (mouse_message_queue_struct *)list_get(mouse_message_queue_handles, handle);
+    // message #1
+    int32_t i = queue->last + 1;
+    if (i > queue->lastIndex)
+        i = 0;
+    if (i == queue->current) {
+        int32_t nextIndex = queue->last + 1;
+        if (nextIndex > queue->lastIndex)
+            nextIndex = 0;
+        queue->current = nextIndex;
+    }
+    queue->queue[i].x = queue->queue[queue->last].x;
+    queue->queue[i].y = queue->queue[queue->last].y;
+    queue->queue[i].movementx = deltaX;
+    queue->queue[i].movementy = deltaY;
+    queue->queue[i].buttons = queue->queue[queue->last].buttons;
+    queue->last = i;
+    // message #2 (clears movement values to avoid confusion)
+    i = queue->last + 1;
+    if (i > queue->lastIndex)
+        i = 0;
+    if (i == queue->current) {
+        int32_t nextIndex = queue->last + 1;
+        if (nextIndex > queue->lastIndex)
+            nextIndex = 0;
+        queue->current = nextIndex;
+    }
+    queue->queue[i].x = queue->queue[queue->last].x;
+    queue->queue[i].y = queue->queue[queue->last].y;
+    queue->queue[i].movementx = 0;
+    queue->queue[i].movementy = 0;
+    queue->queue[i].buttons = queue->queue[queue->last].buttons;
+    queue->last = i;
+}
+
 extern "C" int qb64_custom_event(int event, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, void *p1, void *p2) {
     if (event == QB64_EVENT_CLOSE) {
         exit_value |= 1;
-        return NULL;
+        return 0;
     } // close
+
     if (event == QB64_EVENT_KEY) {
         if (v1 == VK + QBVK_PAUSE) {
             if (v2 > 0)
                 keydown_vk(v1);
             else
                 keyup_vk(v1);
-            return NULL;
+            return 0;
         }
         if (v1 == VK + QBVK_BREAK) {
             if (v2 > 0)
                 keydown_vk(v1);
             else
                 keyup_vk(v1);
-            return NULL;
+            return 0;
         }
         return -1;
     } // key
 
-    if (event == QB64_EVENT_RELATIVE_MOUSE_MOVEMENT) { // qb64_custom_event(QB64_EVENT_RELATIVE_MOUSE_MOVEMENT,xPosRelative,yPosRelative,0,0,0,0,0,0,NULL,NULL);
-        static int32 i;
-        int32 handle;
-        handle = mouse_message_queue_first;
-        mouse_message_queue_struct *queue = (mouse_message_queue_struct *)list_get(mouse_message_queue_handles, handle);
-        // message #1
-        i = queue->last + 1;
-        if (i > queue->lastIndex)
-            i = 0;
-        if (i == queue->current) {
-            int32 nextIndex = queue->last + 1;
-            if (nextIndex > queue->lastIndex)
-                nextIndex = 0;
-            queue->current = nextIndex;
-        }
-        queue->queue[i].x = queue->queue[queue->last].x;
-        queue->queue[i].y = queue->queue[queue->last].y;
-        queue->queue[i].movementx = v1;
-        queue->queue[i].movementy = v2;
-        queue->queue[i].buttons = queue->queue[queue->last].buttons;
-        queue->last = i;
-        // message #2 (clears movement values to avoid confusion)
-        i = queue->last + 1;
-        if (i > queue->lastIndex)
-            i = 0;
-        if (i == queue->current) {
-            int32 nextIndex = queue->last + 1;
-            if (nextIndex > queue->lastIndex)
-                nextIndex = 0;
-            queue->current = nextIndex;
-        }
-        queue->queue[i].x = queue->queue[queue->last].x;
-        queue->queue[i].y = queue->queue[queue->last].y;
-        queue->queue[i].movementx = 0;
-        queue->queue[i].movementy = 0;
-        queue->queue[i].buttons = queue->queue[queue->last].buttons;
-        queue->last = i;
-        return NULL;
+    // qb64_custom_event(QB64_EVENT_RELATIVE_MOUSE_MOVEMENT,xPosRelative,yPosRelative,0,0,0,0,0,0,NULL,NULL);
+    if (event == QB64_EVENT_RELATIVE_MOUSE_MOVEMENT) {
+        qb64_custom_event_relative_mouse_movement(v1, v2);
+        return 0;
     } // QB64_EVENT_RELATIVE_MOUSE_MOVEMENT
 
     if (event == QB64_EVENT_FILE_DROP) {
@@ -32480,11 +32491,11 @@ extern "C" int qb64_custom_event(int event, int v1, int v2, int v3, int v4, int
         hdrop = (HDROP)p1;
         totalDroppedFiles = DragQueryFile(hdrop, -1, NULL, 0);
 #endif
-        return NULL;
+        return 0;
     }
 
     return -1; // Unknown command (use for debugging purposes only)
-} // qb64_custom_event
+}
 
 int32 func__capslock() {
 #ifdef QB64_WINDOWS

internal/c/libqb/build.mk

@@ -34,7 +34,7 @@ libqb-objs-y$(DEP_CONSOLE_ONLY) += $(PATH_LIBQB)/src/glut-msg-queue.o
 libqb-objs-$(DEP_CONSOLE_ONLY) += $(PATH_LIBQB)/src/console-only-main-thread.o
 
 ifeq ($(OS),osx)
-libqb-objs-y$(DEP_CONSOLE_ONLY) += $(PATH_LIBQB)/src/mac-key-monitor.o
+libqb-objs-y$(DEP_CONSOLE_ONLY) += $(PATH_LIBQB)/src/mac-key-monitor.o $(PATH_LIBQB)/src/mac-mouse-support.o
 endif
 
 $(PATH_LIBQB)/src/%.o: $(PATH_LIBQB)/src/%.cpp

internal/c/libqb/include/mac-mouse-support.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#ifdef QB64_MACOSX
+void macMouseInit();
+void macMouseDone();
+void macMouseUpdatePosition(int x, int y);
+#else
+static inline void macMouseInit() {}
+static inline void macMouseDone() {}
+static inline void macMouseUpdatePosition(int x, int y) {}
+#endif

internal/c/libqb/src/glut-main-thread.cpp

@@ -1,14 +1,14 @@
 
 #include "libqb-common.h"
 
-#include <string.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <unistd.h>
+#include <GL/glew.h>
 #include <list>
 #include <queue>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
 #include <unordered_map>
-#include "GL/glew.h"
 
 // note: MacOSX uses Apple's GLUT not FreeGLUT
 #ifdef QB64_MACOSX
@@ -18,12 +18,13 @@
 #    include <GL/freeglut.h>
 #endif
 
-#include "mutex.h"
-#include "thread.h"
 #include "completion.h"
+#include "glut-thread.h"
 #include "gui.h"
 #include "mac-key-monitor.h"
-#include "glut-thread.h"
+#include "mac-mouse-support.h"
+#include "mutex.h"
+#include "thread.h"
 
 // FIXME: These extern variable and function definitions should probably go
 // somewhere more global so that they can be referenced by libqb.cpp
@@ -58,20 +59,20 @@ static void glutWarning(const char *fmt, va_list lst) {
 
 // Performs all of the FreeGLUT initialization except for calling glutMainLoop()
 static void initialize_glut(int argc, char **argv) {
-#    ifdef CORE_FREEGLUT
+#ifdef CORE_FREEGLUT
     glutInitWarningFunc(glutWarning);
     glutInitErrorFunc(glutWarning);
-#    endif
+#endif
 
     glutInit(&argc, argv);
 
     mac_register_key_handler();
 
-#    ifdef QB64_WINDOWS
+#ifdef QB64_WINDOWS
     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
-#    else
+#else
     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
-#    endif
+#endif
 
     glutInitWindowSize(640, 400); // cannot be changed unless display_x(etc) are modified
 
@@ -96,11 +97,11 @@ static void initialize_glut(int argc, char **argv) {
 
     glutDisplayFunc(GLUT_DISPLAY_REQUEST);
 
-#    ifdef QB64_WINDOWS
+#ifdef QB64_WINDOWS
     glutTimerFunc(8, GLUT_TIMER_EVENT, 0);
-#    else
+#else
     glutIdleFunc(GLUT_IDLEFUNC);
-#    endif
+#endif
 
     glutKeyboardFunc(GLUT_KEYBOARD_FUNC);
     glutKeyboardUpFunc(GLUT_KEYBOARDUP_FUNC);
@@ -111,9 +112,11 @@ static void initialize_glut(int argc, char **argv) {
     glutPassiveMotionFunc(GLUT_PASSIVEMOTION_FUNC);
     glutReshapeFunc(GLUT_RESHAPE_FUNC);
 
-#    ifdef CORE_FREEGLUT
+#ifdef CORE_FREEGLUT
     glutMouseWheelFunc(GLUT_MOUSEWHEEL_FUNC);
-#    endif
+#endif
+
+    macMouseInit();
 }
 
 static bool glut_is_started;
@@ -136,9 +139,7 @@ void libqb_start_glut_thread() {
 }
 
 // Checks whether the GLUT thread is running
-bool libqb_is_glut_up() {
-    return glut_is_started;
-}
+bool libqb_is_glut_up() { return glut_is_started; }
 
 void libqb_glut_presetup(int argc, char **argv) {
     if (!screen_hide) {
@@ -178,8 +179,7 @@ void libqb_start_main_thread(int argc, char **argv) {
 // from two threads at the same time).
 //
 // This is accomplished by simply queuing a GLUT message that calls exit() for us.
-void libqb_exit(int exitcode)
-{
+void libqb_exit(int exitcode) {
     // If GLUT isn't running then we're free to do the exit() call from here
     if (!libqb_is_glut_up())
         exit(exitcode);

internal/c/libqb/src/glut-message.cpp

@@ -15,6 +15,7 @@
 #endif
 
 #include "glut-message.h"
+#include "mac-mouse-support.h"
 
 void glut_message_set_cursor::execute() {
     glutSetCursor(style);
@@ -49,6 +50,6 @@ void glut_message_set_window_title::execute() {
 }
 
 void glut_message_exit_program::execute() {
+    macMouseDone();
     exit(exitCode);
 }
-