Merge branch 'master' into multi-monitor

Conflicts: CMakeLists.txt readme.html src/CMakeLists.txt src/cocoa_platform.h src/win32_platform.h src/x11_platform.h tests/events.c
2024-11-26 12:18:51 -05:00 · 2012-12-02 20:52:03 +01:00 · 2012-12-02 20:52:03 +01:00 · 73cdc34df7
parent 5f68e12b52 ccdb776cc3
commit 73cdc34df7
32 changed files with 1911 additions and 261 deletions
--- a/CMake/modules/FindEGL.cmake
+++ b/CMake/modules/FindEGL.cmake
@ -0,0 +1,16 @@
 # Find EGL
 #
 # EGL_INCLUDE_DIR
 # EGL_LIBRARY
 # EGL_FOUND
 find_path(EGL_INCLUDE_DIR NAMES EGL/egl.h)
 set(EGL_NAMES ${EGL_NAMES} egl EGL)
 find_library(EGL_LIBRARY NAMES ${EGL_NAMES})
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(EGL DEFAULT_MSG EGL_LIBRARY EGL_INCLUDE_DIR)
 mark_as_advanced(EGL_INCLUDE_DIR EGL_LIBRARY)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -15,7 +15,20 @@ option(GLFW_BUILD_TESTS "Build the GLFW test programs" ON)
 option(GLFW_NATIVE_API "Build the GLFW native API" OFF)
 option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
-find_package(OpenGL REQUIRED)
+if (NOT APPLE)
    option(GLFW_USE_EGL "Use EGL for context creation" OFF)
 endif()
 if (GLFW_USE_EGL)
    set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMake/modules)
    find_package(EGL REQUIRED)
    set(GLFW_BUILD_EXAMPLES OFF)
    set(GLFW_BUILD_TESTS OFF)
    message(STATUS "NOTE: Examples and tests are disabled for EGL")
 else()
    find_package(OpenGL REQUIRED)
 endif()
 #--------------------------------------------------------------------
 # Enable all warnings on GCC, regardless of OS
@ -32,17 +45,40 @@ if (BUILD_SHARED_LIBS)
 endif()
 #--------------------------------------------------------------------
-# Detect and select target platform
+# Detect and select target APIs
 #--------------------------------------------------------------------
 if (WIN32)
-    set(_GLFW_WIN32_WGL 1)
+    set(_GLFW_WIN32 1)
-    message(STATUS "Building GLFW for WGL on a Win32 system") 
+    message(STATUS "Using Win32 for window creation") 
-elseif (UNIX AND APPLE)
+
-    set(_GLFW_COCOA_NSGL 1)
+    if (GLFW_USE_EGL)
-    message(STATUS "Building GLFW for Cocoa and NSOpenGL on Mac OS X")
+        set(_GLFW_EGL 1)
-elseif (UNIX AND NOT APPLE)
+        message(STATUS "Using EGL for context creation")
-    set(_GLFW_X11_GLX 1)
+    else()
-    message(STATUS "Building GLFW for X11 and GLX on a Unix-like system")
+        set(_GLFW_WGL 1)
        message(STATUS "Using WGL for context creation")
    endif()
 elseif (APPLE)
    set(_GLFW_COCOA 1)
    message(STATUS "Using Cocoa for window creation")
    if (GLFW_USE_EGL)
        message(FATAL_ERROR "EGL not supported on Mac OS X")
    else()
        set(_GLFW_NSGL 1)
        message(STATUS "Using NSGL for context creation")
    endif()
 elseif (UNIX)
    set(_GLFW_X11 1)
    message(STATUS "Using X11 for window creation") 
    if (GLFW_USE_EGL)
        set(_GLFW_EGL 1)
        message(STATUS "Using EGL for context creation")
    else()
        set(_GLFW_GLX 1)
        message(STATUS "Using GLX for context creation")
    endif()
 else()
    message(FATAL_ERROR "No supported platform was detected")
 endif()
@ -50,7 +86,7 @@ endif()
 #--------------------------------------------------------------------
 # Set up GLFW for Win32 and WGL on Windows
 #--------------------------------------------------------------------
-if (_GLFW_WIN32_WGL)
+if (_GLFW_WIN32)
    # Set up library and include paths
    list(APPEND glfw_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR})
@ -79,26 +115,18 @@ if (_GLFW_WIN32_WGL)
 endif()
 #--------------------------------------------------------------------
-# Set up GLFW for Xlib and GLX on Unix-like systems with X Windows
+# Set up GLFW for Xlib and GLX or EGL on Unix-like systems with X Windows
 #--------------------------------------------------------------------
-if (_GLFW_X11_GLX)
+if (_GLFW_X11)
    find_package(X11 REQUIRED)
-    set(CMAKE_THREAD_PREFER_PTHREADS YES)
+    set(GLFW_PKG_LIBS "")
-    find_package(Threads)
+    set(GLFW_PKG_DEPS "x11")
    if (CMAKE_THREAD_LIBS_INIT)
        list(APPEND glfw_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
    endif()
    # Set up library and include paths
-    list(APPEND glfw_INCLUDE_DIRS ${X11_X11_INCLUDE_PATH} ${OPENGL_INCLUDE_DIR})
+    list(APPEND glfw_INCLUDE_DIRS ${X11_X11_INCLUDE_PATH})
-    list(APPEND glfw_LIBRARIES ${X11_X11_LIB} ${OPENGL_gl_LIBRARY})
+    list(APPEND glfw_LIBRARIES ${X11_X11_LIB})
    set(GLFW_PKG_DEPS "gl x11")
    set(GLFW_PKG_LIBS "")
    include(CheckFunctionExists)
    # Check for XRandR (modern resolution switching extension)
    if (X11_Xrandr_FOUND)
@ -144,6 +172,21 @@ if (_GLFW_X11_GLX)
        set(GLFW_PKG_LIBS "${GLFW_PKG_LIBS} -lm")
    endif()
 endif()
 #--------------------------------------------------------------------
 # GLX Context
 #--------------------------------------------------------------------
 if (_GLFW_GLX)
    # Set up library and include paths
    list(APPEND glfw_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR})
    list(APPEND glfw_LIBRARIES ${OPENGL_gl_LIBRARY})
    set(GLFW_PKG_DEPS "${GLFW_PKG_DEPS} gl")
    include(CheckFunctionExists)
    set(CMAKE_REQUIRED_LIBRARIES ${OPENGL_gl_LIBRARY})
    check_function_exists(glXGetProcAddress _GLFW_HAS_GLXGETPROCADDRESS)
@ -182,12 +225,59 @@ if (_GLFW_X11_GLX)
            set(GLFW_PKG_LIBS "${GLFW_PKG_LIBS} -ldl")
        endif()
    endif()
 endif()
 #--------------------------------------------------------------------
 # EGL Context
 #--------------------------------------------------------------------
 if (_GLFW_EGL)
    # Set up library and include paths
    list(APPEND glfw_INCLUDE_DIRS ${EGL_INCLUDE_DIR})
    list(APPEND glfw_LIBRARIES ${EGL_LIBRARY})
    set(CMAKE_REQUIRED_LIBRARIES ${EGL_LIBRARY})
    if (_GLFW_X11)
        set(GLFW_PKG_DEPS "${GLFW_PKG_DEPS} egl")
        include(CheckFunctionExists)
        check_function_exists(eglGetProcAddress _GLFW_HAS_EGLGETPROCADDRESS)
        if (NOT _GLFW_HAS_EGLGETPROCADDRESS)
            message(WARNING "No eglGetProcAddress found")
            # Check for dlopen support as a fallback
            find_library(DL_LIBRARY dl)
            mark_as_advanced(DL_LIBRARY)
            if (DL_LIBRARY)
                set(CMAKE_REQUIRED_LIBRARIES ${DL_LIBRARY})
            else()
                set(CMAKE_REQUIRED_LIBRARIES "")
            endif()
            check_function_exists(dlopen _GLFW_HAS_DLOPEN)
            if (NOT _GLFW_HAS_DLOPEN)
                message(FATAL_ERROR "No entry point retrieval mechanism found")
            endif()
            if (DL_LIBRARY)
                list(APPEND glfw_LIBRARIES ${DL_LIBRARY})
                set(GLFW_PKG_LIBS "${GLFW_PKG_LIBS} -ldl")
            endif()
        endif()
    endif()
 endif()
 #--------------------------------------------------------------------
 # Set up GLFW for Cocoa and NSOpenGL on Mac OS X
 #--------------------------------------------------------------------
-if (_GLFW_COCOA_NSGL)
+if (_GLFW_COCOA AND _GLFW_NSGL)
    option(GLFW_BUILD_UNIVERSAL "Build GLFW as a Universal Binary" OFF)
@ -269,7 +359,7 @@ install(FILES COPYING.txt readme.html
 #--------------------------------------------------------------------
 # Create and install pkg-config file on supported platforms
 #--------------------------------------------------------------------
-if (_GLFW_X11_GLX OR _GLFW_COCOA_NSGL)
+if (UNIX)
    configure_file(${GLFW_SOURCE_DIR}/src/glfw3.pc.in
                   ${GLFW_BINARY_DIR}/src/glfw3.pc @ONLY)
--- a/include/GL/glfw3.h
+++ b/include/GL/glfw3.h
@ -188,6 +188,10 @@ extern "C" {
 #else
  #if defined(GLFW_INCLUDE_GLCOREARB)
    #include <GL/glcorearb.h>
  #elif defined(GLFW_INCLUDE_ES1)
    #include <GLES/gl.h>
  #elif defined(GLFW_INCLUDE_ES2)
    #include <GLES2/gl2.h>
  #else
    #include <GL/gl.h>
  #endif
@ -509,6 +513,10 @@ extern "C" {
 /*! @brief The number of samples used for default framebuffer multisampling.
 */
 #define GLFW_FSAA_SAMPLES         0x0002100E
 /*! @brief @c GL_TRUE if the framebuffer should be sRGB capable, or @c GL_FALSE
 *  otherwise.
 */
 #define GLFW_SRGB_CAPABLE         0x0002100F
 /*! @brief The @link clients client API @endlink to create a context for.
 */
@ -709,6 +717,16 @@ typedef void* GLFWwindow;
 */
 typedef void (* GLFWerrorfun)(int,const char*);
 /*! @brief The function signature for window position callbacks.
 *  @param[in] window The window that the user moved.
 *  @param[in] x The new x-coordinate, in pixels, of the upper-left corner of
 *  the client area of the window.
 *  @param[in] y The new y-coordinate, in pixels, of the upper-left corner of
 *  the client area of the window.
 *  @ingroup window
 */
 typedef void (* GLFWwindowposfun)(GLFWwindow,int,int);
 /*! @brief The function signature for window resize callbacks.
 *  @param[in] window The window that the user resized.
 *  @param[in] width The new width, in pixels, of the window.
@ -1005,7 +1023,7 @@ GLFWAPI void glfwGetVideoMode(GLFWmonitor monitor, GLFWvidmode* mode);
 /*! @brief Sets the system gamma ramp to one generated from the specified
 *  exponent.
- *  @param[in] The desired exponent.
+ *  @param[in] gamma The desired exponent.
 *  @ingroup gamma
 */
 GLFWAPI void glfwSetGamma(float gamma);
@ -1071,6 +1089,9 @@ GLFWAPI void glfwDefaultWindowHints(void);
 *  The @ref GLFW_FSAA_SAMPLES hint specifies the desired number of samples to
 *  use for multisampling.
 *
 *  The @ref GLFW_SRGB_CAPABLE hint specifies whether the framebuffer should be
 *  sRGB capable.
 *
 *  The @ref GLFW_CLIENT_API hint specifies which client API to create the
 *  context for.  Possible values are @ref GLFW_OPENGL_API and @ref
 *  GLFW_OPENGL_ES_API.
@ -1099,7 +1120,8 @@ GLFWAPI void glfwDefaultWindowHints(void);
 *  used by the OpenGL context.
 *
 *  The @ref GLFW_RESIZABLE hint specifies whether the window will be resizable
- *  by the user.  This hint is ignored for fullscreen windows.
+ *  by the user.  The window will still be resizable using the @ref
 *  glfwSetWindowSize function.  This hint is ignored for fullscreen windows.
 *
 *  The @ref GLFW_VISIBLE hint specifies whether the window will be initially
 *  visible.  This hint is ignored for fullscreen windows.
@ -1110,7 +1132,9 @@ GLFWAPI void glfwDefaultWindowHints(void);
 *  Some window hints are hard constraints.  These must match the available
 *  capabilities @em exactly for window and context creation to succeed.  Hints
 *  that are not hard constraints are matched as closely as possible, but the
- *  resulting window and context may differ from what these hints requested.
+ *  resulting window and context may differ from what these hints requested.  To
 *  find out the actual properties of the created window and context, use the
 *  @ref glfwGetWindowParam function.
 *
 *  The following window hints are hard constraints:
 *  @arg @ref GLFW_STEREO
@ -1343,11 +1367,21 @@ GLFWAPI void glfwSetWindowUserPointer(GLFWwindow window, void* pointer);
 */
 GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow window);
 /*! @brief Sets the position callback for the specified window.
 *  @param[in] window The window whose callback to set.
 *  @param[in] cbfun The new callback, or @c NULL to remove the currently set
 *  callback.
 *  @ingroup window
 */
 GLFWAPI void glfwSetWindowPosCallback(GLFWwindow window, GLFWwindowposfun cbfun);
 /*! @brief Sets the size callback for the specified window.
 *  @param[in] window The window whose callback to set.
 *  @param[in] cbfun The new callback, or @c NULL to remove the currently set
 *  callback.
 *  @ingroup window
 *
 *  This callback is called when the window is resized.
 */
 GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfun);
@ -1356,6 +1390,14 @@ GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfu
 *  @param[in] cbfun The new callback, or @c NULL to remove the currently set
 *  callback.
 *  @ingroup window
 *
 *  This callback is called when the user attempts to close the window, i.e.
 *  clicks the window's close widget or, on Mac OS X, selects @b Quit from the
 *  application menu.  Calling @ref glfwDestroyWindow does not cause this
 *  callback to be called.
 *
 *  The return value of the close callback becomes the new value of the @ref
 *  GLFW_CLOSE_REQUESTED window parameter.
 */
 GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cbfun);
