Merge branch 'master' of github.com:elmindreda/glfw

CMakeLists.txt

@@ -12,7 +12,6 @@ set(LIB_SUFFIX "" CACHE STRING "Takes an empty string or 64. Directory where lib
 
 option(GLFW_BUILD_EXAMPLES "Build the GLFW example programs" ON)
 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)
 
 if (NOT APPLE)
@@ -355,12 +354,7 @@ configure_file(${GLFW_SOURCE_DIR}/src/config.h.in
 # The src directory's CMakeLists.txt file installs the library
 #--------------------------------------------------------------------
 install(DIRECTORY include/GL DESTINATION include 
-        FILES_MATCHING PATTERN glfw3.h)
+        FILES_MATCHING PATTERN glfw3.h PATTERN glfw3native.h)
-
-if (GLFW_NATIVE_API)
-    install(DIRECTORY include/GL DESTINATION include 
-            FILES_MATCHING PATTERN glfw3native.h)
-endif()
 
 install(FILES COPYING.txt readme.html 
         DESTINATION share/doc/glfw-${GLFW_VERSION_FULL})

include/GL/glfw3native.h

@@ -51,29 +51,30 @@ extern "C" {
  * System headers and types
  *************************************************************************/
 
-#if defined(GLFW_EXPOSE_NATIVE_WIN32_WGL)
+#if defined(GLFW_EXPOSE_NATIVE_WIN32)
-
- /* We are building for Win32 and WGL */
  #include <windows.h>
-
+#elif defined(GLFW_EXPOSE_NATIVE_COCOA)
-#elif defined(GLFW_EXPOSE_NATIVE_COCOA_NSGL)
-
- /* We are building for Cocoa and NSOpenGL */
  #if defined(__OBJC__)
   #import <Cocoa/Cocoa.h>
  #else
   typedef void* id;
  #endif
-
+#elif defined(GLFW_EXPOSE_NATIVE_X11)
-#elif defined(GLFW_EXPOSE_NATIVE_X11_GLX)
-
- /* We are building for X11 and GLX */
  #include <X11/Xlib.h>
-
 #else
+ #error "No window API specified"
+#endif
 
- #error "No platform specified"
+#if defined(GLFW_EXPOSE_NATIVE_WGL)
-
+ /* WGL is declared by windows.h */
+#elif defined(GLFW_EXPOSE_NATIVE_NSGL)
+ /* NSGL is declared by Cocoa.h */
+#elif defined(GLFW_EXPOSE_NATIVE_GLX)
+ #include <GL/glx.h>
+#elif defined(GLFW_EXPOSE_NATIVE_EGL)
+ #include <EGL/egl.h>
+#else
+ #error "No context API specified"
 #endif
 
 
@@ -81,56 +82,76 @@ extern "C" {
  * Functions
  *************************************************************************/
 
-#if defined(GLFW_EXPOSE_NATIVE_WIN32_WGL)
+#if defined(GLFW_EXPOSE_NATIVE_WIN32)
-
 /*! @brief Returns the @c HWND of the specified window.
  *  @return The @c HWND of the specified window.
  *  @ingroup native
  */
-GLFWAPI HWND glfwGetWin32Window(GLFWwindow window);
+GLFWAPI HWND glfwGetWin32Window(GLFWwindow* window);
+#endif
 
+#if defined(GLFW_EXPOSE_NATIVE_WGL)
 /*! @brief Returns the @c HGLRC of the specified window.
  *  @return The @c HGLRC of the specified window.
  *  @ingroup native
  */
-GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow window);
+GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* window);
-
+#endif
-#elif defined(GLFW_EXPOSE_NATIVE_COCOA_NSGL)
 
+#if defined(GLFW_EXPOSE_NATIVE_COCOA)
 /*! @brief Returns the @c NSWindow of the specified window.
  *  @return The @c NSWindow of the specified window.
  *  @ingroup native
  */
-GLFWAPI id glfwGetCocoaWindow(GLFWwindow window);
+GLFWAPI id glfwGetCocoaWindow(GLFWwindow* window);
+#endif
 
