diff --git a/CMakeLists.txt b/CMakeLists.txt index c35ccc20..40c16ff9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -218,10 +218,6 @@ if (_GLFW_X11_GLX) endif() endif() - if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux") - set(_GLFW_HAS_LINUX_JOYSTICKS 1) - endif() - endif() #-------------------------------------------------------------------- @@ -266,10 +262,6 @@ if (_GLFW_X11_EGL) endif() endif() - if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux") - set(_GLFW_HAS_LINUX_JOYSTICKS 1) - endif() - endif() #-------------------------------------------------------------------- diff --git a/examples/boing.c b/examples/boing.c index a2094c5f..5a1993ff 100644 --- a/examples/boing.c +++ b/examples/boing.c @@ -577,8 +577,6 @@ int main( void ) exit( EXIT_FAILURE ); } - glfwSetWindowSizeCallback( reshape ); - glfwWindowHint(GLFW_DEPTH_BITS, 16); window = glfwCreateWindow( 400, 400, GLFW_WINDOWED, "Boing (classic Amiga demo)", NULL ); @@ -589,6 +587,8 @@ int main( void ) exit( EXIT_FAILURE ); } + glfwSetWindowSizeCallback(window, reshape); + glfwMakeContextCurrent(window); glfwSwapInterval( 1 ); diff --git a/examples/gears.c b/examples/gears.c index cd3cdbb1..b056251a 100644 --- a/examples/gears.c +++ b/examples/gears.c @@ -338,11 +338,6 @@ int main(int argc, char *argv[]) exit( EXIT_FAILURE ); } - // Set callback functions - glfwSetWindowCloseCallback(window_close_callback); - glfwSetWindowSizeCallback( reshape ); - glfwSetKeyCallback( key ); - glfwWindowHint(GLFW_DEPTH_BITS, 16); window = glfwCreateWindow( 300, 300, GLFW_WINDOWED, "Gears", NULL ); @@ -353,14 +348,17 @@ 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 ); glfwGetWindowSize(window, &width, &height); reshape(window, width, height); - glfwSetInputMode( window, GLFW_KEY_REPEAT, GL_TRUE ); - // Parse command-line options init(argc, argv); diff --git a/examples/heightmap.c b/examples/heightmap.c index 5139a493..6abaa1ec 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 4a48a383..965a183c 100644 --- a/examples/splitview.c +++ b/examples/splitview.c @@ -450,12 +450,6 @@ int main(void) exit(EXIT_FAILURE); } - // Set callback functions - glfwSetWindowSizeCallback(windowSizeFun); - glfwSetWindowRefreshCallback(windowRefreshFun); - glfwSetCursorPosCallback(cursorPosFun); - glfwSetMouseButtonCallback(mouseButtonFun); - glfwWindowHint(GLFW_DEPTH_BITS, 16); // Open OpenGL window @@ -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 615483a9..3a1cef94 100644 --- a/examples/triangle.c +++ b/examples/triangle.c @@ -27,6 +27,8 @@ int main(void) if (!window) { fprintf(stderr, "Failed to open GLFW window\n"); + + glfwTerminate(); exit(EXIT_FAILURE); } diff --git a/examples/wave.c b/examples/wave.c index 668d54bd..7b4b4c32 100644 --- a/examples/wave.c +++ b/examples/wave.c @@ -399,13 +399,6 @@ int main(int argc, char* argv[]) exit(EXIT_FAILURE); } - glfwSetKeyCallback(key_callback); - glfwSetWindowCloseCallback(window_close_callback); - glfwSetWindowSizeCallback(window_size_callback); - glfwSetMouseButtonCallback(mouse_button_callback); - glfwSetCursorPosCallback(cursor_position_callback); - glfwSetScrollCallback(scroll_callback); - window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Wave Simulation", NULL); if (!window) { @@ -413,14 +406,19 @@ 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); glfwGetWindowSize(window, &width, &height); window_size_callback(window, width, height); - glfwSetInputMode(window, GLFW_KEY_REPEAT, GL_TRUE); - // Initialize OpenGL init_opengl(); diff --git a/include/GL/glfw3.h b/include/GL/glfw3.h index 31d76761..12d74449 100644 --- a/include/GL/glfw3.h +++ b/include/GL/glfw3.h @@ -35,13 +35,48 @@ extern "C" { #endif +/************************************************************************* + * Doxygen documentation + *************************************************************************/ + +/*! @mainpage notitle + * + * @section intro Introduction + * + * This is the reference documentation for the GLFW library. + */ + +/*! @defgroup clipboard Clipboard support + */ +/*! @defgroup error Error handling + */ +/*! @defgroup gamma Gamma ramp support + */ +/*! @defgroup init Initialization and version information + */ +/*! @defgroup input Input handling + */ +/*! @defgroup opengl OpenGL support + */ +/*! @defgroup time Time input + */ +/*! @defgroup window Window handling + * + * The primary purpose of GLFW is to provide a simple interface to OpenGL + * context creation and window management. GLFW supports multiple windows, + * which can be either a normal desktop window or a fullscreen window. + */ +/*! @defgroup monitor Monitor handling + */ + + /************************************************************************* * Global definitions *************************************************************************/ /* ------------------- BEGIN SYSTEM/COMPILER SPECIFIC -------------------- */ -/* Please report any probles that you find with your compiler, which may +/* Please report any problems that you find with your compiler, which may * be solved in this section! There are several compilers that I have not * been able to test this file with yet. * @@ -141,7 +176,7 @@ extern "C" { /* Include the chosen OpenGL header and, optionally, the GLU header. */ #if defined(__APPLE_CC__) - #if defined(GLFW_INCLUDE_GL3) + #if defined(GLFW_INCLUDE_GLCOREARB) #include #else #define GL_GLEXT_LEGACY @@ -151,8 +186,8 @@ extern "C" { #include #endif #else - #if defined(GLFW_INCLUDE_GL3) - #include + #if defined(GLFW_INCLUDE_GLCOREARB) + #include #elif defined(GLFW_INCLUDE_ES2) #include #else @@ -168,18 +203,46 @@ extern "C" { * GLFW version *************************************************************************/ +/*! @name GLFW version macros + * @{ */ +/*! @brief The major version number of the GLFW library. + * + * This is incremented when the API is changed in non-compatible ways. + * @ingroup init + */ #define GLFW_VERSION_MAJOR 3 +/*! @brief The minor version number of the GLFW library. + * + * This is incremented when features are added to the API but it remains + * backward-compatible. + * @ingroup init + */ #define GLFW_VERSION_MINOR 0 +/*! @brief The revision number of the GLFW library. + * + * This is incremented when a bug fix release is made that does not contain any + * API changes. + * @ingroup init + */ #define GLFW_VERSION_REVISION 0 +/*! @} */ /************************************************************************* * Input handling definitions *************************************************************************/ -/* Key and button state/action definitions */ +/*! @name Key and button actions + * @{ */ +/*! @brief The key or button was released. + * @ingroup input + */ #define GLFW_RELEASE 0 +/*! @brief The key or button was pressed. + * @ingroup input + */ #define GLFW_PRESS 1 +/*! @} */ /* Keyboard raw key codes. * These key codes are inspired by the USB HID Usage Tables v1.12 (p. 53-60), @@ -197,6 +260,11 @@ extern "C" { * "BACKSPACE", etc). */ +/*! @defgroup keys Keyboard keys + * @ingroup input + * @{ + */ + /* Printable keys */ #define GLFW_KEY_SPACE 32 #define GLFW_KEY_APOSTROPHE 39 /* ' */ @@ -337,7 +405,11 @@ extern "C" { #define GLFW_KEY_RALT GLFW_KEY_RIGHT_ALT #define GLFW_KEY_RSUPER GLFW_KEY_RIGHT_SUPER -/* Mouse button definitions */ +/*! @} */ + +/*! @defgroup buttons Mouse buttons + * @ingroup input + * @{ */ #define GLFW_MOUSE_BUTTON_1 0 #define GLFW_MOUSE_BUTTON_2 1 #define GLFW_MOUSE_BUTTON_3 2 @@ -347,13 +419,14 @@ extern "C" { #define GLFW_MOUSE_BUTTON_7 6 #define GLFW_MOUSE_BUTTON_8 7 #define GLFW_MOUSE_BUTTON_LAST GLFW_MOUSE_BUTTON_8 - -/* Mouse button aliases */ #define GLFW_MOUSE_BUTTON_LEFT GLFW_MOUSE_BUTTON_1 #define GLFW_MOUSE_BUTTON_RIGHT GLFW_MOUSE_BUTTON_2 #define GLFW_MOUSE_BUTTON_MIDDLE GLFW_MOUSE_BUTTON_3 +/*! @} */ -/* Joystick identifiers */ +/*! @defgroup joysticks Joysticks + * @ingroup input + * @{ */ #define GLFW_JOYSTICK_1 0 #define GLFW_JOYSTICK_2 1 #define GLFW_JOYSTICK_3 2 @@ -371,40 +444,84 @@ extern "C" { #define GLFW_JOYSTICK_15 14 #define GLFW_JOYSTICK_16 15 #define GLFW_JOYSTICK_LAST GLFW_JOYSTICK_16 +/*! @} */ /************************************************************************* * Other definitions *************************************************************************/ -/* glfwCreateWindow modes */ +/*! @brief A regular, overlapped window. + * @ingroup window + */ #define GLFW_WINDOWED 0x00010001 +/*! @brief A fullscreen window that may changed the monitor's resolution. + * @ingroup window + */ #define GLFW_FULLSCREEN 0x00010002 -/* glfwGetWindowParam tokens */ -#define GLFW_ACTIVE 0x00020001 +/*! @defgroup paramhints Window parameters and hints + * @ingroup window + * @{ */ + +/*! @brief @c GL_TRUE if the window has focus, or @c GL_FALSE otherwise. + */ +#define GLFW_FOCUSED 0x00020001 +/*! @brief @c GL_TRUE if the window is iconified, or @c GL_FALSE otherwise. + */ #define GLFW_ICONIFIED 0x00020002 +/*! @brief @c GL_TRUE if the window has been requested to close, or @c GL_FALSE + * otherwise. + */ #define GLFW_CLOSE_REQUESTED 0x00020003 +/*! @brief The OpenGL API version revision. + */ #define GLFW_OPENGL_REVISION 0x00020004 -/* glfwWindowHint tokens */ +/*! @brief The bit depth of the red component of the color buffer. + */ #define GLFW_RED_BITS 0x00021000 +/*! @brief The bit depth of the green component of the color buffer. + */ #define GLFW_GREEN_BITS 0x00021001 +/*! @brief The bit depth of the blue component of the color buffer. + */ #define GLFW_BLUE_BITS 0x00021002 +/*! @brief The bit depth of the alpha component of the color buffer. + */ #define GLFW_ALPHA_BITS 0x00021003 +/*! @brief The bit depth of the depth buffer of the default framebuffer. + */ #define GLFW_DEPTH_BITS 0x00021004 +/*! @brief The bit depth of the stencil buffer of the default framebuffer. + */ #define GLFW_STENCIL_BITS 0x00021005 +/*! @brief The monitor refresh rate. + */ #define GLFW_REFRESH_RATE 0x00021006 +/*! @brief The bit depth of the red component of the accumulation buffer. + */ #define GLFW_ACCUM_RED_BITS 0x00021007 +/*! @brief The bit depth of the red component of the accumulation buffer. + */ #define GLFW_ACCUM_GREEN_BITS 0x00021008 +/*! @brief The bit depth of the red component of the accumulation buffer. + */ #define GLFW_ACCUM_BLUE_BITS 0x00021009 +/*! @brief The bit depth of the red component of the accumulation buffer. + */ #define GLFW_ACCUM_ALPHA_BITS 0x0002100A +/*! @brief The number of auxiliary buffers. + */ #define GLFW_AUX_BUFFERS 0x0002100B +/*! @brief @c GL_TRUE for stereo rendering, or @c GL_FALSE otherwise. + */ #define GLFW_STEREO 0x0002100C +/*! @brief The number of samples used for default framebuffer multisampling. + */ #define GLFW_FSAA_SAMPLES 0x0002100E -/* The following constants are used with both glfwGetWindowParam - * and glfwWindowHint +/*! @brief The @link clients client API @endlink to create a context for. */ #define GLFW_CLIENT_API 0x00022000 #define GLFW_OPENGL_VERSION_MAJOR 0x00022001 @@ -413,81 +530,274 @@ extern "C" { #define GLFW_OPENGL_DEBUG_CONTEXT 0x00022004 #define GLFW_OPENGL_PROFILE 0x00022005 #define GLFW_OPENGL_ROBUSTNESS 0x00022006 +/*! @brief @c GL_TRUE if the window is resizable, or @c GL_FALSE otherwise. + */ #define GLFW_RESIZABLE 0x00022007 +/*! @brief @c GL_TRUE if the window is visible, or @c GL_FALSE otherwise. + */ #define GLFW_VISIBLE 0x00022008 +/*! @brief The x-coordinate, in pixels, of the upper-left corner of the + * client area of the window. + */ +#define GLFW_POSITION_X 0x00022009 +/*! @brief The y-coordinate, in pixels, of the upper-left corner of the + * client area of the window. + */ +#define GLFW_POSITION_Y 0x0002200A -/* GLFW_CLIENT_API tokens */ +/*! @} */ + +/*! @name Client APIs + * @{ */ +/*! @brief The OpenGL API. + * @ingroup opengl + */ #define GLFW_OPENGL_API 0x00000001 +/*! @brief The OpenGL ES API. + * @ingroup opengl + */ #define GLFW_OPENGL_ES_API 0x00000002 +/*! @} */ -/* GLFW_OPENGL_ROBUSTNESS mode tokens */ +/*! @name OpenGL robustness strategies + * @{ */ +/*! @brief No robustness strategy is used. + * + * This is the default. + * @ingroup opengl + */ #define GLFW_OPENGL_NO_ROBUSTNESS 0x00000000 +/*! @brief + * @ingroup opengl + */ #define GLFW_OPENGL_NO_RESET_NOTIFICATION 0x00000001 +/*! @brief + * @ingroup opengl + */ #define GLFW_OPENGL_LOSE_CONTEXT_ON_RESET 0x00000002 +/*! @} */ -/* GLFW_OPENGL_PROFILE bit tokens */ +/*! @name OpenGL profiles + * @{ */ +/*! @brief No OpenGL profile. + * @ingroup opengl + */ #define GLFW_OPENGL_NO_PROFILE 0x00000000 +/*! @brief The OpenGL core profile. + * @ingroup opengl + */ #define GLFW_OPENGL_CORE_PROFILE 0x00000001 +/*! @brief The OpenGL compatibility profile. + * @ingroup opengl + */ #define GLFW_OPENGL_COMPAT_PROFILE 0x00000002 +/*! @} */ -/* glfwGetInputMode/glfwSetInputMode tokens */ +/*! @name Input modes + * @{ */ +/*! @brief The behaviour of the cursor. + * @ingroup input + */ #define GLFW_CURSOR_MODE 0x00030001 +/*! @brief Whether the @ref glfwGetKey function uses sticky state. + * @ingroup input + */ #define GLFW_STICKY_KEYS 0x00030002 +/*! @brief Whether the @ref glfwGetMouseButton function uses sticky state. + * @ingroup input + */ #define GLFW_STICKY_MOUSE_BUTTONS 0x00030003 -#define GLFW_SYSTEM_KEYS 0x00030004 -#define GLFW_KEY_REPEAT 0x00030005 +/*! @} */ -/* GLFW_CURSOR_MODE values */ +/*! @name Cursor modes + * @{ */ +/*! @brief The cursor is visible and behaves normally. + * @ingroup input + */ #define GLFW_CURSOR_NORMAL 0x00040001 +/*! @brief The cursor is hidden when over the client area of the window. + * @ingroup input + */ #define GLFW_CURSOR_HIDDEN 0x00040002 +/*! @brief The cursor is disabled and cursor movement is unbounded. + * @ingroup input + */ #define GLFW_CURSOR_CAPTURED 0x00040003 +/*! @} */ -/* glfwGetJoystickParam tokens */ +/*! @name Joystick parameters + * @{ */ +/*! @brief @c GL_TRUE if the joystick is present, or @c GL_FALSE otherwise. + * @ingroup input + */ #define GLFW_PRESENT 0x00050001 +/*! @brief The number of axes on the specified joystick, or zero if the joystick + * is not present. + * @ingroup input + */ #define GLFW_AXES 0x00050002 +/*! @brief The number of buttons on the specified joystick, or zero if the + * joystick is not present. + * @ingroup input + */ #define GLFW_BUTTONS 0x00050003 +/*! @} */ -/* glfwGetError/glfwErrorString tokens */ +/*! @defgroup errors Error codes + * @ingroup error + * @{ */ +/*! @brief No error has occurred. + */ #define GLFW_NO_ERROR 0 +/*! @brief GLFW has not been initialized. + */ #define GLFW_NOT_INITIALIZED 0x00070001 +/*! @brief No context is current for this thread. + */ #define GLFW_NO_CURRENT_CONTEXT 0x00070002 +/*! @brief One of the enum parameters for the function was given an invalid + * enum. + */ #define GLFW_INVALID_ENUM 0x00070003 +/*! @brief One of the parameters for the function was given an invalid value. + */ #define GLFW_INVALID_VALUE 0x00070004 +/*! @brief A memory allocation failed. + */ #define GLFW_OUT_OF_MEMORY 0x00070005 -#define GLFW_OPENGL_UNAVAILABLE 0x00070006 +/*! @brief GLFW could not find support for the requested client API on the + * system. + */ +#define GLFW_API_UNAVAILABLE 0x00070006 +/*! @brief The requested OpenGL or GLES version is not available. + */ #define GLFW_VERSION_UNAVAILABLE 0x00070007 +/*! @brief A platform-specific error occurred that does not match any of the + * more specific categories. + */ #define GLFW_PLATFORM_ERROR 0x00070008 -#define GLFW_WINDOW_NOT_ACTIVE 0x00070009 -#define GLFW_FORMAT_UNAVAILABLE 0x0007000A +/*! @brief The clipboard did not contain data in the requested format. + */ +#define GLFW_FORMAT_UNAVAILABLE 0x00070009 +/*! @} */ -/* Gamma ramps */ +/*! @brief The number of entries in the gamma ramp. + * @ingroup gamma + */ #define GLFW_GAMMA_RAMP_SIZE 256 + /************************************************************************* * Typedefs *************************************************************************/ -/* OpenGL function pointer type */ +/*! @brief OpenGL function pointer type. + * @ingroup opengl + */ typedef void (*GLFWglproc)(void); -/* Window handle type */ +/*! @brief Window handle type. + * @ingroup window + */ typedef void* GLFWwindow; -/* Function pointer types */ +/*! @brief The function signature for error callbacks. + * @param[in] error An @link errors error code @endlink. + * @param[in] description A UTF-8 encoded string describing the error. + * @ingroup error + */ typedef void (* GLFWerrorfun)(int,const char*); + +/*! @brief The function signature for window resize callbacks. + * @param[in] window The window that the user resized. + * @param[in] width The new width, in pixels, of the window. + * @param[in] height The new height, in pixels, of the window. + * @ingroup window + */ typedef void (* GLFWwindowsizefun)(GLFWwindow,int,int); -typedef int (* GLFWwindowclosefun)(GLFWwindow); + +/*! @brief The function signature for window close callbacks. + * @param[in] window The window that the user attempted to close. + * @return @c GL_TRUE to allow the window to be closed, or @c GL_FALSE to + * ignore the attempt. + * @ingroup window + */ +typedef int (* GLFWwindowclosefun)(GLFWwindow); + +/*! @brief The function signature for window content refresh callbacks. + * @param[in] window The window whose content needs to be refreshed. + * @ingroup window + */ typedef void (* GLFWwindowrefreshfun)(GLFWwindow); + +/*! @brief The function signature for window focus/defocus callbacks. + * @param[in] window The window that was focused or defocused. + * @param[in] focused @c GL_TRUE if the window was focused, or @c GL_FALSE if + * it was defocused. + * @ingroup window + */ typedef void (* GLFWwindowfocusfun)(GLFWwindow,int); + +/*! @brief The function signature for window iconify/restore callbacks. + * @param[in] window The window that was iconified or restored. + * @param[in] iconified @c GL_TRUE if the window was iconified, or @c GL_FALSE + * if it was restored. + * @ingroup window + */ typedef void (* GLFWwindowiconifyfun)(GLFWwindow,int); + +/*! @brief The function signature for mouse button callbacks. + * @param[in] window The window that received the event. + * @param[in] button The @link buttons mouse button @endlink that was pressed + * or released. + * @param[in] action @ref GLFW_PRESS or @ref GLFW_RELEASE. + * @ingroup input + */ typedef void (* GLFWmousebuttonfun)(GLFWwindow,int,int); + +/*! @brief The function signature for cursor position callbacks. + * @param[in] window The window that received the event. + * @param[in] x The new x-coordinate of the cursor. + * @param[in] y The new y-coordinate of the cursor. + * @ingroup input + */ typedef void (* GLFWcursorposfun)(GLFWwindow,int,int); + +/*! @brief The function signature for cursor enter/exit callbacks. + * @param[in] window The window that received the event. + * @param[in] entered @c GL_TRUE if the cursor entered the window's client + * area, or @c GL_FALSE if it left it. + * @ingroup input + */ typedef void (* GLFWcursorenterfun)(GLFWwindow,int); + +/*! @brief The function signature for scroll callbacks. + * @param[in] window The window that received the event. + * @param[in] x The scroll offset along the x-axis. + * @param[in] y The scroll offset along the y-axis. + * @ingroup input + */ typedef void (* GLFWscrollfun)(GLFWwindow,double,double); + +/*! @brief The function signature for keyboard key callbacks. + * @param[in] window The window that received the event. + * @param[in] key The @link keys keyboard key @endlink that was pressed or + * released. + * @param[in] action @ref GLFW_PRESS or @ref GLFW_RELEASE. + * @ingroup input + */ typedef void (* GLFWkeyfun)(GLFWwindow,int,int); + +/*! @brief The function signature for Unicode character callbacks. + * @param[in] window The window that received the event. + * @param[in] character The Unicode code point of the character. + * @ingroup input + */ typedef void (* GLFWcharfun)(GLFWwindow,int); -/* The video mode structure used by glfwGetVideoModes */ +/* @brief Video mode type. + * @ingroup monitor + */ typedef struct { int width; @@ -497,7 +807,9 @@ typedef struct int greenBits; } GLFWvidmode; -/* Gamma ramp */ +/*! @brief Gamma ramp. + * @ingroup gamma + */ typedef struct { unsigned short red[GLFW_GAMMA_RAMP_SIZE]; @@ -510,88 +822,779 @@ typedef struct * Prototypes *************************************************************************/ -/* Initialization, termination and version querying */ -GLFWAPI int glfwInit(void); +/*! @brief Initializes the GLFW library. + * + * Before most GLFW functions can be used, GLFW must be initialized, and before + * a program terminates GLFW should be terminated in order to free allocated + * resources, memory, etc. + * + * @return @c GL_TRUE if successful, or @c GL_FALSE if an error occurred. + * @ingroup init + * + * @remarks Additional calls to this function after successful initialization + * but before termination will succeed but will do nothing. + * + * @note This function may only be called from the main thread. + * + * @note This function may take several seconds to complete on some systems, + * while on other systems it may take only a fraction of a second to complete. + * + * @note On Mac OS X, this function will change the current directory of the + * application to the @c Contents/Resources subdirectory of the application's + * bundle, if present. + * + * @sa glfwTerminate + */ +GLFWAPI int glfwInit(void); + +/*! @brief Terminates the GLFW library. + * @ingroup init + * + * @remarks This function may be called before @ref glfwInit. + * + * @note This function may only be called from the main thread. + * + * @note This function closes all GLFW windows. + * + * @note This function should be called before the program exits. + * + * @warning No window's context may be current on another thread when this + * function is called. + * + * @sa glfwInit + */ GLFWAPI void glfwTerminate(void); + +/*! @brief Retrieves the version of the GLFW library. + * @param[out] major Where to store the major version number, or @c NULL. + * @param[out] minor Where to store the minor version number, or @c NULL. + * @param[out] rev Where to store the revision number, or @c NULL. + * @ingroup init + * + * @remarks This function may be called before @ref glfwInit. + * + * @remarks This function may be called from secondary threads. + * + * @sa glfwGetVersionString + */ GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev); + +/*! @brief Returns the version string of the GLFW library. + * + * The version string contains information about what compile-time options were + * enabled when the library was built. + * + * @return The GLFW version string. + * @ingroup init + * + * @remarks This function may be called before @ref glfwInit. + * + * @remarks This function may be called from secondary threads. + * + * @sa glfwGetVersion + */ GLFWAPI const char* glfwGetVersionString(void); -/* Error handling */ +/*! @brief Retrieves the latest error. + * @return The latest @link errors error code @endlink. + * @ingroup error + * + * @remarks This function may be called before @ref glfwInit. + */ GLFWAPI int glfwGetError(void); + +/*! @brief Retrieves a generic, human readable description of the specified error. + * @param[in] error The @link errors error code @endlink to be described. + * @return A UTF-8 encoded string describing the error. + * @ingroup error + * + * @remarks This function may be called before @ref glfwInit. + * + * @remarks This function may be called from secondary threads. + */ GLFWAPI const char* glfwErrorString(int error); + +/*! @brief Sets the error callback. + * @param[in] cbfun The new callback, or @c NULL to remove the currently set + * callback. + * @ingroup error + * + * @remarks This function may be called before @ref glfwInit. + * + * @remarks The error callback is the preferred error retrieval mechanism, as + * it may be provided with a more specific error description than the generic + * one returned by @ref glfwErrorString. + * + * @note Because the description string provided to the callback may have been + * generated specifically for that error, it is not guaranteed to be valid + * after the callback has returned. If you wish to use it after that, you need + * to make your own copy of it before returning. + */ GLFWAPI void glfwSetErrorCallback(GLFWerrorfun cbfun); -/* Video mode functions */ +/*! @brief This function will be replaced when the @c multi-monitor branch is + * merged. + * @ingroup monitor + */ GLFWAPI GLFWvidmode* glfwGetVideoModes(int* count); + +/*! @brief This function will be replaced when the @c multi-monitor branch is + * merged. + * @ingroup monitor + */ GLFWAPI void glfwGetDesktopMode(GLFWvidmode* mode); -/* Gamma ramp functions */ +/*! @brief Sets the system gamma ramp to one generated from the specified + * exponent. + * @param[in] The desired exponent. + * @ingroup gamma + */ GLFWAPI void glfwSetGamma(float gamma); + +/*! @brief Retrieves the current system gamma ramp. + * @param[out] ramp Where to store the gamma ramp. + * @ingroup gamma + */ GLFWAPI void glfwGetGammaRamp(GLFWgammaramp* ramp); + +/*! @brief Sets the system gamma ramp to the one specified. + * @param[in] ramp The gamma ramp to use. + * @ingroup gamma + */ GLFWAPI void glfwSetGammaRamp(const GLFWgammaramp* ramp); -/* Window handling */ -GLFWAPI void glfwWindowHint(int target, int hint); -GLFWAPI GLFWwindow glfwCreateWindow(int width, int height, int mode, const char* title, GLFWwindow share); -GLFWAPI void glfwDestroyWindow(GLFWwindow window); -GLFWAPI void glfwSetWindowTitle(GLFWwindow window, const char* title); -GLFWAPI void glfwGetWindowSize(GLFWwindow window, int* width, int* height); -GLFWAPI void glfwSetWindowSize(GLFWwindow window, int width, int height); -GLFWAPI void glfwGetWindowPos(GLFWwindow window, int* xpos, int* ypos); -GLFWAPI void glfwSetWindowPos(GLFWwindow window, int xpos, int ypos); -GLFWAPI void glfwIconifyWindow(GLFWwindow window); -GLFWAPI void glfwRestoreWindow(GLFWwindow window); -GLFWAPI void glfwShowWindow(GLFWwindow window); -GLFWAPI void glfwHideWindow(GLFWwindow window); -GLFWAPI int glfwGetWindowParam(GLFWwindow window, int param); -GLFWAPI void glfwSetWindowUserPointer(GLFWwindow window, void* pointer); -GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow window); -GLFWAPI void glfwSetWindowSizeCallback(GLFWwindowsizefun cbfun); -GLFWAPI void glfwSetWindowCloseCallback(GLFWwindowclosefun cbfun); -GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindowrefreshfun cbfun); -GLFWAPI void glfwSetWindowFocusCallback(GLFWwindowfocusfun cbfun); -GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindowiconifyfun cbfun); +/*! @brief Resets all window hints to their default values + * + * The @ref GLFW_RED_BITS, @ref GLFW_GREEN_BITS, @ref GLFW_BLUE_BITS, @ref + * GLFW_ALPHA_BITS and @ref GLFW_STENCIL_BITS hints are set to 8. + * + * The @ref GLFW_DEPTH_BITS hint is set to 24. + * + * The @ref GLFW_VISIBLE and @ref GLFW_RESIZABLE hints are set to 1. + * + * The @ref GLFW_CLIENT_API hint is set to @ref GLFW_OPENGL_API. + * + * The @ref GLFW_OPENGL_VERSION_MAJOR and @ref GLFW_OPENGL_VERSION_MINOR hints + * are set to 1 and 0, respectively. + * + * All other hints are set to 0. + * + * @ingroup window + * + * @note This function may only be called from the main thread. + * + * @sa glfwWindowHint + */ +GLFWAPI void glfwDefaultWindowHints(void); -/* Event handling */ +/*! @brief Sets the specified window hint to the desired value. + * @param[in] target The window hint to set. + * @param[in] target The new value of the window hint. + * @ingroup window + * + * The @ref GLFW_RED_BITS, @ref GLFW_GREEN_BITS, @ref GLFW_BLUE_BITS, @ref + * GLFW_ALPHA_BITS, @ref GLFW_DEPTH_BITS and @ref GLFW_STENCIL_BITS hints + * specify the desired bit depths of the various components of the default + * framebuffer. + * + * The @ref GLFW_REFRESH_RATE hint specifies the desired monitor refresh rate + * for fullscreen windows. + * + * The @ref GLFW_ACCUM_RED_BITS, @ref GLFW_ACCUM_GREEN_BITS, @ref + * GLFW_ACCUM_BLUE_BITS and @ref GLFW_ACCUM_ALPHA_BITS hints specify the + * desired bit depths of the various components of the accumulation buffer. + * + * The @ref GLFW_AUX_BUFFERS hint specifies the desired number of auxiliary + * buffers. + * + * The @ref GLFW_STEREO hint specifies whether to use stereoscopic rendering. + * + * The @ref GLFW_FSAA_SAMPLES hint specifies the desired number of samples to + * use for multisampling. + * + * The @ref GLFW_CLIENT_API hint specifies which client API to create the + * context for. Possible values are @ref GLFW_OPENGL_API and @ref + * GLFW_OPENGL_ES_API. + * + * The @ref GLFW_OPENGL_VERSION_MAJOR and @ref GLFW_OPENGL_VERSION_MINOR hints + * specify the OpenGL version that the created context must be compatible with. + * + * These hints are @em not hard constraints, as they don't have to match + * exactly, but @ref glfwCreateWindow will still fail if the resulting OpenGL + * version is less than the one requested with hints. It is therefore + * perfectly safe to use the default of version 1.0 for legacy code and you + * will still get backwards-compatible contexts of version 3.0 and above when + * available. + * + * The @ref GLFW_OPENGL_FORWARD_COMPAT hint specifies whether the OpenGL + * context should be forward-compatible. + * + * The @ref GLFW_OPENGL_DEBUG_CONTEXT hint specifies whether to create a debug + * OpenGL context. + * + * The @ref GLFW_OPENGL_PROFILE hint specifies which OpenGL profile to create + * the context for. Possible values are @ref GLFW_OPENGL_NO_PROFILE, @ref + * GLFW_OPENGL_CORE_PROFILE and @ref GLFW_OPENGL_COMPAT_PROFILE. + * + * The @ref GLFW_OPENGL_ROBUSTNESS hint specifies the robustness strategy to be + * used by the OpenGL context. + * + * The @ref GLFW_RESIZABLE hint specifies whether the window will be resizable + * by the user. This hint is ignored for fullscreen windows. + * + * The @ref GLFW_VISIBLE hint specifies whether the window will be initially + * visible. This hint is ignored for fullscreen windows. + * + * The @ref GLFW_POSITION_X and @ref GLFW_POSITION_Y hints specify the initial + * position of the window. These hints are ignored for fullscreen windows. + * + * Some window hints are hard constraints. These must match the available + * capabilities @em exactly for window and context creation to succeed. Hints + * that are not hard constraints are matched as closely as possible, but the + * resulting window and context may differ from what these hints requested. + * + * The following window hints are hard constraints: + * @arg @ref GLFW_STEREO + * @arg @ref GLFW_CLIENT_API + * @arg @ref GLFW_OPENGL_FORWARD_COMPAT + * @arg @ref GLFW_OPENGL_PROFILE + * + * @note This function may only be called from the main thread. + * + * @sa glfwDefaultWindowHints + */ +GLFWAPI void glfwWindowHint(int target, int hint); + +/*! @brief Creates a window and its associated context. + * + * @param[in] width The desired width, in pixels, of the window. This must be + * greater than zero. + * @param[in] height The desired height, in pixels, of the window. This must + * be greater than zero. + * @param[in] mode One of @ref GLFW_WINDOWED or @ref GLFW_FULLSCREEN. + * @param[in] title The initial, UTF-8 encoded window title. + * @param[in] share The window whose context to share resources with, or @c + * NULL to not share resources. + * @return The handle of the created window, or @c NULL if an error occurred. + * @ingroup window + * + * @remarks Most of the options for how the window and its context should be + * created are specified via the @ref glfwWindowHint function. + * + * @remarks This function does not change which context is current. Before you + * can use the newly created context, you need to make it current using @ref + * glfwMakeContextCurrent. + * + * @remarks For fullscreen windows the initial cursor mode is @ref + * GLFW_CURSOR_CAPTURED and the screensaver is prohibited from starting. For + * regular windows the initial cursor mode is @ref GLFW_CURSOR_NORMAL and the + * screensaver is allowed to start. + * + * @remarks In order to determine the actual properties of an opened window, + * use @ref glfwGetWindowParam and @ref glfwGetWindowSize. + * + * @remarks On Microsoft Windows, if the executable has an icon resource named + * @c GLFW_ICON, it will be set as the icon for the window. If no such icon is + * present, the @c IDI_WINLOGO icon will be used instead. + * + * @remarks On Mac OS X the GLFW window has no icon, but programs using GLFW + * will use the application bundle's icon. Also, the first time a window is + * opened the menu bar is populated with common commands like Hide, Quit and + * About. The (minimal) about dialog uses information from the application's + * bundle. For more information on bundles, see the Bundle Programming Guide + * provided by Apple. + * + * @note This function may only be called from the main thread. + * + * @sa glfwDestroyWindow + */ +GLFWAPI GLFWwindow glfwCreateWindow(int width, int height, int mode, const char* title, GLFWwindow share); + +/*! @brief Destroys the specified window and its context. + * @param[in] window The window to destroy. + * @ingroup window + * + * @note This function may only be called from the main thread. + * + * @note If the window's context is current on the main thread, it is + * detached before being destroyed. + * + * @warning The window's context must not be current on any other thread. + * + * @sa glfwCreateWindow + */ +GLFWAPI void glfwDestroyWindow(GLFWwindow window); + +/*! @brief Sets the title of the specified window. + * @param[in] window The window whose title to change. + * @param[in] title The UTF-8 encoded window title. + * @ingroup window + * + * @note This function may only be called from the main thread. + */ +GLFWAPI void glfwSetWindowTitle(GLFWwindow window, const char* title); + +/*! @brief Retrieves the size of the client area of the specified window. + * @param[in] window The window whose size to retrieve. + * @param[out] width The width of the client area. + * @param[out] height The height of the client area. + * @ingroup window + * + * @sa glfwSetWindowSize + */ +GLFWAPI void glfwGetWindowSize(GLFWwindow window, int* width, int* height); + +/*! @brief Sets the size of the client area of the specified window. + * @param[in] window The window to resize. + * @param[in] width The desired width of the specified window. + * @param[in] height The desired height of the specified window. + * @ingroup window + * + * @note This function may only be called from the main thread. + * + * @note The window manager may put limits on what window sizes are allowed. + * + * @note For fullscreen windows, this function selects and switches to the + * resolution closest to the specified size, without destroying the window's + * context. + * + * @sa glfwGetWindowSize + */ +GLFWAPI void glfwSetWindowSize(GLFWwindow window, int width, int height); + +/*! @brief Iconifies the specified window. + * @param[in] window The window to iconify. + * @ingroup window + * + * @remarks If the window is already iconified, this function does nothing. + * + * @note This function may only be called from the main thread. + * + * @sa glfwRestoreWindow + */ +GLFWAPI void glfwIconifyWindow(GLFWwindow window); + +/*! @brief Restores the specified window. + * @param[in] window The window to restore. + * @ingroup window + * + * @remarks If the window is already restored, this function does nothing. + * + * @note This function may only be called from the main thread. + * + * @sa glfwIconifyWindow + */ +GLFWAPI void glfwRestoreWindow(GLFWwindow window); + +/*! @brief Makes the specified window visible. + * @param[in] window The window to make visible. + * @ingroup window + * + * @remarks If the window is already visible or is in fullscreen mode, this + * function does nothing. + * + * @note This function may only be called from the main thread. + * + * @sa glfwHideWindow + */ +GLFWAPI void glfwShowWindow(GLFWwindow window); + +/*! @brief Hides the specified window. + * @param[in] window The window to hide. + * @ingroup window + * + * @remarks If the window is already hidden or is in fullscreen mode, this + * function does nothing. + * + * @note This function may only be called from the main thread. + * + * @sa glfwShowWindow + */ +GLFWAPI void glfwHideWindow(GLFWwindow window); + +/*! @brief Returns a property of the specified window. + * @param[in] window The window to query. + * @param[in] param The property whose value to return. + * @ingroup window + * + * The @ref GLFW_FOCUSED property indicates whether the window is focused. + * + * The @ref GLFW_ICONIFIED property indicates whether the window is iconified. + * + * The @ref GLFW_VISIBLE property indicates whether the window is visible. + * + * The @ref GLFW_RESIZABLE property indicates whether the window is resizable + * by the user. + * + * The @ref GLFW_CLOSE_REQUESTED property indicates whether the window has been + * requested by the user to close. + * + * The @ref GLFW_REFRESH_RATE property will be replaced when the @c + * multi-monitor branch is merged. + * + * The @ref GLFW_POSITION_X and @ref GLFW_POSITION_Y properties indicate the + * screen position, in pixels, of the upper-left corner of the window's client + * area. + * + * The @ref GLFW_CLIENT_API property indicates the client API provided by the + * window's context. + * + * The @ref GLFW_OPENGL_VERSION_MAJOR, @ref GLFW_OPENGL_VERSION_MINOR and @ref + * GLFW_OPENGL_REVISION properties indicate the API version of the window's + * context. + * + * The @ref GLFW_OPENGL_FORWARD_COMPAT property indicates whether an OpenGL + * context is forward-compatible. + * + * The @ref GLFW_OPENGL_DEBUG_CONTEXT property indicates whether the + * corresponding window hint was used when the window was created. + * + * The @ref GLFW_OPENGL_PROFILE property indicates the profile used by the + * OpenGL context, or @ref GLFW_OPENGL_NO_PROFILE if the context is for another + * client API than OpenGL. + * + * The @ref GLFW_OPENGL_ROBUSTNESS property indicates the robustness strategy + * used by the OpenGL context, or @ref GLFW_OPENGL_NO_ROBUSTNESS if robustness + * is not used. + */ +GLFWAPI int glfwGetWindowParam(GLFWwindow window, int param); + +/*! @brief Sets the user pointer of the specified window. + * @param[in] window The window whose pointer to set. + * @param[in] pointer The new value. + * @ingroup window + * + * @sa glfwGetWindowUserPointer + */ +GLFWAPI void glfwSetWindowUserPointer(GLFWwindow window, void* pointer); + +/*! @brief Returns the user pointer of the specified window. + * @param[in] window The window whose pointer to return. + * @ingroup window + * + * @sa glfwSetWindowUserPointer + */ +GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow window); + +/*! @brief Sets the size callback for the specified window. + * @param[in] window The window whose callback to set. + * @param[in] cbfun The new callback, or @c NULL to remove the currently set + * callback. + * @ingroup window + */ +GLFWAPI void glfwSetWindowSizeCallback(GLFWwindow window, GLFWwindowsizefun cbfun); + +/*! @brief Sets the close callback for the specified window. + * @param[in] window The window whose callback to set. + * @param[in] cbfun The new callback, or @c NULL to remove the currently set + * callback. + * @ingroup window + */ +GLFWAPI void glfwSetWindowCloseCallback(GLFWwindow window, GLFWwindowclosefun cbfun); + +/*! @brief Sets the refresh callback for the specified window. + * @param[in] window The window whose callback to set. + * @param[in] cbfun The new callback, or @c NULL to remove the currently set + * callback. + * @ingroup window + */ +GLFWAPI void glfwSetWindowRefreshCallback(GLFWwindow window, GLFWwindowrefreshfun cbfun); + +/*! @brief Sets the focus callback for the specified window. + * @param[in] window The window whose callback to set. + * @param[in] cbfun The new callback, or @c NULL to remove the currently set + * callback. + * @ingroup window + */ +GLFWAPI void glfwSetWindowFocusCallback(GLFWwindow window, GLFWwindowfocusfun cbfun); + +/*! @brief Sets the iconify callback for the specified window. + * @param[in] window The window whose callback to set. + * @param[in] cbfun The new callback, or @c NULL to remove the currently set + * callback. + * @ingroup window + */ +GLFWAPI void glfwSetWindowIconifyCallback(GLFWwindow window, GLFWwindowiconifyfun cbfun); + +/*! @brief Processes all pending events. + * @ingroup window + * + * @note This function may only be called from the main thread. + * + * @sa glfwWaitEvents + */ GLFWAPI void glfwPollEvents(void); + +/*! @brief Waits until events are pending and processes them. + * @ingroup window + * + * @note This function may only be called from the main thread. + * + * @sa glfwPollEvents + */ GLFWAPI void glfwWaitEvents(void); -/* Input handling */ -GLFWAPI int glfwGetInputMode(GLFWwindow window, int mode); -GLFWAPI void glfwSetInputMode(GLFWwindow window, int mode, int value); -GLFWAPI int glfwGetKey(GLFWwindow window, int key); -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); +/*! @brief Returns the value of an input option for the specified window. + * @param[in] window The window to query. + * @param[in] mode One of the following: + * @arg @ref GLFW_CURSOR_MODE Sets the cursor mode. + * @arg @ref GLFW_STICKY_KEYS Sets whether sticky keys are enabled. + * @arg @ref GLFW_STICKY_MOUSE_BUTTONS Sets whether sticky mouse buttons are enabled. + * @ingroup input + * + * @sa glfwSetInputMode + */ +GLFWAPI int glfwGetInputMode(GLFWwindow window, int mode); -/* Joystick input */ +/*! @brief Sets an input option for the specified window. + * @param[in] mode One of the following: + * @arg @ref GLFW_CURSOR_MODE Sets the cursor mode. + * @arg @ref GLFW_STICKY_KEYS Sets whether sticky keys are enabled. + * @arg @ref GLFW_STICKY_MOUSE_BUTTONS Sets whether sticky mouse buttons are enabled. + * @ingroup input + * + * @sa glfwGetInputMode + */ +GLFWAPI void glfwSetInputMode(GLFWwindow window, int mode, int value); + +/*! @brief Returns the last reported state of a keyboard key for the specified + * window. + * @param[in] window The desired window. + * @param[in] key The desired @link keys keyboard key @endlink. + * @return @ref GLFW_PRESS or @ref GLFW_RELEASE. + * @ingroup input + */ +GLFWAPI int glfwGetKey(GLFWwindow window, int key); + +/*! @brief Returns the last reported state of a mouse button for the specified + * window. + * @param[in] window The desired window. + * @param[in] key The desired @link buttons mouse buttons @endlink. + * @return @ref GLFW_PRESS or @ref GLFW_RELEASE. + * @ingroup input + */ +GLFWAPI int glfwGetMouseButton(GLFWwindow window, int button); + +/*! @brief Retrieves the last reported cursor position, relative to the client + * area of the window. + * @param[in] window The desired window. + * @param[out] xpos The cursor x-coordinate, relative to the left edge of the + * client area, or @c NULL. + * @param[out] ypos The cursor y-coordinate, relative to the to top edge of the + * client area, or @c NULL. + * @ingroup input + * + * @sa glfwSetCursorPos + */ +GLFWAPI void glfwGetCursorPos(GLFWwindow window, int* xpos, int* ypos); + +/*! @brief Sets the position of the cursor, relative to the client area of the window. + * @param[in] window The desired window. + * @param[in] xpos The desired x-coordinate, relative to the left edge of the + * client area, or @c NULL. + * @param[in] ypos The desired y-coordinate, relative to the top edge of the + * client area, or @c NULL. + * @ingroup input + * + * @note The specified window must be focused. + * + * @sa glfwGetCursorPos + */ +GLFWAPI void glfwSetCursorPos(GLFWwindow window, int xpos, int ypos); + +/*! @ingroup input + */ +GLFWAPI void glfwGetScrollOffset(GLFWwindow window, double* xoffset, double* yoffset); + +/*! @brief Sets the key callback. + * @param[in] cbfun The new key callback, or @c NULL to remove the currently + * set callback. + * @ingroup input + * + * @note The key callback deals with physical keys, with @link keys tokens + * @endlink named after their use on the standard US keyboard layout. If you + * want to input text, use the Unicode character callback instead. + */ +GLFWAPI void glfwSetKeyCallback(GLFWwindow window, GLFWkeyfun cbfun); + +/*! @brief Sets the Unicode character callback. + * @param[in] cbfun The new Unicode character callback, or @c NULL to remove + * the currently set callback. + * @ingroup input + * + * @note The Unicode character callback is for text input. If you want to know + * whether a specific key was pressed or released, use the key callback. + */ +GLFWAPI void glfwSetCharCallback(GLFWwindow window, GLFWcharfun cbfun); + +/*! @brief Sets the mouse button callback. + * @param[in] cbfun The new mouse button callback, or @c NULL to remove the + * currently set callback. + * @ingroup input + */ +GLFWAPI void glfwSetMouseButtonCallback(GLFWwindow window, GLFWmousebuttonfun cbfun); + +/*! @brief Sets the cursor position callback. + * @param[in] cbfun The new cursor position callback, or @c NULL to remove the + * currently set callback. + * @ingroup input + */ +GLFWAPI void glfwSetCursorPosCallback(GLFWwindow window, GLFWcursorposfun cbfun); + +/*! @brief Sets the cursor enter/exit callback. + * @param[in] cbfun The new cursor enter/exit callback, or @c NULL to remove + * the currently set callback. + * @ingroup input + */ +GLFWAPI void glfwSetCursorEnterCallback(GLFWwindow window, GLFWcursorenterfun cbfun); + +/*! @brief Sets the scroll callback. + * @param[in] cbfun The new scroll callback, or @c NULL to remove the currently + * set callback. + * @ingroup input + * + * @note This receives all scrolling input, like that from a mouse wheel or + * a touchpad scrolling area. + */ +GLFWAPI void glfwSetScrollCallback(GLFWwindow window, GLFWscrollfun cbfun); + +/*! @brief Returns a property of the specified joystick. + * @param[in] joy The joystick to query. + * @param[in] param The property whose value to return. + * @return The specified joystick's current value, or zero if the joystick is + * not present. + * @ingroup input + */ GLFWAPI int glfwGetJoystickParam(int joy, int param); + +/*! @brief Returns the values of axes of the specified joystick. + * @param[in] joy The joystick to query. + * @param[out] axes The array to hold the values. + * @param[in] numaxes The size of the provided array. + * @return The number of values written to @p axes. + * @ingroup input + */ GLFWAPI int glfwGetJoystickAxes(int joy, float* axes, int numaxes); + +/*! @brief Returns the values of buttons of the specified joystick. + * @param[in] joy The joystick to query. + * @param[out] buttons The array to hold the values. + * @param[in] numbuttons The size of the provided array. + * @return The number of values written to @p buttons. + * @ingroup input + */ GLFWAPI int glfwGetJoystickButtons(int joy, unsigned char* buttons, int numbuttons); -/* Clipboard */ +/*! @brief Sets the clipboard to the specified string. + * @param[in] window The window that will own the clipboard contents. + * @param[in] string A UTF-8 encoded string. + * @ingroup clipboard + * + * @sa glfwGetClipboardString + */ GLFWAPI void glfwSetClipboardString(GLFWwindow window, const char* string); + +/*! @brief Retrieves the contents of the clipboard as a string. + * @param[in] window The window that will request the clipboard contents. + * @return The contents of the clipboard as a UTF-8 encoded string, or @c NULL + * if that format was unavailable. + * @ingroup clipboard + * + * @note The returned string is valid only until the next call to @ref + * glfwGetClipboardString or @ref glfwSetClipboardString. + * + * @sa glfwSetClipboardString + */ GLFWAPI const char* glfwGetClipboardString(GLFWwindow window); -/* Time */ +/*! @brief Retrieves the current value of the GLFW timer. + * @return The current value, in seconds. + * @ingroup time + * + * @remarks This function may be called from secondary threads. + * + * @remarks Unless the timer has been set using @ref glfwSetTime, the timer + * measures time elapsed since GLFW was initialized. + * + * @note The resolution of the timer is system dependent. + */ GLFWAPI double glfwGetTime(void); -GLFWAPI void glfwSetTime(double time); -/* OpenGL support */ +/*! @brief Sets the GLFW timer. + * @param[in] time The new value, in seconds. + * @ingroup time + * + * @note The resolution of the timer is system dependent. + */ +GLFWAPI void glfwSetTime(double time); + +/*! @brief Makes the context of the specified window current for this thread. + * @param[in] window The window whose context to make current, or @c NULL to + * detach the current context. + * @ingroup opengl + * + * @remarks This function may be called from secondary threads. + * + * @note A context may only be current for a single thread at a time. + * + * @sa glfwGetCurrentContext + */ GLFWAPI void glfwMakeContextCurrent(GLFWwindow window); + +/*! @brief Returns the window whose context is current on this thread. + * @return The window whose context is current, or @c NULL if no window's + * context is current. + * @ingroup opengl + * + * @remarks This function may be called from secondary threads. + * + * @sa glfwMakeContextCurrent + */ GLFWAPI GLFWwindow glfwGetCurrentContext(void); -GLFWAPI void glfwSwapBuffers(GLFWwindow window); -GLFWAPI void glfwSwapInterval(int interval); -GLFWAPI int glfwExtensionSupported(const char* extension); + +/*! @brief Swaps the front and back buffers of the specified window. + * @param[in] The window whose buffers to swap. + * @ingroup opengl + * + * @remarks This function may be called from secondary threads. + * + * @sa glfwSwapInterval + */ +GLFWAPI void glfwSwapBuffers(GLFWwindow window); + +/*! @brief Sets the swap interval for the current context. + * @param[in] interval The minimum number of video frame periods to wait for + * until the buffers are swapped by @ref glfwSwapBuffers. + * @ingroup opengl + * + * @remarks This function may be called from secondary threads. + * + * @sa glfwSwapBuffers + */ +GLFWAPI void glfwSwapInterval(int interval); + +/*! @brief Checks whether the specified extension is available. + * @param[in] extension The ASCII encoded name of the extension. + * @return @c GL_TRUE if the extension is available, or @c FALSE otherwise. + * @ingroup opengl + * + * @remarks This function may be called from secondary threads. + * + * @note This function checks not only the client API extension string, but + * also any platform-specific context creation API extension strings. + */ +GLFWAPI int glfwExtensionSupported(const char* extension); + +/*! @brief Returns the address of the specified client API function for the + * current context. + * @param[in] procname The ASCII encoded name of the function. + * @return The address of the function, or @c NULL if the function is + * unavailable. + * @ingroup opengl + * + * @remarks This function may be called from secondary threads. + */ GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname); -GLFWAPI void glfwCopyContext(GLFWwindow src, GLFWwindow dst, unsigned long mask); /************************************************************************* diff --git a/readme.html b/readme.html index 404c515b..5f299f98 100644 --- a/readme.html +++ b/readme.html @@ -268,6 +268,7 @@ version of GLFW.