@ -1364,6 +1406,13 @@ GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cb
 *  @param[in] cbfun The new callback, or @c NULL to remove the currently set
 *  callback.
 *  @ingroup window
 *
 *  This callback is called when the client area of the window needs to be
 *  redrawn, for example if the window has been exposed after having been
 *  covered by another window.
 *
 *  @note On compositing window systems such as Mac OS X, where the window
 *  contents are saved off-screen, this callback may never be called.
 */
 GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfun cbfun);
@ -1372,6 +1421,8 @@ GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfu
 *  @param[in] cbfun The new callback, or @c NULL to remove the currently set
 *  callback.
 *  @ingroup window
 *
 *  This callback is called when the window gains or loses focus.
 */
 GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cbfun);
@ -1380,6 +1431,8 @@ GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cb
 *  @param[in] cbfun The new callback, or @c NULL to remove the currently set
 *  callback.
 *  @ingroup window
 *
 *  This callback is called when the window is iconified or restored.
 */
 GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow window, GLFWwindowiconifyfun cbfun);
@ -1478,7 +1531,7 @@ GLFWAPI void glfwGetScrollOffset(GLFWwindow window, double* xoffset, double* yof
 *  set callback.
 *  @ingroup input
 *
- *  @note The key callback deals with physical keys, with @link keys tokens
+ *  @remarks The key callback deals with physical keys, with @link keys tokens
 *  @endlink named after their use on the standard US keyboard layout.  If you
 *  want to input text, use the Unicode character callback instead.
 */
@ -1489,8 +1542,8 @@ GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun);
 *  the currently set callback.
 *  @ingroup input
 *
- *  @note The Unicode character callback is for text input.  If you want to know
+ *  @remarks The Unicode character callback is for text input.  If you want to
- *  whether a specific key was pressed or released, use the key callback.
+ *  know whether a specific key was pressed or released, use the key callback.
 */
 GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun);
@ -1505,6 +1558,9 @@ GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cb
 *  @param[in] cbfun The new cursor position callback, or @c NULL to remove the
 *  currently set callback.
 *  @ingroup input
 *
 *  @remarks The position is relative to the upper-left corner of the client
 *  area of the window.
 */
 GLFWAPI void glfwSetCursorPosCallback(GLFWwindow window, GLFWcursorposfun cbfun);
@ -1552,11 +1608,24 @@ GLFWAPI int glfwGetJoystickAxes(int joy, float* axes, int numaxes);
 */
 GLFWAPI int glfwGetJoystickButtons(int joy, unsigned char* buttons, int numbuttons);
 /*! @brief Returns the name of the specified joystick.
 *  @param[in] joy The joystick to query.
 *  @return The UTF-8 encoded name of the joystick, or @c NULL if the joystick
 *  is not present.
 *  @ingroup input
 *
 *  @note The returned string is valid only until the next call to @ref
 *  glfwGetJoystickName.
 */
 GLFWAPI const char* glfwGetJoystickName(int joy);
 /*! @brief Sets the clipboard to the specified string.
 *  @param[in] window The window that will own the clipboard contents.
 *  @param[in] string A UTF-8 encoded string.
 *  @ingroup clipboard
 *
 *  @note This function may only be called from the main thread.
 *
 *  @sa glfwGetClipboardString
 */
 GLFWAPI void glfwSetClipboardString(GLFWwindow window, const char* string);
@ -1567,6 +1636,8 @@ GLFWAPI void glfwSetClipboardString(GLFWwindow window, const char* string);
 *  if that format was unavailable.
 *  @ingroup clipboard
 *
 *  @note This function may only be called from the main thread.
 *
 *  @note The returned string is valid only until the next call to @ref
 *  glfwGetClipboardString or @ref glfwSetClipboardString.
 *
--- a/readme.html
+++ b/readme.html
@ -279,17 +279,21 @@ version of GLFW.</p>
  <li>Added <code>glfwSetErrorCallback</code> function and <code>GLFWerrorfun</code> type for receiving more specific and/or nested errors</li>
  <li>Added <code>glfwSetWindowUserPointer</code> and <code>glfwGetWindowUserPointer</code> functions for per-window user pointers</li>
  <li>Added <code>glfwGetVersionString</code> function for determining which code paths were enabled at compile time</li>
  <li>Added <code>glfwGetWindowPos</code> function for querying the position of the specified window</li>
  <li>Added <code>glfwGetWindowMonitor</code> for querying the monitor, if any, of the specified window</li>
  <li>Added <code>glfwSetWindowPosCallback</code> function and <code>GLFWwindowposfun</code> type for reciving window position events</li>
  <li>Added <code>glfwSetWindowFocusCallback</code> function and <code>GLFWwindowfocusfun</code> type for receiving window focus events</li>
  <li>Added <code>glfwSetWindowIconifyCallback</code> function and <code>GLFWwindowiconifyfun</code> type for receiving window iconification events</li>
  <li>Added <code>glfwGetClipboardString</code> and <code>glfwSetClipboardString</code> functions for interacting with the system clipboard</li>
  <li>Added <code>glfwGetJoystickName</code> for retrieving the name of a joystick</li>
  <li>Added <code>glfwGetCurrentContext</code> function for retrieving the window whose OpenGL context is current</li>
  <li>Added <code>GLFW_SRGB_CAPABLE</code> for requesting sRGB capable framebuffers</li>
  <li>Added <code>GLFW_CLIENT_API</code>, <code>GLFW_OPENGL_API</code> and <code>GLFW_OPENGL_ES_API</code> for selecting client API</li>
  <li>Added <code>GLFW_OPENGL_ROBUSTNESS</code> window hint and associated strategy tokens for <code>GL_ARB_robustness</code> support</li>
  <li>Added <code>GLFW_OPENGL_REVISION</code> window parameter to make up for removal of <code>glfwGetGLVersion</code></li>
  <li>Added <code>GLFW_INCLUDE_GLCOREARB</code> macro for including <code>glcorearb.h</code> instead of <code>gl.h</code></li>
  <li>Added <code>GLFW_INCLUDE_ES2</code> macro for telling the GLFW header to include the OpenGL ES 2.0 header instead of <code>gl.h</code></li>
  <li>Added <code>GLFW_VISIBLE</code> window hint and parameter for controlling and polling window visibility</li>
  <li>Added <code>GLFW_POSITION_X</code> and <code>GLFW_POSITION_Y</code> window hints and parameter for controlling and polling window position</li>
  <li>Added <code>windows</code> simple multi-window test program</li>
  <li>Added <code>sharing</code> simple OpenGL object sharing test program</li>
  <li>Added <code>modes</code> video mode enumeration and setting test program</li>
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -8,43 +8,55 @@ if (MSVC)
 endif()
 set(common_HEADERS ${GLFW_SOURCE_DIR}/include/GL/glfw3.h internal.h)
-set(common_SOURCES clipboard.c gamma.c init.c input.c joystick.c monitor.c
+set(common_SOURCES clipboard.c context.c gamma.c init.c input.c joystick.c
-                   opengl.c time.c window.c)
+                   monitor.c time.c window.c)
-if (_GLFW_COCOA_NSGL)
+if (_GLFW_COCOA)
    set(glfw_HEADERS ${common_HEADERS} cocoa_platform.h)
    set(glfw_SOURCES ${common_SOURCES} cocoa_clipboard.m cocoa_gamma.c
-                     cocoa_init.m cocoa_joystick.m cocoa_monitor.m
+                     cocoa_init.m cocoa_joystick.m cocoa_monitor.m cocoa_time.c
-                     cocoa_opengl.m cocoa_time.c cocoa_window.m)
+                     cocoa_window.m)
    if (GLFW_NATIVE_API)
        list(APPEND glfw_SOURCES cocoa_native.m)
    endif()
-
+elseif (_GLFW_WIN32)
    # For some reason, CMake doesn't know about .m
    set_source_files_properties(${glfw_SOURCES} PROPERTIES LANGUAGE C)
 elseif (_GLFW_WIN32_WGL)
    set(glfw_HEADERS ${common_HEADERS} win32_platform.h)
    set(glfw_SOURCES ${common_SOURCES} win32_clipboard.c win32_gamma.c
-                     win32_init.c win32_joystick.c win32_monitor.c
+                     win32_init.c win32_joystick.c win32_monitor.c win32_time.c
-                     win32_opengl.c win32_time.c win32_window.c)
+                     win32_window.c)
    if (GLFW_NATIVE_API)
        list(APPEND glfw_SOURCES win32_native.c)
    endif()
-elseif (_GLFW_X11_GLX)
+elseif (_GLFW_X11)
    set(glfw_HEADERS ${common_HEADERS} x11_platform.h)
    set(glfw_SOURCES ${common_SOURCES} x11_clipboard.c x11_gamma.c x11_init.c
                     x11_joystick.c x11_keysym2unicode.c x11_monitor.c
-                     x11_opengl.c x11_time.c x11_window.c)
+                     x11_time.c x11_window.c)
    if (GLFW_NATIVE_API)
        list(APPEND glfw_SOURCES x11_native.c)
    endif()
 endif()
-if (MSVC)
+if (_GLFW_EGL)
-    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    list(APPEND glfw_HEADERS ${common_HEADERS} egl_platform.h)
    list(APPEND glfw_SOURCES ${common_SOURCES} egl_context.c)
 elseif (_GLFW_NSGL)
    list(APPEND glfw_HEADERS ${common_HEADERS} nsgl_platform.h)
    list(APPEND glfw_SOURCES ${common_SOURCES} nsgl_context.m)
 elseif (_GLFW_WGL)
    list(APPEND glfw_HEADERS ${common_HEADERS} wgl_platform.h)
    list(APPEND glfw_SOURCES ${common_SOURCES} wgl_context.c)
 elseif (_GLFW_X11)
    list(APPEND glfw_HEADERS ${common_HEADERS} glx_platform.h)
    list(APPEND glfw_SOURCES ${common_SOURCES} glx_context.c)
 endif()
 if (APPLE)
    # For some reason, CMake doesn't know about .m
    set_source_files_properties(${glfw_SOURCES} PROPERTIES LANGUAGE C)
 endif()
 add_library(glfw ${glfw_SOURCES} ${glfw_HEADERS})
@ -57,7 +69,7 @@ if (BUILD_SHARED_LIBS)
        set_target_properties(glfw PROPERTIES SOVERSION ${GLFW_VERSION_MAJOR})
    endif()
-    if (_GLFW_WIN32_WGL)
+    if (WIN32)
        # The GLFW DLL needs a special compile-time macro and import library name
        set_target_properties(glfw PROPERTIES PREFIX "" IMPORT_PREFIX "")
@ -66,8 +78,9 @@ if (BUILD_SHARED_LIBS)
        else()
            set_target_properties(glfw PROPERTIES IMPORT_SUFFIX "dll.lib")
        endif()
-    elseif (_GLFW_COCOA_NSGL)
+    elseif (APPLE)
-        # Append -fno-common to the compile flags to work around a bug in the Apple GCC
+        # Append -fno-common to the compile flags to work around a bug in
        # Apple's GCC
        get_target_property(glfw_CFLAGS glfw COMPILE_FLAGS)
        if (NOT glfw_CFLAGS)
            set(glfw_CFLAGS "")
--- a/src/cocoa_joystick.m
+++ b/src/cocoa_joystick.m
@ -68,7 +68,7 @@ typedef struct
 typedef struct
 {
    int present;
-    char product[256];
+    char name[256];
    IOHIDDeviceInterface** interface;
@ -443,9 +443,9 @@ void _glfwInitJoysticks(void)
        if (refCF)
        {
            CFStringGetCString(refCF,
-                               (char*) &(joystick->product),
+                               joystick->name,
-                               256,
+                               sizeof(joystick->name),
-                               CFStringGetSystemEncoding());
+                               kCFStringEncodingUTF8);
        }
        joystick->numAxes = 0;
@ -625,3 +625,13 @@ int _glfwPlatformGetJoystickButtons(int joy, unsigned char* buttons,
    return button;
 }
 //========================================================================
 // Get joystick name
 //========================================================================
 const char* _glfwPlatformGetJoystickName(int joy)
 {
    return _glfwJoysticks[joy].name;
 }
--- a/src/cocoa_platform.h
+++ b/src/cocoa_platform.h
@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
+// Platform:    Cocoa
 // API Version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@ -27,13 +27,12 @@
 //
 //========================================================================
-#ifndef _platform_h_
+#ifndef _cocoa_platform_h_
-#define _platform_h_
+#define _cocoa_platform_h_
 #include <stdint.h>
 #if defined(__OBJC__)
 #import <Cocoa/Cocoa.h>
 #else
@ -41,12 +40,15 @@
 typedef void* id;
 #endif
 #if defined(_GLFW_NSGL)
 #include "nsgl_platform.h"
 #else
 #error "No supported context creation API selected"
 #endif