+#if defined(GLFW_EXPOSE_NATIVE_NSGL)
 /*! @brief Returns the @c NSOpenGLContext of the specified window.
  *  @return The @c NSOpenGLContext of the specified window.
  *  @ingroup native
  */
-GLFWAPI id glfwGetNSGLContext(GLFWwindow window);
+GLFWAPI id glfwGetNSGLContext(GLFWwindow* window);
-
+#endif
-#elif defined(GLFW_EXPOSE_NATIVE_X11_GLX)
 
+#if defined(GLFW_EXPOSE_NATIVE_X11)
 /*! @brief Returns the @c Display used by GLFW.
  *  @return The @c Display used by GLFW.
  *  @ingroup native
  */
 GLFWAPI Display* glfwGetX11Display(void);
-
 /*! @brief Returns the @c Window of the specified window.
  *  @return The @c Window of the specified window.
  *  @ingroup native
  */
-GLFWAPI Window glfwGetX11Window(GLFWwindow window);
+GLFWAPI Window glfwGetX11Window(GLFWwindow* window);
+#endif
 
+#if defined(GLFW_EXPOSE_NATIVE_GLX)
 /*! @brief Returns the @c GLXContext of the specified window.
  *  @return The @c GLXContext of the specified window.
  *  @ingroup native
  */
-GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow window);
+GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* window);
-
 #endif
 
+#if defined(GLFW_EXPOSE_NATIVE_EGL)
+/*! @brief Returns the @c EGLDisplay used by GLFW.
+ *  @return The @c EGLDisplay used by GLFW.
+ *  @ingroup native
+ */
+GLFWAPI EGLDisplay glfwGetEGLDisplay(void);
+/*! @brief Returns the @c EGLContext of the specified window.
+ *  @return The @c EGLContext of the specified window.
+ *  @ingroup native
+ */
+GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window);
+/*! @brief Returns the @c EGLSurface of the specified window.
+ *  @return The @c EGLSurface of the specified window.
+ *  @ingroup native
+ */
+GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* window);
+#endif
 
 #ifdef __cplusplus
 }

src/CMakeLists.txt

@@ -16,28 +16,16 @@ if (_GLFW_COCOA)
     set(glfw_SOURCES ${common_SOURCES} cocoa_clipboard.m cocoa_gamma.c
                      cocoa_init.m cocoa_joystick.m cocoa_monitor.m cocoa_time.c
                      cocoa_window.m)
-
-    if (GLFW_NATIVE_API)
-        list(APPEND glfw_SOURCES cocoa_native.m)
-    endif()
 elseif (_GLFW_WIN32)
     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_time.c
                      win32_window.c)
-
-    if (GLFW_NATIVE_API)
-        list(APPEND glfw_SOURCES win32_native.c)
-    endif()
 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_time.c x11_window.c)
-
-    if (GLFW_NATIVE_API)
-        list(APPEND glfw_SOURCES x11_native.c)
-    endif()
 endif()
 
 if (_GLFW_EGL)

src/cocoa_init.m

@@ -101,7 +101,7 @@ int _glfwPlatformInit(void)
 
     _glfwInitJoysticks();
 
-    if (!_glfwInitOpenGL())
+    if (!_glfwInitContextAPI())
         return GL_FALSE;
 
     _glfw.ns.eventSource = CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
@@ -141,7 +141,7 @@ void _glfwPlatformTerminate(void)
 
     _glfwTerminateJoysticks();
 
-    _glfwTerminateOpenGL();
+    _glfwTerminateContextAPI();
 }
 
 

src/cocoa_native.m

@@ -1,74 +0,0 @@
-//========================================================================
-// GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
-// API version: 3.0
-// WWW:         http://www.glfw.org/
-//------------------------------------------------------------------------
-// Copyright (c) 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"
-
-#define GLFW_EXPOSE_NATIVE_COCOA_NSGL
-#include "../include/GL/glfw3native.h"
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                        GLFW native API                       //////
-//////////////////////////////////////////////////////////////////////////
-
-//========================================================================
-// Returns the X11 handle of the specified window
-//========================================================================
-
-GLFWAPI id glfwGetCocoaWindow(GLFWwindow handle)
-{
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-
-    if (!_glfwInitialized)
-    {
-        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
-        return 0;
-    }
-
-    return window->ns.object;
-}
-
-
-//========================================================================
-// Return the GLX context of the specified window
-//========================================================================
-
-GLFWAPI id glfwGetNSGLContext(GLFWwindow handle)
-{
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-
-    if (!_glfwInitialized)
-    {
-        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
-        return NULL;
-    }
-
-    return window->nsgl.context;
-}
-

