Merge branch 'master' into showwindow

include/GL/glfw3.h

@@ -67,12 +67,6 @@ extern "C" {
  #endif
 #endif /* APIENTRY */
 
-/* TEMPORARY MinGW-w64 hacks.
- */
-#if __MINGW64__
- #define WINAPI
-#endif
-
 /* The following three defines are here solely to make some Windows-based
  * <GL/gl.h> files happy. Theoretically we could include <windows.h>, but
  * it has the major drawback of severely polluting our namespace.

src/CMakeLists.txt

@@ -3,7 +3,7 @@ include_directories(${GLFW_SOURCE_DIR}/src
                     ${glfw_INCLUDE_DIRS})
 
 set(common_HEADERS ${GLFW_SOURCE_DIR}/include/GL/glfw3.h internal.h)
-set(common_SOURCES clipboard.c error.c fullscreen.c gamma.c init.c input.c
+set(common_SOURCES clipboard.c fullscreen.c gamma.c init.c input.c
                    joystick.c opengl.c time.c window.c)
 
 if (_GLFW_COCOA_NSGL)

src/cocoa_clipboard.m

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
+// Platform:    Cocoa
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -70,7 +70,7 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
     if (!object)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Cocoa/NSGL: Failed to retrieve object from pasteboard");
+                      "Cocoa: Failed to retrieve object from pasteboard");
         return NULL;
     }
 

src/cocoa_fullscreen.m

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
+// Platform:    Cocoa
 // API Version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------

src/cocoa_gamma.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
+// Platform:    Cocoa
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -40,7 +40,7 @@
 //************************************************************************
 
 //========================================================================
-// Save the original gamma ramp so that we can restore it later
+// Save the original gamma ramp so that it can be restored later
 //========================================================================
 
 void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp)

src/cocoa_input.m

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
+// Platform:    Cocoa
 // API Version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -40,13 +40,14 @@
 
 void _glfwPlatformEnableSystemKeys(_GLFWwindow* window)
 {
-    // This is checked in macosx_window.m; we take no action here
+    // This is checked in cocoa_window.m; no action needed here
 }
 
 void _glfwPlatformDisableSystemKeys(_GLFWwindow* window)
 {
-    // This is checked in macosx_window.m; we take no action here
-    // I don't think it's really possible to disable stuff like Exposé
+    // This is checked in cocoa_window.m; no action needed here
+
+    // Note that it may not be possible to disable things like Exposé
     // except in full-screen mode.
 }
 

src/cocoa_joystick.m

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
+// Platform:    Cocoa
 // API Version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -47,7 +47,6 @@
 //------------------------------------------------------------------------
 // Joystick element information
 //------------------------------------------------------------------------
-
 typedef struct
 {
     IOHIDElementCookie cookie;
@@ -66,7 +65,6 @@ typedef struct
 //------------------------------------------------------------------------
 // Joystick information & state
 //------------------------------------------------------------------------
-
 typedef struct
 {
     int present;
@@ -214,7 +212,7 @@ static long getElementValue(_glfwJoystick* joystick, _glfwJoystickElement* eleme
                                                            &hidEvent);
         if (kIOReturnSuccess == result)
         {
-            /* record min and max for auto calibration */
+            // Record min and max for auto calibration
             if (hidEvent.value < element->minReport)
                 element->minReport = hidEvent.value;
             if (hidEvent.value > element->maxReport)
@@ -222,7 +220,7 @@ static long getElementValue(_glfwJoystick* joystick, _glfwJoystickElement* eleme
         }
     }
 
-    /* auto user scale */
+    // Auto user scale
     return (long) hidEvent.value;
 }
 
@@ -285,7 +283,7 @@ static void removalCallback(void* target, IOReturn result, void* refcon, void* s
 
 
 //========================================================================
-// Polls for joystick events and updates GFLW state
+// Polls for joystick events and updates GLFW state
 //========================================================================
 
 static void pollJoystickEvents(void)
@@ -385,14 +383,14 @@ void _glfwInitJoysticks(void)
         if (result != kIOReturnSuccess)
             continue;
 
-        /* Check device type */
+        // Check device type
         refCF = CFDictionaryGetValue(hidProperties, CFSTR(kIOHIDPrimaryUsagePageKey));
         if (refCF)
         {
             CFNumberGetValue(refCF, kCFNumberLongType, &usagePage);
             if (usagePage != kHIDPage_GenericDesktop)
             {
-                /* We are not interested in this device */
+                // This device is not relevant to GLFW
                 continue;
             }
         }
@@ -406,7 +404,7 @@ void _glfwInitJoysticks(void)
                  usage != kHIDUsage_GD_GamePad &&
                  usage != kHIDUsage_GD_MultiAxisController))
             {
-                /* We are not interested in this device */
+                // This device is not relevant to GLFW
                 continue;
             }
         }
@@ -440,7 +438,7 @@ void _glfwInitJoysticks(void)
                                                      joystick,
                                                      joystick);
 
-        /* Get product string */
+        // Get product string
         refCF = CFDictionaryGetValue(hidProperties, CFSTR(kIOHIDProductKey));
         if (refCF)
         {
@@ -562,8 +560,6 @@ int _glfwPlatformGetJoystickPos(int joy, float* pos, int numaxes)
         else
             pos[i] = (2.0f * (axes->value - axes->minReport) / readScale) - 1.0f;
 
-        //printf("%ld, %ld, %ld\n", axes->value, axes->minReport, axes->maxReport);
-
         if (i & 1)
             pos[i] = -pos[i];
     }

src/cocoa_time.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
+// Platform:    Cocoa
 // API Version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------

src/cocoa_window.m

@@ -296,9 +296,6 @@ static int convertMacKeyCode(unsigned int macKeyCode)
     if (macKeyCode >= 128)
         return -1;
 
-    // This treats keycodes as *positional*; that is, we'll return 'a'
-    // for the key left of 's', even on an AZERTY keyboard.  The charInput
-    // function should still get 'q' though.
     return table[macKeyCode];
 }
 
@@ -560,7 +557,7 @@ static NSString* findAppName(void)
         }
     }
 
-    // If we get here, we're unbundled
+    // If we get here, the application is unbundled
     ProcessSerialNumber psn = { 0, kCurrentProcess };
     TransformProcessType(&psn, kProcessTransformToForegroundApplication);
 
@@ -570,10 +567,7 @@ static NSString* findAppName(void)
 
     char** progname = _NSGetProgname();
     if (progname && *progname)
-    {
-        // TODO: UTF-8?
         return [NSString stringWithUTF8String:*progname];
-    }
 
     // Really shouldn't get here
     return @"GLFW Application";
@@ -699,8 +693,7 @@ static GLboolean createWindow(_GLFWwindow* window,
 
     if (window->NS.object == nil)
     {
-        _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Cocoa/NSOpenGL: Failed to create window");
+        _glfwSetError(GLFW_PLATFORM_ERROR, "Cocoa: Failed to create window");
         return GL_FALSE;
     }
 
@@ -742,8 +735,8 @@ static GLboolean createContext(_GLFWwindow* window,
         (wndconfig->glMajor == 3 && wndconfig->glMinor != 2))
     {
         _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                      "Cocoa/NSOpenGL: The targeted version of Mac OS X does "
-                      "not support any OpenGL version above 2.1 except 3.2");
+                      "NSOpenGL: The targeted version of Mac OS X does not "
+                      "support any OpenGL version above 2.1 except 3.2");
         return GL_FALSE;
     }
 
@@ -752,8 +745,8 @@ static GLboolean createContext(_GLFWwindow* window,
         if (!wndconfig->glForward)
         {
             _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                          "Cocoa/NSOpenGL: The targeted version of Mac OS X "
-                          "only supports OpenGL 3.2 contexts if they are "
+                          "NSOpenGL: The targeted version of Mac OS X only "
+                          "supports OpenGL 3.2 contexts if they are "
                           "forward-compatible");
             return GL_FALSE;
         }
@@ -761,8 +754,8 @@ static GLboolean createContext(_GLFWwindow* window,
         if (wndconfig->glProfile != GLFW_OPENGL_CORE_PROFILE)
         {
             _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                          "Cocoa/NSOpenGL: The targeted version of Mac OS X "
-                          "only supports OpenGL 3.2 contexts if they use the "
+                          "NSOpenGL: The targeted version of Mac OS X only "
+                          "supports OpenGL 3.2 contexts if they use the "
                           "core profile");
             return GL_FALSE;
         }
@@ -772,8 +765,8 @@ static GLboolean createContext(_GLFWwindow* window,
     if (wndconfig->glMajor > 2)
     {
         _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                      "Cocoa/NSOpenGL: The targeted version of Mac OS X does "
-                      "not support OpenGL version 3.0 or above");
+                      "NSOpenGL: The targeted version of Mac OS X does not "
+                      "support OpenGL version 3.0 or above");
         return GL_FALSE;
     }
 #endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