-#define _GLFW_PLATFORM_MONITOR_STATE _GLFWmonitorNS NS
+#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowNS  NS
 #define _GLFW_PLATFORM_WINDOW_STATE  _GLFWwindowNS NS
 #define _GLFW_PLATFORM_CONTEXT_STATE _GLFWcontextNSGL NSGL
 #define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryNS NS
-#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryNSGL NSGL
+#define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorNS NS
 //========================================================================
@ -59,16 +61,6 @@ typedef void* id;
 typedef intptr_t GLFWintptr;
 //------------------------------------------------------------------------
 // Platform-specific OpenGL context structure
 //------------------------------------------------------------------------
 typedef struct _GLFWcontextNSGL
 {
    id           pixelFormat;
    id	         context;
 } _GLFWcontextNSGL;
 //------------------------------------------------------------------------
 // Platform-specific window structure
 //------------------------------------------------------------------------
@ -110,16 +102,6 @@ typedef struct _GLFWmonitorNS
 } _GLFWmonitorNS;
 //------------------------------------------------------------------------
 // Platform-specific library global data for NSGL
 //------------------------------------------------------------------------
 typedef struct _GLFWlibraryNSGL
 {
    // dlopen handle for dynamically loading OpenGL extension entry points
    void*            framework;
 } _GLFWlibraryNSGL;
 //========================================================================
 // Prototypes for platform specific internal functions
 //========================================================================
@ -139,4 +121,4 @@ void _glfwRestoreVideoMode(void);
 int _glfwInitOpenGL(void);
 void _glfwTerminateOpenGL(void);
-#endif // _platform_h_
+#endif // _cocoa_platform_h_
--- a/src/cocoa_window.m
+++ b/src/cocoa_window.m
@ -835,6 +835,9 @@ static GLboolean createContext(_GLFWwindow* window,
        ADD_ATTR2(NSOpenGLPFASamples, fbconfig->samples);
    }
    // NOTE: All NSOpenGLPixelFormats on the relevant cards support sRGB
    // frambuffer, so there's no need (and no way) to request it
    ADD_ATTR(0);
 #undef ADD_ATTR
--- a/src/config.h.in
+++ b/src/config.h.in
@ -35,12 +35,21 @@
 // it.  Instead, you should modify the config.h.in file.
 //========================================================================
-// Define this to 1 if building GLFW for X11/GLX
+// Define this to 1 if building GLFW for X11
-#cmakedefine _GLFW_X11_GLX
+#cmakedefine _GLFW_X11
-// Define this to 1 if building GLFW for Win32/WGL
+// Define this to 1 if building GLFW for Win32
-#cmakedefine _GLFW_WIN32_WGL
+#cmakedefine _GLFW_WIN32
-// Define this to 1 if building GLFW for Cocoa/NSOpenGL
+// Define this to 1 if building GLFW for Cocoa
-#cmakedefine _GLFW_COCOA_NSGL
+#cmakedefine _GLFW_COCOA
 // Define this to 1 if building GLFW for EGL
 #cmakedefine _GLFW_EGL
 // Define this to 1 if building GLFW for GLX
 #cmakedefine _GLFW_GLX
 // Define this to 1 if building GLFW for WGL
 #cmakedefine _GLFW_WGL
 // Define this to 1 if building GLFW for NSGL
 #cmakedefine _GLFW_NSGL
 // Define this to 1 if building as a shared library / dynamic library / DLL
 #cmakedefine _GLFW_BUILD_DLL
@ -63,6 +72,9 @@
 // Define this to 1 if glXGetProcAddressEXT is available
 #cmakedefine _GLFW_HAS_GLXGETPROCADDRESSEXT
 // Define this to 1 if eglGetProcAddress is available
 #cmakedefine _GLFW_HAS_EGLGETPROCADDRESS
 // The GLFW version as used by glfwGetVersionString
 #define _GLFW_VERSION_FULL "@GLFW_VERSION_FULL@"
--- a/src/context.c
+++ b/src/context.c
@ -33,6 +33,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <limits.h>
 #include <stdio.h>
 //========================================================================
@ -217,6 +218,12 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
                extraDiff += (desired->samples - current->samples) *
                             (desired->samples - current->samples);
            }
            if (desired->sRGB)
            {
                if (!current->sRGB)
                    extraDiff++;
            }
        }
        // Figure out if the current one is better than the best one found so far
@ -247,8 +254,8 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
 //========================================================================
-// Checks whether the OpenGL part of the window config is sane
+// Checks whether the client API part of the window config is sane
-// It blames glfwCreateWindow because that's the only caller
+// It blames glfwOpenWindow because that's the only caller
 //========================================================================
 GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
@ -482,7 +489,7 @@ GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig)
 //========================================================================
