Navy.gif/glfw
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' into multi-monitor

Browse Source 
Conflicts:
	examples/wave.c
	src/init.c
	src/internal.h
	src/window.c
	tests/accuracy.c
	tests/events.c
	tests/reopen.c
This commit is contained in:
Camilla Berglund 2012-11-01 00:07:01 +01:00
commit 7c426d1c92
28 changed files with 245 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/boing.c
View File

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

10
examples/gears.c
View File

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

11
examples/heightmap.c
View File

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

14
examples/splitview.c
View File

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

2
examples/triangle.c
View File

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

14
examples/wave.c
View File

@ -399,13 +399,6 @@ int main(int argc, char* argv[])
exit(EXIT_FAILURE); 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); window = glfwCreateWindow(640, 480, "Wave Simulation", NULL, NULL);
if (!window) if (!window)
{ {
@ -413,6 +406,13 @@ int main(int argc, char* argv[])
exit(EXIT_FAILURE); 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); glfwMakeContextCurrent(window);
glfwSwapInterval(1); glfwSwapInterval(1);

23
include/GL/glfw3.h
View File

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

2
readme.html
View File

@ -273,6 +273,7 @@ version of GLFW.</p>
<li>Added <code>glfwSetMonitorUserPointer</code> and <code>glfwGetMonitorUserPointer</code> for per-monitor user pointers</li> <li>Added <code>glfwSetMonitorUserPointer</code> and <code>glfwGetMonitorUserPointer</code> for per-monitor user pointers</li>
<li>Added <code>glfwSetMonitorCallback</code> and <code>GLFWmonitorfun</code> for notification of changes in the set of available monitors</li> <li>Added <code>glfwSetMonitorCallback</code> and <code>GLFWmonitorfun</code> for notification of changes in the set of available monitors</li>
<li>Added <code>GLFWwindow</code> window handle type and updated window-related functions and callbacks to take a window handle</li> <li>Added <code>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>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>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> <li>Added <code>glfwSetErrorCallback</code> function and <code>GLFWerrorfun</code> type for receiving more specific and/or nested errors</li>
@ -323,6 +324,7 @@ version of GLFW.</p>
<li>Removed the entire threading API</li> <li>Removed the entire threading API</li>
<li>Removed the entire image loading API</li> <li>Removed the entire image loading API</li>
<li>Removed deprecated Carbon port</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>glfwSleep</code> function</li>
<li>Removed <code>glfwGetNumberOfProcessors</code> function</li> <li>Removed <code>glfwGetNumberOfProcessors</code> function</li>
<li>Removed <code>glfwGetGLVersion</code> function</li> <li>Removed <code>glfwGetGLVersion</code> function</li>

8
src/init.c
View File

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

64
src/input.c
View File

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

31
src/internal.h
View File

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

115
src/window.c
View File

@ -68,32 +68,6 @@ static void clearScrollOffsets(void)
////// GLFW internal API ////// ////// 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 // Register window focus events
//======================================================================== //========================================================================
@ -107,8 +81,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
_glfwLibrary.activeWindow = window; _glfwLibrary.activeWindow = window;
if (_glfwLibrary.windowFocusCallback) if (window->windowFocusCallback)
_glfwLibrary.windowFocusCallback(window, activated); window->windowFocusCallback(window, activated);
} }
else else
{ {
@ -133,8 +107,8 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated)
_glfwLibrary.activeWindow = NULL; _glfwLibrary.activeWindow = NULL;
if (_glfwLibrary.windowFocusCallback) if (window->windowFocusCallback)
_glfwLibrary.windowFocusCallback(window, activated); window->windowFocusCallback(window, activated);
} }
} }
@ -162,8 +136,8 @@ void _glfwInputWindowSize(_GLFWwindow* window, int width, int height)
window->width = width; window->width = width;
window->height = height; window->height = height;
if (_glfwLibrary.windowSizeCallback) if (window->windowSizeCallback)
_glfwLibrary.windowSizeCallback(window, width, height); window->windowSizeCallback(window, width, height);
} }
@ -178,8 +152,8 @@ void _glfwInputWindowIconify(_GLFWwindow* window, int iconified)
window->iconified = iconified; window->iconified = iconified;
if (_glfwLibrary.windowIconifyCallback) if (window->windowIconifyCallback)
_glfwLibrary.windowIconifyCallback(window, iconified); window->windowIconifyCallback(window, iconified);
} }
@ -199,8 +173,8 @@ void _glfwInputWindowVisibility(_GLFWwindow* window, int visible)
void _glfwInputWindowDamage(_GLFWwindow* window) void _glfwInputWindowDamage(_GLFWwindow* window)
{ {
if (_glfwLibrary.windowRefreshCallback) if (window->windowRefreshCallback)
_glfwLibrary.windowRefreshCallback(window); window->windowRefreshCallback(window);
} }
@ -210,8 +184,8 @@ void _glfwInputWindowDamage(_GLFWwindow* window)
void _glfwInputWindowCloseRequest(_GLFWwindow* window) void _glfwInputWindowCloseRequest(_GLFWwindow* window)
{ {
if (_glfwLibrary.windowCloseCallback) if (window->windowCloseCallback)
window->closeRequested = _glfwLibrary.windowCloseCallback(window); window->closeRequested = window->windowCloseCallback(window);
else else
window->closeRequested = GL_TRUE; window->closeRequested = GL_TRUE;
} }
@ -274,9 +248,6 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
wndconfig.monitor = (_GLFWmonitor*) monitor; wndconfig.monitor = (_GLFWmonitor*) monitor;
wndconfig.share = (_GLFWwindow*) share; wndconfig.share = (_GLFWwindow*) share;
// Reset to default values for the next call
_glfwSetDefaultWindowHints();
// Check the OpenGL bits of the window config // Check the OpenGL bits of the window config
if (!_glfwIsValidContextConfig(&wndconfig)) if (!_glfwIsValidContextConfig(&wndconfig))
return GL_FALSE; 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 // Set hints for creating the window
//======================================================================== //========================================================================
@ -819,15 +822,17 @@ GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow handle)
// Set callback function for window size changes // 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) if (!_glfwInitialized)
{ {
_glfwSetError(GLFW_NOT_INITIALIZED, NULL); _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return; return;
} }
_glfwLibrary.windowSizeCallback = cbfun; window->windowSizeCallback = cbfun;
} }
@ -835,15 +840,17 @@ GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun)
// Set callback function for window close events // 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) if (!_glfwInitialized)
{ {
_glfwSetError(GLFW_NOT_INITIALIZED, NULL); _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return; return;
} }
_glfwLibrary.windowCloseCallback = cbfun; window->windowCloseCallback = cbfun;
} }
@ -851,15 +858,17 @@ GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun)
// Set callback function for window refresh events // 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) if (!_glfwInitialized)
{ {
_glfwSetError(GLFW_NOT_INITIALIZED, NULL); _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return; return;
} }
_glfwLibrary.windowRefreshCallback = cbfun; window->windowRefreshCallback = cbfun;
} }
@ -867,15 +876,17 @@ GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun)
// Set callback function for window focus events // 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) if (!_glfwInitialized)
{ {
_glfwSetError(GLFW_NOT_INITIALIZED, NULL); _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return; return;
} }
_glfwLibrary.windowFocusCallback = cbfun; window->windowFocusCallback = cbfun;
} }
@ -883,15 +894,17 @@ GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun)
// Set callback function for window iconification events // 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) if (!_glfwInitialized)
{ {
_glfwSetError(GLFW_NOT_INITIALIZED, NULL); _glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return; return;
} }
_glfwLibrary.windowIconifyCallback = cbfun; window->windowIconifyCallback = cbfun;
} }

8
tests/accuracy.c
View File

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

6
tests/clipboard.c
View File

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

27
tests/events.c
View File

@ -386,19 +386,6 @@ int main(void)
printf("Library initialized\n"); 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); window = glfwCreateWindow(0, 0, "Event Linter", NULL, NULL);
if (!window) if (!window)
{ {
@ -410,6 +397,20 @@ int main(void)
printf("Window opened\n"); 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); glfwMakeContextCurrent(window);
glfwSwapInterval(1); glfwSwapInterval(1);

6
tests/fsaa.c
View File

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

6
tests/fsfocus.c
View File

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

6
tests/gamma.c
View File

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

6
tests/glfwinfo.c
View File

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

10
tests/iconify.c
View File

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

2
tests/joysticks.c
View File

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

11
tests/modes.c
View File

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

10
tests/peter.c
View File

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

11
tests/reopen.c
View File

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

8
tests/sharing.c
View File

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

8
tests/tearing.c
View File

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

5
tests/title.c
View File

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

1
tests/windows.c
View File

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