src/cocoa_platform.h

@@ -118,8 +118,8 @@ GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, int* width, int* height, int*
 void _glfwRestoreVideoMode(_GLFWmonitor* monitor);
 
 // OpenGL support
-int _glfwInitOpenGL(void);
+int _glfwInitContextAPI(void);
-void _glfwTerminateOpenGL(void);
+void _glfwTerminateContextAPI(void);
 int _glfwCreateContext(_GLFWwindow* window,
                        const _GLFWwndconfig* wndconfig,
                        const _GLFWfbconfig* fbconfig);

src/cocoa_window.m

@@ -969,3 +969,25 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
     }
 }
 
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+//========================================================================
+// Returns the Cocoa object of the specified window
+//========================================================================
+
+GLFWAPI id glfwGetCocoaWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    if (!_glfwInitialized)
+    {
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
+        return 0;
+    }
+
+    return window->ns.object;
+}
+

src/egl_context.c

@@ -113,7 +113,7 @@ static const char* getErrorString(EGLint error)
 // Initialize EGL
 //========================================================================
 
-int _glfwInitOpenGL(void)
+int _glfwInitContextAPI(void)
 {
     _glfw.egl.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
     if (_glfw.egl.display == EGL_NO_DISPLAY)
@@ -145,7 +145,7 @@ int _glfwInitOpenGL(void)
 // Terminate EGL
 //========================================================================
 
-void _glfwTerminateOpenGL(void)
+void _glfwTerminateContextAPI(void)
 {
     eglTerminate(_glfw.egl.display);
 }
@@ -497,3 +497,58 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
     return eglGetProcAddress(procname);
 }
 
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+//========================================================================
+// Return the EGL display
+//========================================================================
+
+GLFWAPI EGLDisplay glfwGetEGLDisplay(void)
+{
+    if (!_glfwInitialized)
+    {
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
+        return NULL;
+    }
+
+    return _glfw.egl.display;
+}
+
+
+//========================================================================
+// Return the WGL context of the specified window
+//========================================================================
+
+GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    if (!_glfwInitialized)
+    {
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
+        return 0;
+    }
+
+    return window->egl.context;
+}
+
+//========================================================================
+// Return the EGL surface of the specified window
+//========================================================================
+
+GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    if (!_glfwInitialized)
+    {
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
+        return 0;
+    }
+
+    return window->egl.surface;
+}
+

src/glx_context.c

@@ -113,7 +113,7 @@ static GLXContext createLegacyContext(_GLFWwindow* window,
 // Initialize GLX
 //========================================================================
 
-int _glfwInitOpenGL(void)
+int _glfwInitContextAPI(void)
 {
 #ifdef _GLFW_DLOPEN_LIBGL
     int i;
@@ -237,7 +237,7 @@ int _glfwInitOpenGL(void)
 // Terminate GLX
 //========================================================================
 
-void _glfwTerminateOpenGL(void)
+void _glfwTerminateContextAPI(void)
 {
     // Unload libGL.so if necessary
 #ifdef _GLFW_DLOPEN_LIBGL
@@ -633,3 +633,25 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
     return _glfw_glXGetProcAddress((const GLubyte*) procname);
 }
 
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+//========================================================================
+// Return the GLX context of the specified window
+//========================================================================
+
+GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    if (!_glfwInitialized)
+    {
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
+        return NULL;
+    }
+
+    return window->glx.context;
+}
+

src/input.c

@@ -146,8 +146,8 @@ void _glfwInputKey(_GLFWwindow* window, int key, int action)
     }
 
     // Call user callback function
-    if (window->keyCallback && !repeated)
+    if (window->callbacks.key && !repeated)
-        window->keyCallback((GLFWwindow*) window, key, action);
+        window->callbacks.key((GLFWwindow*) window, key, action);
 }
 
 
