Merge branch 'master' into multi-monitor

Conflicts:
	examples/wave.c
	src/init.c
	src/internal.h
	src/window.c
	tests/accuracy.c
	tests/events.c
	tests/reopen.c

examples/boing.c

@@ -577,8 +577,6 @@ int main( void )
       exit( EXIT_FAILURE );
    }
 
-   glfwSetWindowSizeCallback( reshape );
-
    glfwWindowHint(GLFW_DEPTH_BITS, 16);
 
    window = glfwCreateWindow( 400, 400, "Boing (classic Amiga demo)", NULL, NULL );
@@ -589,6 +587,8 @@ int main( void )
        exit( EXIT_FAILURE );
    }
 
+   glfwSetWindowSizeCallback(window, reshape);
+
    glfwMakeContextCurrent(window);
    glfwSwapInterval( 1 );
 

examples/gears.c

@@ -338,11 +338,6 @@ int main(int argc, char *argv[])
         exit( EXIT_FAILURE );
     }
 
-    // Set callback functions
-    glfwSetWindowCloseCallback(window_close_callback);
-    glfwSetWindowSizeCallback( reshape );
-    glfwSetKeyCallback( key );
-
     glfwWindowHint(GLFW_DEPTH_BITS, 16);
 
     window = glfwCreateWindow( 300, 300, "Gears", NULL, NULL );
@@ -353,6 +348,11 @@ int main(int argc, char *argv[])
         exit( EXIT_FAILURE );
     }
 
+    // Set callback functions
+    glfwSetWindowCloseCallback(window, window_close_callback);
+    glfwSetWindowSizeCallback(window, reshape);
+    glfwSetKeyCallback(window, key);
+
     glfwMakeContextCurrent(window);
     glfwSwapInterval( 1 );
 

examples/heightmap.c

@@ -595,12 +595,14 @@ int main(int argc, char** argv)
 
         free(vertex_shader_src);
         free(fragment_shader_src);
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
     /* Register events callback */
-    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
-    glfwSetKeyCallback(key_callback);
+    glfwSetKeyCallback(window, key_callback);
 
     glfwMakeContextCurrent(window);
     if (GL_TRUE != init_opengl())
@@ -608,6 +610,8 @@ int main(int argc, char** argv)
         fprintf(stderr, "ERROR: unable to resolve OpenGL function pointers\n");
         free(vertex_shader_src);
         free(fragment_shader_src);
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
     /* Prepare opengl resources for rendering */
@@ -619,6 +623,8 @@ int main(int argc, char** argv)
     {
         fprintf(stderr, "ERROR: during creation of the shader program\n");
         usage();
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
@@ -683,6 +689,7 @@ int main(int argc, char** argv)
         }
     }
 
+    glfwTerminate();
     exit(EXIT_SUCCESS);
 }
 

examples/splitview.c

@@ -450,12 +450,6 @@ int main(void)
         exit(EXIT_FAILURE);
     }
 
-    // Set callback functions
-    glfwSetWindowSizeCallback(windowSizeFun);
-    glfwSetWindowRefreshCallback(windowRefreshFun);
-    glfwSetCursorPosCallback(cursorPosFun);
-    glfwSetMouseButtonCallback(mouseButtonFun);
-
     glfwWindowHint(GLFW_DEPTH_BITS, 16);
 
     // Open OpenGL window
@@ -463,9 +457,17 @@ int main(void)
     if (!window)
     {
         fprintf(stderr, "Failed to open GLFW window\n");
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
+    // Set callback functions
+    glfwSetWindowSizeCallback(window, windowSizeFun);
+    glfwSetWindowRefreshCallback(window, windowRefreshFun);
+    glfwSetCursorPosCallback(window, cursorPosFun);
+    glfwSetMouseButtonCallback(window, mouseButtonFun);
+
     // Enable vsync
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);

examples/triangle.c

@@ -27,6 +27,8 @@ int main(void)
     if (!window)
     {
         fprintf(stderr, "Failed to open GLFW window\n");
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 

examples/wave.c

@@ -399,13 +399,6 @@ int main(int argc, char* argv[])
         exit(EXIT_FAILURE);
     }
 
