Merge a284523f9e into 63a7e8b7f8

Fixes #2746

CONTRIBUTORS.md

@@ -55,6 +55,7 @@ video tutorials.
  - Jason Daly
  - danhambleton
  - Jarrod Davis
+ - decce
  - Olivier Delannoy
  - Paul R. Deppe
  - Michael Dickens

docs/monitor.md

@@ -255,3 +255,7 @@ hardware gamma correction, which today is typically an approximation of sRGB
 gamma.  This means that setting a perfectly linear ramp, or gamma 1.0, will
 produce the default (usually sRGB-like) behavior.
 
+@note @wayland An application cannot read or modify the monitor gamma ramp.  The
+@ref glfwGetGammaRamp, @ref glfwSetGammaRamp and @ref glfwSetGamma functions
+emit @ref GLFW_FEATURE_UNAVAILABLE.
+

docs/window.md

@@ -893,6 +893,12 @@ int xpos, ypos;
 glfwGetWindowPos(window, &xpos, &ypos);
 ```
 
+@note @wayland An applications cannot know the positions of its windows or
+whether one has been moved.  The @ref GLFW_POSITION_X and @ref GLFW_POSITION_Y
+window hints are ignored.  The @ref glfwGetWindowPos and @ref glfwSetWindowPos
+functions emit @ref GLFW_FEATURE_UNAVAILABLE.  The window position callback will
+not be called.
+
 
 ### Window title {#window_title}
 
@@ -1038,6 +1044,12 @@ You can also get the current iconification state with @ref glfwGetWindowAttrib.
 int iconified = glfwGetWindowAttrib(window, GLFW_ICONIFIED);
 ```
 
+@note @wayland An application cannot know if any of its windows have been
+iconified or restore one from iconification.  The @ref glfwRestoreWindow
+function can only restore windows from maximization and the iconify callback
+will not be called.  The [GLFW_ICONIFIED](@ref GLFW_ICONIFIED_attrib) attribute
+will be false.  The @ref glfwIconifyWindow function works normally.
+
 
 ### Window maximization {#window_maximize}
 

include/GLFW/glfw3.h

@@ -2915,8 +2915,8 @@ GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* monitor);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref GLFW_INVALID_VALUE,
  *  @ref GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
  *
- *  @remark @wayland Gamma handling is a privileged protocol, this function
+ *  @remark @wayland Monitor gamma is a privileged protocol, so this function
- *  will thus never be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE.
+ *  cannot be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE.
  *
  *  @thread_safety This function must only be called from the main thread.
  *
@@ -2939,8 +2939,8 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* monitor, float gamma);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref GLFW_PLATFORM_ERROR
  *  and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
  *
- *  @remark @wayland Gamma handling is a privileged protocol, this function
+ *  @remark @wayland Monitor gamma is a privileged protocol, so this function
- *  will thus never be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE while
+ *  cannot be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE while
  *  returning `NULL`.
  *
  *  @pointer_lifetime The returned structure and its arrays are allocated and
@@ -2983,8 +2983,8 @@ GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* monitor);
  *
  *  @remark @win32 The gamma ramp size must be 256.
  *
- *  @remark @wayland Gamma handling is a privileged protocol, this function
+ *  @remark @wayland Monitor gamma is a privileged protocol, so this function
- *  will thus never be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE.
+ *  cannot be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE.
  *
  *  @pointer_lifetime The specified gamma ramp is copied before this function
  *  returns.
@@ -3430,8 +3430,8 @@ GLFWAPI void glfwSetWindowIcon(GLFWwindow* window, int count, const GLFWimage* i
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
  *
- *  @remark @wayland There is no way for an application to retrieve the global
+ *  @remark @wayland Window positions are not currently part of any common
- *  position of its windows.  This function will emit @ref
+ *  Wayland protocol, so this function cannot be implemented and will emit @ref
  *  GLFW_FEATURE_UNAVAILABLE.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -3464,8 +3464,8 @@ GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
  *
- *  @remark @wayland There is no way for an application to set the global
+ *  @remark @wayland Window positions are not currently part of any common
- *  position of its windows.  This function will emit @ref
+ *  Wayland protocol, so this function cannot be implemented and will emit @ref
  *  GLFW_FEATURE_UNAVAILABLE.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -3807,10 +3807,6 @@ GLFWAPI void glfwSetWindowOpacity(GLFWwindow* window, float opacity);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
- *  @remark @wayland Once a window is iconified, @ref glfwRestoreWindow won’t
- *  be able to restore it.  This is a design decision of the xdg-shell
- *  protocol.
- *
  *  @thread_safety This function must only be called from the main thread.
  *
  *  @sa @ref window_iconify
@@ -3838,6 +3834,10 @@ GLFWAPI void glfwIconifyWindow(GLFWwindow* window);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
+ *  @remark @wayland Restoring a window from maximization is not currently part
+ *  of any common Wayland protocol, so this function can only restore windows
+ *  from maximization.
+ *
  *  @thread_safety This function must only be called from the main thread.
  *
  *  @sa @ref window_iconify
@@ -4058,8 +4058,8 @@ GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window);
  *  affected by any resizing or mode switching, although you may need to update
  *  your viewport if the framebuffer size has changed.
  *