@@ -161,8 +161,8 @@ void _glfwInputChar(_GLFWwindow* window, int character)
     if (!((character >= 32 && character <= 126) || character >= 160))
         return;
 
-    if (window->charCallback)
+    if (window->callbacks.character)
-        window->charCallback((GLFWwindow*) window, character);
+        window->callbacks.character((GLFWwindow*) window, character);
 }
 
 
@@ -175,8 +175,8 @@ void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset)
     window->scrollX += xoffset;
     window->scrollY += yoffset;
 
-    if (window->scrollCallback)
+    if (window->callbacks.scroll)
-        window->scrollCallback((GLFWwindow*) window, xoffset, yoffset);
+        window->callbacks.scroll((GLFWwindow*) window, xoffset, yoffset);
 }
 
 
@@ -195,8 +195,8 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action)
     else
         window->mouseButton[button] = (char) action;
 
-    if (window->mouseButtonCallback)
+    if (window->callbacks.mouseButton)
-        window->mouseButtonCallback((GLFWwindow*) window, button, action);
+        window->callbacks.mouseButton((GLFWwindow*) window, button, action);
 }
 
 
@@ -223,11 +223,11 @@ void _glfwInputCursorMotion(_GLFWwindow* window, int x, int y)
         window->cursorPosY = y;
     }
 
-    if (window->cursorPosCallback)
+    if (window->callbacks.cursorPos)
     {
-        window->cursorPosCallback((GLFWwindow*) window,
+        window->callbacks.cursorPos((GLFWwindow*) window,
-                                  window->cursorPosX,
+                                    window->cursorPosX,
-                                  window->cursorPosY);
+                                    window->cursorPosY);
     }
 }
 
@@ -238,8 +238,8 @@ void _glfwInputCursorMotion(_GLFWwindow* window, int x, int y)
 
 void _glfwInputCursorEnter(_GLFWwindow* window, int entered)
 {
-    if (window->cursorEnterCallback)
+    if (window->callbacks.cursorEnter)
-        window->cursorEnterCallback((GLFWwindow*) window, entered);
+        window->callbacks.cursorEnter((GLFWwindow*) window, entered);
 }
 
 
@@ -464,7 +464,7 @@ GLFWAPI void glfwSetKeyCallback(GLFWwindow* handle, GLFWkeyfun cbfun)
         return;
     }
 
-    window->keyCallback = cbfun;
+    window->callbacks.key = cbfun;
 }
 
 
@@ -482,7 +482,7 @@ GLFWAPI void glfwSetCharCallback(GLFWwindow* handle, GLFWcharfun cbfun)
         return;
     }
 
-    window->charCallback = cbfun;
+    window->callbacks.character = cbfun;
 }
 
 
@@ -500,7 +500,7 @@ GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow* handle, GLFWmousebuttonfun c
         return;
     }
 
-    window->mouseButtonCallback = cbfun;
+    window->callbacks.mouseButton = cbfun;
 }
 
 
@@ -518,7 +518,7 @@ GLFWAPI void glfwSetCursorPosCallback(GLFWwindow* handle, GLFWcursorposfun cbfun
         return;
     }
 
-    window->cursorPosCallback = cbfun;
+    window->callbacks.cursorPos = cbfun;
 }
 
 
@@ -536,7 +536,7 @@ GLFWAPI void glfwSetCursorEnterCallback(GLFWwindow* handle, GLFWcursorenterfun c
         return;
     }
 
-    window->cursorEnterCallback = cbfun;
+    window->callbacks.cursorEnter = cbfun;
 }
 
 
@@ -554,6 +554,6 @@ GLFWAPI void glfwSetScrollCallback(GLFWwindow* handle, GLFWscrollfun cbfun)
         return;
     }
 
-    window->scrollCallback = cbfun;
+    window->callbacks.scroll = cbfun;
 }
 

src/internal.h

@@ -235,18 +235,20 @@ struct _GLFWwindow
     PFNGLGETSTRINGIPROC GetStringi;
 #endif
 