-    glfwSetKeyCallback(key_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
-    glfwSetWindowSizeCallback(window_size_callback);
-    glfwSetMouseButtonCallback(mouse_button_callback);
-    glfwSetCursorPosCallback(cursor_position_callback);
-    glfwSetScrollCallback(scroll_callback);
-
     window = glfwCreateWindow(640, 480, "Wave Simulation", NULL, NULL);
     if (!window)
     {
@@ -413,6 +406,13 @@ int main(int argc, char* argv[])
         exit(EXIT_FAILURE);
     }
 
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+    glfwSetMouseButtonCallback(window, mouse_button_callback);
+    glfwSetCursorPosCallback(window, cursor_position_callback);
+    glfwSetScrollCallback(window, scroll_callback);
+
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 

include/GL/glfw3.h

@@ -546,6 +546,7 @@ GLFWAPI void glfwGetGammaRamp(GLFWgammaramp* ramp);
 GLFWAPI void glfwSetGammaRamp(const GLFWgammaramp* ramp);
 
 /* Window handling */
+GLFWAPI void glfwDefaultWindowHints(void);
 GLFWAPI void glfwWindowHint(int target, int hint);
 GLFWAPI GLFWwindow glfwCreateWindow(int width, int height, const char* title, GLFWmonitor monitor, GLFWwindow share);
 GLFWAPI void glfwDestroyWindow(GLFWwindow window);
@@ -562,11 +563,11 @@ GLFWAPI int  glfwGetWindowParam(GLFWwindow window, int param);
 GLFWAPI GLFWmonitor glfwGetWindowMonitor(GLFWwindow window);
 GLFWAPI void glfwSetWindowUserPointer(GLFWwindow window, void* pointer);
 GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow window);
-GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun);
+GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfun);
-GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun);
+GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cbfun);
-GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun);
+GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfun cbfun);
-GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun);
+GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cbfun);
-GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindowiconifyfun cbfun);
+GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow window, GLFWwindowiconifyfun cbfun);
 
 /* Event handling */
 GLFWAPI void glfwPollEvents(void);
@@ -580,12 +581,12 @@ GLFWAPI int  glfwGetMouseButton(GLFWwindow window, int button);
 GLFWAPI void glfwGetCursorPos(GLFWwindow window, int* xpos, int* ypos);
 GLFWAPI void glfwSetCursorPos(GLFWwindow window, int xpos, int ypos);
 GLFWAPI void glfwGetScrollOffset(GLFWwindow window, double* xoffset, double* yoffset);
-GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun);
+GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun);
-GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun);
+GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun);
-GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun);
+GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cbfun);
-GLFWAPI void glfwSetCursorPosCallback(GLFWcursorposfun cbfun);
+GLFWAPI void glfwSetCursorPosCallback(GLFWwindow window, GLFWcursorposfun cbfun);
-GLFWAPI void glfwSetCursorEnterCallback(GLFWcursorenterfun cbfun);
+GLFWAPI void glfwSetCursorEnterCallback(GLFWwindow window, GLFWcursorenterfun cbfun);
-GLFWAPI void glfwSetScrollCallback(GLFWscrollfun cbfun);
+GLFWAPI void glfwSetScrollCallback(GLFWwindow window, GLFWscrollfun cbfun);
 
 /* Joystick input */
 GLFWAPI int glfwGetJoystickParam(int joy, int param);

readme.html

@@ -273,6 +273,7 @@ version of GLFW.</p>
   <li>Added <code>glfwSetMonitorUserPointer</code> and <code>glfwGetMonitorUserPointer</code> for per-monitor user pointers</li>
   <li>Added <code>glfwSetMonitorCallback</code> and <code>GLFWmonitorfun</code> for notification of changes in the set of available monitors</li>
   <li>Added <code>GLFWwindow</code> window handle type and updated window-related functions and callbacks to take a window handle</li>
+  <li>Added <code>glfwDefaultWindowHints</code> function for resetting all window hints to their default values</li>
   <li>Added <code>glfwMakeContextCurrent</code> function for making the context of the specified window current</li>
   <li>Added <code>glfwGetError</code> and <code>glfwErrorString</code> error reporting functions and a number of error tokens</li>
   <li>Added <code>glfwSetErrorCallback</code> function and <code>GLFWerrorfun</code> type for receiving more specific and/or nested errors</li>
@@ -323,6 +324,7 @@ version of GLFW.</p>
   <li>Removed the entire threading API</li>
   <li>Removed the entire image loading API</li>
   <li>Removed deprecated Carbon port</li>
+  <li>Removed registering <code>glfwTerminate</code> with <code>atexit</code></li>
   <li>Removed <code>glfwSleep</code> function</li>
   <li>Removed <code>glfwGetNumberOfProcessors</code> function</li>
   <li>Removed <code>glfwGetGLVersion</code> function</li>

src/init.c

@@ -121,9 +121,6 @@ GLFWAPI int glfwInit(void)
 
     memset(&_glfwLibrary, 0, sizeof(_glfwLibrary));
 
