diff --git a/examples/boing.c b/examples/boing.c
index 8dc6ac95..a5914f9d 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, "Boing (classic Amiga demo)", NULL, 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 d5d93251..4b814b79 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, "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 );
diff --git a/examples/heightmap.c b/examples/heightmap.c
index 43f8da8a..60ac99d2 100644
--- a/examples/heightmap.c
+++ b/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);
- glfwSetKeyCallback(key_callback);
+ glfwSetWindowCloseCallback(window, window_close_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);
}
diff --git a/examples/splitview.c b/examples/splitview.c
index 86339e4e..9b3e0858 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
@@ -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);
diff --git a/examples/triangle.c b/examples/triangle.c
index 6d15c7b3..52e11498 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/examples/wave.c b/examples/wave.c
index 3dfce8ef..4ac443cc 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, "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);
diff --git a/include/GL/glfw3.h b/include/GL/glfw3.h
index a1341ea4..1021412c 100644
--- a/include/GL/glfw3.h
+++ b/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 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);
@@ -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 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/readme.html b/readme.html
index 5b5e2214..f1dbb5b7 100644
--- a/readme.html
+++ b/readme.html
@@ -273,6 +273,7 @@ version of GLFW.
Added glfwSetMonitorUserPointer and glfwGetMonitorUserPointer for per-monitor user pointers
Added glfwSetMonitorCallback and GLFWmonitorfun for notification of changes in the set of available monitors
Added GLFWwindow window handle type and updated window-related functions and callbacks to take a window handle
+ Added glfwDefaultWindowHints function for resetting all window hints to their default values
Added glfwMakeContextCurrent function for making the context of the specified window current
Added glfwGetError and glfwErrorString error reporting functions and a number of error tokens
Added glfwSetErrorCallback function and GLFWerrorfun type for receiving more specific and/or nested errors
@@ -323,6 +324,7 @@ version of GLFW.
Removed the entire threading API
Removed the entire image loading API
Removed deprecated Carbon port
+ Removed registering glfwTerminate with atexit
Removed glfwSleep function
Removed glfwGetNumberOfProcessors function
Removed glfwGetGLVersion function
diff --git a/src/init.c b/src/init.c
index 453c2c66..02ccc111 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();
@@ -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;
}
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 df8fd249..ee82f5df 100644
--- a/src/internal.h
+++ b/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,19 +253,7 @@ 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;
+ GLFWmonitorfun monitorCallback;
GLFWgammaramp currentRamp;
GLFWgammaramp originalRamp;
@@ -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,
diff --git a/src/window.c b/src/window.c
index 7c85dc82..10a77f9b 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
//========================================================================
@@ -107,8 +81,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
{
@@ -133,8 +107,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
_glfwLibrary.activeWindow = NULL;
- if (_glfwLibrary.windowFocusCallback)
- _glfwLibrary.windowFocusCallback(window, activated);
+ if (window->windowFocusCallback)
+ 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)
- _glfwLibrary.windowSizeCallback(window, width, height);
+ if (window->windowSizeCallback)
+ window->windowSizeCallback(window, width, height);
}
@@ -178,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);
}
@@ -199,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);
}
@@ -210,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;
}
@@ -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;
}
diff --git a/tests/accuracy.c b/tests/accuracy.c
index f9c485c9..e26d0456 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, "", 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);
diff --git a/tests/clipboard.c b/tests/clipboard.c
index eafce3f7..9d4e2c18 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 a006e447..9febb2d0 100644
--- a/tests/events.c
+++ b/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);
diff --git a/tests/fsaa.c b/tests/fsaa.c
index 060d0b7b..a80f79ec 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, "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);
diff --git a/tests/fsfocus.c b/tests/fsfocus.c
index a00e4fa4..72570ca3 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 aaed81d9..e65bd96f 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/glfwinfo.c b/tests/glfwinfo.c
index f6e1aa75..3a4526c8 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, "Version", NULL, NULL);
if (!window)
+ {
+ glfwTerminate();
exit(EXIT_FAILURE);
+ }
glfwMakeContextCurrent(window);
diff --git a/tests/iconify.c b/tests/iconify.c
index d5544b07..06016bb3 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 78bcb702..3f8c06cb 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 478a9354..ecf54258 100644
--- a/tests/modes.c
+++ b/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);
}
diff --git a/tests/peter.c b/tests/peter.c
index 6515d2e4..68cbcd2d 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;
}
@@ -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 c095424e..5097b65b 100644
--- a/tests/reopen.c
+++ b/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);
}
}
diff --git a/tests/sharing.c b/tests/sharing.c
index 6989105b..e02128f5 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;
}
@@ -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 734b96c8..81b7738d 100644
--- a/tests/tearing.c
+++ b/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);
diff --git a/tests/title.c b/tests/title.c
index b151d751..4c5a9163 100644
--- a/tests/title.c
+++ b/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);
}
diff --git a/tests/windows.c b/tests/windows.c
index 46481dfb..a49cb727 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);
}