Made window-related callbacks per-window.

This makes polymorphic behaviour easier to implement and avoids the problem of
events being triggered before the GLFW window object is fully usable.
This commit is contained in:
Camilla Berglund 2012-10-28 13:45:11 +01:00
parent d68acb78bf
commit 18d71c2b6d
23 changed files with 164 additions and 142 deletions

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, GLFW_WINDOWED, "Boing (classic Amiga demo)", NULL ); window = glfwCreateWindow( 400, 400, GLFW_WINDOWED, "Boing (classic Amiga demo)", 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 );

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, GLFW_WINDOWED, "Gears", NULL ); window = glfwCreateWindow( 300, 300, GLFW_WINDOWED, "Gears", 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 );

View File

@ -601,8 +601,8 @@ int main(int argc, char** argv)
} }
/* 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())

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
@ -468,6 +462,12 @@ int main(void)
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);

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, GLFW_WINDOWED, "Wave Simulation", NULL); window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Wave Simulation", 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);

View File

@ -545,11 +545,11 @@ GLFWAPI void glfwHideWindow(GLFWwindow window);
GLFWAPI int glfwGetWindowParam(GLFWwindow window, int param); GLFWAPI int glfwGetWindowParam(GLFWwindow window, int param);
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);
@ -563,12 +563,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);

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,9 +249,9 @@ 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;
} }

View File

@ -197,6 +197,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;
@ -213,18 +225,6 @@ struct _GLFWlibrary
_GLFWwindow* windowListHead; _GLFWwindow* windowListHead;
_GLFWwindow* activeWindow; _GLFWwindow* activeWindow;
GLFWwindowsizefun windowSizeCallback;
GLFWwindowclosefun windowCloseCallback;
GLFWwindowrefreshfun windowRefreshCallback;
GLFWwindowfocusfun windowFocusCallback;
GLFWwindowiconifyfun windowIconifyCallback;
GLFWmousebuttonfun mouseButtonCallback;
GLFWcursorposfun cursorPosCallback;
GLFWcursorenterfun cursorEnterCallback;
GLFWscrollfun scrollCallback;
GLFWkeyfun keyCallback;
GLFWcharfun charCallback;
GLFWgammaramp currentRamp; GLFWgammaramp currentRamp;
GLFWgammaramp originalRamp; GLFWgammaramp originalRamp;
int originalRampSize; int originalRampSize;

View File

@ -80,8 +80,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
@ -106,8 +106,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);
} }
} }
} }
@ -136,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);
} }
@ -152,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);
} }
@ -173,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);
} }
@ -184,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;
} }
@ -810,15 +810,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;
} }
@ -826,15 +828,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;
} }
@ -842,15 +846,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;
} }
@ -858,15 +864,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;
} }
@ -874,15 +882,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;
} }

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, GLFW_WINDOWED, "", NULL); window = glfwCreateWindow(window_width, window_height, GLFW_WINDOWED, "", 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);

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

View File

@ -363,18 +363,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);
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Event Linter", NULL); window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Event Linter", NULL);
if (!window) if (!window)
{ {
@ -386,6 +374,18 @@ int main(void)
printf("Window opened\n"); printf("Window opened\n");
glfwSetWindowSizeCallback(window, window_size_callback);
glfwSetWindowCloseCallback(window, window_close_callback);
glfwSetWindowRefreshCallback(window, window_refresh_callback);
glfwSetWindowFocusCallback(window, window_focus_callback);
glfwSetWindowIconifyCallback(window, window_iconify_callback);
glfwSetMouseButtonCallback(window, mouse_button_callback);
glfwSetCursorPosCallback(window, cursor_position_callback);
glfwSetCursorEnterCallback(window, cursor_enter_callback);
glfwSetScrollCallback(window, scroll_callback);
glfwSetKeyCallback(window, key_callback);
glfwSetCharCallback(window, char_callback);
glfwMakeContextCurrent(window); glfwMakeContextCurrent(window);
glfwSwapInterval(1); glfwSwapInterval(1);

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, GLFW_WINDOWED, "Aliasing Detector", NULL); window = glfwCreateWindow(800, 400, GLFW_WINDOWED, "Aliasing Detector", 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);

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

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

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

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

View File

@ -117,10 +117,6 @@ static void test_modes(void)
int i, count; int i, count;
GLFWvidmode* modes = glfwGetVideoModes(&count); GLFWvidmode* modes = glfwGetVideoModes(&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;
@ -143,6 +139,10 @@ static void test_modes(void)
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);

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

View File

@ -102,9 +102,9 @@ static GLboolean open_window(int width, int height, int mode)
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",
get_mode_name(mode), get_mode_name(mode),

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

View File

@ -82,8 +82,8 @@ int main(void)
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);

View File

@ -59,7 +59,7 @@ int main(void)
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))
{ {