-    // Not all window hints have zero as their default value
-    _glfwSetDefaultWindowHints();
-
     if (!_glfwPlatformInit())
     {
         _glfwPlatformTerminate();
@@ -137,10 +134,11 @@ GLFWAPI int glfwInit(void)
         return GL_FALSE;
     }
 
-    atexit(glfwTerminate);
-
     _glfwInitialized = GL_TRUE;
 
+    // Not all window hints have zero as their default value
+    glfwDefaultWindowHints();
+
     return GL_TRUE;
 }
 

src/input.c

@@ -172,8 +172,8 @@ void _glfwInputKey(_GLFWwindow* window, int key, int action)
     }
 
     // Call user callback function
-    if (_glfwLibrary.keyCallback && (window->keyRepeat || !repeated))
+    if (window->keyCallback && (window->keyRepeat || !repeated))
-        _glfwLibrary.keyCallback(window, key, action);
+        window->keyCallback(window, key, action);
 }
 
 
@@ -187,8 +187,8 @@ void _glfwInputChar(_GLFWwindow* window, int character)
     if (!((character >= 32 && character <= 126) || character >= 160))
         return;
 
-    if (_glfwLibrary.charCallback)
+    if (window->charCallback)
-        _glfwLibrary.charCallback(window, character);
+        window->charCallback(window, character);
 }
 
 
@@ -201,8 +201,8 @@ void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset)
     window->scrollX += xoffset;
     window->scrollY += yoffset;
 
-    if (_glfwLibrary.scrollCallback)
+    if (window->scrollCallback)
-        _glfwLibrary.scrollCallback(window, xoffset, yoffset);
+        window->scrollCallback(window, xoffset, yoffset);
 }
 
 
@@ -221,8 +221,8 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action)
     else
         window->mouseButton[button] = (char) action;
 
-    if (_glfwLibrary.mouseButtonCallback)
+    if (window->mouseButtonCallback)
-        _glfwLibrary.mouseButtonCallback(window, button, action);
+        window->mouseButtonCallback(window, button, action);
 }
 
 
@@ -249,9 +249,9 @@ void _glfwInputCursorMotion(_GLFWwindow* window, int x, int y)
         window->cursorPosY = y;
     }
 
-    if (_glfwLibrary.cursorPosCallback)
+    if (window->cursorPosCallback)
     {
-        _glfwLibrary.cursorPosCallback(window,
+        window->cursorPosCallback(window,
                                   window->cursorPosX,
                                   window->cursorPosY);
     }
@@ -264,8 +264,8 @@ void _glfwInputCursorMotion(_GLFWwindow* window, int x, int y)
 
 void _glfwInputCursorEnter(_GLFWwindow* window, int entered)
 {
-    if (_glfwLibrary.cursorEnterCallback)
+    if (window->cursorEnterCallback)
-        _glfwLibrary.cursorEnterCallback(window, entered);
+        window->cursorEnterCallback(window, entered);
 }
 
 
@@ -494,15 +494,17 @@ GLFWAPI void glfwGetScrollOffset(GLFWwindow handle, double* xoffset, double* yof
 // Set callback function for keyboard input
 //========================================================================
 
-GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun)
+GLFWAPI void glfwSetKeyCallback(GLFWwindow handle, GLFWkeyfun cbfun)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
         return;
     }
 
-    _glfwLibrary.keyCallback = cbfun;
+    window->keyCallback = cbfun;
 }
 
 
@@ -510,15 +512,17 @@ GLFWAPI void glfwSetKeyCallback(GLFWkeyfun cbfun)
 // Set callback function for character input
 //========================================================================
 
-GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun)
+GLFWAPI void glfwSetCharCallback(GLFWwindow handle, GLFWcharfun cbfun)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
         return;
     }
 
-    _glfwLibrary.charCallback = cbfun;
+    window->charCallback = cbfun;
 }
 
 
@@ -526,15 +530,17 @@ GLFWAPI void glfwSetCharCallback(GLFWcharfun cbfun)
 // Set callback function for mouse clicks
 //========================================================================
 
-GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun)
+GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow handle, GLFWmousebuttonfun cbfun)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
         return;
     }
 
-    _glfwLibrary.mouseButtonCallback = cbfun;
+    window->mouseButtonCallback = cbfun;
 }
 
 
@@ -542,15 +548,17 @@ GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun)
 // Set callback function for mouse moves
 //========================================================================
 
-GLFWAPI void glfwSetCursorPosCallback(GLFWcursorposfun cbfun)
+GLFWAPI void glfwSetCursorPosCallback(GLFWwindow handle, GLFWcursorposfun cbfun)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
         return;
     }
 