-// Check if a string can be found in an OpenGL extension string
+// Check if a string can be found in a client API extension string
 //========================================================================
 int _glfwStringInExtensionString(const char* string,
@ -521,7 +528,7 @@ int _glfwStringInExtensionString(const char* string,
 //////////////////////////////////////////////////////////////////////////
 //========================================================================
-// Make the OpenGL context associated with the specified window current
+// Make the context associated with the specified window current
 //========================================================================
 GLFWAPI void glfwMakeContextCurrent(GLFWwindow handle)
@ -542,7 +549,7 @@ GLFWAPI void glfwMakeContextCurrent(GLFWwindow handle)
 //========================================================================
-// Return the window object whose context is current
+// Returns the window whose context is current
 //========================================================================
 GLFWAPI GLFWwindow glfwGetCurrentContext(void)
@ -598,7 +605,7 @@ GLFWAPI void glfwSwapInterval(int interval)
 //========================================================================
-// Check if an OpenGL extension is available at runtime
+// Check if a client API extension is available at runtime
 //========================================================================
 GLFWAPI int glfwExtensionSupported(const char* extension)
@ -661,8 +668,8 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
 //========================================================================
-// Get the function pointer to an OpenGL function.
+// Get the function pointer to a client API function
-// This function can be used to get access to extended OpenGL functions.
+// This can be used to get access to client API extension functions
 //========================================================================
 GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
--- a/src/egl_context.c
+++ b/src/egl_context.c
@ -0,0 +1,595 @@
 //========================================================================
 // GLFW - An OpenGL library
 // Platform:    EGL
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
 // arising from the use of this software.
 //
 // Permission is granted to anyone to use this software for any purpose,
 // including commercial applications, and to alter it and redistribute it
 // freely, subject to the following restrictions:
 //
 // 1. The origin of this software must not be misrepresented; you must not
 //    claim that you wrote the original software. If you use this software
 //    in a product, an acknowledgment in the product documentation would
 //    be appreciated but is not required.
 //
 // 2. Altered source versions must be plainly marked as such, and must not
 //    be misrepresented as being the original software.
 //
 // 3. This notice may not be removed or altered from any source
 //    distribution.
 //
 //========================================================================
 #include "internal.h"
 #include <stdio.h>
 #include <stdlib.h>
 //========================================================================
 // Thread local storage attribute macro
 //========================================================================
 #if defined(_MSC_VER)
 #define _GLFW_TLS __declspec(thread)
 #elif defined(__GNUC__)
 #define _GLFW_TLS __thread
 #else
 #define _GLFW_TLS
 #endif
 //========================================================================
 // The per-thread current context/window pointer
 //========================================================================
 static _GLFW_TLS _GLFWwindow* _glfwCurrentWindow = NULL;
 //========================================================================
 // Returns the specified attribute of the specified EGLConfig
 //========================================================================
 static int getConfigAttrib(EGLConfig config, int attrib)
 {
    int value;
    eglGetConfigAttrib(_glfwLibrary.EGL.display, config, attrib, &value);
    return value;
 }
 //========================================================================
 // Return a list of available and usable framebuffer configs
 //========================================================================
 static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window,
                                   const _GLFWwndconfig* wndconfig,
                                   unsigned int* found)
 {
    EGLConfig* configs;
    _GLFWfbconfig* result;
    int i, count = 0;
    *found = 0;
    eglGetConfigs(_glfwLibrary.EGL.display, NULL, 0, &count);
    configs = (EGLConfig*) malloc(sizeof(EGLConfig) * count);
    if (!configs)
    {
        _glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
        return NULL;
    }
    eglGetConfigs(_glfwLibrary.EGL.display, configs, count, &count);
    if (!count)
    {
        free(configs);
        _glfwSetError(GLFW_API_UNAVAILABLE,
                      "EGL: No EGLConfigs returned");
        return NULL;
    }
    result = (_GLFWfbconfig*) malloc(sizeof(_GLFWfbconfig) * count);
    if (!result)
    {
        free(configs);
        _glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
        return NULL;
    }
    for (i = 0;  i < count;  i++)
    {
        _GLFWfbconfig* f = result + *found;
        if (!getConfigAttrib(configs[i], EGL_NATIVE_VISUAL_ID))
        {
            // Only consider EGLConfigs with associated visuals
            continue;
        }
        if (!(getConfigAttrib(configs[i], EGL_COLOR_BUFFER_TYPE) & EGL_RGB_BUFFER))
        {
            // Only consider RGB(A) EGLConfigs
            continue;
        }
        if (!(getConfigAttrib(configs[i], EGL_SURFACE_TYPE) & EGL_WINDOW_BIT))
        {
            // Only consider window EGLConfigs
            continue;
        }
        if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
        {
            if (wndconfig->glMajor == 1)
            {
                if (!(getConfigAttrib(configs[i], EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES_BIT))
                    continue;
            }
            else
            {
                if (!(getConfigAttrib(configs[i], EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT))
                    continue;
            }
        }
        else if (wndconfig->clientAPI == GLFW_OPENGL_API)
        {
            if (!(getConfigAttrib(configs[i], EGL_RENDERABLE_TYPE) & EGL_OPENGL_BIT))
                continue;
        }
        f->redBits = getConfigAttrib(configs[i], EGL_RED_SIZE);
        f->greenBits = getConfigAttrib(configs[i], EGL_GREEN_SIZE);
        f->blueBits = getConfigAttrib(configs[i], EGL_BLUE_SIZE);
        f->alphaBits = getConfigAttrib(configs[i], EGL_ALPHA_SIZE);
        f->depthBits = getConfigAttrib(configs[i], EGL_DEPTH_SIZE);
        f->stencilBits = getConfigAttrib(configs[i], EGL_STENCIL_SIZE);
        f->samples = getConfigAttrib(configs[i], EGL_SAMPLES);
        // NOTE: There does not appear to be any way to request sRGB
        // framebuffers for OpenGL or GLES contexts; only for OpenVG ones
        f->sRGB = GL_FALSE;
        f->platformID = (GLFWintptr) getConfigAttrib(configs[i], EGL_CONFIG_ID);
        (*found)++;
    }
    free(configs);
    return result;
 }
 //========================================================================
 // Create the actual OpenGL(|ES) context
 //========================================================================
 #define setEGLattrib(attribs, index, attribName, attribValue) \
 { \
    attribs[index++] = attribName; \
    attribs[index++] = attribValue; \
 }
 static int createContext(_GLFWwindow* window,
                         const _GLFWwndconfig* wndconfig,
                         EGLint fbconfigID)
 {
    int attribs[40];
    EGLint count, index;
    EGLConfig config;
    EGLContext share = NULL;
    if (wndconfig->share)
        share = wndconfig->share->EGL.context;
    // Retrieve the previously selected EGLConfig
    {
        index = 0;
        setEGLattrib(attribs, index, EGL_CONFIG_ID, fbconfigID);
        setEGLattrib(attribs, index, EGL_NONE, EGL_NONE);
        eglChooseConfig(_glfwLibrary.EGL.display, attribs, &config, 1, &count);
        if (!count)
        {
            _glfwSetError(GLFW_PLATFORM_ERROR,
                          "EGL: Failed to retrieve the selected EGLConfig");
            return GL_FALSE;
        }
    }
    // Retrieve the corresponding visual
    // NOTE: This is the only non-portable code in this file.
    // Maybe it would not hurt too much to add #ifdefs for different platforms?
 #if defined(_GLFW_X11)
    {
        int mask;
        EGLint redBits, greenBits, blueBits, alphaBits, visualID = 0;
        XVisualInfo info;
        eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
                           EGL_NATIVE_VISUAL_ID, &visualID);
        info.screen = _glfwLibrary.X11.screen;
        mask = VisualScreenMask;
        if (visualID)
        {
            // The X window visual must match the EGL config
            info.visualid = visualID;
            mask |= VisualIDMask;
        }
        else
        {
            // some EGL drivers don't implement the EGL_NATIVE_VISUAL_ID
            // attribute, so attempt to find the closest match.
            eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
                               EGL_RED_SIZE, &redBits);
            eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
                               EGL_GREEN_SIZE, &greenBits);
            eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
                               EGL_BLUE_SIZE, &blueBits);
            eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
                               EGL_ALPHA_SIZE, &alphaBits);
            info.depth = redBits + greenBits + blueBits + alphaBits;
            mask |= VisualDepthMask;
        }
        window->EGL.visual = XGetVisualInfo(_glfwLibrary.X11.display,
                                            mask, &info, &count);
        if (window->EGL.visual == NULL)
        {
            _glfwSetError(GLFW_PLATFORM_ERROR,
                          "EGL: Failed to retrieve visual for EGLConfig");
            return GL_FALSE;
        }
    }
 #endif
    if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
    {
        if (!eglBindAPI(EGL_OPENGL_ES_API))
        {
            _glfwSetError(GLFW_PLATFORM_ERROR,
                          "EGL: OpenGL ES is not supported");
            return GL_FALSE;
        }
    }
    else
    {
        if (!eglBindAPI(EGL_OPENGL_API))
        {
            _glfwSetError(GLFW_PLATFORM_ERROR,
                          "EGL: OpenGL is not supported");
            return GL_FALSE;
        }
    }
    index = 0;
    if (_glfwLibrary.EGL.KHR_create_context)
    {
        setEGLattrib(attribs, index, EGL_CONTEXT_MAJOR_VERSION_KHR, wndconfig->glMajor);
        setEGLattrib(attribs, index, EGL_CONTEXT_MINOR_VERSION_KHR, wndconfig->glMinor);
        if (wndconfig->glForward || wndconfig->glDebug || wndconfig->glRobustness)
        {
            int flags = 0;
            if (wndconfig->glForward)
                flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
            if (wndconfig->glDebug)
                flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
            if (wndconfig->glRobustness)
                flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
            setEGLattrib(attribs, index, EGL_CONTEXT_FLAGS_KHR, flags);
        }
        if (wndconfig->glProfile)
        {
            int flags = 0;
            if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
                flags = EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
            else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
                flags = EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
            setEGLattrib(attribs, index, EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, flags);
        }
        if (wndconfig->glRobustness)
        {
            int strategy;
            if (wndconfig->glRobustness == GLFW_OPENGL_NO_RESET_NOTIFICATION)
                strategy = EGL_NO_RESET_NOTIFICATION_KHR;
            else if (wndconfig->glRobustness == GLFW_OPENGL_LOSE_CONTEXT_ON_RESET)
                strategy = EGL_LOSE_CONTEXT_ON_RESET_KHR;
            setEGLattrib(attribs, index, EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, strategy);
        }
    }
    else
    {
        if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
            setEGLattrib(attribs, index, EGL_CONTEXT_CLIENT_VERSION, wndconfig->glMajor);
    }
    setEGLattrib(attribs, index, EGL_NONE, EGL_NONE);
    window->EGL.context = eglCreateContext(_glfwLibrary.EGL.display,
                                           config, share, attribs);
    if (window->EGL.context == EGL_NO_CONTEXT)
    {
        // TODO: Handle all the various error codes here
        _glfwSetError(GLFW_PLATFORM_ERROR,
                      "EGL: Failed to create context");
        return GL_FALSE;
    }
    window->EGL.config = config;
    return GL_TRUE;
 }
 #undef setEGLattrib
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 //========================================================================
 // Initialize EGL
 //========================================================================
 int _glfwInitOpenGL(void)
 {
 #ifdef _GLFW_DLOPEN_LIBEGL
    int i;
    char* libEGL_names[ ] =
    {
        "libEGL.so",
        "libEGL.so.1",
        "/usr/lib/libEGL.so",
        "/usr/lib/libEGL.so.1",
        NULL
    };
    for (i = 0;  libEGL_names[i] != NULL;  i++)
    {
        _glfwLibrary.EGL.libEGL = dlopen(libEGL_names[i], RTLD_LAZY | RTLD_GLOBAL);
        if (_glfwLibrary.EGL.libEGL)
            break;
    }
    if (!_glfwLibrary.EGL.libEGL)
    {
        _glfwSetError(GLFW_PLATFORM_ERROR, "EGL: Failed to find libEGL");
        return GL_FALSE;
    }
 #endif
    _glfwLibrary.EGL.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
    if (_glfwLibrary.EGL.display == EGL_NO_DISPLAY)
    {
        _glfwSetError(GLFW_API_UNAVAILABLE,
                      "EGL: Failed to get EGL display");
        return GL_FALSE;
    }
    if (!eglInitialize(_glfwLibrary.EGL.display,
                       &_glfwLibrary.EGL.majorVersion,
                       &_glfwLibrary.EGL.minorVersion))
    {
        _glfwSetError(GLFW_API_UNAVAILABLE,
                      "EGL: Failed to initialize EGL");
        return GL_FALSE;
    }
    if (_glfwPlatformExtensionSupported("EGL_KHR_create_context"))
        _glfwLibrary.EGL.KHR_create_context = GL_TRUE;
    return GL_TRUE;
 }
 //========================================================================
 // Terminate EGL
 //========================================================================
 void _glfwTerminateOpenGL(void)
 {
 #ifdef _GLFW_DLOPEN_LIBEGL
    if (_glfwLibrary.EGL.libEGL != NULL)
    {
        dlclose(_glfwLibrary.EGL.libEGL);
        _glfwLibrary.EGL.libEGL = NULL;
    }
 #endif
    eglTerminate(_glfwLibrary.EGL.display);
 }
 //========================================================================
 // Prepare for creation of the OpenGL context
 //========================================================================
 int _glfwCreateContext(_GLFWwindow* window,
                       const _GLFWwndconfig* wndconfig,
                       const _GLFWfbconfig* fbconfig)
 {
    _GLFWfbconfig closest;
    // Choose the best available fbconfig
    {
        unsigned int fbcount;
        _GLFWfbconfig* fbconfigs;
        const _GLFWfbconfig* result;
        fbconfigs = getFBConfigs(window, wndconfig, &fbcount);
        if (!fbconfigs)
        {
            _glfwSetError(GLFW_PLATFORM_ERROR,
                          "EGL: No usable EGLFBConfigs found");
            return GL_FALSE;
        }
        result = _glfwChooseFBConfig(fbconfig, fbconfigs, fbcount);
        if (!result)
        {
            _glfwSetError(GLFW_PLATFORM_ERROR,
                          "EGL: No EGLFBConfig matched the criteria");
            free(fbconfigs);
            return GL_FALSE;
        }
        closest = *result;
        free(fbconfigs);
    }
    return createContext(window, wndconfig, closest.platformID);
 }
 //========================================================================
 // Destroy the OpenGL context
 //========================================================================
 void _glfwDestroyContext(_GLFWwindow* window)
 {
    if (window->EGL.visual)
    {
       XFree(window->EGL.visual);
       window->EGL.visual = NULL;
    }
    if (window->EGL.surface)
    {
        eglDestroySurface(_glfwLibrary.EGL.display, window->EGL.surface);
        window->EGL.surface = EGL_NO_SURFACE;
    }
    if (window->EGL.context)
    {
        eglDestroyContext(_glfwLibrary.EGL.display, window->EGL.context);
        window->EGL.context = EGL_NO_CONTEXT;
    }
 }
 //========================================================================
 // Make the OpenGL context associated with the specified window current
 //========================================================================
 void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
 {
    if (window)
    {
        if (window->EGL.surface == EGL_NO_SURFACE)
        {
            window->EGL.surface = eglCreateWindowSurface(_glfwLibrary.EGL.display,
                                                         window->EGL.config,
                                                         _GLFW_EGL_NATIVE_WINDOW,
                                                         NULL);
            if (window->EGL.surface == EGL_NO_SURFACE)
            {
                _glfwSetError(GLFW_PLATFORM_ERROR,
                              "EGL: Failed to create window surface");
            }
        }
        eglMakeCurrent(_glfwLibrary.EGL.display,
                       window->EGL.surface,
                       window->EGL.surface,
                       window->EGL.context);
    }
    else
    {
        eglMakeCurrent(_glfwLibrary.EGL.display,
                       EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    }
    _glfwCurrentWindow = window;
 }
 //========================================================================
 // Return the window object whose context is current
 //========================================================================
 _GLFWwindow* _glfwPlatformGetCurrentContext(void)
 {
    return _glfwCurrentWindow;
 }
 //========================================================================
 // Swap OpenGL buffers
 //========================================================================
 void _glfwPlatformSwapBuffers(_GLFWwindow* window)
 {
    eglSwapBuffers(_glfwLibrary.EGL.display, window->EGL.surface);
 }
 //========================================================================
 // Set double buffering swap interval
 //========================================================================
 void _glfwPlatformSwapInterval(int interval)
 {
    eglSwapInterval(_glfwLibrary.EGL.display, interval);
 }
 //========================================================================
 // Check if an OpenGL extension is available at runtime
 //========================================================================
 int _glfwPlatformExtensionSupported(const char* extension)
 {
    const char* extensions;
    extensions = eglQueryString(_glfwLibrary.EGL.display, EGL_EXTENSIONS);
    if (extensions != NULL)
    {
        if (_glfwStringInExtensionString(extension, (unsigned char*) extensions))
            return GL_TRUE;
    }
    return GL_FALSE;
 }
 //========================================================================
 // Get the function pointer to an OpenGL function
 //========================================================================
 GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
 {
    return _glfw_eglGetProcAddress(procname);
 }
--- a/src/egl_platform.h
+++ b/src/egl_platform.h
@ -0,0 +1,96 @@
 //========================================================================
 // GLFW - An OpenGL library
 // Platform:    EGL
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
 // arising from the use of this software.
 //
 // Permission is granted to anyone to use this software for any purpose,
 // including commercial applications, and to alter it and redistribute it
 // freely, subject to the following restrictions:
 //
 // 1. The origin of this software must not be misrepresented; you must not
 //    claim that you wrote the original software. If you use this software
 //    in a product, an acknowledgment in the product documentation would
 //    be appreciated but is not required.
 //
 // 2. Altered source versions must be plainly marked as such, and must not
 //    be misrepresented as being the original software.
 //
 // 3. This notice may not be removed or altered from any source
 //    distribution.
 //
 //========================================================================
 #ifndef _egl_platform_h_
 #define _egl_platform_h_
 #include <EGL/egl.h>
 // This path may need to be changed if you build GLFW using your own setup
 // We ship and use our own copy of eglext.h since GLFW uses fairly new
 // extensions and not all operating systems come with an up-to-date version
 #include "../support/GL/eglext.h"
 // Do we have support for dlopen/dlsym?
 #if defined(_GLFW_HAS_DLOPEN)
 #include <dlfcn.h>
 #endif
 // We support two different ways for getting addresses for EGL
 // extension functions: eglGetProcAddress and dlsym
 #if defined(_GLFW_HAS_EGLGETPROCADDRESS)
 #define _glfw_eglGetProcAddress(x) eglGetProcAddress(x)
 #elif defined(_GLFW_HAS_DLOPEN)
 #define _glfw_eglGetProcAddress(x) dlsym(_glfwLibrary.EGL.libEGL, x)
 #define _GLFW_DLOPEN_LIBEGL
 #else
 #error "No OpenGL entry point retrieval mechanism was enabled"
 #endif
 #define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextEGL EGL
 #define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryEGL EGL
 //========================================================================
 // GLFW platform specific types
 //========================================================================
 //------------------------------------------------------------------------
 // Platform-specific OpenGL context structure
 //------------------------------------------------------------------------
 typedef struct _GLFWcontextEGL
 {
   EGLConfig      config;
   EGLContext     context;
   EGLSurface     surface;
 #if defined(_GLFW_X11)
   XVisualInfo*   visual;
 #endif
 } _GLFWcontextEGL;
 //------------------------------------------------------------------------
 // Platform-specific library global data for EGL
 //------------------------------------------------------------------------
 typedef struct _GLFWlibraryEGL
 {
    EGLDisplay      display;
    EGLint          majorVersion, minorVersion;
    GLboolean       KHR_create_context;
 #if defined(_GLFW_DLOPEN_LIBEGL)
    void*           libEGL;  // dlopen handle for libEGL.so
 #endif
 } _GLFWlibraryEGL;
 #endif // _egl_platform_h_
--- a/src/glx_context.c
+++ b/src/glx_context.c
@ -190,6 +190,11 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
        else
            f->samples = 0;
        if (_glfwLibrary.GLX.ARB_framebuffer_sRGB)
            f->sRGB = getFBConfigAttrib(window, fbconfigs[i], GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB);
        else
            f->sRGB = GL_FALSE;
        f->platformID = (GLFWintptr) getFBConfigAttrib(window, fbconfigs[i], GLX_FBCONFIG_ID);
        (*found)++;
@ -527,6 +532,9 @@ int _glfwInitOpenGL(void)
    if (_glfwPlatformExtensionSupported("GLX_ARB_multisample"))
        _glfwLibrary.GLX.ARB_multisample = GL_TRUE;
    if (_glfwPlatformExtensionSupported("GLX_ARB_framebuffer_sRGB"))
        _glfwLibrary.GLX.ARB_framebuffer_sRGB = GL_TRUE;
    if (_glfwPlatformExtensionSupported("GLX_ARB_create_context"))
    {
        _glfwLibrary.GLX.CreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)
@ -624,16 +632,6 @@ void _glfwDestroyContext(_GLFWwindow* window)
 }
 //========================================================================
 // Return the X visual associated with the specified context
 //========================================================================
 XVisualInfo* _glfwGetContextVisual(_GLFWwindow* window)
 {
    return window->GLX.visual;
 }
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
--- a/src/glx_platform.h
+++ b/src/glx_platform.h
@ -0,0 +1,120 @@
 //========================================================================
 // GLFW - An OpenGL library
 // Platform:    X11/GLX
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
 // arising from the use of this software.
 //
 // Permission is granted to anyone to use this software for any purpose,
 // including commercial applications, and to alter it and redistribute it
 // freely, subject to the following restrictions:
 //
 // 1. The origin of this software must not be misrepresented; you must not
 //    claim that you wrote the original software. If you use this software
 //    in a product, an acknowledgment in the product documentation would
 //    be appreciated but is not required.
 //
 // 2. Altered source versions must be plainly marked as such, and must not
 //    be misrepresented as being the original software.
 //
 // 3. This notice may not be removed or altered from any source
 //    distribution.
 //
 //========================================================================
 #ifndef _x11_glx_platform_h_
 #define _x11_glx_platform_h_
 #define GLX_GLXEXT_LEGACY
 #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
 // extensions and not all operating systems come with an up-to-date version
 #include "../support/GL/glxext.h"
 // Do we have support for dlopen/dlsym?
 #if defined(_GLFW_HAS_DLOPEN)
 #include <dlfcn.h>
 #endif
 // We support four different ways for getting addresses for GL/GLX
 // extension functions: glXGetProcAddress, glXGetProcAddressARB,
 // glXGetProcAddressEXT, and dlsym
 #if defined(_GLFW_HAS_GLXGETPROCADDRESSARB)
 #define _glfw_glXGetProcAddress(x) glXGetProcAddressARB(x)
 #elif defined(_GLFW_HAS_GLXGETPROCADDRESS)
 #define _glfw_glXGetProcAddress(x) glXGetProcAddress(x)
 #elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
 #define _glfw_glXGetProcAddress(x) glXGetProcAddressEXT(x)
 #elif defined(_GLFW_HAS_DLOPEN)
 #define _glfw_glXGetProcAddress(x) dlsym(_glfwLibrary.GLX.libGL, x)
 #define _GLFW_DLOPEN_LIBGL
 #else
 #error "No OpenGL entry point retrieval mechanism was enabled"
 #endif
 #define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextGLX GLX
 #define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryGLX GLX
 #ifndef GLX_MESA_swap_control
 typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
 #endif
 //========================================================================
 // GLFW platform specific types
 //========================================================================
 //------------------------------------------------------------------------
 // Platform-specific OpenGL context structure
 //------------------------------------------------------------------------
 typedef struct _GLFWcontextGLX
 {
    GLXContext    context;           // OpenGL rendering context
    XVisualInfo*  visual;            // Visual for selected GLXFBConfig
 } _GLFWcontextGLX;
 //------------------------------------------------------------------------
 // Platform-specific library global data for GLX
 //------------------------------------------------------------------------
 typedef struct _GLFWlibraryGLX
 {
    // Server-side GLX version
    int             majorVersion, minorVersion;
    // GLX extensions
    PFNGLXSWAPINTERVALSGIPROC             SwapIntervalSGI;
    PFNGLXSWAPINTERVALEXTPROC             SwapIntervalEXT;
    PFNGLXSWAPINTERVALMESAPROC            SwapIntervalMESA;
    PFNGLXGETFBCONFIGATTRIBSGIXPROC       GetFBConfigAttribSGIX;
    PFNGLXCHOOSEFBCONFIGSGIXPROC          ChooseFBConfigSGIX;
    PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC CreateContextWithConfigSGIX;
    PFNGLXGETVISUALFROMFBCONFIGSGIXPROC   GetVisualFromFBConfigSGIX;
    PFNGLXCREATECONTEXTATTRIBSARBPROC     CreateContextAttribsARB;
    GLboolean   SGIX_fbconfig;
    GLboolean   SGI_swap_control;
    GLboolean   EXT_swap_control;
    GLboolean   MESA_swap_control;
    GLboolean   ARB_multisample;
    GLboolean   ARB_framebuffer_sRGB;
    GLboolean   ARB_create_context;
    GLboolean   ARB_create_context_profile;
    GLboolean   ARB_create_context_robustness;
    GLboolean   EXT_create_context_es2_profile;
 #if defined(_GLFW_DLOPEN_LIBGL)
    void*           libGL;  // dlopen handle for libGL.so
 #endif
 } _GLFWlibraryGLX;
 #endif // _x11_glx_platform_h_
