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

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);
-    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);

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);
-    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)
     {

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);

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);
-    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",

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);
-    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;
 }
@@ -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);
-    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",
            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);
-    glfwSetKeyCallback(key_callback);
+    glfwSetWindowCloseCallback(window, window_close_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);
-    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);

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);
         }