- *  @remark @wayland The desired window position is ignored, as there is no way
+ *  @remark @wayland Window positions are not currently part of any common
- *  for an application to set this property.
+ *  Wayland protocol.  The window position arguments are ignored.
  *
  *  @thread_safety This function must only be called from the main thread.
  *
@@ -4096,8 +4096,9 @@ GLFWAPI void glfwSetWindowMonitor(GLFWwindow* window, GLFWmonitor* monitor, int
  *  errors.  However, this function should not fail as long as it is passed
  *  valid arguments and the library has been [initialized](@ref intro_init).
  *
- *  @remark @wayland The Wayland protocol provides no way to check whether a
+ *  @remark @wayland Checking whether a window is iconified is not currently
- *  window is iconfied, so @ref GLFW_ICONIFIED always returns `GLFW_FALSE`.
+ *  part of any common Wayland protocol, so the @ref GLFW_ICONIFIED attribute
+ *  cannot be implemented and is always `GLFW_FALSE`.
  *
  *  @thread_safety This function must only be called from the main thread.
  *
@@ -4219,8 +4220,8 @@ GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* window);
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
  *
- *  @remark @wayland This callback will never be called, as there is no way for
+ *  @remark @wayland This callback will not be called.  The Wayland protocol
- *  an application to know its global position.
+ *  provides no way to be notified of when a window is moved.
  *
  *  @thread_safety This function must only be called from the main thread.
  *
@@ -4395,6 +4396,10 @@ GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwi
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
  *
+ *  @remark @wayland This callback will not be called.  The Wayland protocol
+ *  provides no way to be notified of when a window is iconified, and no way to
+ *  check whether a window is currently iconified.
+ *
  *  @thread_safety This function must only be called from the main thread.
  *
  *  @sa @ref window_iconify

src/win32_window.c

@@ -35,6 +35,19 @@
 #include <assert.h>
 #include <windowsx.h>
 #include <shellapi.h>
+#include <BaseTsd.h>
+#include <stdio.h>
+
+
+#ifdef _WIN64
+typedef UINT64 QWORD; // Needed for NEXTRAWINPUTBLOCK()
+#endif
+
+#ifndef RI_MOUSE_HWHEEL
+// MinGW may not have the define for RI_MOUSE_HWHEEL
+#define RI_MOUSE_HWHEEL 0x0800
+#endif
+
 
 // Returns the window style for the specified window
 //
@@ -265,7 +278,7 @@ static void releaseCursor(void)
 //
 static void enableRawMouseMotion(_GLFWwindow* window)
 {
-    const RAWINPUTDEVICE rid = { 0x01, 0x02, 0, window->win32.handle };
+    const RAWINPUTDEVICE rid = { 0x01, 0x02, RIDEV_NOLEGACY, window->win32.handle };
 
     if (!RegisterRawInputDevices(&rid, 1, sizeof(rid)))
     {
@@ -894,77 +907,6 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM l
             return 0;
         }
 
-        case WM_INPUT:
-        {
-            UINT size = 0;
-            HRAWINPUT ri = (HRAWINPUT) lParam;
-            RAWINPUT* data = NULL;
-            int dx, dy;
-
-            if (_glfw.win32.disabledCursorWindow != window)
-                break;
-            if (!window->rawMouseMotion)
-                break;
-
-            GetRawInputData(ri, RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER));
-            if (size > (UINT) _glfw.win32.rawInputSize)
-            {
-                _glfw_free(_glfw.win32.rawInput);
-                _glfw.win32.rawInput = _glfw_calloc(size, 1);
-                _glfw.win32.rawInputSize = size;
-            }
-
-            size = _glfw.win32.rawInputSize;
-            if (GetRawInputData(ri, RID_INPUT,
-                                _glfw.win32.rawInput, &size,
-                                sizeof(RAWINPUTHEADER)) == (UINT) -1)
-            {
-                _glfwInputError(GLFW_PLATFORM_ERROR,
-                                "Win32: Failed to retrieve raw input data");
-                break;
-            }
-
-            data = _glfw.win32.rawInput;
-            if (data->data.mouse.usFlags & MOUSE_MOVE_ABSOLUTE)
-            {
-                POINT pos = {0};
-                int width, height;
-
-                if (data->data.mouse.usFlags & MOUSE_VIRTUAL_DESKTOP)
-                {
-                    pos.x += GetSystemMetrics(SM_XVIRTUALSCREEN);
-                    pos.y += GetSystemMetrics(SM_YVIRTUALSCREEN);
-                    width = GetSystemMetrics(SM_CXVIRTUALSCREEN);
-                    height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
-                }
-                else
-                {
-                    width = GetSystemMetrics(SM_CXSCREEN);
-                    height = GetSystemMetrics(SM_CYSCREEN);
-                }
-
-                pos.x += (int) ((data->data.mouse.lLastX / 65535.f) * width);
-                pos.y += (int) ((data->data.mouse.lLastY / 65535.f) * height);
-                ScreenToClient(window->win32.handle, &pos);
-
-                dx = pos.x - window->win32.lastCursorPosX;
-                dy = pos.y - window->win32.lastCursorPosY;
-            }
-            else
-            {
-                dx = data->data.mouse.lLastX;
-                dy = data->data.mouse.lLastY;
-            }
-
-            _glfwInputCursorPos(window,
-                                window->virtualCursorPosX + dx,
-                                window->virtualCursorPosY + dy);
-
-            window->win32.lastCursorPosX += dx;
-            window->win32.lastCursorPosY += dy;
-            break;
-        }
-
         case WM_MOUSELEAVE:
         {
             window->win32.cursorTracked = GLFW_FALSE;
@@ -2086,11 +2028,215 @@ GLFWbool _glfwRawMouseMotionSupportedWin32(void)
     return GLFW_TRUE;
 }
 