--- a/src/internal.h
+++ b/src/internal.h
@ -66,14 +66,14 @@ typedef struct _GLFWmonitor     _GLFWmonitor;
 // extensions and not all operating systems come with an up-to-date version
 #include "../support/GL/glext.h"
-#if defined(_GLFW_COCOA_NSGL)
+#if defined(_GLFW_COCOA)
 #include "cocoa_platform.h"
-#elif defined(_GLFW_WIN32_WGL)
+#elif defined(_GLFW_WIN32)
 #include "win32_platform.h"
-#elif defined(_GLFW_X11_GLX)
+#elif defined(_GLFW_X11)
 #include "x11_platform.h"
 #else
- #error "No supported platform selected"
+ #error "No supported window creation API selected"
 #endif
@ -101,6 +101,7 @@ struct _GLFWhints
    GLboolean   resizable;
    GLboolean   visible;
    int         samples;
    GLboolean   sRGB;
    int         clientAPI;
    int         glMajor;
    int         glMinor;
@ -161,6 +162,7 @@ struct _GLFWfbconfig
    int         auxBuffers;
    GLboolean   stereo;
    int         samples;
    GLboolean   sRGB;
    GLFWintptr  platformID;
 };
@ -201,6 +203,7 @@ struct _GLFWwindow
    int       glRobustness;
    PFNGLGETSTRINGIPROC GetStringi;
    GLFWwindowposfun     windowPosCallback;
    GLFWwindowsizefun    windowSizeCallback;
    GLFWwindowclosefun   windowCloseCallback;
    GLFWwindowrefreshfun windowRefreshCallback;
@ -314,6 +317,7 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window);
 int _glfwPlatformGetJoystickParam(int joy, int param);
 int _glfwPlatformGetJoystickAxes(int joy, float* axes, int numaxes);
 int _glfwPlatformGetJoystickButtons(int joy, unsigned char* buttons, int numbuttons);
 const char* _glfwPlatformGetJoystickName(int joy);
 // Time input
 double _glfwPlatformGetTime(void);
--- a/src/joystick.c
+++ b/src/joystick.c
@ -126,3 +126,25 @@ GLFWAPI int glfwGetJoystickButtons(int joy,
    return _glfwPlatformGetJoystickButtons(joy, buttons, numbuttons);
 }
 //========================================================================
 // Get joystick name
 //========================================================================
 GLFWAPI const char* glfwGetJoystickName(int joy)
 {
    if (!_glfwInitialized)
    {
        _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
        return NULL;
    }
    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
    {
        _glfwSetError(GLFW_INVALID_ENUM, NULL);
        return NULL;
    }
    return _glfwPlatformGetJoystickName(joy);
 }
--- a/src/nsgl_context.m
+++ b/src/nsgl_context.m
--- a/src/nsgl_platform.h
+++ b/src/nsgl_platform.h
@ -0,0 +1,62 @@
 //========================================================================
 // GLFW - An OpenGL library
 // Platform:    NSOpenGL
 // API Version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
 // arising from the use of this software.
 //
 // Permission is granted to anyone to use this software for any purpose,
 // including commercial applications, and to alter it and redistribute it
 // freely, subject to the following restrictions:
 //
 // 1. The origin of this software must not be misrepresented; you must not
 //    claim that you wrote the original software. If you use this software
 //    in a product, an acknowledgment in the product documentation would
 //    be appreciated but is not required.
 //
 // 2. Altered source versions must be plainly marked as such, and must not
 //    be misrepresented as being the original software.
 //
 // 3. This notice may not be removed or altered from any source
 //    distribution.
 //
 //========================================================================
 #ifndef _nsgl_platform_h_
 #define _nsgl_platform_h_
 #define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextNSGL NSGL
 #define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryNSGL NSGL
 //========================================================================
 // GLFW platform specific types
 //========================================================================
 //------------------------------------------------------------------------
 // Platform-specific OpenGL context structure
 //------------------------------------------------------------------------
 typedef struct _GLFWcontextNSGL
 {
    id           pixelFormat;
    id	         context;
 } _GLFWcontextNSGL;
 //------------------------------------------------------------------------
 // Platform-specific library global data for NSGL
 //------------------------------------------------------------------------
 typedef struct _GLFWlibraryNSGL
 {
    // dlopen handle for dynamically loading OpenGL extension entry points
    void*            framework;
 } _GLFWlibraryNSGL;
 #endif // _nsgl_platform_h_
--- a/src/win32_opengl.c
+++ b/src/win32_opengl.c
@ -72,6 +72,7 @@ static void initWGLExtensions(_GLFWwindow* window)
    // This needs to include every extension used below except for
    // WGL_ARB_extensions_string and WGL_EXT_extensions_string
    window->WGL.ARB_multisample = GL_FALSE;
    window->WGL.ARB_framebuffer_sRGB = GL_FALSE;
    window->WGL.ARB_create_context = GL_FALSE;
    window->WGL.ARB_create_context_profile = GL_FALSE;
    window->WGL.EXT_create_context_es2_profile = GL_FALSE;
@ -92,6 +93,9 @@ static void initWGLExtensions(_GLFWwindow* window)
    if (_glfwPlatformExtensionSupported("WGL_ARB_multisample"))
        window->WGL.ARB_multisample = GL_TRUE;
    if (_glfwPlatformExtensionSupported("WGL_ARB_framebuffer_sRGB"))
        window->WGL.ARB_framebuffer_sRGB = GL_TRUE;
    if (_glfwPlatformExtensionSupported("WGL_ARB_create_context"))
    {
        window->WGL.CreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)
@ -246,6 +250,11 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
                f->samples = getPixelFormatAttrib(window, i, WGL_SAMPLES_ARB);
            else
                f->samples = 0;
            if (window->WGL.ARB_framebuffer_sRGB)
                f->sRGB = getPixelFormatAttrib(window, i, WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB);
            else
                f->sRGB = GL_FALSE;
        }
        else
        {
@ -293,6 +302,9 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
            // PFD pixel formats do not support FSAA
            f->samples = 0;
            // PFD pixel formats do not support sRGB
            f->sRGB = GL_FALSE;
        }
        f->platformID = i;
--- a/src/wgl_platform.h
+++ b/src/wgl_platform.h
@ -0,0 +1,84 @@
 //========================================================================
 // GLFW - An OpenGL library
 // Platform:    WGL
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
 // arising from the use of this software.
 //
 // Permission is granted to anyone to use this software for any purpose,
 // including commercial applications, and to alter it and redistribute it
 // freely, subject to the following restrictions:
 //
 // 1. The origin of this software must not be misrepresented; you must not
 //    claim that you wrote the original software. If you use this software
 //    in a product, an acknowledgment in the product documentation would
 //    be appreciated but is not required.
 //
 // 2. Altered source versions must be plainly marked as such, and must not
 //    be misrepresented as being the original software.
 //
 // 3. This notice may not be removed or altered from any source
 //    distribution.
 //
 //========================================================================
 #ifndef _wgl_platform_h_
 #define _wgl_platform_h_
 // This path may need to be changed if you build GLFW using your own setup
 // We ship and use our own copy of wglext.h since GLFW uses fairly new
 // extensions and not all operating systems come with an up-to-date version
 #include "../support/GL/wglext.h"
 #define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextWGL WGL
 #define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryWGL WGL
 //========================================================================
 // GLFW platform specific types
 //========================================================================
 //------------------------------------------------------------------------
 // Platform-specific OpenGL context structure
 //------------------------------------------------------------------------
 typedef struct _GLFWcontextWGL
 {
    // Platform specific window resources
    HDC       DC;              // Private GDI device context
    HGLRC     context;         // Permanent rendering context
    // Platform specific extensions (context specific)
    PFNWGLSWAPINTERVALEXTPROC           SwapIntervalEXT;
    PFNWGLGETPIXELFORMATATTRIBIVARBPROC GetPixelFormatAttribivARB;
    PFNWGLGETEXTENSIONSSTRINGEXTPROC    GetExtensionsStringEXT;
    PFNWGLGETEXTENSIONSSTRINGARBPROC    GetExtensionsStringARB;
    PFNWGLCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
    GLboolean                           EXT_swap_control;
    GLboolean                           ARB_multisample;
    GLboolean                           ARB_framebuffer_sRGB;
    GLboolean                           ARB_pixel_format;
    GLboolean                           ARB_create_context;
    GLboolean                           ARB_create_context_profile;
    GLboolean                           EXT_create_context_es2_profile;
    GLboolean                           ARB_create_context_robustness;
 } _GLFWcontextWGL;
 //------------------------------------------------------------------------
 // Platform-specific library global data for WGL
 //------------------------------------------------------------------------
 typedef struct _GLFWlibraryWGL
 {
    int dummy;
 } _GLFWlibraryWGL;
 #endif // _wgl_platform_h_