-    _glfwLibrary.cursorPosCallback = cbfun;
+    window->cursorPosCallback = cbfun;
 }
 
 
@@ -558,15 +566,17 @@ GLFWAPI void glfwSetCursorPosCallback(GLFWcursorposfun cbfun)
 // Set callback function for cursor enter/leave events
 //========================================================================
 
-GLFWAPI void glfwSetCursorEnterCallback(GLFWcursorenterfun cbfun)
+GLFWAPI void glfwSetCursorEnterCallback(GLFWwindow handle, GLFWcursorenterfun cbfun)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
         return;
     }
 
-    _glfwLibrary.cursorEnterCallback = cbfun;
+    window->cursorEnterCallback = cbfun;
 }
 
 
@@ -574,14 +584,16 @@ GLFWAPI void glfwSetCursorEnterCallback(GLFWcursorenterfun cbfun)
 // Set callback function for scroll events
 //========================================================================
 
-GLFWAPI void glfwSetScrollCallback(GLFWscrollfun cbfun)
+GLFWAPI void glfwSetScrollCallback(GLFWwindow handle, GLFWscrollfun cbfun)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
         return;
     }
 
-    _glfwLibrary.scrollCallback = cbfun;
+    window->scrollCallback = cbfun;
 }
 

src/internal.h

@@ -173,7 +173,7 @@ struct _GLFWwindow
     GLboolean closeRequested;  // GL_TRUE if this window should be closed
     int       width, height;
     int       positionX, positionY;
-    int       mode;            // GLFW_WINDOW or GLFW_FULLSCREEN
+    int       mode;            // GLFW_WINDOWED or GLFW_FULLSCREEN
     GLboolean resizable;       // GL_TRUE if user may resize this window
     GLboolean visible;         // GL_TRUE if this window is visible
     int       refreshRate;     // monitor refresh rate
@@ -199,6 +199,18 @@ struct _GLFWwindow
     int       glRobustness;
     PFNGLGETSTRINGIPROC GetStringi;
 
+    GLFWwindowsizefun    windowSizeCallback;
+    GLFWwindowclosefun   windowCloseCallback;
+    GLFWwindowrefreshfun windowRefreshCallback;
+    GLFWwindowfocusfun   windowFocusCallback;
+    GLFWwindowiconifyfun windowIconifyCallback;
+    GLFWmousebuttonfun   mouseButtonCallback;
+    GLFWcursorposfun     cursorPosCallback;
+    GLFWcursorenterfun   cursorEnterCallback;
+    GLFWscrollfun        scrollCallback;
+    GLFWkeyfun           keyCallback;
+    GLFWcharfun          charCallback;
+
     // These are defined in the current port's platform.h
     _GLFW_PLATFORM_WINDOW_STATE;
     _GLFW_PLATFORM_CONTEXT_STATE;
@@ -241,18 +253,6 @@ struct _GLFWlibrary
 
     _GLFWmonitor** monitors;
     int            monitorCount;
-
-    GLFWwindowsizefun    windowSizeCallback;
-    GLFWwindowclosefun   windowCloseCallback;
-    GLFWwindowrefreshfun windowRefreshCallback;
-    GLFWwindowfocusfun   windowFocusCallback;
-    GLFWwindowiconifyfun windowIconifyCallback;
-    GLFWmousebuttonfun   mouseButtonCallback;
-    GLFWcursorposfun     cursorPosCallback;
-    GLFWcursorenterfun   cursorEnterCallback;
-    GLFWscrollfun        scrollCallback;
-    GLFWkeyfun           keyCallback;
-    GLFWcharfun          charCallback;
     GLFWmonitorfun monitorCallback;
 
     GLFWgammaramp currentRamp;
@@ -385,9 +385,6 @@ void _glfwSplitBPP(int bpp, int* red, int* green, int* blue);
 // Error handling (init.c)
 void _glfwSetError(int error, const char* format, ...);
 
-// Window management (window.c)
-void _glfwSetDefaultWindowHints(void);
-
 // OpenGL context helpers (opengl.c)
 int _glfwStringInExtensionString(const char* string, const GLubyte* extensions);
 const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,

src/window.c