@@ -782,8 +775,8 @@ static GLboolean createContext(_GLFWwindow* window,
     if (wndconfig->glRobustness)
     {
         _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                      "Cocoa/NSOpenGL: Mac OS X does not support OpenGL "
-                      "robustness strategies");
+                      "NSOpenGL: Mac OS X does not support OpenGL robustness "
+                      "strategies");
         return GL_FALSE;
     }
 
@@ -846,7 +839,7 @@ static GLboolean createContext(_GLFWwindow* window,
     if (window->NSGL.pixelFormat == nil)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Cocoa/NSOpenGL: Failed to create OpenGL pixel format");
+                      "NSOpenGL: Failed to create OpenGL pixel format");
         return GL_FALSE;
     }
 
@@ -861,7 +854,7 @@ static GLboolean createContext(_GLFWwindow* window,
     if (window->NSGL.context == nil)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Cocoa/NSOpenGL: Failed to create OpenGL context");
+                      "NSOpenGL: Failed to create OpenGL context");
         return GL_FALSE;
     }
 
@@ -885,16 +878,15 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
     if (!initializeAppKit())
         return GL_FALSE;
 
-    // We can only have one application delegate, but we only allocate it the
-    // first time we create a window to keep all window code in this file
+    // There can only be one application delegate, but we allocate it the
+    // first time a window is created to keep all window code in this file
     if (_glfwLibrary.NS.delegate == nil)
     {
         _glfwLibrary.NS.delegate = [[GLFWApplicationDelegate alloc] init];
         if (_glfwLibrary.NS.delegate == nil)
         {
             _glfwSetError(GLFW_PLATFORM_ERROR,
-                          "Cocoa/NSOpenGL: Failed to create application "
-                          "delegate");
+                          "Cocoa: Failed to create application delegate");
             return GL_FALSE;
         }
 
@@ -905,7 +897,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
     if (window->NS.delegate == nil)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Cocoa/NSOpenGL: Failed to create window delegate");
+                      "Cocoa: Failed to create window delegate");
         return GL_FALSE;
     }
 

src/error.c

@@ -1,149 +0,0 @@
-//========================================================================
-// GLFW - An OpenGL library
-// Platform:    All
-// API version: 3.0
-// WWW:         http://www.glfw.org/
-//------------------------------------------------------------------------
-// Copyright (c) 2008-2010 Camilla Berglund <[email protected]>
-//
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not
-//    claim that you wrote the original software. If you use this software
-//    in a product, an acknowledgment in the product documentation would
-//    be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such, and must not
-//    be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source
-//    distribution.
-//
-//========================================================================
-
-#include "internal.h"
-
-#include <stdio.h>
-#include <stdarg.h>
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW internal API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-//========================================================================
-// The current error value and callback
-// These are not in _glfwLibrary since they need to be initialized and
-// accessible before glfwInit so it can report errors
-//========================================================================
-
-static int _glfwError = GLFW_NO_ERROR;
-static GLFWerrorfun _glfwErrorCallback = NULL;
-
-
-//========================================================================
-// Sets the current error value
-// This function may be called without GLFW having been initialized
-//========================================================================
-
-void _glfwSetError(int error, const char* format, ...)
-{
-    if (_glfwErrorCallback)
-    {
-        char buffer[16384];
-        const char* description;
-
-        if (format)
-        {
-            int count;
-            va_list vl;
-
-            va_start(vl, format);
-            count = vsnprintf(buffer, sizeof(buffer), format, vl);
-            va_end(vl);
-
-            if (count < 0)
-                buffer[sizeof(buffer) - 1] = '\0';
-
-            description = buffer;
-        }
-        else
-            description = glfwErrorString(error);
-
-        _glfwErrorCallback(error, description);
-    }
-    else
-        _glfwError = error;
-}
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                        GLFW public API                       //////
-//////////////////////////////////////////////////////////////////////////
-
-//========================================================================
-// Returns the current error value
-// This function may be called without GLFW having been initialized
-//========================================================================
-
-GLFWAPI int glfwGetError(void)
-{
-    int error = _glfwError;
-    _glfwError = GLFW_NO_ERROR;
-    return error;
-}
-
-
-//========================================================================
-// Returns a string representation of the specified error value
-// This function may be called without GLFW having been initialized
-//========================================================================
-
-GLFWAPI const char* glfwErrorString(int error)
-{
-    switch (error)
-    {
-        case GLFW_NO_ERROR:
-            return "No error";
-        case GLFW_NOT_INITIALIZED:
-            return "The GLFW library is not initialized";
-        case GLFW_NO_CURRENT_CONTEXT:
-            return "There is no current OpenGL context";
-        case GLFW_INVALID_ENUM:
-            return "Invalid argument for enum parameter";
-        case GLFW_INVALID_VALUE:
-            return "Invalid value for parameter";
-        case GLFW_OUT_OF_MEMORY:
-            return "Out of memory";
-        case GLFW_OPENGL_UNAVAILABLE:
-            return "OpenGL is not available on this machine";
-        case GLFW_VERSION_UNAVAILABLE:
-            return "The requested OpenGL version is unavailable";
-        case GLFW_PLATFORM_ERROR:
-            return "A platform-specific error occurred";
-        case GLFW_WINDOW_NOT_ACTIVE:
-            return "The specified window is not active";
-        case GLFW_FORMAT_UNAVAILABLE:
-            return "The requested format is unavailable";
-    }
-
-    return "ERROR: UNKNOWN ERROR TOKEN PASSED TO glfwErrorString";
-}
-
-
-//========================================================================
-// Sets the callback function for GLFW errors
-// This function may be called without GLFW having been initialized
-//========================================================================
-
-GLFWAPI void glfwSetErrorCallback(GLFWerrorfun cbfun)
-{
-    _glfwErrorCallback = cbfun;
-}
-

src/fullscreen.c

@@ -92,7 +92,7 @@ void _glfwSplitBPP(int bpp, int* red, int* green, int* blue)
 {
     int delta;
 
-    // We assume that by 32 they really meant 24
+    // We assume that by 32 the user really meant 24
     if (bpp == 32)
         bpp = 24;
 

src/init.c

@@ -28,11 +28,82 @@
 //
 //========================================================================
 
-#define _init_c_
 #include "internal.h"
 
 #include <string.h>
 #include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+
+//------------------------------------------------------------------------
+// Flag indicating whether GLFW has been successfully initialized
+//------------------------------------------------------------------------
+GLboolean _glfwInitialized = GL_FALSE;
+
+
+//------------------------------------------------------------------------
+// All shared and API-specific global data protected by _glfwInitialized
+// This should only be touched after a call to glfwInit that has not been
+// followed by a call to glfwTerminate
+//------------------------------------------------------------------------
+_GLFWlibrary _glfwLibrary;
+
+
+//------------------------------------------------------------------------
+// The current GLFW error code
+// This is outside of _glfwLibrary so it can be initialized and usable
+// before glfwInit is called, which lets that function report errors
+// TODO: Make this thread-local
+//------------------------------------------------------------------------
+static int _glfwError = GLFW_NO_ERROR;
+
+
+//------------------------------------------------------------------------
+// The current error callback
+// This is outside of _glfwLibrary so it can be initialized and usable
+// before glfwInit is called, which lets that function report errors
+//------------------------------------------------------------------------
+static GLFWerrorfun _glfwErrorCallback = NULL;
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+//========================================================================
+// Sets the current error value
+//========================================================================
+
+void _glfwSetError(int error, const char* format, ...)
+{
+    if (_glfwErrorCallback)
+    {
+        char buffer[16384];
+        const char* description;
+
+        if (format)
+        {
+            int count;
+            va_list vl;
+
+            va_start(vl, format);
+            count = vsnprintf(buffer, sizeof(buffer), format, vl);
+            va_end(vl);
+
+            if (count < 0)
+                buffer[sizeof(buffer) - 1] = '\0';
+
+            description = buffer;
+        }
+        else
+            description = glfwErrorString(error);
+
+        _glfwErrorCallback(error, description);
+    }
+    else
+        _glfwError = error;
+}
 
 
 //////////////////////////////////////////////////////////////////////////
@@ -50,8 +121,7 @@ GLFWAPI int glfwInit(void)
 
     memset(&_glfwLibrary, 0, sizeof(_glfwLibrary));
 
-    // Not all window hints have zero as their default value, so this
-    // needs to be here despite the memset above
+    // Not all window hints have zero as their default value
     _glfwSetDefaultWindowHints();
 
     if (!_glfwPlatformInit())
@@ -93,6 +163,7 @@ GLFWAPI void glfwTerminate(void)
 
 //========================================================================
 // Get GLFW version
+// This function may be called without GLFW having been initialized
 //========================================================================
 
 GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev)
