From 5df4df6ca49dc156556d177cf21c35e5f1545175 Mon Sep 17 00:00:00 2001
From: Camilla Berglund <elmindreda@elmindreda.org>
Date: Mon, 22 Oct 2012 02:59:05 +0200
Subject: [PATCH 1/4] Added glfwDefaultWindowHints.

---
 include/GL/glfw3.h |  1 +
 readme.html        |  1 +
 src/init.c         |  6 ++---
 src/internal.h     |  3 ---
 src/window.c       | 61 ++++++++++++++++++++++++----------------------
 5 files changed, 37 insertions(+), 35 deletions(-)

diff --git a/include/GL/glfw3.h b/include/GL/glfw3.h
index 968ab0db..df0ac6b1 100644
--- a/include/GL/glfw3.h
+++ b/include/GL/glfw3.h
@@ -529,6 +529,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, int mode, const char* title, GLFWwindow share);
 GLFWAPI void glfwDestroyWindow(GLFWwindow window);
diff --git a/readme.html b/readme.html
index 22e2b6bb..a40e1d35 100644
--- a/readme.html
+++ b/readme.html
@@ -268,6 +268,7 @@ version of GLFW.</p>
 <h3>v3.0</h3>
 <ul>
   <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>
diff --git a/src/init.c b/src/init.c
index 7e9fe4e7..12d806cc 100644
--- a/src/init.c
+++ b/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();
@@ -134,6 +131,9 @@ GLFWAPI int glfwInit(void)
 
     _glfwInitialized = GL_TRUE;
 
+    // Not all window hints have zero as their default value
+    glfwDefaultWindowHints();
+
     return GL_TRUE;
 }
 
diff --git a/src/internal.h b/src/internal.h
index 67aa3151..01767c96 100644
--- a/src/internal.h
+++ b/src/internal.h
@@ -350,9 +350,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,
diff --git a/src/window.c b/src/window.c
index bb1093f5..c48fceb6 100644
--- a/src/window.c
+++ b/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
 //========================================================================
@@ -273,9 +247,6 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
     wndconfig.glRobustness   = _glfwLibrary.hints.glRobustness ? GL_TRUE : GL_FALSE;
     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;
@@ -375,6 +346,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
 //========================================================================

From d68acb78bfbd3c09511b653ea3ea95d017ea41de Mon Sep 17 00:00:00 2001
From: Camilla Berglund <elmindreda@elmindreda.org>
Date: Mon, 22 Oct 2012 03:20:16 +0200
Subject: [PATCH 2/4] Removed registering glfwTerminate with atexit.

Functions registered with atexit are called from the thread calling exit.
glfwTerminate should only be called from the main thread.  Mistakes should be
explicit.
---
 examples/heightmap.c | 7 +++++++
 examples/splitview.c | 2 ++
 examples/triangle.c  | 2 ++
 readme.html          | 1 +
 src/init.c           | 2 --
 tests/glfwinfo.c     | 6 ++++++
 tests/modes.c        | 3 +++
 tests/peter.c        | 4 ++++
 tests/reopen.c       | 5 +++++
 tests/sharing.c      | 4 ++++
 tests/tearing.c      | 4 ++--
 tests/title.c        | 3 +++
 tests/windows.c      | 1 +
 13 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/examples/heightmap.c b/examples/heightmap.c
index 5139a493..94e2bb95 100644
--- a/examples/heightmap.c
+++ b/examples/heightmap.c
@@ -595,6 +595,8 @@ int main(int argc, char** argv)
 
         free(vertex_shader_src);
         free(fragment_shader_src);
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
@@ -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);
 }
 
diff --git a/examples/splitview.c b/examples/splitview.c
index 4a48a383..92fa6c22 100644
--- a/examples/splitview.c
+++ b/examples/splitview.c
@@ -463,6 +463,8 @@ int main(void)
     if (!window)
     {
         fprintf(stderr, "Failed to open GLFW window\n");
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
diff --git a/examples/triangle.c b/examples/triangle.c
index 615483a9..3a1cef94 100644
--- a/examples/triangle.c
+++ b/examples/triangle.c
@@ -27,6 +27,8 @@ int main(void)
     if (!window)
     {
         fprintf(stderr, "Failed to open GLFW window\n");
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
diff --git a/readme.html b/readme.html
index a40e1d35..cf5eb5b8 100644
--- a/readme.html
+++ b/readme.html
@@ -318,6 +318,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>
diff --git a/src/init.c b/src/init.c
index 12d806cc..efcea20c 100644
--- a/src/init.c
+++ b/src/init.c
@@ -127,8 +127,6 @@ GLFWAPI int glfwInit(void)
         return GL_FALSE;
     }
 
-    atexit(glfwTerminate);
-
     _glfwInitialized = GL_TRUE;
 
     // Not all window hints have zero as their default value
diff --git a/tests/glfwinfo.c b/tests/glfwinfo.c
index 3b262852..792e4bd5 100644
--- a/tests/glfwinfo.c
+++ b/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, GLFW_WINDOWED, "Version", NULL);
     if (!window)