@@ -68,32 +68,6 @@ static void clearScrollOffsets(void)
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
-//========================================================================
-// Reset all window hints to their default values
-//========================================================================
-
-void _glfwSetDefaultWindowHints(void)
-{
-    memset(&_glfwLibrary.hints, 0, sizeof(_glfwLibrary.hints));
-
-    // The default is OpenGL with minimum version 1.0
-    _glfwLibrary.hints.clientAPI = GLFW_OPENGL_API;
-    _glfwLibrary.hints.glMajor = 1;
-    _glfwLibrary.hints.glMinor = 0;
-
-    // The default is to show the window and allow window resizing
-    _glfwLibrary.hints.resizable = GL_TRUE;
-    _glfwLibrary.hints.visible   = GL_TRUE;
-
-    // The default is 24 bits of color, 24 bits of depth and 8 bits of stencil
-    _glfwLibrary.hints.redBits     = 8;
-    _glfwLibrary.hints.greenBits   = 8;
-    _glfwLibrary.hints.blueBits    = 8;
-    _glfwLibrary.hints.depthBits   = 24;
-    _glfwLibrary.hints.stencilBits = 8;
-}
-
-
 //========================================================================
 // Register window focus events
 //========================================================================
@@ -107,8 +81,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
 
         _glfwLibrary.activeWindow = window;
 
-        if (_glfwLibrary.windowFocusCallback)
+        if (window->windowFocusCallback)
-            _glfwLibrary.windowFocusCallback(window, activated);
+            window->windowFocusCallback(window, activated);
     }
     else
     {
@@ -133,8 +107,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
 
         _glfwLibrary.activeWindow = NULL;
 
-        if (_glfwLibrary.windowFocusCallback)
+        if (window->windowFocusCallback)
-            _glfwLibrary.windowFocusCallback(window, activated);
+            window->windowFocusCallback(window, activated);
     }
 }
 
@@ -162,8 +136,8 @@ void _glfwInputWindowSize(_GLFWwindow* window, int width, int height)
     window->width = width;
     window->height = height;
 
-    if (_glfwLibrary.windowSizeCallback)
+    if (window->windowSizeCallback)
-        _glfwLibrary.windowSizeCallback(window, width, height);
+        window->windowSizeCallback(window, width, height);
 }
 
 
@@ -178,8 +152,8 @@ void _glfwInputWindowIconify(_GLFWwindow* window, int iconified)
 
     window->iconified = iconified;
 
-    if (_glfwLibrary.windowIconifyCallback)
+    if (window->windowIconifyCallback)
-        _glfwLibrary.windowIconifyCallback(window, iconified);
+        window->windowIconifyCallback(window, iconified);
 }
 
 
@@ -199,8 +173,8 @@ void _glfwInputWindowVisibility(_GLFWwindow* window, int visible)
 
 void _glfwInputWindowDamage(_GLFWwindow* window)
 {
-    if (_glfwLibrary.windowRefreshCallback)
+    if (window->windowRefreshCallback)
-        _glfwLibrary.windowRefreshCallback(window);
+        window->windowRefreshCallback(window);
 }
 
 
@@ -210,8 +184,8 @@ void _glfwInputWindowDamage(_GLFWwindow* window)
 
 void _glfwInputWindowCloseRequest(_GLFWwindow* window)
 {
-    if (_glfwLibrary.windowCloseCallback)
+    if (window->windowCloseCallback)
-        window->closeRequested = _glfwLibrary.windowCloseCallback(window);
+        window->closeRequested = window->windowCloseCallback(window);
     else
         window->closeRequested = GL_TRUE;
 }
@@ -274,9 +248,6 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
     wndconfig.monitor        = (_GLFWmonitor*) monitor;
     wndconfig.share          = (_GLFWwindow*) share;
 
-    // Reset to default values for the next call
-    _glfwSetDefaultWindowHints();
-
     // Check the OpenGL bits of the window config
     if (!_glfwIsValidContextConfig(&wndconfig))
         return GL_FALSE;
@@ -369,6 +340,38 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
 }
 
 
+//========================================================================
+// Reset all window hints to their default values
+//========================================================================
+
+void glfwDefaultWindowHints(void)
+{
+    if (!_glfwInitialized)
+    {
+        _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
+        return;
+    }
+
+    memset(&_glfwLibrary.hints, 0, sizeof(_glfwLibrary.hints));
+
+    // The default is OpenGL with minimum version 1.0
+    _glfwLibrary.hints.clientAPI = GLFW_OPENGL_API;
+    _glfwLibrary.hints.glMajor = 1;
+    _glfwLibrary.hints.glMinor = 0;
+
+    // The default is to show the window and allow window resizing
+    _glfwLibrary.hints.resizable = GL_TRUE;
+    _glfwLibrary.hints.visible   = GL_TRUE;
+
+    // The default is 24 bits of color, 24 bits of depth and 8 bits of stencil
+    _glfwLibrary.hints.redBits     = 8;
+    _glfwLibrary.hints.greenBits   = 8;
+    _glfwLibrary.hints.blueBits    = 8;
+    _glfwLibrary.hints.depthBits   = 24;
+    _glfwLibrary.hints.stencilBits = 8;
+}
+
+
 //========================================================================
 // Set hints for creating the window
 //========================================================================