@@ -110,6 +181,7 @@ GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev)
 
 //========================================================================
 // Get the GLFW version string
+// This function may be called without GLFW having been initialized
 //========================================================================
 
 GLFWAPI const char* glfwGetVersionString(void)
@@ -117,3 +189,64 @@ GLFWAPI const char* glfwGetVersionString(void)
     return _glfwPlatformGetVersionString();
 }
 
+
+//========================================================================
+// Returns the current error value
+// This function may be called without GLFW having been initialized
+//========================================================================
+
+GLFWAPI int glfwGetError(void)
+{
+    int error = _glfwError;
+    _glfwError = GLFW_NO_ERROR;
+    return error;
+}
+
+
+//========================================================================
+// Returns a string representation of the specified error value
+// This function may be called without GLFW having been initialized
+//========================================================================
+
+GLFWAPI const char* glfwErrorString(int error)
+{
+    switch (error)
+    {
+        case GLFW_NO_ERROR:
+            return "No error";
+        case GLFW_NOT_INITIALIZED:
+            return "The GLFW library is not initialized";
+        case GLFW_NO_CURRENT_CONTEXT:
+            return "There is no current OpenGL context";
+        case GLFW_INVALID_ENUM:
+            return "Invalid argument for enum parameter";
+        case GLFW_INVALID_VALUE:
+            return "Invalid value for parameter";
+        case GLFW_OUT_OF_MEMORY:
+            return "Out of memory";
+        case GLFW_OPENGL_UNAVAILABLE:
+            return "OpenGL is not available on this machine";
+        case GLFW_VERSION_UNAVAILABLE:
+            return "The requested OpenGL version is unavailable";
+        case GLFW_PLATFORM_ERROR:
+            return "A platform-specific error occurred";
+        case GLFW_WINDOW_NOT_ACTIVE:
+            return "The specified window is not active";
+        case GLFW_FORMAT_UNAVAILABLE:
+            return "The requested format is unavailable";
+    }
+
+    return "ERROR: UNKNOWN ERROR TOKEN PASSED TO glfwErrorString";
+}
+
+
+//========================================================================
+// Sets the callback function for GLFW errors
+// This function may be called without GLFW having been initialized
+//========================================================================
+
+GLFWAPI void glfwSetErrorCallback(GLFWerrorfun cbfun)
+{
+    _glfwErrorCallback = cbfun;
+}
+

src/internal.h

@@ -31,17 +31,6 @@
 #ifndef _internal_h_
 #define _internal_h_
 
-//========================================================================
-// GLFWGLOBAL is a macro that places all global variables in the init.c
-// module (all other modules reference global variables as 'extern')
-//========================================================================
-
-#if defined(_init_c_)
- #define GLFWGLOBAL
-#else
- #define GLFWGLOBAL extern
-#endif
-
 
 //========================================================================
 // Input handling definitions
@@ -247,53 +236,50 @@ struct _GLFWlibrary
 };
 
 
-//========================================================================
-// System independent global variables (GLFW internals)
-//========================================================================
-
-// Flag indicating if GLFW has been initialized
-#if defined(_init_c_)
-GLboolean _glfwInitialized = GL_FALSE;
-#else
-GLFWGLOBAL GLboolean _glfwInitialized;
-#endif
-
-GLFWGLOBAL _GLFWlibrary _glfwLibrary;
+//------------------------------------------------------------------------
+// Global state shared between compilation units of GLFW
+// These are exported from and documented in init.c
+//------------------------------------------------------------------------
+extern GLboolean _glfwInitialized;
+extern _GLFWlibrary _glfwLibrary;
 
 
 //========================================================================
-// Prototypes for platform specific implementation functions
+// Prototypes for the platform API
+// This is the interface exposed by the platform-specific code for each
+// platform and is called by the shared code of the public API
+// It mirrors the public API except it uses objects instead of handles
 //========================================================================
 
-// Init/terminate
+// Platform init and version
 int _glfwPlatformInit(void);
 int _glfwPlatformTerminate(void);
 const char* _glfwPlatformGetVersionString(void);
 
-// Input
+// Input mode support
 void _glfwPlatformEnableSystemKeys(_GLFWwindow* window);
 void _glfwPlatformDisableSystemKeys(_GLFWwindow* window);
 void _glfwPlatformSetCursorPos(_GLFWwindow* window, int x, int y);
 void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode);
 
-// Fullscreen
+// Video mode support
 GLFWvidmode* _glfwPlatformGetVideoModes(int* count);
 void _glfwPlatformGetDesktopMode(GLFWvidmode* mode);
 
-// Gamma ramp
+// Gamma ramp support
 void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp);
 void _glfwPlatformSetGammaRamp(const GLFWgammaramp* ramp);
 
-// Clipboard
+// Clipboard support
 void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string);
 const char* _glfwPlatformGetClipboardString(_GLFWwindow* window);
 
-// Joystick
+// Joystick input
 int _glfwPlatformGetJoystickParam(int joy, int param);
 int _glfwPlatformGetJoystickPos(int joy, float* pos, int numaxes);
 int _glfwPlatformGetJoystickButtons(int joy, unsigned char* buttons, int numbuttons);
 
-// Time
+// Time input
 double _glfwPlatformGetTime(void);
 void _glfwPlatformSetTime(double time);
 
@@ -308,7 +294,7 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window);
 void _glfwPlatformShowWindow(_GLFWwindow* window);
 void _glfwPlatformHideWindow(_GLFWwindow* window);
 
-// Event management
+// Event processing
 void _glfwPlatformPollEvents(void);
 void _glfwPlatformWaitEvents(void);
 
@@ -323,19 +309,12 @@ void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long
 
 
 //========================================================================
-// Prototypes for platform independent internal functions
+// Prototypes for the event API
+// This is used by the platform-specific code to notify the shared code of
+// events that can be translated into state changes and/or callback calls,
+// instead of directly calling callbacks or modifying shared state
 //========================================================================
 
-// Fullscren management (fullscreen.c)
-int _glfwCompareVideoModes(const GLFWvidmode* first, const GLFWvidmode* second);
-void _glfwSplitBPP(int bpp, int* red, int* green, int* blue);
-
-// Error handling (error.c)
-void _glfwSetError(int error, const char* format, ...);
-
-// Window management (window.c)
-void _glfwSetDefaultWindowHints(void);
-
 // Window event notification (window.c)
 void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated);
 void _glfwInputWindowPos(_GLFWwindow* window, int x, int y);
@@ -353,6 +332,24 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action);
 void _glfwInputCursorMotion(_GLFWwindow* window, int x, int y);
 void _glfwInputCursorEnter(_GLFWwindow* window, int entered);
 
+
+//========================================================================
+// Prototypes for internal utility functions
+// These functions are shared code and may be used by any part of GLFW
+// Each platform may add its own utility functions, but those may only be
+// called by the platform-specific code
+//========================================================================
+
+// Fullscren management (fullscreen.c)
+int _glfwCompareVideoModes(const GLFWvidmode* first, const GLFWvidmode* second);
+void _glfwSplitBPP(int bpp, int* red, int* green, int* blue);
+
+// Error handling (init.c)
+void _glfwSetError(int error, const char* format, ...);
+
+// Window management (window.c)
+void _glfwSetDefaultWindowHints(void);
+
 // OpenGL context helpers (opengl.c)
 int _glfwStringInExtensionString(const char* string, const GLubyte* extensions);
 const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,

src/joystick.c

@@ -47,6 +47,12 @@ GLFWAPI int glfwGetJoystickParam(int joy, int param)
         return 0;
     }
 
+    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    {
+        _glfwSetError(GLFW_INVALID_ENUM, NULL);
+        return 0;
+    }
+
     return _glfwPlatformGetJoystickParam(joy, param);
 }
 
@@ -65,6 +71,18 @@ GLFWAPI int glfwGetJoystickPos(int joy, float* pos, int numaxes)
         return 0;
     }
 
+    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    {
+        _glfwSetError(GLFW_INVALID_ENUM, NULL);
+        return 0;
+    }
+
+    if (pos == NULL || numaxes < 0)
+    {
+        _glfwSetError(GLFW_INVALID_VALUE, NULL);
+        return 0;
+    }
+
     // Clear positions
     for (i = 0;  i < numaxes;  i++)
         pos[i] = 0.0f;
@@ -89,6 +107,18 @@ GLFWAPI int glfwGetJoystickButtons(int joy,
         return 0;
     }
 
+    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    {
+        _glfwSetError(GLFW_INVALID_ENUM, NULL);
+        return 0;
+    }
+
+    if (buttons == NULL || numbuttons < 0)
+    {
+        _glfwSetError(GLFW_INVALID_VALUE, NULL);
+        return 0;
+    }
+
     // Clear button states
     for (i = 0;  i < numbuttons;  i++)
         buttons[i] = GLFW_RELEASE;