--- a/src/win32_init.c
+++ b/src/win32_init.c
@ -232,6 +232,11 @@ int _glfwPlatformTerminate(void)
 const char* _glfwPlatformGetVersionString(void)
 {
    const char* version = _GLFW_VERSION_FULL
 #if defined(_GLFW_WGL)
        " WGL"
 #elif defined(_GLFW_EGL)
        " EGL"
 #endif
 #if defined(__MINGW32__)
        " MinGW"
 #elif defined(_MSC_VER)
--- a/src/win32_joystick.c
+++ b/src/win32_joystick.c
@ -199,15 +199,43 @@ int _glfwPlatformGetJoystickButtons(int joy, unsigned char* buttons,
    if (hats > 0)
    {
-        int j;
+        int j, value = ji.dwPOV / 100 / 45;
-        int value = ji.dwPOV / 100 / 45;
+
-        if (value < 0 || value > 8) value = 8;
+        if (value < 0 || value > 8)
            value = 8;
        for (j = 0; j < 4 && button < numbuttons; j++)
        {
-            buttons[button++] = directions[value] & (1 << j) ? GLFW_PRESS : GLFW_RELEASE;
+            if (directions[value] & (1 << j))
                buttons[button] = GLFW_PRESS;
            else
                buttons[button] = GLFW_RELEASE;
            button++;
        }
    }
    return button;
 }
 //========================================================================
 // Get joystick name
 //========================================================================
 const char* _glfwPlatformGetJoystickName(int joy)
 {
    JOYCAPS jc;
    const int i = joy - GLFW_JOYSTICK_1;
    if (!isJoystickPresent(joy))
        return NULL;
    _glfw_joyGetDevCaps(i, &jc, sizeof(JOYCAPS));
    free(_glfwLibrary.Win32.joyNames[i]);
    _glfwLibrary.Win32.joyNames[i] = _glfwCreateUTF8FromWideString(jc.szPname);
    return _glfwLibrary.Win32.joyNames[i];
 }
--- a/src/win32_platform.h
+++ b/src/win32_platform.h
@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    Win32/WGL
+// Platform:    Win32
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@ -28,8 +28,8 @@
 //
 //========================================================================
-#ifndef _platform_h_
+#ifndef _win32_platform_h_
-#define _platform_h_
+#define _win32_platform_h_
 // We don't need all the fancy stuff
@ -64,11 +64,6 @@
 #include <mmsystem.h>
 #include <dbt.h>
 // This path may need to be changed if you build GLFW using your own setup
 // We ship and use our own copy of wglext.h since GLFW uses fairly new
 // extensions and not all operating systems come with an up-to-date version
 #include "../support/GL/wglext.h"
 //========================================================================
 // Hack: Define things that some windows.h variants don't
@ -111,13 +106,19 @@ typedef DWORD (WINAPI * TIMEGETTIME_T) (void);
 #define _GLFW_WNDCLASSNAME L"GLFW30"
-#define _GLFW_PLATFORM_WINDOW_STATE  _GLFWwindowWin32 Win32
+#if defined(_GLFW_WGL)
-#define _GLFW_PLATFORM_CONTEXT_STATE _GLFWcontextWGL WGL
+ #include "wgl_platform.h"
-
+#elif defined(_GLFW_EGL)
-#define _GLFW_PLATFORM_MONITOR_STATE _GLFWmonitorWin32 Win32
+ #define _GLFW_EGL_NATIVE_WINDOW  window->Win32.handle
 #define _GLFW_EGL_NATIVE_DISPLAY NULL
 #include "egl_platform.h"
 #else
 #error "No supported context creation API selected"
 #endif
 #define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowWin32  Win32
 #define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryWin32 Win32
-#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryWGL WGL
+#define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorWin32 Win32
 //========================================================================
@ -130,31 +131,6 @@ typedef DWORD (WINAPI * TIMEGETTIME_T) (void);
 typedef INT_PTR GLFWintptr;
 //------------------------------------------------------------------------
 // Platform-specific OpenGL context structure
 //------------------------------------------------------------------------
 typedef struct _GLFWcontextWGL
 {
    // Platform specific window resources
    HDC       DC;              // Private GDI device context
    HGLRC     context;         // Permanent rendering context
    // Platform specific extensions (context specific)
    PFNWGLSWAPINTERVALEXTPROC           SwapIntervalEXT;
    PFNWGLGETPIXELFORMATATTRIBIVARBPROC GetPixelFormatAttribivARB;
    PFNWGLGETEXTENSIONSSTRINGEXTPROC    GetExtensionsStringEXT;
    PFNWGLGETEXTENSIONSSTRINGARBPROC    GetExtensionsStringARB;
    PFNWGLCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
    GLboolean                           EXT_swap_control;
    GLboolean                           ARB_multisample;
    GLboolean                           ARB_pixel_format;
    GLboolean                           ARB_create_context;
    GLboolean                           ARB_create_context_profile;
    GLboolean                           EXT_create_context_es2_profile;
    GLboolean                           ARB_create_context_robustness;
 } _GLFWcontextWGL;
 //------------------------------------------------------------------------
 // Platform-specific window structure
 //------------------------------------------------------------------------
@ -211,6 +187,8 @@ typedef struct _GLFWlibraryWin32
    } winmm;
 #endif // _GLFW_NO_DLOAD_WINMM
    char*                     joyNames[GLFW_JOYSTICK_LAST + 1];
 } _GLFWlibraryWin32;
@ -224,16 +202,6 @@ typedef struct _GLFWmonitorWin32
 } _GLFWmonitorWin32;
 //------------------------------------------------------------------------
 // Platform-specific library global data for WGL
 //------------------------------------------------------------------------
 typedef struct _GLFWlibraryWGL
 {
    int dummy;
 } _GLFWlibraryWGL;
 //========================================================================
 // Prototypes for platform specific internal functions
 //========================================================================
@ -258,4 +226,4 @@ void _glfwSetVideoMode(int* width, int* height,
 void _glfwRestoreVideoMode(void);
-#endif // _platform_h_
+#endif // _win32_platform_h_
--- a/src/window.c
+++ b/src/window.c
@ -119,8 +119,14 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused)
 void _glfwInputWindowPos(_GLFWwindow* window, int x, int y)
 {
    if (window->positionX == x && window->positionY == y)
        return;
    window->positionX = x;
    window->positionY = y;
    if (window->windowPosCallback)
        window->windowPosCallback(window, x, y);
 }
@ -232,6 +238,7 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
    fbconfig.auxBuffers     = Max(_glfwLibrary.hints.auxBuffers, 0);
    fbconfig.stereo         = _glfwLibrary.hints.stereo ? GL_TRUE : GL_FALSE;
    fbconfig.samples        = Max(_glfwLibrary.hints.samples, 0);
    fbconfig.sRGB           = _glfwLibrary.hints.sRGB ? GL_TRUE : GL_FALSE;
    // Set up desired window config
    wndconfig.title          = title;
@ -434,6 +441,9 @@ GLFWAPI void glfwWindowHint(int target, int hint)
        case GLFW_FSAA_SAMPLES:
            _glfwLibrary.hints.samples = hint;
            break;
        case GLFW_SRGB_CAPABLE:
            _glfwLibrary.hints.sRGB = hint;
            break;
        case GLFW_CLIENT_API:
            _glfwLibrary.hints.clientAPI = hint;
            break;
@ -776,6 +786,24 @@ GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow handle)
 }
 //========================================================================
 // Set callback function for window position changes
 //========================================================================
 GLFWAPI void glfwSetWindowPosCallback(GLFWwindow handle, GLFWwindowposfun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
    if (!_glfwInitialized)
    {
        _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
        return;
    }
    window->windowPosCallback = cbfun;
 }
 //========================================================================
 // Set callback function for window size changes
 //========================================================================
--- a/src/x11_init.c
+++ b/src/x11_init.c
@ -693,6 +693,11 @@ int _glfwPlatformTerminate(void)
 const char* _glfwPlatformGetVersionString(void)
 {
    const char* version = _GLFW_VERSION_FULL
 #if defined(_GLFW_GLX)
        " GLX"
 #elif defined(_GLFW_EGL)
        " EGL"
 #endif
 #if defined(_GLFW_HAS_XRANDR)
        " XRandR"
 #endif
@ -711,8 +716,12 @@ const char* _glfwPlatformGetVersionString(void)
        " glXGetProcAddressARB"
 #elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
        " glXGetProcAddressEXT"
 #elif defined(_GLFW_HAS_EGLGETPROCADDRESS)
        " eglGetProcAddress"
 #elif defined(_GLFW_DLOPEN_LIBGL)
        " dlsym(libGL)"
 #elif defined(_GLFW_DLOPEN_LIBEGL)
        " dlsym(libEGL)"
 #else
        " no-extension-support"
 #endif
--- a/src/x11_joystick.c
+++ b/src/x11_joystick.c
@ -41,6 +41,7 @@
 #include <dirent.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #endif // __linux__
@ -52,6 +53,7 @@ static int openJoystickDevice(int joy, const char* path)
 {
 #ifdef __linux__
    char numAxes, numButtons;
    char name[256];
    int fd, version;
    fd = open(path, O_RDONLY | O_NONBLOCK);
@ -69,6 +71,11 @@ static int openJoystickDevice(int joy, const char* path)
        return GL_FALSE;
    }
    if (ioctl(fd, JSIOCGNAME(sizeof(name)), name) < 0)
        strncpy(name, "Unknown", sizeof(name));
    _glfwLibrary.X11.joystick[joy].name = strdup(name);
    ioctl(fd, JSIOCGAXES, &numAxes);
    _glfwLibrary.X11.joystick[joy].numAxes = (int) numAxes;
@ -237,6 +244,7 @@ void _glfwTerminateJoysticks(void)
            close(_glfwLibrary.X11.joystick[i].fd);
            free(_glfwLibrary.X11.joystick[i].axis);
            free(_glfwLibrary.X11.joystick[i].button);
            free(_glfwLibrary.X11.joystick[i].name);
            _glfwLibrary.X11.joystick[i].present = GL_FALSE;
        }
@ -325,3 +333,16 @@ int _glfwPlatformGetJoystickButtons(int joy, unsigned char* buttons,
    return numButtons;
 }
 //========================================================================
 // Get joystick name
 //========================================================================
 const char* _glfwPlatformGetJoystickName(int joy)
 {
    if (!_glfwLibrary.X11.joystick[joy].present)
        return NULL;
    return _glfwLibrary.X11.joystick[joy].name;
 }
--- a/src/x11_monitor.c
+++ b/src/x11_monitor.c
@ -434,11 +434,10 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
        return 0;
    }
    // Build array of available RGB channel depths
    rgbs = (int*) malloc(sizeof(int) * visualCount);
    rgbCount = 0;
 #if defined(_GLFW_GLX)
    for (i = 0;  i < visualCount;  i++)
    {
        int gl, rgba, rgb, r, g, b;
@ -473,6 +472,7 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
    }
    XFree(visuals);
 #endif
    // Build all permutations of channel depths and resolutions
--- a/src/x11_platform.h
+++ b/src/x11_platform.h
@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    X11/GLX
+// Platform:    X11
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@ -38,15 +38,7 @@
 #include <X11/keysym.h>
 #include <X11/Xatom.h>
-#define GLX_GLXEXT_LEGACY
+// With XFree86, we can use the XF86VidMode extension
 #include <GL/glx.h>
 // This path may need to be changed if you build GLFW using your own setup
 // 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"
 // The XF86VidMode extension provides mode setting and gamma control
 #if defined(_GLFW_HAS_XF86VIDMODE)
 #include <X11/extensions/xf86vmode.h>
 #endif
@ -56,39 +48,26 @@
 #include <X11/extensions/Xrandr.h>
 #endif
 // dlopen is used as a fallback function retrieval mechanism
 #if defined(_GLFW_HAS_DLOPEN)
 #include <dlfcn.h>
 #endif
 // The Xkb extension provides improved keyboard support
 #if defined(_GLFW_HAS_XKB)
 #include <X11/XKBlib.h>
 #endif
-// GLFW supports four different ways for getting addresses for GL/GLX
+#if defined(_GLFW_GLX)
-// extension functions: glXGetProcAddress, glXGetProcAddressARB,
+ #define _GLFW_X11_CONTEXT_VISUAL window->GLX.visual
-// glXGetProcAddressEXT, and dlsym
+ #include "glx_platform.h"
-#if defined(_GLFW_HAS_GLXGETPROCADDRESSARB)
+#elif defined(_GLFW_EGL)
- #define _glfw_glXGetProcAddress(x) glXGetProcAddressARB(x)
+ #define _GLFW_X11_CONTEXT_VISUAL window->EGL.visual
-#elif defined(_GLFW_HAS_GLXGETPROCADDRESS)
+ #define _GLFW_EGL_NATIVE_WINDOW  window->X11.handle
- #define _glfw_glXGetProcAddress(x) glXGetProcAddress(x)
+ #define _GLFW_EGL_NATIVE_DISPLAY _glfwLibrary.X11.display
-#elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
+ #include "egl_platform.h"
 #define _glfw_glXGetProcAddress(x) glXGetProcAddressEXT(x)
 #elif defined(_GLFW_HAS_DLOPEN)
 #define _glfw_glXGetProcAddress(x) dlsym(_glfwLibrary.GLX.libGL, x)
 #define _GLFW_DLOPEN_LIBGL
 #else
- #error "No OpenGL entry point retrieval mechanism was enabled"
+ #error "No supported context creation API selected"
 #endif
-#define _GLFW_PLATFORM_WINDOW_STATE  _GLFWwindowX11 X11
+#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowX11  X11
 #define _GLFW_PLATFORM_CONTEXT_STATE _GLFWcontextGLX GLX
 #define _GLFW_PLATFORM_MONITOR_STATE _GLFWmonitorX11 X11
 #define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryX11 X11
-#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryGLX GLX
+#define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorX11 X11
 // Clipboard format atom indices
 #define _GLFW_CLIPBOARD_FORMAT_UTF8     0
@ -101,10 +80,6 @@
 #define _GLFW_CONVERSION_SUCCEEDED      1
 #define _GLFW_CONVERSION_FAILED         2
 #ifndef GLX_MESA_swap_control
 typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
 #endif
 //========================================================================
 // GLFW platform specific types
@ -116,17 +91,6 @@ typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
 typedef intptr_t GLFWintptr;
 //------------------------------------------------------------------------
 // Platform-specific OpenGL context structure
 //------------------------------------------------------------------------
 typedef struct _GLFWcontextGLX
 {
    GLXContext    context;           // OpenGL rendering context
    XVisualInfo*  visual;            // Visual for selected GLXFBConfig
 } _GLFWcontextGLX;
 //------------------------------------------------------------------------
 // Platform-specific window structure
 //------------------------------------------------------------------------