@@ -819,15 +822,17 @@ GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow handle)
 // Set callback function for window size changes
 //========================================================================
 
-GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun)
+GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow handle, GLFWwindowsizefun cbfun)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
         return;
     }
 
-    _glfwLibrary.windowSizeCallback = cbfun;
+    window->windowSizeCallback = cbfun;
 }
 
 
@@ -835,15 +840,17 @@ GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun)
 // Set callback function for window close events
 //========================================================================
 
-GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun)
+GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow handle, GLFWwindowclosefun cbfun)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
         return;
     }
 
-    _glfwLibrary.windowCloseCallback = cbfun;
+    window->windowCloseCallback = cbfun;
 }
 
 
@@ -851,15 +858,17 @@ GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun)
 // Set callback function for window refresh events
 //========================================================================
 
-GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun)
+GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow handle, GLFWwindowrefreshfun cbfun)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
         return;
     }
 
-    _glfwLibrary.windowRefreshCallback = cbfun;
+    window->windowRefreshCallback = cbfun;
 }
 
 
@@ -867,15 +876,17 @@ GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun)
 // Set callback function for window focus events
 //========================================================================
 
-GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun)
+GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow handle, GLFWwindowfocusfun cbfun)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
         return;
     }
 
-    _glfwLibrary.windowFocusCallback = cbfun;
+    window->windowFocusCallback = cbfun;
 }
 
 
@@ -883,15 +894,17 @@ GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun)
 // Set callback function for window iconification events
 //========================================================================
 
-GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindowiconifyfun cbfun)
+GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow handle, GLFWwindowiconifyfun cbfun)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
     if (!_glfwInitialized)
     {
         _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
         return;
     }
 
-    _glfwLibrary.windowIconifyCallback = cbfun;
+    window->windowIconifyCallback = cbfun;
 }
 
 

tests/accuracy.c

@@ -86,10 +86,6 @@ int main(void)
         exit(EXIT_FAILURE);
     }
 
-    glfwSetCursorPosCallback(cursor_position_callback);
-    glfwSetWindowSizeCallback(window_size_callback);
-    glfwSetKeyCallback(key_callback);
-
     window = glfwCreateWindow(window_width, window_height, "", NULL, NULL);
     if (!window)
     {
@@ -99,6 +95,10 @@ int main(void)
         exit(EXIT_FAILURE);
     }
 