src/opengl.c

@@ -509,7 +509,7 @@ GLFWAPI GLFWwindow glfwGetCurrentContext(void)
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
-        return GL_FALSE;
+        return NULL;
     }
 
     return _glfwLibrary.currentWindow;

src/win32_clipboard.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Win32/WGL
+// Platform:    Win32
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -53,7 +53,7 @@ void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
     if (!wideString)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                        "Win32/WGL: Failed to convert clipboard string to "
+                        "Win32: Failed to convert clipboard string to "
                         "wide string");
         return;
     }
@@ -66,7 +66,7 @@ void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
         free(wideString);
 
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Win32/WGL: Failed to allocate global handle for clipboard");
+                      "Win32: Failed to allocate global handle for clipboard");
         return;
     }
 
@@ -79,7 +79,7 @@ void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
         free(wideString);
 
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Win32/WGL: Failed to open clipboard");
+                      "Win32: Failed to open clipboard");
         return;
     }
 
@@ -108,7 +108,7 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
     if (!OpenClipboard(window->Win32.handle))
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Win32/WGL: Failed to open clipboard");
+                      "Win32: Failed to open clipboard");
         return NULL;
     }
 
@@ -118,7 +118,7 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
         CloseClipboard();
 
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Win32/WGL: Failed to retrieve clipboard data");
+                      "Win32: Failed to retrieve clipboard data");
         return NULL;
     }
 
@@ -132,7 +132,7 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
     if (!_glfwLibrary.Win32.clipboardString)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Win32/WGL: Failed to convert wide string to UTF-8");
+                      "Win32: Failed to convert wide string to UTF-8");
         return NULL;
     }
 

src/win32_dllmain.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Win32/WGL
+// Platform:    Win32
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------

src/win32_fullscreen.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Win32/WGL
+// Platform:    Win32
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------

src/win32_gamma.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Win32/WGL
+// Platform:    Win32
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------

src/win32_input.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Win32/WGL
+// Platform:    Win32
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------

src/win32_joystick.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Win32/WGL
+// Platform:    Win32
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------

src/win32_opengl.c

@@ -171,15 +171,14 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
 
     if (!available)
     {
-        _glfwSetError(GLFW_OPENGL_UNAVAILABLE, "Win32/WGL: No pixel formats found");
+        _glfwSetError(GLFW_OPENGL_UNAVAILABLE, "WGL: No pixel formats found");
         return NULL;
     }
 
     fbconfigs = (_GLFWfbconfig*) malloc(sizeof(_GLFWfbconfig) * available);
     if (!fbconfigs)
     {
-        _glfwSetError(GLFW_OUT_OF_MEMORY,
-                      "Win32/WGL: Failed to allocate _GLFWfbconfig array");
+        _glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
         return NULL;
     }
 
@@ -285,6 +284,9 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
 
     if (*found == 0)
     {
+        _glfwSetError(GLFW_PLATFORM_ERROR,
+                      "Win32/WGL: No usable pixel formats found");
+
         free(fbconfigs);
         return NULL;
     }
@@ -310,15 +312,15 @@ static GLboolean createContext(_GLFWwindow* window,
 
     if (!DescribePixelFormat(window->WGL.DC, pixelFormat, sizeof(pfd), &pfd))
     {
-        _glfwSetError(GLFW_OPENGL_UNAVAILABLE,
-                      "Win32/WGL: Failed to retrieve PFD for selected pixel format");
+        _glfwSetError(GLFW_PLATFORM_ERROR,
+                      "Win32: Failed to retrieve PFD for selected pixel format");
         return GL_FALSE;
     }
 
     if (!SetPixelFormat(window->WGL.DC, pixelFormat, &pfd))
     {
-        _glfwSetError(GLFW_OPENGL_UNAVAILABLE,
-                      "Win32/WGL: Failed to set selected pixel format");
+        _glfwSetError(GLFW_PLATFORM_ERROR,
+                      "Win32: Failed to set selected pixel format");
         return GL_FALSE;
     }
 
@@ -360,7 +362,7 @@ static GLboolean createContext(_GLFWwindow* window,
             if (!window->WGL.ARB_create_context_profile)
             {
                 _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                              "Win32/WGL: OpenGL profile requested but "
+                              "WGL: OpenGL profile requested but "
                               "WGL_ARB_create_context_profile is unavailable");
                 return GL_FALSE;
             }
@@ -369,7 +371,7 @@ static GLboolean createContext(_GLFWwindow* window,
                 !window->WGL.EXT_create_context_es2_profile)
             {
                 _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                              "Win32/WGL: OpenGL ES 2.x profile requested but "
+                              "WGL: OpenGL ES 2.x profile requested but "
                               "WGL_EXT_create_context_es2_profile is unavailable");
                 return GL_FALSE;
             }
@@ -392,7 +394,7 @@ static GLboolean createContext(_GLFWwindow* window,
             if (!window->WGL.ARB_create_context_robustness)
             {
                 _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                              "Win32/WGL: An OpenGL robustness strategy was "
+                              "WGL: An OpenGL robustness strategy was "
                               "requested but WGL_ARB_create_context_robustness "
                               "is unavailable");
                 return GL_FALSE;
@@ -415,7 +417,7 @@ static GLboolean createContext(_GLFWwindow* window,
         if (!window->WGL.context)
         {
             _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                          "Win32/WGL: Failed to create OpenGL context");
+                          "WGL: Failed to create OpenGL context");
             return GL_FALSE;
         }
     }
@@ -425,7 +427,7 @@ static GLboolean createContext(_GLFWwindow* window,
         if (!window->WGL.context)
         {
             _glfwSetError(GLFW_PLATFORM_ERROR,
-                          "Win32/WGL: Failed to create OpenGL context");
+                          "WGL: Failed to create OpenGL context");
             return GL_FALSE;
         }
 
@@ -434,8 +436,8 @@ static GLboolean createContext(_GLFWwindow* window,
             if (!wglShareLists(share, window->WGL.context))
             {
                 _glfwSetError(GLFW_PLATFORM_ERROR,
-                              "Win32/WGL: Failed to enable sharing with "
-                              "specified OpenGL context");
+                              "WGL: Failed to enable sharing with specified "
+                              "OpenGL context");
                 return GL_FALSE;
             }
         }
@@ -466,7 +468,7 @@ int _glfwCreateContext(_GLFWwindow* window,
     if (!window->WGL.DC)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Win32/WGL: Failed to retrieve DC for window");
+                      "Win32: Failed to retrieve DC for window");
         return GL_FALSE;
     }
 
@@ -478,16 +480,12 @@ int _glfwCreateContext(_GLFWwindow* window,
 
         fbconfigs = getFBConfigs(window, &fbcount);
         if (!fbconfigs)
-        {
-            _glfwSetError(GLFW_PLATFORM_ERROR,
-                          "Win32/WGL: No usable pixel formats found");
             return GL_FALSE;
-        }
 
         result = _glfwChooseFBConfig(fbconfig, fbconfigs, fbcount);
         if (!result)
         {
-            _glfwSetError(GLFW_PLATFORM_ERROR,
+            _glfwSetError(GLFW_FORMAT_UNAVAILABLE,
                           "Win32/WGL: No pixel format matched the criteria");
 
             free(fbconfigs);
@@ -620,7 +618,7 @@ void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long
     if (!wglCopyContext(src->WGL.context, dst->WGL.context, mask))
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Win32/WGL: Failed to copy OpenGL context attributes");
+                      "WGL: Failed to copy OpenGL context attributes");
     }
 }
 

src/win32_time.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Win32/WGL
+// Platform:    Win32
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------

src/win32_window.c

@@ -730,7 +730,7 @@ static ATOM registerWindowClass(void)
     if (!classAtom)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "Win32/WGL: Failed to register window class");
+                      "Win32: Failed to register window class");
         return 0;
     }
 
@@ -803,7 +803,7 @@ static int createWindow(_GLFWwindow* window,
     if (!wideTitle)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "glfwCreateWindow: Failed to convert title to wide string");
+                      "Win32: Failed to convert title to wide string");
         return GL_FALSE;
     }
 
@@ -821,7 +821,7 @@ static int createWindow(_GLFWwindow* window,
 
     if (!window->Win32.handle)
     {
-        _glfwSetError(GLFW_PLATFORM_ERROR, "Win32/WGL: Failed to create window");
+        _glfwSetError(GLFW_PLATFORM_ERROR, "Win32: Failed to create window");
         return GL_FALSE;
     }
 
@@ -925,8 +925,8 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
         if (!window->WGL.ARB_create_context)
         {
             _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                          "Win32/WGL: A forward compatible OpenGL context "
-                          "requested but WGL_ARB_create_context is unavailable");
+                          "WGL: A forward compatible OpenGL context requested "
+                          "but WGL_ARB_create_context is unavailable");
             return GL_FALSE;
         }
 