-    GLFWwindowposfun     windowPosCallback;
+    struct {
-    GLFWwindowsizefun    windowSizeCallback;
+        GLFWwindowposfun     pos;
-    GLFWwindowclosefun   windowCloseCallback;
+        GLFWwindowsizefun    size;
-    GLFWwindowrefreshfun windowRefreshCallback;
+        GLFWwindowclosefun   close;
-    GLFWwindowfocusfun   windowFocusCallback;
+        GLFWwindowrefreshfun refresh;
-    GLFWwindowiconifyfun windowIconifyCallback;
+        GLFWwindowfocusfun   focus;
-    GLFWmousebuttonfun   mouseButtonCallback;
+        GLFWwindowiconifyfun iconify;
-    GLFWcursorposfun     cursorPosCallback;
+        GLFWmousebuttonfun   mouseButton;
-    GLFWcursorenterfun   cursorEnterCallback;
+        GLFWcursorposfun     cursorPos;
-    GLFWscrollfun        scrollCallback;
+        GLFWcursorenterfun   cursorEnter;
-    GLFWkeyfun           keyCallback;
+        GLFWscrollfun        scroll;
-    GLFWcharfun          charCallback;
+        GLFWkeyfun           key;
+        GLFWcharfun          character;
+    } callbacks;
 
     // This is defined in the window API's platform.h
     _GLFW_PLATFORM_WINDOW_STATE;

src/nsgl_context.m

@@ -46,7 +46,7 @@ static pthread_key_t _glfwCurrentTLS;
 // Initialize OpenGL support
 //========================================================================
 
-int _glfwInitOpenGL(void)
+int _glfwInitContextAPI(void)
 {
     if (pthread_key_create(&_glfwCurrentTLS, NULL) != 0)
     {
@@ -63,7 +63,7 @@ int _glfwInitOpenGL(void)
 // Terminate OpenGL support
 //========================================================================
 
-void _glfwTerminateOpenGL(void)
+void _glfwTerminateContextAPI(void)
 {
     pthread_key_delete(_glfwCurrentTLS);
 }
@@ -325,3 +325,25 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
     return symbol;
 }
 
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+//========================================================================
+// Return the NSGL context of the specified window
+//========================================================================
+
+GLFWAPI id glfwGetNSGLContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    if (!_glfwInitialized)
+    {
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
+        return NULL;
+    }
+
+    return window->nsgl.context;
+}
+

src/wgl_context.c

@@ -612,3 +612,25 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
     return (GLFWglproc) wglGetProcAddress(procname);
 }
 
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+//========================================================================
+// Return the WGL context of the specified window
+//========================================================================
+
+GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    if (!_glfwInitialized)
+    {
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
+        return NULL;
+    }
+
+    return window->wgl.context;
+}
+

src/win32_native.c

@@ -1,74 +0,0 @@
-_glfw
-// GLFW - An OpenGL library
-// Platform:    Win32/WGL
-// API version: 3.0
-// WWW:         http://www.glfw.org/
-//------------------------------------------------------------------------
-// Copyright (c) 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"
-
-#define GLFW_EXPOSE_NATIVE_WIN32_WGL
-#include "../include/GL/glfw3native.h"
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                        GLFW native API                       //////
-//////////////////////////////////////////////////////////////////////////
-
-//========================================================================
-// Returns the Win32 handle of the specified window
-//========================================================================
-
-GLFWAPI HWND glfwGetWin32Window(GLFWwindow handle)
-{
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-
-    if (!_glfwInitialized)
-    {
-        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
-        return NULL;
-    }
-
-    return window->win32.handle;
-}
-
-
-//========================================================================
-// Return the WGL context of the specified window
-//========================================================================
-
-GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow handle)
-{
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-
-    if (!_glfwInitialized)
-    {
-        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
-        return NULL;
-    }
-
-    return window->WGL.context;
-}
-

src/win32_window.c

@@ -579,7 +579,6 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
         case WM_MOUSEHWHEEL:
         {
             // This message is only sent on Windows Vista and later
-
             _glfwInputScroll(window, (SHORT) HIWORD(wParam) / (double) WHEEL_DELTA, 0.0);
             return 0;
         }