+    glfwSetCursorPosCallback(window, cursor_position_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+    glfwSetKeyCallback(window, key_callback);
+
     glfwMakeContextCurrent(window);
 
     glfwGetWindowSize(window, &width, &height);

tests/clipboard.c

@@ -137,9 +137,9 @@ int main(int argc, char** argv)
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 
-    glfwSetKeyCallback(key_callback);
+    glfwSetKeyCallback(window, key_callback);
-    glfwSetWindowSizeCallback(window_size_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
 
     glMatrixMode(GL_PROJECTION);
     glOrtho(-1.f, 1.f, -1.f, 1.f, -1.f, 1.f);

tests/events.c

@@ -386,19 +386,6 @@ int main(void)
 
     printf("Library initialized\n");
 
-    glfwSetWindowSizeCallback(window_size_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
-    glfwSetWindowRefreshCallback(window_refresh_callback);
-    glfwSetWindowFocusCallback(window_focus_callback);
-    glfwSetWindowIconifyCallback(window_iconify_callback);
-    glfwSetMouseButtonCallback(mouse_button_callback);
-    glfwSetCursorPosCallback(cursor_position_callback);
-    glfwSetCursorEnterCallback(cursor_enter_callback);
-    glfwSetScrollCallback(scroll_callback);
-    glfwSetKeyCallback(key_callback);
-    glfwSetCharCallback(char_callback);
-    glfwSetMonitorCallback(monitor_callback);
-
     window = glfwCreateWindow(0, 0, "Event Linter", NULL, NULL);
     if (!window)
     {
@@ -410,6 +397,20 @@ int main(void)
 
     printf("Window opened\n");
 
+    glfwSetMonitorCallback(monitor_callback);
+
+    glfwSetWindowSizeCallback(window, window_size_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
+    glfwSetWindowRefreshCallback(window, window_refresh_callback);
+    glfwSetWindowFocusCallback(window, window_focus_callback);
+    glfwSetWindowIconifyCallback(window, window_iconify_callback);
+    glfwSetMouseButtonCallback(window, mouse_button_callback);
+    glfwSetCursorPosCallback(window, cursor_position_callback);
+    glfwSetCursorEnterCallback(window, cursor_enter_callback);
+    glfwSetScrollCallback(window, scroll_callback);
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetCharCallback(window, char_callback);
+
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 

tests/fsaa.c

@@ -93,9 +93,6 @@ int main(int argc, char** argv)
     else
         printf("Requesting that FSAA not be available\n");
 
-    glfwSetKeyCallback(key_callback);
-    glfwSetWindowSizeCallback(window_size_callback);
-
     glfwWindowHint(GLFW_FSAA_SAMPLES, samples);
 
     window = glfwCreateWindow(800, 400, "Aliasing Detector", NULL, NULL);
@@ -107,6 +104,9 @@ int main(int argc, char** argv)
         exit(EXIT_FAILURE);
     }
 
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 

tests/fsfocus.c

@@ -96,9 +96,9 @@ int main(void)
 
     glfwSetInputMode(window, GLFW_CURSOR_MODE, GLFW_CURSOR_NORMAL);
 
-    glfwSetWindowFocusCallback(window_focus_callback);
+    glfwSetWindowFocusCallback(window, window_focus_callback);
-    glfwSetKeyCallback(window_key_callback);
+    glfwSetKeyCallback(window, window_key_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
 
     while (running)
     {

tests/gamma.c

@@ -151,9 +151,9 @@ int main(int argc, char** argv)
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 
-    glfwSetKeyCallback(key_callback);
+    glfwSetKeyCallback(window, key_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
-    glfwSetWindowSizeCallback(size_callback);
+    glfwSetWindowSizeCallback(window, size_callback);
 
     glMatrixMode(GL_PROJECTION);
     glOrtho(-1.f, 1.f, -1.f, 1.f, -1.f, 1.f);

tests/glfwinfo.c

@@ -106,7 +106,10 @@ static void list_extensions(int api, int major, int minor)
     {
         PFNGLGETSTRINGIPROC glGetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
         if (!glGetStringi)
+        {
+            glfwTerminate();
             exit(EXIT_FAILURE);
+        }
 
         glGetIntegerv(GL_NUM_EXTENSIONS, &count);
 
@@ -267,7 +270,10 @@ int main(int argc, char** argv)
 
     window = glfwCreateWindow(0, 0, "Version", NULL, NULL);
     if (!window)
+    {
+        glfwTerminate();
         exit(EXIT_FAILURE);
+    }
 
     glfwMakeContextCurrent(window);
 

tests/iconify.c

@@ -144,11 +144,11 @@ int main(int argc, char** argv)
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 
-    glfwSetKeyCallback(key_callback);
+    glfwSetKeyCallback(window, key_callback);
-    glfwSetWindowSizeCallback(window_size_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
-    glfwSetWindowFocusCallback(window_focus_callback);
+    glfwSetWindowFocusCallback(window, window_focus_callback);
-    glfwSetWindowIconifyCallback(window_iconify_callback);
+    glfwSetWindowIconifyCallback(window, window_iconify_callback);
 
     printf("Window is %s and %s\n",
            glfwGetWindowParam(window, GLFW_ICONIFIED) ? "iconified" : "restored",

tests/joysticks.c

@@ -195,7 +195,7 @@ int main(void)
         exit(EXIT_FAILURE);
     }
 
-    glfwSetWindowSizeCallback(window_size_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
 
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);

tests/modes.c

@@ -127,10 +127,6 @@ static void test_modes(GLFWmonitor monitor)
     int i, count;
     GLFWvidmode* modes = glfwGetVideoModes(monitor, &count);
 
-    glfwSetWindowSizeCallback(window_size_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
-    glfwSetKeyCallback(key_callback);
-
     for (i = 0;  i < count;  i++)
     {
         GLFWvidmode* mode = modes + i;
@@ -157,6 +153,10 @@ static void test_modes(GLFWmonitor monitor)
             continue;
         }
 
+        glfwSetWindowSizeCallback(window_handle, window_size_callback);
+        glfwSetWindowCloseCallback(window_handle, window_close_callback);
+        glfwSetKeyCallback(window_handle, key_callback);
+
         glfwMakeContextCurrent(window_handle);
         glfwSwapInterval(1);
 
@@ -171,6 +171,8 @@ static void test_modes(GLFWmonitor monitor)
             if (!window_handle)
             {
                 printf("User terminated program\n");
+
+                glfwTerminate();
                 exit(EXIT_SUCCESS);
             }
         }
@@ -244,6 +246,7 @@ int main(int argc, char** argv)
             test_modes(monitors[i]);
     }
 
+    glfwTerminate();
     exit(EXIT_SUCCESS);
 }
 

tests/peter.c

@@ -102,9 +102,9 @@ static GLboolean open_window(void)
     glfwGetCursorPos(window_handle, &cursor_x, &cursor_y);
     printf("Cursor position: %i %i\n", cursor_x, cursor_y);
 
-    glfwSetWindowSizeCallback(window_size_callback);
+    glfwSetWindowSizeCallback(window_handle, window_size_callback);
-    glfwSetCursorPosCallback(cursor_position_callback);
+    glfwSetCursorPosCallback(window_handle, cursor_position_callback);
-    glfwSetKeyCallback(key_callback);
+    glfwSetKeyCallback(window_handle, key_callback);
 
     return GL_TRUE;
 }
@@ -120,6 +120,8 @@ int main(void)
     if (!open_window())
     {
         fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
@@ -138,6 +140,8 @@ int main(void)
             if (!open_window())
             {
                 fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
+
+                glfwTerminate();
                 exit(EXIT_FAILURE);
             }
 

tests/reopen.c

@@ -85,9 +85,9 @@ static GLboolean open_window(int width, int height, GLFWmonitor monitor)
     glfwMakeContextCurrent(window_handle);
     glfwSwapInterval(1);
 
-    glfwSetWindowSizeCallback(window_size_callback);
+    glfwSetWindowSizeCallback(window_handle, window_size_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetWindowCloseCallback(window_handle, window_close_callback);
-    glfwSetKeyCallback(key_callback);
+    glfwSetKeyCallback(window_handle, key_callback);
 
     printf("Opening %s mode window took %0.3f seconds\n",
            monitor ? "fullscreen" : "windowed",
@@ -124,7 +124,10 @@ int main(int argc, char** argv)
             monitor = glfwGetPrimaryMonitor();
 
         if (!open_window(640, 480, monitor))
+        {
+            glfwTerminate();
             exit(EXIT_FAILURE);
+        }
 
         glMatrixMode(GL_PROJECTION);
         glOrtho(-1.f, 1.f, -1.f, 1.f, 1.f, -1.f);
@@ -148,6 +151,8 @@ int main(int argc, char** argv)
             {
                 close_window();
                 printf("User closed window\n");
+
+                glfwTerminate();
                 exit(EXIT_SUCCESS);
             }
         }

tests/sharing.c

@@ -62,8 +62,8 @@ static GLFWwindow open_window(const char* title, GLFWwindow share)
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 
-    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
-    glfwSetKeyCallback(key_callback);
+    glfwSetKeyCallback(window, key_callback);
 
     return window;
 }
@@ -137,6 +137,8 @@ int main(int argc, char** argv)
     if (!windows[0])
     {
         fprintf(stderr, "Failed to open first GLFW window: %s\n", glfwErrorString(glfwGetError()));
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
@@ -149,6 +151,8 @@ int main(int argc, char** argv)
     if (!windows[1])
     {
         fprintf(stderr, "Failed to open second GLFW window: %s\n", glfwErrorString(glfwGetError()));
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 

tests/tearing.c

@@ -73,17 +73,17 @@ int main(void)
     window = glfwCreateWindow(0, 0, "", NULL, NULL);
     if (!window)
     {
-        glfwTerminate();
-
         fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
     glfwMakeContextCurrent(window);
     set_swap_interval(window, swap_interval);
 
-    glfwSetWindowSizeCallback(window_size_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
-    glfwSetKeyCallback(key_callback);
+    glfwSetKeyCallback(window, key_callback);
 
     glMatrixMode(GL_PROJECTION);
     glOrtho(-1.f, 1.f, -1.f, 1.f, 1.f, -1.f);

tests/title.c

@@ -51,13 +51,15 @@ int main(void)
     if (!window)
     {
         fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 
-    glfwSetWindowSizeCallback(window_size_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
 
     while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
     {
@@ -66,6 +68,7 @@ int main(void)
         glfwWaitEvents();
     }
 
+    glfwTerminate();
     exit(EXIT_SUCCESS);
 }
 

tests/windows.c

@@ -60,6 +60,7 @@ int main(void)
         {
             fprintf(stderr, "Failed to open GLFW window: %s\n",
                     glfwErrorString(glfwGetError()));
+
             glfwTerminate();
             exit(EXIT_FAILURE);
         }