@@ -938,7 +938,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
         if (!window->WGL.ARB_create_context_profile)
         {
             _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                          "Win32/WGL: OpenGL profile requested but "
+                          "WGL: OpenGL profile requested but "
                           "WGL_ARB_create_context_profile is unavailable");
             return GL_FALSE;
         }
@@ -1021,7 +1021,7 @@ void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
     if (!wideTitle)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "glfwSetWindowTitle: Failed to convert title to wide string");
+                      "Win32: Failed to convert title to wide string");
         return;
     }
 

src/window.c

@@ -279,7 +279,7 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
     if (mode != GLFW_WINDOWED && mode != GLFW_FULLSCREEN)
     {
         _glfwSetError(GLFW_INVALID_ENUM,
-                      "glfwCreateWindow: Invalid enum for 'mode' parameter");
+                      "glfwCreateWindow: Invalid window mode");
         return GL_FALSE;
     }
 
@@ -304,8 +304,7 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
     window = (_GLFWwindow*) malloc(sizeof(_GLFWwindow));
     if (!window)
     {
-        _glfwSetError(GLFW_OUT_OF_MEMORY,
-                      "glfwCreateWindow: Failed to allocate window structure");
+        _glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
         return NULL;
     }
 

src/x11_clipboard.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    X11/GLX
+// Platform:    X11
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -182,7 +182,7 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
     if (_glfwLibrary.X11.selection.status == _GLFW_CONVERSION_FAILED)
     {
         _glfwSetError(GLFW_FORMAT_UNAVAILABLE,
-                      "X11/GLX: Failed to convert selection to string");
+                      "X11: Failed to convert selection to string");
         return NULL;
     }
 

src/x11_fullscreen.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    X11/GLX
+// Platform:    X11
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -442,7 +442,7 @@ GLFWvidmode* _glfwPlatformGetVideoModes(int* found)
     if (visuals == NULL)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "X11/GLX: Failed to retrieve the available visuals");
+                      "X11: Failed to retrieve the available visuals");
         return 0;
     }
 

src/x11_gamma.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    X11/GLX
+// Platform:    X11
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -115,7 +115,7 @@ void _glfwPlatformGetGammaRamp(GLFWgammaramp* ramp)
     if (_glfwLibrary.originalRampSize != GLFW_GAMMA_RAMP_SIZE)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "X11/GLX: Failed to get gamma ramp due to size "
+                      "X11: Failed to get gamma ramp due to size "
                       "incompatibility");
         return;
     }
@@ -166,7 +166,7 @@ void _glfwPlatformSetGammaRamp(const GLFWgammaramp* ramp)
     if (_glfwLibrary.originalRampSize != GLFW_GAMMA_RAMP_SIZE)
     {
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "X11/GLX: Failed to set gamma ramp due to size "
+                      "X11: Failed to set gamma ramp due to size "
                       "incompatibility");
         return;
     }

src/x11_init.c

@@ -491,7 +491,7 @@ static GLboolean initDisplay(void)
     _glfwLibrary.X11.display = XOpenDisplay(NULL);
     if (!_glfwLibrary.X11.display)
     {
-        _glfwSetError(GLFW_OPENGL_UNAVAILABLE, "X11/GLX: Failed to open X display");
+        _glfwSetError(GLFW_OPENGL_UNAVAILABLE, "X11: Failed to open X display");
         return GL_FALSE;
     }
 
@@ -525,7 +525,7 @@ static GLboolean initDisplay(void)
                              &_glfwLibrary.X11.RandR.minorVersion))
         {
             _glfwSetError(GLFW_PLATFORM_ERROR,
-                          "X11/GLX: Failed to query RandR version");
+                          "X11: Failed to query RandR version");
             return GL_FALSE;
         }
     }

src/x11_input.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    X11 (Unix)
+// Platform:    X11
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------

src/x11_joystick.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    X11/GLX
+// Platform:    X11
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@@ -30,148 +30,121 @@
 
 #include "internal.h"
 
+#ifdef _GLFW_USE_LINUX_JOYSTICKS
+#include <linux/joystick.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#endif // _GLFW_USE_LINUX_JOYSTICKS
+
 
 //========================================================================
-// Note: Only Linux joystick input is supported at the moment. Other
-// systems will behave as if there are no joysticks connected.
+// Attempt to open the specified joystick device
 //========================================================================
 
-
+static int openJoystickDevice(int joy, const char* path)
+{
 #ifdef _GLFW_USE_LINUX_JOYSTICKS
+    char numAxes, numButtons;
+    int fd, version;
 
-//------------------------------------------------------------------------
-// Here are the Linux joystick driver v1.x interface definitions that we
-// use (we do not want to rely on <linux/joystick.h>):
-//------------------------------------------------------------------------
+    fd = open(path, O_NONBLOCK);
+    if (fd == -1)
+        return GL_FALSE;
 
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
+    _glfwLibrary.X11.joystick[joy].fd = fd;
 
-// Joystick event types
-#define JS_EVENT_BUTTON     0x01    /* button pressed/released */
-#define JS_EVENT_AXIS       0x02    /* joystick moved */
-#define JS_EVENT_INIT       0x80    /* initial state of device */
+    // Verify that the joystick driver version is at least 1.0
+    ioctl(fd, JSIOCGVERSION, &version);
+    if (version < 0x010000)
+    {
+        // It's an old 0.x interface (we don't support it)
+        close(fd);
+        return GL_FALSE;
+    }
 
-// Joystick event structure
-struct js_event {
-    unsigned int  time;    /* (u32) event timestamp in milliseconds */
-    signed short  value;   /* (s16) value */
-    unsigned char type;    /* (u8)  event type */
-    unsigned char number;  /* (u8)  axis/button number */
-};
+    ioctl(fd, JSIOCGAXES, &numAxes);
+    _glfwLibrary.X11.joystick[joy].numAxes = (int) numAxes;
 
-// Joystick IOCTL commands
-#define JSIOCGVERSION  _IOR('j', 0x01, int)   /* get driver version (u32) */
-#define JSIOCGAXES     _IOR('j', 0x11, char)  /* get number of axes (u8) */
-#define JSIOCGBUTTONS  _IOR('j', 0x12, char)  /* get number of buttons (u8) */
+    ioctl(fd, JSIOCGBUTTONS, &numButtons);
+    _glfwLibrary.X11.joystick[joy].numButtons = (int) numButtons;
+
+    _glfwLibrary.X11.joystick[joy].axis =
+        (float*) malloc(sizeof(float) * numAxes);
+    if (_glfwLibrary.X11.joystick[joy].axis == NULL)
+    {
+        close(fd);
 
+        _glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
+        return GL_FALSE;
+    }
+
+    _glfwLibrary.X11.joystick[joy].button =
+        (unsigned char*) malloc(sizeof(char) * numButtons);
+    if (_glfwLibrary.X11.joystick[joy].button == NULL)
+    {
+        free(_glfwLibrary.X11.joystick[joy].axis);
+        close(fd);
+
+        _glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
+        return GL_FALSE;
+    }
+
+    _glfwLibrary.X11.joystick[joy].present = GL_TRUE;
 #endif // _GLFW_USE_LINUX_JOYSTICKS
 
+    return GL_TRUE;
+}
 
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW internal API                      //////
-//////////////////////////////////////////////////////////////////////////
 
 //========================================================================
-// Initialize joystick interface
+// Polls for and processes events for all present joysticks
 //========================================================================
 