+
+void _processRawInput(void)
+{
+    UINT size = 0;
+    UINT riSize = 0;
+    _GLFWwindow* window = _glfw.windowListHead;
+
+    if (_glfw.win32.disabledCursorWindow != window)
+        return;
+    if (!window->rawMouseMotion)
+        return;
+
+    // get the size of the raw input buffer
+    UINT result = GetRawInputBuffer(NULL, &riSize, sizeof(RAWINPUTHEADER));
+    if (result == (UINT)-1)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to retrieve raw input buffer size");
+        return;
+    }
+
+    UINT byteCount = riSize * 16;
+
+    if (byteCount > (UINT)_glfw.win32.rawInputSize)
+    {
+        _glfw_free(_glfw.win32.rawInput);
+        _glfw.win32.rawInput = _glfw_calloc(byteCount, 1);
+        _glfw.win32.rawInputSize = byteCount;
+    }
+
+    // read it (actually) this time into the buffer
+    size = _glfw.win32.rawInputSize;
+    result = GetRawInputBuffer(_glfw.win32.rawInput, &size, sizeof(RAWINPUTHEADER));
+    if (result == (UINT)-1)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to retrieve raw input buffer");
+        _glfw_free(_glfw.win32.rawInput);
+        return;
+    }
+
+    // print msg count
+    //printf("raw input count: %u\n", result);
+
+    UINT riCount = result;
+
+    RAWINPUT* data = _glfw.win32.rawInput;
+
+    for (unsigned int i = 0; i < riCount; ++i)
+    {
+        if (data->header.dwType == RIM_TYPEMOUSE) {
+            int dx = 0, dy = 0;
+            
+            if (data->data.mouse.usFlags & MOUSE_MOVE_ABSOLUTE)
+            {
+                POINT pos = {0};
+                int width, height;
+
+                if (data->data.mouse.usFlags & MOUSE_VIRTUAL_DESKTOP)
+                {
+                    pos.x += GetSystemMetrics(SM_XVIRTUALSCREEN);
+                    pos.y += GetSystemMetrics(SM_YVIRTUALSCREEN);
+                    width = GetSystemMetrics(SM_CXVIRTUALSCREEN);
+                    height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
+                }
+                else
+                {
+                    width = GetSystemMetrics(SM_CXSCREEN);
+                    height = GetSystemMetrics(SM_CYSCREEN);
+                }
+
+                pos.x += (int)((data->data.mouse.lLastX / 65535.f) * width);
+                pos.y += (int)((data->data.mouse.lLastY / 65535.f) * height);
+                ScreenToClient(window->win32.handle, &pos);
+
+                dx = pos.x - window->win32.lastCursorPosX;
+                dy = pos.y - window->win32.lastCursorPosY;
+            }
+            else
+            {
+                if (data->data.mouse.lLastX || data->data.mouse.lLastY)
+                {
+                    dx = data->data.mouse.lLastX;
+                    dy = data->data.mouse.lLastY;
+                }
+            }
+
+            if (dx != 0 || dy != 0)
+            {
+                _glfwInputCursorPos(window,
+                                    window->virtualCursorPosX + dx,
+                                    window->virtualCursorPosY + dy);
+
+                window->win32.lastCursorPosX += dx;
+                window->win32.lastCursorPosY += dy;
+            }
+
+            // Instead of reposting the events, we duplicate the button events' handlers here.
+
+            
+            USHORT buttonFlags = data->data.mouse.usButtonFlags;
+            HWND hwnd = window->win32.handle;
+
+            // if any down or up button (anything except RI_MOUSE_WHEEL or RI_MOUSE_HWHEEL), process
+            if (buttonFlags & 0xFFFF & ~(RI_MOUSE_WHEEL | RI_MOUSE_HWHEEL))
+            {
+                int i, button = -1, action = -1;
+                
+                if (buttonFlags & RI_MOUSE_LEFT_BUTTON_DOWN)
+                {
+                    button = GLFW_MOUSE_BUTTON_LEFT;
+                    action = GLFW_PRESS;
+                }
+
+                if (buttonFlags & RI_MOUSE_LEFT_BUTTON_UP)
+                {
+                    button = GLFW_MOUSE_BUTTON_LEFT;
+                    action = GLFW_RELEASE;
+                }
+                    
+                if (buttonFlags & RI_MOUSE_RIGHT_BUTTON_DOWN)
+                {
+                    button = GLFW_MOUSE_BUTTON_RIGHT;
+                    action = GLFW_PRESS;
+                }
+                if (buttonFlags & RI_MOUSE_RIGHT_BUTTON_UP)
+                {
+                    button = GLFW_MOUSE_BUTTON_RIGHT;
+                    action = GLFW_RELEASE;
+                }
+                    
+                if (buttonFlags & RI_MOUSE_MIDDLE_BUTTON_DOWN)
+                {
+                    button = GLFW_MOUSE_BUTTON_MIDDLE;
+                    action = GLFW_PRESS;
+                }
+                if (buttonFlags & RI_MOUSE_MIDDLE_BUTTON_UP)
+                {
+                    button = GLFW_MOUSE_BUTTON_MIDDLE;
+                    action = GLFW_RELEASE;
+                }
+                    
+                if (buttonFlags & RI_MOUSE_BUTTON_4_DOWN)
+                {
+                    button = GLFW_MOUSE_BUTTON_4;
+                    action = GLFW_PRESS;
+                }
+                if (buttonFlags & RI_MOUSE_BUTTON_4_UP)
+                {
+                    button = GLFW_MOUSE_BUTTON_4;
+                    action = GLFW_RELEASE;
+                }
+                    
+                if (buttonFlags & RI_MOUSE_BUTTON_5_DOWN)
+                {
+                    button = GLFW_MOUSE_BUTTON_5;
+                    action = GLFW_PRESS;
+                }
+                if (buttonFlags & RI_MOUSE_BUTTON_5_UP)
+                {
+                    button = GLFW_MOUSE_BUTTON_5;
+                    action = GLFW_RELEASE;
+                }
+
+                for (i = 0;  i <= GLFW_MOUSE_BUTTON_LAST;  i++)
+                {
+                    if (window->mouseButtons[i] == GLFW_PRESS)
+                        break;
+                }
+
+                if (i > GLFW_MOUSE_BUTTON_LAST)
+                    SetCapture(hwnd);
+                
+                _glfwInputMouseClick(window, button, action, getKeyMods());
+
+                for (i = 0;  i <= GLFW_MOUSE_BUTTON_LAST;  i++)
+                {
+                    if (window->mouseButtons[i] == GLFW_PRESS)
+                        break;
+                }
+
+                if (i > GLFW_MOUSE_BUTTON_LAST)
+                    ReleaseCapture();
+            }
+            // Handle mouse wheel events
+            if (buttonFlags & RI_MOUSE_WHEEL)
+            {
+                SHORT wheelDelta = (SHORT)data->data.mouse.usButtonData;
+                _glfwInputScroll(window, 0.0, wheelDelta / (double) WHEEL_DELTA);
+            }
+            if (buttonFlags & RI_MOUSE_HWHEEL)
+            {
+                SHORT wheelDelta = (SHORT)data->data.mouse.usButtonData;
+                _glfwInputScroll(window, -wheelDelta / (double) WHEEL_DELTA, 0.0);
+            }
+        }
+
+        data = NEXTRAWINPUTBLOCK(data);
+    }
+}
+
+
 void _glfwPollEventsWin32(void)
 {
     MSG msg;
     HWND handle;
-    _GLFWwindow* window;
+    _GLFWwindow* window = _glfw.windowListHead;
+
+    _processRawInput(); // this does the whole `GetRawInputBuffer` thing
 
     while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
     {
@@ -2153,7 +2299,8 @@ void _glfwPollEventsWin32(void)
     }
 
     window = _glfw.win32.disabledCursorWindow;
-    if (window)
+    // Disable with raw mouse motion because that reports dx/dy directly
+    if (window && !window->rawMouseMotion)
     {
         int width, height;
         _glfwGetWindowSizeWin32(window, &width, &height);