+    {
+        glfwTerminate();
         exit(EXIT_FAILURE);
+    }
 
     glfwMakeContextCurrent(window);
 
diff --git a/tests/modes.c b/tests/modes.c
index ef1db71c..60dbb8fa 100644
--- a/tests/modes.c
+++ b/tests/modes.c
@@ -157,6 +157,8 @@ static void test_modes(void)
             if (!window_handle)
             {
                 printf("User terminated program\n");
+
+                glfwTerminate();
                 exit(EXIT_SUCCESS);
             }
         }
@@ -224,6 +226,7 @@ int main(int argc, char** argv)
     else if (mode == TEST_MODE)
         test_modes();
 
+    glfwTerminate();
     exit(EXIT_SUCCESS);
 }
 
diff --git a/tests/peter.c b/tests/peter.c
index 59c917e9..d803c2a1 100644
--- a/tests/peter.c
+++ b/tests/peter.c
@@ -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);
             }
 
diff --git a/tests/reopen.c b/tests/reopen.c
index 5d137188..ad8401d8 100644
--- a/tests/reopen.c
+++ b/tests/reopen.c
@@ -132,7 +132,10 @@ int main(int argc, char** argv)
     for (;;)
     {
         if (!open_window(640, 480, (count & 1) ? GLFW_FULLSCREEN : GLFW_WINDOWED))
+        {
+            glfwTerminate();
             exit(EXIT_FAILURE);
+        }
 
         glMatrixMode(GL_PROJECTION);
         glOrtho(-1.f, 1.f, -1.f, 1.f, 1.f, -1.f);
@@ -156,6 +159,8 @@ int main(int argc, char** argv)
             {
                 close_window();
                 printf("User closed window\n");
+
+                glfwTerminate();
                 exit(EXIT_SUCCESS);
             }
         }
diff --git a/tests/sharing.c b/tests/sharing.c
index 64e61740..2f060484 100644
--- a/tests/sharing.c
+++ b/tests/sharing.c
@@ -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);
     }
 
diff --git a/tests/tearing.c b/tests/tearing.c
index a8d774a4..a4647096 100644
--- a/tests/tearing.c
+++ b/tests/tearing.c
@@ -73,9 +73,9 @@ int main(void)
     window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "", NULL);
     if (!window)
     {
-        glfwTerminate();
-
         fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
diff --git a/tests/title.c b/tests/title.c
index c7539033..38535708 100644
--- a/tests/title.c
+++ b/tests/title.c
@@ -51,6 +51,8 @@ int main(void)
     if (!window)
     {
         fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError()));
+
+        glfwTerminate();
         exit(EXIT_FAILURE);
     }
 
@@ -66,6 +68,7 @@ int main(void)
         glfwWaitEvents();
     }
 
+    glfwTerminate();
     exit(EXIT_SUCCESS);
 }
 
diff --git a/tests/windows.c b/tests/windows.c
index 894febeb..ddf67915 100644
--- a/tests/windows.c
+++ b/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);
         }

From 18d71c2b6d031c58d0d1e7c6406431a19b92aca8 Mon Sep 17 00:00:00 2001
From: Camilla Berglund <elmindreda@elmindreda.org>
Date: Sun, 28 Oct 2012 13:45:11 +0100
Subject: [PATCH 3/4] Made window-related callbacks per-window.