-void _glfwInitJoysticks(void)
+static void pollJoystickEvents(void)
 {
 #ifdef _GLFW_USE_LINUX_JOYSTICKS
-    int  k, n, fd, joy_count;
-    const char* joy_base_name;
-    char joy_dev_name[20];
-    int  driver_version = 0x000800;
-    char ret_data;
-#endif // _GLFW_USE_LINUX_JOYSTICKS
-    int  i;
+    int i;
+    struct js_event e;
 
-    // Start by saying that there are no sticks
     for (i = 0;  i <= GLFW_JOYSTICK_LAST;  i++)
-        _glfwJoy[i].Present = GL_FALSE;
-
-#ifdef _GLFW_USE_LINUX_JOYSTICKS
-
-    // Try to open joysticks (nonblocking)
-    joy_count = 0;
-    for (k = 0;  k <= 1 && joy_count <= GLFW_JOYSTICK_LAST;  k++)
     {
-        // Pick joystick base name
-        switch (k)
-        {
-            case 0:
-                // USB joysticks
-                joy_base_name = "/dev/input/js";
-                break;
-            case 1:
-                // "Legacy" joysticks
-                joy_base_name = "/dev/js";
-                break;
-            default:
-                // This should never happen
-                continue;
-        }
+        if (!_glfwLibrary.X11.joystick[i].present)
+            continue;
 
-        // Try to open a few of these sticks
-        for (i = 0;  i <= 50 && joy_count <= GLFW_JOYSTICK_LAST;  i++)
+        // Read all queued events (non-blocking)
+        while (read(_glfwLibrary.X11.joystick[i].fd, &e, sizeof(e)) > 0)
         {
-            sprintf(joy_dev_name, "%s%d", joy_base_name, i);
-            fd = open(joy_dev_name, O_NONBLOCK);
-            if (fd != -1)
+            // We don't care if it's an init event or not
+            e.type &= ~JS_EVENT_INIT;
+
+            switch (e.type)
             {
-                // Remember fd
-                _glfwJoy[joy_count].fd = fd;
-
-                // Check that the joystick driver version is 1.0+
-                ioctl(fd, JSIOCGVERSION, &driver_version);
-                if (driver_version < 0x010000)
-                {
-                    // It's an old 0.x interface (we don't support it)
-                    close(fd);
-                    continue;
-                }
-
-                // Get number of joystick axes
-                ioctl(fd, JSIOCGAXES, &ret_data);
-                _glfwJoy[joy_count].NumAxes = (int) ret_data;
-
-                // Get number of joystick buttons
-                ioctl(fd, JSIOCGBUTTONS, &ret_data);
-                _glfwJoy[joy_count].NumButtons = (int) ret_data;
-
-                // Allocate memory for joystick state
-                _glfwJoy[joy_count].Axis =
-                    (float*) malloc(sizeof(float) *
-                                     _glfwJoy[joy_count].NumAxes);
-                if (_glfwJoy[joy_count].Axis == NULL)
-                {
-                    close(fd);
-                    continue;
-                }
-                _glfwJoy[joy_count].Button =
-                    (unsigned char*) malloc(sizeof(char) *
-                                     _glfwJoy[joy_count].NumButtons);
-                if (_glfwJoy[joy_count].Button == NULL)
-                {
-                    free(_glfwJoy[joy_count].Axis);
-                    close(fd);
-                    continue;
-                }
-
-                // Clear joystick state
-                for (n = 0;  n < _glfwJoy[joy_count].NumAxes;  n++)
-                    _glfwJoy[joy_count].Axis[n] = 0.0f;
-
-                for (n = 0;  n < _glfwJoy[joy_count].NumButtons;  n++)
-                    _glfwJoy[joy_count].Button[n] = GLFW_RELEASE;
-
-                // The joystick is supported and connected
-                _glfwJoy[joy_count].Present = GL_TRUE;
-                joy_count++;
+                case JS_EVENT_AXIS:
+                    _glfwLibrary.X11.joystick[i].axis[e.number] =
+                        (float) e.value / 32767.0f;
+
+                    // We need to change the sign for the Y axes, so that
+                    // positive = up/forward, according to the GLFW spec.
+                    if (e.number & 1)
+                    {
+                        _glfwLibrary.X11.joystick[i].axis[e.number] =
+                            -_glfwLibrary.X11.joystick[i].axis[e.number];
+                    }
+
+                    break;
+
+                case JS_EVENT_BUTTON:
+                    _glfwLibrary.X11.joystick[i].button[e.number] =
+                        e.value ? GLFW_PRESS : GLFW_RELEASE;
+                    break;
+
+                default:
+                    break;
             }
         }
     }
@@ -179,78 +152,59 @@ void _glfwInitJoysticks(void)
 }
 
 
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
 //========================================================================
-// Close all opened joystick handles
+// Initialize joystick interface
 //========================================================================
 
-void _glfwTerminateJoysticks(void)
+void _glfwInitJoysticks(void)
 {
-
 #ifdef _GLFW_USE_LINUX_JOYSTICKS
+    int i, j, joy = 0;
+    char path[20];
+    const char* bases[] =
+    {
+        "/dev/input/js",
+        "/dev/js"
+    };
 
-    int i;
-
-    // Close any opened joysticks
-    for (i = 0;  i <= GLFW_JOYSTICK_LAST;  i++)
+    for (i = 0;  i < sizeof(bases) / sizeof(bases[0]);  i++)
     {
-        if (_glfwJoy[i].Present)
+        for (j = 0;  j < 50;  j++)
         {
-            close(_glfwJoy[i].fd);
-            free(_glfwJoy[i].Axis);
-            free(_glfwJoy[i].Button);
+            if (joy > GLFW_JOYSTICK_LAST)
+                break;
 
-            _glfwJoy[i].Present = GL_FALSE;
+            sprintf(path, "%s%i", bases[i], j);
+            if (openJoystickDevice(joy, path))
+                joy++;
         }
     }
-
 #endif // _GLFW_USE_LINUX_JOYSTICKS
-
 }
 
 
 //========================================================================
-// Empty joystick event queue
+// Close all opened joystick handles
 //========================================================================
 
-static void pollJoystickEvents(void)
+void _glfwTerminateJoysticks(void)
 {
 #ifdef _GLFW_USE_LINUX_JOYSTICKS
-
-    struct js_event e;
     int i;
 
-    // Get joystick events for all GLFW joysticks
     for (i = 0;  i <= GLFW_JOYSTICK_LAST;  i++)
     {
-        // Is the stick present?
-        if (_glfwJoy[i].Present)
+        if (_glfwLibrary.X11.joystick[i].present)
         {
-            // Read all queued events (non-blocking)
-            while (read(_glfwJoy[i].fd, &e, sizeof(struct js_event)) > 0)
-            {
-                // We don't care if it's an init event or not
-                e.type &= ~JS_EVENT_INIT;
-
-                // Check event type
-                switch (e.type)
-                {
-                    case JS_EVENT_AXIS:
-                        _glfwJoy[i].Axis[e.number] = (float) e.value / 32767.0f;
-                        // We need to change the sign for the Y axes, so that
-                        // positive = up/forward, according to the GLFW spec.
-                        if (e.number & 1)
-                            _glfwJoy[i].Axis[e.number] = -_glfwJoy[i].Axis[e.number];
-                        break;
-
-                    case JS_EVENT_BUTTON:
-                        _glfwJoy[i].Button[e.number] =
-                            e.value ? GLFW_PRESS : GLFW_RELEASE;
-                        break;
-
-                    default:
-                        break;
-                }
-            }
+            close(_glfwLibrary.X11.joystick[i].fd);
+            free(_glfwLibrary.X11.joystick[i].axis);
+            free(_glfwLibrary.X11.joystick[i].button);
+
+            _glfwLibrary.X11.joystick[i].present = GL_FALSE;
         }
     }
 #endif // _GLFW_USE_LINUX_JOYSTICKS
@@ -267,11 +221,8 @@ static void pollJoystickEvents(void)
 
 int _glfwPlatformGetJoystickParam(int joy, int param)
 {
-    if (!_glfwJoy[joy].Present)
-    {
-        // TODO: Figure out if this is an error
+    if (!_glfwLibrary.X11.joystick[joy].present)
         return 0;
-    }
 
     switch (param)
     {
@@ -279,13 +230,13 @@ int _glfwPlatformGetJoystickParam(int joy, int param)
             return GL_TRUE;
 
         case GLFW_AXES:
-            return _glfwJoy[joy].NumAxes;
+            return _glfwLibrary.X11.joystick[joy].numAxes;
 
         case GLFW_BUTTONS:
-            return _glfwJoy[joy].NumButtons;
+            return _glfwLibrary.X11.joystick[joy].numButtons;
 
         default:
-            break;
+            _glfwSetError(GLFW_INVALID_ENUM, NULL);
     }
 
     return 0;
@@ -296,28 +247,22 @@ int _glfwPlatformGetJoystickParam(int joy, int param)
 // Get joystick axis positions
 //========================================================================
 
-int _glfwPlatformGetJoystickPos(int joy, float* pos, int numaxes)
+int _glfwPlatformGetJoystickPos(int joy, float* pos, int numAxes)
 {
     int i;
 
-    if (!_glfwJoy[joy].Present)
-    {
-        // TODO: Figure out if this is an error
+    if (!_glfwLibrary.X11.joystick[joy].present)
         return 0;
-    }
 
-    // Update joystick state
     pollJoystickEvents();
 
-    // Does the joystick support less axes than requested?
-    if (_glfwJoy[joy].NumAxes < numaxes)
-        numaxes = _glfwJoy[joy].NumAxes;
+    if (_glfwLibrary.X11.joystick[joy].numAxes < numAxes)
+        numAxes = _glfwLibrary.X11.joystick[joy].numAxes;
 
-    // Copy axis positions from internal state
-    for (i = 0;  i < numaxes;  i++)
-        pos[i] = _glfwJoy[joy].Axis[i];
+    for (i = 0;  i < numAxes;  i++)
+        pos[i] = _glfwLibrary.X11.joystick[joy].axis[i];
 
-    return numaxes;
+    return numAxes;
 }
 
 
@@ -326,27 +271,21 @@ int _glfwPlatformGetJoystickPos(int joy, float* pos, int numaxes)
 //========================================================================
 
 int _glfwPlatformGetJoystickButtons(int joy, unsigned char* buttons,
-                                    int numbuttons)
+                                    int numButtons)
 {
     int i;
 
-    if (!_glfwJoy[joy].Present)
-    {
-        // TODO: Figure out if this is an error
+    if (!_glfwLibrary.X11.joystick[joy].present)
         return 0;
-    }
 
-    // Update joystick state
     pollJoystickEvents();
 
-    // Does the joystick support less buttons than requested?
-    if (_glfwJoy[joy].NumButtons < numbuttons)
-        numbuttons = _glfwJoy[joy].NumButtons;
+    if (_glfwLibrary.X11.joystick[joy].numButtons < numButtons)
+        numButtons = _glfwLibrary.X11.joystick[joy].numButtons;
 
-    // Copy button states from internal state
-    for (i = 0;  i < numbuttons;  i++)
-        buttons[i] = _glfwJoy[joy].Button[i];
+    for (i = 0;  i < numButtons;  i++)
+        buttons[i] = _glfwLibrary.X11.joystick[joy].button[i];
 
-    return numbuttons;
+    return numButtons;
 }
 

src/x11_keysym2unicode.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    X11/GLX
+// Platform:    X11
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------

src/x11_opengl.c

@@ -78,7 +78,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
         if (!_glfwLibrary.GLX.SGIX_fbconfig)
         {
             _glfwSetError(GLFW_OPENGL_UNAVAILABLE,
-                          "X11/GLX: GLXFBConfig support not found");
+                          "GLX: GLXFBConfig support not found");
             return NULL;
         }
     }
