From 556cc61848e5e9bd302b4aed4b780a4f8b032ea6 Mon Sep 17 00:00:00 2001
From: Beoran <beoran@gmail.com>
Date: Wed, 30 Oct 2019 23:56:53 +0100
Subject: [PATCH 01/11] Added WIP types for the joystick callbacks.

---
 include/GLFW/glfw3.h | 99 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)

diff --git a/include/GLFW/glfw3.h b/include/GLFW/glfw3.h
index 2aade0f0..4460d94c 100644
--- a/include/GLFW/glfw3.h
+++ b/include/GLFW/glfw3.h
@@ -1613,6 +1613,105 @@ typedef void (* GLFWmonitorfun)(GLFWmonitor*,int);
  */
 typedef void (* GLFWjoystickfun)(int,int);
 
+/*! @brief The function pointer type for joystick button callbacks.
+ *
+ *  This is the function pointer type for joystick button callbacks.  A joystick
+ *  button callback function has the following signature:
+ *  @code
+ *  void function_name(int jid, int button, int action)
+ *  @endcode
+ *
+ *  @param[in] jid The joystick that had a button pressed or released.
+ *  @param[in] button The [joystick button](@ref buttons) that was pressed or released.
+ *  @param[in] action `GLFW_PRESS` or `GLFW_RELEASE`.  Future
+ *  releases may add more actions.
+ *
+ *  @sa @ref input_joystick_button
+ *  @sa @ref glfwSetJoystickButonCallback
+ *
+ *  @since Added in version 3.4.
+ *  @ingroup input
+ */
+typedef void (* GLFWjoystickbuttonfun)(int,int,int);
+
+/*! @brief The function pointer type for joystick axis movement callbacks.
+ *
+ *  This is the function pointer type for joystick axis movement callbacks.  A joystick
+ *  axis movement callback function has the following signature:
+ *  @code
+ *  void function_name(int jid, int axis, float position)
+ *  @endcode
+ *
+ *  @param[in] jid The joystick that had an axis moved.
+ *  @param[in] axis The [joystick axis](@ref gamepad axes) that was moved.
+ *  @param[in] position A value between -1.0 and 1.0 that indicates the position of the axis.
+ *
+ *  @sa @ref input_gamepad_axis
+ *  @sa @ref glfwSetJoystickAxisCallback
+ *
+ *  @since Added in version 3.4.
+ *  @ingroup input
+ */
+typedef void (* GLFWjoystickaxisfun)(int,int,float);
+
+/*! @brief The function pointer type for joystick hat movement callbacks.
+ *
+ *  This is the function pointer type for joystick hat movement callbacks.  A joystick
+ *  hat movement callback function has the following signature:
+ *  @code
+ *  void function_name(int jid, int hat, int position)
+ *  @endcode
+ *
+ *  @param[in] jid The joystick that had an axis moved.
+ *  @param[in] hat The [joystick hat](@ref joystick hats) that was moved.
+ *  @param[in] position A value that indicates the position of the hat.
+ *  The position parameter is one of the following values:
+ *
+ *  Name                  | Value
+ *  ----                  | -----
+ *  `GLFW_HAT_CENTERED`   | 0
+ *  `GLFW_HAT_UP`         | 1
+ *  `GLFW_HAT_RIGHT`      | 2
+ *  `GLFW_HAT_DOWN`       | 4
+ *  `GLFW_HAT_LEFT`       | 8
+ *  `GLFW_HAT_RIGHT_UP`   | `GLFW_HAT_RIGHT` \| `GLFW_HAT_UP`
+ *  `GLFW_HAT_RIGHT_DOWN` | `GLFW_HAT_RIGHT` \| `GLFW_HAT_DOWN`
+ *  `GLFW_HAT_LEFT_UP`    | `GLFW_HAT_LEFT` \| `GLFW_HAT_UP`
+ *  `GLFW_HAT_LEFT_DOWN`  | `GLFW_HAT_LEFT` \| `GLFW_HAT_DOWN`
+ *
+ *  The diagonal directions are bitwise combinations of the primary (up, right,
+ *  down and left) directions and you can test for these individually by ANDing
+ *  it with the corresponding direction.
+ *
+ *  @sa @ref input_joystick_hat
+ *  @sa @ref glfwSetJoystickHatCallback
+ *
+ *  @since Added in version 3.4.
+ *  @ingroup input
+ */
+typedef void (* GLFWjoystickhatfun)(int,int,int);
+
+/*! @brief The function pointer type for Unicode character callbacks.
+ *
+ *  This is the function pointer type for Unicode character callbacks.
+ *  A Unicode character callback function has the following signature:
+ *  @code
+ *  void function_name(GLFWwindow* window, unsigned int codepoint)
+ *  @endcode
+ *
+ *  @param[in] window The window that received the event.
+ *  @param[in] codepoint The Unicode code point of the character.
+ *
+ *  @sa @ref input_char
+ *  @sa @ref glfwSetCharCallback
+ *
+ *  @since Added in version 2.4.
+ *  @glfw3 Added window handle parameter.
+ *
+ *  @ingroup input
+ */
+typedef void (* GLFWcharfun)(GLFWwindow*,unsigned int);
+
 /*! @brief Video mode type.
  *
  *  This describes a single video mode.

From f5536ccae0a751994a0cfdf6541a841a2198482f Mon Sep 17 00:00:00 2001
From: Beoran <beoran@gmail.com>
Date: Thu, 31 Oct 2019 20:49:39 +0100
Subject: [PATCH 02/11] Implement joystick and game pad callbacks.

This allows using GLFW joysticks in an event based manner.

For the joysticks, this was done by adding the callbacks
and then calling them in the shared code in input.c.
For the gamepads, a new shared function is called whenever the
joystick's state changes. However the gamepad state callback is
only called if the joystick is mapped to a gamepad.
---
 include/GLFW/glfw3.h | 166 +++++++++++++++++++++++++++++++++++++++++++
 src/input.c          |  59 +++++++++++++++
 src/internal.h       |   8 ++-
 3 files changed, 231 insertions(+), 2 deletions(-)

diff --git a/include/GLFW/glfw3.h b/include/GLFW/glfw3.h
index 4460d94c..34713091 100644
--- a/include/GLFW/glfw3.h
+++ b/include/GLFW/glfw3.h
@@ -1168,6 +1168,17 @@ typedef struct GLFWwindow GLFWwindow;
  */
 typedef struct GLFWcursor GLFWcursor;
 
+/*! @brief Gamepad state object.
+ *
+ *  Gamepad state object, predeclared here.
+ *
+ *  @since Added in version 3.4.
+ *
+ *  @ingroup input
+ */
+typedef struct GLFWgamepadstate GLFWgamepadstate;
+
+
 /*! @brief The function pointer type for error callbacks.
  *
  *  This is the function pointer type for error callbacks.  An error callback
@@ -1691,6 +1702,26 @@ typedef void (* GLFWjoystickaxisfun)(int,int,float);
  */
 typedef void (* GLFWjoystickhatfun)(int,int,int);
 
+/*! @brief The function pointer type for game pad state changes.
+ *
+ *  This is the function pointer type for game pad state change callbacks.
+ *  A game pad state change callback function has the following signature:
+ *  @code
+ *  void function_name(int jid, GLFWgamepadstate* state)
+ *  @endcode
+ *
+ *  @param[in] jid The ID of the game pad that changed state.
+ *  @param[in] state The updated state of the game pad.
+ *
+ *  @sa @ref input_gamepad
+ *  @sa @ref glfwSetGamepadStateCallback
+ *
+ *  @since Added in version 3.4.
+ *  @ingroup input
+ */
+typedef void (* GLFWgamepadstatefun)(int,GLFWgamepadstate*);
+
+
 /*! @brief The function pointer type for Unicode character callbacks.
  *
  *  This is the function pointer type for Unicode character callbacks.
@@ -1807,6 +1838,7 @@ typedef struct GLFWimage
  *
  *  @sa @ref gamepad
  *  @sa @ref glfwGetGamepadState
+ *  @sa @ref glfwSetGamepadStateCallback
  *
  *  @since Added in version 3.3.
  *
@@ -5237,6 +5269,140 @@ GLFWAPI int glfwJoystickIsGamepad(int jid);
  */
 GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun callback);
 
+/*! @brief Sets the joystick button callback.
+ *
+ *  This function sets the joystick configuration callback, or removes the
+ *  currently set callback.  This is called when a joystick button is pressed
+ *  or released.
+ *
+ *  For joystick button events to be delivered on all platforms,
+ *  you need to call one of the [event processing](@ref events)
+ *  functions.
+ *
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(int jid, int button, int state)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWjoystickbuttonfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_event
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWjoystickbuttonfun glfwSetJoystickButtonCallback(GLFWjoystickbuttonfun callback);
+
+/*! @brief Sets the joystick axis callback.
+ *
+ *  This function sets the joystick axis callback, or removes the
+ *  currently set callback.  This is called when a joystick axis moved.
+ *
+ *  For joystick axis events to be delivered on all platforms,
+ *  you need to call one of the [event processing](@ref events)
+ *  functions.
+ *
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(int jid, int axis, float state)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWjoystickaxisfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_event
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWjoystickaxisfun glfwSetJoystickAxisCallback(GLFWjoystickaxisfun callback);
+
+/*! @brief Sets the joystick hat callback.
+ *
+ *  This function sets the joystick hat callback, or removes the
+ *  currently set callback.  This is called when a joystick hat moved.
+ *
+ *  For joystick hat events to be delivered on all platforms,
+ *  you need to call one of the [event processing](@ref events)
+ *  functions.
+ *
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(int jid, int hat, int state)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWjoystickhatfun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_event
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWjoystickhatfun glfwSetJoystickHatCallback(GLFWjoystickhatfun callback);
+
+/*! @brief Sets the game pad state callback.
+ *
+ *  This function sets the game pad state callback, or removes the
+ *  currently set callback.  This is called when a game pad state changes.
+ *
+ *  For game pad events to be delivered on all platforms,
+ *  you need to call one of the [event processing](@ref events)
+ *  functions.
+ *
+ *  @param[in] callback The new callback, or `NULL` to remove the currently set
+ *  callback.
+ *  @return The previously set callback, or `NULL` if no callback was set or the
+ *  library had not been [initialized](@ref intro_init).
+ *
+ *  @callback_signature
+ *  @code
+ *  void function_name(int jid, GLFWgamepadstate* state)
+ *  @endcode
+ *  For more information about the callback parameters, see the
+ *  [function pointer type](@ref GLFWgamepadstatefun).
+ *
+ *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
+ *
+ *  @thread_safety This function must only be called from the main thread.
+ *
+ *  @sa @ref joystick_event
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup input
+ */
+GLFWAPI GLFWgamepadstatefun glfwSetGamepadStateCallback(GLFWgamepadstatefun callback);
+
+
 /*! @brief Adds the specified SDL_GameControllerDB gamepad mappings.
  *
  *  This function parses the specified ASCII encoded string and updates the
diff --git a/src/input.c b/src/input.c
index 28291750..6d07ce73 100644
--- a/src/input.c
+++ b/src/input.c
@@ -365,6 +365,19 @@ void _glfwInputDrop(_GLFWwindow* window, int count, const char** paths)
         window->callbacks.drop((GLFWwindow*) window, count, paths);
 }
 
+// Notifies shared code of a change in the gamepad state.
+// Automatically recalculates the state if the gamepad callback is installed.
+void _glfwInputGamepad(_GLFWjoystick* js)
+{
+    const int jid = (int) (js - _glfw.joysticks);
+    if (glfwJoystickIsGamepad(jid)  && (_glfw.callbacks.gamepad_state)) {
+        GLFWgamepadstate state;
+        if (0 == glfwGetGamepadState(jid, &state)) {
+          _glfw.callbacks.gamepad_state(jid, &state);
+        }
+    }
+}
+
 // Notifies shared code of a joystick connection or disconnection
 //
 void _glfwInputJoystick(_GLFWjoystick* js, int event)
@@ -379,20 +392,33 @@ void _glfwInputJoystick(_GLFWjoystick* js, int event)
 //
 void _glfwInputJoystickAxis(_GLFWjoystick* js, int axis, float value)
 {
+    const int jid = (int) (js - _glfw.joysticks);
+
     js->axes[axis] = value;
+
+    if (_glfw.callbacks.joystick_axis)
+        _glfw.callbacks.joystick_axis(jid, axis, value);
+    _glfwInputGamepad(js);
 }
 
 // Notifies shared code of the new value of a joystick button
 //
 void _glfwInputJoystickButton(_GLFWjoystick* js, int button, char value)
 {
+    const int jid = (int) (js - _glfw.joysticks);
+
     js->buttons[button] = value;
+
+    if (_glfw.callbacks.joystick_button)
+        _glfw.callbacks.joystick_button(jid, button, value);
+    _glfwInputGamepad(js);
 }
 
 // Notifies shared code of the new value of a joystick hat
 //
 void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value)
 {
+    const int jid = (int) (js - _glfw.joysticks);
     const int base = js->buttonCount + hat * 4;
 
     js->buttons[base + 0] = (value & 0x01) ? GLFW_PRESS : GLFW_RELEASE;
@@ -401,6 +427,10 @@ void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value)
     js->buttons[base + 3] = (value & 0x08) ? GLFW_PRESS : GLFW_RELEASE;
 
     js->hats[hat] = value;
+
+    if (_glfw.callbacks.joystick_hat)
+        _glfw.callbacks.joystick_hat(jid, hat, value);
+    _glfwInputGamepad(js);
 }
 
 
@@ -1112,6 +1142,35 @@ GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun cbfun)
     return cbfun;
 }
 
+GLFWAPI GLFWgamepadstatefun glfwSetGamepadStateCallback(GLFWgamepadstatefun cbfun)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(_glfw.callbacks.gamepad_state, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWjoystickbuttonfun glfwSetJoystickButtonCallback(GLFWjoystickbuttonfun cbfun)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(_glfw.callbacks.joystick_button, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWjoystickaxisfun glfwSetJoystickAxisCallback(GLFWjoystickaxisfun cbfun)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(_glfw.callbacks.joystick_axis, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWjoystickhatfun glfwSetJoystickHatCallback(GLFWjoystickhatfun cbfun)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(_glfw.callbacks.joystick_hat, cbfun);
+    return cbfun;
+}
+
+
 GLFWAPI int glfwUpdateGamepadMappings(const char* string)
 {
     int jid;
diff --git a/src/internal.h b/src/internal.h
index acdae22d..c135083f 100644
--- a/src/internal.h
+++ b/src/internal.h
@@ -565,8 +565,12 @@ struct _GLFWlibrary
     } vk;
 
     struct {
-        GLFWmonitorfun  monitor;
-        GLFWjoystickfun joystick;
+        GLFWmonitorfun        monitor;
+        GLFWjoystickfun       joystick;
+        GLFWjoystickaxisfun   joystick_axis;
+        GLFWjoystickbuttonfun joystick_button;
+        GLFWjoystickhatfun    joystick_hat;
+        GLFWgamepadstatefun   gamepad_state;
     } callbacks;
 
     // This is defined in the window API's platform.h

From ee4132b5cfb278b9660eedff55f283f0aaab4645 Mon Sep 17 00:00:00 2001
From: Beoran <beoran@gmail.com>
Date: Thu, 7 Nov 2019 01:01:31 +0100
Subject: [PATCH 03/11] Test and fix joystick and game pad callbacks on Linux.

---
 include/GLFW/glfw3.h | 22 ++++++----------
 src/input.c          | 27 ++++++++++++++++----
 src/internal.h       |  1 +
 src/window.c         |  2 ++
 src/x11_window.c     | 60 +++++++++++++++++++++++++++++++-------------
 tests/events.c       | 50 ++++++++++++++++++++++++++++++++++++
 6 files changed, 125 insertions(+), 37 deletions(-)

diff --git a/include/GLFW/glfw3.h b/include/GLFW/glfw3.h
index 34713091..21ae6ce3 100644
--- a/include/GLFW/glfw3.h
+++ b/include/GLFW/glfw3.h
@@ -1168,17 +1168,6 @@ typedef struct GLFWwindow GLFWwindow;
  */
 typedef struct GLFWcursor GLFWcursor;
 
-/*! @brief Gamepad state object.
- *
- *  Gamepad state object, predeclared here.
- *
- *  @since Added in version 3.4.
- *
- *  @ingroup input
- */
-typedef struct GLFWgamepadstate GLFWgamepadstate;
-
-
 /*! @brief The function pointer type for error callbacks.
  *
  *  This is the function pointer type for error callbacks.  An error callback
@@ -1711,7 +1700,11 @@ typedef void (* GLFWjoystickhatfun)(int,int,int);
  *  @endcode
  *
  *  @param[in] jid The ID of the game pad that changed state.
- *  @param[in] state The updated state of the game pad.
+ *  @param[in] buttons The states of each
+ *             [gamepad button](@ref gamepad_buttons),
+ *             `GLFW_PRESS` or `GLFW_RELEASE`.
+ *  @param[in] axes The states of each [gamepad axis](@ref gamepad_axes),
+ *                  in the range -1.0 to 1.0 inclusive.
  *
  *  @sa @ref input_gamepad
  *  @sa @ref glfwSetGamepadStateCallback
@@ -1719,7 +1712,8 @@ typedef void (* GLFWjoystickhatfun)(int,int,int);
  *  @since Added in version 3.4.
  *  @ingroup input
  */
-typedef void (* GLFWgamepadstatefun)(int,GLFWgamepadstate*);
+typedef void (* GLFWgamepadstatefun)(int, unsigned char buttons[15],
+                                          float axes[6]);
 
 
 /*! @brief The function pointer type for Unicode character callbacks.
@@ -5385,7 +5379,7 @@ GLFWAPI GLFWjoystickhatfun glfwSetJoystickHatCallback(GLFWjoystickhatfun callbac
  *
  *  @callback_signature
  *  @code
- *  void function_name(int jid, GLFWgamepadstate* state)
+ *  void function_name(int jid, unsigned char buttons[15], float axes[6])
  *  @endcode
  *  For more information about the callback parameters, see the
  *  [function pointer type](@ref GLFWgamepadstatefun).
diff --git a/src/input.c b/src/input.c
index 6d07ce73..3664379b 100644
--- a/src/input.c
+++ b/src/input.c
@@ -370,10 +370,15 @@ void _glfwInputDrop(_GLFWwindow* window, int count, const char** paths)
 void _glfwInputGamepad(_GLFWjoystick* js)
 {
     const int jid = (int) (js - _glfw.joysticks);
-    if (glfwJoystickIsGamepad(jid)  && (_glfw.callbacks.gamepad_state)) {
+
+    if (!_glfw.initialized) {
+        return;
+    }
+
+    if ((js->mapping != NULL)  && (_glfw.callbacks.gamepad_state)) {
         GLFWgamepadstate state;
-        if (0 == glfwGetGamepadState(jid, &state)) {
-          _glfw.callbacks.gamepad_state(jid, &state);
+        if (glfwGetGamepadState(jid, &state)) {
+          _glfw.callbacks.gamepad_state(jid, state.buttons, state.axes);
         }
     }
 }
@@ -394,10 +399,11 @@ void _glfwInputJoystickAxis(_GLFWjoystick* js, int axis, float value)
 {
     const int jid = (int) (js - _glfw.joysticks);
 
+    if ((_glfw.callbacks.joystick_axis) && (js->axes[axis] != value))
+        _glfw.callbacks.joystick_axis(jid, axis, value);
+
     js->axes[axis] = value;
 
-    if (_glfw.callbacks.joystick_axis)
-        _glfw.callbacks.joystick_axis(jid, axis, value);
     _glfwInputGamepad(js);
 }
 
@@ -495,6 +501,17 @@ void _glfwCenterCursorInContentArea(_GLFWwindow* window)
     _glfwPlatformSetCursorPos(window, width / 2.0, height / 2.0);
 }
 
+void _glfwPollAllJoysticks() {
+    int jid;
+
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
+    {
+        if (_glfw.joysticks[jid].present == GLFW_TRUE) {
+          _glfwPlatformPollJoystick(_glfw.joysticks + jid, _GLFW_POLL_ALL);
+        }
+    }
+}
+
 
 //////////////////////////////////////////////////////////////////////////
 //////                        GLFW public API                       //////
diff --git a/src/internal.h b/src/internal.h
index c135083f..4fdd4780 100644
--- a/src/internal.h
+++ b/src/internal.h
@@ -769,6 +769,7 @@ _GLFWjoystick* _glfwAllocJoystick(const char* name,
                                   int hatCount);
 void _glfwFreeJoystick(_GLFWjoystick* js);
 void _glfwCenterCursorInContentArea(_GLFWwindow* window);
+void _glfwPollAllJoysticks();
 
 GLFWbool _glfwInitVulkan(int mode);
 void _glfwTerminateVulkan(void);
diff --git a/src/window.c b/src/window.c
index fa604d01..a8a00c3e 100644
--- a/src/window.c
+++ b/src/window.c
@@ -1069,12 +1069,14 @@ GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow*
 GLFWAPI void glfwPollEvents(void)
 {
     _GLFW_REQUIRE_INIT();
+    _glfwPollAllJoysticks();
     _glfwPlatformPollEvents();
 }
 
 GLFWAPI void glfwWaitEvents(void)
 {
     _GLFW_REQUIRE_INIT();
+    _glfwPollAllJoysticks();
     _glfwPlatformWaitEvents();
 }
 
diff --git a/src/x11_window.c b/src/x11_window.c
index 56379a3c..b1182735 100644
--- a/src/x11_window.c
+++ b/src/x11_window.c
@@ -65,21 +65,32 @@ static GLFWbool waitForEvent(double* timeout)
 {
     fd_set fds;
     const int fd = ConnectionNumber(_glfw.x11.display);
-    int count = fd + 1;
-
-#if defined(__linux__)
-    if (_glfw.linjs.inotify > fd)
-        count = _glfw.linjs.inotify + 1;
-#endif
     for (;;)
     {
+        int count = fd + 1;
         FD_ZERO(&fds);
         FD_SET(fd, &fds);
+
 #if defined(__linux__)
         if (_glfw.linjs.inotify > 0)
-            FD_SET(_glfw.linjs.inotify, &fds);
-#endif
+        {
+            if (_glfw.linjs.inotify >= count )
+                count = _glfw.linjs.inotify + 1;
 
+            FD_SET(_glfw.linjs.inotify, &fds);
+        }
+
+        for (int jid = 0; jid <= GLFW_JOYSTICK_LAST;  jid++)
+        {
+            if (_glfw.joysticks[jid].present) {
+                if  (_glfw.joysticks[jid].linjs.fd >= count)
+                    count = _glfw.joysticks[jid].linjs.fd + 1;
+
+                FD_SET(_glfw.joysticks[jid].linjs.fd, &fds);
+            }
+        }
+
+#endif
         if (timeout)
         {
             const long seconds = (long) *timeout;
@@ -2681,6 +2692,7 @@ void _glfwPlatformPollEvents(void)
 
 #if defined(__linux__)
     _glfwDetectJoystickConnectionLinux();
+    _glfwPollAllJoysticks();
 #endif
     XPending(_glfw.x11.display);
 
@@ -2709,23 +2721,35 @@ void _glfwPlatformPollEvents(void)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwPlatformWaitEvents(void)
+static GLFWbool waitForAndPollEvents(double * timeout)
 {
-    while (!XPending(_glfw.x11.display))
-        waitForEvent(NULL);
+    GLFWbool result = GLFW_FALSE;
+    for (;;)
+    {
+        int xpending = XPending(_glfw.x11.display);
+        GLFWbool event = waitForEvent(timeout);
+        // We cannot use the boolean shortcut here, since
+        // waiting for events might have a side effect.
+        if (event || xpending )
+        {
+            result = GLFW_TRUE;
+            break;
+        }
+    }
 
     _glfwPlatformPollEvents();
+    return result;
+}
+
+
+void _glfwPlatformWaitEvents(void)
+{
+    waitForAndPollEvents(NULL);
 }
 
 void _glfwPlatformWaitEventsTimeout(double timeout)
 {
-    while (!XPending(_glfw.x11.display))
-    {
-        if (!waitForEvent(&timeout))
-            break;
-    }
-
-    _glfwPlatformPollEvents();
+    waitForAndPollEvents(&timeout);
 }
 
 void _glfwPlatformPostEmptyEvent(void)
diff --git a/tests/events.c b/tests/events.c
index 251e15d9..043436f4 100644
--- a/tests/events.c
+++ b/tests/events.c
@@ -494,6 +494,52 @@ static void joystick_callback(int jid, int event)
     }
 }
 
+static void joystick_button_callback(int jid, int button, int state) {
+    printf("%08x at %0.3f: Joystick %i (%s) button %d state %d\n",
+               counter++, glfwGetTime(),
+               jid,
+               glfwGetJoystickName(jid),
+               button,
+               state);
+}
+
+static void joystick_axis_callback(int jid, int axis, float value) {
+    printf("%08x at %0.3f: Joystick %i (%s) axis %d value %0.4f\n",
+               counter++, glfwGetTime(), jid,
+               glfwGetJoystickName(jid),
+               axis,
+               value);
+}
+
+static void joystick_hat_callback(int jid, int hat, int value) {
+    printf("%08x at %0.3f: Joystick %i (%s) hat %d value %d\n",
+               counter++, glfwGetTime(),
+               jid,
+               glfwGetJoystickName(jid),
+               hat,
+               value);
+}
+
+static void gamepad_state_callback(int jid, unsigned char buttons[15], float axes[6]) {
+    int i = 0;
+    printf("%08x at %0.3f: Gamepad %i (%s) state:",
+               counter++, glfwGetTime(),
+               jid,
+               glfwGetJoystickName(jid));
+
+    printf("Buttons: ");
+    for (i= 0 ; i < 15; i++) {
+      printf(" %d:%d", i, buttons[i]);
+    }
+    printf("Axes: ");
+    for (i= 0 ; i < 6; i++) {
+      printf(" %d:%0.4f", i, axes[i]);
+    }
+    printf("\n");
+
+}
+
+
 int main(int argc, char** argv)
 {
     Slot* slots;
@@ -511,6 +557,10 @@ int main(int argc, char** argv)
 
     glfwSetMonitorCallback(monitor_callback);
     glfwSetJoystickCallback(joystick_callback);
+    glfwSetJoystickAxisCallback(joystick_axis_callback);
+    glfwSetJoystickButtonCallback(joystick_button_callback);
+    glfwSetJoystickHatCallback(joystick_hat_callback);
+    glfwSetGamepadStateCallback(gamepad_state_callback);
 
     while ((ch = getopt(argc, argv, "hfn:")) != -1)
     {

From 1ed4c6955031150fb814c322bd1b682c673faf82 Mon Sep 17 00:00:00 2001
From: Beoran <beoran@gmail.com>
Date: Thu, 7 Nov 2019 01:19:01 +0100
Subject: [PATCH 04/11] Remove accidentally duplicated function type
 definition.

---
 include/GLFW/glfw3.h | 23 -----------------------
 1 file changed, 23 deletions(-)

diff --git a/include/GLFW/glfw3.h b/include/GLFW/glfw3.h
index 21ae6ce3..2f2ddd23 100644
--- a/include/GLFW/glfw3.h
+++ b/include/GLFW/glfw3.h
@@ -1714,29 +1714,6 @@ typedef void (* GLFWjoystickhatfun)(int,int,int);
  */
 typedef void (* GLFWgamepadstatefun)(int, unsigned char buttons[15],
                                           float axes[6]);
-
-
-/*! @brief The function pointer type for Unicode character callbacks.
- *
- *  This is the function pointer type for Unicode character callbacks.
- *  A Unicode character callback function has the following signature:
- *  @code
- *  void function_name(GLFWwindow* window, unsigned int codepoint)
- *  @endcode
- *
- *  @param[in] window The window that received the event.
- *  @param[in] codepoint The Unicode code point of the character.
- *
- *  @sa @ref input_char
- *  @sa @ref glfwSetCharCallback
- *
- *  @since Added in version 2.4.
- *  @glfw3 Added window handle parameter.
- *
- *  @ingroup input
- */
-typedef void (* GLFWcharfun)(GLFWwindow*,unsigned int);
-
 /*! @brief Video mode type.
  *
  *  This describes a single video mode.

From ef269c0ae95627efad6dacf02eba55e589aaf64a Mon Sep 17 00:00:00 2001
From: Beoran <beoran@gmail.com>
Date: Sun, 15 Mar 2020 20:53:20 +0100
Subject: [PATCH 05/11] Only call the joystick event callback if the state
 actually changed. Only calculate the joystick ID when the event callback is
 actually called.

---
 src/input.c | 46 +++++++++++++++++++++++++---------------------
 1 file changed, 25 insertions(+), 21 deletions(-)

diff --git a/src/input.c b/src/input.c
index 3664379b..02675513 100644
--- a/src/input.c
+++ b/src/input.c
@@ -387,44 +387,45 @@ void _glfwInputGamepad(_GLFWjoystick* js)
 //
 void _glfwInputJoystick(_GLFWjoystick* js, int event)
 {
-    const int jid = (int) (js - _glfw.joysticks);
-
-    if (_glfw.callbacks.joystick)
+    if (_glfw.callbacks.joystick) {
+        const int jid = (int) (js - _glfw.joysticks);
         _glfw.callbacks.joystick(jid, event);
+    }
 }
 
+
 // Notifies shared code of the new value of a joystick axis
 //
 void _glfwInputJoystickAxis(_GLFWjoystick* js, int axis, float value)
 {
-    const int jid = (int) (js - _glfw.joysticks);
+    if (js->axes[axis] != value) {
+        const int jid = (int) (js - _glfw.joysticks);
 
-    if ((_glfw.callbacks.joystick_axis) && (js->axes[axis] != value))
-        _glfw.callbacks.joystick_axis(jid, axis, value);
-
-    js->axes[axis] = value;
-
-    _glfwInputGamepad(js);
+        js->axes[axis] = value;
+        if (_glfw.callbacks.joystick_axis)
+            _glfw.callbacks.joystick_axis(jid, axis, value);
+        _glfwInputGamepad(js);
+    }
 }
 
 // Notifies shared code of the new value of a joystick button
 //
 void _glfwInputJoystickButton(_GLFWjoystick* js, int button, char value)
 {
-    const int jid = (int) (js - _glfw.joysticks);
+    if (js->buttons[button] != value) {
+        const int jid = (int) (js - _glfw.joysticks);
 
-    js->buttons[button] = value;
-
-    if (_glfw.callbacks.joystick_button)
-        _glfw.callbacks.joystick_button(jid, button, value);
-    _glfwInputGamepad(js);
+        js->buttons[button] = value;
+        if(_glfw.callbacks.joystick_button)
+            _glfw.callbacks.joystick_button(jid, button, value);
+        _glfwInputGamepad(js);
+    }
 }
 
 // Notifies shared code of the new value of a joystick hat
 //
 void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value)
 {
-    const int jid = (int) (js - _glfw.joysticks);
     const int base = js->buttonCount + hat * 4;
 
     js->buttons[base + 0] = (value & 0x01) ? GLFW_PRESS : GLFW_RELEASE;
@@ -432,11 +433,14 @@ void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value)
     js->buttons[base + 2] = (value & 0x04) ? GLFW_PRESS : GLFW_RELEASE;
     js->buttons[base + 3] = (value & 0x08) ? GLFW_PRESS : GLFW_RELEASE;
 
-    js->hats[hat] = value;
+    if (js->hats[hat] != value) {
+        const int jid = (int) (js - _glfw.joysticks);
 
-    if (_glfw.callbacks.joystick_hat)
-        _glfw.callbacks.joystick_hat(jid, hat, value);
-    _glfwInputGamepad(js);
+        js->hats[hat] = value;
+        if(_glfw.callbacks.joystick_hat)
+          _glfw.callbacks.joystick_hat(jid, hat, value);
+        _glfwInputGamepad(js);
+    }
 }
 
 

From e65723069fdda8e5b73773b06c666c9f5d4c7867 Mon Sep 17 00:00:00 2001
From: Enthuin <enthuin@skiff.com>
Date: Thu, 20 Oct 2022 20:37:48 -0500
Subject: [PATCH 06/11] change gamepad state callback to use the state.  post
 empty event after joystick polling to make waitEvents return

---
 include/GLFW/glfw3.h | 198 +++++++++++++++++++++----------------------
 src/input.c          |  25 +++---
 tests/events.c       |   6 +-
 3 files changed, 111 insertions(+), 118 deletions(-)

diff --git a/include/GLFW/glfw3.h b/include/GLFW/glfw3.h
index 8e30fd2f..ecce3438 100644
--- a/include/GLFW/glfw3.h
+++ b/include/GLFW/glfw3.h
@@ -1964,107 +1964,6 @@ typedef void (* GLFWmonitorfun)(GLFWmonitor* monitor, int event);
  */
 typedef void (* GLFWjoystickfun)(int jid, int event);
 
-/*! @brief The function pointer type for joystick button callbacks.
- *
- *  This is the function pointer type for joystick button callbacks.  A joystick
- *  button callback function has the following signature:
- *  @code
- *  void function_name(int jid, int button, int action)
- *  @endcode
- *
- *  @param[in] jid The joystick that had a button pressed or released.
- *  @param[in] button The [joystick button](@ref buttons) that was pressed or released.
- *  @param[in] action `GLFW_PRESS` or `GLFW_RELEASE`.  Future
- *  releases may add more actions.
- *
- *  @sa @ref input_joystick_button
- *  @sa @ref glfwSetJoystickButonCallback
- *
- *  @since Added in version 3.4.
- *  @ingroup input
- */
-typedef void (* GLFWjoystickbuttonfun)(int,int,int);
-
-/*! @brief The function pointer type for joystick axis movement callbacks.
- *
- *  This is the function pointer type for joystick axis movement callbacks.  A joystick
- *  axis movement callback function has the following signature:
- *  @code
- *  void function_name(int jid, int axis, float position)
- *  @endcode
- *
- *  @param[in] jid The joystick that had an axis moved.
- *  @param[in] axis The [joystick axis](@ref gamepad axes) that was moved.
- *  @param[in] position A value between -1.0 and 1.0 that indicates the position of the axis.
- *
- *  @sa @ref input_gamepad_axis
- *  @sa @ref glfwSetJoystickAxisCallback
- *
- *  @since Added in version 3.4.
- *  @ingroup input
- */
-typedef void (* GLFWjoystickaxisfun)(int,int,float);
-
-/*! @brief The function pointer type for joystick hat movement callbacks.
- *
- *  This is the function pointer type for joystick hat movement callbacks.  A joystick
- *  hat movement callback function has the following signature:
- *  @code
- *  void function_name(int jid, int hat, int position)
- *  @endcode
- *
- *  @param[in] jid The joystick that had an axis moved.
- *  @param[in] hat The [joystick hat](@ref joystick hats) that was moved.
- *  @param[in] position A value that indicates the position of the hat.
- *  The position parameter is one of the following values:
- *
- *  Name                  | Value
- *  ----                  | -----
- *  `GLFW_HAT_CENTERED`   | 0
- *  `GLFW_HAT_UP`         | 1
- *  `GLFW_HAT_RIGHT`      | 2
- *  `GLFW_HAT_DOWN`       | 4
- *  `GLFW_HAT_LEFT`       | 8
- *  `GLFW_HAT_RIGHT_UP`   | `GLFW_HAT_RIGHT` \| `GLFW_HAT_UP`
- *  `GLFW_HAT_RIGHT_DOWN` | `GLFW_HAT_RIGHT` \| `GLFW_HAT_DOWN`
- *  `GLFW_HAT_LEFT_UP`    | `GLFW_HAT_LEFT` \| `GLFW_HAT_UP`
- *  `GLFW_HAT_LEFT_DOWN`  | `GLFW_HAT_LEFT` \| `GLFW_HAT_DOWN`
- *
- *  The diagonal directions are bitwise combinations of the primary (up, right,
- *  down and left) directions and you can test for these individually by ANDing
- *  it with the corresponding direction.
- *
- *  @sa @ref input_joystick_hat
- *  @sa @ref glfwSetJoystickHatCallback
- *
- *  @since Added in version 3.4.
- *  @ingroup input
- */
-typedef void (* GLFWjoystickhatfun)(int,int,int);
-
-/*! @brief The function pointer type for game pad state changes.
- *
- *  This is the function pointer type for game pad state change callbacks.
- *  A game pad state change callback function has the following signature:
- *  @code
- *  void function_name(int jid, GLFWgamepadstate* state)
- *  @endcode
- *
- *  @param[in] jid The ID of the game pad that changed state.
- *  @param[in] buttons The states of each
- *             [gamepad button](@ref gamepad_buttons),
- *             `GLFW_PRESS` or `GLFW_RELEASE`.
- *  @param[in] axes The states of each [gamepad axis](@ref gamepad_axes),
- *                  in the range -1.0 to 1.0 inclusive.
- *
- *  @sa @ref input_gamepad
- *  @sa @ref glfwSetGamepadStateCallback
- *
- *  @since Added in version 3.4.
- *  @ingroup input
- */
-typedef void (* GLFWgamepadstatefun)(int, unsigned char buttons[15],
-                                          float axes[6]);
 /*! @brief Video mode type.
  *
  *  This describes a single video mode.
@@ -2195,6 +2094,103 @@ typedef struct GLFWallocator
     void* user;
 } GLFWallocator;
 
+/*! @brief The function pointer type for joystick button callbacks.
+ *
+ *  This is the function pointer type for joystick button callbacks.  A joystick
+ *  button callback function has the following signature:
+ *  @code
+ *  void function_name(int jid, int button, int action)
+ *  @endcode
+ *
+ *  @param[in] jid The joystick that had a button pressed or released.
+ *  @param[in] button The [joystick button](@ref buttons) that was pressed or released.
+ *  @param[in] action `GLFW_PRESS` or `GLFW_RELEASE`.  Future
+ *  releases may add more actions.
+ *
+ *  @sa @ref input_joystick_button
+ *  @sa @ref glfwSetJoystickButonCallback
+ *
+ *  @since Added in version 3.4.
+ *  @ingroup input
+ */
+typedef void (* GLFWjoystickbuttonfun)(int,int,int);
+
+/*! @brief The function pointer type for joystick axis movement callbacks.
+ *
+ *  This is the function pointer type for joystick axis movement callbacks.  A joystick
+ *  axis movement callback function has the following signature:
+ *  @code
+ *  void function_name(int jid, int axis, float position)
+ *  @endcode
+ *
+ *  @param[in] jid The joystick that had an axis moved.
+ *  @param[in] axis The [joystick axis](@ref gamepad axes) that was moved.
+ *  @param[in] position A value between -1.0 and 1.0 that indicates the position of the axis.
+ *
+ *  @sa @ref input_gamepad_axis
+ *  @sa @ref glfwSetJoystickAxisCallback
+ *
+ *  @since Added in version 3.4.
+ *  @ingroup input
+ */
+typedef void (* GLFWjoystickaxisfun)(int,int,float);
+
+/*! @brief The function pointer type for joystick hat movement callbacks.
+ *
+ *  This is the function pointer type for joystick hat movement callbacks.  A joystick
+ *  hat movement callback function has the following signature:
+ *  @code
+ *  void function_name(int jid, int hat, int position)
+ *  @endcode
+ *
+ *  @param[in] jid The joystick that had an axis moved.
+ *  @param[in] hat The [joystick hat](@ref joystick hats) that was moved.
+ *  @param[in] position A value that indicates the position of the hat.
+ *  The position parameter is one of the following values:
+ *
+ *  Name                  | Value
+ *  ----                  | -----
+ *  `GLFW_HAT_CENTERED`   | 0
+ *  `GLFW_HAT_UP`         | 1
+ *  `GLFW_HAT_RIGHT`      | 2
+ *  `GLFW_HAT_DOWN`       | 4
+ *  `GLFW_HAT_LEFT`       | 8
+ *  `GLFW_HAT_RIGHT_UP`   | `GLFW_HAT_RIGHT` \| `GLFW_HAT_UP`
+ *  `GLFW_HAT_RIGHT_DOWN` | `GLFW_HAT_RIGHT` \| `GLFW_HAT_DOWN`
+ *  `GLFW_HAT_LEFT_UP`    | `GLFW_HAT_LEFT` \| `GLFW_HAT_UP`
+ *  `GLFW_HAT_LEFT_DOWN`  | `GLFW_HAT_LEFT` \| `GLFW_HAT_DOWN`
+ *
+ *  The diagonal directions are bitwise combinations of the primary (up, right,
+ *  down and left) directions and you can test for these individually by ANDing
+ *  it with the corresponding direction.
+ *
+ *  @sa @ref input_joystick_hat
+ *  @sa @ref glfwSetJoystickHatCallback
+ *
+ *  @since Added in version 3.4.
+ *  @ingroup input
+ */
+typedef void (* GLFWjoystickhatfun)(int,int,int);
+
+/*! @brief The function pointer type for game pad state changes.
+ *
+ *  This is the function pointer type for game pad state change callbacks.
+ *  A game pad state change callback function has the following signature:
+ *  @code
+ *  void function_name(int jid, GLFWgamepadstate* state)
+ *  @endcode
+ *
+ *  @param[in] jid The ID of the game pad that changed state.
+ *  @param[in] state the state of the game pad
+ *
+ *  @sa @ref input_gamepad
+ *  @sa @ref glfwSetGamepadStateCallback
+ *
+ *  @since Added in version 3.4.
+ *  @ingroup input
+ */
+typedef void (* GLFWgamepadstatefun)(int jid, GLFWgamepadstate state);
+
 
 /*************************************************************************
  * GLFW API functions
diff --git a/src/input.c b/src/input.c
index 218b4578..3aff147a 100644
--- a/src/input.c
+++ b/src/input.c
@@ -427,7 +427,7 @@ void _glfwInputGamepad(_GLFWjoystick *js)
         GLFWgamepadstate state;
         if (glfwGetGamepadState(jid, &state))
         {
-            _glfw.callbacks.gamepad_state(jid, state.buttons, state.axes);
+            _glfw.callbacks.gamepad_state(jid, state);
         }
     }
 }
@@ -464,9 +464,7 @@ void _glfwInputJoystickAxis(_GLFWjoystick *js, int axis, float value)
         if (_glfw.callbacks.joystick_axis)
             _glfw.callbacks.joystick_axis(jid, axis, value);
         _glfwInputGamepad(js);
-    }
-    else
-    {
+    } else {
         js->axes[axis] = value;
     }
 }
@@ -479,17 +477,15 @@ void _glfwInputJoystickButton(_GLFWjoystick *js, int button, char value)
     assert(button >= 0);
     assert(button < js->buttonCount);
     assert(value == GLFW_PRESS || value == GLFW_RELEASE);
-    if (js->buttons[button] != value)
-    {
+    
+    if (js->buttons[button] != value) {
         const int jid = (int)(js - _glfw.joysticks);
 
         js->buttons[button] = value;
         if (_glfw.callbacks.joystick_button)
             _glfw.callbacks.joystick_button(jid, button, value);
         _glfwInputGamepad(js);
-    }
-    else
-    {
+    } else {
         js->buttons[button] = value;
     }
 }
@@ -610,7 +606,8 @@ void _glfwPollAllJoysticks()
     {
         if (_glfw.joysticks[jid].connected == GLFW_TRUE)
         {
-            _glfwPlatformPollJoystick(_glfw.joysticks + jid, _GLFW_POLL_ALL);
+            _glfw.platform.pollJoystick(_glfw.joysticks + jid, _GLFW_POLL_ALL);
+            glfwPostEmptyEvent();
         }
     }
 }
@@ -1310,28 +1307,28 @@ GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun cbfun)
 GLFWAPI GLFWgamepadstatefun glfwSetGamepadStateCallback(GLFWgamepadstatefun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    _GLFW_SWAP_POINTERS(_glfw.callbacks.gamepad_state, cbfun);
+    _GLFW_SWAP(GLFWgamepadstatefun, _glfw.callbacks.gamepad_state, cbfun);
     return cbfun;
 }
 
 GLFWAPI GLFWjoystickbuttonfun glfwSetJoystickButtonCallback(GLFWjoystickbuttonfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    _GLFW_SWAP_POINTERS(_glfw.callbacks.joystick_button, cbfun);
+    _GLFW_SWAP(GLFWjoystickbuttonfun, _glfw.callbacks.joystick_button, cbfun);
     return cbfun;
 }
 
 GLFWAPI GLFWjoystickaxisfun glfwSetJoystickAxisCallback(GLFWjoystickaxisfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    _GLFW_SWAP_POINTERS(_glfw.callbacks.joystick_axis, cbfun);
+    _GLFW_SWAP(GLFWjoystickaxisfun, _glfw.callbacks.joystick_axis, cbfun);
     return cbfun;
 }
 
 GLFWAPI GLFWjoystickhatfun glfwSetJoystickHatCallback(GLFWjoystickhatfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    _GLFW_SWAP_POINTERS(_glfw.callbacks.joystick_hat, cbfun);
+    _GLFW_SWAP(GLFWjoystickhatfun, _glfw.callbacks.joystick_hat, cbfun);
     return cbfun;
 }
 
diff --git a/tests/events.c b/tests/events.c
index d849d37d..cfdea0dd 100644
--- a/tests/events.c
+++ b/tests/events.c
@@ -558,7 +558,7 @@ static void joystick_hat_callback(int jid, int hat, int value) {
                value);
 }
 
-static void gamepad_state_callback(int jid, unsigned char buttons[15], float axes[6]) {
+static void gamepad_state_callback(int jid, GLFWgamepadstate state) {
     int i = 0;
     printf("%08x at %0.3f: Gamepad %i (%s) state:",
                counter++, glfwGetTime(),
@@ -567,11 +567,11 @@ static void gamepad_state_callback(int jid, unsigned char buttons[15], float axe
 
     printf("Buttons: ");
     for (i= 0 ; i < 15; i++) {
-      printf(" %d:%d", i, buttons[i]);
+      printf(" %d:%d", i, state.buttons[i]);
     }
     printf("Axes: ");
     for (i= 0 ; i < 6; i++) {
-      printf(" %d:%0.4f", i, axes[i]);
+      printf(" %d:%0.4f", i, state.axes[i]);
     }
     printf("\n");
 

From a06c00215abc85863200dac9bf82e269cc31d175 Mon Sep 17 00:00:00 2001
From: NarrikSynthfox <80410683+NarrikSynthfox@users.noreply.github.com>
Date: Wed, 10 Apr 2024 11:22:59 -0400
Subject: [PATCH 07/11] Fixed issue with bad merge

---
 src/input.c      |  129 ++--
 src/x11_window.c | 1585 +++++++++++++++++++++-------------------------
 2 files changed, 763 insertions(+), 951 deletions(-)

diff --git a/src/input.c b/src/input.c
index 6310b653..7c2a153a 100644
--- a/src/input.c
+++ b/src/input.c
@@ -653,93 +653,80 @@ GLFWAPI void glfwSetInputMode(GLFWwindow *handle, int mode, int value)
 
     switch (mode)
     {
-    case GLFW_CURSOR:
-    {
-        if (value != GLFW_CURSOR_NORMAL &&
-            value != GLFW_CURSOR_HIDDEN &&
-            value != GLFW_CURSOR_DISABLED &&
-            value != GLFW_CURSOR_CAPTURED)
+        case GLFW_CURSOR:
         {
-            _glfwInputError(GLFW_INVALID_ENUM,
-                            "Invalid cursor mode 0x%08X",
-                            value);
-            return;
-        }
-
-        if (window->cursorMode == value)
-            return;
-
-        window->cursorMode = value;
-
-        _glfw.platform.getCursorPos(window,
-                                    &window->virtualCursorPosX,
-                                    &window->virtualCursorPosY);
-        _glfw.platform.setCursorMode(window, value);
-        return;
-    }
-
-    case GLFW_STICKY_KEYS:
-    {
-        value = value ? GLFW_TRUE : GLFW_FALSE;
-        if (window->stickyKeys == value)
-            return;
-
-        if (!value)
-        {
-            int i;
-
-            // Release all sticky keys
-            for (i = 0; i <= GLFW_KEY_LAST; i++)
+            if (value != GLFW_CURSOR_NORMAL &&
+                value != GLFW_CURSOR_HIDDEN &&
+                value != GLFW_CURSOR_DISABLED &&
+                value != GLFW_CURSOR_CAPTURED)
             {
-                if (window->keys[i] == _GLFW_STICK)
-                    window->keys[i] = GLFW_RELEASE;
+                _glfwInputError(GLFW_INVALID_ENUM,
+                                "Invalid cursor mode 0x%08X",
+                                value);
+                return;
             }
+
+            if (window->cursorMode == value)
+                return;
+
+            window->cursorMode = value;
+
+            _glfw.platform.getCursorPos(window,
+                                        &window->virtualCursorPosX,
+                                        &window->virtualCursorPosY);
+            _glfw.platform.setCursorMode(window, value);
+            return;
         }
 
-        window->stickyKeys = value;
-        return;
-    }
-
-    case GLFW_STICKY_MOUSE_BUTTONS:
-    {
-        value = value ? GLFW_TRUE : GLFW_FALSE;
-        if (window->stickyMouseButtons == value)
-            return;
-
-        if (!value)
+        case GLFW_STICKY_KEYS:
         {
-            int i;
+            value = value ? GLFW_TRUE : GLFW_FALSE;
+            if (window->stickyKeys == value)
+                return;
 
-            // Release all sticky mouse buttons
-            for (i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++)
+            if (!value)
             {
-                if (window->mouseButtons[i] == _GLFW_STICK)
-                    window->mouseButtons[i] = GLFW_RELEASE;
+                int i;
+
+                // Release all sticky keys
+                for (i = 0; i <= GLFW_KEY_LAST; i++)
+                {
+                    if (window->keys[i] == _GLFW_STICK)
+                        window->keys[i] = GLFW_RELEASE;
+                }
             }
+
+            window->stickyKeys = value;
+            return;
         }
 
-        window->stickyMouseButtons = value;
-        return;
-    }
-
-    case GLFW_LOCK_KEY_MODS:
-    {
-        window->lockKeyMods = value ? GLFW_TRUE : GLFW_FALSE;
-        return;
-    }
-
-    case GLFW_RAW_MOUSE_MOTION:
-    {
-        if (!_glfw.platform.rawMouseMotionSupported())
+        case GLFW_STICKY_MOUSE_BUTTONS:
         {
-            _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "Raw mouse motion is not supported on this system");
+            value = value ? GLFW_TRUE : GLFW_FALSE;
+            if (window->stickyMouseButtons == value)
+                return;
+
+            if (!value)
+            {
+                int i;
+
+                // Release all sticky mouse buttons
+                for (i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++)
+                {
+                    if (window->mouseButtons[i] == _GLFW_STICK)
+                        window->mouseButtons[i] = GLFW_RELEASE;
+                }
+            }
+
+            window->stickyMouseButtons = value;
             return;
         }
 
-        value = value ? GLFW_TRUE : GLFW_FALSE;
-        if (window->rawMouseMotion == value)
+        case GLFW_LOCK_KEY_MODS:
+        {
+            window->lockKeyMods = value ? GLFW_TRUE : GLFW_FALSE;
             return;
+        }
 
         case GLFW_RAW_MOUSE_MOTION:
         {
diff --git a/src/x11_window.c b/src/x11_window.c
index df82d4c2..322349f0 100644
--- a/src/x11_window.c
+++ b/src/x11_window.c
@@ -42,17 +42,17 @@
 #include <assert.h>
 
 // Action for EWMH client messages
-#define _NET_WM_STATE_REMOVE 0
-#define _NET_WM_STATE_ADD 1
-#define _NET_WM_STATE_TOGGLE 2
+#define _NET_WM_STATE_REMOVE        0
+#define _NET_WM_STATE_ADD           1
+#define _NET_WM_STATE_TOGGLE        2
 
 // Additional mouse button names for XButtonEvent
-#define Button6 6
-#define Button7 7
+#define Button6            6
+#define Button7            7
 
 // Motif WM hints flags
-#define MWM_HINTS_DECORATIONS 2
-#define MWM_DECOR_ALL 1
+#define MWM_HINTS_DECORATIONS   2
+#define MWM_DECOR_ALL           1
 
 #define _GLFW_XDND_VERSION 5
 
@@ -60,9 +60,9 @@
 // This avoids blocking other threads via the per-display Xlib lock that also
 // covers GLX functions
 //
-static GLFWbool waitForX11Event(double *timeout)
+static GLFWbool waitForX11Event(double* timeout)
 {
-    struct pollfd fd = {ConnectionNumber(_glfw.x11.display), POLLIN};
+    struct pollfd fd = { ConnectionNumber(_glfw.x11.display), POLLIN };
 
     while (!XPending(_glfw.x11.display))
     {
@@ -77,7 +77,7 @@ static GLFWbool waitForX11Event(double *timeout)
 // This avoids blocking other threads via the per-display Xlib lock that also
 // covers GLX functions
 //
-static GLFWbool waitForAnyEvent(double *timeout)
+static GLFWbool waitForAnyEvent(double* timeout)
 {
     enum { XLIB_FD, PIPE_FD, INOTIFY_FD };
     struct pollfd fds[] =
@@ -136,7 +136,7 @@ static void drainEmptyEvents(void)
 // Waits until a VisibilityNotify event arrives for the specified window or the
 // timeout period elapses (ICCCM section 4.2.2)
 //
-static GLFWbool waitForVisibilityNotify(_GLFWwindow *window)
+static GLFWbool waitForVisibilityNotify(_GLFWwindow* window)
 {
     XEvent dummy;
     double timeout = 0.1;
@@ -155,11 +155,10 @@ static GLFWbool waitForVisibilityNotify(_GLFWwindow *window)
 
 // Returns whether the window is iconified
 //
-static int getWindowState(_GLFWwindow *window)
+static int getWindowState(_GLFWwindow* window)
 {
     int result = WithdrawnState;
-    struct
-    {
+    struct {
         CARD32 state;
         Window icon;
     } *state = NULL;
@@ -167,7 +166,7 @@ static int getWindowState(_GLFWwindow *window)
     if (_glfwGetWindowPropertyX11(window->x11.handle,
                                   _glfw.x11.WM_STATE,
                                   _glfw.x11.WM_STATE,
-                                  (unsigned char **)&state) >= 2)
+                                  (unsigned char**) &state) >= 2)
     {
         result = state->state;
     }
@@ -180,7 +179,7 @@ static int getWindowState(_GLFWwindow *window)
 
 // Returns whether the event is a selection event
 //
-static Bool isSelectionEvent(Display *display, XEvent *event, XPointer pointer)
+static Bool isSelectionEvent(Display* display, XEvent* event, XPointer pointer)
 {
     if (event->xany.window != _glfw.x11.helperWindowHandle)
         return False;
@@ -192,9 +191,9 @@ static Bool isSelectionEvent(Display *display, XEvent *event, XPointer pointer)
 
 // Returns whether it is a _NET_FRAME_EXTENTS event for the specified window
 //
-static Bool isFrameExtentsEvent(Display *display, XEvent *event, XPointer pointer)
+static Bool isFrameExtentsEvent(Display* display, XEvent* event, XPointer pointer)
 {
-    _GLFWwindow *window = (_GLFWwindow *)pointer;
+    _GLFWwindow* window = (_GLFWwindow*) pointer;
     return event->type == PropertyNotify &&
            event->xproperty.state == PropertyNewValue &&
            event->xproperty.window == window->x11.handle &&
@@ -203,9 +202,9 @@ static Bool isFrameExtentsEvent(Display *display, XEvent *event, XPointer pointe
 
 // Returns whether it is a property event for the specified selection transfer
 //
-static Bool isSelPropNewValueNotify(Display *display, XEvent *event, XPointer pointer)
+static Bool isSelPropNewValueNotify(Display* display, XEvent* event, XPointer pointer)
 {
-    XEvent *notification = (XEvent *)pointer;
+    XEvent* notification = (XEvent*) pointer;
     return event->type == PropertyNotify &&
            event->xproperty.state == PropertyNewValue &&
            event->xproperty.window == notification->xselection.requestor &&
@@ -247,10 +246,10 @@ static int translateKey(int scancode)
 
 // Sends an EWMH or ICCCM event to the window manager
 //
-static void sendEventToWM(_GLFWwindow *window, Atom type,
+static void sendEventToWM(_GLFWwindow* window, Atom type,
                           long a, long b, long c, long d, long e)
 {
-    XEvent event = {ClientMessage};
+    XEvent event = { ClientMessage };
     event.xclient.window = window->x11.handle;
     event.xclient.format = 32; // Data is 32-bit longs
     event.xclient.message_type = type;
@@ -268,9 +267,9 @@ static void sendEventToWM(_GLFWwindow *window, Atom type,
 
 // Updates the normal hints according to the window settings
 //
-static void updateNormalHints(_GLFWwindow *window, int width, int height)
+static void updateNormalHints(_GLFWwindow* window, int width, int height)
 {
-    XSizeHints *hints = XAllocSizeHints();
+    XSizeHints* hints = XAllocSizeHints();
 
     long supplied;
     XGetWMNormalHints(_glfw.x11.display, window->x11.handle, hints, &supplied);
@@ -308,7 +307,7 @@ static void updateNormalHints(_GLFWwindow *window, int width, int height)
         else
         {
             hints->flags |= (PMinSize | PMaxSize);
-            hints->min_width = hints->max_width = width;
+            hints->min_width  = hints->max_width  = width;
             hints->min_height = hints->max_height = height;
         }
     }
@@ -319,7 +318,7 @@ static void updateNormalHints(_GLFWwindow *window, int width, int height)
 
 // Updates the full screen status of the window
 //
-static void updateWindowMode(_GLFWwindow *window)
+static void updateWindowMode(_GLFWwindow* window)
 {
     if (window->monitor)
     {
@@ -368,9 +367,9 @@ static void updateWindowMode(_GLFWwindow *window)
         {
             const unsigned long value = 1;
 
-            XChangeProperty(_glfw.x11.display, window->x11.handle,
+            XChangeProperty(_glfw.x11.display,  window->x11.handle,
                             _glfw.x11.NET_WM_BYPASS_COMPOSITOR, XA_CARDINAL, 32,
-                            PropModeReplace, (unsigned char *)&value, 1);
+                            PropModeReplace, (unsigned char*) &value, 1);
         }
     }
     else
@@ -414,17 +413,18 @@ static void updateWindowMode(_GLFWwindow *window)
 // Decode a Unicode code point from a UTF-8 stream
 // Based on cutef8 by Jeff Bezanson (Public Domain)
 //
-static uint32_t decodeUTF8(const char **s)
+static uint32_t decodeUTF8(const char** s)
 {
     uint32_t codepoint = 0, count = 0;
     static const uint32_t offsets[] =
-        {
-            0x00000000u, 0x00003080u, 0x000e2080u,
-            0x03c82080u, 0xfa082080u, 0x82082080u};
+    {
+        0x00000000u, 0x00003080u, 0x000e2080u,
+        0x03c82080u, 0xfa082080u, 0x82082080u
+    };
 
     do
     {
-        codepoint = (codepoint << 6) + (unsigned char)**s;
+        codepoint = (codepoint << 6) + (unsigned char) **s;
         (*s)++;
         count++;
     } while ((**s & 0xc0) == 0x80);
@@ -435,18 +435,18 @@ static uint32_t decodeUTF8(const char **s)
 
 // Convert the specified Latin-1 string to UTF-8
 //
-static char *convertLatin1toUTF8(const char *source)
+static char* convertLatin1toUTF8(const char* source)
 {
     size_t size = 1;
-    const char *sp;
+    const char* sp;
 
-    for (sp = source; *sp; sp++)
+    for (sp = source;  *sp;  sp++)
         size += (*sp & 0x80) ? 2 : 1;
 
-    char *target = _glfw_calloc(size, 1);
-    char *tp = target;
+    char* target = _glfw_calloc(size, 1);
+    char* tp = target;
 
-    for (sp = source; *sp; sp++)
+    for (sp = source;  *sp;  sp++)
         tp += _glfwEncodeUTF8(tp, *sp);
 
     return target;
@@ -454,7 +454,7 @@ static char *convertLatin1toUTF8(const char *source)
 
 // Updates the cursor image according to its cursor mode
 //
-static void updateCursorImage(_GLFWwindow *window)
+static void updateCursorImage(_GLFWwindow* window)
 {
     if (window->cursorMode == GLFW_CURSOR_NORMAL ||
         window->cursorMode == GLFW_CURSOR_CAPTURED)
@@ -476,7 +476,7 @@ static void updateCursorImage(_GLFWwindow *window)
 
 // Grabs the cursor and confines it to the window
 //
-static void captureCursor(_GLFWwindow *window)
+static void captureCursor(_GLFWwindow* window)
 {
     XGrabPointer(_glfw.x11.display, window->x11.handle, True,
                  ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
@@ -495,10 +495,10 @@ static void releaseCursor(void)
 
 // Enable XI2 raw mouse motion events
 //
-static void enableRawMouseMotion(_GLFWwindow *window)
+static void enableRawMouseMotion(_GLFWwindow* window)
 {
     XIEventMask em;
-    unsigned char mask[XIMaskLen(XI_RawMotion)] = {0};
+    unsigned char mask[XIMaskLen(XI_RawMotion)] = { 0 };
 
     em.deviceid = XIAllMasterDevices;
     em.mask_len = sizeof(mask);
@@ -510,10 +510,10 @@ static void enableRawMouseMotion(_GLFWwindow *window)
 
 // Disable XI2 raw mouse motion events
 //
-static void disableRawMouseMotion(_GLFWwindow *window)
+static void disableRawMouseMotion(_GLFWwindow* window)
 {
     XIEventMask em;
-    unsigned char mask[] = {0};
+    unsigned char mask[] = { 0 };
 
     em.deviceid = XIAllMasterDevices;
     em.mask_len = sizeof(mask);
@@ -524,7 +524,7 @@ static void disableRawMouseMotion(_GLFWwindow *window)
 
 // Apply disabled cursor mode to a focused window
 //
-static void disableCursor(_GLFWwindow *window)
+static void disableCursor(_GLFWwindow* window)
 {
     if (window->rawMouseMotion)
         enableRawMouseMotion(window);
@@ -540,7 +540,7 @@ static void disableCursor(_GLFWwindow *window)
 
 // Exit disabled cursor mode for the specified window
 //
-static void enableCursor(_GLFWwindow *window)
+static void enableCursor(_GLFWwindow* window)
 {
     if (window->rawMouseMotion)
         disableRawMouseMotion(window);
@@ -557,15 +557,15 @@ static void enableCursor(_GLFWwindow *window)
 //
 static void inputContextDestroyCallback(XIC ic, XPointer clientData, XPointer callData)
 {
-    _GLFWwindow *window = (_GLFWwindow *)clientData;
+    _GLFWwindow* window = (_GLFWwindow*) clientData;
     window->x11.ic = NULL;
 }
 
 // Create the X11 window (and its colormap)
 //
-static GLFWbool createNativeWindow(_GLFWwindow *window,
-                                   const _GLFWwndconfig *wndconfig,
-                                   Visual *visual, int depth)
+static GLFWbool createNativeWindow(_GLFWwindow* window,
+                                   const _GLFWwndconfig* wndconfig,
+                                   Visual* visual, int depth)
 {
     int width = wndconfig->width;
     int height = wndconfig->height;
@@ -592,7 +592,7 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
 
     window->x11.transparent = _glfwIsVisualTransparentX11(visual);
 
-    XSetWindowAttributes wa = {0};
+    XSetWindowAttributes wa = { 0 };
     wa.colormap = window->x11.colormap;
     wa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask |
                     PointerMotionMask | ButtonPressMask | ButtonReleaseMask |
@@ -606,8 +606,8 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
                                        _glfw.x11.root,
                                        xpos, ypos,
                                        width, height,
-                                       0,     // Border width
-                                       depth, // Color depth
+                                       0,      // Border width
+                                       depth,  // Color depth
                                        InputOutput,
                                        visual,
                                        CWBorderPixel | CWColormap | CWEventMask,
@@ -625,7 +625,7 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
     XSaveContext(_glfw.x11.display,
                  window->x11.handle,
                  _glfw.x11.context,
-                 (XPointer)window);
+                 (XPointer) window);
 
     if (!wndconfig->decorated)
         _glfwSetWindowDecoratedX11(window, GLFW_FALSE);
@@ -656,16 +656,17 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
         {
             XChangeProperty(_glfw.x11.display, window->x11.handle,
                             _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
-                            PropModeReplace, (unsigned char *)states, count);
+                            PropModeReplace, (unsigned char*) states, count);
         }
     }
 
     // Declare the WM protocols supported by GLFW
     {
         Atom protocols[] =
-            {
-                _glfw.x11.WM_DELETE_WINDOW,
-                _glfw.x11.NET_WM_PING};
+        {
+            _glfw.x11.WM_DELETE_WINDOW,
+            _glfw.x11.NET_WM_PING
+        };
 
         XSetWMProtocols(_glfw.x11.display, window->x11.handle,
                         protocols, sizeof(protocols) / sizeof(Atom));
@@ -675,23 +676,23 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
     {
         const long pid = getpid();
 
-        XChangeProperty(_glfw.x11.display, window->x11.handle,
+        XChangeProperty(_glfw.x11.display,  window->x11.handle,
                         _glfw.x11.NET_WM_PID, XA_CARDINAL, 32,
                         PropModeReplace,
-                        (unsigned char *)&pid, 1);
+                        (unsigned char*) &pid, 1);
     }
 
     if (_glfw.x11.NET_WM_WINDOW_TYPE && _glfw.x11.NET_WM_WINDOW_TYPE_NORMAL)
     {
         Atom type = _glfw.x11.NET_WM_WINDOW_TYPE_NORMAL;
-        XChangeProperty(_glfw.x11.display, window->x11.handle,
+        XChangeProperty(_glfw.x11.display,  window->x11.handle,
                         _glfw.x11.NET_WM_WINDOW_TYPE, XA_ATOM, 32,
-                        PropModeReplace, (unsigned char *)&type, 1);
+                        PropModeReplace, (unsigned char*) &type, 1);
     }
 
     // Set ICCCM WM_HINTS property
     {
-        XWMHints *hints = XAllocWMHints();
+        XWMHints* hints = XAllocWMHints();
         if (!hints)
         {
             _glfwInputError(GLFW_OUT_OF_MEMORY,
@@ -708,7 +709,7 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
 
     // Set ICCCM WM_NORMAL_HINTS property
     {
-        XSizeHints *hints = XAllocSizeHints();
+        XSizeHints* hints = XAllocSizeHints();
         if (!hints)
         {
             _glfwInputError(GLFW_OUT_OF_MEMORY, "X11: Failed to allocate size hints");
@@ -718,7 +719,7 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
         if (!wndconfig->resizable)
         {
             hints->flags |= (PMinSize | PMaxSize);
-            hints->min_width = hints->max_width = width;
+            hints->min_width  = hints->max_width  = width;
             hints->min_height = hints->max_height = height;
         }
 
@@ -740,28 +741,28 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
 
     // Set ICCCM WM_CLASS property
     {
-        XClassHint *hint = XAllocClassHint();
+        XClassHint* hint = XAllocClassHint();
 
         if (strlen(wndconfig->x11.instanceName) &&
             strlen(wndconfig->x11.className))
         {
-            hint->res_name = (char *)wndconfig->x11.instanceName;
-            hint->res_class = (char *)wndconfig->x11.className;
+            hint->res_name = (char*) wndconfig->x11.instanceName;
+            hint->res_class = (char*) wndconfig->x11.className;
         }
         else
         {
-            const char *resourceName = getenv("RESOURCE_NAME");
+            const char* resourceName = getenv("RESOURCE_NAME");
             if (resourceName && strlen(resourceName))
-                hint->res_name = (char *)resourceName;
+                hint->res_name = (char*) resourceName;
             else if (strlen(wndconfig->title))
-                hint->res_name = (char *)wndconfig->title;
+                hint->res_name = (char*) wndconfig->title;
             else
-                hint->res_name = (char *)"glfw-application";
+                hint->res_name = (char*) "glfw-application";
 
             if (strlen(wndconfig->title))
-                hint->res_class = (char *)wndconfig->title;
+                hint->res_class = (char*) wndconfig->title;
             else
-                hint->res_class = (char *)"GLFW-Application";
+                hint->res_class = (char*) "GLFW-Application";
         }
 
         XSetClassHint(_glfw.x11.display, window->x11.handle, hint);
@@ -773,7 +774,7 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
         const Atom version = _GLFW_XDND_VERSION;
         XChangeProperty(_glfw.x11.display, window->x11.handle,
                         _glfw.x11.XdndAware, XA_ATOM, 32,
-                        PropModeReplace, (unsigned char *)&version, 1);
+                        PropModeReplace, (unsigned char*) &version, 1);
     }
 
     if (_glfw.x11.im)
@@ -788,10 +789,10 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
 
 // Set the specified property to the selection converted to the requested target
 //
-static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
+static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
 {
-    char *selectionString = NULL;
-    const Atom formats[] = {_glfw.x11.UTF8_STRING, XA_STRING};
+    char* selectionString = NULL;
+    const Atom formats[] = { _glfw.x11.UTF8_STRING, XA_STRING };
     const int formatCount = sizeof(formats) / sizeof(formats[0]);
 
     if (request->selection == _glfw.x11.PRIMARY)
@@ -810,10 +811,10 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
     {
         // The list of supported targets was requested
 
-        const Atom targets[] = {_glfw.x11.TARGETS,
-                                _glfw.x11.MULTIPLE,
-                                _glfw.x11.UTF8_STRING,
-                                XA_STRING};
+        const Atom targets[] = { _glfw.x11.TARGETS,
+                                 _glfw.x11.MULTIPLE,
+                                 _glfw.x11.UTF8_STRING,
+                                 XA_STRING };
 
         XChangeProperty(_glfw.x11.display,
                         request->requestor,
@@ -821,7 +822,7 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
                         XA_ATOM,
                         32,
                         PropModeReplace,
-                        (unsigned char *)targets,
+                        (unsigned char*) targets,
                         sizeof(targets) / sizeof(targets[0]));
 
         return request->property;
@@ -831,18 +832,18 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
     {
         // Multiple conversions were requested
 
-        Atom *targets;
+        Atom* targets;
         const unsigned long count =
             _glfwGetWindowPropertyX11(request->requestor,
                                       request->property,
                                       _glfw.x11.ATOM_PAIR,
-                                      (unsigned char **)&targets);
+                                      (unsigned char**) &targets);
 
-        for (unsigned long i = 0; i < count; i += 2)
+        for (unsigned long i = 0;  i < count;  i += 2)
         {
             int j;
 
-            for (j = 0; j < formatCount; j++)
+            for (j = 0;  j < formatCount;  j++)
             {
                 if (targets[i] == formats[j])
                     break;
@@ -856,7 +857,7 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
                                 targets[i],
                                 8,
                                 PropModeReplace,
-                                (unsigned char *)selectionString,
+                                (unsigned char *) selectionString,
                                 strlen(selectionString));
             }
             else
@@ -869,7 +870,7 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
                         _glfw.x11.ATOM_PAIR,
                         32,
                         PropModeReplace,
-                        (unsigned char *)targets,
+                        (unsigned char*) targets,
                         count);
 
         XFree(targets);
@@ -896,7 +897,7 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
 
     // Conversion to a data target was requested
 
-    for (int i = 0; i < formatCount; i++)
+    for (int i = 0;  i < formatCount;  i++)
     {
         if (request->target == formats[i])
         {
@@ -908,7 +909,7 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
                             request->target,
                             8,
                             PropModeReplace,
-                            (unsigned char *)selectionString,
+                            (unsigned char *) selectionString,
                             strlen(selectionString));
 
             return request->property;
@@ -920,11 +921,11 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
     return None;
 }
 
-static void handleSelectionRequest(XEvent *event)
+static void handleSelectionRequest(XEvent* event)
 {
-    const XSelectionRequestEvent *request = &event->xselectionrequest;
+    const XSelectionRequestEvent* request = &event->xselectionrequest;
 
-    XEvent reply = {SelectionNotify};
+    XEvent reply = { SelectionNotify };
     reply.xselection.property = writeTargetToProperty(request);
     reply.xselection.display = request->display;
     reply.xselection.requestor = request->requestor;
@@ -935,10 +936,10 @@ static void handleSelectionRequest(XEvent *event)
     XSendEvent(_glfw.x11.display, request->requestor, False, 0, &reply);
 }
 
-static const char *getSelectionString(Atom selection)
+static const char* getSelectionString(Atom selection)
 {
-    char **selectionString = NULL;
-    const Atom targets[] = {_glfw.x11.UTF8_STRING, XA_STRING};
+    char** selectionString = NULL;
+    const Atom targets[] = { _glfw.x11.UTF8_STRING, XA_STRING };
     const size_t targetCount = sizeof(targets) / sizeof(targets[0]);
 
     if (selection == _glfw.x11.PRIMARY)
@@ -957,9 +958,9 @@ static const char *getSelectionString(Atom selection)
     _glfw_free(*selectionString);
     *selectionString = NULL;
 
-    for (size_t i = 0; i < targetCount; i++)
+    for (size_t i = 0;  i < targetCount;  i++)
     {
-        char *data;
+        char* data;
         Atom actualType;
         int actualFormat;
         unsigned long itemCount, bytesAfter;
@@ -986,7 +987,7 @@ static const char *getSelectionString(Atom selection)
         XCheckIfEvent(_glfw.x11.display,
                       &dummy,
                       isSelPropNewValueNotify,
-                      (XPointer)&notification);
+                      (XPointer) &notification);
 
         XGetWindowProperty(_glfw.x11.display,
                            notification.xselection.requestor,
@@ -999,19 +1000,19 @@ static const char *getSelectionString(Atom selection)
                            &actualFormat,
                            &itemCount,
                            &bytesAfter,
-                           (unsigned char **)&data);
+                           (unsigned char**) &data);
 
         if (actualType == _glfw.x11.INCR)
         {
             size_t size = 1;
-            char *string = NULL;
+            char* string = NULL;
 
             for (;;)
             {
                 while (!XCheckIfEvent(_glfw.x11.display,
                                       &dummy,
                                       isSelPropNewValueNotify,
-                                      (XPointer)&notification))
+                                      (XPointer) &notification))
                 {
                     waitForX11Event(NULL);
                 }
@@ -1028,7 +1029,7 @@ static const char *getSelectionString(Atom selection)
                                    &actualFormat,
                                    &itemCount,
                                    &bytesAfter,
-                                   (unsigned char **)&data);
+                                   (unsigned char**) &data);
 
                 if (itemCount)
                 {
@@ -1080,7 +1081,7 @@ static const char *getSelectionString(Atom selection)
 
 // Make the specified window and its video mode active on its monitor
 //
-static void acquireMonitor(_GLFWwindow *window)
+static void acquireMonitor(_GLFWwindow* window)
 {
     if (_glfw.x11.saver.count == 0)
     {
@@ -1119,7 +1120,7 @@ static void acquireMonitor(_GLFWwindow *window)
 
 // Remove the window and restore the original video mode
 //
-static void releaseMonitor(_GLFWwindow *window)
+static void releaseMonitor(_GLFWwindow* window)
 {
     if (window->monitor->window != window)
         return;
@@ -1167,10 +1168,10 @@ static void processEvent(XEvent *event)
     {
         if (event->type == _glfw.x11.xkb.eventBase + XkbEventCode)
         {
-            if (((XkbEvent *)event)->any.xkb_type == XkbStateNotify &&
-                (((XkbEvent *)event)->state.changed & XkbGroupStateMask))
+            if (((XkbEvent*) event)->any.xkb_type == XkbStateNotify &&
+                (((XkbEvent*) event)->state.changed & XkbGroupStateMask))
             {
-                _glfw.x11.xkb.group = ((XkbEvent *)event)->state.group;
+                _glfw.x11.xkb.group = ((XkbEvent*) event)->state.group;
             }
 
             return;
@@ -1181,7 +1182,7 @@ static void processEvent(XEvent *event)
     {
         if (_glfw.x11.xi.available)
         {
-            _GLFWwindow *window = _glfw.x11.disabledCursorWindow;
+            _GLFWwindow* window = _glfw.x11.disabledCursorWindow;
 
             if (window &&
                 window->rawMouseMotion &&
@@ -1189,10 +1190,10 @@ static void processEvent(XEvent *event)
                 XGetEventData(_glfw.x11.display, &event->xcookie) &&
                 event->xcookie.evtype == XI_RawMotion)
             {
-                XIRawEvent *re = event->xcookie.data;
+                XIRawEvent* re = event->xcookie.data;
                 if (re->valuators.mask_len)
                 {
-                    const double *values = re->raw_values;
+                    const double* values = re->raw_values;
                     double xpos = window->virtualCursorPosX;
                     double ypos = window->virtualCursorPosY;
 
@@ -1221,11 +1222,11 @@ static void processEvent(XEvent *event)
         return;
     }
 
-    _GLFWwindow *window = NULL;
+    _GLFWwindow* window = NULL;
     if (XFindContext(_glfw.x11.display,
                      event->xany.window,
                      _glfw.x11.context,
-                     (XPointer *)&window) != 0)
+                     (XPointer*) &window) != 0)
     {
         // This is an event for a window that has already been destroyed
         return;
@@ -1233,385 +1234,128 @@ static void processEvent(XEvent *event)
 
     switch (event->type)
     {
-    case ReparentNotify:
-    {
-        window->x11.parent = event->xreparent.parent;
-        return;
-    }
-
-    case KeyPress:
-    {
-        const int key = translateKey(keycode);
-        const int mods = translateState(event->xkey.state);
-        const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
-
-        if (window->x11.ic)
+        case ReparentNotify:
         {
-            // HACK: Do not report the key press events duplicated by XIM
-            //       Duplicate key releases are filtered out implicitly by
-            //       the GLFW key repeat logic in _glfwInputKey
-            //       A timestamp per key is used to handle simultaneous keys
-            // NOTE: Always allow the first event for each key through
-            //       (the server never sends a timestamp of zero)
-            // NOTE: Timestamp difference is compared to handle wrap-around
-            Time diff = event->xkey.time - window->x11.keyPressTimes[keycode];
-            if (diff == event->xkey.time || (diff > 0 && diff < ((Time)1 << 31)))
+            window->x11.parent = event->xreparent.parent;
+            return;
+        }
+
+        case KeyPress:
+        {
+            const int key = translateKey(keycode);
+            const int mods = translateState(event->xkey.state);
+            const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
+
+            if (window->x11.ic)
             {
-                if (keycode)
-                    _glfwInputKey(window, key, keycode, GLFW_PRESS, mods);
-
-                window->x11.keyPressTimes[keycode] = event->xkey.time;
-            }
-
-            if (!filtered)
-            {
-                int count;
-                Status status;
-                char buffer[100];
-                char *chars = buffer;
-
-                count = Xutf8LookupString(window->x11.ic,
-                                          &event->xkey,
-                                          buffer, sizeof(buffer) - 1,
-                                          NULL, &status);
-
-                if (status == XBufferOverflow)
+                // HACK: Do not report the key press events duplicated by XIM
+                //       Duplicate key releases are filtered out implicitly by
+                //       the GLFW key repeat logic in _glfwInputKey
+                //       A timestamp per key is used to handle simultaneous keys
+                // NOTE: Always allow the first event for each key through
+                //       (the server never sends a timestamp of zero)
+                // NOTE: Timestamp difference is compared to handle wrap-around
+                Time diff = event->xkey.time - window->x11.keyPressTimes[keycode];
+                if (diff == event->xkey.time || (diff > 0 && diff < ((Time)1 << 31)))
                 {
-                    chars = _glfw_calloc(count + 1, 1);
+                    if (keycode)
+                        _glfwInputKey(window, key, keycode, GLFW_PRESS, mods);
+
+                    window->x11.keyPressTimes[keycode] = event->xkey.time;
+                }
+
+                if (!filtered)
+                {
+                    int count;
+                    Status status;
+                    char buffer[100];
+                    char* chars = buffer;
+
                     count = Xutf8LookupString(window->x11.ic,
                                               &event->xkey,
-                                              chars, count,
+                                              buffer, sizeof(buffer) - 1,
                                               NULL, &status);
-                }
 
-                if (status == XLookupChars || status == XLookupBoth)
-                {
-                    const char *c = chars;
-                    chars[count] = '\0';
-                    while (c - chars < count)
-                        _glfwInputChar(window, decodeUTF8(&c), mods, plain);
-                }
-
-                if (chars != buffer)
-                    _glfw_free(chars);
-            }
-        }
-        else
-        {
-            KeySym keysym;
-            XLookupString(&event->xkey, NULL, 0, &keysym, NULL);
-
-            _glfwInputKey(window, key, keycode, GLFW_PRESS, mods);
-
-            const uint32_t codepoint = _glfwKeySym2Unicode(keysym);
-            if (codepoint != GLFW_INVALID_CODEPOINT)
-                _glfwInputChar(window, codepoint, mods, plain);
-        }
-
-        return;
-    }
-
-    case KeyRelease:
-    {
-        const int key = translateKey(keycode);
-        const int mods = translateState(event->xkey.state);
-
-        if (!_glfw.x11.xkb.detectable)
-        {
-            // HACK: Key repeat events will arrive as KeyRelease/KeyPress
-            //       pairs with similar or identical time stamps
-            //       The key repeat logic in _glfwInputKey expects only key
-            //       presses to repeat, so detect and discard release events
-            if (XEventsQueued(_glfw.x11.display, QueuedAfterReading))
-            {
-                XEvent next;
-                XPeekEvent(_glfw.x11.display, &next);
-
-                if (next.type == KeyPress &&
-                    next.xkey.window == event->xkey.window &&
-                    next.xkey.keycode == keycode)
-                {
-                    // HACK: The time of repeat events sometimes doesn't
-                    //       match that of the press event, so add an
-                    //       epsilon
-                    //       Toshiyuki Takahashi can press a button
-                    //       16 times per second so it's fairly safe to
-                    //       assume that no human is pressing the key 50
-                    //       times per second (value is ms)
-                    if ((next.xkey.time - event->xkey.time) < 20)
+                    if (status == XBufferOverflow)
                     {
-                        // This is very likely a server-generated key repeat
-                        // event, so ignore it
-                        return;
+                        chars = _glfw_calloc(count + 1, 1);
+                        count = Xutf8LookupString(window->x11.ic,
+                                                  &event->xkey,
+                                                  chars, count,
+                                                  NULL, &status);
+                    }
+
+                    if (status == XLookupChars || status == XLookupBoth)
+                    {
+                        const char* c = chars;
+                        chars[count] = '\0';
+                        while (c - chars < count)
+                            _glfwInputChar(window, decodeUTF8(&c), mods, plain);
+                    }
+
+                    if (chars != buffer)
+                        _glfw_free(chars);
+                }
+            }
+            else
+            {
+                KeySym keysym;
+                XLookupString(&event->xkey, NULL, 0, &keysym, NULL);
+
+                _glfwInputKey(window, key, keycode, GLFW_PRESS, mods);
+
+                const uint32_t codepoint = _glfwKeySym2Unicode(keysym);
+                if (codepoint != GLFW_INVALID_CODEPOINT)
+                    _glfwInputChar(window, codepoint, mods, plain);
+            }
+
+            return;
+        }
+
+        case KeyRelease:
+        {
+            const int key = translateKey(keycode);
+            const int mods = translateState(event->xkey.state);
+
+            if (!_glfw.x11.xkb.detectable)
+            {
+                // HACK: Key repeat events will arrive as KeyRelease/KeyPress
+                //       pairs with similar or identical time stamps
+                //       The key repeat logic in _glfwInputKey expects only key
+                //       presses to repeat, so detect and discard release events
+                if (XEventsQueued(_glfw.x11.display, QueuedAfterReading))
+                {
+                    XEvent next;
+                    XPeekEvent(_glfw.x11.display, &next);
+
+                    if (next.type == KeyPress &&
+                        next.xkey.window == event->xkey.window &&
+                        next.xkey.keycode == keycode)
+                    {
+                        // HACK: The time of repeat events sometimes doesn't
+                        //       match that of the press event, so add an
+                        //       epsilon
+                        //       Toshiyuki Takahashi can press a button
+                        //       16 times per second so it's fairly safe to
+                        //       assume that no human is pressing the key 50
+                        //       times per second (value is ms)
+                        if ((next.xkey.time - event->xkey.time) < 20)
+                        {
+                            // This is very likely a server-generated key repeat
+                            // event, so ignore it
+                            return;
+                        }
                     }
                 }
             }
-        }
 
-        _glfwInputKey(window, key, keycode, GLFW_RELEASE, mods);
-        return;
-    }
-
-    case ButtonPress:
-    {
-        const int mods = translateState(event->xbutton.state);
-
-        if (event->xbutton.button == Button1)
-            _glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, mods);
-        else if (event->xbutton.button == Button2)
-            _glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_MIDDLE, GLFW_PRESS, mods);
-        else if (event->xbutton.button == Button3)
-            _glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS, mods);
-
-        // Modern X provides scroll events as mouse button presses
-        else if (event->xbutton.button == Button4)
-            _glfwInputScroll(window, 0.0, 1.0);
-        else if (event->xbutton.button == Button5)
-            _glfwInputScroll(window, 0.0, -1.0);
-        else if (event->xbutton.button == Button6)
-            _glfwInputScroll(window, 1.0, 0.0);
-        else if (event->xbutton.button == Button7)
-            _glfwInputScroll(window, -1.0, 0.0);
-
-        else
-        {
-            // Additional buttons after 7 are treated as regular buttons
-            // We subtract 4 to fill the gap left by scroll input above
-            _glfwInputMouseClick(window,
-                                 event->xbutton.button - Button1 - 4,
-                                 GLFW_PRESS,
-                                 mods);
-        }
-
-        return;
-    }
-
-    case ButtonRelease:
-    {
-        const int mods = translateState(event->xbutton.state);
-
-        if (event->xbutton.button == Button1)
-        {
-            _glfwInputMouseClick(window,
-                                 GLFW_MOUSE_BUTTON_LEFT,
-                                 GLFW_RELEASE,
-                                 mods);
-        }
-        else if (event->xbutton.button == Button2)
-        {
-            _glfwInputMouseClick(window,
-                                 GLFW_MOUSE_BUTTON_MIDDLE,
-                                 GLFW_RELEASE,
-                                 mods);
-        }
-        else if (event->xbutton.button == Button3)
-        {
-            _glfwInputMouseClick(window,
-                                 GLFW_MOUSE_BUTTON_RIGHT,
-                                 GLFW_RELEASE,
-                                 mods);
-        }
-        else if (event->xbutton.button > Button7)
-        {
-            // Additional buttons after 7 are treated as regular buttons
-            // We subtract 4 to fill the gap left by scroll input above
-            _glfwInputMouseClick(window,
-                                 event->xbutton.button - Button1 - 4,
-                                 GLFW_RELEASE,
-                                 mods);
-        }
-
-        return;
-    }
-
-    case EnterNotify:
-    {
-        // XEnterWindowEvent is XCrossingEvent
-        const int x = event->xcrossing.x;
-        const int y = event->xcrossing.y;
-
-        // HACK: This is a workaround for WMs (KWM, Fluxbox) that otherwise
-        //       ignore the defined cursor for hidden cursor mode
-        if (window->cursorMode == GLFW_CURSOR_HIDDEN)
-            updateCursorImage(window);
-
-        _glfwInputCursorEnter(window, GLFW_TRUE);
-        _glfwInputCursorPos(window, x, y);
-
-        window->x11.lastCursorPosX = x;
-        window->x11.lastCursorPosY = y;
-        return;
-    }
-
-    case LeaveNotify:
-    {
-        _glfwInputCursorEnter(window, GLFW_FALSE);
-        return;
-    }
-
-    case MotionNotify:
-    {
-        const int x = event->xmotion.x;
-        const int y = event->xmotion.y;
-
-        if (x != window->x11.warpCursorPosX ||
-            y != window->x11.warpCursorPosY)
-        {
-            // The cursor was moved by something other than GLFW
-
-            if (window->cursorMode == GLFW_CURSOR_DISABLED)
-            {
-                if (_glfw.x11.disabledCursorWindow != window)
-                    return;
-                if (window->rawMouseMotion)
-                    return;
-
-                const int dx = x - window->x11.lastCursorPosX;
-                const int dy = y - window->x11.lastCursorPosY;
-
-                _glfwInputCursorPos(window,
-                                    window->virtualCursorPosX + dx,
-                                    window->virtualCursorPosY + dy);
-            }
-            else
-                _glfwInputCursorPos(window, x, y);
-        }
-
-        window->x11.lastCursorPosX = x;
-        window->x11.lastCursorPosY = y;
-        return;
-    }
-
-    case ConfigureNotify:
-    {
-        if (event->xconfigure.width != window->x11.width ||
-            event->xconfigure.height != window->x11.height)
-        {
-            _glfwInputFramebufferSize(window,
-                                      event->xconfigure.width,
-                                      event->xconfigure.height);
-
-            _glfwInputWindowSize(window,
-                                 event->xconfigure.width,
-                                 event->xconfigure.height);
-
-            window->x11.width = event->xconfigure.width;
-            window->x11.height = event->xconfigure.height;
-        }
-
-        int xpos = event->xconfigure.x;
-        int ypos = event->xconfigure.y;
-
-        // NOTE: ConfigureNotify events from the server are in local
-        //       coordinates, so if we are reparented we need to translate
-        //       the position into root (screen) coordinates
-        if (!event->xany.send_event && window->x11.parent != _glfw.x11.root)
-        {
-            _glfwGrabErrorHandlerX11();
-
-            Window dummy;
-            XTranslateCoordinates(_glfw.x11.display,
-                                  window->x11.parent,
-                                  _glfw.x11.root,
-                                  xpos, ypos,
-                                  &xpos, &ypos,
-                                  &dummy);
-
-            _glfwReleaseErrorHandlerX11();
-            if (_glfw.x11.errorCode == BadWindow)
-                return;
-        }
-
-        if (xpos != window->x11.xpos || ypos != window->x11.ypos)
-        {
-            _glfwInputWindowPos(window, xpos, ypos);
-            window->x11.xpos = xpos;
-            window->x11.ypos = ypos;
-        }
-
-        return;
-    }
-
-    case ClientMessage:
-    {
-        // Custom client message, probably from the window manager
-
-        if (filtered)
+            _glfwInputKey(window, key, keycode, GLFW_RELEASE, mods);
             return;
-
-        if (event->xclient.message_type == None)
-            return;
-
-        if (event->xclient.message_type == _glfw.x11.WM_PROTOCOLS)
-        {
-            const Atom protocol = event->xclient.data.l[0];
-            if (protocol == None)
-                return;
-
-            if (protocol == _glfw.x11.WM_DELETE_WINDOW)
-            {
-                // The window manager was asked to close the window, for
-                // example by the user pressing a 'close' window decoration
-                // button
-                _glfwInputWindowCloseRequest(window);
-            }
-            else if (protocol == _glfw.x11.NET_WM_PING)
-            {
-                // The window manager is pinging the application to ensure
-                // it's still responding to events
-
-                XEvent reply = *event;
-                reply.xclient.window = _glfw.x11.root;
-
-                XSendEvent(_glfw.x11.display, _glfw.x11.root,
-                           False,
-                           SubstructureNotifyMask | SubstructureRedirectMask,
-                           &reply);
-            }
         }
-        else if (event->xclient.message_type == _glfw.x11.XdndEnter)
+
+        case ButtonPress:
         {
-            // A drag operation has entered the window
-            unsigned long count;
-            Atom *formats = NULL;
-            const GLFWbool list = event->xclient.data.l[1] & 1;
-
-            _glfw.x11.xdnd.source = event->xclient.data.l[0];
-            _glfw.x11.xdnd.version = event->xclient.data.l[1] >> 24;
-            _glfw.x11.xdnd.format = None;
-
-            if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
-                return;
-
-            if (list)
-            {
-                count = _glfwGetWindowPropertyX11(_glfw.x11.xdnd.source,
-                                                  _glfw.x11.XdndTypeList,
-                                                  XA_ATOM,
-                                                  (unsigned char **)&formats);
-            }
-            else
-            {
-                count = 3;
-                formats = (Atom *)event->xclient.data.l + 2;
-            }
-
-            for (unsigned int i = 0; i < count; i++)
-            {
-                if (formats[i] == _glfw.x11.text_uri_list)
-                {
-                    _glfw.x11.xdnd.format = _glfw.x11.text_uri_list;
-                    break;
-                }
-            }
-
-            if (list && formats)
-                XFree(formats);
-        }
-        else if (event->xclient.message_type == _glfw.x11.XdndDrop)
-        {
-            // The drag operation has finished by dropping on the window
-            Time time = CurrentTime;
+            const int mods = translateState(event->xbutton.state);
 
             if (event->xbutton.button == Button1)
                 _glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, mods);
@@ -1797,221 +1541,299 @@ static void processEvent(XEvent *event)
             if (filtered)
                 return;
 
-            if (_glfw.x11.xdnd.format)
-            {
-                if (_glfw.x11.xdnd.version >= 1)
-                    time = event->xclient.data.l[2];
-
-                // Request the chosen format from the source window
-                XConvertSelection(_glfw.x11.display,
-                                  _glfw.x11.XdndSelection,
-                                  _glfw.x11.xdnd.format,
-                                  _glfw.x11.XdndSelection,
-                                  window->x11.handle,
-                                  time);
-            }
-            else if (_glfw.x11.xdnd.version >= 2)
-            {
-                XEvent reply = {ClientMessage};
-                reply.xclient.window = _glfw.x11.xdnd.source;
-                reply.xclient.message_type = _glfw.x11.XdndFinished;
-                reply.xclient.format = 32;
-                reply.xclient.data.l[0] = window->x11.handle;
-                reply.xclient.data.l[1] = 0; // The drag was rejected
-                reply.xclient.data.l[2] = None;
-
-                XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
-                           False, NoEventMask, &reply);
-                XFlush(_glfw.x11.display);
-            }
-        }
-        else if (event->xclient.message_type == _glfw.x11.XdndPosition)
-        {
-            // The drag operation has moved over the window
-            const int xabs = (event->xclient.data.l[2] >> 16) & 0xffff;
-            const int yabs = (event->xclient.data.l[2]) & 0xffff;
-            Window dummy;
-            int xpos, ypos;
-
-            if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
+            if (event->xclient.message_type == None)
                 return;
 
-            XTranslateCoordinates(_glfw.x11.display,
-                                  _glfw.x11.root,
-                                  window->x11.handle,
-                                  xabs, yabs,
-                                  &xpos, &ypos,
-                                  &dummy);
-
-            _glfwInputCursorPos(window, xpos, ypos);
-
-            XEvent reply = {ClientMessage};
-            reply.xclient.window = _glfw.x11.xdnd.source;
-            reply.xclient.message_type = _glfw.x11.XdndStatus;
-            reply.xclient.format = 32;
-            reply.xclient.data.l[0] = window->x11.handle;
-            reply.xclient.data.l[2] = 0; // Specify an empty rectangle
-            reply.xclient.data.l[3] = 0;
-
-            if (_glfw.x11.xdnd.format)
+            if (event->xclient.message_type == _glfw.x11.WM_PROTOCOLS)
             {
-                // Reply that we are ready to copy the dragged data
-                reply.xclient.data.l[1] = 1; // Accept with no rectangle
-                if (_glfw.x11.xdnd.version >= 2)
-                    reply.xclient.data.l[4] = _glfw.x11.XdndActionCopy;
-            }
+                const Atom protocol = event->xclient.data.l[0];
+                if (protocol == None)
+                    return;
 
-            XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
-                       False, NoEventMask, &reply);
-            XFlush(_glfw.x11.display);
-        }
-
-        return;
-    }
-
-    case SelectionNotify:
-    {
-        if (event->xselection.property == _glfw.x11.XdndSelection)
-        {
-            // The converted data from the drag operation has arrived
-            char *data;
-            const unsigned long result =
-                _glfwGetWindowPropertyX11(event->xselection.requestor,
-                                          event->xselection.property,
-                                          event->xselection.target,
-                                          (unsigned char **)&data);
-
-            if (result)
-            {
-                int count;
-                char **paths = _glfwParseUriList(data, &count);
-
-                _glfwInputDrop(window, count, (const char **)paths);
-
-                for (int i = 0; i < count; i++)
-                    _glfw_free(paths[i]);
-                _glfw_free(paths);
-            }
-
-            if (data)
-                XFree(data);
-
-            if (_glfw.x11.xdnd.version >= 2)
-            {
-                XEvent reply = {ClientMessage};
-                reply.xclient.window = _glfw.x11.xdnd.source;
-                reply.xclient.message_type = _glfw.x11.XdndFinished;
-                reply.xclient.format = 32;
-                reply.xclient.data.l[0] = window->x11.handle;
-                reply.xclient.data.l[1] = result;
-                reply.xclient.data.l[2] = _glfw.x11.XdndActionCopy;
-
-                XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
-                           False, NoEventMask, &reply);
-                XFlush(_glfw.x11.display);
-            }
-        }
-
-        return;
-    }
-
-    case FocusIn:
-    {
-        if (event->xfocus.mode == NotifyGrab ||
-            event->xfocus.mode == NotifyUngrab)
-        {
-            // Ignore focus events from popup indicator windows, window menu
-            // key chords and window dragging
-            return;
-        }
-
-        if (window->cursorMode == GLFW_CURSOR_DISABLED)
-            disableCursor(window);
-        else if (window->cursorMode == GLFW_CURSOR_CAPTURED)
-            captureCursor(window);
-
-        if (window->x11.ic)
-            XSetICFocus(window->x11.ic);
-
-        _glfwInputWindowFocus(window, GLFW_TRUE);
-        return;
-    }
-
-    case FocusOut:
-    {
-        if (event->xfocus.mode == NotifyGrab ||
-            event->xfocus.mode == NotifyUngrab)
-        {
-            // Ignore focus events from popup indicator windows, window menu
-            // key chords and window dragging
-            return;
-        }
-
-        if (window->cursorMode == GLFW_CURSOR_DISABLED)
-            enableCursor(window);
-        else if (window->cursorMode == GLFW_CURSOR_CAPTURED)
-            releaseCursor();
-
-        if (window->x11.ic)
-            XUnsetICFocus(window->x11.ic);
-
-        if (window->monitor && window->autoIconify)
-            _glfwIconifyWindowX11(window);
-
-        _glfwInputWindowFocus(window, GLFW_FALSE);
-        return;
-    }
-
-    case Expose:
-    {
-        _glfwInputWindowDamage(window);
-        return;
-    }
-
-    case PropertyNotify:
-    {
-        if (event->xproperty.state != PropertyNewValue)
-            return;
-
-        if (event->xproperty.atom == _glfw.x11.WM_STATE)
-        {
-            const int state = getWindowState(window);
-            if (state != IconicState && state != NormalState)
-                return;
-
-            const GLFWbool iconified = (state == IconicState);
-            if (window->x11.iconified != iconified)
-            {
-                if (window->monitor)
+                if (protocol == _glfw.x11.WM_DELETE_WINDOW)
                 {
-                    if (iconified)
-                        releaseMonitor(window);
-                    else
-                        acquireMonitor(window);
+                    // The window manager was asked to close the window, for
+                    // example by the user pressing a 'close' window decoration
+                    // button
+                    _glfwInputWindowCloseRequest(window);
+                }
+                else if (protocol == _glfw.x11.NET_WM_PING)
+                {
+                    // The window manager is pinging the application to ensure
+                    // it's still responding to events
+
+                    XEvent reply = *event;
+                    reply.xclient.window = _glfw.x11.root;
+
+                    XSendEvent(_glfw.x11.display, _glfw.x11.root,
+                               False,
+                               SubstructureNotifyMask | SubstructureRedirectMask,
+                               &reply);
+                }
+            }
+            else if (event->xclient.message_type == _glfw.x11.XdndEnter)
+            {
+                // A drag operation has entered the window
+                unsigned long count;
+                Atom* formats = NULL;
+                const GLFWbool list = event->xclient.data.l[1] & 1;
+
+                _glfw.x11.xdnd.source  = event->xclient.data.l[0];
+                _glfw.x11.xdnd.version = event->xclient.data.l[1] >> 24;
+                _glfw.x11.xdnd.format  = None;
+
+                if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
+                    return;
+
+                if (list)
+                {
+                    count = _glfwGetWindowPropertyX11(_glfw.x11.xdnd.source,
+                                                      _glfw.x11.XdndTypeList,
+                                                      XA_ATOM,
+                                                      (unsigned char**) &formats);
+                }
+                else
+                {
+                    count = 3;
+                    formats = (Atom*) event->xclient.data.l + 2;
                 }
 
-                window->x11.iconified = iconified;
-                _glfwInputWindowIconify(window, iconified);
+                for (unsigned int i = 0;  i < count;  i++)
+                {
+                    if (formats[i] == _glfw.x11.text_uri_list)
+                    {
+                        _glfw.x11.xdnd.format = _glfw.x11.text_uri_list;
+                        break;
+                    }
+                }
+
+                if (list && formats)
+                    XFree(formats);
             }
-        }
-        else if (event->xproperty.atom == _glfw.x11.NET_WM_STATE)
-        {
-            const GLFWbool maximized = _glfwWindowMaximizedX11(window);
-            if (window->x11.maximized != maximized)
+            else if (event->xclient.message_type == _glfw.x11.XdndDrop)
             {
-                window->x11.maximized = maximized;
-                _glfwInputWindowMaximize(window, maximized);
+                // The drag operation has finished by dropping on the window
+                Time time = CurrentTime;
+
+                if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
+                    return;
+
+                if (_glfw.x11.xdnd.format)
+                {
+                    if (_glfw.x11.xdnd.version >= 1)
+                        time = event->xclient.data.l[2];
+
+                    // Request the chosen format from the source window
+                    XConvertSelection(_glfw.x11.display,
+                                      _glfw.x11.XdndSelection,
+                                      _glfw.x11.xdnd.format,
+                                      _glfw.x11.XdndSelection,
+                                      window->x11.handle,
+                                      time);
+                }
+                else if (_glfw.x11.xdnd.version >= 2)
+                {
+                    XEvent reply = { ClientMessage };
+                    reply.xclient.window = _glfw.x11.xdnd.source;
+                    reply.xclient.message_type = _glfw.x11.XdndFinished;
+                    reply.xclient.format = 32;
+                    reply.xclient.data.l[0] = window->x11.handle;
+                    reply.xclient.data.l[1] = 0; // The drag was rejected
+                    reply.xclient.data.l[2] = None;
+
+                    XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
+                               False, NoEventMask, &reply);
+                    XFlush(_glfw.x11.display);
+                }
             }
+            else if (event->xclient.message_type == _glfw.x11.XdndPosition)
+            {
+                // The drag operation has moved over the window
+                const int xabs = (event->xclient.data.l[2] >> 16) & 0xffff;
+                const int yabs = (event->xclient.data.l[2]) & 0xffff;
+                Window dummy;
+                int xpos, ypos;
+
+                if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
+                    return;
+
+                XTranslateCoordinates(_glfw.x11.display,
+                                      _glfw.x11.root,
+                                      window->x11.handle,
+                                      xabs, yabs,
+                                      &xpos, &ypos,
+                                      &dummy);
+
+                _glfwInputCursorPos(window, xpos, ypos);
+
+                XEvent reply = { ClientMessage };
+                reply.xclient.window = _glfw.x11.xdnd.source;
+                reply.xclient.message_type = _glfw.x11.XdndStatus;
+                reply.xclient.format = 32;
+                reply.xclient.data.l[0] = window->x11.handle;
+                reply.xclient.data.l[2] = 0; // Specify an empty rectangle
+                reply.xclient.data.l[3] = 0;
+
+                if (_glfw.x11.xdnd.format)
+                {
+                    // Reply that we are ready to copy the dragged data
+                    reply.xclient.data.l[1] = 1; // Accept with no rectangle
+                    if (_glfw.x11.xdnd.version >= 2)
+                        reply.xclient.data.l[4] = _glfw.x11.XdndActionCopy;
+                }
+
+                XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
+                           False, NoEventMask, &reply);
+                XFlush(_glfw.x11.display);
+            }
+
+            return;
         }
 
-        return;
-    }
+        case SelectionNotify:
+        {
+            if (event->xselection.property == _glfw.x11.XdndSelection)
+            {
+                // The converted data from the drag operation has arrived
+                char* data;
+                const unsigned long result =
+                    _glfwGetWindowPropertyX11(event->xselection.requestor,
+                                              event->xselection.property,
+                                              event->xselection.target,
+                                              (unsigned char**) &data);
 
-    case DestroyNotify:
-        return;
+                if (result)
+                {
+                    int count;
+                    char** paths = _glfwParseUriList(data, &count);
+
+                    _glfwInputDrop(window, count, (const char**) paths);
+
+                    for (int i = 0;  i < count;  i++)
+                        _glfw_free(paths[i]);
+                    _glfw_free(paths);
+                }
+
+                if (data)
+                    XFree(data);
+
+                if (_glfw.x11.xdnd.version >= 2)
+                {
+                    XEvent reply = { ClientMessage };
+                    reply.xclient.window = _glfw.x11.xdnd.source;
+                    reply.xclient.message_type = _glfw.x11.XdndFinished;
+                    reply.xclient.format = 32;
+                    reply.xclient.data.l[0] = window->x11.handle;
+                    reply.xclient.data.l[1] = result;
+                    reply.xclient.data.l[2] = _glfw.x11.XdndActionCopy;
+
+                    XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
+                               False, NoEventMask, &reply);
+                    XFlush(_glfw.x11.display);
+                }
+            }
+
+            return;
+        }
+
+        case FocusIn:
+        {
+            if (event->xfocus.mode == NotifyGrab ||
+                event->xfocus.mode == NotifyUngrab)
+            {
+                // Ignore focus events from popup indicator windows, window menu
+                // key chords and window dragging
+                return;
+            }
+
+            if (window->cursorMode == GLFW_CURSOR_DISABLED)
+                disableCursor(window);
+            else if (window->cursorMode == GLFW_CURSOR_CAPTURED)
+                captureCursor(window);
+
+            if (window->x11.ic)
+                XSetICFocus(window->x11.ic);
+
+            _glfwInputWindowFocus(window, GLFW_TRUE);
+            return;
+        }
+
+        case FocusOut:
+        {
+            if (event->xfocus.mode == NotifyGrab ||
+                event->xfocus.mode == NotifyUngrab)
+            {
+                // Ignore focus events from popup indicator windows, window menu
+                // key chords and window dragging
+                return;
+            }
+
+            if (window->cursorMode == GLFW_CURSOR_DISABLED)
+                enableCursor(window);
+            else if (window->cursorMode == GLFW_CURSOR_CAPTURED)
+                releaseCursor();
+
+            if (window->x11.ic)
+                XUnsetICFocus(window->x11.ic);
+
+            if (window->monitor && window->autoIconify)
+                _glfwIconifyWindowX11(window);
+
+            _glfwInputWindowFocus(window, GLFW_FALSE);
+            return;
+        }
+
+        case Expose:
+        {
+            _glfwInputWindowDamage(window);
+            return;
+        }
+
+        case PropertyNotify:
+        {
+            if (event->xproperty.state != PropertyNewValue)
+                return;
+
+            if (event->xproperty.atom == _glfw.x11.WM_STATE)
+            {
+                const int state = getWindowState(window);
+                if (state != IconicState && state != NormalState)
+                    return;
+
+                const GLFWbool iconified = (state == IconicState);
+                if (window->x11.iconified != iconified)
+                {
+                    if (window->monitor)
+                    {
+                        if (iconified)
+                            releaseMonitor(window);
+                        else
+                            acquireMonitor(window);
+                    }
+
+                    window->x11.iconified = iconified;
+                    _glfwInputWindowIconify(window, iconified);
+                }
+            }
+            else if (event->xproperty.atom == _glfw.x11.NET_WM_STATE)
+            {
+                const GLFWbool maximized = _glfwWindowMaximizedX11(window);
+                if (window->x11.maximized != maximized)
+                {
+                    window->x11.maximized = maximized;
+                    _glfwInputWindowMaximize(window, maximized);
+                }
+            }
+
+            return;
+        }
+
+        case DestroyNotify:
+            return;
     }
 }
 
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
@@ -2022,7 +1844,7 @@ static void processEvent(XEvent *event)
 unsigned long _glfwGetWindowPropertyX11(Window window,
                                         Atom property,
                                         Atom type,
-                                        unsigned char **value)
+                                        unsigned char** value)
 {
     Atom actualType;
     int actualFormat;
@@ -2044,12 +1866,12 @@ unsigned long _glfwGetWindowPropertyX11(Window window,
     return itemCount;
 }
 
-GLFWbool _glfwIsVisualTransparentX11(Visual *visual)
+GLFWbool _glfwIsVisualTransparentX11(Visual* visual)
 {
     if (!_glfw.x11.xrender.available)
         return GLFW_FALSE;
 
-    XRenderPictFormat *pf = XRenderFindVisualFormat(_glfw.x11.display, visual);
+    XRenderPictFormat* pf = XRenderFindVisualFormat(_glfw.x11.display, visual);
     return pf && pf->direct.alphaMask;
 }
 
@@ -2072,24 +1894,24 @@ void _glfwPushSelectionToManagerX11(void)
         {
             switch (event.type)
             {
-            case SelectionRequest:
-                handleSelectionRequest(&event);
-                break;
+                case SelectionRequest:
+                    handleSelectionRequest(&event);
+                    break;
 
-            case SelectionNotify:
-            {
-                if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
+                case SelectionNotify:
                 {
-                    // This means one of two things; either the selection
-                    // was not owned, which means there is no clipboard
-                    // manager, or the transfer to the clipboard manager has
-                    // completed
-                    // In either case, it means we are done here
-                    return;
-                }
+                    if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
+                    {
+                        // This means one of two things; either the selection
+                        // was not owned, which means there is no clipboard
+                        // manager, or the transfer to the clipboard manager has
+                        // completed
+                        // In either case, it means we are done here
+                        return;
+                    }
 
-                break;
-            }
+                    break;
+                }
             }
         }
 
@@ -2097,11 +1919,11 @@ void _glfwPushSelectionToManagerX11(void)
     }
 }
 
-void _glfwCreateInputContextX11(_GLFWwindow *window)
+void _glfwCreateInputContextX11(_GLFWwindow* window)
 {
     XIMCallback callback;
-    callback.callback = (XIMProc)inputContextDestroyCallback;
-    callback.client_data = (XPointer)window;
+    callback.callback = (XIMProc) inputContextDestroyCallback;
+    callback.client_data = (XPointer) window;
 
     window->x11.ic = XCreateIC(_glfw.x11.im,
                                XNInputStyle,
@@ -2129,16 +1951,17 @@ void _glfwCreateInputContextX11(_GLFWwindow *window)
     }
 }
 
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWbool _glfwCreateWindowX11(_GLFWwindow *window,
-                              const _GLFWwndconfig *wndconfig,
-                              const _GLFWctxconfig *ctxconfig,
-                              const _GLFWfbconfig *fbconfig)
+GLFWbool _glfwCreateWindowX11(_GLFWwindow* window,
+                              const _GLFWwndconfig* wndconfig,
+                              const _GLFWctxconfig* ctxconfig,
+                              const _GLFWfbconfig* fbconfig)
 {
-    Visual *visual = NULL;
+    Visual* visual = NULL;
     int depth;
 
     if (ctxconfig->client != GLFW_NO_API)
@@ -2221,7 +2044,7 @@ GLFWbool _glfwCreateWindowX11(_GLFWwindow *window,
     return GLFW_TRUE;
 }
 
-void _glfwDestroyWindowX11(_GLFWwindow *window)
+void _glfwDestroyWindowX11(_GLFWwindow* window)
 {
     if (_glfw.x11.disabledCursorWindow == window)
         enableCursor(window);
@@ -2243,19 +2066,19 @@ void _glfwDestroyWindowX11(_GLFWwindow *window)
         XDeleteContext(_glfw.x11.display, window->x11.handle, _glfw.x11.context);
         XUnmapWindow(_glfw.x11.display, window->x11.handle);
         XDestroyWindow(_glfw.x11.display, window->x11.handle);
-        window->x11.handle = (Window)0;
+        window->x11.handle = (Window) 0;
     }
 
     if (window->x11.colormap)
     {
         XFreeColormap(_glfw.x11.display, window->x11.colormap);
-        window->x11.colormap = (Colormap)0;
+        window->x11.colormap = (Colormap) 0;
     }
 
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowTitleX11(_GLFWwindow *window, const char *title)
+void _glfwSetWindowTitleX11(_GLFWwindow* window, const char* title)
 {
     if (_glfw.x11.xlib.utf8)
     {
@@ -2266,42 +2089,42 @@ void _glfwSetWindowTitleX11(_GLFWwindow *window, const char *title)
                              NULL, NULL, NULL);
     }
 
-    XChangeProperty(_glfw.x11.display, window->x11.handle,
+    XChangeProperty(_glfw.x11.display,  window->x11.handle,
                     _glfw.x11.NET_WM_NAME, _glfw.x11.UTF8_STRING, 8,
                     PropModeReplace,
-                    (unsigned char *)title, strlen(title));
+                    (unsigned char*) title, strlen(title));
 
-    XChangeProperty(_glfw.x11.display, window->x11.handle,
+    XChangeProperty(_glfw.x11.display,  window->x11.handle,
                     _glfw.x11.NET_WM_ICON_NAME, _glfw.x11.UTF8_STRING, 8,
                     PropModeReplace,
-                    (unsigned char *)title, strlen(title));
+                    (unsigned char*) title, strlen(title));
 
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowIconX11(_GLFWwindow *window, int count, const GLFWimage *images)
+void _glfwSetWindowIconX11(_GLFWwindow* window, int count, const GLFWimage* images)
 {
     if (count)
     {
         int longCount = 0;
 
-        for (int i = 0; i < count; i++)
+        for (int i = 0;  i < count;  i++)
             longCount += 2 + images[i].width * images[i].height;
 
-        unsigned long *icon = _glfw_calloc(longCount, sizeof(unsigned long));
-        unsigned long *target = icon;
+        unsigned long* icon = _glfw_calloc(longCount, sizeof(unsigned long));
+        unsigned long* target = icon;
 
-        for (int i = 0; i < count; i++)
+        for (int i = 0;  i < count;  i++)
         {
             *target++ = images[i].width;
             *target++ = images[i].height;
 
-            for (int j = 0; j < images[i].width * images[i].height; j++)
+            for (int j = 0;  j < images[i].width * images[i].height;  j++)
             {
-                *target++ = (((unsigned long)images[i].pixels[j * 4 + 0]) << 16) |
-                            (((unsigned long)images[i].pixels[j * 4 + 1]) << 8) |
-                            (((unsigned long)images[i].pixels[j * 4 + 2]) << 0) |
-                            (((unsigned long)images[i].pixels[j * 4 + 3]) << 24);
+                *target++ = (((unsigned long) images[i].pixels[j * 4 + 0]) << 16) |
+                            (((unsigned long) images[i].pixels[j * 4 + 1]) <<  8) |
+                            (((unsigned long) images[i].pixels[j * 4 + 2]) <<  0) |
+                            (((unsigned long) images[i].pixels[j * 4 + 3]) << 24);
             }
         }
 
@@ -2315,7 +2138,7 @@ void _glfwSetWindowIconX11(_GLFWwindow *window, int count, const GLFWimage *imag
                         _glfw.x11.NET_WM_ICON,
                         XA_CARDINAL, 32,
                         PropModeReplace,
-                        (unsigned char *)icon,
+                        (unsigned char*) icon,
                         longCount);
 
         _glfw_free(icon);
@@ -2329,7 +2152,7 @@ void _glfwSetWindowIconX11(_GLFWwindow *window, int count, const GLFWimage *imag
     XFlush(_glfw.x11.display);
 }
 
-void _glfwGetWindowPosX11(_GLFWwindow *window, int *xpos, int *ypos)
+void _glfwGetWindowPosX11(_GLFWwindow* window, int* xpos, int* ypos)
 {
     Window dummy;
     int x, y;
@@ -2343,14 +2166,14 @@ void _glfwGetWindowPosX11(_GLFWwindow *window, int *xpos, int *ypos)
         *ypos = y;
 }
 
-void _glfwSetWindowPosX11(_GLFWwindow *window, int xpos, int ypos)
+void _glfwSetWindowPosX11(_GLFWwindow* window, int xpos, int ypos)
 {
     // HACK: Explicitly setting PPosition to any value causes some WMs, notably
     //       Compiz and Metacity, to honor the position of unmapped windows
     if (!_glfwWindowVisibleX11(window))
     {
         long supplied;
-        XSizeHints *hints = XAllocSizeHints();
+        XSizeHints* hints = XAllocSizeHints();
 
         if (XGetWMNormalHints(_glfw.x11.display, window->x11.handle, hints, &supplied))
         {
@@ -2367,7 +2190,7 @@ void _glfwSetWindowPosX11(_GLFWwindow *window, int xpos, int ypos)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwGetWindowSizeX11(_GLFWwindow *window, int *width, int *height)
+void _glfwGetWindowSizeX11(_GLFWwindow* window, int* width, int* height)
 {
     XWindowAttributes attribs;
     XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &attribs);
@@ -2378,7 +2201,7 @@ void _glfwGetWindowSizeX11(_GLFWwindow *window, int *width, int *height)
         *height = attribs.height;
 }
 
-void _glfwSetWindowSizeX11(_GLFWwindow *window, int width, int height)
+void _glfwSetWindowSizeX11(_GLFWwindow* window, int width, int height)
 {
     if (window->monitor)
     {
@@ -2396,7 +2219,7 @@ void _glfwSetWindowSizeX11(_GLFWwindow *window, int width, int height)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowSizeLimitsX11(_GLFWwindow *window,
+void _glfwSetWindowSizeLimitsX11(_GLFWwindow* window,
                                  int minwidth, int minheight,
                                  int maxwidth, int maxheight)
 {
@@ -2406,7 +2229,7 @@ void _glfwSetWindowSizeLimitsX11(_GLFWwindow *window,
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowAspectRatioX11(_GLFWwindow *window, int numer, int denom)
+void _glfwSetWindowAspectRatioX11(_GLFWwindow* window, int numer, int denom)
 {
     int width, height;
     _glfwGetWindowSizeX11(window, &width, &height);
@@ -2414,16 +2237,16 @@ void _glfwSetWindowAspectRatioX11(_GLFWwindow *window, int numer, int denom)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwGetFramebufferSizeX11(_GLFWwindow *window, int *width, int *height)
+void _glfwGetFramebufferSizeX11(_GLFWwindow* window, int* width, int* height)
 {
     _glfwGetWindowSizeX11(window, width, height);
 }
 
-void _glfwGetWindowFrameSizeX11(_GLFWwindow *window,
-                                int *left, int *top,
-                                int *right, int *bottom)
+void _glfwGetWindowFrameSizeX11(_GLFWwindow* window,
+                                int* left, int* top,
+                                int* right, int* bottom)
 {
-    long *extents = NULL;
+    long* extents = NULL;
 
     if (window->monitor || !window->decorated)
         return;
@@ -2450,7 +2273,7 @@ void _glfwGetWindowFrameSizeX11(_GLFWwindow *window,
         while (!XCheckIfEvent(_glfw.x11.display,
                               &event,
                               isFrameExtentsEvent,
-                              (XPointer)window))
+                              (XPointer) window))
         {
             if (!waitForX11Event(&timeout))
             {
@@ -2464,7 +2287,7 @@ void _glfwGetWindowFrameSizeX11(_GLFWwindow *window,
     if (_glfwGetWindowPropertyX11(window->x11.handle,
                                   _glfw.x11.NET_FRAME_EXTENTS,
                                   XA_CARDINAL,
-                                  (unsigned char **)&extents) == 4)
+                                  (unsigned char**) &extents) == 4)
     {
         if (left)
             *left = extents[0];
@@ -2480,7 +2303,7 @@ void _glfwGetWindowFrameSizeX11(_GLFWwindow *window,
         XFree(extents);
 }
 
-void _glfwGetWindowContentScaleX11(_GLFWwindow *window, float *xscale, float *yscale)
+void _glfwGetWindowContentScaleX11(_GLFWwindow* window, float* xscale, float* yscale)
 {
     if (xscale)
         *xscale = _glfw.x11.contentScaleX;
@@ -2488,7 +2311,7 @@ void _glfwGetWindowContentScaleX11(_GLFWwindow *window, float *xscale, float *ys
         *yscale = _glfw.x11.contentScaleY;
 }
 
-void _glfwIconifyWindowX11(_GLFWwindow *window)
+void _glfwIconifyWindowX11(_GLFWwindow* window)
 {
     if (window->x11.overrideRedirect)
     {
@@ -2503,7 +2326,7 @@ void _glfwIconifyWindowX11(_GLFWwindow *window)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwRestoreWindowX11(_GLFWwindow *window)
+void _glfwRestoreWindowX11(_GLFWwindow* window)
 {
     if (window->x11.overrideRedirect)
     {
@@ -2537,7 +2360,7 @@ void _glfwRestoreWindowX11(_GLFWwindow *window)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwMaximizeWindowX11(_GLFWwindow *window)
+void _glfwMaximizeWindowX11(_GLFWwindow* window)
 {
     if (!_glfw.x11.NET_WM_STATE ||
         !_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
@@ -2549,33 +2372,34 @@ void _glfwMaximizeWindowX11(_GLFWwindow *window)
     if (_glfwWindowVisibleX11(window))
     {
         sendEventToWM(window,
-                      _glfw.x11.NET_WM_STATE,
-                      _NET_WM_STATE_ADD,
-                      _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
-                      _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ,
-                      1, 0);
+                    _glfw.x11.NET_WM_STATE,
+                    _NET_WM_STATE_ADD,
+                    _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
+                    _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ,
+                    1, 0);
     }
     else
     {
-        Atom *states = NULL;
+        Atom* states = NULL;
         unsigned long count =
             _glfwGetWindowPropertyX11(window->x11.handle,
                                       _glfw.x11.NET_WM_STATE,
                                       XA_ATOM,
-                                      (unsigned char **)&states);
+                                      (unsigned char**) &states);
 
         // NOTE: We don't check for failure as this property may not exist yet
         //       and that's fine (and we'll create it implicitly with append)
 
         Atom missing[2] =
-            {
-                _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
-                _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ};
+        {
+            _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
+            _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ
+        };
         unsigned long missingCount = 2;
 
-        for (unsigned long i = 0; i < count; i++)
+        for (unsigned long i = 0;  i < count;  i++)
         {
-            for (unsigned long j = 0; j < missingCount; j++)
+            for (unsigned long j = 0;  j < missingCount;  j++)
             {
                 if (states[i] == missing[j])
                 {
@@ -2594,14 +2418,14 @@ void _glfwMaximizeWindowX11(_GLFWwindow *window)
         XChangeProperty(_glfw.x11.display, window->x11.handle,
                         _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
                         PropModeAppend,
-                        (unsigned char *)missing,
+                        (unsigned char*) missing,
                         missingCount);
     }
 
     XFlush(_glfw.x11.display);
 }
 
-void _glfwShowWindowX11(_GLFWwindow *window)
+void _glfwShowWindowX11(_GLFWwindow* window)
 {
     if (_glfwWindowVisibleX11(window))
         return;
@@ -2610,13 +2434,13 @@ void _glfwShowWindowX11(_GLFWwindow *window)
     waitForVisibilityNotify(window);
 }
 
-void _glfwHideWindowX11(_GLFWwindow *window)
+void _glfwHideWindowX11(_GLFWwindow* window)
 {
     XUnmapWindow(_glfw.x11.display, window->x11.handle);
     XFlush(_glfw.x11.display);
 }
 
-void _glfwRequestWindowAttentionX11(_GLFWwindow *window)
+void _glfwRequestWindowAttentionX11(_GLFWwindow* window)
 {
     if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_DEMANDS_ATTENTION)
         return;
@@ -2628,7 +2452,7 @@ void _glfwRequestWindowAttentionX11(_GLFWwindow *window)
                   0, 1, 0);
 }
 
-void _glfwFocusWindowX11(_GLFWwindow *window)
+void _glfwFocusWindowX11(_GLFWwindow* window)
 {
     if (_glfw.x11.NET_ACTIVE_WINDOW)
         sendEventToWM(window, _glfw.x11.NET_ACTIVE_WINDOW, 1, 0, 0, 0, 0);
@@ -2642,8 +2466,8 @@ void _glfwFocusWindowX11(_GLFWwindow *window)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowMonitorX11(_GLFWwindow *window,
-                              _GLFWmonitor *monitor,
+void _glfwSetWindowMonitorX11(_GLFWwindow* window,
+                              _GLFWmonitor* monitor,
                               int xpos, int ypos,
                               int width, int height,
                               int refreshRate)
@@ -2699,7 +2523,7 @@ void _glfwSetWindowMonitorX11(_GLFWwindow *window,
     XFlush(_glfw.x11.display);
 }
 
-GLFWbool _glfwWindowFocusedX11(_GLFWwindow *window)
+GLFWbool _glfwWindowFocusedX11(_GLFWwindow* window)
 {
     Window focused;
     int state;
@@ -2708,21 +2532,21 @@ GLFWbool _glfwWindowFocusedX11(_GLFWwindow *window)
     return window->x11.handle == focused;
 }
 
-GLFWbool _glfwWindowIconifiedX11(_GLFWwindow *window)
+GLFWbool _glfwWindowIconifiedX11(_GLFWwindow* window)
 {
     return getWindowState(window) == IconicState;
 }
 
-GLFWbool _glfwWindowVisibleX11(_GLFWwindow *window)
+GLFWbool _glfwWindowVisibleX11(_GLFWwindow* window)
 {
     XWindowAttributes wa;
     XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &wa);
     return wa.map_state == IsViewable;
 }
 
-GLFWbool _glfwWindowMaximizedX11(_GLFWwindow *window)
+GLFWbool _glfwWindowMaximizedX11(_GLFWwindow* window)
 {
-    Atom *states;
+    Atom* states;
     GLFWbool maximized = GLFW_FALSE;
 
     if (!_glfw.x11.NET_WM_STATE ||
@@ -2736,9 +2560,9 @@ GLFWbool _glfwWindowMaximizedX11(_GLFWwindow *window)
         _glfwGetWindowPropertyX11(window->x11.handle,
                                   _glfw.x11.NET_WM_STATE,
                                   XA_ATOM,
-                                  (unsigned char **)&states);
+                                  (unsigned char**) &states);
 
-    for (unsigned long i = 0; i < count; i++)
+    for (unsigned long i = 0;  i < count;  i++)
     {
         if (states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
             states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
@@ -2754,7 +2578,7 @@ GLFWbool _glfwWindowMaximizedX11(_GLFWwindow *window)
     return maximized;
 }
 
-GLFWbool _glfwWindowHoveredX11(_GLFWwindow *window)
+GLFWbool _glfwWindowHoveredX11(_GLFWwindow* window)
 {
     Window w = _glfw.x11.root;
     while (w)
@@ -2782,7 +2606,7 @@ GLFWbool _glfwWindowHoveredX11(_GLFWwindow *window)
     return GLFW_FALSE;
 }
 
-GLFWbool _glfwFramebufferTransparentX11(_GLFWwindow *window)
+GLFWbool _glfwFramebufferTransparentX11(_GLFWwindow* window)
 {
     if (!window->x11.transparent)
         return GLFW_FALSE;
@@ -2790,14 +2614,14 @@ GLFWbool _glfwFramebufferTransparentX11(_GLFWwindow *window)
     return XGetSelectionOwner(_glfw.x11.display, _glfw.x11.NET_WM_CM_Sx) != None;
 }
 
-void _glfwSetWindowResizableX11(_GLFWwindow *window, GLFWbool enabled)
+void _glfwSetWindowResizableX11(_GLFWwindow* window, GLFWbool enabled)
 {
     int width, height;
     _glfwGetWindowSizeX11(window, &width, &height);
     updateNormalHints(window, width, height);
 }
 
-void _glfwSetWindowDecoratedX11(_GLFWwindow *window, GLFWbool enabled)
+void _glfwSetWindowDecoratedX11(_GLFWwindow* window, GLFWbool enabled)
 {
     struct
     {
@@ -2815,11 +2639,11 @@ void _glfwSetWindowDecoratedX11(_GLFWwindow *window, GLFWbool enabled)
                     _glfw.x11.MOTIF_WM_HINTS,
                     _glfw.x11.MOTIF_WM_HINTS, 32,
                     PropModeReplace,
-                    (unsigned char *)&hints,
+                    (unsigned char*) &hints,
                     sizeof(hints) / sizeof(long));
 }
 
-void _glfwSetWindowFloatingX11(_GLFWwindow *window, GLFWbool enabled)
+void _glfwSetWindowFloatingX11(_GLFWwindow* window, GLFWbool enabled)
 {
     if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_ABOVE)
         return;
@@ -2835,12 +2659,12 @@ void _glfwSetWindowFloatingX11(_GLFWwindow *window, GLFWbool enabled)
     }
     else
     {
-        Atom *states = NULL;
+        Atom* states = NULL;
         const unsigned long count =
             _glfwGetWindowPropertyX11(window->x11.handle,
                                       _glfw.x11.NET_WM_STATE,
                                       XA_ATOM,
-                                      (unsigned char **)&states);
+                                      (unsigned char**) &states);
 
         // NOTE: We don't check for failure as this property may not exist yet
         //       and that's fine (and we'll create it implicitly with append)
@@ -2849,7 +2673,7 @@ void _glfwSetWindowFloatingX11(_GLFWwindow *window, GLFWbool enabled)
         {
             unsigned long i;
 
-            for (i = 0; i < count; i++)
+            for (i = 0;  i < count;  i++)
             {
                 if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
                     break;
@@ -2860,20 +2684,20 @@ void _glfwSetWindowFloatingX11(_GLFWwindow *window, GLFWbool enabled)
                 XChangeProperty(_glfw.x11.display, window->x11.handle,
                                 _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
                                 PropModeAppend,
-                                (unsigned char *)&_glfw.x11.NET_WM_STATE_ABOVE,
+                                (unsigned char*) &_glfw.x11.NET_WM_STATE_ABOVE,
                                 1);
             }
         }
         else if (states)
         {
-            for (unsigned long i = 0; i < count; i++)
+            for (unsigned long i = 0;  i < count;  i++)
             {
                 if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
                 {
                     states[i] = states[count - 1];
                     XChangeProperty(_glfw.x11.display, window->x11.handle,
                                     _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
-                                    PropModeReplace, (unsigned char *)states, count - 1);
+                                    PropModeReplace, (unsigned char*) states, count - 1);
                     break;
                 }
             }
@@ -2886,7 +2710,7 @@ void _glfwSetWindowFloatingX11(_GLFWwindow *window, GLFWbool enabled)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowMousePassthroughX11(_GLFWwindow *window, GLFWbool enabled)
+void _glfwSetWindowMousePassthroughX11(_GLFWwindow* window, GLFWbool enabled)
 {
     if (!_glfw.x11.xshape.available)
         return;
@@ -2905,20 +2729,20 @@ void _glfwSetWindowMousePassthroughX11(_GLFWwindow *window, GLFWbool enabled)
     }
 }
 
-float _glfwGetWindowOpacityX11(_GLFWwindow *window)
+float _glfwGetWindowOpacityX11(_GLFWwindow* window)
 {
     float opacity = 1.f;
 
     if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.NET_WM_CM_Sx))
     {
-        CARD32 *value = NULL;
+        CARD32* value = NULL;
 
         if (_glfwGetWindowPropertyX11(window->x11.handle,
                                       _glfw.x11.NET_WM_WINDOW_OPACITY,
                                       XA_CARDINAL,
-                                      (unsigned char **)&value))
+                                      (unsigned char**) &value))
         {
-            opacity = (float)(*value / (double)0xffffffffu);
+            opacity = (float) (*value / (double) 0xffffffffu);
         }
 
         if (value)
@@ -2928,12 +2752,12 @@ float _glfwGetWindowOpacityX11(_GLFWwindow *window)
     return opacity;
 }
 
-void _glfwSetWindowOpacityX11(_GLFWwindow *window, float opacity)
+void _glfwSetWindowOpacityX11(_GLFWwindow* window, float opacity)
 {
-    const CARD32 value = (CARD32)(0xffffffffu * (double)opacity);
+    const CARD32 value = (CARD32) (0xffffffffu * (double) opacity);
     XChangeProperty(_glfw.x11.display, window->x11.handle,
                     _glfw.x11.NET_WM_WINDOW_OPACITY, XA_CARDINAL, 32,
-                    PropModeReplace, (unsigned char *)&value, 1);
+                    PropModeReplace, (unsigned char*) &value, 1);
 }
 
 void _glfwSetRawMouseMotionX11(_GLFWwindow *window, GLFWbool enabled)
@@ -2961,8 +2785,7 @@ void _glfwPollEventsX11(void)
 
 #if defined(GLFW_BUILD_LINUX_JOYSTICK)
     if (_glfw.joysticksInitialized)
-        _glfwPollAllJoysticks();
-    _glfwDetectJoystickConnectionLinux();
+        _glfwDetectJoystickConnectionLinux();
 #endif
     XPending(_glfw.x11.display);
 
@@ -2973,7 +2796,7 @@ void _glfwPollEventsX11(void)
         processEvent(&event);
     }
 
-    _GLFWwindow *window = _glfw.x11.disabledCursorWindow;
+    _GLFWwindow* window = _glfw.x11.disabledCursorWindow;
     if (window)
     {
         int width, height;
@@ -3008,7 +2831,7 @@ void _glfwPostEmptyEventX11(void)
     writeEmptyEvent();
 }
 
-void _glfwGetCursorPosX11(_GLFWwindow *window, double *xpos, double *ypos)
+void _glfwGetCursorPosX11(_GLFWwindow* window, double* xpos, double* ypos)
 {
     Window root, child;
     int rootX, rootY, childX, childY;
@@ -3025,18 +2848,18 @@ void _glfwGetCursorPosX11(_GLFWwindow *window, double *xpos, double *ypos)
         *ypos = childY;
 }
 
-void _glfwSetCursorPosX11(_GLFWwindow *window, double x, double y)
+void _glfwSetCursorPosX11(_GLFWwindow* window, double x, double y)
 {
     // Store the new position so it can be recognized later
-    window->x11.warpCursorPosX = (int)x;
-    window->x11.warpCursorPosY = (int)y;
+    window->x11.warpCursorPosX = (int) x;
+    window->x11.warpCursorPosY = (int) y;
 
     XWarpPointer(_glfw.x11.display, None, window->x11.handle,
-                 0, 0, 0, 0, (int)x, (int)y);
+                 0,0,0,0, (int) x, (int) y);
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetCursorModeX11(_GLFWwindow *window, int mode)
+void _glfwSetCursorModeX11(_GLFWwindow* window, int mode)
 {
     if (_glfwWindowFocusedX11(window))
     {
@@ -3075,7 +2898,7 @@ void _glfwSetCursorModeX11(_GLFWwindow *window, int mode)
     XFlush(_glfw.x11.display);
 }
 
-const char *_glfwGetScancodeNameX11(int scancode)
+const char* _glfwGetScancodeNameX11(int scancode)
 {
     if (!_glfw.x11.xkb.available)
         return NULL;
@@ -3112,8 +2935,8 @@ int _glfwGetKeyScancodeX11(int key)
     return _glfw.x11.scancodes[key];
 }
 
-GLFWbool _glfwCreateCursorX11(_GLFWcursor *cursor,
-                              const GLFWimage *image,
+GLFWbool _glfwCreateCursorX11(_GLFWcursor* cursor,
+                              const GLFWimage* image,
                               int xhot, int yhot)
 {
     cursor->x11.handle = _glfwCreateNativeCursorX11(image, xhot, yhot);
@@ -3123,51 +2946,51 @@ GLFWbool _glfwCreateCursorX11(_GLFWcursor *cursor,
     return GLFW_TRUE;
 }
 
-GLFWbool _glfwCreateStandardCursorX11(_GLFWcursor *cursor, int shape)
+GLFWbool _glfwCreateStandardCursorX11(_GLFWcursor* cursor, int shape)
 {
     if (_glfw.x11.xcursor.handle)
     {
-        char *theme = XcursorGetTheme(_glfw.x11.display);
+        char* theme = XcursorGetTheme(_glfw.x11.display);
         if (theme)
         {
             const int size = XcursorGetDefaultSize(_glfw.x11.display);
-            const char *name = NULL;
+            const char* name = NULL;
 
             switch (shape)
             {
-            case GLFW_ARROW_CURSOR:
-                name = "default";
-                break;
-            case GLFW_IBEAM_CURSOR:
-                name = "text";
-                break;
-            case GLFW_CROSSHAIR_CURSOR:
-                name = "crosshair";
-                break;
-            case GLFW_POINTING_HAND_CURSOR:
-                name = "pointer";
-                break;
-            case GLFW_RESIZE_EW_CURSOR:
-                name = "ew-resize";
-                break;
-            case GLFW_RESIZE_NS_CURSOR:
-                name = "ns-resize";
-                break;
-            case GLFW_RESIZE_NWSE_CURSOR:
-                name = "nwse-resize";
-                break;
-            case GLFW_RESIZE_NESW_CURSOR:
-                name = "nesw-resize";
-                break;
-            case GLFW_RESIZE_ALL_CURSOR:
-                name = "all-scroll";
-                break;
-            case GLFW_NOT_ALLOWED_CURSOR:
-                name = "not-allowed";
-                break;
+                case GLFW_ARROW_CURSOR:
+                    name = "default";
+                    break;
+                case GLFW_IBEAM_CURSOR:
+                    name = "text";
+                    break;
+                case GLFW_CROSSHAIR_CURSOR:
+                    name = "crosshair";
+                    break;
+                case GLFW_POINTING_HAND_CURSOR:
+                    name = "pointer";
+                    break;
+                case GLFW_RESIZE_EW_CURSOR:
+                    name = "ew-resize";
+                    break;
+                case GLFW_RESIZE_NS_CURSOR:
+                    name = "ns-resize";
+                    break;
+                case GLFW_RESIZE_NWSE_CURSOR:
+                    name = "nwse-resize";
+                    break;
+                case GLFW_RESIZE_NESW_CURSOR:
+                    name = "nesw-resize";
+                    break;
+                case GLFW_RESIZE_ALL_CURSOR:
+                    name = "all-scroll";
+                    break;
+                case GLFW_NOT_ALLOWED_CURSOR:
+                    name = "not-allowed";
+                    break;
             }
 
-            XcursorImage *image = XcursorLibraryLoadImage(name, theme, size);
+            XcursorImage* image = XcursorLibraryLoadImage(name, theme, size);
             if (image)
             {
                 cursor->x11.handle = XcursorImageLoadCursor(_glfw.x11.display, image);
@@ -3182,31 +3005,31 @@ GLFWbool _glfwCreateStandardCursorX11(_GLFWcursor *cursor, int shape)
 
         switch (shape)
         {
-        case GLFW_ARROW_CURSOR:
-            native = XC_left_ptr;
-            break;
-        case GLFW_IBEAM_CURSOR:
-            native = XC_xterm;
-            break;
-        case GLFW_CROSSHAIR_CURSOR:
-            native = XC_crosshair;
-            break;
-        case GLFW_POINTING_HAND_CURSOR:
-            native = XC_hand2;
-            break;
-        case GLFW_RESIZE_EW_CURSOR:
-            native = XC_sb_h_double_arrow;
-            break;
-        case GLFW_RESIZE_NS_CURSOR:
-            native = XC_sb_v_double_arrow;
-            break;
-        case GLFW_RESIZE_ALL_CURSOR:
-            native = XC_fleur;
-            break;
-        default:
-            _glfwInputError(GLFW_CURSOR_UNAVAILABLE,
-                            "X11: Standard cursor shape unavailable");
-            return GLFW_FALSE;
+            case GLFW_ARROW_CURSOR:
+                native = XC_left_ptr;
+                break;
+            case GLFW_IBEAM_CURSOR:
+                native = XC_xterm;
+                break;
+            case GLFW_CROSSHAIR_CURSOR:
+                native = XC_crosshair;
+                break;
+            case GLFW_POINTING_HAND_CURSOR:
+                native = XC_hand2;
+                break;
+            case GLFW_RESIZE_EW_CURSOR:
+                native = XC_sb_h_double_arrow;
+                break;
+            case GLFW_RESIZE_NS_CURSOR:
+                native = XC_sb_v_double_arrow;
+                break;
+            case GLFW_RESIZE_ALL_CURSOR:
+                native = XC_fleur;
+                break;
+            default:
+                _glfwInputError(GLFW_CURSOR_UNAVAILABLE,
+                                "X11: Standard cursor shape unavailable");
+                return GLFW_FALSE;
         }
 
         cursor->x11.handle = XCreateFontCursor(_glfw.x11.display, native);
@@ -3221,13 +3044,13 @@ GLFWbool _glfwCreateStandardCursorX11(_GLFWcursor *cursor, int shape)
     return GLFW_TRUE;
 }
 
-void _glfwDestroyCursorX11(_GLFWcursor *cursor)
+void _glfwDestroyCursorX11(_GLFWcursor* cursor)
 {
     if (cursor->x11.handle)
         XFreeCursor(_glfw.x11.display, cursor->x11.handle);
 }
 
-void _glfwSetCursorX11(_GLFWwindow *window, _GLFWcursor *cursor)
+void _glfwSetCursorX11(_GLFWwindow* window, _GLFWcursor* cursor)
 {
     if (window->cursorMode == GLFW_CURSOR_NORMAL ||
         window->cursorMode == GLFW_CURSOR_CAPTURED)
@@ -3237,9 +3060,9 @@ void _glfwSetCursorX11(_GLFWwindow *window, _GLFWcursor *cursor)
     }
 }
 
-void _glfwSetClipboardStringX11(const char *string)
+void _glfwSetClipboardStringX11(const char* string)
 {
-    char *copy = _glfw_strdup(string);
+    char* copy = _glfw_strdup(string);
     _glfw_free(_glfw.x11.clipboardString);
     _glfw.x11.clipboardString = copy;
 
@@ -3256,12 +3079,12 @@ void _glfwSetClipboardStringX11(const char *string)
     }
 }
 
-const char *_glfwGetClipboardStringX11(void)
+const char* _glfwGetClipboardStringX11(void)
 {
     return getSelectionString(_glfw.x11.CLIPBOARD);
 }
 
-EGLenum _glfwGetEGLPlatformX11(EGLint **attribs)
+EGLenum _glfwGetEGLPlatformX11(EGLint** attribs)
 {
     if (_glfw.egl.ANGLE_platform_angle)
     {
@@ -3302,15 +3125,15 @@ EGLNativeDisplayType _glfwGetEGLNativeDisplayX11(void)
     return _glfw.x11.display;
 }
 
-EGLNativeWindowType _glfwGetEGLNativeWindowX11(_GLFWwindow *window)
+EGLNativeWindowType _glfwGetEGLNativeWindowX11(_GLFWwindow* window)
 {
     if (_glfw.egl.platform)
         return &window->x11.handle;
     else
-        return (EGLNativeWindowType)window->x11.handle;
+        return (EGLNativeWindowType) window->x11.handle;
 }
 
-void _glfwGetRequiredInstanceExtensionsX11(char **extensions)
+void _glfwGetRequiredInstanceExtensionsX11(char** extensions)
 {
     if (!_glfw.vk.KHR_surface)
         return;
@@ -3342,8 +3165,8 @@ GLFWbool _glfwGetPhysicalDevicePresentationSupportX11(VkInstance instance,
     {
         PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR
             vkGetPhysicalDeviceXcbPresentationSupportKHR =
-                (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)
-                    vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
+            (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)
+            vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
         if (!vkGetPhysicalDeviceXcbPresentationSupportKHR)
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
@@ -3351,7 +3174,7 @@ GLFWbool _glfwGetPhysicalDevicePresentationSupportX11(VkInstance instance,
             return GLFW_FALSE;
         }
 
-        xcb_connection_t *connection = XGetXCBConnection(_glfw.x11.display);
+        xcb_connection_t* connection = XGetXCBConnection(_glfw.x11.display);
         if (!connection)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -3368,8 +3191,8 @@ GLFWbool _glfwGetPhysicalDevicePresentationSupportX11(VkInstance instance,
     {
         PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR
             vkGetPhysicalDeviceXlibPresentationSupportKHR =
-                (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)
-                    vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
+            (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)
+            vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
         if (!vkGetPhysicalDeviceXlibPresentationSupportKHR)
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
@@ -3385,9 +3208,9 @@ GLFWbool _glfwGetPhysicalDevicePresentationSupportX11(VkInstance instance,
 }
 
 VkResult _glfwCreateWindowSurfaceX11(VkInstance instance,
-                                     _GLFWwindow *window,
-                                     const VkAllocationCallbacks *allocator,
-                                     VkSurfaceKHR *surface)
+                                     _GLFWwindow* window,
+                                     const VkAllocationCallbacks* allocator,
+                                     VkSurfaceKHR* surface)
 {
     if (_glfw.vk.KHR_xcb_surface && _glfw.x11.x11xcb.handle)
     {
@@ -3395,7 +3218,7 @@ VkResult _glfwCreateWindowSurfaceX11(VkInstance instance,
         VkXcbSurfaceCreateInfoKHR sci;
         PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR;
 
-        xcb_connection_t *connection = XGetXCBConnection(_glfw.x11.display);
+        xcb_connection_t* connection = XGetXCBConnection(_glfw.x11.display);
         if (!connection)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -3459,11 +3282,12 @@ VkResult _glfwCreateWindowSurfaceX11(VkInstance instance,
     }
 }
 
+
 //////////////////////////////////////////////////////////////////////////
 //////                        GLFW native API                       //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWAPI Display *glfwGetX11Display(void)
+GLFWAPI Display* glfwGetX11Display(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -3476,7 +3300,7 @@ GLFWAPI Display *glfwGetX11Display(void)
     return _glfw.x11.display;
 }
 
-GLFWAPI Window glfwGetX11Window(GLFWwindow *handle)
+GLFWAPI Window glfwGetX11Window(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(None);
 
@@ -3492,7 +3316,7 @@ GLFWAPI Window glfwGetX11Window(GLFWwindow *handle)
     return window->x11.handle;
 }
 
-GLFWAPI void glfwSetX11SelectionString(const char *string)
+GLFWAPI void glfwSetX11SelectionString(const char* string)
 {
     assert(string != NULL);
 
@@ -3520,7 +3344,7 @@ GLFWAPI void glfwSetX11SelectionString(const char *string)
     }
 }
 
-GLFWAPI const char *glfwGetX11SelectionString(void)
+GLFWAPI const char* glfwGetX11SelectionString(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -3534,3 +3358,4 @@ GLFWAPI const char *glfwGetX11SelectionString(void)
 }
 
 #endif // _GLFW_X11
+

From 094db02c39f5e003d1932ee4eb6b27cbf29816a5 Mon Sep 17 00:00:00 2001
From: NarrikSynthfox <80410683+NarrikSynthfox@users.noreply.github.com>
Date: Wed, 10 Apr 2024 13:08:34 -0400
Subject: [PATCH 08/11] Update docs, readme, news, and contributors

---
 CONTRIBUTORS.md |  3 ++
 README.md       |  2 +-
 docs/input.md   | 79 +++++++++++++++++++++++++++++++++++++++++++++++++
 docs/news.md    | 15 ++++++++++
 4 files changed, 98 insertions(+), 1 deletion(-)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 1371aedb..d3349217 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -294,6 +294,9 @@ video tutorials.
  - Jonas Ådahl
  - Lasse Öörni
  - Leonard König
+ - Beoran
+ - Enthuin
+ - Narrik Synthfox
  - All the unmentioned and anonymous contributors in the GLFW community, for bug
    reports, patches, feedback, testing and encouragement
 
diff --git a/README.md b/README.md
index 2718e45e..44f3fadd 100644
--- a/README.md
+++ b/README.md
@@ -129,7 +129,7 @@ information on what to include when reporting a bug.
  - [Null] Added EGL context creation on Mesa via `EGL_MESA_platform_surfaceless`
  - [EGL] Allowed native access on Wayland with `GLFW_CONTEXT_CREATION_API` set to
    `GLFW_NATIVE_CONTEXT_API` (#2518)
-
+ - Added `GLFWgamepadstatefun`, `glfwSetGamepadStateCallback`, `GLFWjoystickbuttonfun`,`glfwSetJoystickButtonCallback`, `GLFWjoystickaxisfun`, `glfwSetJoystickAxisCallback`, `GLFWjoystickhatfun`, and `glfwSetJoystickHatCallback` for event-based joystick/gamepad input.
 
 ## Contact
 
diff --git a/docs/input.md b/docs/input.md
index 3ef1aebe..acfcfcdb 100644
--- a/docs/input.md
+++ b/docs/input.md
@@ -911,6 +911,85 @@ righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,
 were recently added to SDL.  The input modifiers `+`, `-` and `~` are supported
 and described above.
 
+### Event-based joystick and gamepad input {#joystick_input_event}
+
+If you wish to be notified when a button on a joystick is pressed or released, set a joystick button callback.
+
+```c
+glfwSetJoystickButtonCallback(joystick_button_callback);
+```
+
+The callback function receives the joystick id, the [joystick button](@ref joystick_button) that was pressed or released, and action.
+
+```c
+void joystick_button_callback(int jid, int button, int action)
+{
+    if (button == 0 && action == GLFW_PRESS)
+        jump();
+}
+```
+
+The action is one of `GLFW_PRESS` or `GLFW_RELEASE`
+
+If you wish to be notified when an axis on a joystick is moved, set a joystick axis callback.
+
+```c
+glfwSetJoystickAxisCallback(joystick_axis_callback);
+```
+
+The callback function receives the joystick id, [joystick axis](@ref joystick_axis) that was moved, and float value from -1.0 to 1.0 for the axis.
+
+```c
+void joystick_axis_callback(int jid, int axis, float value)
+{
+    if (axis == 0){
+        if(value == -1.0f)
+            move_left();
+        else if(value == 1.0f)
+            move_right();
+    }
+}
+```
+
+If you wish to be notified when a hat on a joystick is moved, set a joystick hat callback.
+
+```c
+glfwSetJoystickHatCallback(joystick_hat_callback);
+```
+
+The callback function receives the joystick id, hat, and the [hat states](@ref hat_state).
+
+```c
+void joystick_hat_callback(int jid, int hat, int position)
+{
+    if(hat == 0 && position == GLFW_HAT_UP)
+        move_up();
+}
+```
+
+If you wish to be notified when the state of a gamepad is updated, set a gamepad state callback. This callback will occur every time any button, axis, or hat updates, so with this, you will have to handle checks for if a value is changed.
+
+```c
+glfwSetGamepadStateCallback(gamepad_state_callback);
+```
+
+The callback function recieves the joystick id and the gamepad state.
+
+```c
+bool jumpButtonHeld = false;
+
+gamepad_state_callback(int jid, GLFWgamepadstate state){
+    if (state.buttons[GLFW_GAMEPAD_BUTTON_A] && !jumpButtonHeld)
+    {
+        input_jump();
+        jumpButtonHeld = true;
+    }
+    else if (!state.buttons[GLFW_GAMEPAD_BUTTON_A] && jumpButtonHeld)
+    {
+        jumpButtonHeld = false;
+    }
+}
+```
 
 ## Time input {#time}
 
diff --git a/docs/news.md b/docs/news.md
index 148d0871..cf02ac1d 100644
--- a/docs/news.md
+++ b/docs/news.md
@@ -14,6 +14,11 @@ values over 8. For compatibility with older versions, the
 @ref GLFW_UNLIMITED_MOUSE_BUTTONS input mode needs to be set to make use of
 this.
 
+### Callback functions for gamepad state, joystick buttons, joystick axes, and joystick hat inputs {#joystick_input_callbacks}
+
+GLFW now has callback functions for [gamepad state](@ref glfwSetGamepadStateCallback), [joystick buttons](@ref glfwSetJoystickButtonCallback), [joystick axes](@ref glfwSetJoystickAxisCallback), and [joystick hats](@ref glfwSetJoystickHatCallback), allowing for 
+event-based inputs for joysticks and gamepads.
+
 ## Caveats {#caveats}
 
 ## Deprecations {#deprecations}
@@ -24,8 +29,18 @@ this.
 
 ### New functions {#new_functions}
 
+- @ref glfwSetJoystickButtonCallback
+- @ref glfwSetJoystickAxisCallback
+- @ref glfwSetJoystickHatCallback
+- @ref glfwSetGamepadStateCallback
+
 ### New types {#new_types}
 
+- @ref GLFWjoystickbuttonfun
+- @ref GLFWjoystickaxisfun
+- @ref GLFWjoystickhatfun
+- @ref GLFWgamepadstatefun
+
 ### New constants {#new_constants}
 
 - @ref GLFW_UNLIMITED_MOUSE_BUTTONS

From a4c3492a03b9bae5724ed74c8531d70983ccfe26 Mon Sep 17 00:00:00 2001
From: NarrikSynthfox <80410683+NarrikSynthfox@users.noreply.github.com>
Date: Wed, 10 Apr 2024 13:39:35 -0400
Subject: [PATCH 09/11] Fix issue with merge

---
 src/input.c      |  129 ++--
 src/window.c     |  392 ++++++------
 src/x11_window.c | 1585 +++++++++++++++++++++-------------------------
 3 files changed, 960 insertions(+), 1146 deletions(-)

diff --git a/src/input.c b/src/input.c
index 6310b653..7c2a153a 100644
--- a/src/input.c
+++ b/src/input.c
@@ -653,93 +653,80 @@ GLFWAPI void glfwSetInputMode(GLFWwindow *handle, int mode, int value)
 
     switch (mode)
     {
-    case GLFW_CURSOR:
-    {
-        if (value != GLFW_CURSOR_NORMAL &&
-            value != GLFW_CURSOR_HIDDEN &&
-            value != GLFW_CURSOR_DISABLED &&
-            value != GLFW_CURSOR_CAPTURED)
+        case GLFW_CURSOR:
         {
-            _glfwInputError(GLFW_INVALID_ENUM,
-                            "Invalid cursor mode 0x%08X",
-                            value);
-            return;
-        }
-
-        if (window->cursorMode == value)
-            return;
-
-        window->cursorMode = value;
-
-        _glfw.platform.getCursorPos(window,
-                                    &window->virtualCursorPosX,
-                                    &window->virtualCursorPosY);
-        _glfw.platform.setCursorMode(window, value);
-        return;
-    }
-
-    case GLFW_STICKY_KEYS:
-    {
-        value = value ? GLFW_TRUE : GLFW_FALSE;
-        if (window->stickyKeys == value)
-            return;
-
-        if (!value)
-        {
-            int i;
-
-            // Release all sticky keys
-            for (i = 0; i <= GLFW_KEY_LAST; i++)
+            if (value != GLFW_CURSOR_NORMAL &&
+                value != GLFW_CURSOR_HIDDEN &&
+                value != GLFW_CURSOR_DISABLED &&
+                value != GLFW_CURSOR_CAPTURED)
             {
-                if (window->keys[i] == _GLFW_STICK)
-                    window->keys[i] = GLFW_RELEASE;
+                _glfwInputError(GLFW_INVALID_ENUM,
+                                "Invalid cursor mode 0x%08X",
+                                value);
+                return;
             }
+
+            if (window->cursorMode == value)
+                return;
+
+            window->cursorMode = value;
+
+            _glfw.platform.getCursorPos(window,
+                                        &window->virtualCursorPosX,
+                                        &window->virtualCursorPosY);
+            _glfw.platform.setCursorMode(window, value);
+            return;
         }
 
-        window->stickyKeys = value;
-        return;
-    }
-
-    case GLFW_STICKY_MOUSE_BUTTONS:
-    {
-        value = value ? GLFW_TRUE : GLFW_FALSE;
-        if (window->stickyMouseButtons == value)
-            return;
-
-        if (!value)
+        case GLFW_STICKY_KEYS:
         {
-            int i;
+            value = value ? GLFW_TRUE : GLFW_FALSE;
+            if (window->stickyKeys == value)
+                return;
 
-            // Release all sticky mouse buttons
-            for (i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++)
+            if (!value)
             {
-                if (window->mouseButtons[i] == _GLFW_STICK)
-                    window->mouseButtons[i] = GLFW_RELEASE;
+                int i;
+
+                // Release all sticky keys
+                for (i = 0; i <= GLFW_KEY_LAST; i++)
+                {
+                    if (window->keys[i] == _GLFW_STICK)
+                        window->keys[i] = GLFW_RELEASE;
+                }
             }
+
+            window->stickyKeys = value;
+            return;
         }
 
-        window->stickyMouseButtons = value;
-        return;
-    }
-
-    case GLFW_LOCK_KEY_MODS:
-    {
-        window->lockKeyMods = value ? GLFW_TRUE : GLFW_FALSE;
-        return;
-    }
-
-    case GLFW_RAW_MOUSE_MOTION:
-    {
-        if (!_glfw.platform.rawMouseMotionSupported())
+        case GLFW_STICKY_MOUSE_BUTTONS:
         {
-            _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "Raw mouse motion is not supported on this system");
+            value = value ? GLFW_TRUE : GLFW_FALSE;
+            if (window->stickyMouseButtons == value)
+                return;
+
+            if (!value)
+            {
+                int i;
+
+                // Release all sticky mouse buttons
+                for (i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++)
+                {
+                    if (window->mouseButtons[i] == _GLFW_STICK)
+                        window->mouseButtons[i] = GLFW_RELEASE;
+                }
+            }
+
+            window->stickyMouseButtons = value;
             return;
         }
 
-        value = value ? GLFW_TRUE : GLFW_FALSE;
-        if (window->rawMouseMotion == value)
+        case GLFW_LOCK_KEY_MODS:
+        {
+            window->lockKeyMods = value ? GLFW_TRUE : GLFW_FALSE;
             return;
+        }
 
         case GLFW_RAW_MOUSE_MOTION:
         {
diff --git a/src/window.c b/src/window.c
index ebd1b240..4bd53cb9 100644
--- a/src/window.c
+++ b/src/window.c
@@ -33,25 +33,26 @@
 #include <stdlib.h>
 #include <float.h>
 
+
 //////////////////////////////////////////////////////////////////////////
 //////                         GLFW event API                       //////
 //////////////////////////////////////////////////////////////////////////
 
 // Notifies shared code that a window has lost or received input focus
 //
-void _glfwInputWindowFocus(_GLFWwindow *window, GLFWbool focused)
+void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused)
 {
     assert(window != NULL);
     assert(focused == GLFW_TRUE || focused == GLFW_FALSE);
 
     if (window->callbacks.focus)
-        window->callbacks.focus((GLFWwindow *)window, focused);
+        window->callbacks.focus((GLFWwindow*) window, focused);
 
     if (!focused)
     {
         int key, button;
 
-        for (key = 0; key <= GLFW_KEY_LAST; key++)
+        for (key = 0;  key <= GLFW_KEY_LAST;  key++)
         {
             if (window->keys[key] == GLFW_PRESS)
             {
@@ -60,7 +61,7 @@ void _glfwInputWindowFocus(_GLFWwindow *window, GLFWbool focused)
             }
         }
 
-        for (button = 0; button <= GLFW_MOUSE_BUTTON_LAST; button++)
+        for (button = 0;  button <= GLFW_MOUSE_BUTTON_LAST;  button++)
         {
             if (window->mouseButtons[button] == GLFW_PRESS)
                 _glfwInputMouseClick(window, button, GLFW_RELEASE, 0);
@@ -71,66 +72,66 @@ void _glfwInputWindowFocus(_GLFWwindow *window, GLFWbool focused)
 // Notifies shared code that a window has moved
 // The position is specified in content area relative screen coordinates
 //
-void _glfwInputWindowPos(_GLFWwindow *window, int x, int y)
+void _glfwInputWindowPos(_GLFWwindow* window, int x, int y)
 {
     assert(window != NULL);
 
     if (window->callbacks.pos)
-        window->callbacks.pos((GLFWwindow *)window, x, y);
+        window->callbacks.pos((GLFWwindow*) window, x, y);
 }
 
 // Notifies shared code that a window has been resized
 // The size is specified in screen coordinates
 //
-void _glfwInputWindowSize(_GLFWwindow *window, int width, int height)
+void _glfwInputWindowSize(_GLFWwindow* window, int width, int height)
 {
     assert(window != NULL);
     assert(width >= 0);
     assert(height >= 0);
 
     if (window->callbacks.size)
-        window->callbacks.size((GLFWwindow *)window, width, height);
+        window->callbacks.size((GLFWwindow*) window, width, height);
 }
 
 // Notifies shared code that a window has been iconified or restored
 //
-void _glfwInputWindowIconify(_GLFWwindow *window, GLFWbool iconified)
+void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified)
 {
     assert(window != NULL);
     assert(iconified == GLFW_TRUE || iconified == GLFW_FALSE);
 
     if (window->callbacks.iconify)
-        window->callbacks.iconify((GLFWwindow *)window, iconified);
+        window->callbacks.iconify((GLFWwindow*) window, iconified);
 }
 
 // Notifies shared code that a window has been maximized or restored
 //
-void _glfwInputWindowMaximize(_GLFWwindow *window, GLFWbool maximized)
+void _glfwInputWindowMaximize(_GLFWwindow* window, GLFWbool maximized)
 {
     assert(window != NULL);
     assert(maximized == GLFW_TRUE || maximized == GLFW_FALSE);
 
     if (window->callbacks.maximize)
-        window->callbacks.maximize((GLFWwindow *)window, maximized);
+        window->callbacks.maximize((GLFWwindow*) window, maximized);
 }
 
 // Notifies shared code that a window framebuffer has been resized
 // The size is specified in pixels
 //
-void _glfwInputFramebufferSize(_GLFWwindow *window, int width, int height)
+void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height)
 {
     assert(window != NULL);
     assert(width >= 0);
     assert(height >= 0);
 
     if (window->callbacks.fbsize)
-        window->callbacks.fbsize((GLFWwindow *)window, width, height);
+        window->callbacks.fbsize((GLFWwindow*) window, width, height);
 }
 
 // Notifies shared code that a window content scale has changed
 // The scale is specified as the ratio between the current and default DPI
 //
-void _glfwInputWindowContentScale(_GLFWwindow *window, float xscale, float yscale)
+void _glfwInputWindowContentScale(_GLFWwindow* window, float xscale, float yscale)
 {
     assert(window != NULL);
     assert(xscale > 0.f);
@@ -139,34 +140,34 @@ void _glfwInputWindowContentScale(_GLFWwindow *window, float xscale, float yscal
     assert(yscale < FLT_MAX);
 
     if (window->callbacks.scale)
-        window->callbacks.scale((GLFWwindow *)window, xscale, yscale);
+        window->callbacks.scale((GLFWwindow*) window, xscale, yscale);
 }
 
 // Notifies shared code that the window contents needs updating
 //
-void _glfwInputWindowDamage(_GLFWwindow *window)
+void _glfwInputWindowDamage(_GLFWwindow* window)
 {
     assert(window != NULL);
 
     if (window->callbacks.refresh)
-        window->callbacks.refresh((GLFWwindow *)window);
+        window->callbacks.refresh((GLFWwindow*) window);
 }
 
 // Notifies shared code that the user wishes to close a window
 //
-void _glfwInputWindowCloseRequest(_GLFWwindow *window)
+void _glfwInputWindowCloseRequest(_GLFWwindow* window)
 {
     assert(window != NULL);
 
     window->shouldClose = GLFW_TRUE;
 
     if (window->callbacks.close)
-        window->callbacks.close((GLFWwindow *)window);
+        window->callbacks.close((GLFWwindow*) window);
 }
 
 // Notifies shared code that a window has changed its desired monitor
 //
-void _glfwInputWindowMonitor(_GLFWwindow *window, _GLFWmonitor *monitor)
+void _glfwInputWindowMonitor(_GLFWwindow* window, _GLFWmonitor* monitor)
 {
     assert(window != NULL);
     window->monitor = monitor;
@@ -176,15 +177,15 @@ void _glfwInputWindowMonitor(_GLFWwindow *window, _GLFWmonitor *monitor)
 //////                        GLFW public API                       //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWAPI GLFWwindow *glfwCreateWindow(int width, int height,
-                                     const char *title,
-                                     GLFWmonitor *monitor,
-                                     GLFWwindow *share)
+GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
+                                     const char* title,
+                                     GLFWmonitor* monitor,
+                                     GLFWwindow* share)
 {
     _GLFWfbconfig fbconfig;
     _GLFWctxconfig ctxconfig;
     _GLFWwndconfig wndconfig;
-    _GLFWwindow *window;
+    _GLFWwindow* window;
 
     assert(title != NULL);
     assert(width >= 0);
@@ -201,14 +202,14 @@ GLFWAPI GLFWwindow *glfwCreateWindow(int width, int height,
         return NULL;
     }
 
-    fbconfig = _glfw.hints.framebuffer;
+    fbconfig  = _glfw.hints.framebuffer;
     ctxconfig = _glfw.hints.context;
     wndconfig = _glfw.hints.window;
 
-    wndconfig.width = width;
-    wndconfig.height = height;
-    wndconfig.title = title;
-    ctxconfig.share = (_GLFWwindow *)share;
+    wndconfig.width   = width;
+    wndconfig.height  = height;
+    wndconfig.title   = title;
+    ctxconfig.share   = (_GLFWwindow*) share;
 
     if (!_glfwIsValidContextConfig(&ctxconfig))
         return NULL;
@@ -217,21 +218,21 @@ GLFWAPI GLFWwindow *glfwCreateWindow(int width, int height,
     window->next = _glfw.windowListHead;
     _glfw.windowListHead = window;
 
-    window->videoMode.width = width;
-    window->videoMode.height = height;
-    window->videoMode.redBits = fbconfig.redBits;
-    window->videoMode.greenBits = fbconfig.greenBits;
-    window->videoMode.blueBits = fbconfig.blueBits;
+    window->videoMode.width       = width;
+    window->videoMode.height      = height;
+    window->videoMode.redBits     = fbconfig.redBits;
+    window->videoMode.greenBits   = fbconfig.greenBits;
+    window->videoMode.blueBits    = fbconfig.blueBits;
     window->videoMode.refreshRate = _glfw.hints.refreshRate;
 
-    window->monitor = (_GLFWmonitor *)monitor;
-    window->resizable = wndconfig.resizable;
-    window->decorated = wndconfig.decorated;
-    window->autoIconify = wndconfig.autoIconify;
-    window->floating = wndconfig.floating;
-    window->focusOnShow = wndconfig.focusOnShow;
+    window->monitor          = (_GLFWmonitor*) monitor;
+    window->resizable        = wndconfig.resizable;
+    window->decorated        = wndconfig.decorated;
+    window->autoIconify      = wndconfig.autoIconify;
+    window->floating         = wndconfig.floating;
+    window->focusOnShow      = wndconfig.focusOnShow;
     window->mousePassthrough = wndconfig.mousePassthrough;
-    window->cursorMode = GLFW_CURSOR_NORMAL;
+    window->cursorMode       = GLFW_CURSOR_NORMAL;
 
     window->doublebuffer = fbconfig.doublebuffer;
 
@@ -245,11 +246,11 @@ GLFWAPI GLFWwindow *glfwCreateWindow(int width, int height,
 
     if (!_glfw.platform.createWindow(window, &wndconfig, &ctxconfig, &fbconfig))
     {
-        glfwDestroyWindow((GLFWwindow *)window);
+        glfwDestroyWindow((GLFWwindow*) window);
         return NULL;
     }
 
-    return (GLFWwindow *)window;
+    return (GLFWwindow*) window;
 }
 
 void glfwDefaultWindowHints(void)
@@ -260,16 +261,16 @@ void glfwDefaultWindowHints(void)
     memset(&_glfw.hints.context, 0, sizeof(_glfw.hints.context));
     _glfw.hints.context.client = GLFW_OPENGL_API;
     _glfw.hints.context.source = GLFW_NATIVE_CONTEXT_API;
-    _glfw.hints.context.major = 1;
-    _glfw.hints.context.minor = 0;
+    _glfw.hints.context.major  = 1;
+    _glfw.hints.context.minor  = 0;
 
     // The default is a focused, visible, resizable window with decorations
     memset(&_glfw.hints.window, 0, sizeof(_glfw.hints.window));
-    _glfw.hints.window.resizable = GLFW_TRUE;
-    _glfw.hints.window.visible = GLFW_TRUE;
-    _glfw.hints.window.decorated = GLFW_TRUE;
-    _glfw.hints.window.focused = GLFW_TRUE;
-    _glfw.hints.window.autoIconify = GLFW_TRUE;
+    _glfw.hints.window.resizable    = GLFW_TRUE;
+    _glfw.hints.window.visible      = GLFW_TRUE;
+    _glfw.hints.window.decorated    = GLFW_TRUE;
+    _glfw.hints.window.focused      = GLFW_TRUE;
+    _glfw.hints.window.autoIconify  = GLFW_TRUE;
     _glfw.hints.window.centerCursor = GLFW_TRUE;
     _glfw.hints.window.focusOnShow  = GLFW_TRUE;
     _glfw.hints.window.xpos         = GLFW_ANY_POSITION;
@@ -279,12 +280,12 @@ void glfwDefaultWindowHints(void)
     // The default is 24 bits of color, 24 bits of depth and 8 bits of stencil,
     // double buffered
     memset(&_glfw.hints.framebuffer, 0, sizeof(_glfw.hints.framebuffer));
-    _glfw.hints.framebuffer.redBits = 8;
-    _glfw.hints.framebuffer.greenBits = 8;
-    _glfw.hints.framebuffer.blueBits = 8;
-    _glfw.hints.framebuffer.alphaBits = 8;
-    _glfw.hints.framebuffer.depthBits = 24;
-    _glfw.hints.framebuffer.stencilBits = 8;
+    _glfw.hints.framebuffer.redBits      = 8;
+    _glfw.hints.framebuffer.greenBits    = 8;
+    _glfw.hints.framebuffer.blueBits     = 8;
+    _glfw.hints.framebuffer.alphaBits    = 8;
+    _glfw.hints.framebuffer.depthBits    = 24;
+    _glfw.hints.framebuffer.stencilBits  = 8;
     _glfw.hints.framebuffer.doublebuffer = GLFW_TRUE;
 
     // The default is to select the highest available refresh rate
@@ -435,7 +436,7 @@ GLFWAPI void glfwWindowHint(int hint, int value)
     _glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint 0x%08X", hint);
 }
 
-GLFWAPI void glfwWindowHintString(int hint, const char *value)
+GLFWAPI void glfwWindowHintString(int hint, const char* value)
 {
     assert(value != NULL);
 
@@ -443,28 +444,28 @@ GLFWAPI void glfwWindowHintString(int hint, const char *value)
 
     switch (hint)
     {
-    case GLFW_COCOA_FRAME_NAME:
-        strncpy(_glfw.hints.window.ns.frameName, value,
-                sizeof(_glfw.hints.window.ns.frameName) - 1);
-        return;
-    case GLFW_X11_CLASS_NAME:
-        strncpy(_glfw.hints.window.x11.className, value,
-                sizeof(_glfw.hints.window.x11.className) - 1);
-        return;
-    case GLFW_X11_INSTANCE_NAME:
-        strncpy(_glfw.hints.window.x11.instanceName, value,
-                sizeof(_glfw.hints.window.x11.instanceName) - 1);
-        return;
-    case GLFW_WAYLAND_APP_ID:
-        strncpy(_glfw.hints.window.wl.appId, value,
-                sizeof(_glfw.hints.window.wl.appId) - 1);
-        return;
+        case GLFW_COCOA_FRAME_NAME:
+            strncpy(_glfw.hints.window.ns.frameName, value,
+                    sizeof(_glfw.hints.window.ns.frameName) - 1);
+            return;
+        case GLFW_X11_CLASS_NAME:
+            strncpy(_glfw.hints.window.x11.className, value,
+                    sizeof(_glfw.hints.window.x11.className) - 1);
+            return;
+        case GLFW_X11_INSTANCE_NAME:
+            strncpy(_glfw.hints.window.x11.instanceName, value,
+                    sizeof(_glfw.hints.window.x11.instanceName) - 1);
+            return;
+        case GLFW_WAYLAND_APP_ID:
+            strncpy(_glfw.hints.window.wl.appId, value,
+                    sizeof(_glfw.hints.window.wl.appId) - 1);
+            return;
     }
 
     _glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint string 0x%08X", hint);
 }
 
-GLFWAPI void glfwDestroyWindow(GLFWwindow *handle)
+GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -486,7 +487,7 @@ GLFWAPI void glfwDestroyWindow(GLFWwindow *handle)
 
     // Unlink window from global linked list
     {
-        _GLFWwindow **prev = &_glfw.windowListHead;
+        _GLFWwindow** prev = &_glfw.windowListHead;
 
         while (*prev != window)
             prev = &((*prev)->next);
@@ -498,7 +499,7 @@ GLFWAPI void glfwDestroyWindow(GLFWwindow *handle)
     _glfw_free(window);
 }
 
-GLFWAPI int glfwWindowShouldClose(GLFWwindow *handle)
+GLFWAPI int glfwWindowShouldClose(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(0);
 
@@ -508,7 +509,7 @@ GLFWAPI int glfwWindowShouldClose(GLFWwindow *handle)
     return window->shouldClose;
 }
 
-GLFWAPI void glfwSetWindowShouldClose(GLFWwindow *handle, int value)
+GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* handle, int value)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -544,8 +545,8 @@ GLFWAPI void glfwSetWindowTitle(GLFWwindow* handle, const char* title)
     _glfw_free(prev);
 }
 
-GLFWAPI void glfwSetWindowIcon(GLFWwindow *handle,
-                               int count, const GLFWimage *images)
+GLFWAPI void glfwSetWindowIcon(GLFWwindow* handle,
+                               int count, const GLFWimage* images)
 {
     int i;
 
@@ -578,7 +579,7 @@ GLFWAPI void glfwSetWindowIcon(GLFWwindow *handle,
     _glfw.platform.setWindowIcon(window, count, images);
 }
 
-GLFWAPI void glfwGetWindowPos(GLFWwindow *handle, int *xpos, int *ypos)
+GLFWAPI void glfwGetWindowPos(GLFWwindow* handle, int* xpos, int* ypos)
 {
     if (xpos)
         *xpos = 0;
@@ -593,7 +594,7 @@ GLFWAPI void glfwGetWindowPos(GLFWwindow *handle, int *xpos, int *ypos)
     _glfw.platform.getWindowPos(window, xpos, ypos);
 }
 
-GLFWAPI void glfwSetWindowPos(GLFWwindow *handle, int xpos, int ypos)
+GLFWAPI void glfwSetWindowPos(GLFWwindow* handle, int xpos, int ypos)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -606,7 +607,7 @@ GLFWAPI void glfwSetWindowPos(GLFWwindow *handle, int xpos, int ypos)
     _glfw.platform.setWindowPos(window, xpos, ypos);
 }
 
-GLFWAPI void glfwGetWindowSize(GLFWwindow *handle, int *width, int *height)
+GLFWAPI void glfwGetWindowSize(GLFWwindow* handle, int* width, int* height)
 {
     if (width)
         *width = 0;
@@ -621,7 +622,7 @@ GLFWAPI void glfwGetWindowSize(GLFWwindow *handle, int *width, int *height)
     _glfw.platform.getWindowSize(window, width, height);
 }
 
-GLFWAPI void glfwSetWindowSize(GLFWwindow *handle, int width, int height)
+GLFWAPI void glfwSetWindowSize(GLFWwindow* handle, int width, int height)
 {
     assert(width >= 0);
     assert(height >= 0);
@@ -637,7 +638,7 @@ GLFWAPI void glfwSetWindowSize(GLFWwindow *handle, int width, int height)
     _glfw.platform.setWindowSize(window, width, height);
 }
 
-GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow *handle,
+GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* handle,
                                      int minwidth, int minheight,
                                      int maxwidth, int maxheight)
 {
@@ -669,9 +670,9 @@ GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow *handle,
         }
     }
 
-    window->minwidth = minwidth;
+    window->minwidth  = minwidth;
     window->minheight = minheight;
-    window->maxwidth = maxwidth;
+    window->maxwidth  = maxwidth;
     window->maxheight = maxheight;
 
     if (window->monitor || !window->resizable)
@@ -682,7 +683,7 @@ GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow *handle,
                                        maxwidth, maxheight);
 }
 
-GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow *handle, int numer, int denom)
+GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* handle, int numer, int denom)
 {
     assert(numer != 0);
     assert(denom != 0);
@@ -712,7 +713,7 @@ GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow *handle, int numer, int denom)
     _glfw.platform.setWindowAspectRatio(window, numer, denom);
 }
 
-GLFWAPI void glfwGetFramebufferSize(GLFWwindow *handle, int *width, int *height)
+GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
 {
     if (width)
         *width = 0;
@@ -727,9 +728,9 @@ GLFWAPI void glfwGetFramebufferSize(GLFWwindow *handle, int *width, int *height)
     _glfw.platform.getFramebufferSize(window, width, height);
 }
 
-GLFWAPI void glfwGetWindowFrameSize(GLFWwindow *handle,
-                                    int *left, int *top,
-                                    int *right, int *bottom)
+GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* handle,
+                                    int* left, int* top,
+                                    int* right, int* bottom)
 {
     if (left)
         *left = 0;
@@ -748,8 +749,8 @@ GLFWAPI void glfwGetWindowFrameSize(GLFWwindow *handle,
     _glfw.platform.getWindowFrameSize(window, left, top, right, bottom);
 }
 
-GLFWAPI void glfwGetWindowContentScale(GLFWwindow *handle,
-                                       float *xscale, float *yscale)
+GLFWAPI void glfwGetWindowContentScale(GLFWwindow* handle,
+                                       float* xscale, float* yscale)
 {
     if (xscale)
         *xscale = 0.f;
@@ -764,7 +765,7 @@ GLFWAPI void glfwGetWindowContentScale(GLFWwindow *handle,
     _glfw.platform.getWindowContentScale(window, xscale, yscale);
 }
 
-GLFWAPI float glfwGetWindowOpacity(GLFWwindow *handle)
+GLFWAPI float glfwGetWindowOpacity(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(0.f);
 
@@ -774,7 +775,7 @@ GLFWAPI float glfwGetWindowOpacity(GLFWwindow *handle)
     return _glfw.platform.getWindowOpacity(window);
 }
 
-GLFWAPI void glfwSetWindowOpacity(GLFWwindow *handle, float opacity)
+GLFWAPI void glfwSetWindowOpacity(GLFWwindow* handle, float opacity)
 {
     assert(opacity == opacity);
     assert(opacity >= 0.f);
@@ -794,7 +795,7 @@ GLFWAPI void glfwSetWindowOpacity(GLFWwindow *handle, float opacity)
     _glfw.platform.setWindowOpacity(window, opacity);
 }
 
-GLFWAPI void glfwIconifyWindow(GLFWwindow *handle)
+GLFWAPI void glfwIconifyWindow(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -804,7 +805,7 @@ GLFWAPI void glfwIconifyWindow(GLFWwindow *handle)
     _glfw.platform.iconifyWindow(window);
 }
 
-GLFWAPI void glfwRestoreWindow(GLFWwindow *handle)
+GLFWAPI void glfwRestoreWindow(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -814,7 +815,7 @@ GLFWAPI void glfwRestoreWindow(GLFWwindow *handle)
     _glfw.platform.restoreWindow(window);
 }
 
-GLFWAPI void glfwMaximizeWindow(GLFWwindow *handle)
+GLFWAPI void glfwMaximizeWindow(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -827,7 +828,7 @@ GLFWAPI void glfwMaximizeWindow(GLFWwindow *handle)
     _glfw.platform.maximizeWindow(window);
 }
 
-GLFWAPI void glfwShowWindow(GLFWwindow *handle)
+GLFWAPI void glfwShowWindow(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -843,7 +844,7 @@ GLFWAPI void glfwShowWindow(GLFWwindow *handle)
         _glfw.platform.focusWindow(window);
 }
 
-GLFWAPI void glfwRequestWindowAttention(GLFWwindow *handle)
+GLFWAPI void glfwRequestWindowAttention(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -853,7 +854,7 @@ GLFWAPI void glfwRequestWindowAttention(GLFWwindow *handle)
     _glfw.platform.requestWindowAttention(window);
 }
 
-GLFWAPI void glfwHideWindow(GLFWwindow *handle)
+GLFWAPI void glfwHideWindow(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -866,7 +867,7 @@ GLFWAPI void glfwHideWindow(GLFWwindow *handle)
     _glfw.platform.hideWindow(window);
 }
 
-GLFWAPI void glfwFocusWindow(GLFWwindow *handle)
+GLFWAPI void glfwFocusWindow(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -876,7 +877,7 @@ GLFWAPI void glfwFocusWindow(GLFWwindow *handle)
     _glfw.platform.focusWindow(window);
 }
 
-GLFWAPI int glfwGetWindowAttrib(GLFWwindow *handle, int attrib)
+GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(0);
 
@@ -885,61 +886,61 @@ GLFWAPI int glfwGetWindowAttrib(GLFWwindow *handle, int attrib)
 
     switch (attrib)
     {
-    case GLFW_FOCUSED:
-        return _glfw.platform.windowFocused(window);
-    case GLFW_ICONIFIED:
-        return _glfw.platform.windowIconified(window);
-    case GLFW_VISIBLE:
-        return _glfw.platform.windowVisible(window);
-    case GLFW_MAXIMIZED:
-        return _glfw.platform.windowMaximized(window);
-    case GLFW_HOVERED:
-        return _glfw.platform.windowHovered(window);
-    case GLFW_FOCUS_ON_SHOW:
-        return window->focusOnShow;
-    case GLFW_MOUSE_PASSTHROUGH:
-        return window->mousePassthrough;
-    case GLFW_TRANSPARENT_FRAMEBUFFER:
-        return _glfw.platform.framebufferTransparent(window);
-    case GLFW_RESIZABLE:
-        return window->resizable;
-    case GLFW_DECORATED:
-        return window->decorated;
-    case GLFW_FLOATING:
-        return window->floating;
-    case GLFW_AUTO_ICONIFY:
-        return window->autoIconify;
-    case GLFW_DOUBLEBUFFER:
-        return window->doublebuffer;
-    case GLFW_CLIENT_API:
-        return window->context.client;
-    case GLFW_CONTEXT_CREATION_API:
-        return window->context.source;
-    case GLFW_CONTEXT_VERSION_MAJOR:
-        return window->context.major;
-    case GLFW_CONTEXT_VERSION_MINOR:
-        return window->context.minor;
-    case GLFW_CONTEXT_REVISION:
-        return window->context.revision;
-    case GLFW_CONTEXT_ROBUSTNESS:
-        return window->context.robustness;
-    case GLFW_OPENGL_FORWARD_COMPAT:
-        return window->context.forward;
-    case GLFW_CONTEXT_DEBUG:
-        return window->context.debug;
-    case GLFW_OPENGL_PROFILE:
-        return window->context.profile;
-    case GLFW_CONTEXT_RELEASE_BEHAVIOR:
-        return window->context.release;
-    case GLFW_CONTEXT_NO_ERROR:
-        return window->context.noerror;
+        case GLFW_FOCUSED:
+            return _glfw.platform.windowFocused(window);
+        case GLFW_ICONIFIED:
+            return _glfw.platform.windowIconified(window);
+        case GLFW_VISIBLE:
+            return _glfw.platform.windowVisible(window);
+        case GLFW_MAXIMIZED:
+            return _glfw.platform.windowMaximized(window);
+        case GLFW_HOVERED:
+            return _glfw.platform.windowHovered(window);
+        case GLFW_FOCUS_ON_SHOW:
+            return window->focusOnShow;
+        case GLFW_MOUSE_PASSTHROUGH:
+            return window->mousePassthrough;
+        case GLFW_TRANSPARENT_FRAMEBUFFER:
+            return _glfw.platform.framebufferTransparent(window);
+        case GLFW_RESIZABLE:
+            return window->resizable;
+        case GLFW_DECORATED:
+            return window->decorated;
+        case GLFW_FLOATING:
+            return window->floating;
+        case GLFW_AUTO_ICONIFY:
+            return window->autoIconify;
+        case GLFW_DOUBLEBUFFER:
+            return window->doublebuffer;
+        case GLFW_CLIENT_API:
+            return window->context.client;
+        case GLFW_CONTEXT_CREATION_API:
+            return window->context.source;
+        case GLFW_CONTEXT_VERSION_MAJOR:
+            return window->context.major;
+        case GLFW_CONTEXT_VERSION_MINOR:
+            return window->context.minor;
+        case GLFW_CONTEXT_REVISION:
+            return window->context.revision;
+        case GLFW_CONTEXT_ROBUSTNESS:
+            return window->context.robustness;
+        case GLFW_OPENGL_FORWARD_COMPAT:
+            return window->context.forward;
+        case GLFW_CONTEXT_DEBUG:
+            return window->context.debug;
+        case GLFW_OPENGL_PROFILE:
+            return window->context.profile;
+        case GLFW_CONTEXT_RELEASE_BEHAVIOR:
+            return window->context.release;
+        case GLFW_CONTEXT_NO_ERROR:
+            return window->context.noerror;
     }
 
     _glfwInputError(GLFW_INVALID_ENUM, "Invalid window attribute 0x%08X", attrib);
     return 0;
 }
 
-GLFWAPI void glfwSetWindowAttrib(GLFWwindow *handle, int attrib, int value)
+GLFWAPI void glfwSetWindowAttrib(GLFWwindow* handle, int attrib, int value)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -950,42 +951,42 @@ GLFWAPI void glfwSetWindowAttrib(GLFWwindow *handle, int attrib, int value)
 
     switch (attrib)
     {
-    case GLFW_AUTO_ICONIFY:
-        window->autoIconify = value;
-        return;
+        case GLFW_AUTO_ICONIFY:
+            window->autoIconify = value;
+            return;
 
-    case GLFW_RESIZABLE:
-        window->resizable = value;
-        if (!window->monitor)
-            _glfw.platform.setWindowResizable(window, value);
-        return;
+        case GLFW_RESIZABLE:
+            window->resizable = value;
+            if (!window->monitor)
+                _glfw.platform.setWindowResizable(window, value);
+            return;
 
-    case GLFW_DECORATED:
-        window->decorated = value;
-        if (!window->monitor)
-            _glfw.platform.setWindowDecorated(window, value);
-        return;
+        case GLFW_DECORATED:
+            window->decorated = value;
+            if (!window->monitor)
+                _glfw.platform.setWindowDecorated(window, value);
+            return;
 
-    case GLFW_FLOATING:
-        window->floating = value;
-        if (!window->monitor)
-            _glfw.platform.setWindowFloating(window, value);
-        return;
+        case GLFW_FLOATING:
+            window->floating = value;
+            if (!window->monitor)
+                _glfw.platform.setWindowFloating(window, value);
+            return;
 
-    case GLFW_FOCUS_ON_SHOW:
-        window->focusOnShow = value;
-        return;
+        case GLFW_FOCUS_ON_SHOW:
+            window->focusOnShow = value;
+            return;
 
-    case GLFW_MOUSE_PASSTHROUGH:
-        window->mousePassthrough = value;
-        _glfw.platform.setWindowMousePassthrough(window, value);
-        return;
+        case GLFW_MOUSE_PASSTHROUGH:
+            window->mousePassthrough = value;
+            _glfw.platform.setWindowMousePassthrough(window, value);
+            return;
     }
 
     _glfwInputError(GLFW_INVALID_ENUM, "Invalid window attribute 0x%08X", attrib);
 }
 
-GLFWAPI GLFWmonitor *glfwGetWindowMonitor(GLFWwindow *handle)
+GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -995,8 +996,8 @@ GLFWAPI GLFWmonitor *glfwGetWindowMonitor(GLFWwindow *handle)
     return (GLFWmonitor*) window->monitor;
 }
 
-GLFWAPI void glfwSetWindowMonitor(GLFWwindow *wh,
-                                  GLFWmonitor *mh,
+GLFWAPI void glfwSetWindowMonitor(GLFWwindow* wh,
+                                  GLFWmonitor* mh,
                                   int xpos, int ypos,
                                   int width, int height,
                                   int refreshRate)
@@ -1026,8 +1027,8 @@ GLFWAPI void glfwSetWindowMonitor(GLFWwindow *wh,
         return;
     }
 
-    window->videoMode.width = width;
-    window->videoMode.height = height;
+    window->videoMode.width       = width;
+    window->videoMode.height      = height;
     window->videoMode.refreshRate = refreshRate;
 
     _glfw.platform.setWindowMonitor(window, monitor,
@@ -1035,7 +1036,7 @@ GLFWAPI void glfwSetWindowMonitor(GLFWwindow *wh,
                                     refreshRate);
 }
 
-GLFWAPI void glfwSetWindowUserPointer(GLFWwindow *handle, void *pointer)
+GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* handle, void* pointer)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -1045,7 +1046,7 @@ GLFWAPI void glfwSetWindowUserPointer(GLFWwindow *handle, void *pointer)
     window->userPointer = pointer;
 }
 
-GLFWAPI void *glfwGetWindowUserPointer(GLFWwindow *handle)
+GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -1055,7 +1056,7 @@ GLFWAPI void *glfwGetWindowUserPointer(GLFWwindow *handle)
     return window->userPointer;
 }
 
-GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow *handle,
+GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* handle,
                                                   GLFWwindowposfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1067,7 +1068,7 @@ GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow *handle,
     return cbfun;
 }
 
-GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow *handle,
+GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* handle,
                                                     GLFWwindowsizefun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1079,7 +1080,7 @@ GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow *handle,
     return cbfun;
 }
 
-GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow *handle,
+GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* handle,
                                                       GLFWwindowclosefun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1091,7 +1092,7 @@ GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow *handle,
     return cbfun;
 }
 
-GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow *handle,
+GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* handle,
                                                           GLFWwindowrefreshfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1103,7 +1104,7 @@ GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow *handle,
     return cbfun;
 }
 
-GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow *handle,
+GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* handle,
                                                       GLFWwindowfocusfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1115,7 +1116,7 @@ GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow *handle,
     return cbfun;
 }
 
-GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow *handle,
+GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* handle,
                                                           GLFWwindowiconifyfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1127,7 +1128,7 @@ GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow *handle,
     return cbfun;
 }
 
-GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow *handle,
+GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* handle,
                                                             GLFWwindowmaximizefun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1139,7 +1140,7 @@ GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow *handle,
     return cbfun;
 }
 
-GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow *handle,
+GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* handle,
                                                               GLFWframebuffersizefun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1151,7 +1152,7 @@ GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow *handle
     return cbfun;
 }
 
-GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow *handle,
+GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* handle,
                                                                     GLFWwindowcontentscalefun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1198,3 +1199,4 @@ GLFWAPI void glfwPostEmptyEvent(void)
     _GLFW_REQUIRE_INIT();
     _glfw.platform.postEmptyEvent();
 }
+
diff --git a/src/x11_window.c b/src/x11_window.c
index df82d4c2..322349f0 100644
--- a/src/x11_window.c
+++ b/src/x11_window.c
@@ -42,17 +42,17 @@
 #include <assert.h>
 
 // Action for EWMH client messages
-#define _NET_WM_STATE_REMOVE 0
-#define _NET_WM_STATE_ADD 1
-#define _NET_WM_STATE_TOGGLE 2
+#define _NET_WM_STATE_REMOVE        0
+#define _NET_WM_STATE_ADD           1
+#define _NET_WM_STATE_TOGGLE        2
 
 // Additional mouse button names for XButtonEvent
-#define Button6 6
-#define Button7 7
+#define Button6            6
+#define Button7            7
 
 // Motif WM hints flags
-#define MWM_HINTS_DECORATIONS 2
-#define MWM_DECOR_ALL 1
+#define MWM_HINTS_DECORATIONS   2
+#define MWM_DECOR_ALL           1
 
 #define _GLFW_XDND_VERSION 5
 
@@ -60,9 +60,9 @@
 // This avoids blocking other threads via the per-display Xlib lock that also
 // covers GLX functions
 //
-static GLFWbool waitForX11Event(double *timeout)
+static GLFWbool waitForX11Event(double* timeout)
 {
-    struct pollfd fd = {ConnectionNumber(_glfw.x11.display), POLLIN};
+    struct pollfd fd = { ConnectionNumber(_glfw.x11.display), POLLIN };
 
     while (!XPending(_glfw.x11.display))
     {
@@ -77,7 +77,7 @@ static GLFWbool waitForX11Event(double *timeout)
 // This avoids blocking other threads via the per-display Xlib lock that also
 // covers GLX functions
 //
-static GLFWbool waitForAnyEvent(double *timeout)
+static GLFWbool waitForAnyEvent(double* timeout)
 {
     enum { XLIB_FD, PIPE_FD, INOTIFY_FD };
     struct pollfd fds[] =
@@ -136,7 +136,7 @@ static void drainEmptyEvents(void)
 // Waits until a VisibilityNotify event arrives for the specified window or the
 // timeout period elapses (ICCCM section 4.2.2)
 //
-static GLFWbool waitForVisibilityNotify(_GLFWwindow *window)
+static GLFWbool waitForVisibilityNotify(_GLFWwindow* window)
 {
     XEvent dummy;
     double timeout = 0.1;
@@ -155,11 +155,10 @@ static GLFWbool waitForVisibilityNotify(_GLFWwindow *window)
 
 // Returns whether the window is iconified
 //
-static int getWindowState(_GLFWwindow *window)
+static int getWindowState(_GLFWwindow* window)
 {
     int result = WithdrawnState;
-    struct
-    {
+    struct {
         CARD32 state;
         Window icon;
     } *state = NULL;
@@ -167,7 +166,7 @@ static int getWindowState(_GLFWwindow *window)
     if (_glfwGetWindowPropertyX11(window->x11.handle,
                                   _glfw.x11.WM_STATE,
                                   _glfw.x11.WM_STATE,
-                                  (unsigned char **)&state) >= 2)
+                                  (unsigned char**) &state) >= 2)
     {
         result = state->state;
     }
@@ -180,7 +179,7 @@ static int getWindowState(_GLFWwindow *window)
 
 // Returns whether the event is a selection event
 //
-static Bool isSelectionEvent(Display *display, XEvent *event, XPointer pointer)
+static Bool isSelectionEvent(Display* display, XEvent* event, XPointer pointer)
 {
     if (event->xany.window != _glfw.x11.helperWindowHandle)
         return False;
@@ -192,9 +191,9 @@ static Bool isSelectionEvent(Display *display, XEvent *event, XPointer pointer)
 
 // Returns whether it is a _NET_FRAME_EXTENTS event for the specified window
 //
-static Bool isFrameExtentsEvent(Display *display, XEvent *event, XPointer pointer)
+static Bool isFrameExtentsEvent(Display* display, XEvent* event, XPointer pointer)
 {
-    _GLFWwindow *window = (_GLFWwindow *)pointer;
+    _GLFWwindow* window = (_GLFWwindow*) pointer;
     return event->type == PropertyNotify &&
            event->xproperty.state == PropertyNewValue &&
            event->xproperty.window == window->x11.handle &&
@@ -203,9 +202,9 @@ static Bool isFrameExtentsEvent(Display *display, XEvent *event, XPointer pointe
 
 // Returns whether it is a property event for the specified selection transfer
 //
-static Bool isSelPropNewValueNotify(Display *display, XEvent *event, XPointer pointer)
+static Bool isSelPropNewValueNotify(Display* display, XEvent* event, XPointer pointer)
 {
-    XEvent *notification = (XEvent *)pointer;
+    XEvent* notification = (XEvent*) pointer;
     return event->type == PropertyNotify &&
            event->xproperty.state == PropertyNewValue &&
            event->xproperty.window == notification->xselection.requestor &&
@@ -247,10 +246,10 @@ static int translateKey(int scancode)
 
 // Sends an EWMH or ICCCM event to the window manager
 //
-static void sendEventToWM(_GLFWwindow *window, Atom type,
+static void sendEventToWM(_GLFWwindow* window, Atom type,
                           long a, long b, long c, long d, long e)
 {
-    XEvent event = {ClientMessage};
+    XEvent event = { ClientMessage };
     event.xclient.window = window->x11.handle;
     event.xclient.format = 32; // Data is 32-bit longs
     event.xclient.message_type = type;
@@ -268,9 +267,9 @@ static void sendEventToWM(_GLFWwindow *window, Atom type,
 
 // Updates the normal hints according to the window settings
 //
-static void updateNormalHints(_GLFWwindow *window, int width, int height)
+static void updateNormalHints(_GLFWwindow* window, int width, int height)
 {
-    XSizeHints *hints = XAllocSizeHints();
+    XSizeHints* hints = XAllocSizeHints();
 
     long supplied;
     XGetWMNormalHints(_glfw.x11.display, window->x11.handle, hints, &supplied);
@@ -308,7 +307,7 @@ static void updateNormalHints(_GLFWwindow *window, int width, int height)
         else
         {
             hints->flags |= (PMinSize | PMaxSize);
-            hints->min_width = hints->max_width = width;
+            hints->min_width  = hints->max_width  = width;
             hints->min_height = hints->max_height = height;
         }
     }
@@ -319,7 +318,7 @@ static void updateNormalHints(_GLFWwindow *window, int width, int height)
 
 // Updates the full screen status of the window
 //
-static void updateWindowMode(_GLFWwindow *window)
+static void updateWindowMode(_GLFWwindow* window)
 {
     if (window->monitor)
     {
@@ -368,9 +367,9 @@ static void updateWindowMode(_GLFWwindow *window)
         {
             const unsigned long value = 1;
 
-            XChangeProperty(_glfw.x11.display, window->x11.handle,
+            XChangeProperty(_glfw.x11.display,  window->x11.handle,
                             _glfw.x11.NET_WM_BYPASS_COMPOSITOR, XA_CARDINAL, 32,
-                            PropModeReplace, (unsigned char *)&value, 1);
+                            PropModeReplace, (unsigned char*) &value, 1);
         }
     }
     else
@@ -414,17 +413,18 @@ static void updateWindowMode(_GLFWwindow *window)
 // Decode a Unicode code point from a UTF-8 stream
 // Based on cutef8 by Jeff Bezanson (Public Domain)
 //
-static uint32_t decodeUTF8(const char **s)
+static uint32_t decodeUTF8(const char** s)
 {
     uint32_t codepoint = 0, count = 0;
     static const uint32_t offsets[] =
-        {
-            0x00000000u, 0x00003080u, 0x000e2080u,
-            0x03c82080u, 0xfa082080u, 0x82082080u};
+    {
+        0x00000000u, 0x00003080u, 0x000e2080u,
+        0x03c82080u, 0xfa082080u, 0x82082080u
+    };
 
     do
     {
-        codepoint = (codepoint << 6) + (unsigned char)**s;
+        codepoint = (codepoint << 6) + (unsigned char) **s;
         (*s)++;
         count++;
     } while ((**s & 0xc0) == 0x80);
@@ -435,18 +435,18 @@ static uint32_t decodeUTF8(const char **s)
 
 // Convert the specified Latin-1 string to UTF-8
 //
-static char *convertLatin1toUTF8(const char *source)
+static char* convertLatin1toUTF8(const char* source)
 {
     size_t size = 1;
-    const char *sp;
+    const char* sp;
 
-    for (sp = source; *sp; sp++)
+    for (sp = source;  *sp;  sp++)
         size += (*sp & 0x80) ? 2 : 1;
 
-    char *target = _glfw_calloc(size, 1);
-    char *tp = target;
+    char* target = _glfw_calloc(size, 1);
+    char* tp = target;
 
-    for (sp = source; *sp; sp++)
+    for (sp = source;  *sp;  sp++)
         tp += _glfwEncodeUTF8(tp, *sp);
 
     return target;
@@ -454,7 +454,7 @@ static char *convertLatin1toUTF8(const char *source)
 
 // Updates the cursor image according to its cursor mode
 //
-static void updateCursorImage(_GLFWwindow *window)
+static void updateCursorImage(_GLFWwindow* window)
 {
     if (window->cursorMode == GLFW_CURSOR_NORMAL ||
         window->cursorMode == GLFW_CURSOR_CAPTURED)
@@ -476,7 +476,7 @@ static void updateCursorImage(_GLFWwindow *window)
 
 // Grabs the cursor and confines it to the window
 //
-static void captureCursor(_GLFWwindow *window)
+static void captureCursor(_GLFWwindow* window)
 {
     XGrabPointer(_glfw.x11.display, window->x11.handle, True,
                  ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
@@ -495,10 +495,10 @@ static void releaseCursor(void)
 
 // Enable XI2 raw mouse motion events
 //
-static void enableRawMouseMotion(_GLFWwindow *window)
+static void enableRawMouseMotion(_GLFWwindow* window)
 {
     XIEventMask em;
-    unsigned char mask[XIMaskLen(XI_RawMotion)] = {0};
+    unsigned char mask[XIMaskLen(XI_RawMotion)] = { 0 };
 
     em.deviceid = XIAllMasterDevices;
     em.mask_len = sizeof(mask);
@@ -510,10 +510,10 @@ static void enableRawMouseMotion(_GLFWwindow *window)
 
 // Disable XI2 raw mouse motion events
 //
-static void disableRawMouseMotion(_GLFWwindow *window)
+static void disableRawMouseMotion(_GLFWwindow* window)
 {
     XIEventMask em;
-    unsigned char mask[] = {0};
+    unsigned char mask[] = { 0 };
 
     em.deviceid = XIAllMasterDevices;
     em.mask_len = sizeof(mask);
@@ -524,7 +524,7 @@ static void disableRawMouseMotion(_GLFWwindow *window)
 
 // Apply disabled cursor mode to a focused window
 //
-static void disableCursor(_GLFWwindow *window)
+static void disableCursor(_GLFWwindow* window)
 {
     if (window->rawMouseMotion)
         enableRawMouseMotion(window);
@@ -540,7 +540,7 @@ static void disableCursor(_GLFWwindow *window)
 
 // Exit disabled cursor mode for the specified window
 //
-static void enableCursor(_GLFWwindow *window)
+static void enableCursor(_GLFWwindow* window)
 {
     if (window->rawMouseMotion)
         disableRawMouseMotion(window);
@@ -557,15 +557,15 @@ static void enableCursor(_GLFWwindow *window)
 //
 static void inputContextDestroyCallback(XIC ic, XPointer clientData, XPointer callData)
 {
-    _GLFWwindow *window = (_GLFWwindow *)clientData;
+    _GLFWwindow* window = (_GLFWwindow*) clientData;
     window->x11.ic = NULL;
 }
 
 // Create the X11 window (and its colormap)
 //
-static GLFWbool createNativeWindow(_GLFWwindow *window,
-                                   const _GLFWwndconfig *wndconfig,
-                                   Visual *visual, int depth)
+static GLFWbool createNativeWindow(_GLFWwindow* window,
+                                   const _GLFWwndconfig* wndconfig,
+                                   Visual* visual, int depth)
 {
     int width = wndconfig->width;
     int height = wndconfig->height;
@@ -592,7 +592,7 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
 
     window->x11.transparent = _glfwIsVisualTransparentX11(visual);
 
-    XSetWindowAttributes wa = {0};
+    XSetWindowAttributes wa = { 0 };
     wa.colormap = window->x11.colormap;
     wa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask |
                     PointerMotionMask | ButtonPressMask | ButtonReleaseMask |
@@ -606,8 +606,8 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
                                        _glfw.x11.root,
                                        xpos, ypos,
                                        width, height,
-                                       0,     // Border width
-                                       depth, // Color depth
+                                       0,      // Border width
+                                       depth,  // Color depth
                                        InputOutput,
                                        visual,
                                        CWBorderPixel | CWColormap | CWEventMask,
@@ -625,7 +625,7 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
     XSaveContext(_glfw.x11.display,
                  window->x11.handle,
                  _glfw.x11.context,
-                 (XPointer)window);
+                 (XPointer) window);
 
     if (!wndconfig->decorated)
         _glfwSetWindowDecoratedX11(window, GLFW_FALSE);
@@ -656,16 +656,17 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
         {
             XChangeProperty(_glfw.x11.display, window->x11.handle,
                             _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
-                            PropModeReplace, (unsigned char *)states, count);
+                            PropModeReplace, (unsigned char*) states, count);
         }
     }
 
     // Declare the WM protocols supported by GLFW
     {
         Atom protocols[] =
-            {
-                _glfw.x11.WM_DELETE_WINDOW,
-                _glfw.x11.NET_WM_PING};
+        {
+            _glfw.x11.WM_DELETE_WINDOW,
+            _glfw.x11.NET_WM_PING
+        };
 
         XSetWMProtocols(_glfw.x11.display, window->x11.handle,
                         protocols, sizeof(protocols) / sizeof(Atom));
@@ -675,23 +676,23 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
     {
         const long pid = getpid();
 
-        XChangeProperty(_glfw.x11.display, window->x11.handle,
+        XChangeProperty(_glfw.x11.display,  window->x11.handle,
                         _glfw.x11.NET_WM_PID, XA_CARDINAL, 32,
                         PropModeReplace,
-                        (unsigned char *)&pid, 1);
+                        (unsigned char*) &pid, 1);
     }
 
     if (_glfw.x11.NET_WM_WINDOW_TYPE && _glfw.x11.NET_WM_WINDOW_TYPE_NORMAL)
     {
         Atom type = _glfw.x11.NET_WM_WINDOW_TYPE_NORMAL;
-        XChangeProperty(_glfw.x11.display, window->x11.handle,
+        XChangeProperty(_glfw.x11.display,  window->x11.handle,
                         _glfw.x11.NET_WM_WINDOW_TYPE, XA_ATOM, 32,
-                        PropModeReplace, (unsigned char *)&type, 1);
+                        PropModeReplace, (unsigned char*) &type, 1);
     }
 
     // Set ICCCM WM_HINTS property
     {
-        XWMHints *hints = XAllocWMHints();
+        XWMHints* hints = XAllocWMHints();
         if (!hints)
         {
             _glfwInputError(GLFW_OUT_OF_MEMORY,
@@ -708,7 +709,7 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
 
     // Set ICCCM WM_NORMAL_HINTS property
     {
-        XSizeHints *hints = XAllocSizeHints();
+        XSizeHints* hints = XAllocSizeHints();
         if (!hints)
         {
             _glfwInputError(GLFW_OUT_OF_MEMORY, "X11: Failed to allocate size hints");
@@ -718,7 +719,7 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
         if (!wndconfig->resizable)
         {
             hints->flags |= (PMinSize | PMaxSize);
-            hints->min_width = hints->max_width = width;
+            hints->min_width  = hints->max_width  = width;
             hints->min_height = hints->max_height = height;
         }
 
@@ -740,28 +741,28 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
 
     // Set ICCCM WM_CLASS property
     {
-        XClassHint *hint = XAllocClassHint();
+        XClassHint* hint = XAllocClassHint();
 
         if (strlen(wndconfig->x11.instanceName) &&
             strlen(wndconfig->x11.className))
         {
-            hint->res_name = (char *)wndconfig->x11.instanceName;
-            hint->res_class = (char *)wndconfig->x11.className;
+            hint->res_name = (char*) wndconfig->x11.instanceName;
+            hint->res_class = (char*) wndconfig->x11.className;
         }
         else
         {
-            const char *resourceName = getenv("RESOURCE_NAME");
+            const char* resourceName = getenv("RESOURCE_NAME");
             if (resourceName && strlen(resourceName))
-                hint->res_name = (char *)resourceName;
+                hint->res_name = (char*) resourceName;
             else if (strlen(wndconfig->title))
-                hint->res_name = (char *)wndconfig->title;
+                hint->res_name = (char*) wndconfig->title;
             else
-                hint->res_name = (char *)"glfw-application";
+                hint->res_name = (char*) "glfw-application";
 
             if (strlen(wndconfig->title))
-                hint->res_class = (char *)wndconfig->title;
+                hint->res_class = (char*) wndconfig->title;
             else
-                hint->res_class = (char *)"GLFW-Application";
+                hint->res_class = (char*) "GLFW-Application";
         }
 
         XSetClassHint(_glfw.x11.display, window->x11.handle, hint);
@@ -773,7 +774,7 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
         const Atom version = _GLFW_XDND_VERSION;
         XChangeProperty(_glfw.x11.display, window->x11.handle,
                         _glfw.x11.XdndAware, XA_ATOM, 32,
-                        PropModeReplace, (unsigned char *)&version, 1);
+                        PropModeReplace, (unsigned char*) &version, 1);
     }
 
     if (_glfw.x11.im)
@@ -788,10 +789,10 @@ static GLFWbool createNativeWindow(_GLFWwindow *window,
 
 // Set the specified property to the selection converted to the requested target
 //
-static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
+static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
 {
-    char *selectionString = NULL;
-    const Atom formats[] = {_glfw.x11.UTF8_STRING, XA_STRING};
+    char* selectionString = NULL;
+    const Atom formats[] = { _glfw.x11.UTF8_STRING, XA_STRING };
     const int formatCount = sizeof(formats) / sizeof(formats[0]);
 
     if (request->selection == _glfw.x11.PRIMARY)
@@ -810,10 +811,10 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
     {
         // The list of supported targets was requested
 
-        const Atom targets[] = {_glfw.x11.TARGETS,
-                                _glfw.x11.MULTIPLE,
-                                _glfw.x11.UTF8_STRING,
-                                XA_STRING};
+        const Atom targets[] = { _glfw.x11.TARGETS,
+                                 _glfw.x11.MULTIPLE,
+                                 _glfw.x11.UTF8_STRING,
+                                 XA_STRING };
 
         XChangeProperty(_glfw.x11.display,
                         request->requestor,
@@ -821,7 +822,7 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
                         XA_ATOM,
                         32,
                         PropModeReplace,
-                        (unsigned char *)targets,
+                        (unsigned char*) targets,
                         sizeof(targets) / sizeof(targets[0]));
 
         return request->property;
@@ -831,18 +832,18 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
     {
         // Multiple conversions were requested
 
-        Atom *targets;
+        Atom* targets;
         const unsigned long count =
             _glfwGetWindowPropertyX11(request->requestor,
                                       request->property,
                                       _glfw.x11.ATOM_PAIR,
-                                      (unsigned char **)&targets);
+                                      (unsigned char**) &targets);
 
-        for (unsigned long i = 0; i < count; i += 2)
+        for (unsigned long i = 0;  i < count;  i += 2)
         {
             int j;
 
-            for (j = 0; j < formatCount; j++)
+            for (j = 0;  j < formatCount;  j++)
             {
                 if (targets[i] == formats[j])
                     break;
@@ -856,7 +857,7 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
                                 targets[i],
                                 8,
                                 PropModeReplace,
-                                (unsigned char *)selectionString,
+                                (unsigned char *) selectionString,
                                 strlen(selectionString));
             }
             else
@@ -869,7 +870,7 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
                         _glfw.x11.ATOM_PAIR,
                         32,
                         PropModeReplace,
-                        (unsigned char *)targets,
+                        (unsigned char*) targets,
                         count);
 
         XFree(targets);
@@ -896,7 +897,7 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
 
     // Conversion to a data target was requested
 
-    for (int i = 0; i < formatCount; i++)
+    for (int i = 0;  i < formatCount;  i++)
     {
         if (request->target == formats[i])
         {
@@ -908,7 +909,7 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
                             request->target,
                             8,
                             PropModeReplace,
-                            (unsigned char *)selectionString,
+                            (unsigned char *) selectionString,
                             strlen(selectionString));
 
             return request->property;
@@ -920,11 +921,11 @@ static Atom writeTargetToProperty(const XSelectionRequestEvent *request)
     return None;
 }
 
-static void handleSelectionRequest(XEvent *event)
+static void handleSelectionRequest(XEvent* event)
 {
-    const XSelectionRequestEvent *request = &event->xselectionrequest;
+    const XSelectionRequestEvent* request = &event->xselectionrequest;
 
-    XEvent reply = {SelectionNotify};
+    XEvent reply = { SelectionNotify };
     reply.xselection.property = writeTargetToProperty(request);
     reply.xselection.display = request->display;
     reply.xselection.requestor = request->requestor;
@@ -935,10 +936,10 @@ static void handleSelectionRequest(XEvent *event)
     XSendEvent(_glfw.x11.display, request->requestor, False, 0, &reply);
 }
 
-static const char *getSelectionString(Atom selection)
+static const char* getSelectionString(Atom selection)
 {
-    char **selectionString = NULL;
-    const Atom targets[] = {_glfw.x11.UTF8_STRING, XA_STRING};
+    char** selectionString = NULL;
+    const Atom targets[] = { _glfw.x11.UTF8_STRING, XA_STRING };
     const size_t targetCount = sizeof(targets) / sizeof(targets[0]);
 
     if (selection == _glfw.x11.PRIMARY)
@@ -957,9 +958,9 @@ static const char *getSelectionString(Atom selection)
     _glfw_free(*selectionString);
     *selectionString = NULL;
 
-    for (size_t i = 0; i < targetCount; i++)
+    for (size_t i = 0;  i < targetCount;  i++)
     {
-        char *data;
+        char* data;
         Atom actualType;
         int actualFormat;
         unsigned long itemCount, bytesAfter;
@@ -986,7 +987,7 @@ static const char *getSelectionString(Atom selection)
         XCheckIfEvent(_glfw.x11.display,
                       &dummy,
                       isSelPropNewValueNotify,
-                      (XPointer)&notification);
+                      (XPointer) &notification);
 
         XGetWindowProperty(_glfw.x11.display,
                            notification.xselection.requestor,
@@ -999,19 +1000,19 @@ static const char *getSelectionString(Atom selection)
                            &actualFormat,
                            &itemCount,
                            &bytesAfter,
-                           (unsigned char **)&data);
+                           (unsigned char**) &data);
 
         if (actualType == _glfw.x11.INCR)
         {
             size_t size = 1;
-            char *string = NULL;
+            char* string = NULL;
 
             for (;;)
             {
                 while (!XCheckIfEvent(_glfw.x11.display,
                                       &dummy,
                                       isSelPropNewValueNotify,
-                                      (XPointer)&notification))
+                                      (XPointer) &notification))
                 {
                     waitForX11Event(NULL);
                 }
@@ -1028,7 +1029,7 @@ static const char *getSelectionString(Atom selection)
                                    &actualFormat,
                                    &itemCount,
                                    &bytesAfter,
-                                   (unsigned char **)&data);
+                                   (unsigned char**) &data);
 
                 if (itemCount)
                 {
@@ -1080,7 +1081,7 @@ static const char *getSelectionString(Atom selection)
 
 // Make the specified window and its video mode active on its monitor
 //
-static void acquireMonitor(_GLFWwindow *window)
+static void acquireMonitor(_GLFWwindow* window)
 {
     if (_glfw.x11.saver.count == 0)
     {
@@ -1119,7 +1120,7 @@ static void acquireMonitor(_GLFWwindow *window)
 
 // Remove the window and restore the original video mode
 //
-static void releaseMonitor(_GLFWwindow *window)
+static void releaseMonitor(_GLFWwindow* window)
 {
     if (window->monitor->window != window)
         return;
@@ -1167,10 +1168,10 @@ static void processEvent(XEvent *event)
     {
         if (event->type == _glfw.x11.xkb.eventBase + XkbEventCode)
         {
-            if (((XkbEvent *)event)->any.xkb_type == XkbStateNotify &&
-                (((XkbEvent *)event)->state.changed & XkbGroupStateMask))
+            if (((XkbEvent*) event)->any.xkb_type == XkbStateNotify &&
+                (((XkbEvent*) event)->state.changed & XkbGroupStateMask))
             {
-                _glfw.x11.xkb.group = ((XkbEvent *)event)->state.group;
+                _glfw.x11.xkb.group = ((XkbEvent*) event)->state.group;
             }
 
             return;
@@ -1181,7 +1182,7 @@ static void processEvent(XEvent *event)
     {
         if (_glfw.x11.xi.available)
         {
-            _GLFWwindow *window = _glfw.x11.disabledCursorWindow;
+            _GLFWwindow* window = _glfw.x11.disabledCursorWindow;
 
             if (window &&
                 window->rawMouseMotion &&
@@ -1189,10 +1190,10 @@ static void processEvent(XEvent *event)
                 XGetEventData(_glfw.x11.display, &event->xcookie) &&
                 event->xcookie.evtype == XI_RawMotion)
             {
-                XIRawEvent *re = event->xcookie.data;
+                XIRawEvent* re = event->xcookie.data;
                 if (re->valuators.mask_len)
                 {
-                    const double *values = re->raw_values;
+                    const double* values = re->raw_values;
                     double xpos = window->virtualCursorPosX;
                     double ypos = window->virtualCursorPosY;
 
@@ -1221,11 +1222,11 @@ static void processEvent(XEvent *event)
         return;
     }
 
-    _GLFWwindow *window = NULL;
+    _GLFWwindow* window = NULL;
     if (XFindContext(_glfw.x11.display,
                      event->xany.window,
                      _glfw.x11.context,
-                     (XPointer *)&window) != 0)
+                     (XPointer*) &window) != 0)
     {
         // This is an event for a window that has already been destroyed
         return;
@@ -1233,385 +1234,128 @@ static void processEvent(XEvent *event)
 
     switch (event->type)
     {
-    case ReparentNotify:
-    {
-        window->x11.parent = event->xreparent.parent;
-        return;
-    }
-
-    case KeyPress:
-    {
-        const int key = translateKey(keycode);
-        const int mods = translateState(event->xkey.state);
-        const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
-
-        if (window->x11.ic)
+        case ReparentNotify:
         {
-            // HACK: Do not report the key press events duplicated by XIM
-            //       Duplicate key releases are filtered out implicitly by
-            //       the GLFW key repeat logic in _glfwInputKey
-            //       A timestamp per key is used to handle simultaneous keys
-            // NOTE: Always allow the first event for each key through
-            //       (the server never sends a timestamp of zero)
-            // NOTE: Timestamp difference is compared to handle wrap-around
-            Time diff = event->xkey.time - window->x11.keyPressTimes[keycode];
-            if (diff == event->xkey.time || (diff > 0 && diff < ((Time)1 << 31)))
+            window->x11.parent = event->xreparent.parent;
+            return;
+        }
+
+        case KeyPress:
+        {
+            const int key = translateKey(keycode);
+            const int mods = translateState(event->xkey.state);
+            const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
+
+            if (window->x11.ic)
             {
-                if (keycode)
-                    _glfwInputKey(window, key, keycode, GLFW_PRESS, mods);
-
-                window->x11.keyPressTimes[keycode] = event->xkey.time;
-            }
-
-            if (!filtered)
-            {
-                int count;
-                Status status;
-                char buffer[100];
-                char *chars = buffer;
-
-                count = Xutf8LookupString(window->x11.ic,
-                                          &event->xkey,
-                                          buffer, sizeof(buffer) - 1,
-                                          NULL, &status);
-
-                if (status == XBufferOverflow)
+                // HACK: Do not report the key press events duplicated by XIM
+                //       Duplicate key releases are filtered out implicitly by
+                //       the GLFW key repeat logic in _glfwInputKey
+                //       A timestamp per key is used to handle simultaneous keys
+                // NOTE: Always allow the first event for each key through
+                //       (the server never sends a timestamp of zero)
+                // NOTE: Timestamp difference is compared to handle wrap-around
+                Time diff = event->xkey.time - window->x11.keyPressTimes[keycode];
+                if (diff == event->xkey.time || (diff > 0 && diff < ((Time)1 << 31)))
                 {
-                    chars = _glfw_calloc(count + 1, 1);
+                    if (keycode)
+                        _glfwInputKey(window, key, keycode, GLFW_PRESS, mods);
+
+                    window->x11.keyPressTimes[keycode] = event->xkey.time;
+                }
+
+                if (!filtered)
+                {
+                    int count;
+                    Status status;
+                    char buffer[100];
+                    char* chars = buffer;
+
                     count = Xutf8LookupString(window->x11.ic,
                                               &event->xkey,
-                                              chars, count,
+                                              buffer, sizeof(buffer) - 1,
                                               NULL, &status);
-                }
 
-                if (status == XLookupChars || status == XLookupBoth)
-                {
-                    const char *c = chars;
-                    chars[count] = '\0';
-                    while (c - chars < count)
-                        _glfwInputChar(window, decodeUTF8(&c), mods, plain);
-                }
-
-                if (chars != buffer)
-                    _glfw_free(chars);
-            }
-        }
-        else
-        {
-            KeySym keysym;
-            XLookupString(&event->xkey, NULL, 0, &keysym, NULL);
-
-            _glfwInputKey(window, key, keycode, GLFW_PRESS, mods);
-
-            const uint32_t codepoint = _glfwKeySym2Unicode(keysym);
-            if (codepoint != GLFW_INVALID_CODEPOINT)
-                _glfwInputChar(window, codepoint, mods, plain);
-        }
-
-        return;
-    }
-
-    case KeyRelease:
-    {
-        const int key = translateKey(keycode);
-        const int mods = translateState(event->xkey.state);
-
-        if (!_glfw.x11.xkb.detectable)
-        {
-            // HACK: Key repeat events will arrive as KeyRelease/KeyPress
-            //       pairs with similar or identical time stamps
-            //       The key repeat logic in _glfwInputKey expects only key
-            //       presses to repeat, so detect and discard release events
-            if (XEventsQueued(_glfw.x11.display, QueuedAfterReading))
-            {
-                XEvent next;
-                XPeekEvent(_glfw.x11.display, &next);
-
-                if (next.type == KeyPress &&
-                    next.xkey.window == event->xkey.window &&
-                    next.xkey.keycode == keycode)
-                {
-                    // HACK: The time of repeat events sometimes doesn't
-                    //       match that of the press event, so add an
-                    //       epsilon
-                    //       Toshiyuki Takahashi can press a button
-                    //       16 times per second so it's fairly safe to
-                    //       assume that no human is pressing the key 50
-                    //       times per second (value is ms)
-                    if ((next.xkey.time - event->xkey.time) < 20)
+                    if (status == XBufferOverflow)
                     {
-                        // This is very likely a server-generated key repeat
-                        // event, so ignore it
-                        return;
+                        chars = _glfw_calloc(count + 1, 1);
+                        count = Xutf8LookupString(window->x11.ic,
+                                                  &event->xkey,
+                                                  chars, count,
+                                                  NULL, &status);
+                    }
+
+                    if (status == XLookupChars || status == XLookupBoth)
+                    {
+                        const char* c = chars;
+                        chars[count] = '\0';
+                        while (c - chars < count)
+                            _glfwInputChar(window, decodeUTF8(&c), mods, plain);
+                    }
+
+                    if (chars != buffer)
+                        _glfw_free(chars);
+                }
+            }
+            else
+            {
+                KeySym keysym;
+                XLookupString(&event->xkey, NULL, 0, &keysym, NULL);
+
+                _glfwInputKey(window, key, keycode, GLFW_PRESS, mods);
+
+                const uint32_t codepoint = _glfwKeySym2Unicode(keysym);
+                if (codepoint != GLFW_INVALID_CODEPOINT)
+                    _glfwInputChar(window, codepoint, mods, plain);
+            }
+
+            return;
+        }
+
+        case KeyRelease:
+        {
+            const int key = translateKey(keycode);
+            const int mods = translateState(event->xkey.state);
+
+            if (!_glfw.x11.xkb.detectable)
+            {
+                // HACK: Key repeat events will arrive as KeyRelease/KeyPress
+                //       pairs with similar or identical time stamps
+                //       The key repeat logic in _glfwInputKey expects only key
+                //       presses to repeat, so detect and discard release events
+                if (XEventsQueued(_glfw.x11.display, QueuedAfterReading))
+                {
+                    XEvent next;
+                    XPeekEvent(_glfw.x11.display, &next);
+
+                    if (next.type == KeyPress &&
+                        next.xkey.window == event->xkey.window &&
+                        next.xkey.keycode == keycode)
+                    {
+                        // HACK: The time of repeat events sometimes doesn't
+                        //       match that of the press event, so add an
+                        //       epsilon
+                        //       Toshiyuki Takahashi can press a button
+                        //       16 times per second so it's fairly safe to
+                        //       assume that no human is pressing the key 50
+                        //       times per second (value is ms)
+                        if ((next.xkey.time - event->xkey.time) < 20)
+                        {
+                            // This is very likely a server-generated key repeat
+                            // event, so ignore it
+                            return;
+                        }
                     }
                 }
             }
-        }
 
-        _glfwInputKey(window, key, keycode, GLFW_RELEASE, mods);
-        return;
-    }
-
-    case ButtonPress:
-    {
-        const int mods = translateState(event->xbutton.state);
-
-        if (event->xbutton.button == Button1)
-            _glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, mods);
-        else if (event->xbutton.button == Button2)
-            _glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_MIDDLE, GLFW_PRESS, mods);
-        else if (event->xbutton.button == Button3)
-            _glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS, mods);
-
-        // Modern X provides scroll events as mouse button presses
-        else if (event->xbutton.button == Button4)
-            _glfwInputScroll(window, 0.0, 1.0);
-        else if (event->xbutton.button == Button5)
-            _glfwInputScroll(window, 0.0, -1.0);
-        else if (event->xbutton.button == Button6)
-            _glfwInputScroll(window, 1.0, 0.0);
-        else if (event->xbutton.button == Button7)
-            _glfwInputScroll(window, -1.0, 0.0);
-
-        else
-        {
-            // Additional buttons after 7 are treated as regular buttons
-            // We subtract 4 to fill the gap left by scroll input above
-            _glfwInputMouseClick(window,
-                                 event->xbutton.button - Button1 - 4,
-                                 GLFW_PRESS,
-                                 mods);
-        }
-
-        return;
-    }
-
-    case ButtonRelease:
-    {
-        const int mods = translateState(event->xbutton.state);
-
-        if (event->xbutton.button == Button1)
-        {
-            _glfwInputMouseClick(window,
-                                 GLFW_MOUSE_BUTTON_LEFT,
-                                 GLFW_RELEASE,
-                                 mods);
-        }
-        else if (event->xbutton.button == Button2)
-        {
-            _glfwInputMouseClick(window,
-                                 GLFW_MOUSE_BUTTON_MIDDLE,
-                                 GLFW_RELEASE,
-                                 mods);
-        }
-        else if (event->xbutton.button == Button3)
-        {
-            _glfwInputMouseClick(window,
-                                 GLFW_MOUSE_BUTTON_RIGHT,
-                                 GLFW_RELEASE,
-                                 mods);
-        }
-        else if (event->xbutton.button > Button7)
-        {
-            // Additional buttons after 7 are treated as regular buttons
-            // We subtract 4 to fill the gap left by scroll input above
-            _glfwInputMouseClick(window,
-                                 event->xbutton.button - Button1 - 4,
-                                 GLFW_RELEASE,
-                                 mods);
-        }
-
-        return;
-    }
-
-    case EnterNotify:
-    {
-        // XEnterWindowEvent is XCrossingEvent
-        const int x = event->xcrossing.x;
-        const int y = event->xcrossing.y;
-
-        // HACK: This is a workaround for WMs (KWM, Fluxbox) that otherwise
-        //       ignore the defined cursor for hidden cursor mode
-        if (window->cursorMode == GLFW_CURSOR_HIDDEN)
-            updateCursorImage(window);
-
-        _glfwInputCursorEnter(window, GLFW_TRUE);
-        _glfwInputCursorPos(window, x, y);
-
-        window->x11.lastCursorPosX = x;
-        window->x11.lastCursorPosY = y;
-        return;
-    }
-
-    case LeaveNotify:
-    {
-        _glfwInputCursorEnter(window, GLFW_FALSE);
-        return;
-    }
-
-    case MotionNotify:
-    {
-        const int x = event->xmotion.x;
-        const int y = event->xmotion.y;
-
-        if (x != window->x11.warpCursorPosX ||
-            y != window->x11.warpCursorPosY)
-        {
-            // The cursor was moved by something other than GLFW
-
-            if (window->cursorMode == GLFW_CURSOR_DISABLED)
-            {
-                if (_glfw.x11.disabledCursorWindow != window)
-                    return;
-                if (window->rawMouseMotion)
-                    return;
-
-                const int dx = x - window->x11.lastCursorPosX;
-                const int dy = y - window->x11.lastCursorPosY;
-
-                _glfwInputCursorPos(window,
-                                    window->virtualCursorPosX + dx,
-                                    window->virtualCursorPosY + dy);
-            }
-            else
-                _glfwInputCursorPos(window, x, y);
-        }
-
-        window->x11.lastCursorPosX = x;
-        window->x11.lastCursorPosY = y;
-        return;
-    }
-
-    case ConfigureNotify:
-    {
-        if (event->xconfigure.width != window->x11.width ||
-            event->xconfigure.height != window->x11.height)
-        {
-            _glfwInputFramebufferSize(window,
-                                      event->xconfigure.width,
-                                      event->xconfigure.height);
-
-            _glfwInputWindowSize(window,
-                                 event->xconfigure.width,
-                                 event->xconfigure.height);
-
-            window->x11.width = event->xconfigure.width;
-            window->x11.height = event->xconfigure.height;
-        }
-
-        int xpos = event->xconfigure.x;
-        int ypos = event->xconfigure.y;
-
-        // NOTE: ConfigureNotify events from the server are in local
-        //       coordinates, so if we are reparented we need to translate
-        //       the position into root (screen) coordinates
-        if (!event->xany.send_event && window->x11.parent != _glfw.x11.root)
-        {
-            _glfwGrabErrorHandlerX11();
-
-            Window dummy;
-            XTranslateCoordinates(_glfw.x11.display,
-                                  window->x11.parent,
-                                  _glfw.x11.root,
-                                  xpos, ypos,
-                                  &xpos, &ypos,
-                                  &dummy);
-
-            _glfwReleaseErrorHandlerX11();
-            if (_glfw.x11.errorCode == BadWindow)
-                return;
-        }
-
-        if (xpos != window->x11.xpos || ypos != window->x11.ypos)
-        {
-            _glfwInputWindowPos(window, xpos, ypos);
-            window->x11.xpos = xpos;
-            window->x11.ypos = ypos;
-        }
-
-        return;
-    }
-
-    case ClientMessage:
-    {
-        // Custom client message, probably from the window manager
-
-        if (filtered)
+            _glfwInputKey(window, key, keycode, GLFW_RELEASE, mods);
             return;
-
-        if (event->xclient.message_type == None)
-            return;
-
-        if (event->xclient.message_type == _glfw.x11.WM_PROTOCOLS)
-        {
-            const Atom protocol = event->xclient.data.l[0];
-            if (protocol == None)
-                return;
-
-            if (protocol == _glfw.x11.WM_DELETE_WINDOW)
-            {
-                // The window manager was asked to close the window, for
-                // example by the user pressing a 'close' window decoration
-                // button
-                _glfwInputWindowCloseRequest(window);
-            }
-            else if (protocol == _glfw.x11.NET_WM_PING)
-            {
-                // The window manager is pinging the application to ensure
-                // it's still responding to events
-
-                XEvent reply = *event;
-                reply.xclient.window = _glfw.x11.root;
-
-                XSendEvent(_glfw.x11.display, _glfw.x11.root,
-                           False,
-                           SubstructureNotifyMask | SubstructureRedirectMask,
-                           &reply);
-            }
         }
-        else if (event->xclient.message_type == _glfw.x11.XdndEnter)
+
+        case ButtonPress:
         {
-            // A drag operation has entered the window
-            unsigned long count;
-            Atom *formats = NULL;
-            const GLFWbool list = event->xclient.data.l[1] & 1;
-
-            _glfw.x11.xdnd.source = event->xclient.data.l[0];
-            _glfw.x11.xdnd.version = event->xclient.data.l[1] >> 24;
-            _glfw.x11.xdnd.format = None;
-
-            if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
-                return;
-
-            if (list)
-            {
-                count = _glfwGetWindowPropertyX11(_glfw.x11.xdnd.source,
-                                                  _glfw.x11.XdndTypeList,
-                                                  XA_ATOM,
-                                                  (unsigned char **)&formats);
-            }
-            else
-            {
-                count = 3;
-                formats = (Atom *)event->xclient.data.l + 2;
-            }
-
-            for (unsigned int i = 0; i < count; i++)
-            {
-                if (formats[i] == _glfw.x11.text_uri_list)
-                {
-                    _glfw.x11.xdnd.format = _glfw.x11.text_uri_list;
-                    break;
-                }
-            }
-
-            if (list && formats)
-                XFree(formats);
-        }
-        else if (event->xclient.message_type == _glfw.x11.XdndDrop)
-        {
-            // The drag operation has finished by dropping on the window
-            Time time = CurrentTime;
+            const int mods = translateState(event->xbutton.state);
 
             if (event->xbutton.button == Button1)
                 _glfwInputMouseClick(window, GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, mods);
@@ -1797,221 +1541,299 @@ static void processEvent(XEvent *event)
             if (filtered)
                 return;
 
-            if (_glfw.x11.xdnd.format)
-            {
-                if (_glfw.x11.xdnd.version >= 1)
-                    time = event->xclient.data.l[2];
-
-                // Request the chosen format from the source window
-                XConvertSelection(_glfw.x11.display,
-                                  _glfw.x11.XdndSelection,
-                                  _glfw.x11.xdnd.format,
-                                  _glfw.x11.XdndSelection,
-                                  window->x11.handle,
-                                  time);
-            }
-            else if (_glfw.x11.xdnd.version >= 2)
-            {
-                XEvent reply = {ClientMessage};
-                reply.xclient.window = _glfw.x11.xdnd.source;
-                reply.xclient.message_type = _glfw.x11.XdndFinished;
-                reply.xclient.format = 32;
-                reply.xclient.data.l[0] = window->x11.handle;
-                reply.xclient.data.l[1] = 0; // The drag was rejected
-                reply.xclient.data.l[2] = None;
-
-                XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
-                           False, NoEventMask, &reply);
-                XFlush(_glfw.x11.display);
-            }
-        }
-        else if (event->xclient.message_type == _glfw.x11.XdndPosition)
-        {
-            // The drag operation has moved over the window
-            const int xabs = (event->xclient.data.l[2] >> 16) & 0xffff;
-            const int yabs = (event->xclient.data.l[2]) & 0xffff;
-            Window dummy;
-            int xpos, ypos;
-
-            if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
+            if (event->xclient.message_type == None)
                 return;
 
-            XTranslateCoordinates(_glfw.x11.display,
-                                  _glfw.x11.root,
-                                  window->x11.handle,
-                                  xabs, yabs,
-                                  &xpos, &ypos,
-                                  &dummy);
-
-            _glfwInputCursorPos(window, xpos, ypos);
-
-            XEvent reply = {ClientMessage};
-            reply.xclient.window = _glfw.x11.xdnd.source;
-            reply.xclient.message_type = _glfw.x11.XdndStatus;
-            reply.xclient.format = 32;
-            reply.xclient.data.l[0] = window->x11.handle;
-            reply.xclient.data.l[2] = 0; // Specify an empty rectangle
-            reply.xclient.data.l[3] = 0;
-
-            if (_glfw.x11.xdnd.format)
+            if (event->xclient.message_type == _glfw.x11.WM_PROTOCOLS)
             {
-                // Reply that we are ready to copy the dragged data
-                reply.xclient.data.l[1] = 1; // Accept with no rectangle
-                if (_glfw.x11.xdnd.version >= 2)
-                    reply.xclient.data.l[4] = _glfw.x11.XdndActionCopy;
-            }
+                const Atom protocol = event->xclient.data.l[0];
+                if (protocol == None)
+                    return;
 
-            XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
-                       False, NoEventMask, &reply);
-            XFlush(_glfw.x11.display);
-        }
-
-        return;
-    }
-
-    case SelectionNotify:
-    {
-        if (event->xselection.property == _glfw.x11.XdndSelection)
-        {
-            // The converted data from the drag operation has arrived
-            char *data;
-            const unsigned long result =
-                _glfwGetWindowPropertyX11(event->xselection.requestor,
-                                          event->xselection.property,
-                                          event->xselection.target,
-                                          (unsigned char **)&data);
-
-            if (result)
-            {
-                int count;
-                char **paths = _glfwParseUriList(data, &count);
-
-                _glfwInputDrop(window, count, (const char **)paths);
-
-                for (int i = 0; i < count; i++)
-                    _glfw_free(paths[i]);
-                _glfw_free(paths);
-            }
-
-            if (data)
-                XFree(data);
-
-            if (_glfw.x11.xdnd.version >= 2)
-            {
-                XEvent reply = {ClientMessage};
-                reply.xclient.window = _glfw.x11.xdnd.source;
-                reply.xclient.message_type = _glfw.x11.XdndFinished;
-                reply.xclient.format = 32;
-                reply.xclient.data.l[0] = window->x11.handle;
-                reply.xclient.data.l[1] = result;
-                reply.xclient.data.l[2] = _glfw.x11.XdndActionCopy;
-
-                XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
-                           False, NoEventMask, &reply);
-                XFlush(_glfw.x11.display);
-            }
-        }
-
-        return;
-    }
-
-    case FocusIn:
-    {
-        if (event->xfocus.mode == NotifyGrab ||
-            event->xfocus.mode == NotifyUngrab)
-        {
-            // Ignore focus events from popup indicator windows, window menu
-            // key chords and window dragging
-            return;
-        }
-
-        if (window->cursorMode == GLFW_CURSOR_DISABLED)
-            disableCursor(window);
-        else if (window->cursorMode == GLFW_CURSOR_CAPTURED)
-            captureCursor(window);
-
-        if (window->x11.ic)
-            XSetICFocus(window->x11.ic);
-
-        _glfwInputWindowFocus(window, GLFW_TRUE);
-        return;
-    }
-
-    case FocusOut:
-    {
-        if (event->xfocus.mode == NotifyGrab ||
-            event->xfocus.mode == NotifyUngrab)
-        {
-            // Ignore focus events from popup indicator windows, window menu
-            // key chords and window dragging
-            return;
-        }
-
-        if (window->cursorMode == GLFW_CURSOR_DISABLED)
-            enableCursor(window);
-        else if (window->cursorMode == GLFW_CURSOR_CAPTURED)
-            releaseCursor();
-
-        if (window->x11.ic)
-            XUnsetICFocus(window->x11.ic);
-
-        if (window->monitor && window->autoIconify)
-            _glfwIconifyWindowX11(window);
-
-        _glfwInputWindowFocus(window, GLFW_FALSE);
-        return;
-    }
-
-    case Expose:
-    {
-        _glfwInputWindowDamage(window);
-        return;
-    }
-
-    case PropertyNotify:
-    {
-        if (event->xproperty.state != PropertyNewValue)
-            return;
-
-        if (event->xproperty.atom == _glfw.x11.WM_STATE)
-        {
-            const int state = getWindowState(window);
-            if (state != IconicState && state != NormalState)
-                return;
-
-            const GLFWbool iconified = (state == IconicState);
-            if (window->x11.iconified != iconified)
-            {
-                if (window->monitor)
+                if (protocol == _glfw.x11.WM_DELETE_WINDOW)
                 {
-                    if (iconified)
-                        releaseMonitor(window);
-                    else
-                        acquireMonitor(window);
+                    // The window manager was asked to close the window, for
+                    // example by the user pressing a 'close' window decoration
+                    // button
+                    _glfwInputWindowCloseRequest(window);
+                }
+                else if (protocol == _glfw.x11.NET_WM_PING)
+                {
+                    // The window manager is pinging the application to ensure
+                    // it's still responding to events
+
+                    XEvent reply = *event;
+                    reply.xclient.window = _glfw.x11.root;
+
+                    XSendEvent(_glfw.x11.display, _glfw.x11.root,
+                               False,
+                               SubstructureNotifyMask | SubstructureRedirectMask,
+                               &reply);
+                }
+            }
+            else if (event->xclient.message_type == _glfw.x11.XdndEnter)
+            {
+                // A drag operation has entered the window
+                unsigned long count;
+                Atom* formats = NULL;
+                const GLFWbool list = event->xclient.data.l[1] & 1;
+
+                _glfw.x11.xdnd.source  = event->xclient.data.l[0];
+                _glfw.x11.xdnd.version = event->xclient.data.l[1] >> 24;
+                _glfw.x11.xdnd.format  = None;
+
+                if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
+                    return;
+
+                if (list)
+                {
+                    count = _glfwGetWindowPropertyX11(_glfw.x11.xdnd.source,
+                                                      _glfw.x11.XdndTypeList,
+                                                      XA_ATOM,
+                                                      (unsigned char**) &formats);
+                }
+                else
+                {
+                    count = 3;
+                    formats = (Atom*) event->xclient.data.l + 2;
                 }
 
-                window->x11.iconified = iconified;
-                _glfwInputWindowIconify(window, iconified);
+                for (unsigned int i = 0;  i < count;  i++)
+                {
+                    if (formats[i] == _glfw.x11.text_uri_list)
+                    {
+                        _glfw.x11.xdnd.format = _glfw.x11.text_uri_list;
+                        break;
+                    }
+                }
+
+                if (list && formats)
+                    XFree(formats);
             }
-        }
-        else if (event->xproperty.atom == _glfw.x11.NET_WM_STATE)
-        {
-            const GLFWbool maximized = _glfwWindowMaximizedX11(window);
-            if (window->x11.maximized != maximized)
+            else if (event->xclient.message_type == _glfw.x11.XdndDrop)
             {
-                window->x11.maximized = maximized;
-                _glfwInputWindowMaximize(window, maximized);
+                // The drag operation has finished by dropping on the window
+                Time time = CurrentTime;
+
+                if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
+                    return;
+
+                if (_glfw.x11.xdnd.format)
+                {
+                    if (_glfw.x11.xdnd.version >= 1)
+                        time = event->xclient.data.l[2];
+
+                    // Request the chosen format from the source window
+                    XConvertSelection(_glfw.x11.display,
+                                      _glfw.x11.XdndSelection,
+                                      _glfw.x11.xdnd.format,
+                                      _glfw.x11.XdndSelection,
+                                      window->x11.handle,
+                                      time);
+                }
+                else if (_glfw.x11.xdnd.version >= 2)
+                {
+                    XEvent reply = { ClientMessage };
+                    reply.xclient.window = _glfw.x11.xdnd.source;
+                    reply.xclient.message_type = _glfw.x11.XdndFinished;
+                    reply.xclient.format = 32;
+                    reply.xclient.data.l[0] = window->x11.handle;
+                    reply.xclient.data.l[1] = 0; // The drag was rejected
+                    reply.xclient.data.l[2] = None;
+
+                    XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
+                               False, NoEventMask, &reply);
+                    XFlush(_glfw.x11.display);
+                }
             }
+            else if (event->xclient.message_type == _glfw.x11.XdndPosition)
+            {
+                // The drag operation has moved over the window
+                const int xabs = (event->xclient.data.l[2] >> 16) & 0xffff;
+                const int yabs = (event->xclient.data.l[2]) & 0xffff;
+                Window dummy;
+                int xpos, ypos;
+
+                if (_glfw.x11.xdnd.version > _GLFW_XDND_VERSION)
+                    return;
+
+                XTranslateCoordinates(_glfw.x11.display,
+                                      _glfw.x11.root,
+                                      window->x11.handle,
+                                      xabs, yabs,
+                                      &xpos, &ypos,
+                                      &dummy);
+
+                _glfwInputCursorPos(window, xpos, ypos);
+
+                XEvent reply = { ClientMessage };
+                reply.xclient.window = _glfw.x11.xdnd.source;
+                reply.xclient.message_type = _glfw.x11.XdndStatus;
+                reply.xclient.format = 32;
+                reply.xclient.data.l[0] = window->x11.handle;
+                reply.xclient.data.l[2] = 0; // Specify an empty rectangle
+                reply.xclient.data.l[3] = 0;
+
+                if (_glfw.x11.xdnd.format)
+                {
+                    // Reply that we are ready to copy the dragged data
+                    reply.xclient.data.l[1] = 1; // Accept with no rectangle
+                    if (_glfw.x11.xdnd.version >= 2)
+                        reply.xclient.data.l[4] = _glfw.x11.XdndActionCopy;
+                }
+
+                XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
+                           False, NoEventMask, &reply);
+                XFlush(_glfw.x11.display);
+            }
+
+            return;
         }
 
-        return;
-    }
+        case SelectionNotify:
+        {
+            if (event->xselection.property == _glfw.x11.XdndSelection)
+            {
+                // The converted data from the drag operation has arrived
+                char* data;
+                const unsigned long result =
+                    _glfwGetWindowPropertyX11(event->xselection.requestor,
+                                              event->xselection.property,
+                                              event->xselection.target,
+                                              (unsigned char**) &data);
 
-    case DestroyNotify:
-        return;
+                if (result)
+                {
+                    int count;
+                    char** paths = _glfwParseUriList(data, &count);
+
+                    _glfwInputDrop(window, count, (const char**) paths);
+
+                    for (int i = 0;  i < count;  i++)
+                        _glfw_free(paths[i]);
+                    _glfw_free(paths);
+                }
+
+                if (data)
+                    XFree(data);
+
+                if (_glfw.x11.xdnd.version >= 2)
+                {
+                    XEvent reply = { ClientMessage };
+                    reply.xclient.window = _glfw.x11.xdnd.source;
+                    reply.xclient.message_type = _glfw.x11.XdndFinished;
+                    reply.xclient.format = 32;
+                    reply.xclient.data.l[0] = window->x11.handle;
+                    reply.xclient.data.l[1] = result;
+                    reply.xclient.data.l[2] = _glfw.x11.XdndActionCopy;
+
+                    XSendEvent(_glfw.x11.display, _glfw.x11.xdnd.source,
+                               False, NoEventMask, &reply);
+                    XFlush(_glfw.x11.display);
+                }
+            }
+
+            return;
+        }
+
+        case FocusIn:
+        {
+            if (event->xfocus.mode == NotifyGrab ||
+                event->xfocus.mode == NotifyUngrab)
+            {
+                // Ignore focus events from popup indicator windows, window menu
+                // key chords and window dragging
+                return;
+            }
+
+            if (window->cursorMode == GLFW_CURSOR_DISABLED)
+                disableCursor(window);
+            else if (window->cursorMode == GLFW_CURSOR_CAPTURED)
+                captureCursor(window);
+
+            if (window->x11.ic)
+                XSetICFocus(window->x11.ic);
+
+            _glfwInputWindowFocus(window, GLFW_TRUE);
+            return;
+        }
+
+        case FocusOut:
+        {
+            if (event->xfocus.mode == NotifyGrab ||
+                event->xfocus.mode == NotifyUngrab)
+            {
+                // Ignore focus events from popup indicator windows, window menu
+                // key chords and window dragging
+                return;
+            }
+
+            if (window->cursorMode == GLFW_CURSOR_DISABLED)
+                enableCursor(window);
+            else if (window->cursorMode == GLFW_CURSOR_CAPTURED)
+                releaseCursor();
+
+            if (window->x11.ic)
+                XUnsetICFocus(window->x11.ic);
+
+            if (window->monitor && window->autoIconify)
+                _glfwIconifyWindowX11(window);
+
+            _glfwInputWindowFocus(window, GLFW_FALSE);
+            return;
+        }
+
+        case Expose:
+        {
+            _glfwInputWindowDamage(window);
+            return;
+        }
+
+        case PropertyNotify:
+        {
+            if (event->xproperty.state != PropertyNewValue)
+                return;
+
+            if (event->xproperty.atom == _glfw.x11.WM_STATE)
+            {
+                const int state = getWindowState(window);
+                if (state != IconicState && state != NormalState)
+                    return;
+
+                const GLFWbool iconified = (state == IconicState);
+                if (window->x11.iconified != iconified)
+                {
+                    if (window->monitor)
+                    {
+                        if (iconified)
+                            releaseMonitor(window);
+                        else
+                            acquireMonitor(window);
+                    }
+
+                    window->x11.iconified = iconified;
+                    _glfwInputWindowIconify(window, iconified);
+                }
+            }
+            else if (event->xproperty.atom == _glfw.x11.NET_WM_STATE)
+            {
+                const GLFWbool maximized = _glfwWindowMaximizedX11(window);
+                if (window->x11.maximized != maximized)
+                {
+                    window->x11.maximized = maximized;
+                    _glfwInputWindowMaximize(window, maximized);
+                }
+            }
+
+            return;
+        }
+
+        case DestroyNotify:
+            return;
     }
 }
 
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
@@ -2022,7 +1844,7 @@ static void processEvent(XEvent *event)
 unsigned long _glfwGetWindowPropertyX11(Window window,
                                         Atom property,
                                         Atom type,
-                                        unsigned char **value)
+                                        unsigned char** value)
 {
     Atom actualType;
     int actualFormat;
@@ -2044,12 +1866,12 @@ unsigned long _glfwGetWindowPropertyX11(Window window,
     return itemCount;
 }
 
-GLFWbool _glfwIsVisualTransparentX11(Visual *visual)
+GLFWbool _glfwIsVisualTransparentX11(Visual* visual)
 {
     if (!_glfw.x11.xrender.available)
         return GLFW_FALSE;
 
-    XRenderPictFormat *pf = XRenderFindVisualFormat(_glfw.x11.display, visual);
+    XRenderPictFormat* pf = XRenderFindVisualFormat(_glfw.x11.display, visual);
     return pf && pf->direct.alphaMask;
 }
 
@@ -2072,24 +1894,24 @@ void _glfwPushSelectionToManagerX11(void)
         {
             switch (event.type)
             {
-            case SelectionRequest:
-                handleSelectionRequest(&event);
-                break;
+                case SelectionRequest:
+                    handleSelectionRequest(&event);
+                    break;
 
-            case SelectionNotify:
-            {
-                if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
+                case SelectionNotify:
                 {
-                    // This means one of two things; either the selection
-                    // was not owned, which means there is no clipboard
-                    // manager, or the transfer to the clipboard manager has
-                    // completed
-                    // In either case, it means we are done here
-                    return;
-                }
+                    if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
+                    {
+                        // This means one of two things; either the selection
+                        // was not owned, which means there is no clipboard
+                        // manager, or the transfer to the clipboard manager has
+                        // completed
+                        // In either case, it means we are done here
+                        return;
+                    }
 
-                break;
-            }
+                    break;
+                }
             }
         }
 
@@ -2097,11 +1919,11 @@ void _glfwPushSelectionToManagerX11(void)
     }
 }
 
-void _glfwCreateInputContextX11(_GLFWwindow *window)
+void _glfwCreateInputContextX11(_GLFWwindow* window)
 {
     XIMCallback callback;
-    callback.callback = (XIMProc)inputContextDestroyCallback;
-    callback.client_data = (XPointer)window;
+    callback.callback = (XIMProc) inputContextDestroyCallback;
+    callback.client_data = (XPointer) window;
 
     window->x11.ic = XCreateIC(_glfw.x11.im,
                                XNInputStyle,
@@ -2129,16 +1951,17 @@ void _glfwCreateInputContextX11(_GLFWwindow *window)
     }
 }
 
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWbool _glfwCreateWindowX11(_GLFWwindow *window,
-                              const _GLFWwndconfig *wndconfig,
-                              const _GLFWctxconfig *ctxconfig,
-                              const _GLFWfbconfig *fbconfig)
+GLFWbool _glfwCreateWindowX11(_GLFWwindow* window,
+                              const _GLFWwndconfig* wndconfig,
+                              const _GLFWctxconfig* ctxconfig,
+                              const _GLFWfbconfig* fbconfig)
 {
-    Visual *visual = NULL;
+    Visual* visual = NULL;
     int depth;
 
     if (ctxconfig->client != GLFW_NO_API)
@@ -2221,7 +2044,7 @@ GLFWbool _glfwCreateWindowX11(_GLFWwindow *window,
     return GLFW_TRUE;
 }
 
-void _glfwDestroyWindowX11(_GLFWwindow *window)
+void _glfwDestroyWindowX11(_GLFWwindow* window)
 {
     if (_glfw.x11.disabledCursorWindow == window)
         enableCursor(window);
@@ -2243,19 +2066,19 @@ void _glfwDestroyWindowX11(_GLFWwindow *window)
         XDeleteContext(_glfw.x11.display, window->x11.handle, _glfw.x11.context);
         XUnmapWindow(_glfw.x11.display, window->x11.handle);
         XDestroyWindow(_glfw.x11.display, window->x11.handle);
-        window->x11.handle = (Window)0;
+        window->x11.handle = (Window) 0;
     }
 
     if (window->x11.colormap)
     {
         XFreeColormap(_glfw.x11.display, window->x11.colormap);
-        window->x11.colormap = (Colormap)0;
+        window->x11.colormap = (Colormap) 0;
     }
 
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowTitleX11(_GLFWwindow *window, const char *title)
+void _glfwSetWindowTitleX11(_GLFWwindow* window, const char* title)
 {
     if (_glfw.x11.xlib.utf8)
     {
@@ -2266,42 +2089,42 @@ void _glfwSetWindowTitleX11(_GLFWwindow *window, const char *title)
                              NULL, NULL, NULL);
     }
 
-    XChangeProperty(_glfw.x11.display, window->x11.handle,
+    XChangeProperty(_glfw.x11.display,  window->x11.handle,
                     _glfw.x11.NET_WM_NAME, _glfw.x11.UTF8_STRING, 8,
                     PropModeReplace,
-                    (unsigned char *)title, strlen(title));
+                    (unsigned char*) title, strlen(title));
 
-    XChangeProperty(_glfw.x11.display, window->x11.handle,
+    XChangeProperty(_glfw.x11.display,  window->x11.handle,
                     _glfw.x11.NET_WM_ICON_NAME, _glfw.x11.UTF8_STRING, 8,
                     PropModeReplace,
-                    (unsigned char *)title, strlen(title));
+                    (unsigned char*) title, strlen(title));
 
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowIconX11(_GLFWwindow *window, int count, const GLFWimage *images)
+void _glfwSetWindowIconX11(_GLFWwindow* window, int count, const GLFWimage* images)
 {
     if (count)
     {
         int longCount = 0;
 
-        for (int i = 0; i < count; i++)
+        for (int i = 0;  i < count;  i++)
             longCount += 2 + images[i].width * images[i].height;
 
-        unsigned long *icon = _glfw_calloc(longCount, sizeof(unsigned long));
-        unsigned long *target = icon;
+        unsigned long* icon = _glfw_calloc(longCount, sizeof(unsigned long));
+        unsigned long* target = icon;
 
-        for (int i = 0; i < count; i++)
+        for (int i = 0;  i < count;  i++)
         {
             *target++ = images[i].width;
             *target++ = images[i].height;
 
-            for (int j = 0; j < images[i].width * images[i].height; j++)
+            for (int j = 0;  j < images[i].width * images[i].height;  j++)
             {
-                *target++ = (((unsigned long)images[i].pixels[j * 4 + 0]) << 16) |
-                            (((unsigned long)images[i].pixels[j * 4 + 1]) << 8) |
-                            (((unsigned long)images[i].pixels[j * 4 + 2]) << 0) |
-                            (((unsigned long)images[i].pixels[j * 4 + 3]) << 24);
+                *target++ = (((unsigned long) images[i].pixels[j * 4 + 0]) << 16) |
+                            (((unsigned long) images[i].pixels[j * 4 + 1]) <<  8) |
+                            (((unsigned long) images[i].pixels[j * 4 + 2]) <<  0) |
+                            (((unsigned long) images[i].pixels[j * 4 + 3]) << 24);
             }
         }
 
@@ -2315,7 +2138,7 @@ void _glfwSetWindowIconX11(_GLFWwindow *window, int count, const GLFWimage *imag
                         _glfw.x11.NET_WM_ICON,
                         XA_CARDINAL, 32,
                         PropModeReplace,
-                        (unsigned char *)icon,
+                        (unsigned char*) icon,
                         longCount);
 
         _glfw_free(icon);
@@ -2329,7 +2152,7 @@ void _glfwSetWindowIconX11(_GLFWwindow *window, int count, const GLFWimage *imag
     XFlush(_glfw.x11.display);
 }
 
-void _glfwGetWindowPosX11(_GLFWwindow *window, int *xpos, int *ypos)
+void _glfwGetWindowPosX11(_GLFWwindow* window, int* xpos, int* ypos)
 {
     Window dummy;
     int x, y;
@@ -2343,14 +2166,14 @@ void _glfwGetWindowPosX11(_GLFWwindow *window, int *xpos, int *ypos)
         *ypos = y;
 }
 
-void _glfwSetWindowPosX11(_GLFWwindow *window, int xpos, int ypos)
+void _glfwSetWindowPosX11(_GLFWwindow* window, int xpos, int ypos)
 {
     // HACK: Explicitly setting PPosition to any value causes some WMs, notably
     //       Compiz and Metacity, to honor the position of unmapped windows
     if (!_glfwWindowVisibleX11(window))
     {
         long supplied;
-        XSizeHints *hints = XAllocSizeHints();
+        XSizeHints* hints = XAllocSizeHints();
 
         if (XGetWMNormalHints(_glfw.x11.display, window->x11.handle, hints, &supplied))
         {
@@ -2367,7 +2190,7 @@ void _glfwSetWindowPosX11(_GLFWwindow *window, int xpos, int ypos)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwGetWindowSizeX11(_GLFWwindow *window, int *width, int *height)
+void _glfwGetWindowSizeX11(_GLFWwindow* window, int* width, int* height)
 {
     XWindowAttributes attribs;
     XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &attribs);
@@ -2378,7 +2201,7 @@ void _glfwGetWindowSizeX11(_GLFWwindow *window, int *width, int *height)
         *height = attribs.height;
 }
 
-void _glfwSetWindowSizeX11(_GLFWwindow *window, int width, int height)
+void _glfwSetWindowSizeX11(_GLFWwindow* window, int width, int height)
 {
     if (window->monitor)
     {
@@ -2396,7 +2219,7 @@ void _glfwSetWindowSizeX11(_GLFWwindow *window, int width, int height)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowSizeLimitsX11(_GLFWwindow *window,
+void _glfwSetWindowSizeLimitsX11(_GLFWwindow* window,
                                  int minwidth, int minheight,
                                  int maxwidth, int maxheight)
 {
@@ -2406,7 +2229,7 @@ void _glfwSetWindowSizeLimitsX11(_GLFWwindow *window,
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowAspectRatioX11(_GLFWwindow *window, int numer, int denom)
+void _glfwSetWindowAspectRatioX11(_GLFWwindow* window, int numer, int denom)
 {
     int width, height;
     _glfwGetWindowSizeX11(window, &width, &height);
@@ -2414,16 +2237,16 @@ void _glfwSetWindowAspectRatioX11(_GLFWwindow *window, int numer, int denom)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwGetFramebufferSizeX11(_GLFWwindow *window, int *width, int *height)
+void _glfwGetFramebufferSizeX11(_GLFWwindow* window, int* width, int* height)
 {
     _glfwGetWindowSizeX11(window, width, height);
 }
 
-void _glfwGetWindowFrameSizeX11(_GLFWwindow *window,
-                                int *left, int *top,
-                                int *right, int *bottom)
+void _glfwGetWindowFrameSizeX11(_GLFWwindow* window,
+                                int* left, int* top,
+                                int* right, int* bottom)
 {
-    long *extents = NULL;
+    long* extents = NULL;
 
     if (window->monitor || !window->decorated)
         return;
@@ -2450,7 +2273,7 @@ void _glfwGetWindowFrameSizeX11(_GLFWwindow *window,
         while (!XCheckIfEvent(_glfw.x11.display,
                               &event,
                               isFrameExtentsEvent,
-                              (XPointer)window))
+                              (XPointer) window))
         {
             if (!waitForX11Event(&timeout))
             {
@@ -2464,7 +2287,7 @@ void _glfwGetWindowFrameSizeX11(_GLFWwindow *window,
     if (_glfwGetWindowPropertyX11(window->x11.handle,
                                   _glfw.x11.NET_FRAME_EXTENTS,
                                   XA_CARDINAL,
-                                  (unsigned char **)&extents) == 4)
+                                  (unsigned char**) &extents) == 4)
     {
         if (left)
             *left = extents[0];
@@ -2480,7 +2303,7 @@ void _glfwGetWindowFrameSizeX11(_GLFWwindow *window,
         XFree(extents);
 }
 
-void _glfwGetWindowContentScaleX11(_GLFWwindow *window, float *xscale, float *yscale)
+void _glfwGetWindowContentScaleX11(_GLFWwindow* window, float* xscale, float* yscale)
 {
     if (xscale)
         *xscale = _glfw.x11.contentScaleX;
@@ -2488,7 +2311,7 @@ void _glfwGetWindowContentScaleX11(_GLFWwindow *window, float *xscale, float *ys
         *yscale = _glfw.x11.contentScaleY;
 }
 
-void _glfwIconifyWindowX11(_GLFWwindow *window)
+void _glfwIconifyWindowX11(_GLFWwindow* window)
 {
     if (window->x11.overrideRedirect)
     {
@@ -2503,7 +2326,7 @@ void _glfwIconifyWindowX11(_GLFWwindow *window)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwRestoreWindowX11(_GLFWwindow *window)
+void _glfwRestoreWindowX11(_GLFWwindow* window)
 {
     if (window->x11.overrideRedirect)
     {
@@ -2537,7 +2360,7 @@ void _glfwRestoreWindowX11(_GLFWwindow *window)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwMaximizeWindowX11(_GLFWwindow *window)
+void _glfwMaximizeWindowX11(_GLFWwindow* window)
 {
     if (!_glfw.x11.NET_WM_STATE ||
         !_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
@@ -2549,33 +2372,34 @@ void _glfwMaximizeWindowX11(_GLFWwindow *window)
     if (_glfwWindowVisibleX11(window))
     {
         sendEventToWM(window,
-                      _glfw.x11.NET_WM_STATE,
-                      _NET_WM_STATE_ADD,
-                      _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
-                      _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ,
-                      1, 0);
+                    _glfw.x11.NET_WM_STATE,
+                    _NET_WM_STATE_ADD,
+                    _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
+                    _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ,
+                    1, 0);
     }
     else
     {
-        Atom *states = NULL;
+        Atom* states = NULL;
         unsigned long count =
             _glfwGetWindowPropertyX11(window->x11.handle,
                                       _glfw.x11.NET_WM_STATE,
                                       XA_ATOM,
-                                      (unsigned char **)&states);
+                                      (unsigned char**) &states);
 
         // NOTE: We don't check for failure as this property may not exist yet
         //       and that's fine (and we'll create it implicitly with append)
 
         Atom missing[2] =
-            {
-                _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
-                _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ};
+        {
+            _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT,
+            _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ
+        };
         unsigned long missingCount = 2;
 
-        for (unsigned long i = 0; i < count; i++)
+        for (unsigned long i = 0;  i < count;  i++)
         {
-            for (unsigned long j = 0; j < missingCount; j++)
+            for (unsigned long j = 0;  j < missingCount;  j++)
             {
                 if (states[i] == missing[j])
                 {
@@ -2594,14 +2418,14 @@ void _glfwMaximizeWindowX11(_GLFWwindow *window)
         XChangeProperty(_glfw.x11.display, window->x11.handle,
                         _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
                         PropModeAppend,
-                        (unsigned char *)missing,
+                        (unsigned char*) missing,
                         missingCount);
     }
 
     XFlush(_glfw.x11.display);
 }
 
-void _glfwShowWindowX11(_GLFWwindow *window)
+void _glfwShowWindowX11(_GLFWwindow* window)
 {
     if (_glfwWindowVisibleX11(window))
         return;
@@ -2610,13 +2434,13 @@ void _glfwShowWindowX11(_GLFWwindow *window)
     waitForVisibilityNotify(window);
 }
 
-void _glfwHideWindowX11(_GLFWwindow *window)
+void _glfwHideWindowX11(_GLFWwindow* window)
 {
     XUnmapWindow(_glfw.x11.display, window->x11.handle);
     XFlush(_glfw.x11.display);
 }
 
-void _glfwRequestWindowAttentionX11(_GLFWwindow *window)
+void _glfwRequestWindowAttentionX11(_GLFWwindow* window)
 {
     if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_DEMANDS_ATTENTION)
         return;
@@ -2628,7 +2452,7 @@ void _glfwRequestWindowAttentionX11(_GLFWwindow *window)
                   0, 1, 0);
 }
 
-void _glfwFocusWindowX11(_GLFWwindow *window)
+void _glfwFocusWindowX11(_GLFWwindow* window)
 {
     if (_glfw.x11.NET_ACTIVE_WINDOW)
         sendEventToWM(window, _glfw.x11.NET_ACTIVE_WINDOW, 1, 0, 0, 0, 0);
@@ -2642,8 +2466,8 @@ void _glfwFocusWindowX11(_GLFWwindow *window)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowMonitorX11(_GLFWwindow *window,
-                              _GLFWmonitor *monitor,
+void _glfwSetWindowMonitorX11(_GLFWwindow* window,
+                              _GLFWmonitor* monitor,
                               int xpos, int ypos,
                               int width, int height,
                               int refreshRate)
@@ -2699,7 +2523,7 @@ void _glfwSetWindowMonitorX11(_GLFWwindow *window,
     XFlush(_glfw.x11.display);
 }
 
-GLFWbool _glfwWindowFocusedX11(_GLFWwindow *window)
+GLFWbool _glfwWindowFocusedX11(_GLFWwindow* window)
 {
     Window focused;
     int state;
@@ -2708,21 +2532,21 @@ GLFWbool _glfwWindowFocusedX11(_GLFWwindow *window)
     return window->x11.handle == focused;
 }
 
-GLFWbool _glfwWindowIconifiedX11(_GLFWwindow *window)
+GLFWbool _glfwWindowIconifiedX11(_GLFWwindow* window)
 {
     return getWindowState(window) == IconicState;
 }
 
-GLFWbool _glfwWindowVisibleX11(_GLFWwindow *window)
+GLFWbool _glfwWindowVisibleX11(_GLFWwindow* window)
 {
     XWindowAttributes wa;
     XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &wa);
     return wa.map_state == IsViewable;
 }
 
-GLFWbool _glfwWindowMaximizedX11(_GLFWwindow *window)
+GLFWbool _glfwWindowMaximizedX11(_GLFWwindow* window)
 {
-    Atom *states;
+    Atom* states;
     GLFWbool maximized = GLFW_FALSE;
 
     if (!_glfw.x11.NET_WM_STATE ||
@@ -2736,9 +2560,9 @@ GLFWbool _glfwWindowMaximizedX11(_GLFWwindow *window)
         _glfwGetWindowPropertyX11(window->x11.handle,
                                   _glfw.x11.NET_WM_STATE,
                                   XA_ATOM,
-                                  (unsigned char **)&states);
+                                  (unsigned char**) &states);
 
-    for (unsigned long i = 0; i < count; i++)
+    for (unsigned long i = 0;  i < count;  i++)
     {
         if (states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
             states[i] == _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
@@ -2754,7 +2578,7 @@ GLFWbool _glfwWindowMaximizedX11(_GLFWwindow *window)
     return maximized;
 }
 
-GLFWbool _glfwWindowHoveredX11(_GLFWwindow *window)
+GLFWbool _glfwWindowHoveredX11(_GLFWwindow* window)
 {
     Window w = _glfw.x11.root;
     while (w)
@@ -2782,7 +2606,7 @@ GLFWbool _glfwWindowHoveredX11(_GLFWwindow *window)
     return GLFW_FALSE;
 }
 
-GLFWbool _glfwFramebufferTransparentX11(_GLFWwindow *window)
+GLFWbool _glfwFramebufferTransparentX11(_GLFWwindow* window)
 {
     if (!window->x11.transparent)
         return GLFW_FALSE;
@@ -2790,14 +2614,14 @@ GLFWbool _glfwFramebufferTransparentX11(_GLFWwindow *window)
     return XGetSelectionOwner(_glfw.x11.display, _glfw.x11.NET_WM_CM_Sx) != None;
 }
 
-void _glfwSetWindowResizableX11(_GLFWwindow *window, GLFWbool enabled)
+void _glfwSetWindowResizableX11(_GLFWwindow* window, GLFWbool enabled)
 {
     int width, height;
     _glfwGetWindowSizeX11(window, &width, &height);
     updateNormalHints(window, width, height);
 }
 
-void _glfwSetWindowDecoratedX11(_GLFWwindow *window, GLFWbool enabled)
+void _glfwSetWindowDecoratedX11(_GLFWwindow* window, GLFWbool enabled)
 {
     struct
     {
@@ -2815,11 +2639,11 @@ void _glfwSetWindowDecoratedX11(_GLFWwindow *window, GLFWbool enabled)
                     _glfw.x11.MOTIF_WM_HINTS,
                     _glfw.x11.MOTIF_WM_HINTS, 32,
                     PropModeReplace,
-                    (unsigned char *)&hints,
+                    (unsigned char*) &hints,
                     sizeof(hints) / sizeof(long));
 }
 
-void _glfwSetWindowFloatingX11(_GLFWwindow *window, GLFWbool enabled)
+void _glfwSetWindowFloatingX11(_GLFWwindow* window, GLFWbool enabled)
 {
     if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_ABOVE)
         return;
@@ -2835,12 +2659,12 @@ void _glfwSetWindowFloatingX11(_GLFWwindow *window, GLFWbool enabled)
     }
     else
     {
-        Atom *states = NULL;
+        Atom* states = NULL;
         const unsigned long count =
             _glfwGetWindowPropertyX11(window->x11.handle,
                                       _glfw.x11.NET_WM_STATE,
                                       XA_ATOM,
-                                      (unsigned char **)&states);
+                                      (unsigned char**) &states);
 
         // NOTE: We don't check for failure as this property may not exist yet
         //       and that's fine (and we'll create it implicitly with append)
@@ -2849,7 +2673,7 @@ void _glfwSetWindowFloatingX11(_GLFWwindow *window, GLFWbool enabled)
         {
             unsigned long i;
 
-            for (i = 0; i < count; i++)
+            for (i = 0;  i < count;  i++)
             {
                 if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
                     break;
@@ -2860,20 +2684,20 @@ void _glfwSetWindowFloatingX11(_GLFWwindow *window, GLFWbool enabled)
                 XChangeProperty(_glfw.x11.display, window->x11.handle,
                                 _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
                                 PropModeAppend,
-                                (unsigned char *)&_glfw.x11.NET_WM_STATE_ABOVE,
+                                (unsigned char*) &_glfw.x11.NET_WM_STATE_ABOVE,
                                 1);
             }
         }
         else if (states)
         {
-            for (unsigned long i = 0; i < count; i++)
+            for (unsigned long i = 0;  i < count;  i++)
             {
                 if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
                 {
                     states[i] = states[count - 1];
                     XChangeProperty(_glfw.x11.display, window->x11.handle,
                                     _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
-                                    PropModeReplace, (unsigned char *)states, count - 1);
+                                    PropModeReplace, (unsigned char*) states, count - 1);
                     break;
                 }
             }
@@ -2886,7 +2710,7 @@ void _glfwSetWindowFloatingX11(_GLFWwindow *window, GLFWbool enabled)
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetWindowMousePassthroughX11(_GLFWwindow *window, GLFWbool enabled)
+void _glfwSetWindowMousePassthroughX11(_GLFWwindow* window, GLFWbool enabled)
 {
     if (!_glfw.x11.xshape.available)
         return;
@@ -2905,20 +2729,20 @@ void _glfwSetWindowMousePassthroughX11(_GLFWwindow *window, GLFWbool enabled)
     }
 }
 
-float _glfwGetWindowOpacityX11(_GLFWwindow *window)
+float _glfwGetWindowOpacityX11(_GLFWwindow* window)
 {
     float opacity = 1.f;
 
     if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.NET_WM_CM_Sx))
     {
-        CARD32 *value = NULL;
+        CARD32* value = NULL;
 
         if (_glfwGetWindowPropertyX11(window->x11.handle,
                                       _glfw.x11.NET_WM_WINDOW_OPACITY,
                                       XA_CARDINAL,
-                                      (unsigned char **)&value))
+                                      (unsigned char**) &value))
         {
-            opacity = (float)(*value / (double)0xffffffffu);
+            opacity = (float) (*value / (double) 0xffffffffu);
         }
 
         if (value)
@@ -2928,12 +2752,12 @@ float _glfwGetWindowOpacityX11(_GLFWwindow *window)
     return opacity;
 }
 
-void _glfwSetWindowOpacityX11(_GLFWwindow *window, float opacity)
+void _glfwSetWindowOpacityX11(_GLFWwindow* window, float opacity)
 {
-    const CARD32 value = (CARD32)(0xffffffffu * (double)opacity);
+    const CARD32 value = (CARD32) (0xffffffffu * (double) opacity);
     XChangeProperty(_glfw.x11.display, window->x11.handle,
                     _glfw.x11.NET_WM_WINDOW_OPACITY, XA_CARDINAL, 32,
-                    PropModeReplace, (unsigned char *)&value, 1);
+                    PropModeReplace, (unsigned char*) &value, 1);
 }
 
 void _glfwSetRawMouseMotionX11(_GLFWwindow *window, GLFWbool enabled)
@@ -2961,8 +2785,7 @@ void _glfwPollEventsX11(void)
 
 #if defined(GLFW_BUILD_LINUX_JOYSTICK)
     if (_glfw.joysticksInitialized)
-        _glfwPollAllJoysticks();
-    _glfwDetectJoystickConnectionLinux();
+        _glfwDetectJoystickConnectionLinux();
 #endif
     XPending(_glfw.x11.display);
 
@@ -2973,7 +2796,7 @@ void _glfwPollEventsX11(void)
         processEvent(&event);
     }
 
-    _GLFWwindow *window = _glfw.x11.disabledCursorWindow;
+    _GLFWwindow* window = _glfw.x11.disabledCursorWindow;
     if (window)
     {
         int width, height;
@@ -3008,7 +2831,7 @@ void _glfwPostEmptyEventX11(void)
     writeEmptyEvent();
 }
 
-void _glfwGetCursorPosX11(_GLFWwindow *window, double *xpos, double *ypos)
+void _glfwGetCursorPosX11(_GLFWwindow* window, double* xpos, double* ypos)
 {
     Window root, child;
     int rootX, rootY, childX, childY;
@@ -3025,18 +2848,18 @@ void _glfwGetCursorPosX11(_GLFWwindow *window, double *xpos, double *ypos)
         *ypos = childY;
 }
 
-void _glfwSetCursorPosX11(_GLFWwindow *window, double x, double y)
+void _glfwSetCursorPosX11(_GLFWwindow* window, double x, double y)
 {
     // Store the new position so it can be recognized later
-    window->x11.warpCursorPosX = (int)x;
-    window->x11.warpCursorPosY = (int)y;
+    window->x11.warpCursorPosX = (int) x;
+    window->x11.warpCursorPosY = (int) y;
 
     XWarpPointer(_glfw.x11.display, None, window->x11.handle,
-                 0, 0, 0, 0, (int)x, (int)y);
+                 0,0,0,0, (int) x, (int) y);
     XFlush(_glfw.x11.display);
 }
 
-void _glfwSetCursorModeX11(_GLFWwindow *window, int mode)
+void _glfwSetCursorModeX11(_GLFWwindow* window, int mode)
 {
     if (_glfwWindowFocusedX11(window))
     {
@@ -3075,7 +2898,7 @@ void _glfwSetCursorModeX11(_GLFWwindow *window, int mode)
     XFlush(_glfw.x11.display);
 }
 
-const char *_glfwGetScancodeNameX11(int scancode)
+const char* _glfwGetScancodeNameX11(int scancode)
 {
     if (!_glfw.x11.xkb.available)
         return NULL;
@@ -3112,8 +2935,8 @@ int _glfwGetKeyScancodeX11(int key)
     return _glfw.x11.scancodes[key];
 }
 
-GLFWbool _glfwCreateCursorX11(_GLFWcursor *cursor,
-                              const GLFWimage *image,
+GLFWbool _glfwCreateCursorX11(_GLFWcursor* cursor,
+                              const GLFWimage* image,
                               int xhot, int yhot)
 {
     cursor->x11.handle = _glfwCreateNativeCursorX11(image, xhot, yhot);
@@ -3123,51 +2946,51 @@ GLFWbool _glfwCreateCursorX11(_GLFWcursor *cursor,
     return GLFW_TRUE;
 }
 
-GLFWbool _glfwCreateStandardCursorX11(_GLFWcursor *cursor, int shape)
+GLFWbool _glfwCreateStandardCursorX11(_GLFWcursor* cursor, int shape)
 {
     if (_glfw.x11.xcursor.handle)
     {
-        char *theme = XcursorGetTheme(_glfw.x11.display);
+        char* theme = XcursorGetTheme(_glfw.x11.display);
         if (theme)
         {
             const int size = XcursorGetDefaultSize(_glfw.x11.display);
-            const char *name = NULL;
+            const char* name = NULL;
 
             switch (shape)
             {
-            case GLFW_ARROW_CURSOR:
-                name = "default";
-                break;
-            case GLFW_IBEAM_CURSOR:
-                name = "text";
-                break;
-            case GLFW_CROSSHAIR_CURSOR:
-                name = "crosshair";
-                break;
-            case GLFW_POINTING_HAND_CURSOR:
-                name = "pointer";
-                break;
-            case GLFW_RESIZE_EW_CURSOR:
-                name = "ew-resize";
-                break;
-            case GLFW_RESIZE_NS_CURSOR:
-                name = "ns-resize";
-                break;
-            case GLFW_RESIZE_NWSE_CURSOR:
-                name = "nwse-resize";
-                break;
-            case GLFW_RESIZE_NESW_CURSOR:
-                name = "nesw-resize";
-                break;
-            case GLFW_RESIZE_ALL_CURSOR:
-                name = "all-scroll";
-                break;
-            case GLFW_NOT_ALLOWED_CURSOR:
-                name = "not-allowed";
-                break;
+                case GLFW_ARROW_CURSOR:
+                    name = "default";
+                    break;
+                case GLFW_IBEAM_CURSOR:
+                    name = "text";
+                    break;
+                case GLFW_CROSSHAIR_CURSOR:
+                    name = "crosshair";
+                    break;
+                case GLFW_POINTING_HAND_CURSOR:
+                    name = "pointer";
+                    break;
+                case GLFW_RESIZE_EW_CURSOR:
+                    name = "ew-resize";
+                    break;
+                case GLFW_RESIZE_NS_CURSOR:
+                    name = "ns-resize";
+                    break;
+                case GLFW_RESIZE_NWSE_CURSOR:
+                    name = "nwse-resize";
+                    break;
+                case GLFW_RESIZE_NESW_CURSOR:
+                    name = "nesw-resize";
+                    break;
+                case GLFW_RESIZE_ALL_CURSOR:
+                    name = "all-scroll";
+                    break;
+                case GLFW_NOT_ALLOWED_CURSOR:
+                    name = "not-allowed";
+                    break;
             }
 
-            XcursorImage *image = XcursorLibraryLoadImage(name, theme, size);
+            XcursorImage* image = XcursorLibraryLoadImage(name, theme, size);
             if (image)
             {
                 cursor->x11.handle = XcursorImageLoadCursor(_glfw.x11.display, image);
@@ -3182,31 +3005,31 @@ GLFWbool _glfwCreateStandardCursorX11(_GLFWcursor *cursor, int shape)
 
         switch (shape)
         {
-        case GLFW_ARROW_CURSOR:
-            native = XC_left_ptr;
-            break;
-        case GLFW_IBEAM_CURSOR:
-            native = XC_xterm;
-            break;
-        case GLFW_CROSSHAIR_CURSOR:
-            native = XC_crosshair;
-            break;
-        case GLFW_POINTING_HAND_CURSOR:
-            native = XC_hand2;
-            break;
-        case GLFW_RESIZE_EW_CURSOR:
-            native = XC_sb_h_double_arrow;
-            break;
-        case GLFW_RESIZE_NS_CURSOR:
-            native = XC_sb_v_double_arrow;
-            break;
-        case GLFW_RESIZE_ALL_CURSOR:
-            native = XC_fleur;
-            break;
-        default:
-            _glfwInputError(GLFW_CURSOR_UNAVAILABLE,
-                            "X11: Standard cursor shape unavailable");
-            return GLFW_FALSE;
+            case GLFW_ARROW_CURSOR:
+                native = XC_left_ptr;
+                break;
+            case GLFW_IBEAM_CURSOR:
+                native = XC_xterm;
+                break;
+            case GLFW_CROSSHAIR_CURSOR:
+                native = XC_crosshair;
+                break;
+            case GLFW_POINTING_HAND_CURSOR:
+                native = XC_hand2;
+                break;
+            case GLFW_RESIZE_EW_CURSOR:
+                native = XC_sb_h_double_arrow;
+                break;
+            case GLFW_RESIZE_NS_CURSOR:
+                native = XC_sb_v_double_arrow;
+                break;
+            case GLFW_RESIZE_ALL_CURSOR:
+                native = XC_fleur;
+                break;
+            default:
+                _glfwInputError(GLFW_CURSOR_UNAVAILABLE,
+                                "X11: Standard cursor shape unavailable");
+                return GLFW_FALSE;
         }
 
         cursor->x11.handle = XCreateFontCursor(_glfw.x11.display, native);
@@ -3221,13 +3044,13 @@ GLFWbool _glfwCreateStandardCursorX11(_GLFWcursor *cursor, int shape)
     return GLFW_TRUE;
 }
 
-void _glfwDestroyCursorX11(_GLFWcursor *cursor)
+void _glfwDestroyCursorX11(_GLFWcursor* cursor)
 {
     if (cursor->x11.handle)
         XFreeCursor(_glfw.x11.display, cursor->x11.handle);
 }
 
-void _glfwSetCursorX11(_GLFWwindow *window, _GLFWcursor *cursor)
+void _glfwSetCursorX11(_GLFWwindow* window, _GLFWcursor* cursor)
 {
     if (window->cursorMode == GLFW_CURSOR_NORMAL ||
         window->cursorMode == GLFW_CURSOR_CAPTURED)
@@ -3237,9 +3060,9 @@ void _glfwSetCursorX11(_GLFWwindow *window, _GLFWcursor *cursor)
     }
 }
 
-void _glfwSetClipboardStringX11(const char *string)
+void _glfwSetClipboardStringX11(const char* string)
 {
-    char *copy = _glfw_strdup(string);
+    char* copy = _glfw_strdup(string);
     _glfw_free(_glfw.x11.clipboardString);
     _glfw.x11.clipboardString = copy;
 
@@ -3256,12 +3079,12 @@ void _glfwSetClipboardStringX11(const char *string)
     }
 }
 
-const char *_glfwGetClipboardStringX11(void)
+const char* _glfwGetClipboardStringX11(void)
 {
     return getSelectionString(_glfw.x11.CLIPBOARD);
 }
 
-EGLenum _glfwGetEGLPlatformX11(EGLint **attribs)
+EGLenum _glfwGetEGLPlatformX11(EGLint** attribs)
 {
     if (_glfw.egl.ANGLE_platform_angle)
     {
@@ -3302,15 +3125,15 @@ EGLNativeDisplayType _glfwGetEGLNativeDisplayX11(void)
     return _glfw.x11.display;
 }
 
-EGLNativeWindowType _glfwGetEGLNativeWindowX11(_GLFWwindow *window)
+EGLNativeWindowType _glfwGetEGLNativeWindowX11(_GLFWwindow* window)
 {
     if (_glfw.egl.platform)
         return &window->x11.handle;
     else
-        return (EGLNativeWindowType)window->x11.handle;
+        return (EGLNativeWindowType) window->x11.handle;
 }
 
-void _glfwGetRequiredInstanceExtensionsX11(char **extensions)
+void _glfwGetRequiredInstanceExtensionsX11(char** extensions)
 {
     if (!_glfw.vk.KHR_surface)
         return;
@@ -3342,8 +3165,8 @@ GLFWbool _glfwGetPhysicalDevicePresentationSupportX11(VkInstance instance,
     {
         PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR
             vkGetPhysicalDeviceXcbPresentationSupportKHR =
-                (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)
-                    vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
+            (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)
+            vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
         if (!vkGetPhysicalDeviceXcbPresentationSupportKHR)
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
@@ -3351,7 +3174,7 @@ GLFWbool _glfwGetPhysicalDevicePresentationSupportX11(VkInstance instance,
             return GLFW_FALSE;
         }
 
-        xcb_connection_t *connection = XGetXCBConnection(_glfw.x11.display);
+        xcb_connection_t* connection = XGetXCBConnection(_glfw.x11.display);
         if (!connection)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -3368,8 +3191,8 @@ GLFWbool _glfwGetPhysicalDevicePresentationSupportX11(VkInstance instance,
     {
         PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR
             vkGetPhysicalDeviceXlibPresentationSupportKHR =
-                (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)
-                    vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
+            (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)
+            vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
         if (!vkGetPhysicalDeviceXlibPresentationSupportKHR)
         {
             _glfwInputError(GLFW_API_UNAVAILABLE,
@@ -3385,9 +3208,9 @@ GLFWbool _glfwGetPhysicalDevicePresentationSupportX11(VkInstance instance,
 }
 
 VkResult _glfwCreateWindowSurfaceX11(VkInstance instance,
-                                     _GLFWwindow *window,
-                                     const VkAllocationCallbacks *allocator,
-                                     VkSurfaceKHR *surface)
+                                     _GLFWwindow* window,
+                                     const VkAllocationCallbacks* allocator,
+                                     VkSurfaceKHR* surface)
 {
     if (_glfw.vk.KHR_xcb_surface && _glfw.x11.x11xcb.handle)
     {
@@ -3395,7 +3218,7 @@ VkResult _glfwCreateWindowSurfaceX11(VkInstance instance,
         VkXcbSurfaceCreateInfoKHR sci;
         PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR;
 
-        xcb_connection_t *connection = XGetXCBConnection(_glfw.x11.display);
+        xcb_connection_t* connection = XGetXCBConnection(_glfw.x11.display);
         if (!connection)
         {
             _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -3459,11 +3282,12 @@ VkResult _glfwCreateWindowSurfaceX11(VkInstance instance,
     }
 }
 
+
 //////////////////////////////////////////////////////////////////////////
 //////                        GLFW native API                       //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWAPI Display *glfwGetX11Display(void)
+GLFWAPI Display* glfwGetX11Display(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -3476,7 +3300,7 @@ GLFWAPI Display *glfwGetX11Display(void)
     return _glfw.x11.display;
 }
 
-GLFWAPI Window glfwGetX11Window(GLFWwindow *handle)
+GLFWAPI Window glfwGetX11Window(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(None);
 
@@ -3492,7 +3316,7 @@ GLFWAPI Window glfwGetX11Window(GLFWwindow *handle)
     return window->x11.handle;
 }
 
-GLFWAPI void glfwSetX11SelectionString(const char *string)
+GLFWAPI void glfwSetX11SelectionString(const char* string)
 {
     assert(string != NULL);
 
@@ -3520,7 +3344,7 @@ GLFWAPI void glfwSetX11SelectionString(const char *string)
     }
 }
 
-GLFWAPI const char *glfwGetX11SelectionString(void)
+GLFWAPI const char* glfwGetX11SelectionString(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -3534,3 +3358,4 @@ GLFWAPI const char *glfwGetX11SelectionString(void)
 }
 
 #endif // _GLFW_X11
+

From b9acd9d45f0a3d3cfc2a9646e482de8ed8367935 Mon Sep 17 00:00:00 2001
From: NarrikSynthfox <80410683+NarrikSynthfox@users.noreply.github.com>
Date: Wed, 10 Apr 2024 13:39:41 -0400
Subject: [PATCH 10/11] Update docs, readme, news, and contributors

---
 CONTRIBUTORS.md |  3 ++
 README.md       |  2 +-
 docs/input.md   | 79 +++++++++++++++++++++++++++++++++++++++++++++++++
 docs/news.md    | 15 ++++++++++
 4 files changed, 98 insertions(+), 1 deletion(-)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 1371aedb..d3349217 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -294,6 +294,9 @@ video tutorials.
  - Jonas Ådahl
  - Lasse Öörni
  - Leonard König
+ - Beoran
+ - Enthuin
+ - Narrik Synthfox
  - All the unmentioned and anonymous contributors in the GLFW community, for bug
    reports, patches, feedback, testing and encouragement
 
diff --git a/README.md b/README.md
index 2718e45e..44f3fadd 100644
--- a/README.md
+++ b/README.md
@@ -129,7 +129,7 @@ information on what to include when reporting a bug.
  - [Null] Added EGL context creation on Mesa via `EGL_MESA_platform_surfaceless`
  - [EGL] Allowed native access on Wayland with `GLFW_CONTEXT_CREATION_API` set to
    `GLFW_NATIVE_CONTEXT_API` (#2518)
-
+ - Added `GLFWgamepadstatefun`, `glfwSetGamepadStateCallback`, `GLFWjoystickbuttonfun`,`glfwSetJoystickButtonCallback`, `GLFWjoystickaxisfun`, `glfwSetJoystickAxisCallback`, `GLFWjoystickhatfun`, and `glfwSetJoystickHatCallback` for event-based joystick/gamepad input.
 
 ## Contact
 
diff --git a/docs/input.md b/docs/input.md
index 3ef1aebe..acfcfcdb 100644
--- a/docs/input.md
+++ b/docs/input.md
@@ -911,6 +911,85 @@ righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,
 were recently added to SDL.  The input modifiers `+`, `-` and `~` are supported
 and described above.
 
+### Event-based joystick and gamepad input {#joystick_input_event}
+
+If you wish to be notified when a button on a joystick is pressed or released, set a joystick button callback.
+
+```c
+glfwSetJoystickButtonCallback(joystick_button_callback);
+```
+
+The callback function receives the joystick id, the [joystick button](@ref joystick_button) that was pressed or released, and action.
+
+```c
+void joystick_button_callback(int jid, int button, int action)
+{
+    if (button == 0 && action == GLFW_PRESS)
+        jump();
+}
+```
+
+The action is one of `GLFW_PRESS` or `GLFW_RELEASE`
+
+If you wish to be notified when an axis on a joystick is moved, set a joystick axis callback.
+
+```c
+glfwSetJoystickAxisCallback(joystick_axis_callback);
+```
+
+The callback function receives the joystick id, [joystick axis](@ref joystick_axis) that was moved, and float value from -1.0 to 1.0 for the axis.
+
+```c
+void joystick_axis_callback(int jid, int axis, float value)
+{
+    if (axis == 0){
+        if(value == -1.0f)
+            move_left();
+        else if(value == 1.0f)
+            move_right();
+    }
+}
+```
+
+If you wish to be notified when a hat on a joystick is moved, set a joystick hat callback.
+
+```c
+glfwSetJoystickHatCallback(joystick_hat_callback);
+```
+
+The callback function receives the joystick id, hat, and the [hat states](@ref hat_state).
+
+```c
+void joystick_hat_callback(int jid, int hat, int position)
+{
+    if(hat == 0 && position == GLFW_HAT_UP)
+        move_up();
+}
+```
+
+If you wish to be notified when the state of a gamepad is updated, set a gamepad state callback. This callback will occur every time any button, axis, or hat updates, so with this, you will have to handle checks for if a value is changed.
+
+```c
+glfwSetGamepadStateCallback(gamepad_state_callback);
+```
+
+The callback function recieves the joystick id and the gamepad state.
+
+```c
+bool jumpButtonHeld = false;
+
+gamepad_state_callback(int jid, GLFWgamepadstate state){
+    if (state.buttons[GLFW_GAMEPAD_BUTTON_A] && !jumpButtonHeld)
+    {
+        input_jump();
+        jumpButtonHeld = true;
+    }
+    else if (!state.buttons[GLFW_GAMEPAD_BUTTON_A] && jumpButtonHeld)
+    {
+        jumpButtonHeld = false;
+    }
+}
+```
 
 ## Time input {#time}
 
diff --git a/docs/news.md b/docs/news.md
index 148d0871..cf02ac1d 100644
--- a/docs/news.md
+++ b/docs/news.md
@@ -14,6 +14,11 @@ values over 8. For compatibility with older versions, the
 @ref GLFW_UNLIMITED_MOUSE_BUTTONS input mode needs to be set to make use of
 this.
 
+### Callback functions for gamepad state, joystick buttons, joystick axes, and joystick hat inputs {#joystick_input_callbacks}
+
+GLFW now has callback functions for [gamepad state](@ref glfwSetGamepadStateCallback), [joystick buttons](@ref glfwSetJoystickButtonCallback), [joystick axes](@ref glfwSetJoystickAxisCallback), and [joystick hats](@ref glfwSetJoystickHatCallback), allowing for 
+event-based inputs for joysticks and gamepads.
+
 ## Caveats {#caveats}
 
 ## Deprecations {#deprecations}
@@ -24,8 +29,18 @@ this.
 
 ### New functions {#new_functions}
 
+- @ref glfwSetJoystickButtonCallback
+- @ref glfwSetJoystickAxisCallback
+- @ref glfwSetJoystickHatCallback
+- @ref glfwSetGamepadStateCallback
+
 ### New types {#new_types}
 
+- @ref GLFWjoystickbuttonfun
+- @ref GLFWjoystickaxisfun
+- @ref GLFWjoystickhatfun
+- @ref GLFWgamepadstatefun
+
 ### New constants {#new_constants}
 
 - @ref GLFW_UNLIMITED_MOUSE_BUTTONS

From 6cd8a730640b9481ebc15f53f0642a1587f221ab Mon Sep 17 00:00:00 2001
From: NarrikSynthfox <80410683+NarrikSynthfox@users.noreply.github.com>
Date: Wed, 10 Apr 2024 13:44:49 -0400
Subject: [PATCH 11/11] Update input.c

---
 src/input.c | 317 ++++++++++++++++++++++++++--------------------------
 1 file changed, 159 insertions(+), 158 deletions(-)

diff --git a/src/input.c b/src/input.c
index 7c2a153a..a9696a94 100644
--- a/src/input.c
+++ b/src/input.c
@@ -38,14 +38,14 @@
 #define _GLFW_STICK 3
 
 // Internal constants for gamepad mapping source types
-#define _GLFW_JOYSTICK_AXIS 1
-#define _GLFW_JOYSTICK_BUTTON 2
-#define _GLFW_JOYSTICK_HATBIT 3
+#define _GLFW_JOYSTICK_AXIS     1
+#define _GLFW_JOYSTICK_BUTTON   2
+#define _GLFW_JOYSTICK_HATBIT   3
 
-#define GLFW_MOD_MASK (GLFW_MOD_SHIFT |     \
-                       GLFW_MOD_CONTROL |   \
-                       GLFW_MOD_ALT |       \
-                       GLFW_MOD_SUPER |     \
+#define GLFW_MOD_MASK (GLFW_MOD_SHIFT | \
+                       GLFW_MOD_CONTROL | \
+                       GLFW_MOD_ALT | \
+                       GLFW_MOD_SUPER | \
                        GLFW_MOD_CAPS_LOCK | \
                        GLFW_MOD_NUM_LOCK)
 
@@ -67,11 +67,11 @@ static GLFWbool initJoysticks(void)
 
 // Finds a mapping based on joystick GUID
 //
-static _GLFWmapping *findMapping(const char *guid)
+static _GLFWmapping* findMapping(const char* guid)
 {
     int i;
 
-    for (i = 0; i < _glfw.mappingCount; i++)
+    for (i = 0;  i < _glfw.mappingCount;  i++)
     {
         if (strcmp(_glfw.mappings[i].guid, guid) == 0)
             return _glfw.mappings + i;
@@ -82,8 +82,8 @@ static _GLFWmapping *findMapping(const char *guid)
 
 // Checks whether a gamepad mapping element is present in the hardware
 //
-static GLFWbool isValidElementForJoystick(const _GLFWmapelement *e,
-                                          const _GLFWjoystick *js)
+static GLFWbool isValidElementForJoystick(const _GLFWmapelement* e,
+                                          const _GLFWjoystick* js)
 {
     if (e->type == _GLFW_JOYSTICK_HATBIT && (e->index >> 4) >= js->hatCount)
         return GLFW_FALSE;
@@ -97,20 +97,20 @@ static GLFWbool isValidElementForJoystick(const _GLFWmapelement *e,
 
 // Finds a mapping based on joystick GUID and verifies element indices
 //
-static _GLFWmapping *findValidMapping(const _GLFWjoystick *js)
+static _GLFWmapping* findValidMapping(const _GLFWjoystick* js)
 {
-    _GLFWmapping *mapping = findMapping(js->guid);
+    _GLFWmapping* mapping = findMapping(js->guid);
     if (mapping)
     {
         int i;
 
-        for (i = 0; i <= GLFW_GAMEPAD_BUTTON_LAST; i++)
+        for (i = 0;  i <= GLFW_GAMEPAD_BUTTON_LAST;  i++)
         {
             if (!isValidElementForJoystick(mapping->buttons + i, js))
                 return NULL;
         }
 
-        for (i = 0; i <= GLFW_GAMEPAD_AXIS_LAST; i++)
+        for (i = 0;  i <= GLFW_GAMEPAD_AXIS_LAST;  i++)
         {
             if (!isValidElementForJoystick(mapping->axes + i, js))
                 return NULL;
@@ -122,38 +122,39 @@ static _GLFWmapping *findValidMapping(const _GLFWjoystick *js)
 
 // Parses an SDL_GameControllerDB line and adds it to the mapping list
 //
-static GLFWbool parseMapping(_GLFWmapping *mapping, const char *string)
+static GLFWbool parseMapping(_GLFWmapping* mapping, const char* string)
 {
-    const char *c = string;
+    const char* c = string;
     size_t i, length;
     struct
     {
-        const char *name;
-        _GLFWmapelement *element;
+        const char* name;
+        _GLFWmapelement* element;
     } fields[] =
-        {
-            {"platform", NULL},
-            {"a", mapping->buttons + GLFW_GAMEPAD_BUTTON_A},
-            {"b", mapping->buttons + GLFW_GAMEPAD_BUTTON_B},
-            {"x", mapping->buttons + GLFW_GAMEPAD_BUTTON_X},
-            {"y", mapping->buttons + GLFW_GAMEPAD_BUTTON_Y},
-            {"back", mapping->buttons + GLFW_GAMEPAD_BUTTON_BACK},
-            {"start", mapping->buttons + GLFW_GAMEPAD_BUTTON_START},
-            {"guide", mapping->buttons + GLFW_GAMEPAD_BUTTON_GUIDE},
-            {"leftshoulder", mapping->buttons + GLFW_GAMEPAD_BUTTON_LEFT_BUMPER},
-            {"rightshoulder", mapping->buttons + GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER},
-            {"leftstick", mapping->buttons + GLFW_GAMEPAD_BUTTON_LEFT_THUMB},
-            {"rightstick", mapping->buttons + GLFW_GAMEPAD_BUTTON_RIGHT_THUMB},
-            {"dpup", mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_UP},
-            {"dpright", mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_RIGHT},
-            {"dpdown", mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_DOWN},
-            {"dpleft", mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_LEFT},
-            {"lefttrigger", mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_TRIGGER},
-            {"righttrigger", mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER},
-            {"leftx", mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_X},
-            {"lefty", mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_Y},
-            {"rightx", mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_X},
-            {"righty", mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_Y}};
+    {
+        { "platform",      NULL },
+        { "a",             mapping->buttons + GLFW_GAMEPAD_BUTTON_A },
+        { "b",             mapping->buttons + GLFW_GAMEPAD_BUTTON_B },
+        { "x",             mapping->buttons + GLFW_GAMEPAD_BUTTON_X },
+        { "y",             mapping->buttons + GLFW_GAMEPAD_BUTTON_Y },
+        { "back",          mapping->buttons + GLFW_GAMEPAD_BUTTON_BACK },
+        { "start",         mapping->buttons + GLFW_GAMEPAD_BUTTON_START },
+        { "guide",         mapping->buttons + GLFW_GAMEPAD_BUTTON_GUIDE },
+        { "leftshoulder",  mapping->buttons + GLFW_GAMEPAD_BUTTON_LEFT_BUMPER },
+        { "rightshoulder", mapping->buttons + GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER },
+        { "leftstick",     mapping->buttons + GLFW_GAMEPAD_BUTTON_LEFT_THUMB },
+        { "rightstick",    mapping->buttons + GLFW_GAMEPAD_BUTTON_RIGHT_THUMB },
+        { "dpup",          mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_UP },
+        { "dpright",       mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_RIGHT },
+        { "dpdown",        mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_DOWN },
+        { "dpleft",        mapping->buttons + GLFW_GAMEPAD_BUTTON_DPAD_LEFT },
+        { "lefttrigger",   mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_TRIGGER },
+        { "righttrigger",  mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER },
+        { "leftx",         mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_X },
+        { "lefty",         mapping->axes + GLFW_GAMEPAD_AXIS_LEFT_Y },
+        { "rightx",        mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_X },
+        { "righty",        mapping->axes + GLFW_GAMEPAD_AXIS_RIGHT_Y }
+    };
 
     length = strcspn(c, ",");
     if (length != 32 || c[length] != ',')
@@ -181,7 +182,7 @@ static GLFWbool parseMapping(_GLFWmapping *mapping, const char *string)
         if (*c == '+' || *c == '-')
             return GLFW_FALSE;
 
-        for (i = 0; i < sizeof(fields) / sizeof(fields[0]); i++)
+        for (i = 0;  i < sizeof(fields) / sizeof(fields[0]);  i++)
         {
             length = strlen(fields[i].name);
             if (strncmp(c, fields[i].name, length) != 0 || c[length] != ':')
@@ -191,7 +192,7 @@ static GLFWbool parseMapping(_GLFWmapping *mapping, const char *string)
 
             if (fields[i].element)
             {
-                _GLFWmapelement *e = fields[i].element;
+                _GLFWmapelement* e = fields[i].element;
                 int8_t minimum = -1;
                 int8_t maximum = 1;
 
@@ -217,12 +218,12 @@ static GLFWbool parseMapping(_GLFWmapping *mapping, const char *string)
 
                 if (e->type == _GLFW_JOYSTICK_HATBIT)
                 {
-                    const unsigned long hat = strtoul(c + 1, (char **)&c, 10);
-                    const unsigned long bit = strtoul(c + 1, (char **)&c, 10);
-                    e->index = (uint8_t)((hat << 4) | bit);
+                    const unsigned long hat = strtoul(c + 1, (char**) &c, 10);
+                    const unsigned long bit = strtoul(c + 1, (char**) &c, 10);
+                    e->index = (uint8_t) ((hat << 4) | bit);
                 }
                 else
-                    e->index = (uint8_t)strtoul(c + 1, (char **)&c, 10);
+                    e->index = (uint8_t) strtoul(c + 1, (char**) &c, 10);
 
                 if (e->type == _GLFW_JOYSTICK_AXIS)
                 {
@@ -238,7 +239,7 @@ static GLFWbool parseMapping(_GLFWmapping *mapping, const char *string)
             }
             else
             {
-                const char *name = _glfw.platform.getMappingName();
+                const char* name = _glfw.platform.getMappingName();
                 length = strlen(name);
                 if (strncmp(c, name, length) != 0)
                     return GLFW_FALSE;
@@ -251,7 +252,7 @@ static GLFWbool parseMapping(_GLFWmapping *mapping, const char *string)
         c += strspn(c, ",");
     }
 
-    for (i = 0; i < 32; i++)
+    for (i = 0;  i < 32;  i++)
     {
         if (mapping->guid[i] >= 'A' && mapping->guid[i] <= 'F')
             mapping->guid[i] += 'a' - 'A';
@@ -261,13 +262,14 @@ static GLFWbool parseMapping(_GLFWmapping *mapping, const char *string)
     return GLFW_TRUE;
 }
 
+
 //////////////////////////////////////////////////////////////////////////
 //////                         GLFW event API                       //////
 //////////////////////////////////////////////////////////////////////////
 
 // Notifies shared code of a physical key event
 //
-void _glfwInputKey(_GLFWwindow *window, int key, int scancode, int action, int mods)
+void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods)
 {
     assert(window != NULL);
     assert(key >= 0 || key == GLFW_KEY_UNKNOWN);
@@ -288,7 +290,7 @@ void _glfwInputKey(_GLFWwindow *window, int key, int scancode, int action, int m
         if (action == GLFW_RELEASE && window->stickyKeys)
             window->keys[key] = _GLFW_STICK;
         else
-            window->keys[key] = (char)action;
+            window->keys[key] = (char) action;
 
         if (repeated)
             action = GLFW_REPEAT;
@@ -298,13 +300,13 @@ void _glfwInputKey(_GLFWwindow *window, int key, int scancode, int action, int m
         mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
 
     if (window->callbacks.key)
-        window->callbacks.key((GLFWwindow *)window, key, scancode, action, mods);
+        window->callbacks.key((GLFWwindow*) window, key, scancode, action, mods);
 }
 
 // Notifies shared code of a Unicode codepoint input event
 // The 'plain' parameter determines whether to emit a regular character event
 //
-void _glfwInputChar(_GLFWwindow *window, uint32_t codepoint, int mods, GLFWbool plain)
+void _glfwInputChar(_GLFWwindow* window, uint32_t codepoint, int mods, GLFWbool plain)
 {
     assert(window != NULL);
     assert(mods == (mods & GLFW_MOD_MASK));
@@ -317,18 +319,18 @@ void _glfwInputChar(_GLFWwindow *window, uint32_t codepoint, int mods, GLFWbool
         mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
 
     if (window->callbacks.charmods)
-        window->callbacks.charmods((GLFWwindow *)window, codepoint, mods);
+        window->callbacks.charmods((GLFWwindow*) window, codepoint, mods);
 
     if (plain)
     {
         if (window->callbacks.character)
-            window->callbacks.character((GLFWwindow *)window, codepoint);
+            window->callbacks.character((GLFWwindow*) window, codepoint);
     }
 }
 
 // Notifies shared code of a scroll event
 //
-void _glfwInputScroll(_GLFWwindow *window, double xoffset, double yoffset)
+void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset)
 {
     assert(window != NULL);
     assert(xoffset > -FLT_MAX);
@@ -337,12 +339,12 @@ void _glfwInputScroll(_GLFWwindow *window, double xoffset, double yoffset)
     assert(yoffset < FLT_MAX);
 
     if (window->callbacks.scroll)
-        window->callbacks.scroll((GLFWwindow *)window, xoffset, yoffset);
+        window->callbacks.scroll((GLFWwindow*) window, xoffset, yoffset);
 }
 
 // Notifies shared code of a mouse button click event
 //
-void _glfwInputMouseClick(_GLFWwindow *window, int button, int action, int mods)
+void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
 {
     assert(window != NULL);
     assert(button >= 0);
@@ -364,13 +366,13 @@ void _glfwInputMouseClick(_GLFWwindow *window, int button, int action, int mods)
     }
 
     if (window->callbacks.mouseButton)
-        window->callbacks.mouseButton((GLFWwindow *)window, button, action, mods);
+        window->callbacks.mouseButton((GLFWwindow*) window, button, action, mods);
 }
 
 // Notifies shared code of a cursor motion event
 // The position is specified in content area relative screen coordinates
 //
-void _glfwInputCursorPos(_GLFWwindow *window, double xpos, double ypos)
+void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
 {
     assert(window != NULL);
     assert(xpos > -FLT_MAX);
@@ -385,30 +387,30 @@ void _glfwInputCursorPos(_GLFWwindow *window, double xpos, double ypos)
     window->virtualCursorPosY = ypos;
 
     if (window->callbacks.cursorPos)
-        window->callbacks.cursorPos((GLFWwindow *)window, xpos, ypos);
+        window->callbacks.cursorPos((GLFWwindow*) window, xpos, ypos);
 }
 
 // Notifies shared code of a cursor enter/leave event
 //
-void _glfwInputCursorEnter(_GLFWwindow *window, GLFWbool entered)
+void _glfwInputCursorEnter(_GLFWwindow* window, GLFWbool entered)
 {
     assert(window != NULL);
     assert(entered == GLFW_TRUE || entered == GLFW_FALSE);
 
     if (window->callbacks.cursorEnter)
-        window->callbacks.cursorEnter((GLFWwindow *)window, entered);
+        window->callbacks.cursorEnter((GLFWwindow*) window, entered);
 }
 
 // Notifies shared code of files or directories dropped on a window
 //
-void _glfwInputDrop(_GLFWwindow *window, int count, const char **paths)
+void _glfwInputDrop(_GLFWwindow* window, int count, const char** paths)
 {
     assert(window != NULL);
     assert(count > 0);
     assert(paths != NULL);
 
     if (window->callbacks.drop)
-        window->callbacks.drop((GLFWwindow *)window, count, paths);
+        window->callbacks.drop((GLFWwindow*) window, count, paths);
 }
 
 // Notifies shared code of a change in the gamepad state.
@@ -434,7 +436,7 @@ void _glfwInputGamepad(_GLFWjoystick *js)
 
 // Notifies shared code of a joystick connection or disconnection
 //
-void _glfwInputJoystick(_GLFWjoystick *js, int event)
+void _glfwInputJoystick(_GLFWjoystick* js, int event)
 {
     assert(js != NULL);
     assert(event == GLFW_CONNECTED || event == GLFW_DISCONNECTED);
@@ -445,12 +447,12 @@ void _glfwInputJoystick(_GLFWjoystick *js, int event)
         js->connected = GLFW_FALSE;
 
     if (_glfw.callbacks.joystick)
-        _glfw.callbacks.joystick((int)(js - _glfw.joysticks), event);
+        _glfw.callbacks.joystick((int) (js - _glfw.joysticks), event);
 }
 
 // Notifies shared code of the new value of a joystick axis
 //
-void _glfwInputJoystickAxis(_GLFWjoystick *js, int axis, float value)
+void _glfwInputJoystickAxis(_GLFWjoystick* js, int axis, float value)
 {
     assert(js != NULL);
     assert(axis >= 0);
@@ -465,13 +467,13 @@ void _glfwInputJoystickAxis(_GLFWjoystick *js, int axis, float value)
             _glfw.callbacks.joystick_axis(jid, axis, value);
         _glfwInputGamepad(js);
     } else {
-        js->axes[axis] = value;
+    js->axes[axis] = value;
     }
 }
 
 // Notifies shared code of the new value of a joystick button
 //
-void _glfwInputJoystickButton(_GLFWjoystick *js, int button, char value)
+void _glfwInputJoystickButton(_GLFWjoystick* js, int button, char value)
 {
     assert(js != NULL);
     assert(button >= 0);
@@ -481,8 +483,8 @@ void _glfwInputJoystickButton(_GLFWjoystick *js, int button, char value)
     if (js->buttons[button] != value) {
         const int jid = (int)(js - _glfw.joysticks);
 
-        js->buttons[button] = value;
-        if (_glfw.callbacks.joystick_button)
+    js->buttons[button] = value;
+    if (_glfw.callbacks.joystick_button)
             _glfw.callbacks.joystick_button(jid, button, value);
         _glfwInputGamepad(js);
     } else {
@@ -492,7 +494,7 @@ void _glfwInputJoystickButton(_GLFWjoystick *js, int button, char value)
 
 // Notifies shared code of the new value of a joystick hat
 //
-void _glfwInputJoystickHat(_GLFWjoystick *js, int hat, char value)
+void _glfwInputJoystickHat(_GLFWjoystick* js, int hat, char value)
 {
     int base;
 
@@ -512,13 +514,12 @@ void _glfwInputJoystickHat(_GLFWjoystick *js, int hat, char value)
     js->buttons[base + 1] = (value & 0x02) ? GLFW_PRESS : GLFW_RELEASE;
     js->buttons[base + 2] = (value & 0x04) ? GLFW_PRESS : GLFW_RELEASE;
     js->buttons[base + 3] = (value & 0x08) ? GLFW_PRESS : GLFW_RELEASE;
-
     if (js->hats[hat] != value)
     {
         const int jid = (int)(js - _glfw.joysticks);
 
-        js->hats[hat] = value;
-        if (_glfw.callbacks.joystick_hat)
+    js->hats[hat] = value;
+    if (_glfw.callbacks.joystick_hat)
             _glfw.callbacks.joystick_hat(jid, hat, value);
         _glfwInputGamepad(js);
     }
@@ -533,10 +534,10 @@ void _glfwInputJoystickHat(_GLFWjoystick *js, int hat, char value)
 void _glfwInitGamepadMappings(void)
 {
     size_t i;
-    const size_t count = sizeof(_glfwDefaultMappings) / sizeof(char *);
+    const size_t count = sizeof(_glfwDefaultMappings) / sizeof(char*);
     _glfw.mappings = _glfw_calloc(count, sizeof(_GLFWmapping));
 
-    for (i = 0; i < count; i++)
+    for (i = 0;  i < count;  i++)
     {
         if (parseMapping(&_glfw.mappings[_glfw.mappingCount], _glfwDefaultMappings[i]))
             _glfw.mappingCount++;
@@ -545,16 +546,16 @@ void _glfwInitGamepadMappings(void)
 
 // Returns an available joystick object with arrays and name allocated
 //
-_GLFWjoystick *_glfwAllocJoystick(const char *name,
-                                  const char *guid,
+_GLFWjoystick* _glfwAllocJoystick(const char* name,
+                                  const char* guid,
                                   int axisCount,
                                   int buttonCount,
                                   int hatCount)
 {
     int jid;
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
-    for (jid = 0; jid <= GLFW_JOYSTICK_LAST; jid++)
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
     {
         if (!_glfw.joysticks[jid].allocated)
             break;
@@ -564,13 +565,13 @@ _GLFWjoystick *_glfwAllocJoystick(const char *name,
         return NULL;
 
     js = _glfw.joysticks + jid;
-    js->allocated = GLFW_TRUE;
-    js->axes = _glfw_calloc(axisCount, sizeof(float));
-    js->buttons = _glfw_calloc(buttonCount + (size_t)hatCount * 4, 1);
-    js->hats = _glfw_calloc(hatCount, 1);
-    js->axisCount = axisCount;
+    js->allocated   = GLFW_TRUE;
+    js->axes        = _glfw_calloc(axisCount, sizeof(float));
+    js->buttons     = _glfw_calloc(buttonCount + (size_t) hatCount * 4, 1);
+    js->hats        = _glfw_calloc(hatCount, 1);
+    js->axisCount   = axisCount;
     js->buttonCount = buttonCount;
-    js->hatCount = hatCount;
+    js->hatCount    = hatCount;
 
     strncpy(js->name, name, sizeof(js->name) - 1);
     strncpy(js->guid, guid, sizeof(js->guid) - 1);
@@ -581,7 +582,7 @@ _GLFWjoystick *_glfwAllocJoystick(const char *name,
 
 // Frees arrays and name and flags the joystick object as unused
 //
-void _glfwFreeJoystick(_GLFWjoystick *js)
+void _glfwFreeJoystick(_GLFWjoystick* js)
 {
     _glfw_free(js->axes);
     _glfw_free(js->buttons);
@@ -591,7 +592,7 @@ void _glfwFreeJoystick(_GLFWjoystick *js)
 
 // Center the cursor in the content area of the specified window
 //
-void _glfwCenterCursorInContentArea(_GLFWwindow *window)
+void _glfwCenterCursorInContentArea(_GLFWwindow* window)
 {
     int width, height;
 
@@ -617,7 +618,7 @@ void _glfwPollAllJoysticks()
 //////                        GLFW public API                       //////
 //////////////////////////////////////////////////////////////////////////
 
-GLFWAPI int glfwGetInputMode(GLFWwindow *handle, int mode)
+GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(0);
 
@@ -644,7 +645,7 @@ GLFWAPI int glfwGetInputMode(GLFWwindow *handle, int mode)
     return 0;
 }
 
-GLFWAPI void glfwSetInputMode(GLFWwindow *handle, int mode, int value)
+GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -689,7 +690,7 @@ GLFWAPI void glfwSetInputMode(GLFWwindow *handle, int mode, int value)
                 int i;
 
                 // Release all sticky keys
-                for (i = 0; i <= GLFW_KEY_LAST; i++)
+                for (i = 0;  i <= GLFW_KEY_LAST;  i++)
                 {
                     if (window->keys[i] == _GLFW_STICK)
                         window->keys[i] = GLFW_RELEASE;
@@ -711,7 +712,7 @@ GLFWAPI void glfwSetInputMode(GLFWwindow *handle, int mode, int value)
                 int i;
 
                 // Release all sticky mouse buttons
-                for (i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++)
+                for (i = 0;  i <= GLFW_MOUSE_BUTTON_LAST;  i++)
                 {
                     if (window->mouseButtons[i] == _GLFW_STICK)
                         window->mouseButtons[i] = GLFW_RELEASE;
@@ -762,7 +763,7 @@ GLFWAPI int glfwRawMouseMotionSupported(void)
     return _glfw.platform.rawMouseMotionSupported();
 }
 
-GLFWAPI const char *glfwGetKeyName(int key, int scancode)
+GLFWAPI const char* glfwGetKeyName(int key, int scancode)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -800,7 +801,7 @@ GLFWAPI int glfwGetKeyScancode(int key)
     return _glfw.platform.getKeyScancode(key);
 }
 
-GLFWAPI int glfwGetKey(GLFWwindow *handle, int key)
+GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
 
@@ -820,10 +821,10 @@ GLFWAPI int glfwGetKey(GLFWwindow *handle, int key)
         return GLFW_PRESS;
     }
 
-    return (int)window->keys[key];
+    return (int) window->keys[key];
 }
 
-GLFWAPI int glfwGetMouseButton(GLFWwindow *handle, int button)
+GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
 
@@ -843,10 +844,10 @@ GLFWAPI int glfwGetMouseButton(GLFWwindow *handle, int button)
         return GLFW_PRESS;
     }
 
-    return (int)window->mouseButtons[button];
+    return (int) window->mouseButtons[button];
 }
 
-GLFWAPI void glfwGetCursorPos(GLFWwindow *handle, double *xpos, double *ypos)
+GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
 {
     if (xpos)
         *xpos = 0;
@@ -869,7 +870,7 @@ GLFWAPI void glfwGetCursorPos(GLFWwindow *handle, double *xpos, double *ypos)
         _glfw.platform.getCursorPos(window, xpos, ypos);
 }
 
-GLFWAPI void glfwSetCursorPos(GLFWwindow *handle, double xpos, double ypos)
+GLFWAPI void glfwSetCursorPos(GLFWwindow* handle, double xpos, double ypos)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -901,9 +902,9 @@ GLFWAPI void glfwSetCursorPos(GLFWwindow *handle, double xpos, double ypos)
     }
 }
 
-GLFWAPI GLFWcursor *glfwCreateCursor(const GLFWimage *image, int xhot, int yhot)
+GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot)
 {
-    _GLFWcursor *cursor;
+    _GLFWcursor* cursor;
 
     assert(image != NULL);
     assert(image->pixels != NULL);
@@ -922,16 +923,16 @@ GLFWAPI GLFWcursor *glfwCreateCursor(const GLFWimage *image, int xhot, int yhot)
 
     if (!_glfw.platform.createCursor(cursor, image, xhot, yhot))
     {
-        glfwDestroyCursor((GLFWcursor *)cursor);
+        glfwDestroyCursor((GLFWcursor*) cursor);
         return NULL;
     }
 
-    return (GLFWcursor *)cursor;
+    return (GLFWcursor*) cursor;
 }
 
-GLFWAPI GLFWcursor *glfwCreateStandardCursor(int shape)
+GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape)
 {
-    _GLFWcursor *cursor;
+    _GLFWcursor* cursor;
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -956,14 +957,14 @@ GLFWAPI GLFWcursor *glfwCreateStandardCursor(int shape)
 
     if (!_glfw.platform.createStandardCursor(cursor, shape))
     {
-        glfwDestroyCursor((GLFWcursor *)cursor);
+        glfwDestroyCursor((GLFWcursor*) cursor);
         return NULL;
     }
 
-    return (GLFWcursor *)cursor;
+    return (GLFWcursor*) cursor;
 }
 
-GLFWAPI void glfwDestroyCursor(GLFWcursor *handle)
+GLFWAPI void glfwDestroyCursor(GLFWcursor* handle)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -974,12 +975,12 @@ GLFWAPI void glfwDestroyCursor(GLFWcursor *handle)
 
     // Make sure the cursor is not being used by any window
     {
-        _GLFWwindow *window;
+        _GLFWwindow* window;
 
-        for (window = _glfw.windowListHead; window; window = window->next)
+        for (window = _glfw.windowListHead;  window;  window = window->next)
         {
             if (window->cursor == cursor)
-                glfwSetCursor((GLFWwindow *)window, NULL);
+                glfwSetCursor((GLFWwindow*) window, NULL);
         }
     }
 
@@ -987,7 +988,7 @@ GLFWAPI void glfwDestroyCursor(GLFWcursor *handle)
 
     // Unlink cursor from global linked list
     {
-        _GLFWcursor **prev = &_glfw.cursorListHead;
+        _GLFWcursor** prev = &_glfw.cursorListHead;
 
         while (*prev != cursor)
             prev = &((*prev)->next);
@@ -998,7 +999,7 @@ GLFWAPI void glfwDestroyCursor(GLFWcursor *handle)
     _glfw_free(cursor);
 }
 
-GLFWAPI void glfwSetCursor(GLFWwindow *windowHandle, GLFWcursor *cursorHandle)
+GLFWAPI void glfwSetCursor(GLFWwindow* windowHandle, GLFWcursor* cursorHandle)
 {
     _GLFW_REQUIRE_INIT();
 
@@ -1011,7 +1012,7 @@ GLFWAPI void glfwSetCursor(GLFWwindow *windowHandle, GLFWcursor *cursorHandle)
     _glfw.platform.setCursor(window, cursor);
 }
 
-GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow *handle, GLFWkeyfun cbfun)
+GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* handle, GLFWkeyfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -1022,7 +1023,7 @@ GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow *handle, GLFWkeyfun cbfun)
     return cbfun;
 }
 
-GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow *handle, GLFWcharfun cbfun)
+GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* handle, GLFWcharfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -1033,7 +1034,7 @@ GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow *handle, GLFWcharfun cbfun)
     return cbfun;
 }
 
-GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow *handle, GLFWcharmodsfun cbfun)
+GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* handle, GLFWcharmodsfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -1044,7 +1045,7 @@ GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow *handle, GLFWcharmods
     return cbfun;
 }
 
-GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow *handle,
+GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* handle,
                                                       GLFWmousebuttonfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1056,7 +1057,7 @@ GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow *handle,
     return cbfun;
 }
 
-GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow *handle,
+GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* handle,
                                                   GLFWcursorposfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1068,7 +1069,7 @@ GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow *handle,
     return cbfun;
 }
 
-GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow *handle,
+GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* handle,
                                                       GLFWcursorenterfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1080,7 +1081,7 @@ GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow *handle,
     return cbfun;
 }
 
-GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow *handle,
+GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* handle,
                                             GLFWscrollfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
@@ -1092,7 +1093,7 @@ GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow *handle,
     return cbfun;
 }
 
-GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow *handle, GLFWdropfun cbfun)
+GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* handle, GLFWdropfun cbfun)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
@@ -1105,7 +1106,7 @@ GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow *handle, GLFWdropfun cbfun)
 
 GLFWAPI int glfwJoystickPresent(int jid)
 {
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
@@ -1128,9 +1129,9 @@ GLFWAPI int glfwJoystickPresent(int jid)
     return _glfw.platform.pollJoystick(js, _GLFW_POLL_PRESENCE);
 }
 
-GLFWAPI const float *glfwGetJoystickAxes(int jid, int *count)
+GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count)
 {
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
@@ -1160,9 +1161,9 @@ GLFWAPI const float *glfwGetJoystickAxes(int jid, int *count)
     return js->axes;
 }
 
-GLFWAPI const unsigned char *glfwGetJoystickButtons(int jid, int *count)
+GLFWAPI const unsigned char* glfwGetJoystickButtons(int jid, int* count)
 {
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
@@ -1196,9 +1197,9 @@ GLFWAPI const unsigned char *glfwGetJoystickButtons(int jid, int *count)
     return js->buttons;
 }
 
-GLFWAPI const unsigned char *glfwGetJoystickHats(int jid, int *count)
+GLFWAPI const unsigned char* glfwGetJoystickHats(int jid, int* count)
 {
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
@@ -1228,9 +1229,9 @@ GLFWAPI const unsigned char *glfwGetJoystickHats(int jid, int *count)
     return js->hats;
 }
 
-GLFWAPI const char *glfwGetJoystickName(int jid)
+GLFWAPI const char* glfwGetJoystickName(int jid)
 {
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
@@ -1256,9 +1257,9 @@ GLFWAPI const char *glfwGetJoystickName(int jid)
     return js->name;
 }
 
-GLFWAPI const char *glfwGetJoystickGUID(int jid)
+GLFWAPI const char* glfwGetJoystickGUID(int jid)
 {
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
@@ -1284,9 +1285,9 @@ GLFWAPI const char *glfwGetJoystickGUID(int jid)
     return js->guid;
 }
 
-GLFWAPI void glfwSetJoystickUserPointer(int jid, void *pointer)
+GLFWAPI void glfwSetJoystickUserPointer(int jid, void* pointer)
 {
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
@@ -1300,9 +1301,9 @@ GLFWAPI void glfwSetJoystickUserPointer(int jid, void *pointer)
     js->userPointer = pointer;
 }
 
-GLFWAPI void *glfwGetJoystickUserPointer(int jid)
+GLFWAPI void* glfwGetJoystickUserPointer(int jid)
 {
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
@@ -1355,10 +1356,10 @@ GLFWAPI GLFWjoystickhatfun glfwSetJoystickHatCallback(GLFWjoystickhatfun cbfun)
     return cbfun;
 }
 
-GLFWAPI int glfwUpdateGamepadMappings(const char *string)
+GLFWAPI int glfwUpdateGamepadMappings(const char* string)
 {
     int jid;
-    const char *c = string;
+    const char* c = string;
 
     assert(string != NULL);
 
@@ -1382,7 +1383,7 @@ GLFWAPI int glfwUpdateGamepadMappings(const char *string)
 
                 if (parseMapping(&mapping, line))
                 {
-                    _GLFWmapping *previous = findMapping(mapping.guid);
+                    _GLFWmapping* previous = findMapping(mapping.guid);
                     if (previous)
                         *previous = mapping;
                     else
@@ -1405,9 +1406,9 @@ GLFWAPI int glfwUpdateGamepadMappings(const char *string)
         }
     }
 
-    for (jid = 0; jid <= GLFW_JOYSTICK_LAST; jid++)
+    for (jid = 0;  jid <= GLFW_JOYSTICK_LAST;  jid++)
     {
-        _GLFWjoystick *js = _glfw.joysticks + jid;
+        _GLFWjoystick* js = _glfw.joysticks + jid;
         if (js->connected)
             js->mapping = findValidMapping(js);
     }
@@ -1417,7 +1418,7 @@ GLFWAPI int glfwUpdateGamepadMappings(const char *string)
 
 GLFWAPI int glfwJoystickIsGamepad(int jid)
 {
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
@@ -1443,9 +1444,9 @@ GLFWAPI int glfwJoystickIsGamepad(int jid)
     return js->mapping != NULL;
 }
 
-GLFWAPI const char *glfwGetGamepadName(int jid)
+GLFWAPI const char* glfwGetGamepadName(int jid)
 {
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
@@ -1474,10 +1475,10 @@ GLFWAPI const char *glfwGetGamepadName(int jid)
     return js->mapping->name;
 }
 
-GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate *state)
+GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state)
 {
     int i;
-    _GLFWjoystick *js;
+    _GLFWjoystick* js;
 
     assert(jid >= GLFW_JOYSTICK_1);
     assert(jid <= GLFW_JOYSTICK_LAST);
@@ -1506,9 +1507,9 @@ GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate *state)
     if (!js->mapping)
         return GLFW_FALSE;
 
-    for (i = 0; i <= GLFW_GAMEPAD_BUTTON_LAST; i++)
+    for (i = 0;  i <= GLFW_GAMEPAD_BUTTON_LAST;  i++)
     {
-        const _GLFWmapelement *e = js->mapping->buttons + i;
+        const _GLFWmapelement* e = js->mapping->buttons + i;
         if (e->type == _GLFW_JOYSTICK_AXIS)
         {
             const float value = js->axes[e->index] * e->axisScale + e->axisOffset;
@@ -1536,9 +1537,9 @@ GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate *state)
             state->buttons[i] = js->buttons[e->index];
     }
 
-    for (i = 0; i <= GLFW_GAMEPAD_AXIS_LAST; i++)
+    for (i = 0;  i <= GLFW_GAMEPAD_AXIS_LAST;  i++)
     {
-        const _GLFWmapelement *e = js->mapping->axes + i;
+        const _GLFWmapelement* e = js->mapping->axes + i;
         if (e->type == _GLFW_JOYSTICK_AXIS)
         {
             const float value = js->axes[e->index] * e->axisScale + e->axisOffset;
@@ -1560,7 +1561,7 @@ GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate *state)
     return GLFW_TRUE;
 }
 
-GLFWAPI void glfwSetClipboardString(GLFWwindow *handle, const char *string)
+GLFWAPI void glfwSetClipboardString(GLFWwindow* handle, const char* string)
 {
     assert(string != NULL);
 
@@ -1568,7 +1569,7 @@ GLFWAPI void glfwSetClipboardString(GLFWwindow *handle, const char *string)
     _glfw.platform.setClipboardString(string);
 }
 
-GLFWAPI const char *glfwGetClipboardString(GLFWwindow *handle)
+GLFWAPI const char* glfwGetClipboardString(GLFWwindow* handle)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     return _glfw.platform.getClipboardString();
@@ -1577,8 +1578,8 @@ GLFWAPI const char *glfwGetClipboardString(GLFWwindow *handle)
 GLFWAPI double glfwGetTime(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(0.0);
-    return (double)(_glfwPlatformGetTimerValue() - _glfw.timer.offset) /
-           _glfwPlatformGetTimerFrequency();
+    return (double) (_glfwPlatformGetTimerValue() - _glfw.timer.offset) /
+        _glfwPlatformGetTimerFrequency();
 }
 
 GLFWAPI void glfwSetTime(double time)
@@ -1592,7 +1593,7 @@ GLFWAPI void glfwSetTime(double time)
     }
 
     _glfw.timer.offset = _glfwPlatformGetTimerValue() -
-                         (uint64_t)(time * _glfwPlatformGetTimerFrequency());
+        (uint64_t) (time * _glfwPlatformGetTimerFrequency());
 }
 
 GLFWAPI uint64_t glfwGetTimerValue(void)