This makes polymorphic behaviour easier to implement and avoids the problem of
events being triggered before the GLFW window object is fully usable.
---
 examples/boing.c     |  4 +--
 examples/gears.c     | 10 +++----
 examples/heightmap.c |  4 +--
 examples/splitview.c | 12 ++++-----
 examples/wave.c      | 14 +++++-----
 include/GL/glfw3.h   | 22 +++++++--------
 src/input.c          | 64 ++++++++++++++++++++++++++------------------
 src/internal.h       | 24 ++++++++---------
 src/window.c         | 54 ++++++++++++++++++++++---------------
 tests/accuracy.c     |  8 +++---
 tests/clipboard.c    |  6 ++---
 tests/events.c       | 24 ++++++++---------
 tests/fsaa.c         |  6 ++---
 tests/fsfocus.c      |  6 ++---
 tests/gamma.c        |  6 ++---
 tests/iconify.c      | 10 +++----
 tests/joysticks.c    |  2 +-
 tests/modes.c        |  8 +++---
 tests/peter.c        |  6 ++---
 tests/reopen.c       |  6 ++---
 tests/sharing.c      |  4 +--
 tests/tearing.c      |  4 +--
 tests/title.c        |  2 +-
 23 files changed, 164 insertions(+), 142 deletions(-)

diff --git a/examples/boing.c b/examples/boing.c
index a2094c5f..5a1993ff 100644
--- a/examples/boing.c
+++ b/examples/boing.c
@@ -577,8 +577,6 @@ int main( void )
       exit( EXIT_FAILURE );
    }
 
-   glfwSetWindowSizeCallback( reshape );
-
    glfwWindowHint(GLFW_DEPTH_BITS, 16);
 
    window = glfwCreateWindow( 400, 400, GLFW_WINDOWED, "Boing (classic Amiga demo)", NULL );
@@ -589,6 +587,8 @@ int main( void )
        exit( EXIT_FAILURE );
    }
 
+   glfwSetWindowSizeCallback(window, reshape);
+
    glfwMakeContextCurrent(window);
    glfwSwapInterval( 1 );
 
diff --git a/examples/gears.c b/examples/gears.c
index cd3cdbb1..63f973d2 100644
--- a/examples/gears.c
+++ b/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, GLFW_WINDOWED, "Gears", 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 );
 
diff --git a/examples/heightmap.c b/examples/heightmap.c
index 94e2bb95..6abaa1ec 100644
--- a/examples/heightmap.c
+++ b/examples/heightmap.c
@@ -601,8 +601,8 @@ int main(int argc, char** argv)
     }
 
     /* Register events callback */
-    glfwSetWindowCloseCallback(window_close_callback);
-    glfwSetKeyCallback(key_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
+    glfwSetKeyCallback(window, key_callback);
 
     glfwMakeContextCurrent(window);
     if (GL_TRUE != init_opengl())
diff --git a/examples/splitview.c b/examples/splitview.c
index 92fa6c22..965a183c 100644
--- a/examples/splitview.c
+++ b/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
@@ -468,6 +462,12 @@ int main(void)
         exit(EXIT_FAILURE);
     }
 
+    // Set callback functions
+    glfwSetWindowSizeCallback(window, windowSizeFun);
+    glfwSetWindowRefreshCallback(window, windowRefreshFun);
+    glfwSetCursorPosCallback(window, cursorPosFun);
+    glfwSetMouseButtonCallback(window, mouseButtonFun);
+
     // Enable vsync
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
diff --git a/examples/wave.c b/examples/wave.c
index 668d54bd..c04bfb2d 100644
--- a/examples/wave.c
+++ b/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, GLFW_WINDOWED, "Wave Simulation", 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);
 
diff --git a/include/GL/glfw3.h b/include/GL/glfw3.h
index df0ac6b1..87ba9423 100644
--- a/include/GL/glfw3.h
+++ b/include/GL/glfw3.h
@@ -545,11 +545,11 @@ GLFWAPI void glfwHideWindow(GLFWwindow window);
 GLFWAPI int  glfwGetWindowParam(GLFWwindow window, int param);
 GLFWAPI void glfwSetWindowUserPointer(GLFWwindow window, void* pointer);
 GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow window);
-GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun);
-GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun);
-GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun);
-GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun);
-GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindowiconifyfun cbfun);
+GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfun);
+GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cbfun);
+GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfun cbfun);
+GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cbfun);
+GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow window, GLFWwindowiconifyfun cbfun);
 
 /* Event handling */
 GLFWAPI void glfwPollEvents(void);
@@ -563,12 +563,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 glfwSetCharCallback(GLFWcharfun cbfun);
-GLFWAPI void glfwSetMouseButtonCallback(GLFWmousebuttonfun cbfun);
-GLFWAPI void glfwSetCursorPosCallback(GLFWcursorposfun cbfun);
-GLFWAPI void glfwSetCursorEnterCallback(GLFWcursorenterfun cbfun);
-GLFWAPI void glfwSetScrollCallback(GLFWscrollfun cbfun);
+GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun);
+GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun);
+GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cbfun);
+GLFWAPI void glfwSetCursorPosCallback(GLFWwindow window, GLFWcursorposfun cbfun);
+GLFWAPI void glfwSetCursorEnterCallback(GLFWwindow window, GLFWcursorenterfun cbfun);
+GLFWAPI void glfwSetScrollCallback(GLFWwindow window, GLFWscrollfun cbfun);
 
 /* Joystick input */
 GLFWAPI int glfwGetJoystickParam(int joy, int param);