@@ -101,7 +101,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
         if (!count)
         {
             _glfwSetError(GLFW_OPENGL_UNAVAILABLE,
-                          "X11/GLX: No GLXFBConfigs returned");
+                          "GLX: No GLXFBConfigs returned");
             return NULL;
         }
     }
@@ -113,7 +113,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
         if (!count)
         {
             _glfwSetError(GLFW_OPENGL_UNAVAILABLE,
-                          "X11/GLX: No GLXFBConfigs returned");
+                          "GLX: No GLXFBConfigs returned");
             return NULL;
         }
     }
@@ -121,8 +121,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
     result = (_GLFWfbconfig*) malloc(sizeof(_GLFWfbconfig) * count);
     if (!result)
     {
-        _glfwSetError(GLFW_OUT_OF_MEMORY,
-                      "X11/GLX: Failed to allocate _GLFWfbconfig array");
+        _glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
         return NULL;
     }
 
@@ -242,7 +241,7 @@ static int createContext(_GLFWwindow* window,
         if (fbconfig == NULL)
         {
             _glfwSetError(GLFW_PLATFORM_ERROR,
-                          "X11/GLX: Failed to retrieve the selected GLXFBConfig");
+                          "GLX: Failed to retrieve the selected GLXFBConfig");
             return GL_FALSE;
         }
     }
@@ -264,7 +263,7 @@ static int createContext(_GLFWwindow* window,
         XFree(fbconfig);
 
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "X11/GLX: Failed to retrieve visual for GLXFBConfig");
+                      "GLX: Failed to retrieve visual for GLXFBConfig");
         return GL_FALSE;
     }
 
@@ -303,7 +302,7 @@ static int createContext(_GLFWwindow* window,
             if (!_glfwLibrary.GLX.ARB_create_context_profile)
             {
                 _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                              "X11/GLX: An OpenGL profile requested but "
+                              "GLX: An OpenGL profile requested but "
                               "GLX_ARB_create_context_profile is unavailable");
                 return GL_FALSE;
             }
@@ -312,7 +311,7 @@ static int createContext(_GLFWwindow* window,
                 !_glfwLibrary.GLX.EXT_create_context_es2_profile)
             {
                 _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                              "X11/GLX: OpenGL ES 2.x profile requested but "
+                              "GLX: OpenGL ES 2.x profile requested but "
                               "GLX_EXT_create_context_es2_profile is unavailable");
                 return GL_FALSE;
             }
@@ -334,7 +333,7 @@ static int createContext(_GLFWwindow* window,
             if (!_glfwLibrary.GLX.ARB_create_context_robustness)
             {
                 _glfwSetError(GLFW_VERSION_UNAVAILABLE,
-                              "X11/GLX: An OpenGL robustness strategy was "
+                              "GLX: An OpenGL robustness strategy was "
                               "requested but GLX_ARB_create_context_robustness "
                               "is unavailable");
                 return GL_FALSE;
@@ -397,7 +396,7 @@ static int createContext(_GLFWwindow* window,
         // TODO: Handle all the various error codes here
 
         _glfwSetError(GLFW_PLATFORM_ERROR,
-                      "X11/GLX: Failed to create OpenGL context");
+                      "GLX: Failed to create OpenGL context");
         return GL_FALSE;
     }
 
@@ -437,7 +436,7 @@ int _glfwInitOpenGL(void)
 
     if (!_glfwLibrary.GLX.libGL)
     {
-        _glfwSetError(GLFW_PLATFORM_ERROR, "X11/GLX: Failed to find libGL");
+        _glfwSetError(GLFW_PLATFORM_ERROR, "GLX: Failed to find libGL");
         return GL_FALSE;
     }
 #endif
@@ -445,7 +444,7 @@ int _glfwInitOpenGL(void)
     // Check if GLX is supported on this display
     if (!glXQueryExtension(_glfwLibrary.X11.display, NULL, NULL))
     {
-        _glfwSetError(GLFW_OPENGL_UNAVAILABLE, "X11/GLX: GLX support not found");
+        _glfwSetError(GLFW_OPENGL_UNAVAILABLE, "GLX: GLX support not found");
         return GL_FALSE;
     }
 
@@ -454,7 +453,7 @@ int _glfwInitOpenGL(void)
                          &_glfwLibrary.GLX.minorVersion))
     {
         _glfwSetError(GLFW_OPENGL_UNAVAILABLE,
-                      "X11/GLX: Failed to query GLX version");
+                      "GLX: Failed to query GLX version");
         return GL_FALSE;
     }
 
@@ -565,17 +564,13 @@ int _glfwCreateContext(_GLFWwindow* window,
 
         fbconfigs = getFBConfigs(window, &fbcount);
         if (!fbconfigs)
-        {
-            _glfwSetError(GLFW_PLATFORM_ERROR,
-                          "X11/GLX: No usable GLXFBConfigs found");
             return GL_FALSE;
-        }
 
         result = _glfwChooseFBConfig(fbconfig, fbconfigs, fbcount);
         if (!result)
         {
             _glfwSetError(GLFW_PLATFORM_ERROR,
-                          "X11/GLX: No GLXFBConfig matched the criteria");
+                          "GLX: No GLXFBConfig matched the criteria");
 
             free(fbconfigs);
             return GL_FALSE;

src/x11_platform.h

@@ -42,20 +42,21 @@
 #include <GL/glx.h>
 
 // This path may need to be changed if you build GLFW using your own setup
-// We ship and use our own copy of glxext.h since GLFW uses fairly new
+// GLFW comes with its own copy of glxext.h since it uses some fairly new
 // extensions and not all operating systems come with an up-to-date version
 #include "../support/GL/glxext.h"
 
-// With XFree86, we can use the XF86VidMode extension
+// The XF86VidMode extension provides mode setting and gamma control
 #if defined(_GLFW_HAS_XF86VIDMODE)
  #include <X11/extensions/xf86vmode.h>
 #endif
 
+// The XRandR extension provides mode setting and gamma control
 #if defined(_GLFW_HAS_XRANDR)
  #include <X11/extensions/Xrandr.h>
 #endif
 
-// Do we have support for dlopen/dlsym?
+// dlopen is used as a fallback function retrieval mechanism
 #if defined(_GLFW_HAS_DLOPEN)
  #include <dlfcn.h>
 #endif
@@ -65,7 +66,7 @@
  #include <X11/XKBlib.h>
 #endif
 
-// We support four different ways for getting addresses for GL/GLX
+// GLFW supports four different ways for getting addresses for GL/GLX
 // extension functions: glXGetProcAddress, glXGetProcAddressARB,
 // glXGetProcAddressEXT, and dlsym
 #if defined(_GLFW_HAS_GLXGETPROCADDRESSARB)
@@ -232,6 +233,15 @@ typedef struct _GLFWlibraryX11
         int status;
     } selection;
 
+    struct {
+        int             present;
+        int             fd;
+        int             numAxes;
+        int             numButtons;
+        float*          axis;
+        unsigned char*  button;
+    } joystick[GLFW_JOYSTICK_LAST + 1];
+
 } _GLFWlibraryX11;
 
 