@ -248,46 +212,14 @@ typedef struct _GLFWlibraryX11
        int             numButtons;
        float*          axis;
        unsigned char*  button;
        char*           name;
    } joystick[GLFW_JOYSTICK_LAST + 1];
 } _GLFWlibraryX11;
 //------------------------------------------------------------------------
-// Platform-specific library global data for GLX
+// Platform-specific monitor structure
 //------------------------------------------------------------------------
 typedef struct _GLFWlibraryGLX
 {
    // Server-side GLX version
    int             majorVersion, minorVersion;
    // GLX extensions
    PFNGLXSWAPINTERVALSGIPROC             SwapIntervalSGI;
    PFNGLXSWAPINTERVALEXTPROC             SwapIntervalEXT;
    PFNGLXSWAPINTERVALMESAPROC            SwapIntervalMESA;
    PFNGLXGETFBCONFIGATTRIBSGIXPROC       GetFBConfigAttribSGIX;
    PFNGLXCHOOSEFBCONFIGSGIXPROC          ChooseFBConfigSGIX;
    PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC CreateContextWithConfigSGIX;
    PFNGLXGETVISUALFROMFBCONFIGSGIXPROC   GetVisualFromFBConfigSGIX;
    PFNGLXCREATECONTEXTATTRIBSARBPROC     CreateContextAttribsARB;
    GLboolean   SGIX_fbconfig;
    GLboolean   SGI_swap_control;
    GLboolean   EXT_swap_control;
    GLboolean   MESA_swap_control;
    GLboolean   ARB_multisample;
    GLboolean   ARB_create_context;
    GLboolean   ARB_create_context_profile;
    GLboolean   ARB_create_context_robustness;
    GLboolean   EXT_create_context_es2_profile;
 #if defined(_GLFW_DLOPEN_LIBGL)
    void*           libGL;  // dlopen handle for libGL.so
 #endif
 } _GLFWlibraryGLX;
 //------------------------------------------------------------------------
 // Platform-specific window structure
 //------------------------------------------------------------------------
 typedef struct _GLFWmonitorX11
 {
@ -318,7 +250,6 @@ int _glfwCreateContext(_GLFWwindow* window,
                       const _GLFWwndconfig* wndconfig,
                       const _GLFWfbconfig* fbconfig);
 void _glfwDestroyContext(_GLFWwindow* window);
 XVisualInfo* _glfwGetContextVisual(_GLFWwindow* window);
 // Fullscreen support
 int  _glfwGetClosestVideoMode(int* width, int* height, int* rate);
--- a/src/x11_window.c
+++ b/src/x11_window.c
@ -1,6 +1,6 @@
 //========================================================================
 // GLFW - An OpenGL library
-// Platform:    X11/GLX
+// Platform:    X11
 // API version: 3.0
 // WWW:         http://www.glfw.org/
 //------------------------------------------------------------------------
@ -85,7 +85,7 @@ static GLboolean createWindow(_GLFWwindow* window,
 {
    unsigned long wamask;
    XSetWindowAttributes wa;
-    XVisualInfo* visual = _glfwGetContextVisual(window);
+    XVisualInfo* visual = _GLFW_X11_CONTEXT_VISUAL;
    // Every window needs a colormap
    // Create one based on the visual used by the current context
--- a/support/GL/eglext.h
+++ b/support/GL/eglext.h
@ -0,0 +1,444 @@
 #ifndef __eglext_h_
 #define __eglext_h_
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2007-2012 The Khronos Group Inc.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a
 ** copy of this software and/or associated documentation files (the
 ** "Materials"), to deal in the Materials without restriction, including
 ** without limitation the rights to use, copy, modify, merge, publish,
 ** distribute, sublicense, and/or sell copies of the Materials, and to
 ** permit persons to whom the Materials are furnished to do so, subject to
 ** the following conditions:
 **
 ** The above copyright notice and this permission notice shall be included
 ** in all copies or substantial portions of the Materials.
 **
 ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 */
 #include <EGL/eglplatform.h>
 /*************************************************************/
 /* Header file version number */
 /* Current version at http://www.khronos.org/registry/egl/ */
 /* $Revision: 18175 $ on $Date: 2012-06-13 11:26:12 -0700 (Wed, 13 Jun 2012) $ */
 #define EGL_EGLEXT_VERSION 13
 #ifndef EGL_KHR_config_attribs
 #define EGL_KHR_config_attribs 1
 #define EGL_CONFORMANT_KHR			0x3042	/* EGLConfig attribute */
 #define EGL_VG_COLORSPACE_LINEAR_BIT_KHR	0x0020	/* EGL_SURFACE_TYPE bitfield */
 #define EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR		0x0040	/* EGL_SURFACE_TYPE bitfield */
 #endif
 #ifndef EGL_KHR_lock_surface
 #define EGL_KHR_lock_surface 1
 #define EGL_READ_SURFACE_BIT_KHR		0x0001	/* EGL_LOCK_USAGE_HINT_KHR bitfield */
 #define EGL_WRITE_SURFACE_BIT_KHR		0x0002	/* EGL_LOCK_USAGE_HINT_KHR bitfield */
 #define EGL_LOCK_SURFACE_BIT_KHR		0x0080	/* EGL_SURFACE_TYPE bitfield */
 #define EGL_OPTIMAL_FORMAT_BIT_KHR		0x0100	/* EGL_SURFACE_TYPE bitfield */
 #define EGL_MATCH_FORMAT_KHR			0x3043	/* EGLConfig attribute */
 #define EGL_FORMAT_RGB_565_EXACT_KHR		0x30C0	/* EGL_MATCH_FORMAT_KHR value */
 #define EGL_FORMAT_RGB_565_KHR			0x30C1	/* EGL_MATCH_FORMAT_KHR value */
 #define EGL_FORMAT_RGBA_8888_EXACT_KHR		0x30C2	/* EGL_MATCH_FORMAT_KHR value */
 #define EGL_FORMAT_RGBA_8888_KHR		0x30C3	/* EGL_MATCH_FORMAT_KHR value */
 #define EGL_MAP_PRESERVE_PIXELS_KHR		0x30C4	/* eglLockSurfaceKHR attribute */
 #define EGL_LOCK_USAGE_HINT_KHR			0x30C5	/* eglLockSurfaceKHR attribute */
 #define EGL_BITMAP_POINTER_KHR			0x30C6	/* eglQuerySurface attribute */
 #define EGL_BITMAP_PITCH_KHR			0x30C7	/* eglQuerySurface attribute */
 #define EGL_BITMAP_ORIGIN_KHR			0x30C8	/* eglQuerySurface attribute */
 #define EGL_BITMAP_PIXEL_RED_OFFSET_KHR		0x30C9	/* eglQuerySurface attribute */
 #define EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR	0x30CA	/* eglQuerySurface attribute */
 #define EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR	0x30CB	/* eglQuerySurface attribute */
 #define EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR	0x30CC	/* eglQuerySurface attribute */
 #define EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR	0x30CD	/* eglQuerySurface attribute */
 #define EGL_LOWER_LEFT_KHR			0x30CE	/* EGL_BITMAP_ORIGIN_KHR value */
 #define EGL_UPPER_LEFT_KHR			0x30CF	/* EGL_BITMAP_ORIGIN_KHR value */
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglLockSurfaceKHR (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglUnlockSurfaceKHR (EGLDisplay display, EGLSurface surface);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface);
 #endif
 #ifndef EGL_KHR_image
 #define EGL_KHR_image 1
 #define EGL_NATIVE_PIXMAP_KHR			0x30B0	/* eglCreateImageKHR target */
 typedef void *EGLImageKHR;
 #define EGL_NO_IMAGE_KHR			((EGLImageKHR)0)
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR image);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEIMAGEKHRPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYIMAGEKHRPROC) (EGLDisplay dpy, EGLImageKHR image);
 #endif
 #ifndef EGL_KHR_vg_parent_image
 #define EGL_KHR_vg_parent_image 1
 #define EGL_VG_PARENT_IMAGE_KHR			0x30BA	/* eglCreateImageKHR target */
 #endif
 #ifndef EGL_KHR_gl_texture_2D_image
 #define EGL_KHR_gl_texture_2D_image 1
 #define EGL_GL_TEXTURE_2D_KHR			0x30B1	/* eglCreateImageKHR target */
 #define EGL_GL_TEXTURE_LEVEL_KHR		0x30BC	/* eglCreateImageKHR attribute */
 #endif
 #ifndef EGL_KHR_gl_texture_cubemap_image
 #define EGL_KHR_gl_texture_cubemap_image 1
 #define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR	0x30B3	/* eglCreateImageKHR target */
 #define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR	0x30B4	/* eglCreateImageKHR target */
 #define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR	0x30B5	/* eglCreateImageKHR target */
 #define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR	0x30B6	/* eglCreateImageKHR target */
 #define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR	0x30B7	/* eglCreateImageKHR target */
 #define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR	0x30B8	/* eglCreateImageKHR target */
 #endif
 #ifndef EGL_KHR_gl_texture_3D_image
 #define EGL_KHR_gl_texture_3D_image 1
 #define EGL_GL_TEXTURE_3D_KHR			0x30B2	/* eglCreateImageKHR target */
 #define EGL_GL_TEXTURE_ZOFFSET_KHR		0x30BD	/* eglCreateImageKHR attribute */
 #endif
 #ifndef EGL_KHR_gl_renderbuffer_image
 #define EGL_KHR_gl_renderbuffer_image 1
 #define EGL_GL_RENDERBUFFER_KHR			0x30B9	/* eglCreateImageKHR target */
 #endif
 #if KHRONOS_SUPPORT_INT64   /* EGLTimeKHR requires 64-bit uint support */
 #ifndef EGL_KHR_reusable_sync
 #define EGL_KHR_reusable_sync 1
 typedef void* EGLSyncKHR;
 typedef khronos_utime_nanoseconds_t EGLTimeKHR;
 #define EGL_SYNC_STATUS_KHR			0x30F1
 #define EGL_SIGNALED_KHR			0x30F2
 #define EGL_UNSIGNALED_KHR			0x30F3
 #define EGL_TIMEOUT_EXPIRED_KHR			0x30F5
 #define EGL_CONDITION_SATISFIED_KHR		0x30F6
 #define EGL_SYNC_TYPE_KHR			0x30F7
 #define EGL_SYNC_REUSABLE_KHR			0x30FA
 #define EGL_SYNC_FLUSH_COMMANDS_BIT_KHR		0x0001	/* eglClientWaitSyncKHR <flags> bitfield */
 #define EGL_FOREVER_KHR				0xFFFFFFFFFFFFFFFFull
 #define EGL_NO_SYNC_KHR				((EGLSyncKHR)0)
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync);
 EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
 EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
 EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLSyncKHR (EGLAPIENTRYP PFNEGLCREATESYNCKHRPROC) (EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync);
 typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
 #endif
 #endif
 #ifndef EGL_KHR_image_base
 #define EGL_KHR_image_base 1
 /* Most interfaces defined by EGL_KHR_image_pixmap above */
 #define EGL_IMAGE_PRESERVED_KHR			0x30D2	/* eglCreateImageKHR attribute */
 #endif
 #ifndef EGL_KHR_image_pixmap
 #define EGL_KHR_image_pixmap 1
 /* Interfaces defined by EGL_KHR_image above */
 #endif
 #ifndef EGL_IMG_context_priority
 #define EGL_IMG_context_priority 1
 #define EGL_CONTEXT_PRIORITY_LEVEL_IMG		0x3100
 #define EGL_CONTEXT_PRIORITY_HIGH_IMG		0x3101
 #define EGL_CONTEXT_PRIORITY_MEDIUM_IMG		0x3102
 #define EGL_CONTEXT_PRIORITY_LOW_IMG		0x3103
 #endif
 #ifndef EGL_KHR_lock_surface2
 #define EGL_KHR_lock_surface2 1
 #define EGL_BITMAP_PIXEL_SIZE_KHR		0x3110
 #endif
 #ifndef EGL_NV_coverage_sample
 #define EGL_NV_coverage_sample 1
 #define EGL_COVERAGE_BUFFERS_NV			0x30E0
 #define EGL_COVERAGE_SAMPLES_NV			0x30E1
 #endif
 #ifndef EGL_NV_depth_nonlinear
 #define EGL_NV_depth_nonlinear 1
 #define EGL_DEPTH_ENCODING_NV			0x30E2
 #define EGL_DEPTH_ENCODING_NONE_NV 0
 #define EGL_DEPTH_ENCODING_NONLINEAR_NV		0x30E3
 #endif
 #if KHRONOS_SUPPORT_INT64   /* EGLTimeNV requires 64-bit uint support */
 #ifndef EGL_NV_sync
 #define EGL_NV_sync 1
 #define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV	0x30E6
 #define EGL_SYNC_STATUS_NV			0x30E7
 #define EGL_SIGNALED_NV				0x30E8
 #define EGL_UNSIGNALED_NV			0x30E9
 #define EGL_SYNC_FLUSH_COMMANDS_BIT_NV		0x0001
 #define EGL_FOREVER_NV				0xFFFFFFFFFFFFFFFFull
 #define EGL_ALREADY_SIGNALED_NV			0x30EA
 #define EGL_TIMEOUT_EXPIRED_NV			0x30EB
 #define EGL_CONDITION_SATISFIED_NV		0x30EC
 #define EGL_SYNC_TYPE_NV			0x30ED
 #define EGL_SYNC_CONDITION_NV			0x30EE
 #define EGL_SYNC_FENCE_NV			0x30EF
 #define EGL_NO_SYNC_NV				((EGLSyncNV)0)
 typedef void* EGLSyncNV;
 typedef khronos_utime_nanoseconds_t EGLTimeNV;
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLSyncNV EGLAPIENTRY eglCreateFenceSyncNV (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncNV (EGLSyncNV sync);
 EGLAPI EGLBoolean EGLAPIENTRY eglFenceNV (EGLSyncNV sync);
 EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncNV (EGLSyncNV sync, EGLint flags, EGLTimeNV timeout);
 EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncNV (EGLSyncNV sync, EGLenum mode);
 EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribNV (EGLSyncNV sync, EGLint attribute, EGLint *value);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLSyncNV (EGLAPIENTRYP PFNEGLCREATEFENCESYNCNVPROC) (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCNVPROC) (EGLSyncNV sync);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLFENCENVPROC) (EGLSyncNV sync);
 typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCNVPROC) (EGLSyncNV sync, EGLint flags, EGLTimeNV timeout);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCNVPROC) (EGLSyncNV sync, EGLenum mode);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBNVPROC) (EGLSyncNV sync, EGLint attribute, EGLint *value);
 #endif
 #endif
 #if KHRONOS_SUPPORT_INT64   /* Dependent on EGL_KHR_reusable_sync which requires 64-bit uint support */
 #ifndef EGL_KHR_fence_sync
 #define EGL_KHR_fence_sync 1
 /* Reuses most tokens and entry points from EGL_KHR_reusable_sync */
 #define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR	0x30F0
 #define EGL_SYNC_CONDITION_KHR			0x30F8
 #define EGL_SYNC_FENCE_KHR			0x30F9
 #endif
 #endif
 #ifndef EGL_HI_clientpixmap
 #define EGL_HI_clientpixmap 1
 /* Surface Attribute */
 #define EGL_CLIENT_PIXMAP_POINTER_HI		0x8F74
 /*
 * Structure representing a client pixmap
 * (pixmap's data is in client-space memory).
 */
 struct EGLClientPixmapHI
 {
 	void*		pData;
 	EGLint		iWidth;
 	EGLint		iHeight;
 	EGLint		iStride;
 };
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurfaceHI(EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI* pixmap);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPIXMAPSURFACEHIPROC) (EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI* pixmap);
 #endif	/* EGL_HI_clientpixmap */
 #ifndef EGL_HI_colorformats
 #define EGL_HI_colorformats 1
 /* Config Attribute */
 #define EGL_COLOR_FORMAT_HI			0x8F70
 /* Color Formats */
 #define EGL_COLOR_RGB_HI			0x8F71
 #define EGL_COLOR_RGBA_HI			0x8F72
 #define EGL_COLOR_ARGB_HI			0x8F73
 #endif /* EGL_HI_colorformats */
 #ifndef EGL_MESA_drm_image
 #define EGL_MESA_drm_image 1
 #define EGL_DRM_BUFFER_FORMAT_MESA		0x31D0	    /* CreateDRMImageMESA attribute */
 #define EGL_DRM_BUFFER_USE_MESA			0x31D1	    /* CreateDRMImageMESA attribute */
 #define EGL_DRM_BUFFER_FORMAT_ARGB32_MESA	0x31D2	    /* EGL_IMAGE_FORMAT_MESA attribute value */
 #define EGL_DRM_BUFFER_MESA			0x31D3	    /* eglCreateImageKHR target */
 #define EGL_DRM_BUFFER_STRIDE_MESA		0x31D4
 #define EGL_DRM_BUFFER_USE_SCANOUT_MESA		0x00000001  /* EGL_DRM_BUFFER_USE_MESA bits */
 #define EGL_DRM_BUFFER_USE_SHARE_MESA		0x00000002  /* EGL_DRM_BUFFER_USE_MESA bits */
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLImageKHR EGLAPIENTRY eglCreateDRMImageMESA (EGLDisplay dpy, const EGLint *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglExportDRMImageMESA (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEDRMIMAGEMESAPROC) (EGLDisplay dpy, const EGLint *attrib_list);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLEXPORTDRMIMAGEMESAPROC) (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
 #endif
 #ifndef EGL_NV_post_sub_buffer
 #define EGL_NV_post_sub_buffer 1
 #define EGL_POST_SUB_BUFFER_SUPPORTED_NV	0x30BE
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglPostSubBufferNV (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLPOSTSUBBUFFERNVPROC) (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
 #endif
 #ifndef EGL_ANGLE_query_surface_pointer
 #define EGL_ANGLE_query_surface_pointer 1
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLBoolean eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value);
 #endif
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value);
 #endif
 #ifndef EGL_ANGLE_surface_d3d_texture_2d_share_handle
 #define EGL_ANGLE_surface_d3d_texture_2d_share_handle 1
 #define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE	0x3200
 #endif
 #ifndef EGL_NV_coverage_sample_resolve
 #define EGL_NV_coverage_sample_resolve 1
 #define EGL_COVERAGE_SAMPLE_RESOLVE_NV		0x3131
 #define EGL_COVERAGE_SAMPLE_RESOLVE_DEFAULT_NV	0x3132
 #define EGL_COVERAGE_SAMPLE_RESOLVE_NONE_NV	0x3133
 #endif
 #if KHRONOS_SUPPORT_INT64   /* EGLuint64NV requires 64-bit uint support */
 #ifndef EGL_NV_system_time
 #define EGL_NV_system_time 1
 typedef khronos_utime_nanoseconds_t EGLuint64NV;
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeFrequencyNV(void);
 EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeNV(void);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC) (void);
 typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMENVPROC) (void);
 #endif
 #endif
 #if KHRONOS_SUPPORT_INT64 /* EGLuint64KHR requires 64-bit uint support */
 #ifndef EGL_KHR_stream
 #define EGL_KHR_stream 1
 typedef void* EGLStreamKHR;
 typedef khronos_uint64_t EGLuint64KHR;
 #define EGL_NO_STREAM_KHR			    ((EGLStreamKHR)0)
 #define EGL_CONSUMER_LATENCY_USEC_KHR		    0x3210
 #define EGL_PRODUCER_FRAME_KHR			    0x3212
 #define EGL_CONSUMER_FRAME_KHR			    0x3213
 #define EGL_STREAM_STATE_KHR			    0x3214
 #define EGL_STREAM_STATE_CREATED_KHR		    0x3215
 #define EGL_STREAM_STATE_CONNECTING_KHR		    0x3216
 #define EGL_STREAM_STATE_EMPTY_KHR		    0x3217
 #define EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR    0x3218
 #define EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR    0x3219
 #define EGL_STREAM_STATE_DISCONNECTED_KHR	    0x321A
 #define EGL_BAD_STREAM_KHR			    0x321B
 #define EGL_BAD_STATE_KHR			    0x321C
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLStreamKHR EGLAPIENTRY eglCreateStreamKHR(EGLDisplay dpy, const EGLint *attrib_list);
 EGLAPI EGLBoolean EGLAPIENTRY eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream);
 EGLAPI EGLBoolean EGLAPIENTRY eglStreamAttribKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value);
 EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *value);
 EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamu64KHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *value);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMKHRPROC)(EGLDisplay dpy, const EGLint *attrib_list);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSTREAMKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMATTRIBKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *value);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMU64KHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *value);
 #endif
 #endif
 #ifdef EGL_KHR_stream /* Requires KHR_stream extension */
 #ifndef EGL_KHR_stream_consumer_gltexture
 #define EGL_KHR_stream_consumer_gltexture 1
 #define EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR	    0x321E
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream);
 EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream);
 EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERACQUIREKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERRELEASEKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream);
 #endif
 #endif
 #ifdef EGL_KHR_stream /* Requires KHR_stream extension */
 #ifndef EGL_KHR_stream_producer_eglsurface
 #define EGL_KHR_stream_producer_eglsurface 1
 #define EGL_STREAM_BIT_KHR			    0x0800
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLSurface EGLAPIENTRY eglCreateStreamProducerSurfaceKHR(EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *attrib_list);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC)(EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *attrib_list);
 #endif
 #endif
 #ifdef EGL_KHR_stream /* Requires KHR_stream extension */
 #ifndef EGL_KHR_stream_producer_aldatalocator
 #define EGL_KHR_stream_producer_aldatalocator 1
 #endif
 #endif
 #ifdef EGL_KHR_stream /* Requires KHR_stream extension */
 #ifndef EGL_KHR_stream_fifo
 #define EGL_KHR_stream_fifo 1
 /* reuse EGLTimeKHR */
 #define EGL_STREAM_FIFO_LENGTH_KHR		    0x31FC
 #define EGL_STREAM_TIME_NOW_KHR			    0x31FD
 #define EGL_STREAM_TIME_CONSUMER_KHR		    0x31FE
 #define EGL_STREAM_TIME_PRODUCER_KHR		    0x31FF
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamTimeKHR(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLTimeKHR *value);
 #endif /* EGL_EGLEXT_PROTOTYPES */
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMTIMEKHRPROC)(EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLTimeKHR *value);
 #endif
 #endif
 #ifndef EGL_EXT_create_context_robustness
 #define EGL_EXT_create_context_robustness 1
 #define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT	    0x30BF
 #define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT 0x3138
 #define EGL_NO_RESET_NOTIFICATION_EXT		    0x31BE
 #define EGL_LOSE_CONTEXT_ON_RESET_EXT		    0x31BF
 #endif
 #ifndef EGL_ANGLE_d3d_share_handle_client_buffer
 #define EGL_ANGLE_d3d_share_handle_client_buffer 1
 /* reuse EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE */
 #endif
 #ifndef EGL_KHR_create_context
 #define EGL_KHR_create_context 1
 #define EGL_CONTEXT_MAJOR_VERSION_KHR			    EGL_CONTEXT_CLIENT_VERSION
 #define EGL_CONTEXT_MINOR_VERSION_KHR			    0x30FB
 #define EGL_CONTEXT_FLAGS_KHR				    0x30FC
 #define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR		    0x30FD
 #define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR  0x31BD
 #define EGL_NO_RESET_NOTIFICATION_KHR			    0x31BE
 #define EGL_LOSE_CONTEXT_ON_RESET_KHR			    0x31BF
 #define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR		    0x00000001
 #define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR	    0x00000002
 #define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR	    0x00000004
 #define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR		    0x00000001
 #define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR    0x00000002
 #endif
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/tests/events.c
+++ b/tests/events.c
@ -218,6 +218,15 @@ static const char* get_character_string(int character)
    return result;
 }
 static void window_pos_callback(GLFWwindow window, int x, int y)
 {
    printf("%08x at %0.3f: Window position: %i %i\n",
           counter++,
           glfwGetTime(),
           x,
           y);
 }
 static void window_size_callback(GLFWwindow window, int width, int height)
 {
    printf("%08x at %0.3f: Window size: %i %i\n",
@ -382,6 +391,7 @@ int main(void)
    glfwSetMonitorCallback(monitor_callback);
    glfwSetWindowPosCallback(window, window_pos_callback);
    glfwSetWindowSizeCallback(window, window_size_callback);
    glfwSetWindowCloseCallback(window, window_close_callback);
    glfwSetWindowRefreshCallback(window, window_refresh_callback);
--- a/tests/joysticks.c
+++ b/tests/joysticks.c
@ -37,6 +37,7 @@
 typedef struct Joystick
 {
    GLboolean present;
    char* name;
    float* axes;
    unsigned char* buttons;
    int axis_count;
@ -94,11 +95,11 @@ static void draw_joystick(Joystick* j, int x, int y, int width, int height)
    }
 }
-static void draw_joysticks(void)
+static void draw_joysticks(GLFWwindow window)
 {
    int i, width, height;
-    glfwGetWindowSize(glfwGetCurrentContext(), &width, &height);
+    glfwGetWindowSize(window, &width, &height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
@ -130,6 +131,9 @@ static void refresh_joysticks(void)
        {
            int axis_count, button_count;
            free(j->name);
            j->name = strdup(glfwGetJoystickName(GLFW_JOYSTICK_1 + i));
            axis_count = glfwGetJoystickParam(GLFW_JOYSTICK_1 + i, GLFW_AXES);
            if (axis_count != j->axis_count)
            {
@ -150,8 +154,8 @@ static void refresh_joysticks(void)
            if (!j->present)
            {
-                printf("Found joystick %i with %i axes, %i buttons\n",
+                printf("Found joystick %i named \'%s\' with %i axes, %i buttons\n",
-                       i + 1, j->axis_count, j->button_count);
+                       i + 1, j->name, j->axis_count, j->button_count);
                joystick_count++;
            }
@ -162,12 +166,13 @@ static void refresh_joysticks(void)
        {
            if (j->present)
            {
                printf("Lost joystick %i named \'%s\'\n", i + 1, j->name);
                free(j->name);
                free(j->axes);
                free(j->buttons);
                memset(j, 0, sizeof(Joystick));
                printf("Lost joystick %i\n", i + 1);
                joystick_count--;
            }
        }
@ -205,7 +210,7 @@ int main(void)
        glClear(GL_COLOR_BUFFER_BIT);
        refresh_joysticks();
-        draw_joysticks();
+        draw_joysticks(window);
        glfwSwapBuffers(window);
        glfwPollEvents();