diff --git a/src/input.c b/src/input.c
index 52b3b0fb..701da4f0 100644
--- a/src/input.c
+++ b/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))
-        _glfwLibrary.keyCallback(window, key, action);
+    if (window->keyCallback && (window->keyRepeat || !repeated))
+        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)
-        _glfwLibrary.charCallback(window, character);
+    if (window->charCallback)
+        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)
-        _glfwLibrary.scrollCallback(window, xoffset, yoffset);
+    if (window->scrollCallback)
+        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)
-        _glfwLibrary.mouseButtonCallback(window, button, action);
+    if (window->mouseButtonCallback)
+        window->mouseButtonCallback(window, button, action);
 }
 
 
@@ -249,11 +249,11 @@ void _glfwInputCursorMotion(_GLFWwindow* window, int x, int y)
         window->cursorPosY = y;
     }
 
-    if (_glfwLibrary.cursorPosCallback)
+    if (window->cursorPosCallback)
     {
-        _glfwLibrary.cursorPosCallback(window,
-                                       window->cursorPosX,
-                                       window->cursorPosY);
+        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)
-        _glfwLibrary.cursorEnterCallback(window, entered);
+    if (window->cursorEnterCallback)
+        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;
 }
 
diff --git a/src/internal.h b/src/internal.h
index 01767c96..3f70426a 100644
--- a/src/internal.h
+++ b/src/internal.h
@@ -197,6 +197,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;
@@ -213,18 +225,6 @@ struct _GLFWlibrary
     _GLFWwindow*  windowListHead;
     _GLFWwindow*  activeWindow;
 
-    GLFWwindowsizefun    windowSizeCallback;
-    GLFWwindowclosefun   windowCloseCallback;
-    GLFWwindowrefreshfun windowRefreshCallback;
-    GLFWwindowfocusfun   windowFocusCallback;
-    GLFWwindowiconifyfun windowIconifyCallback;
-    GLFWmousebuttonfun   mouseButtonCallback;
-    GLFWcursorposfun     cursorPosCallback;
-    GLFWcursorenterfun   cursorEnterCallback;
-    GLFWscrollfun        scrollCallback;
-    GLFWkeyfun           keyCallback;
-    GLFWcharfun          charCallback;
-
     GLFWgammaramp currentRamp;
     GLFWgammaramp originalRamp;
     int           originalRampSize;
diff --git a/src/window.c b/src/window.c
index c48fceb6..b86dcfec 100644
--- a/src/window.c
+++ b/src/window.c
@@ -80,8 +80,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
         {
             _glfwLibrary.activeWindow = window;
 
-            if (_glfwLibrary.windowFocusCallback)
-                _glfwLibrary.windowFocusCallback(window, activated);
+            if (window->windowFocusCallback)
+                window->windowFocusCallback(window, activated);
         }
     }
     else
@@ -106,8 +106,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
 
             _glfwLibrary.activeWindow = NULL;
 
-            if (_glfwLibrary.windowFocusCallback)
-                _glfwLibrary.windowFocusCallback(window, activated);
+            if (window->windowFocusCallback)
+                window->windowFocusCallback(window, activated);
         }
     }
 }
@@ -136,8 +136,8 @@ void _glfwInputWindowSize(_GLFWwindow* window, int width, int height)
     window->width = width;
     window->height = height;
 
-    if (_glfwLibrary.windowSizeCallback)
-        _glfwLibrary.windowSizeCallback(window, width, height);
+    if (window->windowSizeCallback)
+        window->windowSizeCallback(window, width, height);
 }
 
 
@@ -152,8 +152,8 @@ void _glfwInputWindowIconify(_GLFWwindow* window, int iconified)
 
     window->iconified = iconified;
 
-    if (_glfwLibrary.windowIconifyCallback)
-        _glfwLibrary.windowIconifyCallback(window, iconified);
+    if (window->windowIconifyCallback)
+        window->windowIconifyCallback(window, iconified);
 }
 
 