@@ -268,19 +278,6 @@ typedef struct _GLFWlibraryGLX
 } _GLFWlibraryGLX;
 
 
-//------------------------------------------------------------------------
-// Joystick information & state
-//------------------------------------------------------------------------
-GLFWGLOBAL struct {
-    int           Present;
-    int           fd;
-    int           NumAxes;
-    int           NumButtons;
-    float*        Axis;
-    unsigned char* Button;
-} _glfwJoy[GLFW_JOYSTICK_LAST + 1];
-
-
 //========================================================================
 // Prototypes for platform specific internal functions
 //========================================================================

src/x11_time.c

@@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    X11/GLX
+// Platform:    X11
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------

src/x11_window.c

@@ -43,21 +43,18 @@
 #define Button6            6
 #define Button7            7
 
+
 //========================================================================
 // Translates an X Window key to internal coding
 //========================================================================
 
 static int translateKey(int keycode)
 {
-    // Use the pre-filled LUT (see updateKeyCodeLUT() ).
+    // Use the pre-filled LUT (see updateKeyCodeLUT() in x11_init.c)
     if ((keycode >= 0) && (keycode < 256))
-    {
         return _glfwLibrary.X11.keyCodeLUT[keycode];
-    }
     else
-    {
         return -1;
-    }
 }
 
 
@@ -90,6 +87,7 @@ static GLboolean createWindow(_GLFWwindow* window,
 
     // Every window needs a colormap
     // Create one based on the visual used by the current context
+    // TODO: Decouple this from context creation
 
     window->X11.colormap = XCreateColormap(_glfwLibrary.X11.display,
                                            _glfwLibrary.X11.root,
@@ -109,33 +107,31 @@ static GLboolean createWindow(_GLFWwindow* window,
 
         if (wndconfig->mode == GLFW_WINDOWED)
         {
-            // The /only/ reason we are setting the background pixel here is
-            // that otherwise our window wont get any decorations on systems
-            // using Compiz on Intel hardware
+            // The /only/ reason for setting the background pixel here is that
+            // otherwise our window won't get any decorations on systems using
+            // certain versions of Compiz on Intel hardware
             wa.background_pixel = BlackPixel(_glfwLibrary.X11.display,
                                              _glfwLibrary.X11.screen);
             wamask |= CWBackPixel;
         }
 
-        window->X11.handle = XCreateWindow(
-            _glfwLibrary.X11.display,
-            _glfwLibrary.X11.root,
-            0, 0,                            // Upper left corner of this window on root
-            window->width, window->height,
-            0,                               // Border width
-            visual->depth,                   // Color depth
-            InputOutput,
-            visual->visual,
-            wamask,
-            &wa
-        );
+        window->X11.handle = XCreateWindow(_glfwLibrary.X11.display,
+                                           _glfwLibrary.X11.root,
+                                           0, 0,           // Position
+                                           window->width, window->height,
+                                           0,              // Border width
+                                           visual->depth,  // Color depth
+                                           InputOutput,
+                                           visual->visual,
+                                           wamask,
+                                           &wa);
 
         if (!window->X11.handle)
         {
-            // TODO: Handle all the various error codes here
+            // TODO: Handle all the various error codes here and translate them
+            // to GLFW errors
 
-            _glfwSetError(GLFW_PLATFORM_ERROR,
-                          "X11/GLX: Failed to create window");
+            _glfwSetError(GLFW_PLATFORM_ERROR, "X11: Failed to create window");
             return GL_FALSE;
         }
     }
@@ -147,8 +143,8 @@ static GLboolean createWindow(_GLFWwindow* window,
         // manager ignore the window completely (ICCCM, section 4)
         // The good thing is that this makes undecorated fullscreen windows
         // easy to do; the bad thing is that we have to do everything manually
-        // and some things (like iconify/restore) won't work at all, as they're
-        // usually performed by the window manager
+        // and some things (like iconify/restore) won't work at all, as those
+        // are tasks usually performed by the window manager
 
         XSetWindowAttributes attributes;
         attributes.override_redirect = True;
@@ -165,7 +161,7 @@ static GLboolean createWindow(_GLFWwindow* window,
                                                   "WM_DELETE_WINDOW",
                                                   False);
 
-    // Declare the WM protocols we support
+    // Declare the WM protocols supported by GLFW
     {
         int count = 0;
         Atom protocols[2];
@@ -176,8 +172,8 @@ static GLboolean createWindow(_GLFWwindow* window,
             protocols[count++] = _glfwLibrary.X11.wmDeleteWindow;
 
         // The _NET_WM_PING EWMH protocol
-        // Tells the WM to ping our window and flag us as unresponsive if we
-        // don't reply within a few seconds
+        // Tells the WM to ping the GLFW window and flag the application as
+        // unresponsive if the WM doesn't get a reply within a few seconds
         if (_glfwLibrary.X11.wmPing != None)
             protocols[count++] = _glfwLibrary.X11.wmPing;
 
@@ -194,7 +190,7 @@ static GLboolean createWindow(_GLFWwindow* window,
         if (!hints)
         {
             _glfwSetError(GLFW_OUT_OF_MEMORY,
-                          "X11/GLX: Failed to allocate WM hints");
+                          "X11: Failed to allocate WM hints");
             return GL_FALSE;
         }
 
@@ -211,7 +207,7 @@ static GLboolean createWindow(_GLFWwindow* window,
         if (!hints)
         {
             _glfwSetError(GLFW_OUT_OF_MEMORY,
-                          "X11/GLX: Failed to allocate size hints");
+                          "X11: Failed to allocate size hints");
             return GL_FALSE;
         }
 
@@ -279,7 +275,7 @@ static void captureCursor(_GLFWwindow* window)
 
 static void showCursor(_GLFWwindow* window)
 {
-    // Un-grab cursor (only in windowed mode: in fullscreen mode we still
+    // Un-grab cursor (in windowed mode only; in fullscreen mode we still
     // want the cursor grabbed in order to confine the cursor to the window
     // area)
     if (window->X11.cursorGrabbed)
@@ -373,7 +369,7 @@ static void enterFullscreenMode(_GLFWwindow* window)
     }
     else if (window->X11.overrideRedirect)
     {
-        // In override-redirect mode, we have divorced ourselves from the
+        // In override-redirect mode we have divorced ourselves from the
         // window manager, so we need to do everything manually
 
         XRaiseWindow(_glfwLibrary.X11.display, window->X11.handle);
@@ -401,7 +397,6 @@ static void leaveFullscreenMode(_GLFWwindow* window)
 {
     _glfwRestoreVideoMode();
 
-    // Did we change the screen saver setting?
     if (_glfwLibrary.X11.saver.changed)
     {
         // Restore old screen saver settings
@@ -644,7 +639,8 @@ static void processSingleEvent(void)
             if (event.xmotion.x != window->X11.cursorPosX ||
                 event.xmotion.y != window->X11.cursorPosY)
             {
-                // The cursor was moved and we didn't do it
+                // The cursor was moved by something other than GLFW
+
                 int x, y;
 
                 if (window->cursorMode == GLFW_CURSOR_CAPTURED)
@@ -712,8 +708,8 @@ static void processSingleEvent(void)
             else if (_glfwLibrary.X11.wmPing != None &&
                      (Atom) event.xclient.data.l[0] == _glfwLibrary.X11.wmPing)
             {
-                // The window manager is pinging us to make sure we are still
-                // responding to events
+                // The window manager is pinging the application to ensure it's
+                // still responding to events
 
                 event.xclient.window = _glfwLibrary.X11.root;
                 XSendEvent(_glfwLibrary.X11.display,
@@ -862,7 +858,6 @@ static void processSingleEvent(void)
             {
                 case RRScreenChangeNotify:
                 {
-                    // Show XRandR that we really care
                     XRRUpdateConfiguration(&event);
                     break;
                 }
@@ -1069,8 +1064,8 @@ void _glfwPlatformIconifyWindow(_GLFWwindow* window)
 {
     if (window->X11.overrideRedirect)
     {
-        // We can't iconify/restore override-redirect windows, as that's
-        // performed by the window manager
+        // Override-redirect windows cannot be iconified or restored, as those
+        // tasks are performed by the window manager
         return;
     }
 
@@ -1088,8 +1083,8 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window)
 {
     if (window->X11.overrideRedirect)
     {
-        // We can't iconify/restore override-redirect windows, as that's
-        // performed by the window manager
+        // Override-redirect windows cannot be iconified or restored, as those
+        // tasks are performed by the window manager
         return;
     }
 
@@ -1215,7 +1210,7 @@ void _glfwPlatformWaitEvents(void)
 
 void _glfwPlatformSetCursorPos(_GLFWwindow* window, int x, int y)
 {
-    // Store the new position so we can recognise it later
+    // Store the new position so it can be recognized later
     window->X11.cursorPosX = x;
     window->X11.cursorPosY = y;