@@ -1142,4 +1141,24 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
     }
 }
 
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+//========================================================================
+// Returns the Win32 handle of the specified window
+//========================================================================
+
+GLFWAPI HWND glfwGetWin32Window(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    if (!_glfwInitialized)
+    {
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
+        return NULL;
+    }
+
+    return window->win32.handle;
+}
 

src/window.c

@@ -80,8 +80,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused)
         {
             _glfw.focusedWindow = window;
 
-            if (window->windowFocusCallback)
+            if (window->callbacks.focus)
-                window->windowFocusCallback((GLFWwindow*) window, focused);
+                window->callbacks.focus((GLFWwindow*) window, focused);
         }
     }
     else
@@ -106,8 +106,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused)
 
             _glfw.focusedWindow = NULL;
 
-            if (window->windowFocusCallback)
+            if (window->callbacks.focus)
-                window->windowFocusCallback((GLFWwindow*) window, focused);
+                window->callbacks.focus((GLFWwindow*) window, focused);
         }
     }
 }
@@ -125,8 +125,8 @@ void _glfwInputWindowPos(_GLFWwindow* window, int x, int y)
     window->positionX = x;
     window->positionY = y;
 
-    if (window->windowPosCallback)
+    if (window->callbacks.pos)
-        window->windowPosCallback((GLFWwindow*) window, x, y);
+        window->callbacks.pos((GLFWwindow*) window, x, y);
 }
 
 
@@ -142,8 +142,8 @@ void _glfwInputWindowSize(_GLFWwindow* window, int width, int height)
     window->width = width;
     window->height = height;
 
-    if (window->windowSizeCallback)
+    if (window->callbacks.size)
-        window->windowSizeCallback((GLFWwindow*) window, width, height);
+        window->callbacks.size((GLFWwindow*) window, width, height);
 }
 
 
@@ -158,8 +158,8 @@ void _glfwInputWindowIconify(_GLFWwindow* window, int iconified)
 
     window->iconified = iconified;
 
-    if (window->windowIconifyCallback)
+    if (window->callbacks.iconify)
-        window->windowIconifyCallback((GLFWwindow*) window, iconified);
+        window->callbacks.iconify((GLFWwindow*) window, iconified);
 }
 
 
@@ -179,8 +179,8 @@ void _glfwInputWindowVisibility(_GLFWwindow* window, int visible)
 
 void _glfwInputWindowDamage(_GLFWwindow* window)
 {
-    if (window->windowRefreshCallback)
+    if (window->callbacks.refresh)
-        window->windowRefreshCallback((GLFWwindow*) window);
+        window->callbacks.refresh((GLFWwindow*) window);
 }
 
 
@@ -190,8 +190,8 @@ void _glfwInputWindowDamage(_GLFWwindow* window)
 
 void _glfwInputWindowCloseRequest(_GLFWwindow* window)
 {
-    if (window->windowCloseCallback)
+    if (window->callbacks.close)
-        window->closeRequested = window->windowCloseCallback((GLFWwindow*) window);
+        window->closeRequested = window->callbacks.close((GLFWwindow*) window);
     else
         window->closeRequested = GL_TRUE;
 }
@@ -489,18 +489,7 @@ GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
         return;
 
     // Clear all callbacks to avoid exposing a half torn-down window object
-    window->windowPosCallback = NULL;
+    memset(&window->callbacks, 0, sizeof(window->callbacks));
-    window->windowSizeCallback = NULL;
-    window->windowCloseCallback = NULL;
-    window->windowRefreshCallback = NULL;
-    window->windowFocusCallback = NULL;
-    window->windowIconifyCallback = NULL;
-    window->mouseButtonCallback = NULL;
-    window->cursorPosCallback = NULL;
-    window->cursorEnterCallback = NULL;
-    window->scrollCallback = NULL;
-    window->keyCallback = NULL;
-    window->charCallback = NULL;
 
     // The window's context must not be current on another thread when the
     // window is destroyed
@@ -800,7 +789,7 @@ GLFWAPI void glfwSetWindowPosCallback(GLFWwindow* handle, GLFWwindowposfun cbfun
         return;
     }
 
-    window->windowPosCallback = cbfun;
+    window->callbacks.pos = cbfun;
 }
 
 