@@ -173,8 +173,8 @@ void _glfwInputWindowVisibility(_GLFWwindow* window, int visible)
 
 void _glfwInputWindowDamage(_GLFWwindow* window)
 {
-    if (_glfwLibrary.windowRefreshCallback)
-        _glfwLibrary.windowRefreshCallback(window);
+    if (window->windowRefreshCallback)
+        window->windowRefreshCallback(window);
 }
 
 
@@ -184,8 +184,8 @@ void _glfwInputWindowDamage(_GLFWwindow* window)
 
 void _glfwInputWindowCloseRequest(_GLFWwindow* window)
 {
-    if (_glfwLibrary.windowCloseCallback)
-        window->closeRequested = _glfwLibrary.windowCloseCallback(window);
+    if (window->windowCloseCallback)
+        window->closeRequested = window->windowCloseCallback(window);
     else
         window->closeRequested = GL_TRUE;
 }
@@ -810,15 +810,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;
 }
 
 
@@ -826,15 +828,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;
 }
 
 
@@ -842,15 +846,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;
 }
 
 
@@ -858,15 +864,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;
 }
 
 
@@ -874,15 +882,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;
 }
 
 
diff --git a/tests/accuracy.c b/tests/accuracy.c
index f3fb752b..d320f64c 100644
--- a/tests/accuracy.c
+++ b/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, GLFW_WINDOWED, "", 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);
diff --git a/tests/clipboard.c b/tests/clipboard.c
index f83bbfea..818e6e65 100644
--- a/tests/clipboard.c
+++ b/tests/clipboard.c
@@ -137,9 +137,9 @@ int main(int argc, char** argv)
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 
-    glfwSetKeyCallback(key_callback);
-    glfwSetWindowSizeCallback(window_size_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
 
     glMatrixMode(GL_PROJECTION);
     glOrtho(-1.f, 1.f, -1.f, 1.f, -1.f, 1.f);
diff --git a/tests/events.c b/tests/events.c
index 809da473..9379ded9 100644
--- a/tests/events.c
+++ b/tests/events.c
@@ -363,18 +363,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);
-
     window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Event Linter", NULL);
     if (!window)
     {
@@ -386,6 +374,18 @@ int main(void)
 
     printf("Window opened\n");
 
+    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);
 
diff --git a/tests/fsaa.c b/tests/fsaa.c
index 8fc8b60a..735a1f5f 100644
--- a/tests/fsaa.c
+++ b/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, GLFW_WINDOWED, "Aliasing Detector", 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);
 
diff --git a/tests/fsfocus.c b/tests/fsfocus.c
index 1c46d7af..17ffc35f 100644
--- a/tests/fsfocus.c
+++ b/tests/fsfocus.c
@@ -96,9 +96,9 @@ int main(void)
 
     glfwSetInputMode(window, GLFW_CURSOR_MODE, GLFW_CURSOR_NORMAL);
 