v3.0

  • 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
    • @@ -278,11 +279,10 @@ version of GLFW.

  • Added glfwSetWindowIconifyCallback function and GLFWwindowiconifyfun type for receiving window iconification events
  • Added glfwGetClipboardString and glfwSetClipboardString functions for interacting with the system clipboard
  • Added glfwGetCurrentContext function for retrieving the window whose OpenGL context is current
    • -
  • Added glfwCopyContext function for copying OpenGL state categories between contexts
  • Added GLFW_CLIENT_API window hint for creating contexts for APIs other than desktop OpenGL
  • Added GLFW_OPENGL_ROBUSTNESS window hint and associated strategy tokens for GL_ARB_robustness support
  • Added GLFW_OPENGL_REVISION window parameter to make up for removal of glfwGetGLVersion
    • -
  • Added GLFW_INCLUDE_GL3 macro for telling the GLFW header to include gl3.h header instead of gl.h
    • +
  • Added GLFW_INCLUDE_GLCOREARB macro for including glcorearb.h instead of gl.h
  • Added GLFW_INCLUDE_ES2 macro for telling the GLFW header to include the OpenGL ES 2.0 header instead of gl.h
  • Added GLFW_VISIBLE window hint and parameter for controlling and polling window visibility
  • Added windows simple multi-window test program
    • @@ -298,6 +298,7 @@ version of GLFW.

  • Changed glfwGetVideoModes to return a dynamic, unlimited number of video modes
  • Renamed glfw.h to glfw3.h to avoid conflicts with 2.x series
  • Renamed glfwOpenWindowHint to glfwWindowHint
    • +
  • Renamed GLFW_ACTIVE to GLFW_FOCUSED
  • Renamed GLFW_WINDOW token to GLFW_WINDOWED
  • Renamed GLFW_WINDOW_NO_RESIZE to GLFW_RESIZABLE
  • Renamed GLFW_BUILD_DLL to _GLFW_BUILD_DLL
    • @@ -312,12 +313,13 @@ version of GLFW.

  • Replaced glfwEnable and glfwDisable with glfwGetInputMode and glfwSetInputMode
  • Replaced joystick test with graphical version
  • Replaced automatic closing of windows with GLFW_CLOSE_REQUESTED window parameter
    • -
  • Made Unicode character input unaffected by GLFW_KEY_REPEAT
    • +
  • Removed the GLFW_KEY_REPEAT input option
  • Removed event auto-polling and the GLFW_AUTO_POLL_EVENTS window enable
  • Removed the Win32 port .def files
  • 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
    • @@ -933,8 +935,9 @@ their skills. Special thanks go out to:

    Leopard
  • Riku Salminen, for the initial implementation of - glfwShowWindow and glfwHideWindow, and for making - the X11 event processing able to support multi-threaded rendering
    • + glfwShowWindow and glfwHideWindow, for the idea of + glfwDefaultWindowHints and for making the X11 event processing + able to support multi-threaded rendering
  • Douglas C. Schmidt and Irfan Pyarali, for their excellent article Strategies for Implementing POSIX Condition Variables on Win32
    • diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index b9bd0c77..5e1fcc39 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -2,6 +2,10 @@ include_directories(${GLFW_SOURCE_DIR}/src ${GLFW_BINARY_DIR}/src ${glfw_INCLUDE_DIRS}) +if (MSVC) + add_definitions(-D_CRT_SECURE_NO_WARNINGS) +endif() + set(common_HEADERS ${GLFW_SOURCE_DIR}/include/GL/glfw3.h internal.h) set(common_SOURCES clipboard.c fullscreen.c gamma.c init.c input.c joystick.c opengl.c time.c window.c) @@ -9,7 +13,7 @@ set(common_SOURCES clipboard.c fullscreen.c gamma.c init.c input.c if (_GLFW_COCOA_NSGL) set(glfw_HEADERS ${common_HEADERS} cocoa_platform.h) set(glfw_SOURCES ${common_SOURCES} cocoa_clipboard.m cocoa_fullscreen.m - cocoa_gamma.c cocoa_init.m cocoa_input.m cocoa_joystick.m + cocoa_gamma.c cocoa_init.m cocoa_joystick.m cocoa_opengl.m cocoa_time.c cocoa_window.m) if (GLFW_NATIVE_API) @@ -21,18 +25,17 @@ if (_GLFW_COCOA_NSGL) elseif (_GLFW_WIN32_WGL) set(glfw_HEADERS ${common_HEADERS} win32_platform.h) set(glfw_SOURCES ${common_SOURCES} win32_clipboard.c win32_fullscreen.c - win32_gamma.c win32_init.c win32_input.c win32_joystick.c + win32_gamma.c win32_init.c win32_joystick.c win32_opengl.c win32_time.c win32_window.c) if (GLFW_NATIVE_API) list(APPEND glfw_SOURCES win32_native.c) endif() elseif (_GLFW_X11_GLX) - set(glfw_HEADERS ${common_HEADERS} x11_platform.h glx_platform.h) + set(glfw_HEADERS ${common_HEADERS} x11_platform.h) set(glfw_SOURCES ${common_SOURCES} glx_opengl.c x11_clipboard.c - x11_fullscreen.c x11_gamma.c x11_init.c x11_input.c - x11_joystick.c x11_keysym2unicode.c x11_time.c - x11_window.c) + x11_fullscreen.c x11_gamma.c x11_init.c x11_joystick.c + x11_keysym2unicode.c x11_time.c x11_window.c) if (GLFW_NATIVE_API) list(APPEND glfw_SOURCES x11_native.c) @@ -40,7 +43,7 @@ elseif (_GLFW_X11_GLX) elseif (_GLFW_X11_EGL) set(glfw_HEADERS ${common_HEADERS} x11_platform.h egl_platform.h) set(glfw_SOURCES ${common_SOURCES} egl_opengl.c x11_clipboard.c - x11_fullscreen.c x11_gamma.c x11_init.c x11_input.c + x11_fullscreen.c x11_gamma.c x11_init.c x11_joystick.c x11_keysym2unicode.c x11_time.c x11_window.c) endif() diff --git a/src/cocoa_input.m b/src/cocoa_input.m deleted file mode 100644 index 11e1083b..00000000 --- a/src/cocoa_input.m +++ /dev/null @@ -1,53 +0,0 @@ -//======================================================================== -// GLFW - An OpenGL library -// Platform: Cocoa -// API Version: 3.0 -// WWW: http://www.glfw.org/ -//------------------------------------------------------------------------ -// Copyright (c) 2009-2010 Camilla Berglund -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would -// be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, and must not -// be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source -// distribution. -// -//======================================================================== - -#include "internal.h" - - -////////////////////////////////////////////////////////////////////////// -////// GLFW platform API ////// -////////////////////////////////////////////////////////////////////////// - -//======================================================================== -// Enable and disable system keys -//======================================================================== - -void _glfwPlatformEnableSystemKeys(_GLFWwindow* window) -{ - // This is checked in cocoa_window.m; no action needed here -} - -void _glfwPlatformDisableSystemKeys(_GLFWwindow* window) -{ - // This is checked in cocoa_window.m; no action needed here - - // Note that it may not be possible to disable things like Exposé - // except in full-screen mode. -} - diff --git a/src/cocoa_opengl.m b/src/cocoa_opengl.m index 4d4c4299..ed024d6e 100644 --- a/src/cocoa_opengl.m +++ b/src/cocoa_opengl.m @@ -147,13 +147,3 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname) return symbol; } - -//======================================================================== -// Copies the specified OpenGL state categories from src to dst -//======================================================================== - -void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask) -{ - [dst->NSGL.context copyAttributesFromContext:src->NSGL.context withMask:mask]; -} - diff --git a/src/cocoa_window.m b/src/cocoa_window.m index ed10d384..24ba6628 100644 --- a/src/cocoa_window.m +++ b/src/cocoa_window.m @@ -455,8 +455,7 @@ static int convertMacKeyCode(unsigned int macKeyCode) if ([event modifierFlags] & NSCommandKeyMask) { - if (window->systemKeys) - [super keyDown:event]; + [super keyDown:event]; } else { @@ -654,9 +653,9 @@ static GLboolean initializeAppKit(void) // Implicitly create shared NSApplication instance [GLFWApplication sharedApplication]; - // Setting up the menu bar must go between sharedApplication - // above and finishLaunching below, in order to properly emulate the - // behavior of NSApplicationMain + // Menu bar setup must go between sharedApplication above and + // finishLaunching below, in order to properly emulate the behavior + // of NSApplicationMain createMenuBar(); [NSApp finishLaunching]; @@ -686,7 +685,7 @@ static GLboolean createWindow(_GLFWwindow* window, styleMask = NSBorderlessWindowMask; window->NS.object = [[NSWindow alloc] - initWithContentRect:NSMakeRect(0, 0, window->width, window->height) + initWithContentRect:NSMakeRect(wndconfig->positionX, wndconfig->positionY, window->width, window->height) styleMask:styleMask backing:NSBackingStoreBuffered defer:NO]; @@ -729,7 +728,7 @@ static GLboolean createContext(_GLFWwindow* window, else if (colorBits < 15) colorBits = 15; - if (wndconfig->clientAPI != GLFW_OPENGL_ES_API) + if (wndconfig->clientAPI == GLFW_OPENGL_ES_API) { _glfwSetError(GLFW_VERSION_UNAVAILABLE, "Cocoa/NSOpenGL: NSOpenGL does not support OpenGL ES"); @@ -969,7 +968,6 @@ void _glfwPlatformDestroyWindow(_GLFWwindow* window) [window->NSGL.pixelFormat release]; window->NSGL.pixelFormat = nil; - [NSOpenGLContext clearCurrentContext]; [window->NSGL.context release]; window->NSGL.context = nil; @@ -1007,27 +1005,6 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height) } -//======================================================================== -// Set the window position -//======================================================================== - -void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y) -{ - NSRect contentRect = - [window->NS.object contentRectForFrameRect:[window->NS.object frame]]; - - // We assume here that the client code wants to position the window within the - // screen the window currently occupies - NSRect screenRect = [[window->NS.object screen] visibleFrame]; - contentRect.origin = NSMakePoint(screenRect.origin.x + x, - screenRect.origin.y + screenRect.size.height - - y - contentRect.size.height); - - [window->NS.object setFrame:[window->NS.object frameRectForContentRect:contentRect] - display:YES]; -} - - //======================================================================== // Iconify the window //======================================================================== diff --git a/src/config.h.in b/src/config.h.in index 6d8811c0..f725f89f 100644 --- a/src/config.h.in +++ b/src/config.h.in @@ -66,10 +66,7 @@ #cmakedefine _GLFW_HAS_GLXGETPROCADDRESSEXT // Define this to 1 if eglGetProcAddress is available -#cmakedefine _GLFW_HAS_EGLGETPROCADDRESS 1 - -// Define this to 1 if the Linux joystick API is available -#cmakedefine _GLFW_HAS_LINUX_JOYSTICKS +#cmakedefine _GLFW_HAS_EGLGETPROCADDRESS // The GLFW version as used by glfwGetVersionString #define _GLFW_VERSION_FULL "@GLFW_VERSION_FULL@" diff --git a/src/egl_opengl.c b/src/egl_opengl.c index bc7c0b43..b3247873 100644 --- a/src/egl_opengl.c +++ b/src/egl_opengl.c @@ -92,7 +92,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, { free(configs); - _glfwSetError(GLFW_OPENGL_UNAVAILABLE, + _glfwSetError(GLFW_API_UNAVAILABLE, "EGL: No EGLConfigs returned"); return NULL; } @@ -388,7 +388,7 @@ int _glfwInitOpenGL(void) _glfwLibrary.EGL.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY); if (_glfwLibrary.EGL.display == EGL_NO_DISPLAY) { - _glfwSetError(GLFW_OPENGL_UNAVAILABLE, + _glfwSetError(GLFW_API_UNAVAILABLE, "EGL: Failed to get EGL display"); return GL_FALSE; } @@ -397,7 +397,7 @@ int _glfwInitOpenGL(void) &_glfwLibrary.EGL.majorVersion, &_glfwLibrary.EGL.minorVersion)) { - _glfwSetError(GLFW_OPENGL_UNAVAILABLE, + _glfwSetError(GLFW_API_UNAVAILABLE, "EGL: Failed to initialize EGL"); return GL_FALSE; } diff --git a/src/gamma.c b/src/gamma.c index eed0b66d..51e0ce14 100644 --- a/src/gamma.c +++ b/src/gamma.c @@ -67,8 +67,12 @@ GLFWAPI void glfwSetGamma(float gamma) value = (float) i / (float) (size - 1); // Apply gamma curve value = (float) pow(value, 1.f / gamma) * 65535.f + 0.5f; + // Clamp to value range - value = (float) fmax(fmin(value, 65535.f), 0.f); + if (value < 0.f) + value = 0.f; + else if (value > 65535.f) + value = 65535.f; ramp.red[i] = (unsigned short) value; ramp.green[i] = (unsigned short) value; diff --git a/src/glx_opengl.c b/src/glx_opengl.c index bf93f878..0e2cc554 100644 --- a/src/glx_opengl.c +++ b/src/glx_opengl.c @@ -93,7 +93,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found) { if (!_glfwLibrary.GLX.SGIX_fbconfig) { - _glfwSetError(GLFW_OPENGL_UNAVAILABLE, + _glfwSetError(GLFW_API_UNAVAILABLE, "GLX: GLXFBConfig support not found"); return NULL; } @@ -103,8 +103,8 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found) if (strcmp(vendor, "Chromium") == 0) { - // This is a (hopefully temporary) workaround for Chromium (VirtualBox - // GL) not setting the window bit on any GLXFBConfigs + // HACK: This is a (hopefully temporary) workaround for Chromium + // (VirtualBox GL) not setting the window bit on any GLXFBConfigs trustWindowBit = GL_FALSE; } @@ -116,7 +116,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found) &count); if (!count) { - _glfwSetError(GLFW_OPENGL_UNAVAILABLE, + _glfwSetError(GLFW_API_UNAVAILABLE, "GLX: No GLXFBConfigs returned"); return NULL; } @@ -128,7 +128,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found) &count); if (!count) { - _glfwSetError(GLFW_OPENGL_UNAVAILABLE, + _glfwSetError(GLFW_API_UNAVAILABLE, "GLX: No GLXFBConfigs returned"); return NULL; } @@ -301,7 +301,7 @@ static int createContext(_GLFWwindow* window, !_glfwLibrary.GLX.EXT_create_context_es2_profile) { _glfwSetError(GLFW_VERSION_UNAVAILABLE, - "X11/GLX: OpenGL ES 2.x requested but " + "GLX: OpenGL ES 2.x requested but " "GLX_EXT_create_context_es2_profile is unavailable"); return GL_FALSE; } @@ -465,7 +465,7 @@ int _glfwInitOpenGL(void) // Check if GLX is supported on this display if (!glXQueryExtension(_glfwLibrary.X11.display, NULL, NULL)) { - _glfwSetError(GLFW_OPENGL_UNAVAILABLE, "GLX: GLX support not found"); + _glfwSetError(GLFW_API_UNAVAILABLE, "GLX: GLX support not found"); return GL_FALSE; } @@ -473,8 +473,7 @@ int _glfwInitOpenGL(void) &_glfwLibrary.GLX.majorVersion, &_glfwLibrary.GLX.minorVersion)) { - _glfwSetError(GLFW_OPENGL_UNAVAILABLE, - "GLX: Failed to query GLX version"); + _glfwSetError(GLFW_API_UNAVAILABLE, "GLX: Failed to query GLX version"); return GL_FALSE; } @@ -619,8 +618,6 @@ void _glfwDestroyContext(_GLFWwindow* window) if (window->GLX.context) { - // Release and destroy the context - glXMakeCurrent(_glfwLibrary.X11.display, None, NULL); glXDestroyContext(_glfwLibrary.X11.display, window->GLX.context); window->GLX.context = NULL; } @@ -724,16 +721,3 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname) return _glfw_glXGetProcAddress((const GLubyte*) procname); } - -//======================================================================== -// Copies the specified OpenGL state categories from src to dst -//======================================================================== - -void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask) -{ - glXCopyContext(_glfwLibrary.X11.display, - src->GLX.context, - dst->GLX.context, - mask); -} - diff --git a/src/init.c b/src/init.c index 7e9fe4e7..4d7b731e 100644 --- a/src/init.c +++ b/src/init.c @@ -121,19 +121,17 @@ GLFWAPI int glfwInit(void) memset(&_glfwLibrary, 0, sizeof(_glfwLibrary)); - // Not all window hints have zero as their default value - _glfwSetDefaultWindowHints(); - if (!_glfwPlatformInit()) { _glfwPlatformTerminate(); return GL_FALSE; } - atexit(glfwTerminate); - _glfwInitialized = GL_TRUE; + // Not all window hints have zero as their default value + glfwDefaultWindowHints(); + return GL_TRUE; } @@ -217,21 +215,19 @@ GLFWAPI const char* glfwErrorString(int error) case GLFW_NOT_INITIALIZED: return "The GLFW library is not initialized"; case GLFW_NO_CURRENT_CONTEXT: - return "There is no current OpenGL context"; + return "There is no current context"; case GLFW_INVALID_ENUM: return "Invalid argument for enum parameter"; case GLFW_INVALID_VALUE: return "Invalid value for parameter"; case GLFW_OUT_OF_MEMORY: return "Out of memory"; - case GLFW_OPENGL_UNAVAILABLE: - return "OpenGL is not available on this machine"; + case GLFW_API_UNAVAILABLE: + return "The requested client API is unavailable"; case GLFW_VERSION_UNAVAILABLE: - return "The requested OpenGL version is unavailable"; + return "The requested client API version is unavailable"; case GLFW_PLATFORM_ERROR: return "A platform-specific error occurred"; - case GLFW_WINDOW_NOT_ACTIVE: - return "The specified window is not active"; case GLFW_FORMAT_UNAVAILABLE: return "The requested format is unavailable"; } diff --git a/src/input.c b/src/input.c index 52b3b0fb..2a077502 100644 --- a/src/input.c +++ b/src/input.c @@ -115,34 +115,6 @@ static void setStickyMouseButtons(_GLFWwindow* window, int enabled) } -//======================================================================== -// Set system keys for the specified window -//======================================================================== - -static void setSystemKeys(_GLFWwindow* window, int enabled) -{ - if (window->systemKeys == enabled) - return; - - if (enabled) - _glfwPlatformEnableSystemKeys(window); - else - _glfwPlatformDisableSystemKeys(window); - - window->systemKeys = enabled; -} - - -//======================================================================== -// Set key repeat for the specified window -//======================================================================== - -static void setKeyRepeat(_GLFWwindow* window, int enabled) -{ - window->keyRepeat = enabled; -} - - ////////////////////////////////////////////////////////////////////////// ////// GLFW internal API ////// ////////////////////////////////////////////////////////////////////////// @@ -172,8 +144,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 && !repeated) + window->keyCallback(window, key, action); } @@ -187,8 +159,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 +173,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 +193,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 +221,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 +236,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); } @@ -295,10 +267,6 @@ GLFWAPI int glfwGetInputMode(GLFWwindow handle, int mode) return window->stickyKeys; case GLFW_STICKY_MOUSE_BUTTONS: return window->stickyMouseButtons; - case GLFW_SYSTEM_KEYS: - return window->systemKeys; - case GLFW_KEY_REPEAT: - return window->keyRepeat; default: _glfwSetError(GLFW_INVALID_ENUM, NULL); return 0; @@ -331,12 +299,6 @@ GLFWAPI void glfwSetInputMode(GLFWwindow handle, int mode, int value) case GLFW_STICKY_MOUSE_BUTTONS: setStickyMouseButtons(window, value ? GL_TRUE : GL_FALSE); break; - case GLFW_SYSTEM_KEYS: - setSystemKeys(window, value ? GL_TRUE : GL_FALSE); - break; - case GLFW_KEY_REPEAT: - setKeyRepeat(window, value ? GL_TRUE : GL_FALSE); - break; default: _glfwSetError(GLFW_INVALID_ENUM, NULL); break; @@ -445,11 +407,8 @@ GLFWAPI void glfwSetCursorPos(GLFWwindow handle, int xpos, int ypos) return; } - if (_glfwLibrary.activeWindow != window) - { - _glfwSetError(GLFW_WINDOW_NOT_ACTIVE, NULL); + if (_glfwLibrary.focusedWindow != window) return; - } // Don't do anything if the cursor position did not change if (xpos == window->cursorPosX && ypos == window->cursorPosY) @@ -494,15 +453,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 +471,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 +489,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 +507,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 +525,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 +543,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 5499d4f2..436a63ad 100644 --- a/src/internal.h +++ b/src/internal.h @@ -107,6 +107,8 @@ struct _GLFWhints GLboolean glDebug; int glProfile; int glRobustness; + int positionX; + int positionY; }; @@ -123,6 +125,8 @@ struct _GLFWwndconfig int refreshRate; GLboolean resizable; GLboolean visible; + int positionX; + int positionY; int clientAPI; int glMajor; int glMinor; @@ -172,7 +176,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 @@ -181,8 +185,6 @@ struct _GLFWwindow // Window input state GLboolean stickyKeys; GLboolean stickyMouseButtons; - GLboolean keyRepeat; - GLboolean systemKeys; // system keys enabled flag int cursorPosX, cursorPosY; int cursorMode; double scrollX, scrollY; @@ -197,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; @@ -211,19 +225,7 @@ struct _GLFWlibrary _GLFWhints hints; _GLFWwindow* windowListHead; - _GLFWwindow* activeWindow; - - GLFWwindowsizefun windowSizeCallback; - GLFWwindowclosefun windowCloseCallback; - GLFWwindowrefreshfun windowRefreshCallback; - GLFWwindowfocusfun windowFocusCallback; - GLFWwindowiconifyfun windowIconifyCallback; - GLFWmousebuttonfun mouseButtonCallback; - GLFWcursorposfun cursorPosCallback; - GLFWcursorenterfun cursorEnterCallback; - GLFWscrollfun scrollCallback; - GLFWkeyfun keyCallback; - GLFWcharfun charCallback; + _GLFWwindow* focusedWindow; GLFWgammaramp currentRamp; GLFWgammaramp originalRamp; @@ -290,7 +292,6 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window, const _GLFWwndconfig* wndcon void _glfwPlatformDestroyWindow(_GLFWwindow* window); void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title); void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height); -void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y); void _glfwPlatformIconifyWindow(_GLFWwindow* window); void _glfwPlatformRestoreWindow(_GLFWwindow* window); void _glfwPlatformShowWindow(_GLFWwindow* window); @@ -308,7 +309,6 @@ void _glfwPlatformSwapInterval(int interval); void _glfwPlatformRefreshWindowParams(_GLFWwindow* window); int _glfwPlatformExtensionSupported(const char* extension); GLFWglproc _glfwPlatformGetProcAddress(const char* procname); -void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask); //======================================================================== @@ -319,7 +319,7 @@ void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long //======================================================================== // Window event notification (window.c) -void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated); +void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused); void _glfwInputWindowPos(_GLFWwindow* window, int x, int y); void _glfwInputWindowSize(_GLFWwindow* window, int width, int height); void _glfwInputWindowIconify(_GLFWwindow* window, int iconified); @@ -350,9 +350,6 @@ void _glfwSplitBPP(int bpp, int* red, int* green, int* blue); // Error handling (init.c) void _glfwSetError(int error, const char* format, ...); -// Window management (window.c) -void _glfwSetDefaultWindowHints(void); - // OpenGL context helpers (opengl.c) int _glfwStringInExtensionString(const char* string, const GLubyte* extensions); const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired, diff --git a/src/opengl.c b/src/opengl.c index 722767f8..9412a75b 100644 --- a/src/opengl.c +++ b/src/opengl.c @@ -258,7 +258,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig) wndconfig->clientAPI != GLFW_OPENGL_ES_API) { _glfwSetError(GLFW_INVALID_ENUM, - "glfwOpenWindow: Invalid client API requested"); + "glfwCreateWindow: Invalid client API requested"); return GL_FALSE; } @@ -268,28 +268,28 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig) { // OpenGL 1.0 is the smallest valid version _glfwSetError(GLFW_INVALID_VALUE, - "glfwOpenWindow: Invalid OpenGL version requested"); + "glfwCreateWindow: Invalid OpenGL version requested"); return GL_FALSE; } if (wndconfig->glMajor == 1 && wndconfig->glMinor > 5) { // OpenGL 1.x series ended with version 1.5 _glfwSetError(GLFW_INVALID_VALUE, - "glfwOpenWindow: Invalid OpenGL version requested"); + "glfwCreateWindow: Invalid OpenGL version requested"); return GL_FALSE; } else if (wndconfig->glMajor == 2 && wndconfig->glMinor > 1) { // OpenGL 2.x series ended with version 2.1 _glfwSetError(GLFW_INVALID_VALUE, - "glfwOpenWindow: Invalid OpenGL version requested"); + "glfwCreateWindow: Invalid OpenGL version requested"); return GL_FALSE; } else if (wndconfig->glMajor == 3 && wndconfig->glMinor > 3) { // OpenGL 3.x series ended with version 3.3 _glfwSetError(GLFW_INVALID_VALUE, - "glfwOpenWindow: Invalid OpenGL version requested"); + "glfwCreateWindow: Invalid OpenGL version requested"); return GL_FALSE; } else @@ -303,7 +303,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig) wndconfig->glProfile != GLFW_OPENGL_COMPAT_PROFILE) { _glfwSetError(GLFW_INVALID_ENUM, - "glfwOpenWindow: Invalid OpenGL profile requested"); + "glfwCreateWindow: Invalid OpenGL profile requested"); return GL_FALSE; } @@ -314,7 +314,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig) // and above _glfwSetError(GLFW_INVALID_VALUE, - "glfwOpenWindow: Context profiles only exist for " + "glfwCreateWindow: Context profiles only exist for " "OpenGL version 3.2 and above"); return GL_FALSE; } @@ -324,7 +324,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig) { // Forward-compatible contexts are only defined for OpenGL version 3.0 and above _glfwSetError(GLFW_INVALID_VALUE, - "glfwOpenWindow: Forward compatibility only exist " + "glfwCreateWindow: Forward compatibility only exist " "for OpenGL version 3.0 and above"); return GL_FALSE; } @@ -335,14 +335,14 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig) { // OpenGL ES 1.0 is the smallest valid version _glfwSetError(GLFW_INVALID_VALUE, - "glfwOpenWindow: Invalid OpenGL ES version requested"); + "glfwCreateWindow: Invalid OpenGL ES version requested"); return GL_FALSE; } if (wndconfig->glMajor == 1 && wndconfig->glMinor > 1) { // OpenGL ES 1.x series ended with version 1.1 _glfwSetError(GLFW_INVALID_VALUE, - "glfwOpenWindow: Invalid OpenGL ES version requested"); + "glfwCreateWindow: Invalid OpenGL ES version requested"); return GL_FALSE; } else @@ -354,7 +354,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig) { // OpenGL ES does not support profiles _glfwSetError(GLFW_INVALID_VALUE, - "glfwOpenWindow: Context profiles are not supported " + "glfwCreateWindow: Context profiles are not supported " "by OpenGL ES"); return GL_FALSE; } @@ -363,7 +363,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig) { // OpenGL ES does not support forward-compatibility _glfwSetError(GLFW_INVALID_VALUE, - "glfwOpenWindow: Forward compatibility is not " + "glfwCreateWindow: Forward compatibility is not " "supported by OpenGL ES"); return GL_FALSE; } @@ -375,7 +375,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig) wndconfig->glRobustness != GLFW_OPENGL_LOSE_CONTEXT_ON_RESET) { _glfwSetError(GLFW_INVALID_VALUE, - "glfwOpenWindow: Invalid OpenGL robustness mode " + "glfwCreateWindow: Invalid OpenGL robustness mode " "requested"); return GL_FALSE; } @@ -683,32 +683,3 @@ GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname) return _glfwPlatformGetProcAddress(procname); } - -//======================================================================== -// Copies the specified context state categories from src to dst -//======================================================================== - -GLFWAPI void glfwCopyContext(GLFWwindow hsrc, GLFWwindow hdst, unsigned long mask) -{ - _GLFWwindow* src; - _GLFWwindow* dst; - - if (!_glfwInitialized) - { - _glfwSetError(GLFW_NOT_INITIALIZED, NULL); - return; - } - - src = (_GLFWwindow*) hsrc; - dst = (_GLFWwindow*) hdst; - - if (_glfwPlatformGetCurrentContext() == dst) - { - _glfwSetError(GLFW_INVALID_VALUE, - "glfwCopyContext: Cannot copy OpenGL state to a current context"); - return; - } - - _glfwPlatformCopyContext(src, dst, mask); -} - diff --git a/src/win32_fullscreen.c b/src/win32_fullscreen.c index 35d75054..26740d11 100644 --- a/src/win32_fullscreen.c +++ b/src/win32_fullscreen.c @@ -43,7 +43,7 @@ static GLboolean getClosestVideoMode(int* width, int* height, int* bpp, int* refreshRate, GLboolean exactBPP) { - int mode, bestWidth, bestHeight, bestBPP, bestRate; + int mode, bestWidth = 0, bestHeight = 0, bestBPP = 0, bestRate = 0; unsigned int sizeDiff, rateDiff, leastSizeDiff, leastRateDiff; GLboolean foundMode = GL_FALSE; DEVMODE dm; @@ -130,7 +130,7 @@ void _glfwSetVideoMode(int* width, int* height, closestRate = *refreshRate; if (getClosestVideoMode(&closestWidth, &closestHeight, - &closestBPP, &closestRate, GL_FALSE)) + &closestBPP, &closestRate, exactBPP)) { dm.dmSize = sizeof(DEVMODE); dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL; diff --git a/src/win32_input.c b/src/win32_input.c deleted file mode 100644 index a9195838..00000000 --- a/src/win32_input.c +++ /dev/null @@ -1,128 +0,0 @@ -//======================================================================== -// GLFW - An OpenGL library -// Platform: Win32 -// API version: 3.0 -// WWW: http://www.glfw.org/ -//------------------------------------------------------------------------ -// Copyright (c) 2002-2006 Marcus Geelnard -// Copyright (c) 2006-2010 Camilla Berglund -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would -// be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, and must not -// be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source -// distribution. -// -//======================================================================== - -#include "internal.h" - - -//======================================================================== -// Low level keyboard hook (system callback) function -// Used to disable system keys under Windows NT -//======================================================================== - -static LRESULT CALLBACK keyboardHook(int nCode, WPARAM wParam, LPARAM lParam) -{ - BOOL syskeys = FALSE; - PKBDLLHOOKSTRUCT p; - - // We are only looking for keyboard events - interpret lParam as a - // pointer to a KBDLLHOOKSTRUCT - p = (PKBDLLHOOKSTRUCT) lParam; - - if (nCode == HC_ACTION) - { - // We have a keyboard event - - switch (wParam) - { - case WM_KEYDOWN: - case WM_SYSKEYDOWN: - case WM_KEYUP: - case WM_SYSKEYUP: - // Detect: ALT+TAB, ALT+ESC, ALT+F4, CTRL+ESC, - // LWIN, RWIN, APPS (mysterious menu key) - syskeys = (p->vkCode == VK_TAB && - p->flags & LLKHF_ALTDOWN) || - (p->vkCode == VK_ESCAPE && - p->flags & LLKHF_ALTDOWN) || - (p->vkCode == VK_F4 && - p->flags & LLKHF_ALTDOWN) || - (p->vkCode == VK_ESCAPE && - (GetKeyState(VK_CONTROL) & 0x8000)) || - p->vkCode == VK_LWIN || - p->vkCode == VK_RWIN || - p->vkCode == VK_APPS; - break; - - default: - break; - } - } - - // Was it a system key combination (e.g. ALT+TAB)? - if (syskeys) - { - _GLFWwindow* window = _glfwLibrary.activeWindow; - - // Pass the key event to our window message loop - if (window) - PostMessage(window->Win32.handle, (UINT) wParam, p->vkCode, 0); - - // We've taken care of it - don't let the system know about this - // key event - return 1; - } - else - { - // It's a harmless key press, let the system deal with it - return CallNextHookEx(_glfwLibrary.Win32.keyboardHook, nCode, wParam, lParam); - } -} - - -////////////////////////////////////////////////////////////////////////// -////// GLFW platform API ////// -////////////////////////////////////////////////////////////////////////// - -//======================================================================== -// Enable system keys -//======================================================================== - -void _glfwPlatformEnableSystemKeys(_GLFWwindow* window) -{ - if (_glfwLibrary.Win32.keyboardHook != NULL) - { - UnhookWindowsHookEx(_glfwLibrary.Win32.keyboardHook); - _glfwLibrary.Win32.keyboardHook = NULL; - } -} - - -//======================================================================== -// Disable system keys -//======================================================================== - -void _glfwPlatformDisableSystemKeys(_GLFWwindow* window) -{ - _glfwLibrary.Win32.keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, - keyboardHook, - _glfwLibrary.Win32.instance, - 0); -} - diff --git a/src/win32_opengl.c b/src/win32_opengl.c index 0bcfe452..f1e911f3 100644 --- a/src/win32_opengl.c +++ b/src/win32_opengl.c @@ -189,7 +189,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found) if (!available) { - _glfwSetError(GLFW_OPENGL_UNAVAILABLE, "WGL: No pixel formats found"); + _glfwSetError(GLFW_API_UNAVAILABLE, "WGL: No pixel formats found"); return NULL; } @@ -411,7 +411,7 @@ static GLboolean createContext(_GLFWwindow* window, if (wndconfig->glRobustness) { - int strategy; + int strategy = 0; if (!window->WGL.ARB_create_context_robustness) { @@ -528,11 +528,6 @@ int _glfwCreateContext(_GLFWwindow* window, void _glfwDestroyContext(_GLFWwindow* window) { - // This is duplicated from glfwDestroyWindow - // TODO: Stop duplicating code - if (window == _glfwCurrentWindow) - _glfwPlatformMakeContextCurrent(NULL); - if (window->WGL.context) { wglDeleteContext(window->WGL.context); @@ -642,17 +637,3 @@ GLFWglproc _glfwPlatformGetProcAddress(const char* procname) return (GLFWglproc) wglGetProcAddress(procname); } - -//======================================================================== -// Copies the specified OpenGL state categories from src to dst -//======================================================================== - -void _glfwPlatformCopyContext(_GLFWwindow* src, _GLFWwindow* dst, unsigned long mask) -{ - if (!wglCopyContext(src->WGL.context, dst->WGL.context, mask)) - { - _glfwSetError(GLFW_PLATFORM_ERROR, - "WGL: Failed to copy OpenGL context attributes"); - } -} - diff --git a/src/win32_platform.h b/src/win32_platform.h index ba10039e..217fc2cf 100644 --- a/src/win32_platform.h +++ b/src/win32_platform.h @@ -176,7 +176,6 @@ typedef struct _GLFWlibraryWin32 { HINSTANCE instance; // Instance of the application ATOM classAtom; // Window class atom - HHOOK keyboardHook; // Keyboard hook handle DWORD foregroundLockTimeout; char* clipboardString; diff --git a/src/win32_window.c b/src/win32_window.c index 6b275476..a99f08dd 100644 --- a/src/win32_window.c +++ b/src/win32_window.c @@ -41,6 +41,7 @@ static void hideCursor(_GLFWwindow* window) { + UNREFERENCED_PARAMETER(window); } @@ -69,6 +70,8 @@ static void captureCursor(_GLFWwindow* window) static void showCursor(_GLFWwindow* window) { + UNREFERENCED_PARAMETER(window); + // Un-capture cursor ReleaseCapture(); @@ -325,22 +328,22 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, case WM_ACTIVATE: { - // Window was (de)activated and/or (de)iconified + // Window was (de)focused and/or (de)iconified - BOOL active = LOWORD(wParam) != WA_INACTIVE; + BOOL focused = LOWORD(wParam) != WA_INACTIVE; BOOL iconified = HIWORD(wParam) ? TRUE : FALSE; - if (active && iconified) + if (focused && iconified) { // This is a workaround for window iconification using the - // taskbar leading to windows being told they're active and - // iconified and then never told they're deactivated - active = FALSE; + // taskbar leading to windows being told they're focused and + // iconified and then never told they're defocused + focused = FALSE; } - if (!active && _glfwLibrary.activeWindow == window) + if (!focused && _glfwLibrary.focusedWindow == window) { - // The window was deactivated (or iconified, see above) + // The window was defocused (or iconified, see above) if (window->cursorMode == GLFW_CURSOR_CAPTURED) showCursor(window); @@ -361,9 +364,9 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, } } } - else if (active && _glfwLibrary.activeWindow != window) + else if (focused && _glfwLibrary.focusedWindow != window) { - // The window was activated + // The window was focused if (window->cursorMode == GLFW_CURSOR_CAPTURED) captureCursor(window); @@ -383,7 +386,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, } } - _glfwInputWindowFocus(window, active); + _glfwInputWindowFocus(window, focused); _glfwInputWindowIconify(window, iconified); return 0; } @@ -541,7 +544,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, if (window->cursorMode == GLFW_CURSOR_CAPTURED) { - if (_glfwLibrary.activeWindow != window) + if (_glfwLibrary.focusedWindow != window) return 0; x = newCursorX - window->Win32.oldCursorX; @@ -769,7 +772,11 @@ static int createWindow(_GLFWwindow* window, if (window->mode == GLFW_FULLSCREEN) wa.left = wa.top = 0; else + { SystemParametersInfo(SPI_GETWORKAREA, 0, &wa, 0); + wa.left += wndconfig->positionX; + wa.top += wndconfig->positionY; + } wideTitle = _glfwCreateWideStringFromUTF8(wndconfig->title); if (!wideTitle) @@ -822,8 +829,8 @@ static void destroyWindow(_GLFWwindow* window) // This is duplicated from glfwDestroyWindow // TODO: Stop duplicating code - if (window == _glfwLibrary.activeWindow) - _glfwLibrary.activeWindow = NULL; + if (window == _glfwLibrary.focusedWindow) + _glfwLibrary.focusedWindow = NULL; if (window->Win32.handle) { @@ -947,8 +954,16 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window, // we're just creating an OpenGL 3.0+ context with the same pixel // format, but it's not worth the added code complexity + // First we clear the current context (the one we just created) + // This is usually done by glfwDestroyWindow, but as we're not doing + // full window destruction, it's duplicated here + _glfwPlatformMakeContextCurrent(NULL); + + // Next destroy the Win32 window and WGL context (without resetting or + // destroying the GLFW window object) destroyWindow(window); + // ...and then create them again, this time with better APIs if (!createWindow(window, wndconfig, fbconfig)) return GL_FALSE; } @@ -1043,23 +1058,6 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height) } -//======================================================================== -// Set the window position -//======================================================================== - -void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y) -{ - RECT rect; - - GetClientRect(window->Win32.handle, &rect); - AdjustWindowRectEx(&rect, window->Win32.dwStyle, FALSE, window->Win32.dwExStyle); - - SetWindowPos(window->Win32.handle, HWND_TOP, - x + rect.left, y + rect.top, 0, 0, - SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER); -} - - //======================================================================== // Window iconification //======================================================================== @@ -1134,7 +1132,7 @@ void _glfwPlatformPollEvents(void) MSG msg; _GLFWwindow* window; - window = _glfwLibrary.activeWindow; + window = _glfwLibrary.focusedWindow; if (window) { window->Win32.cursorCentered = GL_FALSE; @@ -1170,7 +1168,7 @@ void _glfwPlatformPollEvents(void) // LSHIFT/RSHIFT fixup (keys tend to "stick" without this fix) // This is the only async event handling in GLFW, but it solves some // nasty problems. - window = _glfwLibrary.activeWindow; + window = _glfwLibrary.focusedWindow; if (window) { int lshift_down, rshift_down; @@ -1188,8 +1186,8 @@ void _glfwPlatformPollEvents(void) _glfwInputKey(window, GLFW_KEY_RIGHT_SHIFT, GLFW_RELEASE); } - // Did the cursor move in an active window that has captured the cursor - window = _glfwLibrary.activeWindow; + // Did the cursor move in an focused window that has captured the cursor + window = _glfwLibrary.focusedWindow; if (window) { if (window->cursorMode == GLFW_CURSOR_CAPTURED && diff --git a/src/window.c b/src/window.c index c3bde9b1..908a2a7c 100644 --- a/src/window.c +++ b/src/window.c @@ -68,50 +68,25 @@ 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 depth, 8 bits of color - _glfwLibrary.hints.depthBits = 24; - _glfwLibrary.hints.redBits = 8; - _glfwLibrary.hints.greenBits = 8; - _glfwLibrary.hints.blueBits = 8; -} - - //======================================================================== // Register window focus events //======================================================================== -void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated) +void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused) { - if (activated) + if (focused) { - if (_glfwLibrary.activeWindow != window) + if (_glfwLibrary.focusedWindow != window) { - _glfwLibrary.activeWindow = window; + _glfwLibrary.focusedWindow = window; - if (_glfwLibrary.windowFocusCallback) - _glfwLibrary.windowFocusCallback(window, activated); + if (window->windowFocusCallback) + window->windowFocusCallback(window, focused); } } else { - if (_glfwLibrary.activeWindow == window) + if (_glfwLibrary.focusedWindow == window) { int i; @@ -129,10 +104,10 @@ void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean activated) _glfwInputMouseClick(window, i, GLFW_RELEASE); } - _glfwLibrary.activeWindow = NULL; + _glfwLibrary.focusedWindow = NULL; - if (_glfwLibrary.windowFocusCallback) - _glfwLibrary.windowFocusCallback(window, activated); + if (window->windowFocusCallback) + window->windowFocusCallback(window, focused); } } } @@ -161,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); } @@ -177,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); } @@ -198,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); } @@ -209,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; } @@ -263,6 +238,8 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height, wndconfig.refreshRate = Max(_glfwLibrary.hints.refreshRate, 0); wndconfig.resizable = _glfwLibrary.hints.resizable ? GL_TRUE : GL_FALSE; wndconfig.visible = _glfwLibrary.hints.visible ? GL_TRUE : GL_FALSE; + wndconfig.positionX = _glfwLibrary.hints.positionX; + wndconfig.positionY = _glfwLibrary.hints.positionY; wndconfig.clientAPI = _glfwLibrary.hints.clientAPI; wndconfig.glMajor = _glfwLibrary.hints.glMajor; wndconfig.glMinor = _glfwLibrary.hints.glMinor; @@ -270,10 +247,7 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height, wndconfig.glDebug = _glfwLibrary.hints.glDebug ? GL_TRUE : GL_FALSE; wndconfig.glProfile = _glfwLibrary.hints.glProfile; wndconfig.glRobustness = _glfwLibrary.hints.glRobustness ? GL_TRUE : GL_FALSE; - wndconfig.share = share; - - // Reset to default values for the next call - _glfwSetDefaultWindowHints(); + wndconfig.share = (_GLFWwindow*) share; // Check the OpenGL bits of the window config if (!_glfwIsValidContextConfig(&wndconfig)) @@ -289,33 +263,20 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height, return GL_FALSE; } - // Check width & height - if (width > 0 && height <= 0) + if (width <= 0 || height <= 0) { - // Set the window aspect ratio to 4:3 - height = (width * 3) / 4; - } - else if (width <= 0 && height > 0) - { - // Set the window aspect ratio to 4:3 - width = (height * 4) / 3; - } - else if (width <= 0 && height <= 0) - { - // Default window size - width = 640; - height = 480; + _glfwSetError(GLFW_INVALID_VALUE, + "glfwCreateWindow: Invalid window size"); + return GL_FALSE; } - window = (_GLFWwindow*) malloc(sizeof(_GLFWwindow)); + window = (_GLFWwindow*) calloc(1, sizeof(_GLFWwindow)); if (!window) { _glfwSetError(GLFW_OUT_OF_MEMORY, NULL); return NULL; } - memset(window, 0, sizeof(_GLFWwindow)); - window->next = _glfwLibrary.windowListHead; _glfwLibrary.windowListHead = window; @@ -325,7 +286,6 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height, window->mode = mode; window->resizable = wndconfig.resizable; window->cursorMode = GLFW_CURSOR_NORMAL; - window->systemKeys = GL_TRUE; // Open the actual window and create its context if (!_glfwPlatformCreateWindow(window, &wndconfig, &fbconfig)) @@ -376,6 +336,42 @@ 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 window position is the upper left corner of the screen + _glfwLibrary.hints.positionX = 0; + _glfwLibrary.hints.positionY = 0; + + // 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 //======================================================================== @@ -435,6 +431,12 @@ GLFWAPI void glfwWindowHint(int target, int hint) case GLFW_VISIBLE: _glfwLibrary.hints.visible = hint; break; + case GLFW_POSITION_X: + _glfwLibrary.hints.positionX = hint; + break; + case GLFW_POSITION_Y: + _glfwLibrary.hints.positionY = hint; + break; case GLFW_FSAA_SAMPLES: _glfwLibrary.hints.samples = hint; break; @@ -484,14 +486,14 @@ GLFWAPI void glfwDestroyWindow(GLFWwindow handle) if (window == NULL) return; - // Clear the current context if this window's context is current - // TODO: Re-examine this in light of multithreading + // The window's context must not be current on another thread when the + // window is destroyed if (window == _glfwPlatformGetCurrentContext()) _glfwPlatformMakeContextCurrent(NULL); - // Clear the active window pointer if this is the active window - if (window == _glfwLibrary.activeWindow) - _glfwLibrary.activeWindow = NULL; + // Clear the focused window pointer if this is the focused window + if (window == _glfwLibrary.focusedWindow) + _glfwLibrary.focusedWindow = NULL; _glfwPlatformDestroyWindow(window); @@ -584,52 +586,6 @@ GLFWAPI void glfwSetWindowSize(GLFWwindow handle, int width, int height) } -//======================================================================== -// Get the window position -//======================================================================== - -GLFWAPI void glfwGetWindowPos(GLFWwindow handle, int* xpos, int* ypos) -{ - _GLFWwindow* window = (_GLFWwindow*) handle; - - if (!_glfwInitialized) - { - _glfwSetError(GLFW_NOT_INITIALIZED, NULL); - return; - } - - if (xpos != NULL) - *xpos = window->positionX; - - if (ypos != NULL) - *ypos = window->positionY; -} - - -//======================================================================== -// Set the window position -//======================================================================== - -GLFWAPI void glfwSetWindowPos(GLFWwindow handle, int xpos, int ypos) -{ - _GLFWwindow* window = (_GLFWwindow*) handle; - - if (!_glfwInitialized) - { - _glfwSetError(GLFW_NOT_INITIALIZED, NULL); - return; - } - - if (window->mode == GLFW_FULLSCREEN || window->iconified) - { - // TODO: Figure out if this is an error - return; - } - - _glfwPlatformSetWindowPos(window, xpos, ypos); -} - - //======================================================================== // Window iconification //======================================================================== @@ -733,8 +689,8 @@ GLFWAPI int glfwGetWindowParam(GLFWwindow handle, int param) switch (param) { - case GLFW_ACTIVE: - return window == _glfwLibrary.activeWindow; + case GLFW_FOCUSED: + return window == _glfwLibrary.focusedWindow; case GLFW_ICONIFIED: return window->iconified; case GLFW_CLOSE_REQUESTED: @@ -745,6 +701,10 @@ GLFWAPI int glfwGetWindowParam(GLFWwindow handle, int param) return window->resizable; case GLFW_VISIBLE: return window->visible; + case GLFW_POSITION_X: + return window->positionX; + case GLFW_POSITION_Y: + return window->positionY; case GLFW_CLIENT_API: return window->clientAPI; case GLFW_OPENGL_VERSION_MAJOR: @@ -808,15 +768,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; } @@ -824,15 +786,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; } @@ -840,15 +804,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; } @@ -856,15 +822,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; } @@ -872,15 +840,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/src/x11_init.c b/src/x11_init.c index a4cfacf0..b76d307e 100644 --- a/src/x11_init.c +++ b/src/x11_init.c @@ -491,7 +491,7 @@ static GLboolean initDisplay(void) _glfwLibrary.X11.display = XOpenDisplay(NULL); if (!_glfwLibrary.X11.display) { - _glfwSetError(GLFW_OPENGL_UNAVAILABLE, "X11: Failed to open X display"); + _glfwSetError(GLFW_API_UNAVAILABLE, "X11: Failed to open X display"); return GL_FALSE; } @@ -728,7 +728,7 @@ const char* _glfwPlatformGetVersionString(void) #if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK) " clock_gettime" #endif -#if defined(_GLFW_HAS_LINUX_JOYSTICKS) +#if defined(__linux__) " Linux-joystick-API" #else " no-joystick-support" diff --git a/src/x11_input.c b/src/x11_input.c deleted file mode 100644 index 2ea8b8c4..00000000 --- a/src/x11_input.c +++ /dev/null @@ -1,65 +0,0 @@ -//======================================================================== -// GLFW - An OpenGL library -// Platform: X11 -// API version: 3.0 -// WWW: http://www.glfw.org/ -//------------------------------------------------------------------------ -// Copyright (c) 2002-2006 Marcus Geelnard -// Copyright (c) 2006-2010 Camilla Berglund -// -// This software is provided 'as-is', without any express or implied -// warranty. In no event will the authors be held liable for any damages -// arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it -// freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not -// claim that you wrote the original software. If you use this software -// in a product, an acknowledgment in the product documentation would -// be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, and must not -// be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source -// distribution. -// -//======================================================================== - -#include "internal.h" - - -////////////////////////////////////////////////////////////////////////// -////// GLFW platform API ////// -////////////////////////////////////////////////////////////////////////// - -//======================================================================== -// Enable system keys -//======================================================================== - -void _glfwPlatformEnableSystemKeys(_GLFWwindow* window) -{ - if (window->X11.keyboardGrabbed) - { - XUngrabKeyboard(_glfwLibrary.X11.display, CurrentTime); - window->X11.keyboardGrabbed = GL_FALSE; - } -} - - -//======================================================================== -// Disable system keys -//======================================================================== - -void _glfwPlatformDisableSystemKeys(_GLFWwindow* window) -{ - if (XGrabKeyboard(_glfwLibrary.X11.display, window->X11.handle, - True, GrabModeAsync, GrabModeAsync, CurrentTime) - == GrabSuccess) - { - window->X11.keyboardGrabbed = GL_TRUE; - } -} - diff --git a/src/x11_joystick.c b/src/x11_joystick.c index 3d2f597d..93ab3e7f 100644 --- a/src/x11_joystick.c +++ b/src/x11_joystick.c @@ -30,7 +30,7 @@ #include "internal.h" -#ifdef _GLFW_HAS_LINUX_JOYSTICKS +#ifdef __linux__ #include #include @@ -41,7 +41,7 @@ #include #include #include -#endif // _GLFW_HAS_LINUX_JOYSTICKS +#endif // __linux__ //======================================================================== @@ -50,7 +50,7 @@ static int openJoystickDevice(int joy, const char* path) { -#ifdef _GLFW_HAS_LINUX_JOYSTICKS +#ifdef __linux__ char numAxes, numButtons; int fd, version; @@ -97,7 +97,7 @@ static int openJoystickDevice(int joy, const char* path) } _glfwLibrary.X11.joystick[joy].present = GL_TRUE; -#endif // _GLFW_HAS_LINUX_JOYSTICKS +#endif // __linux__ return GL_TRUE; } @@ -109,7 +109,7 @@ static int openJoystickDevice(int joy, const char* path) static void pollJoystickEvents(void) { -#ifdef _GLFW_HAS_LINUX_JOYSTICKS +#ifdef __linux__ int i; ssize_t result; struct js_event e; @@ -160,7 +160,7 @@ static void pollJoystickEvents(void) } } } -#endif // _GLFW_HAS_LINUX_JOYSTICKS +#endif // __linux__ } @@ -174,7 +174,7 @@ static void pollJoystickEvents(void) int _glfwInitJoysticks(void) { -#ifdef _GLFW_HAS_LINUX_JOYSTICKS +#ifdef __linux__ int i, joy = 0; regex_t regex; DIR* dir; @@ -215,7 +215,7 @@ int _glfwInitJoysticks(void) } regfree(®ex); -#endif // _GLFW_HAS_LINUX_JOYSTICKS +#endif // __linux__ return GL_TRUE; } @@ -227,7 +227,7 @@ int _glfwInitJoysticks(void) void _glfwTerminateJoysticks(void) { -#ifdef _GLFW_HAS_LINUX_JOYSTICKS +#ifdef __linux__ int i; for (i = 0; i <= GLFW_JOYSTICK_LAST; i++) @@ -241,7 +241,7 @@ void _glfwTerminateJoysticks(void) _glfwLibrary.X11.joystick[i].present = GL_FALSE; } } -#endif // _GLFW_HAS_LINUX_JOYSTICKS +#endif // __linux__ } diff --git a/src/x11_platform.h b/src/x11_platform.h index 3bc06a23..e2acc6e6 100644 --- a/src/x11_platform.h +++ b/src/x11_platform.h @@ -99,12 +99,17 @@ typedef struct _GLFWwindowX11 // Various platform specific internal variables GLboolean overrideRedirect; // True if window is OverrideRedirect - GLboolean keyboardGrabbed; // True if keyboard is currently grabbed GLboolean cursorGrabbed; // True if cursor is currently grabbed GLboolean cursorHidden; // True if cursor is currently hidden GLboolean cursorCentered; // True if cursor was moved since last poll int cursorPosX, cursorPosY; + // Window position hint (commited the first time the window is shown) + GLboolean windowPosSet; // False until the window position has + // been set + int positionX; // The window position to be set the + int positionY; // first time the window is shown + } _GLFWwindowX11; diff --git a/src/x11_window.c b/src/x11_window.c index 5cf1e614..bc880d77 100644 --- a/src/x11_window.c +++ b/src/x11_window.c @@ -119,7 +119,7 @@ static GLboolean createWindow(_GLFWwindow* window, window->X11.handle = XCreateWindow(_glfwLibrary.X11.display, _glfwLibrary.X11.root, - 0, 0, // Position + wndconfig->positionX, wndconfig->positionY, window->width, window->height, 0, // Border width visual->depth, // Color depth @@ -136,6 +136,12 @@ static GLboolean createWindow(_GLFWwindow* window, _glfwSetError(GLFW_PLATFORM_ERROR, "X11: Failed to create window"); return GL_FALSE; } + + // Request a window position to be set once the window is shown + // (see _glfwPlatformShowWindow) + window->X11.windowPosSet = GL_FALSE; + window->X11.positionX = wndconfig->positionX; + window->X11.positionY = wndconfig->positionY; } if (window->mode == GLFW_FULLSCREEN && !_glfwLibrary.X11.hasEWMH) @@ -238,6 +244,15 @@ static GLboolean createWindow(_GLFWwindow* window, static void hideCursor(_GLFWwindow* window) { + // Un-grab cursor (in windowed mode only; in fullscreen mode we still + // want the cursor grabbed in order to confine the cursor to the window + // area) + if (window->X11.cursorGrabbed && window->mode == GLFW_WINDOWED) + { + XUngrabPointer(_glfwLibrary.X11.display, CurrentTime); + window->X11.cursorGrabbed = GL_FALSE; + } + if (!window->X11.cursorHidden) { XDefineCursor(_glfwLibrary.X11.display, @@ -280,7 +295,7 @@ static void showCursor(_GLFWwindow* window) // Un-grab cursor (in windowed mode only; in fullscreen mode we still // want the cursor grabbed in order to confine the cursor to the window // area) - if (window->X11.cursorGrabbed) + if (window->X11.cursorGrabbed && window->mode == GLFW_WINDOWED) { XUngrabPointer(_glfwLibrary.X11.display, CurrentTime); window->X11.cursorGrabbed = GL_FALSE; @@ -617,7 +632,7 @@ static void processEvent(XEvent *event) if (window->cursorMode == GLFW_CURSOR_CAPTURED) { - if (_glfwLibrary.activeWindow != window) + if (_glfwLibrary.focusedWindow != window) break; x = event->xmotion.x - window->X11.cursorPosX; @@ -997,16 +1012,6 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height) } -//======================================================================== -// Set the window position. -//======================================================================== - -void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y) -{ - XMoveWindow(_glfwLibrary.X11.display, window->X11.handle, x, y); -} - - //======================================================================== // Window iconification //======================================================================== @@ -1051,6 +1056,15 @@ void _glfwPlatformShowWindow(_GLFWwindow* window) { XMapRaised(_glfwLibrary.X11.display, window->X11.handle); XFlush(_glfwLibrary.X11.display); + + // Set the window position the first time the window is shown + // Note: XMoveWindow has no effect before the window has been mapped. + if (!window->X11.windowPosSet) + { + XMoveWindow(_glfwLibrary.X11.display, window->X11.handle, + window->X11.positionX, window->X11.positionY); + window->X11.windowPosSet = GL_TRUE; + } } @@ -1120,11 +1134,11 @@ void _glfwPlatformPollEvents(void) processEvent(&event); } - // Check whether the cursor has moved inside an active window that has + // Check whether the cursor has moved inside an focused window that has // captured the cursor (because then it needs to be re-centered) _GLFWwindow* window; - window = _glfwLibrary.activeWindow; + window = _glfwLibrary.focusedWindow; if (window) { if (window->cursorMode == GLFW_CURSOR_CAPTURED && diff --git a/tests/accuracy.c b/tests/accuracy.c index f3fb752b..d320f64c 100644 --- a/tests/accuracy.c +++ b/tests/accuracy.c @@ -86,10 +86,6 @@ int main(void) exit(EXIT_FAILURE); } - glfwSetCursorPosCallback(cursor_position_callback); - glfwSetWindowSizeCallback(window_size_callback); - glfwSetKeyCallback(key_callback); - window = glfwCreateWindow(window_width, window_height, GLFW_WINDOWED, "", NULL); if (!window) { @@ -99,6 +95,10 @@ int main(void) exit(EXIT_FAILURE); } + glfwSetCursorPosCallback(window, cursor_position_callback); + glfwSetWindowSizeCallback(window, window_size_callback); + glfwSetKeyCallback(window, key_callback); + glfwMakeContextCurrent(window); glfwGetWindowSize(window, &width, &height); diff --git a/tests/clipboard.c b/tests/clipboard.c index f83bbfea..c3746f19 100644 --- a/tests/clipboard.c +++ b/tests/clipboard.c @@ -125,7 +125,7 @@ int main(int argc, char** argv) exit(EXIT_FAILURE); } - window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Clipboard Test", NULL); + window = glfwCreateWindow(200, 200, GLFW_WINDOWED, "Clipboard Test", NULL); if (!window) { glfwTerminate(); @@ -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/defaults.c b/tests/defaults.c index 2877cfd9..b1103ca4 100644 --- a/tests/defaults.c +++ b/tests/defaults.c @@ -85,7 +85,7 @@ int main(void) glfwWindowHint(GLFW_VISIBLE, GL_FALSE); - window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Defaults", NULL); + window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Defaults", NULL); if (!window) { glfwTerminate(); diff --git a/tests/events.c b/tests/events.c index 809da473..3150a82e 100644 --- a/tests/events.c +++ b/tests/events.c @@ -41,8 +41,6 @@ #include // These must match the input mode defaults -static GLboolean keyrepeat = GL_FALSE; -static GLboolean systemkeys = GL_TRUE; static GLboolean closeable = GL_TRUE; // Event index @@ -249,12 +247,12 @@ static void window_refresh_callback(GLFWwindow window) } } -static void window_focus_callback(GLFWwindow window, int activated) +static void window_focus_callback(GLFWwindow window, int focused) { printf("%08x at %0.3f: Window %s\n", counter++, glfwGetTime(), - activated ? "activated" : "deactivated"); + focused ? "focused" : "defocused"); } static void window_iconify_callback(GLFWwindow window, int iconified) @@ -311,24 +309,6 @@ static void key_callback(GLFWwindow window, int key, int action) switch (key) { - case GLFW_KEY_R: - { - keyrepeat = !keyrepeat; - glfwSetInputMode(window, GLFW_KEY_REPEAT, keyrepeat); - - printf("(( key repeat %s ))\n", keyrepeat ? "enabled" : "disabled"); - break; - } - - case GLFW_KEY_S: - { - systemkeys = !systemkeys; - glfwSetInputMode(window, GLFW_SYSTEM_KEYS, systemkeys); - - printf("(( system keys %s ))\n", systemkeys ? "enabled" : "disabled"); - break; - } - case GLFW_KEY_C: { closeable = !closeable; @@ -363,19 +343,7 @@ int main(void) printf("Library initialized\n"); - glfwSetWindowSizeCallback(window_size_callback); - glfwSetWindowCloseCallback(window_close_callback); - glfwSetWindowRefreshCallback(window_refresh_callback); - glfwSetWindowFocusCallback(window_focus_callback); - glfwSetWindowIconifyCallback(window_iconify_callback); - glfwSetMouseButtonCallback(mouse_button_callback); - glfwSetCursorPosCallback(cursor_position_callback); - glfwSetCursorEnterCallback(cursor_enter_callback); - glfwSetScrollCallback(scroll_callback); - glfwSetKeyCallback(key_callback); - glfwSetCharCallback(char_callback); - - window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Event Linter", NULL); + window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Event Linter", NULL); if (!window) { glfwTerminate(); @@ -386,15 +354,24 @@ int main(void) printf("Window opened\n"); + glfwSetWindowSizeCallback(window, window_size_callback); + glfwSetWindowCloseCallback(window, window_close_callback); + glfwSetWindowRefreshCallback(window, window_refresh_callback); + glfwSetWindowFocusCallback(window, window_focus_callback); + glfwSetWindowIconifyCallback(window, window_iconify_callback); + glfwSetMouseButtonCallback(window, mouse_button_callback); + glfwSetCursorPosCallback(window, cursor_position_callback); + glfwSetCursorEnterCallback(window, cursor_enter_callback); + glfwSetScrollCallback(window, scroll_callback); + glfwSetKeyCallback(window, key_callback); + glfwSetCharCallback(window, char_callback); + glfwMakeContextCurrent(window); glfwSwapInterval(1); glfwGetWindowSize(window, &width, &height); printf("Window size should be %ix%i\n", width, height); - printf("Key repeat should be %s\n", keyrepeat ? "enabled" : "disabled"); - printf("System keys should be %s\n", systemkeys ? "enabled" : "disabled"); - printf("Main loop starting\n"); while (!glfwGetWindowParam(window, GLFW_CLOSE_REQUESTED)) diff --git a/tests/fsaa.c b/tests/fsaa.c index 8fc8b60a..735a1f5f 100644 --- a/tests/fsaa.c +++ b/tests/fsaa.c @@ -93,9 +93,6 @@ int main(int argc, char** argv) else printf("Requesting that FSAA not be available\n"); - glfwSetKeyCallback(key_callback); - glfwSetWindowSizeCallback(window_size_callback); - glfwWindowHint(GLFW_FSAA_SAMPLES, samples); window = glfwCreateWindow(800, 400, GLFW_WINDOWED, "Aliasing Detector", NULL); @@ -107,6 +104,9 @@ int main(int argc, char** argv) exit(EXIT_FAILURE); } + glfwSetKeyCallback(window, key_callback); + glfwSetWindowSizeCallback(window, window_size_callback); + glfwMakeContextCurrent(window); glfwSwapInterval(1); diff --git a/tests/fsfocus.c b/tests/fsfocus.c index 1c46d7af..a87d136a 100644 --- a/tests/fsfocus.c +++ b/tests/fsfocus.c @@ -23,7 +23,7 @@ // //======================================================================== // -// This test is used to test window activation and iconfication for +// This test is used to test window focusing and iconfication for // fullscreen windows with a video mode differing from the desktop mode // //======================================================================== @@ -35,11 +35,11 @@ static GLboolean running = GL_TRUE; -static void window_focus_callback(GLFWwindow window, int activated) +static void window_focus_callback(GLFWwindow window, int focused) { printf("%0.3f: Window %s\n", glfwGetTime(), - activated ? "activated" : "deactivated"); + focused ? "focused" : "defocused"); } static void window_key_callback(GLFWwindow window, int key, int action) @@ -96,9 +96,9 @@ int main(void) glfwSetInputMode(window, GLFW_CURSOR_MODE, GLFW_CURSOR_NORMAL); - glfwSetWindowFocusCallback(window_focus_callback); - glfwSetKeyCallback(window_key_callback); - glfwSetWindowCloseCallback(window_close_callback); + glfwSetWindowFocusCallback(window, window_focus_callback); + glfwSetKeyCallback(window, window_key_callback); + glfwSetWindowCloseCallback(window, window_close_callback); while (running) { diff --git a/tests/gamma.c b/tests/gamma.c index c30dd53c..8b995afc 100644 --- a/tests/gamma.c +++ b/tests/gamma.c @@ -133,8 +133,8 @@ int main(int argc, char** argv) } else { - width = 0; - height = 0; + width = 200; + height = 200; } window = glfwCreateWindow(width, height, mode, "Gamma Test", NULL); @@ -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 dea207c9..5e46fe1e 100644 --- a/tests/glfwinfo.c +++ b/tests/glfwinfo.c @@ -61,7 +61,7 @@ static void usage(void) static void error_callback(int error, const char* description) { - fprintf(stderr, "Error: %s in %s\n", glfwErrorString(error), description); + fprintf(stderr, "Error: %s\n", description); } static const char* get_client_api_name(int api) @@ -74,7 +74,7 @@ static const char* get_client_api_name(int api) return "Unknown API"; } -static const char* get_profile_name(GLint mask) +static const char* get_profile_name_gl(GLint mask) { if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT) return "compatibility"; @@ -84,6 +84,16 @@ static const char* get_profile_name(GLint mask) return "unknown"; } +static const char* get_profile_name_glfw(int profile) +{ + if (profile == GLFW_OPENGL_COMPAT_PROFILE) + return "compatibility"; + if (profile == GLFW_OPENGL_CORE_PROFILE) + return "core"; + + return "unknown"; +} + static void list_extensions(int api, int major, int minor) { int i; @@ -96,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); @@ -255,9 +268,12 @@ int main(int argc, char** argv) // We assume here that we stand a better chance of success by leaving all // possible details of pixel format selection to GLFW - window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Version", NULL); + window = glfwCreateWindow(200, 200, GLFW_WINDOWED, "Version", NULL); if (!window) + { + glfwTerminate(); exit(EXIT_FAILURE); + } glfwMakeContextCurrent(window); @@ -302,13 +318,17 @@ int main(int argc, char** argv) if (major > 3 || (major == 3 && minor >= 2)) { + int profile = glfwGetWindowParam(window, GLFW_OPENGL_PROFILE); + glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask); printf("%s profile mask (0x%08x): %s\n", get_client_api_name(api), mask, - get_profile_name(mask)); + get_profile_name_gl(mask)); - printf("%s profile mask parsed by GLFW:\n", get_client_api_name(api)); + printf("%s profile mask parsed by GLFW: %s\n", + get_client_api_name(api), + get_profile_name_glfw(profile)); } } diff --git a/tests/iconify.c b/tests/iconify.c index 77815358..b0b6b6a1 100644 --- a/tests/iconify.c +++ b/tests/iconify.c @@ -70,16 +70,29 @@ static void key_callback(GLFWwindow window, int key, int action) static void window_size_callback(GLFWwindow window, int width, int height) { - printf("%0.2f Size %ix%i\n", glfwGetTime(), width, height); + printf("%0.2f Window resized to %ix%i\n", glfwGetTime(), width, height); glViewport(0, 0, width, height); } +static void window_focus_callback(GLFWwindow window, int focused) +{ + printf("%0.2f Window %s\n", + glfwGetTime(), + focused ? "focused" : "defocused"); +} + +static void window_iconify_callback(GLFWwindow window, int iconified) +{ + printf("%0.2f Window %s\n", + glfwGetTime(), + iconified ? "iconified" : "restored"); +} + int main(int argc, char** argv) { int width, height, ch; int mode = GLFW_WINDOWED; - GLboolean active = -1, iconified = -1; GLFWwindow window; while ((ch = getopt(argc, argv, "fh")) != -1) @@ -115,8 +128,8 @@ int main(int argc, char** argv) } else { - width = 0; - height = 0; + width = 640; + height = 480; } window = glfwCreateWindow(width, height, mode, "Iconify", NULL); @@ -131,26 +144,20 @@ 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); + glfwSetWindowFocusCallback(window, window_focus_callback); + glfwSetWindowIconifyCallback(window, window_iconify_callback); + + printf("Window is %s and %s\n", + glfwGetWindowParam(window, GLFW_ICONIFIED) ? "iconified" : "restored", + glfwGetWindowParam(window, GLFW_FOCUSED) ? "focused" : "defocused"); glEnable(GL_SCISSOR_TEST); while (!closed) { - if (iconified != glfwGetWindowParam(window, GLFW_ICONIFIED) || - active != glfwGetWindowParam(window, GLFW_ACTIVE)) - { - iconified = glfwGetWindowParam(window, GLFW_ICONIFIED); - active = glfwGetWindowParam(window, GLFW_ACTIVE); - - printf("%0.2f %s %s\n", - glfwGetTime(), - iconified ? "Iconified" : "Restored", - active ? "Active" : "Inactive"); - } - glfwGetWindowSize(window, &width, &height); glScissor(0, 0, width, height); diff --git a/tests/joysticks.c b/tests/joysticks.c index 40202ce7..c1abb5f8 100644 --- a/tests/joysticks.c +++ b/tests/joysticks.c @@ -186,7 +186,7 @@ int main(void) exit(EXIT_FAILURE); } - window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Joystick Test", NULL); + window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Joystick Test", NULL); if (!window) { glfwTerminate(); @@ -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 ef1db71c..e1f13faa 100644 --- a/tests/modes.c +++ b/tests/modes.c @@ -117,10 +117,6 @@ static void test_modes(void) int i, count; GLFWvidmode* modes = glfwGetVideoModes(&count); - glfwSetWindowSizeCallback(window_size_callback); - glfwSetWindowCloseCallback(window_close_callback); - glfwSetKeyCallback(key_callback); - for (i = 0; i < count; i++) { GLFWvidmode* mode = modes + i; @@ -143,6 +139,10 @@ static void test_modes(void) continue; } + glfwSetWindowSizeCallback(window_handle, window_size_callback); + glfwSetWindowCloseCallback(window_handle, window_close_callback); + glfwSetKeyCallback(window_handle, key_callback); + glfwMakeContextCurrent(window_handle); glfwSwapInterval(1); @@ -157,6 +157,8 @@ static void test_modes(void) if (!window_handle) { printf("User terminated program\n"); + + glfwTerminate(); exit(EXIT_SUCCESS); } } @@ -224,6 +226,7 @@ int main(int argc, char** argv) else if (mode == TEST_MODE) test_modes(); + glfwTerminate(); exit(EXIT_SUCCESS); } diff --git a/tests/peter.c b/tests/peter.c index 59c917e9..30690e68 100644 --- a/tests/peter.c +++ b/tests/peter.c @@ -92,7 +92,7 @@ static void window_size_callback(GLFWwindow window, int width, int height) static GLboolean open_window(void) { - window_handle = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Peter Detector", NULL); + window_handle = glfwCreateWindow(640, 480, GLFW_WINDOWED, "Peter Detector", NULL); if (!window_handle) return GL_FALSE; @@ -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 5d137188..212c108d 100644 --- a/tests/reopen.c +++ b/tests/reopen.c @@ -102,9 +102,9 @@ static GLboolean open_window(int width, int height, int mode) glfwMakeContextCurrent(window_handle); glfwSwapInterval(1); - glfwSetWindowSizeCallback(window_size_callback); - glfwSetWindowCloseCallback(window_close_callback); - glfwSetKeyCallback(key_callback); + glfwSetWindowSizeCallback(window_handle, window_size_callback); + glfwSetWindowCloseCallback(window_handle, window_close_callback); + glfwSetKeyCallback(window_handle, key_callback); printf("Opening %s mode window took %0.3f seconds\n", get_mode_name(mode), @@ -132,7 +132,10 @@ int main(int argc, char** argv) for (;;) { if (!open_window(640, 480, (count & 1) ? GLFW_FULLSCREEN : GLFW_WINDOWED)) + { + glfwTerminate(); exit(EXIT_FAILURE); + } glMatrixMode(GL_PROJECTION); glOrtho(-1.f, 1.f, -1.f, 1.f, 1.f, -1.f); @@ -156,6 +159,8 @@ int main(int argc, char** argv) { close_window(); printf("User closed window\n"); + + glfwTerminate(); exit(EXIT_SUCCESS); } } diff --git a/tests/sharing.c b/tests/sharing.c index 64e61740..0042a858 100644 --- a/tests/sharing.c +++ b/tests/sharing.c @@ -51,10 +51,12 @@ static int window_close_callback(GLFWwindow window) return GL_FALSE; } -static GLFWwindow open_window(const char* title, GLFWwindow share) +static GLFWwindow open_window(const char* title, GLFWwindow share, int posX, int posY) { GLFWwindow window; + glfwWindowHint(GLFW_POSITION_X, posX); + glfwWindowHint(GLFW_POSITION_Y, posY); window = glfwCreateWindow(WIDTH, HEIGHT, GLFW_WINDOWED, title, share); if (!window) return NULL; @@ -62,8 +64,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; } @@ -125,7 +127,6 @@ static void draw_quad(GLuint texture) int main(int argc, char** argv) { GLuint texture; - int x, y; if (!glfwInit()) { @@ -133,10 +134,12 @@ int main(int argc, char** argv) exit(EXIT_FAILURE); } - windows[0] = open_window("First", NULL); + windows[0] = open_window("First", NULL, 0, 0); if (!windows[0]) { fprintf(stderr, "Failed to open first GLFW window: %s\n", glfwErrorString(glfwGetError())); + + glfwTerminate(); exit(EXIT_FAILURE); } @@ -145,21 +148,23 @@ int main(int argc, char** argv) // It will then be shared with the second context, created below texture = create_texture(); - windows[1] = open_window("Second", windows[0]); + // Put the second window to the right of the first one + windows[1] = open_window("Second", windows[0], WIDTH + 50, 0); if (!windows[1]) { fprintf(stderr, "Failed to open second GLFW window: %s\n", glfwErrorString(glfwGetError())); + + glfwTerminate(); exit(EXIT_FAILURE); } - // Set drawing color for the first context and copy it to the second + // Set drawing color for both contexts glfwMakeContextCurrent(windows[0]); glColor3f(0.6f, 0.f, 0.6f); - glfwCopyContext(windows[0], windows[1], GL_CURRENT_BIT); + glfwMakeContextCurrent(windows[1]); + glColor3f(0.6f, 0.6f, 0.f); - // Put the second window to the right of the first one - glfwGetWindowPos(windows[0], &x, &y); - glfwSetWindowPos(windows[1], x + WIDTH + 50, y); + glfwMakeContextCurrent(windows[0]); while (!closed) { diff --git a/tests/tearing.c b/tests/tearing.c index a8d774a4..63ece2ba 100644 --- a/tests/tearing.c +++ b/tests/tearing.c @@ -70,20 +70,20 @@ int main(void) exit(EXIT_FAILURE); } - window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "", NULL); + window = glfwCreateWindow(640, 480, GLFW_WINDOWED, "", 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/threads.c b/tests/threads.c index 35c83716..8b06b1d3 100644 --- a/tests/threads.c +++ b/tests/threads.c @@ -28,6 +28,8 @@ // //======================================================================== +#include "tinycthread.h" + #include #include @@ -35,8 +37,6 @@ #include #include -#include "tinycthread.h" - typedef struct { GLFWwindow window; @@ -89,6 +89,8 @@ int main(void) for (i = 0; i < count; i++) { + glfwWindowHint(GLFW_POSITION_X, 200 + 250 * i); + glfwWindowHint(GLFW_POSITION_Y, 200); threads[i].window = glfwCreateWindow(200, 200, GLFW_WINDOWED, threads[i].title, @@ -100,8 +102,6 @@ int main(void) exit(EXIT_FAILURE); } - glfwSetWindowPos(threads[i].window, 200 + 250 * i, 200); - if (thrd_create(&threads[i].id, thread_main, threads + i) != thrd_success) { diff --git a/tests/title.c b/tests/title.c index c7539033..62690f9c 100644 --- a/tests/title.c +++ b/tests/title.c @@ -47,17 +47,19 @@ int main(void) exit(EXIT_FAILURE); } - window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "English 日本語 русский язык 官話", NULL); + window = glfwCreateWindow(400, 400, GLFW_WINDOWED, "English 日本語 русский язык 官話", NULL); 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 894febeb..187248c2 100644 --- a/tests/windows.c +++ b/tests/windows.c @@ -55,11 +55,14 @@ int main(void) for (i = 0; i < 4; i++) { + glfwWindowHint(GLFW_POSITION_X, 100 + (i & 1) * 300); + glfwWindowHint(GLFW_POSITION_Y, 100 + (i >> 1) * 300); windows[i] = glfwCreateWindow(200, 200, GLFW_WINDOWED, titles[i], NULL); if (!windows[i]) { fprintf(stderr, "Failed to open GLFW window: %s\n", glfwErrorString(glfwGetError())); + glfwTerminate(); exit(EXIT_FAILURE); } @@ -69,8 +72,6 @@ int main(void) (GLclampf) (i >> 1), i ? 0.f : 1.f, 0.f); - - glfwSetWindowPos(windows[i], 100 + (i & 1) * 300, 100 + (i >> 1) * 300); } while (running)