@@ -818,7 +807,7 @@ GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow* handle, GLFWwindowsizefun cbf
         return;
     }
 
-    window->windowSizeCallback = cbfun;
+    window->callbacks.size = cbfun;
 }
 
 
@@ -836,7 +825,7 @@ GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow* handle, GLFWwindowclosefun c
         return;
     }
 
-    window->windowCloseCallback = cbfun;
+    window->callbacks.close = cbfun;
 }
 
 
@@ -854,7 +843,7 @@ GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow* handle, GLFWwindowrefreshf
         return;
     }
 
-    window->windowRefreshCallback = cbfun;
+    window->callbacks.refresh = cbfun;
 }
 
 
@@ -872,7 +861,7 @@ GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow* handle, GLFWwindowfocusfun c
         return;
     }
 
-    window->windowFocusCallback = cbfun;
+    window->callbacks.focus = cbfun;
 }
 
 
@@ -890,7 +879,7 @@ GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow* handle, GLFWwindowiconifyf
         return;
     }
 
-    window->windowIconifyCallback = cbfun;
+    window->callbacks.iconify = cbfun;
 }
 
 

src/x11_init.c

@@ -632,7 +632,7 @@ int _glfwPlatformInit(void)
 
     _glfwInitGammaRamp();
 
-    if (!_glfwInitOpenGL())
+    if (!_glfwInitContextAPI())
         return GL_FALSE;
 
     _glfw.x11.cursor = createNULLCursor();
@@ -662,7 +662,7 @@ void _glfwPlatformTerminate(void)
 
     _glfwTerminateJoysticks();
 
-    _glfwTerminateOpenGL();
+    _glfwTerminateContextAPI();
 
     terminateDisplay();
 

src/x11_native.c

@@ -1,84 +0,0 @@
-//========================================================================
-// GLFW - An OpenGL library
-// Platform:    Win32/WGL
-// API version: 3.0
-// WWW:         http://www.glfw.org/
-//------------------------------------------------------------------------
-// Copyright (c) 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"
-
-#define GLFW_EXPOSE_NATIVE_X11_GLX
-#include "../include/GL/glfw3native.h"
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                        GLFW native API                       //////
-//////////////////////////////////////////////////////////////////////////
-
-//========================================================================
-// Returns the X11 display
-//========================================================================
-
-GLFWAPI Display* glfwGetX11Display(void)
-{
-    return _glfw.x11.display;
-}
-
-
-//========================================================================
-// Returns the X11 handle of the specified window
-//========================================================================
-
-GLFWAPI Window glfwGetX11Window(GLFWwindow handle)
-{
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-
-    if (!_glfwInitialized)
-    {
-        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
-        return 0;
-    }
-
-    return window->x11.handle;
-}
-
-
-//========================================================================
-// Return the GLX context of the specified window
-//========================================================================
-
-GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow handle)
-{
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-
-    if (!_glfwInitialized)
-    {
-        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
-        return NULL;
-    }
-
-    return window->glx.context;
-}
-

src/x11_platform.h

@@ -224,8 +224,8 @@ void _glfwInitGammaRamp(void);
 void _glfwTerminateGammaRamp(void);
 
 // OpenGL support
-int _glfwInitOpenGL(void);
+int _glfwInitContextAPI(void);
-void _glfwTerminateOpenGL(void);
+void _glfwTerminateContextAPI(void);
 int _glfwCreateContext(_GLFWwindow* window,
                        const _GLFWwndconfig* wndconfig,
                        const _GLFWfbconfig* fbconfig);

src/x11_window.c

@@ -1111,3 +1111,41 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
     }
 }
 
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+//========================================================================
+// Return the X11 display
+//========================================================================
+
+GLFWAPI Display* glfwGetX11Display(void)
+{
+    if (!_glfwInitialized)
+    {
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
+        return NULL;
+    }
+
+    return _glfw.x11.display;
+}
+
+
+//========================================================================
+// Return the X11 handle of the specified window
+//========================================================================
+
+GLFWAPI Window glfwGetX11Window(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    if (!_glfwInitialized)
+    {
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL);
+        return 0;
+    }
+
+    return window->x11.handle;
+}
+