-    glfwSetWindowFocusCallback(window_focus_callback);
-    glfwSetKeyCallback(window_key_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
+    glfwSetWindowFocusCallback(window, window_focus_callback);
+    glfwSetKeyCallback(window, window_key_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
 
     while (running)
     {
diff --git a/tests/gamma.c b/tests/gamma.c
index c30dd53c..9ff0e9e5 100644
--- a/tests/gamma.c
+++ b/tests/gamma.c
@@ -151,9 +151,9 @@ int main(int argc, char** argv)
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 
-    glfwSetKeyCallback(key_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
-    glfwSetWindowSizeCallback(size_callback);
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
+    glfwSetWindowSizeCallback(window, size_callback);
 
     glMatrixMode(GL_PROJECTION);
     glOrtho(-1.f, 1.f, -1.f, 1.f, -1.f, 1.f);
diff --git a/tests/iconify.c b/tests/iconify.c
index 0ecde623..f7a87cba 100644
--- a/tests/iconify.c
+++ b/tests/iconify.c
@@ -144,11 +144,11 @@ int main(int argc, char** argv)
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 
-    glfwSetKeyCallback(key_callback);
-    glfwSetWindowSizeCallback(window_size_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
-    glfwSetWindowFocusCallback(window_focus_callback);
-    glfwSetWindowIconifyCallback(window_iconify_callback);
+    glfwSetKeyCallback(window, key_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
+    glfwSetWindowFocusCallback(window, window_focus_callback);
+    glfwSetWindowIconifyCallback(window, window_iconify_callback);
 
     printf("Window is %s and %s\n",
            glfwGetWindowParam(window, GLFW_ICONIFIED) ? "iconified" : "restored",
diff --git a/tests/joysticks.c b/tests/joysticks.c
index 40202ce7..a41eaa5f 100644
--- a/tests/joysticks.c
+++ b/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);
diff --git a/tests/modes.c b/tests/modes.c
index 60dbb8fa..e1f13faa 100644
--- a/tests/modes.c
+++ b/tests/modes.c
@@ -117,10 +117,6 @@ static void test_modes(void)
     int i, count;
     GLFWvidmode* modes = glfwGetVideoModes(&count);
 
-    glfwSetWindowSizeCallback(window_size_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
-    glfwSetKeyCallback(key_callback);
-
     for (i = 0;  i < count;  i++)
     {
         GLFWvidmode* mode = modes + i;
@@ -143,6 +139,10 @@ static void test_modes(void)
             continue;
         }
 
+        glfwSetWindowSizeCallback(window_handle, window_size_callback);
+        glfwSetWindowCloseCallback(window_handle, window_close_callback);
+        glfwSetKeyCallback(window_handle, key_callback);
+
         glfwMakeContextCurrent(window_handle);
         glfwSwapInterval(1);
 
diff --git a/tests/peter.c b/tests/peter.c
index d803c2a1..32748932 100644
--- a/tests/peter.c
+++ b/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);
-    glfwSetCursorPosCallback(cursor_position_callback);
-    glfwSetKeyCallback(key_callback);
+    glfwSetWindowSizeCallback(window_handle, window_size_callback);
+    glfwSetCursorPosCallback(window_handle, cursor_position_callback);
+    glfwSetKeyCallback(window_handle, key_callback);
 
     return GL_TRUE;
 }
diff --git a/tests/reopen.c b/tests/reopen.c
index ad8401d8..212c108d 100644
--- a/tests/reopen.c
+++ b/tests/reopen.c
@@ -102,9 +102,9 @@ static GLboolean open_window(int width, int height, int mode)
     glfwMakeContextCurrent(window_handle);
     glfwSwapInterval(1);
 
-    glfwSetWindowSizeCallback(window_size_callback);
-    glfwSetWindowCloseCallback(window_close_callback);
-    glfwSetKeyCallback(key_callback);
+    glfwSetWindowSizeCallback(window_handle, window_size_callback);
+    glfwSetWindowCloseCallback(window_handle, window_close_callback);
+    glfwSetKeyCallback(window_handle, key_callback);
 
     printf("Opening %s mode window took %0.3f seconds\n",
            get_mode_name(mode),
diff --git a/tests/sharing.c b/tests/sharing.c
index 2f060484..41ce8db5 100644
--- a/tests/sharing.c
+++ b/tests/sharing.c
@@ -62,8 +62,8 @@ static GLFWwindow open_window(const char* title, GLFWwindow share)
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 
-    glfwSetWindowCloseCallback(window_close_callback);
-    glfwSetKeyCallback(key_callback);
+    glfwSetWindowCloseCallback(window, window_close_callback);
+    glfwSetKeyCallback(window, key_callback);
 
     return window;
 }
diff --git a/tests/tearing.c b/tests/tearing.c
index a4647096..e3149c35 100644
--- a/tests/tearing.c
+++ b/tests/tearing.c
@@ -82,8 +82,8 @@ int main(void)
     glfwMakeContextCurrent(window);
     set_swap_interval(window, swap_interval);
 
-    glfwSetWindowSizeCallback(window_size_callback);
-    glfwSetKeyCallback(key_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+    glfwSetKeyCallback(window, key_callback);
 
     glMatrixMode(GL_PROJECTION);
     glOrtho(-1.f, 1.f, -1.f, 1.f, 1.f, -1.f);
diff --git a/tests/title.c b/tests/title.c
index 38535708..a9abebb2 100644
--- a/tests/title.c
+++ b/tests/title.c
@@ -59,7 +59,7 @@ int main(void)
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
 
-    glfwSetWindowSizeCallback(window_size_callback);
+    glfwSetWindowSizeCallback(window, window_size_callback);
 
     while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED))
     {

From 4fc32a4bbf2f5402fb8fc83adfe48b96ce287496 Mon Sep 17 00:00:00 2001
From: Camilla Berglund <elmindreda@elmindreda.org>
Date: Wed, 31 Oct 2012 16:11:09 +0100
Subject: [PATCH 4/4] Comment fix.

---
 src/internal.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/internal.h b/src/internal.h
index 3f70426a..bbbced89 100644
--- a/src/internal.h
+++ b/src/internal.h
@@ -172,7 +172,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