Added description of 3.0.4 release.

Fixed glfwSetWindowSize stealing focus.
Removed stray whitespace in version string.
2026-09-19 23:43:15 +00:00 · 2013-12-31 20:06:18 +01:00 · 2013-12-28 20:56:57 +01:00 · 2013-12-24 00:48:28 +01:00 · 2013-12-23 00:53:04 +01:00 · 2013-12-18 12:42:05 +01:00
54 changed files with 1715 additions and 945 deletions
@@ -21,7 +21,7 @@ cmake_uninstall.cmake
 docs/Doxyfile
 docs/html
 docs/warnings.txt
-src/config.h
+src/glfw_config.h
 src/glfw3.pc
 src/glfwConfig.cmake
 src/glfwConfigVersion.cmake
@@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 2.8)
 set(GLFW_VERSION_MAJOR "3")
 set(GLFW_VERSION_MINOR "0")
-set(GLFW_VERSION_PATCH "3")
+set(GLFW_VERSION_PATCH "4")
 set(GLFW_VERSION_EXTRA "")
 set(GLFW_VERSION "${GLFW_VERSION_MAJOR}.${GLFW_VERSION_MINOR}")
 set(GLFW_VERSION_FULL "${GLFW_VERSION}.${GLFW_VERSION_PATCH}${GLFW_VERSION_EXTRA}")
@@ -13,6 +13,7 @@ set(LIB_SUFFIX "" CACHE STRING "Takes an empty string or 64. Directory where lib
 option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
 option(GLFW_BUILD_EXAMPLES "Build the GLFW example programs" ON)
 option(GLFW_BUILD_TESTS "Build the GLFW test programs" ON)
 option(GLFW_BUILD_DOCS "Build the GLFW documentation" ON)
 option(GLFW_INSTALL "Generate installation target" ON)
 option(GLFW_DOCUMENT_INTERNALS "Include internals in documentation" OFF)
@@ -73,11 +74,13 @@ endif()
 find_package(Threads REQUIRED)
-set(DOXYGEN_SKIP_DOT TRUE)
+if (GLFW_BUILD_DOCS)
-find_package(Doxygen)
+    set(DOXYGEN_SKIP_DOT TRUE)
    find_package(Doxygen)
-if (GLFW_DOCUMENT_INTERNALS)
+    if (GLFW_DOCUMENT_INTERNALS)
-    set(GLFW_INTERNAL_DOCS "${GLFW_SOURCE_DIR}/src/internal.h ${GLFW_SOURCE_DIR}/docs/internal.dox")
+        set(GLFW_INTERNAL_DOCS "${GLFW_SOURCE_DIR}/src/internal.h ${GLFW_SOURCE_DIR}/docs/internal.dox")
    endif()
 endif()
 #--------------------------------------------------------------------
@@ -282,23 +285,15 @@ if (_GLFW_GLX)
        # Check for dlopen support as a fallback
-        find_library(DL_LIBRARY dl)
+        set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_DL_LIBS})
        mark_as_advanced(DL_LIBRARY)
        if (DL_LIBRARY)
            set(CMAKE_REQUIRED_LIBRARIES ${DL_LIBRARY})
        else()
            set(CMAKE_REQUIRED_LIBRARIES "")
        endif()
        check_function_exists(dlopen _GLFW_HAS_DLOPEN)
        if (NOT _GLFW_HAS_DLOPEN)
            message(FATAL_ERROR "No entry point retrieval mechanism found")
        endif()
-        if (DL_LIBRARY)
+        if (CMAKE_DL_LIBS)
-            list(APPEND glfw_LIBRARIES ${DL_LIBRARY})
+            list(APPEND glfw_LIBRARIES ${CMAKE_DL_LIBS})
-            set(GLFW_PKG_LIBS "${GLFW_PKG_LIBS} -ldl")
+            set(GLFW_PKG_LIBS "${GLFW_PKG_LIBS} -l${CMAKE_DL_LIBS}")
        endif()
    endif()
@@ -356,13 +351,15 @@ if (_GLFW_COCOA AND _GLFW_NSGL)
    find_library(COCOA_FRAMEWORK Cocoa)
    find_library(IOKIT_FRAMEWORK IOKit)
    find_library(CORE_FOUNDATION_FRAMEWORK CoreFoundation)
    find_library(CORE_VIDEO_FRAMEWORK CoreVideo)
    list(APPEND glfw_LIBRARIES ${COCOA_FRAMEWORK}
                               ${OPENGL_gl_LIBRARY}
                               ${IOKIT_FRAMEWORK}
-                               ${CORE_FOUNDATION_FRAMEWORK})
+                               ${CORE_FOUNDATION_FRAMEWORK}
                               ${CORE_VIDEO_FRAMEWORK})
    set(GLFW_PKG_DEPS "")
-    set(GLFW_PKG_LIBS "-framework Cocoa -framework OpenGL -framework IOKit -framework CoreFoundation")
+    set(GLFW_PKG_LIBS "-framework Cocoa -framework OpenGL -framework IOKit -framework CoreFoundation -framework CoreVideo")
 endif()
 #--------------------------------------------------------------------
@@ -386,8 +383,8 @@ endif()
 configure_file(${GLFW_SOURCE_DIR}/docs/Doxyfile.in
               ${GLFW_BINARY_DIR}/docs/Doxyfile @ONLY)
-configure_file(${GLFW_SOURCE_DIR}/src/config.h.in 
+configure_file(${GLFW_SOURCE_DIR}/src/glfw_config.h.in 
-               ${GLFW_BINARY_DIR}/src/config.h @ONLY)
+               ${GLFW_BINARY_DIR}/src/glfw_config.h @ONLY)
 configure_file(${GLFW_SOURCE_DIR}/src/glfwConfig.cmake.in
               ${GLFW_BINARY_DIR}/src/glfwConfig.cmake @ONLY)
@@ -413,7 +410,7 @@ if (GLFW_BUILD_TESTS)
    add_subdirectory(tests)
 endif()
-if (DOXYGEN_FOUND)
+if (DOXYGEN_FOUND AND GLFW_BUILD_DOCS)
    add_subdirectory(docs)
 endif()
@@ -6,9 +6,9 @@ GLFW is a free, Open Source, portable library for OpenGL and OpenGL ES
 application development.  It provides a simple, platform-independent API for
 creating windows and contexts, reading input, handling events, etc.
-Version 3.0.3 adds fixes for a number of bugs that together affect all supported
+Version 3.0.4 adds better support for custom build environments and fixes for
-platforms, most notably MinGW compilation issues and cursor mode issues on OS X.
+a large number of bugs that together affect all supported platforms.  As this is
-As this is a patch release, there are no API changes.
+a patch release, there are no API changes.
 If you are new to GLFW, you may find the
 [introductory tutorial](http://www.glfw.org/docs/latest/quick.html) for GLFW
@@ -19,199 +19,69 @@ the GLFW 3 API.
 ## Compiling GLFW
-### Dependencies
+See the [Compiling GLFW](http://www.glfw.org/docs/latest/compile.html) guide in
-
+the GLFW documentation.
 To compile GLFW and the accompanying example programs, you will need **CMake**,
 which will generate the project files or makefiles for your particular
 development environment.  If you are on a Unix-like system such as Linux or
 FreeBSD or have a package system like Fink, MacPorts, Cygwin or Homebrew, you
 can simply install its CMake package.  If not, you can get installers for
 Windows and OS X from the [CMake website](http://www.cmake.org/).
 Additional dependencies are listed below.
 #### Visual C++ on Windows
 The Microsoft Platform SDK that is installed along with Visual C++ contains all
 the necessary headers, link libraries and tools except for CMake.
 #### MinGW or MinGW-w64 on Windows
 These packages contain all the necessary headers, link libraries and tools
 except for CMake.
 #### MinGW or MinGW-w64 cross-compilation
 Both Cygwin and many Linux distributions have MinGW or MinGW-w64 packages.  For
 example, Cygwin has the `mingw64-i686-gcc` and `mingw64-x86_64-gcc` packages
 for 32- and 64-bit version of MinGW-w64, while Debian GNU/Linux and derivatives
 like Ubuntu have the `mingw-w64` package for both.
 GLFW has CMake toolchain files in the `CMake/` directory that allow for easy
 cross-compilation of Windows binaries.  To use these files you need to add a
 special parameter when generating the project files or makefiles:
    cmake -DCMAKE_TOOLCHAIN_FILE=<toolchain-file> .
 The exact toolchain file to use depends on the prefix used by the MinGW or
 MinGW-w64 binaries on your system.  You can usually see this in the /usr
 directory.  For example, both the Debian/Ubuntu and Cygwin MinGW-w64 packages
 have `/usr/x86_64-w64-mingw32` for the 64-bit compilers, so the correct
 invocation would be:
    cmake -DCMAKE_TOOLCHAIN_FILE=CMake/x86_64-w64-mingw32.cmake .
 For more details see the article
 [CMake Cross Compiling](http://www.paraview.org/Wiki/CMake_Cross_Compiling) on
 the CMake wiki.
 #### Xcode on OS X
 Xcode contains all necessary tools except for CMake.  The necessary headers and
 libraries are included in the core OS frameworks.  Xcode can be downloaded from
 the Mac App Store.
 #### Unix-like systems with X11
 To compile GLFW for X11, you need to have the X11 and OpenGL header packages
 installed, as well as the basic development tools like GCC and make.  For
 example, on Ubuntu and other distributions based on Debian GNU/Linux, you need
 to install the `xorg-dev` and `libglu1-mesa-dev` packages.  The former pulls in
 all X.org header packages and the latter pulls in the Mesa OpenGL and GLU
 packages.  Note that using header files and libraries from Mesa during
 compilation *will not* tie your binaries to the Mesa implementation of OpenGL.
 ### Generating with CMake
 Once you have all necessary dependencies, it is time to generate the project
 files or makefiles for your development environment.  CMake needs to know two
 paths for this: the path to the source directory and the target path for the
 generated files and compiled binaries.  If these are the same, it is called an
 in-tree build, otherwise it is called an out-of-tree build.
 One of several advantages of out-of-tree builds is that you can generate files
 and compile for different development environments using a single source tree.
 #### Using CMake from the command-line
 To make an in-tree build, enter the root directory of the GLFW source tree and
 run CMake.  The current directory is used as target path, while the path
 provided as an argument is used to find the source tree.
    cd <glfw-root-dir>
    cmake .
 To make an out-of-tree build, make another directory, enter it and run CMake
 with the (relative or absolute) path to the root of the source tree as an
 argument.
    cd <glfw-root-dir>
    mkdir build
    cd build
    cmake ..
 #### Using the CMake GUI
 If you are using the GUI version, choose the root of the GLFW source tree as
 source location and the same directory or another, empty directory as the
 destination for binaries.  Choose *Configure*, change any options you wish to,
 *Configure* again to let the changes take effect and then *Generate*.
 ### CMake options
 The CMake files for GLFW provide a number of options, although not all are
 available on all supported platforms.  Some of these are de facto standards
 among CMake users and so have no `GLFW_` prefix.
 If you are using the GUI version of CMake, these are listed and can be changed
 from there.  If you are using the command-line version, use the `ccmake` tool.
 Some package systems like Ubuntu and other distributions based on Debian
 GNU/Linux have this tool in a separate `cmake-curses-gui` package.
 #### Shared options
 `BUILD_SHARED_LIBS` determines whether GLFW is built as a static
 library or as a DLL / shared library / dynamic library.
 `LIB_SUFFIX` affects where the GLFW shared /dynamic library is
 installed.  If it is empty, it is installed to `$PREFIX/lib`.  If it is set to
 `64`, it is installed to `$PREFIX/lib64`.
 `GLFW_BUILD_EXAMPLES` determines whether the GLFW examples are built
 along with the library.
 `GLFW_BUILD_TESTS` determines whether the GLFW test programs are
 built along with the library.
 #### OS X specific options
 `GLFW_USE_CHDIR` determines whether `glfwInit` changes the current
 directory of bundled applications to the `Contents/Resources` directory.
 `GLFW_USE_MENUBAR` determines whether the first call to
 `glfwCreateWindow` sets up a minimal menu bar.
 `GLFW_BUILD_UNIVERSAL` determines whether to build Universal Binaries.
 #### Windows specific options
 `USE_MSVC_RUNTIME_LIBRARY_DLL` determines whether to use the DLL version or the
 static library version of the Visual C++ runtime library.
 `GLFW_USE_DWM_SWAP_INTERVAL` determines whether the swap interval is set even
 when DWM compositing is enabled.  This can lead to severe jitter and is not
 usually recommended.
 `GLFW_USE_OPTIMUS_HPG` determines whether to export the `NvOptimusEnablement`
 symbol, which forces the use of the high-performance GPU on nVidia Optimus
 systems.
 #### EGL specific options
 `GLFW_USE_EGL` determines whether to use EGL instead of the platform-specific
 context creation API.  Note that EGL is not yet provided on all supported
 platforms.
 `GLFW_CLIENT_LIBRARY` determines which client API library to use.  If set to
 `opengl` the OpenGL library is used, if set to `glesv1` for the OpenGL ES 1.x
 library is used, or if set to `glesv2` the OpenGL ES 2.0 library is used.  The
 selected library and its header files must be present on the system for this to
 work.
 ## Installing GLFW
 A rudimentary installation target is provided for all supported platforms via
 CMake.
 ## Using GLFW
-See the [GLFW documentation](http://www.glfw.org/docs/latest/).
+See the
 [Building programs that use GLFW](http://www.glfw.org/docs/latest/build.html)
 guide in the GLFW documentation.
 ## Changelog
- - [Win32] Bugfix: `_WIN32_WINNT` was not set to Windows XP or later
+ - Added the `GLFW_BUILD_DOCS` CMake option for controlling whether the
- - [Win32] Bugfix: Legacy MinGW needs `WINVER` and `UNICODE` before `stddef.h`
+   documentation is built
- - [Cocoa] Bugfix: Cursor was not visible in normal mode in full screen
+ - Added the `_GLFW_USE_CONFIG_H` configuration macro for controlling whether to
- - [Cocoa] Bugfix: Cursor was not actually hidden in hidden mode
+   include the configuration header
- - [Cocoa] Bugfix: Cursor modes were not applied to inactive windows
+ - Moved version number macro to `internal.h` for easier manual compilation
- - [X11] Bugfix: Events for mouse buttons 4 and above were not reported
+ - Renamed configuration header to `glfw_config.h` to avoid conflicts
- - [X11] Bugfix: CMake 2.8.7 does not set `X11_Xinput_LIB` even when found
+ - Bugfix: The `glfw3.pc` file did not respect the `LIB_SUFFIX` CMake option
 - Bugfix: The `joysticks` test would segfault if a controller had no axes
 - [Win32] Allowed swap interval to be explicitly set to zero on DWM systems
 - [Win32] Bugfix: Removed joystick axis value negation left over from GLFW 2
 - [Win32] Bugfix: Restoring windows using the Win+D hot key did not trigger the
                   focus callback
 - [Win32] Bugfix: The disabled cursor mode clip rectangle was updated for
                   unfocused windows
 - [Win32] Bugfix: Cursor was not properly re-centered over odd-sized windows
 - [Win32] Bugfix: Negative window positions were reported incorrectly
 - [Win32] Bugfix: The iconify callback was not triggered when switching away
                   from a full screen window using Alt+Tab
 - [Win32] Bugfix: Resizing a window with `glfwSetWindowSize` gave it focus
 - [Cocoa] Added dependency on CoreVideo framework for refresh rate retrieval
 - [Cocoa] Enabled Lion full screen for resizable windowed mode windows
 - [Cocoa] Moved to Cocoa API for application transformation and activation
 - [Cocoa] Bugfix: The `GLFW_KEY_GRAVE_ACCENT` key was reported as
                   `GLFW_KEY_WORLD_1` and vice versa
 - [Cocoa] Bugfix: The `GLFW_KEY_F13` key was reported as
                   `GLFW_KEY_PRINT_SCREEN`
 - [Cocoa] Bugfix: Implicit conversion from `NSUInteger` to int caused warnings
                   with Xcode 5
 - [Cocoa] Bugfix: Use of undeclared selectors with `@selector` caused warnings
                   with Xcode 5
 - [Cocoa] Bugfix: The cursor remained visible if moved onto client area after
                   having been set to hidden outside it
 - [Cocoa] Bugfix: The refresh rate was zero for all modes of certain monitors
 - [Cocoa] Bugfix: The `install_name` field of the dynamic library was not set
 - [Cocoa] Bugfix: Full screen windows were never reported as having focus
 - [Cocoa] Bugfix: A superfluous I/O flag test prevented video modes from being
                   listed for Thunderbolt monitor
 - [Cocoa] Bugfix: Retrieving the name of some external displays caused segfault
 - [Cocoa] Bugfix: The 10.9 SDK defines `GLintptrARB` and `GLsizeiptrARB`
                   differently from the Khronos `glext.h`
 - [Cocoa] Bugfix: Creating hidden windows would steal application focus
 - [Cocoa] Bugfix: Controllers were reported as having zero buttons and axes
 - [Cocoa] Bugfix: Removed joystick axis value negation left over from GLFW 2
 - [X11] Added setting of the `WM_CLASS` property to the initial window title
 - [X11] Added support for `_NET_WM_BYPASS_COMPOSITOR`
 - [X11] Bugfix: Removed joystick axis value negation left over from GLFW 2
 - [X11] Bugfix: The position of hidden windows was ignored by Metacity
                 and Compiz
 - [X11] Bugfix: The `pthread.h` header was not included by the GLX platform
                 header.
 ## Contact
@@ -250,12 +120,14 @@ skills.
 - Doug Binks
 - blanco
 - Lambert Clara
 - Andrew Corrigan
 - Noel Cower
 - Jarrod Davis
 - Olivier Delannoy
 - Paul R. Deppe
 - Jonathan Dummer
 - Ralph Eastwood
 - Michael Fogleman
 - Gerald Franz
 - GeO4d
 - Marcus Geelnard
@@ -280,14 +152,18 @@ skills.
 - Marcel Metz
 - Kenneth Miller
 - Bruce Mitchener
 - Jack Moffitt
 - Jeff Molofee
 - Jon Morton
 - Pierre Moulon
 - Julian Møller
 - Kamil Nowakowski
 - Ozzy
 - Andri Pálsson
 - Peoro
 - Braden Pellett
 - Arturo J. Pérez
 - Pieroman
 - Jorge Rodriguez
 - Ed Ropple
 - Riku Salminen
@@ -295,6 +171,7 @@ skills.
 - Matt Sealey
 - SephiRok
 - Steve Sexton
 - Systemcluster
 - Dmitri Shuralyov
 - Daniel Skorupski
 - Bradley Smith
@@ -305,6 +182,7 @@ skills.
 - TTK-Bandit
 - Sergey Tikhomirov
 - Samuli Tuomola
 - urraka
 - Jari Vetoniemi
 - Simon Voordouw
 - Torsten Walluhn
@@ -33,10 +33,10 @@ extern "C" {
 ** used to make the header, and the header can be found at
 **   http://www.opengl.org/registry/
 **
-** Khronos $Revision$ on $Date$
+** Khronos $Revision: 23649 $ on $Date: 2013-10-23 00:21:49 -0700 (Wed, 23 Oct 2013) $
 */
-#define GLX_GLXEXT_VERSION 20130710
+#define GLX_GLXEXT_VERSION 20131008
 /* Generated C header for:
 * API: glx
@@ -33,7 +33,7 @@ extern "C" {
 ** used to make the header, and the header can be found at
 **   http://www.opengl.org/registry/
 **
-** Khronos $Revision$ on $Date$
+** Khronos $Revision: 23649 $ on $Date: 2013-10-23 00:21:49 -0700 (Wed, 23 Oct 2013) $
 */
 #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
@@ -41,7 +41,7 @@ extern "C" {
 #include <windows.h>
 #endif
-#define WGL_WGLEXT_VERSION 20130710
+#define WGL_WGLEXT_VERSION 20130916
 /* Generated C header for:
 * API: wgl
@@ -645,6 +645,14 @@ BOOL WINAPI wglCopyImageSubDataNV (HGLRC hSrcRC, GLuint srcName, GLenum srcTarge
 #endif
 #endif /* WGL_NV_copy_image */
 #ifndef WGL_NV_delay_before_swap
 #define WGL_NV_delay_before_swap 1
 typedef BOOL (WINAPI * PFNWGLDELAYBEFORESWAPNVPROC) (HDC hDC, GLfloat seconds);
 #ifdef WGL_WGLEXT_PROTOTYPES
 BOOL WINAPI wglDelayBeforeSwapNV (HDC hDC, GLfloat seconds);
 #endif
 #endif /* WGL_NV_delay_before_swap */
 #ifndef WGL_NV_float_buffer
 #define WGL_NV_float_buffer 1
 #define WGL_FLOAT_COMPONENTS_NV           0x20B0
@@ -1,5 +1,5 @@
-
+
-add_custom_target(docs ALL ${DOXYGEN_EXECUTABLE}
+add_custom_target(docs ALL ${DOXYGEN_EXECUTABLE}
-                  WORKING_DIRECTORY ${GLFW_BINARY_DIR}/docs
+                  WORKING_DIRECTORY ${GLFW_BINARY_DIR}/docs
-                  COMMENT "Generating HTML documentation" VERBATIM)
+                  COMMENT "Generating HTML documentation" VERBATIM)
-
+
@@ -659,6 +659,7 @@ INPUT                  = @GLFW_INTERNAL_DOCS@                         \
                         @GLFW_SOURCE_DIR@/docs/news.dox              \
                         @GLFW_SOURCE_DIR@/docs/quick.dox             \
                         @GLFW_SOURCE_DIR@/docs/moving.dox            \
                         @GLFW_SOURCE_DIR@/docs/compile.dox           \
                         @GLFW_SOURCE_DIR@/docs/build.dox             \
                         @GLFW_SOURCE_DIR@/docs/context.dox           \
                         @GLFW_SOURCE_DIR@/docs/monitor.dox           \
@@ -899,13 +900,13 @@ HTML_FILE_EXTENSION    = .html
 # have to redo this when upgrading to a newer version of doxygen or when
 # changing the value of configuration settings such as GENERATE_TREEVIEW!
-HTML_HEADER            =
+HTML_HEADER            = @GLFW_SOURCE_DIR@/docs/header.html
 # The HTML_FOOTER tag can be used to specify a personal HTML footer for
 # each generated HTML page. If it is left blank doxygen will generate a
 # standard footer.
-HTML_FOOTER            =
+HTML_FOOTER            = @GLFW_SOURCE_DIR@/docs/footer.html
 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading
 # style sheet that is used by each HTML page. It can be used to
@@ -924,7 +925,7 @@ HTML_STYLESHEET        =
 # robust against future updates. Doxygen will copy the style sheet file to
 # the output directory.
-HTML_EXTRA_STYLESHEET  = 
+HTML_EXTRA_STYLESHEET  = @GLFW_SOURCE_DIR@/docs/extra.css
 # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the HTML output directory. Note
@@ -1,11 +1,13 @@
 /*!
-@page build Building programs using GLFW
+@page build Building programs that use GLFW
@tableofcontents
 This is about compiling and linking programs that use GLFW.  For information on
-how to *write* such programs, start with the [introductory tutorial](@ref quick).
+how to write such programs, start with the [introductory tutorial](@ref quick).
 For information on how to compile the GLFW library itself, see the @ref compile
 guide.
@section build_include Including the GLFW header file
@@ -48,7 +50,9 @@ header that the GLFW header includes and GLEW will work as expected.
@subsection build_macros GLFW header option macros
 These macros may be defined before the inclusion of the GLFW header and affect
-how that header behaves.
+the behavior of the header.  Note that GLFW does not provide any of the OpenGL
 or OpenGL ES headers mentioned below.  These are provided by your development
 environment or your OpenGL or OpenGL ES SDK.
 `GLFW_INCLUDE_GLCOREARB` makes the header include the modern `GL/glcorearb.h`
 header (`OpenGL/gl3.h` on OS X) instead of the regular OpenGL header.
@@ -81,8 +85,10 @@ The static version of the GLFW library is named `glfw3`.  When using this
 version, it is also necessary to link with some libraries that GLFW uses.
 When linking a program under Windows that uses the static version of GLFW, you
-must link with `opengl32`.  If you are using GLU, you must also link with
+must link with `opengl32`.  On some versions of MinGW, you must also explicitly
-`glu32`.
+link with `gdi32`, while other versions of MinGW include it in the set of
 default libraries along with other dependencies like `user32` and `kernel32`.
 If you are using GLU, you must also link with `glu32`.
 The link library for the GLFW DLL is named `glfw3dll`.  When compiling a program
 that uses the DLL version of GLFW, you need to define the `GLFW_DLL` macro
@@ -158,7 +164,7 @@ If you are using the static library version of GLFW, use the
@subsection build_link_pkgconfig With pkg-config on OS X or other Unix
 GLFW supports [pkg-config](http://www.freedesktop.org/wiki/Software/pkg-config/),
-and `glfw3.pc` file is generated when the GLFW library is built and installed
+and the `glfw3.pc` file is generated when the GLFW library is built and installed
 along with it.  
 A typical compile and link command-line when using the static may look like this:
@@ -189,7 +195,7 @@ If you are using the dynamic library version of GLFW, simply add it to the
 project dependencies.
 If you are using the static library version of GLFW, add it and the Cocoa,
-OpenGL and IOKit frameworks to the project as dependencies.
+OpenGL, IOKit and CoreVideo frameworks to the project as dependencies.
@subsection build_link_osx With command-line on OS X
@@ -198,7 +204,7 @@ If you do not wish to use pkg-config, you need to add the required frameworks
 and libraries to your command-line using the `-l` and `-framework` switches,
 i.e.:
-    cc -o myprog myprog.c -lglfw -framework Cocoa -framework OpenGL -framework IOKit
+    cc -o myprog myprog.c -lglfw -framework Cocoa -framework OpenGL -framework IOKit -framework CoreVideo
 Note that you do not add the `.framework` extension to a framework when adding
 it from the command-line.
@@ -123,15 +123,15 @@ version 2.1.
 Because of this, on OS X 10.7 and later, the `GLFW_CONTEXT_VERSION_MAJOR` and
 `GLFW_CONTEXT_VERSION_MINOR` hints will cause @ref glfwCreateWindow to fail if
-given version 3.0 or 3.1, the `GLFW_OPENGL_FORWARD_COMPAT` is required for
+given version 3.0 or 3.1, the `GLFW_OPENGL_FORWARD_COMPAT` hint must be set to
-creating contexts for OpenGL 3.2 and later, the `GLFW_OPENGL_DEBUG_CONTEXT` hint
+non-zero and the `GLFW_OPENGL_PROFILE` hint must be set to
-is ignored and setting the `GLFW_OPENGL_PROFILE` hint to anything except
+`GLFW_OPENGL_CORE_PROFILE` when creating OpenGL 3.2 and later contexts and the
-`GLFW_OPENGL_CORE_PROFILE` will cause @ref glfwCreateWindow to fail.
+`GLFW_OPENGL_DEBUG_CONTEXT` hint is ignored.
 Also, on Mac OS X 10.6 and below, the `GLFW_CONTEXT_VERSION_MAJOR` and
-`GLFW_CONTEXT_VERSION_MINOR` hints will fail if given a version above 2.1, the
+`GLFW_CONTEXT_VERSION_MINOR` hints will fail if given a version above 2.1,
-`GLFW_OPENGL_DEBUG_CONTEXT` hint will have no effect, and setting the
+setting the `GLFW_OPENGL_PROFILE` or `GLFW_OPENGL_FORWARD_COMPAT` hints to
-`GLFW_OPENGL_PROFILE` or `GLFW_OPENGL_FORWARD_COMPAT` hints to a non-zero value
+a non-default value will cause @ref glfwCreateWindow to fail and the
-will cause @ref glfwCreateWindow to fail.
+`GLFW_OPENGL_DEBUG_CONTEXT` hint is ignored.
 */
@@ -0,0 +1,261 @@
 /*!
@page compile Compiling GLFW
@tableofcontents
 This is about compiling the GLFW library itself.  For information on how to
 build programs that use GLFW, see the @ref build guide.
@section compile_deps Dependencies
 To compile GLFW and the accompanying example programs, you will need **CMake**,
 which will generate the project files or makefiles for your particular
 development environment.  If you are on a Unix-like system such as Linux or
 FreeBSD or have a package system like Fink, MacPorts, Cygwin or Homebrew, you
 can simply install its CMake package.  If not, you can get installers for
 Windows and OS X from the [CMake website](http://www.cmake.org/).
 Additional dependencies are listed below.
 If you wish to compile GLFW without CMake, see @ref compile_manual.
@subsection compile_deps_msvc Dependencies using Visual C++ on Windows
 The Microsoft Platform SDK that is installed along with Visual C++ contains all
 the necessary headers, link libraries and tools except for CMake.
@subsection compile_deps_mingw Dependencies with MinGW or MinGW-w64 on Windows
 Both the MinGW and the MinGW-w64 packages contain all the necessary headers,
 link libraries and tools except for CMake.
@subsection compile_deps_mingw_cross Dependencies using MinGW or MinGW-w64 cross-compilation
 Both Cygwin and many Linux distributions have MinGW or MinGW-w64 packages.  For
 example, Cygwin has the `mingw64-i686-gcc` and `mingw64-x86_64-gcc` packages
 for 32- and 64-bit version of MinGW-w64, while Debian GNU/Linux and derivatives
 like Ubuntu have the `mingw-w64` package for both.
 GLFW has CMake toolchain files in the `CMake/` directory that allow for easy
 cross-compilation of Windows binaries.  To use these files you need to add a
 special parameter when generating the project files or makefiles:
    cmake -DCMAKE_TOOLCHAIN_FILE=<toolchain-file> .
 The exact toolchain file to use depends on the prefix used by the MinGW or
 MinGW-w64 binaries on your system.  You can usually see this in the /usr
 directory.  For example, both the Debian/Ubuntu and Cygwin MinGW-w64 packages
 have `/usr/x86_64-w64-mingw32` for the 64-bit compilers, so the correct
 invocation would be:
    cmake -DCMAKE_TOOLCHAIN_FILE=CMake/x86_64-w64-mingw32.cmake .
 For more details see the article
 [CMake Cross Compiling](http://www.paraview.org/Wiki/CMake_Cross_Compiling) on
 the CMake wiki.
@subsection compile_deps_xcode Dependencies using Xcode on OS X
 Xcode contains all necessary tools except for CMake.  The necessary headers and
 libraries are included in the core OS frameworks.  Xcode can be downloaded from
 the Mac App Store or from the ADC Member Center.
@subsection compile_deps_x11 Dependencies using Linux and X11
 To compile GLFW for X11, you need to have the X11 and OpenGL header packages
 installed, as well as the basic development tools like GCC and make.  For
 example, on Ubuntu and other distributions based on Debian GNU/Linux, you need
 to install the `xorg-dev` and `libglu1-mesa-dev` packages.  The former pulls in
 all X.org header packages and the latter pulls in the Mesa OpenGL and GLU
 packages.  GLFW itself doesn't need or use GLU, but some of the examples do.
 Note that using header files and libraries from Mesa during compilation *will
 not* tie your binaries to the Mesa implementation of OpenGL.
@section compile_cmake Generating files with CMake
 Once you have all necessary dependencies it is time to generate the project
 files or makefiles for your development environment.  CMake needs to know two
 paths for this: the path to the *root* directory of the GLFW source tree (i.e.
 *not* the `src` subdirectory) and the target path for the generated files and
 compiled binaries.  If these are the same, it is called an in-tree build,
 otherwise it is called an out-of-tree build.
 One of several advantages of out-of-tree builds is that you can generate files
 and compile for different development environments using a single source tree.
@subsection compile_cmake_cli Generating files with the CMake command-line tool
 To make an in-tree build, enter the *root* directory of the GLFW source tree
 (i.e. *not* the `src` subdirectory) and run CMake.  The current directory is
 used as target path, while the path provided as an argument is used to find the
 source tree.
    cd <glfw-root-dir>
    cmake .
 To make an out-of-tree build, make another directory, enter it and run CMake
 with the (relative or absolute) path to the root of the source tree as an
 argument.
    cd <glfw-root-dir>
    mkdir build
    cd build
    cmake ..
@subsection compile_cmake_gui Generating files with the CMake GUI
 If you are using the GUI version, choose the root of the GLFW source tree as
 source location and the same directory or another, empty directory as the
 destination for binaries.  Choose *Configure*, change any options you wish to,
 *Configure* again to let the changes take effect and then *Generate*.
@section compile_options CMake options
 The CMake files for GLFW provide a number of options, although not all are
 available on all supported platforms.  Some of these are de facto standards
 among CMake users and so have no `GLFW_` prefix.
 If you are using the GUI version of CMake, these are listed and can be changed
 from there.  If you are using the command-line version, use the `ccmake` tool.
 Some package systems like Ubuntu and other distributions based on Debian
 GNU/Linux have this tool in a separate `cmake-curses-gui` package.
@subsection compile_options_shared Shared CMake options
 `BUILD_SHARED_LIBS` determines whether GLFW is built as a static
 library or as a DLL / shared library / dynamic library.
 `LIB_SUFFIX` affects where the GLFW shared /dynamic library is installed.  If it
 is empty, it is installed to `${CMAKE_INSTALL_PREFIX}/lib`.  If it is set to
 `64`, it is installed to `${CMAKE_INSTALL_PREFIX}/lib64`.
 `GLFW_CLIENT_LIBRARY` determines which client API library to use.  If set to
 `opengl` the OpenGL library is used, if set to `glesv1` for the OpenGL ES 1.x
 library is used, or if set to `glesv2` the OpenGL ES 2.0 library is used.  The
 selected library and its header files must be present on the system for this to
 work.
 `GLFW_BUILD_EXAMPLES` determines whether the GLFW examples are built
 along with the library.
 `GLFW_BUILD_TESTS` determines whether the GLFW test programs are
 built along with the library.
 `GLFW_BUILD_DOCS` determines whether the GLFW documentation is built along with
 the library.
@subsection compile_options_osx OS X specific CMake options
 `GLFW_USE_CHDIR` determines whether `glfwInit` changes the current
 directory of bundled applications to the `Contents/Resources` directory.
 `GLFW_USE_MENUBAR` determines whether the first call to
 `glfwCreateWindow` sets up a minimal menu bar.
 `GLFW_BUILD_UNIVERSAL` determines whether to build Universal Binaries.
@subsection compile_options_win32 Windows specific CMake options
 `USE_MSVC_RUNTIME_LIBRARY_DLL` determines whether to use the DLL version or the
 static library version of the Visual C++ runtime library.  If set to `ON`, the
 DLL version of the Visual C++ library is used.  It is recommended to set this to
 `ON`, as this keeps the executable smaller and benefits from security and bug
 fix updates of the Visual C++ runtime.
 `GLFW_USE_DWM_SWAP_INTERVAL` determines whether the swap interval is set even
 when DWM compositing is enabled.  If this is `ON`, the swap interval is set even
 if DWM is enabled.  It is recommended to set this to `OFF`, as doing otherwise
 can lead to severe jitter.
 `GLFW_USE_OPTIMUS_HPG` determines whether to export the `NvOptimusEnablement`
 symbol, which forces the use of the high-performance GPU on nVidia Optimus
 systems.
@subsection compile_options_egl EGL specific CMake options
 `GLFW_USE_EGL` determines whether to use EGL instead of the platform-specific
 context creation API.  Note that EGL is not yet provided on all supported
 platforms.
@section compile_manual Compiling GLFW manually
 If you wish to compile GLFW without its CMake build environment then you will
 have to do at least some of the platform detection yourself.  GLFW needs
 a number of configuration macros to be defined in order to know what it's being
 compiled for and has many optional, platform-specific ones for various features.
 When building with CMake, the `glfw_config.h` configuration header is generated
 based on the current platform and CMake options.  The GLFW CMake environment
 defines `_GLFW_USE_CONFIG_H`, which causes this header to be included by
 `internal.h`.  Without this macro, GLFW will expect the necessary configuration
 macros to be defined on the command-line.
 Three macros *must* be defined when compiling GLFW: one for selecting the window
 creation API, one selecting the context creation API and one client library.
 Exactly one of each kind must be defined for GLFW to compile and link.
 The window creation API is used to create windows, handle input, monitors, gamma
 ramps and clipboard.  The options are:
 - `_GLFW_COCOA` to use the Cocoa frameworks
 - `_GLFW_WIN32` to use the Win32 API
 - `_GLFW_X11` to use the X Window System
 The context creation API is used to enumerate pixel formats / framebuffer
 configurations and to create contexts.  The options are:
 - `_GLFW_NSGL` to use the Cocoa OpenGL framework
 - `_GLFW_WGL` to use the Win32 WGL API
 - `_GLFW_GLX` to use the X11 GLX API
 - `_GLFW_EGL` to use the EGL API (experimental)
 The client library is the one providing the OpenGL or OpenGL ES API, which is
 used by GLFW to probe the created context.  This is not the same thing as the
 client API, as many desktop OpenGL client libraries now expose the OpenGL ES API
 through extensions.  The options are:
 - `_GLFW_USE_OPENGL` for the desktop OpenGL (opengl32.dll, libGL.so or
   OpenGL.framework)
 - `_GLFW_USE_GLESV1` for OpenGL ES 1.x (experimental)
 - `_GLFW_USE_GLESV2` for OpenGL ES 2.x (experimental)
 Note that `_GLFW_USE_GLESV1` and `_GLFW_USE_GLESV2` may only be used with EGL,
 as the other context creation APIs do not interface with OpenGL ES client
 libraries.
 If you are building GLFW as a shared library / dynamic library / DLL then you
 must also define `_GLFW_BUILD_DLL`.  Otherwise, you may not define it.
 If you are using the X11 window creation API then you *must* also select an entry
 point retrieval mechanism.
 - `_GLFW_HAS_GLXGETPROCADDRESS` to use `glXGetProcAddress` (recommended)
 - `_GLFW_HAS_GLXGETPROCADDRESSARB` to use `glXGetProcAddressARB` (legacy)
 - `_GLFW_HAS_GLXGETPROCADDRESSEXT` to use `glXGetProcAddressEXT` (legacy)
 - `_GLFW_HAS_DLOPEN` to do manual retrieval with `dlopen` (fallback)
 If you are using the Cocoa window creation API, the following options are
 available:
 - `_GLFW_USE_CHDIR` to `chdir` to the `Resources` subdirectory of the
   application bundle during @ref glfwInit (recommended)
 - `_GLFW_USE_MENUBAR` to create and populate the menu bar when the first window
   is created (recommended)
 */
@@ -24,6 +24,15 @@ what kind of context is created.  See
 [context related hints](@ref window_hints_ctx) in the window handling guide.
@section context_sharing Context object sharing
 When creating a window and context with @ref glfwCreateWindow, you can specify
 another window whose context the new one should share its objects with.  OpenGL
 object sharing is implemented by the operating system and graphics driver and is
 described in the OpenGL documentation.  On platforms where it is possible to
 choose which types of objects are shared, GLFW requests that all are shared.
@section context_current Current context
 Before you can use the OpenGL or OpenGL ES APIs, you need to have a current
@@ -0,0 +1,312 @@
 html {
 	background-color:hsl(0,0%,95%);
 }
 .glfwheader {
 	font-size:16px;
 	height:64px;
 	max-width:920px;
 	margin:0em auto;
 }
 .glfwheader a#glfwhome {
 	line-height:64px;
 	padding-right:48px;
 	float:left;
 	color:hsl(0,0%,40%);
 	font-size:2.5em;
 	background-image:url("http://www.glfw.org/css/arrow.png");
 	background-position:right top;
 	background-repeat:no-repeat;
 }
 .glfwnavbar {
 	list-style-type:none;
 	margin-top:0px;
 	float:right;
 }
 .glfwnavbar li {
 	float:left;
 }
 .glfwnavbar a,.glfwnavbar a:visited {
 	line-height:64px;
 	margin-left:2em;
 	display:block;
 	color:hsl(0,0%,40%);
 }
 .glfwheader a#glfwhome,.glfwnavbar a,.glfwnavbar a:visited {
 	transition:all 0.35s ease 0s;
 }
 #titlearea,address.footer {
 	color:hsl(0,0%,40%);
 	background-color:hsl(0,0%,95%);
 	border-bottom:none;
 }
 address.footer {
 	text-align:center;
 	padding:2em;
 }
 div#top {
 	background-color:hsl(0,0%,40%);
 }
 div#navrow1,div#navrow2,div#navrow3,div#navrow4 {
 	background-color:hsl(0,0%,40%);
 	background-image:none;
 	max-width:920px;
 	margin:0em auto;
 }
 ul.tablist {
 	min-width:700px;
 }
 .tablist a,.tablist a:hover,.tablist li,.tablist li.current a {
 	background-image:none;
 	text-shadow:none;
 }
 .tablist a,.tablist a:visited {
 	color:hsl(0,0%,95%);
 	text-shadow:none;
 }
 .tablist li.current a {
 	background:linear-gradient(to bottom,hsl(34,100%,60%) 0%,hsl(24,100%,50%) 100%);
 	box-shadow:inset 0px 0px 32px hsl(24,100%,50%);
 	text-shadow:0px -1px 1px hsl(24,100%,35%);
 	color:hsl(0,0%,100%);
 }
 div.contents {
 	min-height:590px;
 }
 div.contents,div.header {
 	max-width:920px;
 	margin:0em auto;
 	padding:0em 2em 2em 2em;
 	background-color:hsl(0,0%,100%);
 }
 div.header {
 	background-image:none;
 	border-bottom:none;
 }
 table.doxtable th,dl.reflist dt,div.levels {
 	background:linear-gradient(to bottom,hsl(34,100%,60%) 0%,hsl(24,100%,50%) 100%);
 	box-shadow:inset 0px 0px 32px hsl(24,100%,50%);
 	text-shadow:0px -1px 1px hsl(24,100%,35%);
 	color:hsl(0,0%,100%);
 }
 dl.reflist dt a.el,div.levels span {
 	color:hsl(24,100%,50%);
 	padding:0.2em;
 	border-radius:4px;
 	background-color:hsl(24,100%,90%);
 	text-shadow:none;
 }
 div.memproto,div.qindex,div.ah {
 	background:linear-gradient(to bottom,hsl(34,0%,95%) 0%,hsl(24,0%,90%) 100%);
 	box-shadow:inset 0px 0px 32px hsl(24,0%,90%);
 	text-shadow:0px 1px 1px hsl(24,0%,100%);
 	color:hsl(0,0%,10%);
 }
 div.memproto a {
 	color:hsl(24,100%,50%);
 }
 div.memproto td.paramname {
 	text-shadow:0px 1px 1px hsl(24,0%,100%);
 }
 div.memproto,div.qindex,div.ah {
 	border:2px solid hsl(24,0%,90%);
 	border-radius:4px;
 }
 div.memdoc {
 	background:none;
 	box-shadow:none;
 	border:none;
 }
 td.paramname {
 	color:hsl(24,100%,25%);
 }
 dl.reflist dt {
 	border:2px solid hsl(24,100%,50%);
 	border-top-left-radius:4px;
 	border-top-right-radius:4px;
 	border-bottom:none;
 }
 dl.reflist dd {
 	border:2px solid hsl(24,100%,50%);
 	border-bottom-right-radius:4px;
 	border-bottom-left-radius:4px;
 		border-top:none;
 	background:none;
 	box-shadow:none;
 }
 table.doxtable {
 	border-collapse:inherit;
 	border-spacing:0px;
 	border:2px solid hsl(24,100%,50%);
 	border-radius:4px;
 }
 table.doxtable td,table.doxtable th {
 	border:none;
 }
 tr.even,.directory tr.even,table.doxtable tr:nth-child(even) {
 	background-color:hsl(0,0%,95%);
 }
 body {
 	color:hsl(0,0%,30%);
 }
 h1,h2,h2.groupheader,h3,div.toc h3,h4,h5,h6,strong,em {
 	color:hsl(0,0%,10%);
 	border-bottom:none;
 }
 a,a:hover,a:visited,a:visited:hover,a.el,a.el:visited,.glfwheader a#glfwhome:hover,.tablist a:hover {
 	color:hsl(24,100%,50%);
 	text-decoration:none;
 }
 .mdescLeft,.mdescRight,.memItemLeft,.memItemRight {
 	background-color:hsl(0,0%,95%);
 }
 div.directory {
 	border-collapse:inherit;
 	border-spacing:0px;
 	border:2px solid hsl(24,100%,50%);
 	border-radius:4px;
 }
 .directory .levels span {
 	color:hsl(24,100%,50%);
 	padding:0.1em 0.5em;
 	margin:auto 0.25em;
 	border-radius:2px;
 	background-color:hsl(24,100%,90%);
 	text-shadow:none;
 }
 td.memSeparator {
 	height:2px;
 	border:0px;
 	background:linear-gradient(to right,hsl(0,0%,95%) 0%,hsl(0,0%,85%) 50%,hsl(0,0%,95%) 100%);
 }
 dl.note,dl.pre,dl.post,dl.invariant {
 	background:linear-gradient(to bottom,hsl(103,80%,90%) 0%,hsl(103,80%,85%) 100%);
 	box-shadow:inset 0px 0px 32px hsl(103,40%,80%);
 	color:hsl(103,80%,10%);
 	border:2px solid hsl(103,40%,75%);
 }
 dl.warning,dl.attention {
 	background:linear-gradient(to bottom,hsl(34,80%,90%) 0%,hsl(34,80%,85%) 100%);
 	box-shadow:inset 0px 0px 32px hsl(34,40%,80%);
 	color:hsl(34,80%,10%);
 	border:2px solid hsl(34,40%,75%);
 }
 dl.deprecated,dl.bug {
 	background:linear-gradient(to bottom,hsl(333,80%,90%) 0%,hsl(333,80%,85%) 100%);
 	box-shadow:inset 0px 0px 32px hsl(333,40%,80%);
 	color:hsl(333,80%,10%);
 	border:2px solid hsl(333,40%,75%);
 }
 dl.todo,dl.test {
 	background:linear-gradient(to bottom,hsl(200,80%,90%) 0%,hsl(200,80%,85%) 100%);
 	box-shadow:inset 0px 0px 32px hsl(200,40%,80%);
 	color:hsl(200,80%,10%);
 	border:2px solid hsl(200,40%,75%);
 }
 dl.note,dl.pre,dl.post,dl.invariant,dl.warning,dl.attention,dl.deprecated,dl.bug,dl.todo,dl.test {
 	border-radius:4px;
 	padding:1em;
 	text-shadow:0px 1px 1px hsl(0,0%,100%);
 }
 div.toc {
 	background:linear-gradient(to bottom,hsl(34,0%,95%) 0%,hsl(24,0%,90%) 100%);
 	box-shadow:inset 0px 0px 32px hsl(24,0%,90%);
 	text-shadow:0px 1px 1px hsl(24,0%,100%);
 	color:hsl(0,0%,10%);
 	border:2px solid hsl(24,0%,90%);
 	border-radius:4px;
 	float:none;
 	width:auto;
 }
 div.toc h3 {
 	font-size:1.17em;
 }
 div.toc ul {
 	padding-left:1.5em;
 }
 div.toc li {
 	background:none;
 	font-size:1em;
 	padding-left:0em;
 	list-style-type:disc;
 }
 div.ah {
 	background-image:none;
 }
 div.fragment,pre.fragment {
 	background-color:hsl(0,0%,20%);
 	border-radius:4px;
 	border-width:0px;
 	padding:0.5em 2em;
 	overflow:auto;
 	border-left:4px solid hsl(0,0%,80%);
 }
 div.line,pre.fragment {
 	color:hsl(60,30%,96%);
 }
 a.code,a.code:visited,span.preprocessor,span.comment {
 	color:hsl(80,76%,53%);
 }
 span.keyword,span.keywordtype,span.keywordflow {
 	color:hsl(190,81%,67%);
 }
 span.stringliteral {
 	color:hsl(54,70%,68%);
 }
 code {
 	background-color:hsl(0,0%,95%);
 	padding:0.1em;
 	border-radius: 4px;
 }
@@ -0,0 +1,7 @@
 <address class="footer">
 <p>
 Last update on $date for $projectname $projectnumber
 </p>
 </address>
 </body>
 </html>
@@ -0,0 +1,34 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
 <meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
 <meta http-equiv="X-UA-Compatible" content="IE=9"/>
 <meta name="generator" content="Doxygen $doxygenversion"/>
 <!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
 <!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
 <link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
 <script type="text/javascript" src="$relpath^jquery.js"></script>
 <script type="text/javascript" src="$relpath^dynsections.js"></script>
 $treeview
 $search
 $mathjax
 <link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
 $extrastylesheet
 </head>
 <body>
 <div id="top"><!-- do not remove this div, it is closed by doxygen! -->
 <!--BEGIN TITLEAREA-->
 <div id="titlearea">
 	<div class="glfwheader">
 		<a href="http://www.glfw.org/" id="glfwhome">GLFW</a>
 		<ul class="glfwnavbar">
 			<li><a href="http://www.glfw.org/documentation.html">Documentation</a></li>
 			<li><a href="http://www.glfw.org/download.html">Download</a></li>
 			<li><a href="http://www.glfw.org/media.html">Media</a></li>
 			<li><a href="http://www.glfw.org/community.html">Community</a></li>
 		</ul>
 	</div>
 </div>
 <!--END TITLEAREA-->
 <!-- end header part -->
@@ -105,8 +105,8 @@ Examples: `clearScrollOffsets`
@section internals_config Configuration macros
 GLFW uses a number of configuration macros to select at compile time which
-interfaces and code paths to use.  They are defined in the config.h header file,
+interfaces and code paths to use.  They are defined in the glfw_config.h header file,
-which is generated from the `config.h.in` file by CMake.
+which is generated from the `glfw_config.h.in` file by CMake.
 Configuration macros the same style as tokens in the public interface, except
 with a leading underscore.
@@ -11,7 +11,9 @@ existing applications and does not lay claim to the main loop.
 This is the documentation for version 3.0, which has [many new features](@ref news).
 There is a [quick tutorial](@ref quick) for people new to GLFW, which shows how
-to write a small but complete program.
+to write a small but complete program, and guides for
 [compiling GLFW](@ref compile) and
 [building programs that use GLFW](@ref build).
 If you have used GLFW 2.x in the past, there is a
 [transition guide](@ref moving) that explains what has changed and how to update
@@ -176,13 +176,24 @@ similar to that of GLFW 2.
@subsection moving_window_close Window closing
-Window closing is now just an event like any other.  GLFW 3 windows won't
+Window closing initiated by the user is now just an event like any other.
-disappear from underfoot even when no close callback is set; instead the
+Unlike GLFW 2, windows and contexts created with GLFW 3 will not disappear from
-window's close flag is set.  You can query this flag using @ref
+underfoot.  Each window now has a close flag, which is set when the user
-glfwWindowShouldClose, or capture close events by setting a close callback.  The
+attempts to close it.  By default, nothing else happens and the window stays
-close flag can be modified from any point in your program using @ref
+open and visible.  It is then up to you to either destroy the window, take some
 other action or simply ignore the request.  You can query the close flag at any
 time with @ref glfwWindowShouldClose and set it at any time with @ref
 glfwSetWindowShouldClose.
 The close callback no longer returns a value.  Instead, it is called after the
 close flag has been set so it can override its value, if it chooses to, before
 event processing completes.  You may however not call @ref glfwDestroyWindow
 from the close callback (or any other window related callback).
 GLFW itself never clears the close flag, allowing you to set it for other
 reasons for the window to close as well, for example the user choosing Quit from
 the main menu.
@subsection moving_context Explicit context management
@@ -18,7 +18,7 @@ For more information on how to use CMake, see the
 [CMake manual](http://cmake.org/cmake/help/documentation.html).
-@subsection new_30_multiwnd Multi-window support
+@subsection news_30_multiwnd Multi-window support
 GLFW now supports the creation of multiple windows, each with their own OpenGL
 or OpenGL ES context, and all window functions now take a window handle.  Event
@@ -79,7 +79,7 @@ through CMake options.
 GLFW now supports high-DPI monitors on both Windows and OS X, giving windows full
 resolution framebuffers where other UI elements are scaled up.  To achieve this,
@ref glfwGetFramebufferSize and @ref glfwSetFramebufferSizeCallback have been
-added.  These work with pixels, while the rest of the GLFW API work with screen
+added.  These work with pixels, while the rest of the GLFW API works with screen
 coordinates.
@@ -302,4 +302,7 @@ the screen, rendering a triangle and processing events until the user closes the
 window.  It can be found in the source distribution as `examples/simple.c`, and
 is by default compiled along with all other examples when you build GLFW.
 To learn more about how to compile and link programs that use GLFW, see
@ref build.
 */
@@ -62,6 +62,14 @@ Once this function is called, no more events will be delivered for that window
 and its handle becomes invalid.
@section window_userptr Window user pointer
 Each window has a user pointer that can be set with @ref
 glfwSetWindowUserPointer and fetched with @ref glfwGetWindowUserPointer.  This
 can be used for any purpose you need and will not modified by GLFW throughout
 the life-time of the window.
@section window_hints Window creation hints
 There are a number of hints that can be set before the creation of a window and
@@ -440,7 +448,9 @@ context is an OpenGL debug context, or `GL_FALSE` otherwise.
 The `GLFW_OPENGL_PROFILE` attribute indicates the OpenGL profile used by the
 context.  This is `GLFW_OPENGL_CORE_PROFILE` or `GLFW_OPENGL_COMPAT_PROFILE`
 if the context uses a known profile, or `GLFW_OPENGL_ANY_PROFILE` if the
-OpenGL profile is unknown or the context is for another client API.
+OpenGL profile is unknown or the context is for another client API.  Note that
 the returned profile may not match the profile bits of the context flags, as
 GLFW will try other means of detecting the profile when no bits are set.
 The `GLFW_CONTEXT_ROBUSTNESS` attribute indicates the robustness strategy
 used by the context.  This is `GLFW_LOSE_CONTEXT_ON_RESET` or
@@ -477,8 +487,10 @@ zero can be useful for benchmarking purposes, when it is not desirable to
 measure the time it takes to wait for the vertical retrace.  However, a swap
 interval of one lets you avoid tearing.
-Note that not all OpenGL implementations properly implement this function, in
+Note that this may not work on all machines, as some drivers have
-which case @ref glfwSwapInterval will have no effect.  Some drivers also have
+user-controlled settings that override any swap interval the application
-user settings that override requests by GLFW.
+requests.  It is also by default disabled on Windows Vista and later when using
 DWM (Aero), as using it there sometimes leads to severe jitter.  You can
 forcibly enable it for machines using DWM using @ref compile_options_win32.
 */
@@ -644,7 +644,7 @@ int main(int argc, char** argv)
    /* main loop */
    frame = 0;
    iter = 0;
-    dt = last_update_time = glfwGetTime();
+    last_update_time = glfwGetTime();
    while (!glfwWindowShouldClose(window))
    {
@@ -227,7 +227,7 @@ extern "C" {
 *  API changes.
 *  @ingroup init
 */
-#define GLFW_VERSION_REVISION       3
+#define GLFW_VERSION_REVISION       4
 /*! @} */
 /*! @name Key and button actions
@@ -706,8 +706,8 @@ typedef void (* GLFWmousebuttonfun)(GLFWwindow*,int,int,int);
 *  This is the function signature for cursor position callback functions.
 *
 *  @param[in] window The window that received the event.
- *  @param[in] xpos The new x-coordinate of the cursor.
+ *  @param[in] xpos The new x-coordinate, in screen coordinates, of the cursor.
- *  @param[in] ypos The new y-coordinate of the cursor.
+ *  @param[in] ypos The new y-coordinate, in screen coordinates, of the cursor.
 *
 *  @sa glfwSetCursorPosCallback
 *
@@ -765,7 +765,7 @@ typedef void (* GLFWkeyfun)(GLFWwindow*,int,int,int,int);
 *  This is the function signature for Unicode character callback functions.
 *
 *  @param[in] window The window that received the event.
- *  @param[in] character The Unicode code point of the character.
+ *  @param[in] codepoint The Unicode code point of the character.
 *
 *  @sa glfwSetCharCallback
 *
@@ -863,10 +863,7 @@ typedef struct GLFWgammaramp
 *
 *  @note This function may only be called from the main thread.
 *
- *  @note This function may take several seconds to complete on some systems,
+ *  @note **OS X:** This function will change the current directory of the
 *  while on other systems it may take only a fraction of a second to complete.
 *
 *  @note **Mac OS X:** This function will change the current directory of the
 *  application to the `Contents/Resources` subdirectory of the application's
 *  bundle, if present.
 *
@@ -1232,17 +1229,26 @@ GLFWAPI void glfwWindowHint(int target, int hint);
 *  to not share resources.
 *  @return The handle of the created window, or `NULL` if an error occurred.
 *
 *  @remarks **Windows:** Window creation will fail if the Microsoft GDI
 *  software OpenGL implementation is the only one available.
 *
 *  @remarks **Windows:** If the executable has an icon resource named
 *  `GLFW_ICON,` it will be set as the icon for the window.  If no such icon is
 *  present, the `IDI_WINLOGO` icon will be used instead.
 *
- *  @remarks **Mac OS X:** The GLFW window has no icon, as it is not a document
+ *  @remarks **OS X:** The GLFW window has no icon, as it is not a document
 *  window, but the dock icon will be the same as 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.
 *
 *  @remarks **X11:** There is no mechanism for setting the window icon yet.
 *
 *  @remarks The swap interval is not set during window creation, but is left at
 *  the default value for that platform.  For more information, see @ref
 *  glfwSwapInterval.
 *
 *  @note This function may only be called from the main thread.
 *
 *  @sa glfwDestroyWindow
@@ -1354,10 +1360,6 @@ GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos);
 *
 *  @note The window manager may put limits on what positions are allowed.
 *
 *  @bug **X11:** Some window managers ignore the set position of hidden (i.e.
 *  unmapped) windows, instead placing them where it thinks is appropriate once
 *  they are shown.
 *
 *  @sa glfwGetWindowPos
 *
 *  @ingroup window
@@ -1367,7 +1369,8 @@ GLFWAPI void glfwSetWindowPos(GLFWwindow* window, int xpos, int ypos);
 /*! @brief Retrieves the size of the client area of the specified window.
 *
 *  This function retrieves the size, in screen coordinates, of the client area
- *  of the specified window.
+ *  of the specified window.  If you wish to retrieve the size of the
 *  framebuffer in pixels, see @ref glfwGetFramebufferSize.
 *
 *  @param[in] window The window whose size to retrieve.
 *  @param[out] width Where to store the width, in screen coordinates, of the
@@ -1408,7 +1411,8 @@ GLFWAPI void glfwSetWindowSize(GLFWwindow* window, int width, int height);
 /*! @brief Retrieves the size of the framebuffer of the specified window.
 *
 *  This function retrieves the size, in pixels, of the framebuffer of the
- *  specified window.
+ *  specified window.  If you wish to retrieve the size of the window in screen
 *  coordinates, see @ref glfwGetWindowSize.
 *
 *  @param[in] window The window whose framebuffer to query.
 *  @param[out] width Where to store the width, in pixels, of the framebuffer,
@@ -1591,7 +1595,10 @@ GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* window, GLFWwind
 *  @return The previously set callback, or `NULL` if no callback was set or an
 *  error occurred.
 *
- *  @remarks **Mac OS X:** Selecting Quit from the application menu will
+ *  @par New in GLFW 3
 *  The close callback no longer returns a value.
 *
 *  @remarks **OS X:** Selecting Quit from the application menu will
 *  trigger the close callback for all windows.
 *
 *  @ingroup window
@@ -1684,6 +1691,12 @@ GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* window
 *  This function is no longer called by @ref glfwSwapBuffers.  You need to call
 *  it or @ref glfwWaitEvents yourself.
 *
 *  @remarks On some platforms, a window move, resize or menu operation will
 *  cause event processing to block.  This is due to how event processing is
 *  designed on those platforms.  You can use the
 *  [window refresh callback](@ref GLFWwindowrefreshfun) to redraw the contents
 *  of your window when necessary during the operation.
 *
 *  @note This function may only be called from the main thread.
 *
 *  @note This function may not be called from a callback.
@@ -1711,6 +1724,12 @@ GLFWAPI void glfwPollEvents(void);
 *
 *  This function is not required for joystick input to work.
 *
 *  @remarks On some platforms, a window move, resize or menu operation will
 *  cause event processing to block.  This is due to how event processing is
 *  designed on those platforms.  You can use the
 *  [window refresh callback](@ref GLFWwindowrefreshfun) to redraw the contents
 *  of your window when necessary during the operation.
 *
 *  @note This function may only be called from the main thread.
 *
 *  @note This function may not be called from a callback.
@@ -1746,9 +1765,12 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode);
 *  modes:
 *  - `GLFW_CURSOR_NORMAL` makes the cursor visible and behaving normally.
 *  - `GLFW_CURSOR_HIDDEN` makes the cursor invisible when it is over the client
- *    area of the window.
+ *    area of the window but does not restrict the cursor from leaving.  This is
- *  - `GLFW_CURSOR_DISABLED` disables the cursor and removes any limitations on
+ *    useful if you wish to render your own cursor or have no visible cursor at
- *    cursor movement.
+ *    all.
 *  - `GLFW_CURSOR_DISABLED` hides and grabs the cursor, providing virtual
 *    and unlimited cursor movement.  This is useful for implementing for
 *    example 3D camera controls.
 *
 *  If `mode` is `GLFW_STICKY_KEYS`, the value must be either `GL_TRUE` to
 *  enable sticky keys, or `GL_FALSE` to disable it.  If sticky keys are
@@ -1818,7 +1840,8 @@ GLFWAPI int glfwGetMouseButton(GLFWwindow* window, int button);
 /*! @brief Retrieves the last reported cursor position, relative to the client
 *  area of the window.
 *
- *  This function returns the last reported position of the cursor to the
+ *  This function returns the last reported position of the cursor, in screen
 *  coordinates, relative to the upper-left corner of the client area of the
 *  specified window.
 *
 *  If the cursor is disabled (with `GLFW_CURSOR_DISABLED`) then the cursor
@@ -1841,11 +1864,13 @@ GLFWAPI int glfwGetMouseButton(GLFWwindow* window, int button);
 */
 GLFWAPI void glfwGetCursorPos(GLFWwindow* window, double* xpos, double* ypos);
-/*! @brief Sets the position of the cursor, relative to the client area of the window.
+/*! @brief Sets the position of the cursor, relative to the client area of the
 *  window.
 *
- *  This function sets the position of the cursor.  The specified window must be
+ *  This function sets the position, in screen coordinates, of the cursor
- *  focused.  If the window does not have focus when this function is called, it
+ *  relative to the upper-left corner of the client area of the specified
- *  fails silently.
+ *  window.  The window must be focused.  If the window does not have focus when
 *  this function is called, it fails silently.
 *
 *  If the cursor is disabled (with `GLFW_CURSOR_DISABLED`) then the cursor
 *  position is unbounded and limited only by the minimum and maximum values of
@@ -1941,7 +1966,8 @@ GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* window, GLFWmo
 *
 *  This function sets the cursor position callback of the specified window,
 *  which is called when the cursor is moved.  The callback is provided with the
- *  position relative to the upper-left corner of the client area of the window.
+ *  position, in screen coordinates, relative to the upper-left corner of the
 *  client area of the window.
 *
 *  @param[in] window The window whose callback to set.
 *  @param[in] cbfun The new callback, or `NULL` to remove the currently set
@@ -2201,6 +2227,11 @@ GLFWAPI void glfwSwapBuffers(GLFWwindow* window);
 *
 *  @remarks This function may be called from secondary threads.
 *
 *  @note This function is not called during window creation, leaving the swap
 *  interval set to whatever is the default on that platform.  This is done
 *  because some swap interval extensions used by GLFW do not allow the swap
 *  interval to be reset to zero once it has been set to a non-zero value.
 *
 *  @note Some GPU drivers do not honor the requested swap interval, either
 *  because of user settings that override the request or due to bugs in the
 *  driver.
@@ -3,7 +3,9 @@ include_directories(${GLFW_SOURCE_DIR}/src
                    ${GLFW_BINARY_DIR}/src
                    ${glfw_INCLUDE_DIRS})
-set(common_HEADERS ${GLFW_BINARY_DIR}/src/config.h internal.h
+add_definitions(-D_GLFW_USE_CONFIG_H)
 set(common_HEADERS ${GLFW_BINARY_DIR}/src/glfw_config.h internal.h
                   ${GLFW_SOURCE_DIR}/include/GLFW/glfw3.h
                   ${GLFW_SOURCE_DIR}/include/GLFW/glfw3native.h)
 set(common_SOURCES clipboard.c context.c gamma.c init.c input.c joystick.c
@@ -72,7 +74,8 @@ if (BUILD_SHARED_LIBS)
            set(glfw_CFLAGS "")
        endif()
        set_target_properties(glfw PROPERTIES
-                              COMPILE_FLAGS "${glfw_CFLAGS} -fno-common")
+                              COMPILE_FLAGS "${glfw_CFLAGS} -fno-common"
                              INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}")
    endif()
    target_link_libraries(glfw ${glfw_LIBRARIES})
@@ -122,7 +122,7 @@ void _glfwPlatformTerminate(void)
 const char* _glfwPlatformGetVersionString(void)
 {
-    const char* version = _GLFW_VERSION_FULL " Cocoa"
+    const char* version = _GLFW_VERSION_NUMBER " Cocoa"
 #if defined(_GLFW_NSGL)
        " NSGL"
 #endif
@@ -251,9 +251,6 @@ static void pollJoystickEvents(void)
                joystick->axes[i] = value;
            else
                joystick->axes[i] = (2.f * (value - axis->minReport) / readScale) - 1.f;
            if (i & 1)
                joystick->axes[i] = -joystick->axes[i];
        }
        for (i = 0;  i < CFArrayGetCount(joystick->hatElements);  i++)
@@ -319,8 +316,9 @@ void _glfwInitJoysticks(void)
    while ((ioHIDDeviceObject = IOIteratorNext(objectIterator)))
    {
        CFMutableDictionaryRef propsRef = NULL;
        CFTypeRef valueRef = NULL;
        kern_return_t result;
        CFTypeRef valueRef = 0;
        IOCFPlugInInterface** ppPlugInInterface = NULL;
        HRESULT plugInResult = S_OK;
@@ -329,26 +327,29 @@ void _glfwInitJoysticks(void)
        long usagePage, usage;
        // Check device type
-        valueRef = IORegistryEntryCreateCFProperty(ioHIDDeviceObject,
+        result = IORegistryEntryCreateCFProperties(ioHIDDeviceObject,
-                                                   CFSTR(kIOHIDPrimaryUsagePageKey),
+                                                   &propsRef,
                                                   kCFAllocatorDefault,
                                                   kNilOptions);
        if (result != kIOReturnSuccess)
            continue;
        valueRef = CFDictionaryGetValue(propsRef, CFSTR(kIOHIDPrimaryUsagePageKey));
        if (valueRef)
        {
            CFNumberGetValue(valueRef, kCFNumberLongType, &usagePage);
            if (usagePage != kHIDPage_GenericDesktop)
            {
                // This device is not relevant to GLFW
                CFRelease(valueRef);
                continue;
            }
            CFRelease(valueRef);
        }
-        valueRef = IORegistryEntryCreateCFProperty(ioHIDDeviceObject,
+        valueRef = CFDictionaryGetValue(propsRef, CFSTR(kIOHIDPrimaryUsageKey));
                                                   CFSTR(kIOHIDPrimaryUsageKey),
                                                   kCFAllocatorDefault,
                                                   kNilOptions);
        if (valueRef)
        {
            CFNumberGetValue(valueRef, kCFNumberLongType, &usage);
@@ -358,6 +359,7 @@ void _glfwInitJoysticks(void)
                 usage != kHIDUsage_GD_MultiAxisController))
            {
                // This device is not relevant to GLFW
                CFRelease(valueRef);
                continue;
            }
@@ -393,10 +395,7 @@ void _glfwInitJoysticks(void)
                                                     joystick);
        // Get product string
-        valueRef = IORegistryEntryCreateCFProperty(ioHIDDeviceObject,
+        valueRef = CFDictionaryGetValue(propsRef, CFSTR(kIOHIDProductKey));
                                                   CFSTR(kIOHIDProductKey),
                                                   kCFAllocatorDefault,
                                                   kNilOptions);
        if (valueRef)
        {
            CFStringGetCString(valueRef,
@@ -410,10 +409,7 @@ void _glfwInitJoysticks(void)
        joystick->buttonElements = CFArrayCreateMutable(NULL, 0, NULL);
        joystick->hatElements = CFArrayCreateMutable(NULL, 0, NULL);
-        valueRef = IORegistryEntryCreateCFProperty(ioHIDDeviceObject,
+        valueRef = CFDictionaryGetValue(propsRef, CFSTR(kIOHIDElementKey));
                                                   CFSTR(kIOHIDElementKey),
                                                   kCFAllocatorDefault,
                                                   kNilOptions);
        if (CFGetTypeID(valueRef) == CFArrayGetTypeID())
        {
            CFRange range = { 0, CFArrayGetCount(valueRef) };
@@ -31,6 +31,9 @@
 #include <limits.h>
 #include <IOKit/graphics/IOGraphicsLib.h>
 #include <IOKit/graphics/IOGraphicsLib.h>
 #include <CoreVideo/CVBase.h>
 #include <CoreVideo/CVDisplayLink.h>
 // Get the name of the specified display
@@ -46,9 +49,11 @@ static const char* getDisplayName(CGDirectDisplayID displayID)
                                         kIODisplayOnlyPreferredName);
    names = CFDictionaryGetValue(info, CFSTR(kDisplayProductName));
-    if (!CFDictionaryGetValueIfPresent(names, CFSTR("en_US"),
+    if (!names || !CFDictionaryGetValueIfPresent(names, CFSTR("en_US"),
-                                       (const void**) &value))
+                                                 (const void**) &value))
    {
        _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to retrieve display name");
        CFRelease(info);
        return strdup("Unknown");
    }
@@ -74,9 +79,6 @@ static GLboolean modeIsGood(CGDisplayModeRef mode)
    if (flags & kDisplayModeInterlacedFlag)
        return GL_FALSE;
    if (flags & kDisplayModeTelevisionFlag)
        return GL_FALSE;
    if (flags & kDisplayModeStretchedFlag)
        return GL_FALSE;
@@ -94,13 +96,21 @@ static GLboolean modeIsGood(CGDisplayModeRef mode)
 // Convert Core Graphics display mode to GLFW video mode
 //
-static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode)
+static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode,
                                            CVDisplayLinkRef link)
 {
    GLFWvidmode result;
-    result.width = CGDisplayModeGetWidth(mode);
+    result.width = (int) CGDisplayModeGetWidth(mode);
-    result.height = CGDisplayModeGetHeight(mode);
+    result.height = (int) CGDisplayModeGetHeight(mode);
    result.refreshRate = (int) CGDisplayModeGetRefreshRate(mode);
    if (result.refreshRate == 0)
    {
        const CVTime time = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(link);
        if (!(time.flags & kCVTimeIsIndefinite))
            result.refreshRate = (int) (time.timeScale / (double) time.timeValue);
    }
    CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
    if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) == 0)
@@ -334,6 +344,9 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
    CFArrayRef modes;
    CFIndex count, i;
    GLFWvidmode* result;
    CVDisplayLinkRef link;
    CVDisplayLinkCreateWithCGDisplay(monitor->ns.displayID, &link);
    modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
    count = CFArrayGetCount(modes);
@@ -348,21 +361,28 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
        mode = (CGDisplayModeRef) CFArrayGetValueAtIndex(modes, i);
        if (modeIsGood(mode))
        {
-            result[*found] = vidmodeFromCGDisplayMode(mode);
+            result[*found] = vidmodeFromCGDisplayMode(mode, link);
            (*found)++;
        }
    }
    CFRelease(modes);
    CVDisplayLinkRelease(link);
    return result;
 }
 void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode *mode)
 {
    CGDisplayModeRef displayMode;
    CVDisplayLinkRef link;
    CVDisplayLinkCreateWithCGDisplay(monitor->ns.displayID, &link);
    displayMode = CGDisplayCopyDisplayMode(monitor->ns.displayID);
-    *mode = vidmodeFromCGDisplayMode(displayMode);
+    *mode = vidmodeFromCGDisplayMode(displayMode, link);
    CGDisplayModeRelease(displayMode);
    CVDisplayLinkRelease(link);
 }
@@ -58,8 +58,18 @@ static void enterFullscreenMode(_GLFWwindow* window)
    _glfwSetVideoMode(window->monitor, &window->videoMode);
 	NSDictionary* options = [NSDictionary dictionaryWithObjectsAndKeys:
                                [NSNumber numberWithBool:NO],
                                NSFullScreenModeAllScreens,
                                nil];
    [window->ns.view enterFullScreenMode:window->monitor->ns.screen
-                             withOptions:nil];
+                             withOptions:options];
    // HACK: Synthesize focus event as window does not become key when the view
    //       is made full screen
    // TODO: Remove this when moving to a full screen window
    _glfwInputWindowFocus(window, GL_TRUE);
 }
 // Leave fullscreen mode
@@ -69,6 +79,11 @@ static void leaveFullscreenMode(_GLFWwindow* window)
    if (![window->ns.view isInFullScreenMode])
        return;
    // HACK: Synthesize focus event as window does not become key when the view
    //       is made full screen
    // TODO: Remove this when moving to a full screen window
    _glfwInputWindowFocus(window, GL_FALSE);
    _glfwRestoreVideoMode(window->monitor);
    // Exit full screen after the video restore to avoid a nasty display
@@ -90,7 +105,7 @@ static float transformY(float y)
 static NSRect convertRectToBacking(_GLFWwindow* window, NSRect contentRect)
 {
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
-    if (floor(NSAppKitVersionNumber) >= NSAppKitVersionNumber10_7)
+    if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6)
        return [window->ns.view convertRectToBacking:contentRect];
    else
 #endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
@@ -251,7 +266,6 @@ static int translateFlags(NSUInteger flags)
 static int translateKey(unsigned int key)
 {
    // Keyboard symbol translation table
    // TODO: Need to find mappings for F13-F15, volume down/up/mute, and eject.
    static const unsigned int table[128] =
    {
        /* 00 */ GLFW_KEY_A,
@@ -264,7 +278,7 @@ static int translateKey(unsigned int key)
        /* 07 */ GLFW_KEY_X,
        /* 08 */ GLFW_KEY_C,
        /* 09 */ GLFW_KEY_V,
-        /* 0a */ GLFW_KEY_GRAVE_ACCENT,
+        /* 0a */ GLFW_KEY_WORLD_1,
        /* 0b */ GLFW_KEY_B,
        /* 0c */ GLFW_KEY_Q,
        /* 0d */ GLFW_KEY_W,
@@ -304,7 +318,7 @@ static int translateKey(unsigned int key)
        /* 2f */ GLFW_KEY_PERIOD,
        /* 30 */ GLFW_KEY_TAB,
        /* 31 */ GLFW_KEY_SPACE,
-        /* 32 */ GLFW_KEY_WORLD_1,
+        /* 32 */ GLFW_KEY_GRAVE_ACCENT,
        /* 33 */ GLFW_KEY_BACKSPACE,
        /* 34 */ GLFW_KEY_UNKNOWN,
        /* 35 */ GLFW_KEY_ESCAPE,
@@ -359,7 +373,7 @@ static int translateKey(unsigned int key)
        /* 66 */ GLFW_KEY_UNKNOWN,
        /* 67 */ GLFW_KEY_F11,
        /* 68 */ GLFW_KEY_UNKNOWN,
-        /* 69 */ GLFW_KEY_PRINT_SCREEN,
+        /* 69 */ GLFW_KEY_F13,
        /* 6a */ GLFW_KEY_F16,
        /* 6b */ GLFW_KEY_F14,
        /* 6c */ GLFW_KEY_UNKNOWN,
@@ -519,7 +533,7 @@ static int translateKey(unsigned int key)
 - (void)otherMouseDown:(NSEvent *)event
 {
    _glfwInputMouseClick(window,
-                         [event buttonNumber],
+                         (int) [event buttonNumber],
                         GLFW_PRESS,
                         translateFlags([event modifierFlags]));
 }
@@ -532,7 +546,7 @@ static int translateKey(unsigned int key)
 - (void)otherMouseUp:(NSEvent *)event
 {
    _glfwInputMouseClick(window,
-                         [event buttonNumber],
+                         (int) [event buttonNumber],
                         GLFW_RELEASE,
                         translateFlags([event modifierFlags]));
 }
@@ -620,7 +634,7 @@ static int translateKey(unsigned int key)
    double deltaX, deltaY;
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
-    if (floor(NSAppKitVersionNumber) >= NSAppKitVersionNumber10_7)
+    if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6)
    {
        deltaX = [event scrollingDeltaX];
        deltaY = [event scrollingDeltaY];
@@ -781,9 +795,23 @@ static void createMenuBar(void)
                          action:@selector(arrangeInFront:)
                   keyEquivalent:@""];
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
    if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6)
    {
        // TODO: Make this appear at the bottom of the menu (for consistency)
        [windowMenu addItem:[NSMenuItem separatorItem]];
        [[windowMenu addItemWithTitle:@"Enter Full Screen"
                               action:@selector(toggleFullScreen:)
                        keyEquivalent:@"f"]
            setKeyEquivalentModifierMask:NSControlKeyMask | NSCommandKeyMask];
    }
 #endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
    // Prior to Snow Leopard, we need to use this oddly-named semi-private API
    // to get the application menu working properly.
-    [NSApp performSelector:@selector(setAppleMenu:) withObject:appMenu];
+    SEL setAppleMenuSelector = NSSelectorFromString(@"setAppleMenu:");
    [NSApp performSelector:setAppleMenuSelector withObject:appMenu];
 }
 #endif /* _GLFW_USE_MENUBAR */
@@ -798,13 +826,8 @@ static GLboolean initializeAppKit(void)
    // Implicitly create shared NSApplication instance
    [GLFWApplication sharedApplication];
-    // If we get here, the application is unbundled
+    // In case we are unbundled, make us a proper UI application
-    ProcessSerialNumber psn = { 0, kCurrentProcess };
+    [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
    TransformProcessType(&psn, kProcessTransformToForegroundApplication);
    // Having the app in front of the terminal window is also generally
    // handy.  There is an NSApplication API to do this, but...
    SetFrontProcess(&psn);
 #if defined(_GLFW_USE_MENUBAR)
    // Menu bar setup must go between sharedApplication above and
@@ -851,8 +874,13 @@ static GLboolean createWindow(_GLFWwindow* window,
    window->ns.view = [[GLFWContentView alloc] initWithGlfwWindow:window];
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
-    if (floor(NSAppKitVersionNumber) >= NSAppKitVersionNumber10_7)
+    if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6)
    {
        [window->ns.view setWantsBestResolutionOpenGLSurface:YES];
        if (wndconfig->resizable)
            [window->ns.object setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
    }
 #endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
    [window->ns.object setTitle:[NSString stringWithUTF8String:wndconfig->title]];
@@ -862,7 +890,7 @@ static GLboolean createWindow(_GLFWwindow* window,
    [window->ns.object center];
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
-    if (floor(NSAppKitVersionNumber) >= NSAppKitVersionNumber10_7)
+    if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6)
        [window->ns.object setRestorable:NO];
 #endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
@@ -1006,6 +1034,12 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window)
 void _glfwPlatformShowWindow(_GLFWwindow* window)
 {
    // Make us the active application
    // HACK: This has been moved here from initializeAppKit to prevent
    //       applications using only hidden windows from being activated, but
    //       should probably not be done every time any window is shown
    [NSApp activateIgnoringOtherApps:YES];
    [window->ns.object makeKeyAndOrderFront:nil];
    _glfwInputWindowVisibility(window, GL_TRUE);
 }
@@ -1050,6 +1084,8 @@ void _glfwPlatformWaitEvents(void)
 void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
 {
    setModeCursor(window, window->cursorMode);
    if (window->monitor)
    {
        CGDisplayMoveCursorToPoint(window->monitor->ns.displayID,
@@ -98,7 +98,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
    if (wndconfig->clientAPI == GLFW_OPENGL_API)
    {
-        if (wndconfig->glMajor < 1 || wndconfig->glMinor < 0 ||
+        if ((wndconfig->glMajor < 1 || wndconfig->glMinor < 0) ||
            (wndconfig->glMajor == 1 && wndconfig->glMinor > 5) ||
            (wndconfig->glMajor == 2 && wndconfig->glMinor > 1) ||
            (wndconfig->glMajor == 3 && wndconfig->glMinor > 3))
@@ -402,8 +402,8 @@ GLboolean _glfwRefreshContextAttribs(void)
            else if (glfwExtensionSupported("GL_ARB_debug_output"))
            {
                // HACK: This is a workaround for older drivers (pre KHR_debug)
-                // not setting the debug bit in the context flags for debug
+                //       not setting the debug bit in the context flags for
-                // contexts
+                //       debug contexts
                window->glDebug = GL_TRUE;
            }
        }
@@ -419,13 +419,21 @@ GLboolean _glfwRefreshContextAttribs(void)
                window->glProfile = GLFW_OPENGL_COMPAT_PROFILE;
            else if (mask & GL_CONTEXT_CORE_PROFILE_BIT)
                window->glProfile = GLFW_OPENGL_CORE_PROFILE;
            else if (glfwExtensionSupported("GL_ARB_compatibility"))
            {
                // HACK: This is a workaround for the compatibility profile bit
                //       not being set in the context flags if an OpenGL 3.2+
                //       context was created without having requested a specific
                //       version
                window->glProfile = GLFW_OPENGL_COMPAT_PROFILE;
            }
        }
        // Read back robustness strategy
        if (glfwExtensionSupported("GL_ARB_robustness"))
        {
            // NOTE: We avoid using the context flags for detection, as they are
-            // only present from 3.0 while the extension applies from 1.1
+            //       only present from 3.0 while the extension applies from 1.1
            GLint strategy;
            glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
@@ -442,7 +450,7 @@ GLboolean _glfwRefreshContextAttribs(void)
        if (glfwExtensionSupported("GL_EXT_robustness"))
        {
            // NOTE: The values of these constants match those of the OpenGL ARB
-            // one, so we can reuse them here
+            //       one, so we can reuse them here
            GLint strategy;
            glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
@@ -566,7 +574,7 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
        return GL_FALSE;
    }
-    if (extension == NULL || *extension == '\0')
+    if (!extension || *extension == '\0')
    {
        _glfwInputError(GLFW_INVALID_VALUE, NULL);
        return GL_FALSE;
@@ -577,11 +585,15 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
        // Check if extension is in the old style OpenGL extensions string
        extensions = glGetString(GL_EXTENSIONS);
-        if (extensions != NULL)
+        if (!extensions)
        {
-            if (_glfwStringInExtensionString(extension, extensions))
+            _glfwInputError(GLFW_PLATFORM_ERROR,
-                return GL_TRUE;
+                            "Failed to retrieve extension string");
            return GL_FALSE;
        }
        if (_glfwStringInExtensionString(extension, extensions))
            return GL_TRUE;
    }
 #if defined(_GLFW_USE_OPENGL)
    else
@@ -595,11 +607,16 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
        for (i = 0;  i < count;  i++)
        {
-             if (strcmp((const char*) window->GetStringi(GL_EXTENSIONS, i),
+            const char* en = (const char*) window->GetStringi(GL_EXTENSIONS, i);
-                         extension) == 0)
+            if (!en)
-             {
+            {
-                 return GL_TRUE;
+                _glfwInputError(GLFW_PLATFORM_ERROR,
-             }
+                                "Failed to retrieve extension string %i", i);
                return GL_FALSE;
            }
            if (strcmp(en, extension) == 0)
                return GL_TRUE;
        }
    }
 #endif // _GLFW_USE_OPENGL
@@ -1,7 +1,7 @@
 prefix=@CMAKE_INSTALL_PREFIX@
 exec_prefix=${prefix}
 includedir=${prefix}/include
-libdir=${exec_prefix}/lib
+libdir=${exec_prefix}/lib@LIB_SUFFIX@
 Name: GLFW
 Description: A portable library for OpenGL, window and input
@@ -23,13 +23,15 @@
 //    distribution.
 //
 //========================================================================
-// As config.h.in, this file is used by CMake to produce the config.h shared
+// As glfw_config.h.in, this file is used by CMake to produce the
-// configuration header file.  If you are adding a feature requiring
+// glfw_config.h configuration header file.  If you are adding a feature
-// conditional compilation, this is the proper place to add the macros.
+// requiring conditional compilation, this is where to add the macro.
 //========================================================================
-// As config.h, this file defines compile-time build options and macros for
+// As glfw_config.h, this file defines compile-time option macros for a
-// all platforms supported by GLFW.  As this is a generated file, don't modify
+// specific platform and development environment.  If you are using the
-// it.  Instead, you should modify the config.h.in file.
+// GLFW CMake files, modify glfw_config.h.in instead of this file.  If you
 // are using your own build system, make this file define the appropriate
 // macros in whatever way is suitable.
 //========================================================================
 // Define this to 1 if building GLFW for X11
@@ -79,6 +81,3 @@
 // Define this to 1 if using OpenGL ES 2.0 as the client library
 #cmakedefine _GLFW_USE_GLESV2
 // The GLFW version as used by glfwGetVersionString
 #define _GLFW_VERSION_FULL "@GLFW_VERSION_FULL@"
@@ -30,7 +30,6 @@
 #include <string.h>
 #include <stdlib.h>
 #include <assert.h>
 #include <pthread.h>
 // This is the only glXGetProcAddress variant not declared by glxext.h
@@ -75,7 +74,7 @@ static GLboolean chooseFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* resul
    if (strcmp(vendor, "Chromium") == 0)
    {
        // HACK: This is a (hopefully temporary) workaround for Chromium
-        // (VirtualBox GL) not setting the window bit on any GLXFBConfigs
+        //       (VirtualBox GL) not setting the window bit on any GLXFBConfigs
        trustWindowBit = GL_FALSE;
    }
@@ -457,8 +456,8 @@ int _glfwCreateContext(_GLFWwindow* window,
        if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
        {
            // NOTE: Only request an explicitly versioned context when
-            // necessary, as explicitly requesting version 1.0 does not always
+            //       necessary, as explicitly requesting version 1.0 does not
-            // return the highest available version
+            //       always return the highest available version
            setGLXattrib(GLX_CONTEXT_MAJOR_VERSION_ARB, wndconfig->glMajor);
            setGLXattrib(GLX_CONTEXT_MINOR_VERSION_ARB, wndconfig->glMinor);
@@ -485,8 +484,9 @@ int _glfwCreateContext(_GLFWwindow* window,
        if (window->glx.context == NULL)
        {
            // HACK: This is a fallback for the broken Mesa implementation of
-            // GLX_ARB_create_context_profile, which fails default 1.0 context
+            //       GLX_ARB_create_context_profile, which fails default 1.0
-            // creation with a GLXBadProfileARB error in violation of the spec
+            //       context creation with a GLXBadProfileARB error in violation
            //       of the extension spec
            if (_glfw.x11.errorCode == _glfw.glx.errorBase + GLXBadProfileARB &&
                wndconfig->clientAPI == GLFW_OPENGL_API &&
                wndconfig->glProfile == GLFW_OPENGL_ANY_PROFILE &&
@@ -41,6 +41,8 @@
 #include <dlfcn.h>
 #endif
 #include <pthread.h>
 // We support four different ways for getting addresses for GL/GLX
 // extension functions: glXGetProcAddress, glXGetProcAddressARB,
 // glXGetProcAddressEXT, and dlsym
@@ -35,7 +35,7 @@
 //
 static void setCursorMode(_GLFWwindow* window, int newMode)
 {
-    int oldMode;
+    const int oldMode = window->cursorMode;
    if (newMode != GLFW_CURSOR_NORMAL &&
        newMode != GLFW_CURSOR_HIDDEN &&
@@ -45,10 +45,11 @@ static void setCursorMode(_GLFWwindow* window, int newMode)
        return;
    }
    oldMode = window->cursorMode;
    if (oldMode == newMode)
        return;
    window->cursorMode = newMode;
    if (window == _glfw.focusedWindow)
    {
        if (oldMode == GLFW_CURSOR_DISABLED)
@@ -71,8 +72,6 @@ static void setCursorMode(_GLFWwindow* window, int newMode)
        _glfwPlatformSetCursorMode(window, newMode);
    }
    window->cursorMode = newMode;
 }
 // Set sticky keys mode for the specified window
@@ -149,13 +148,13 @@ void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int m
        window->callbacks.key((GLFWwindow*) window, key, scancode, action, mods);
 }
-void _glfwInputChar(_GLFWwindow* window, unsigned int character)
+void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint)
 {
-    if (character < 32 || (character > 126 && character < 160))
+    if (codepoint < 32 || (codepoint > 126 && codepoint < 160))
        return;
    if (window->callbacks.character)
-        window->callbacks.character((GLFWwindow*) window, character);
+        window->callbacks.character((GLFWwindow*) window, codepoint);
 }
 void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset)
@@ -29,7 +29,11 @@
 #define _internal_h_
-#include "config.h"
+#if defined(_GLFW_USE_CONFIG_H)
 #include "glfw_config.h"
 #endif
 #define _GLFW_VERSION_NUMBER "3.0.4"
 #if defined(_GLFW_USE_OPENGL)
 // This is the default for glfw3.h
@@ -624,10 +628,10 @@ void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int m
 /*! @brief Notifies shared code of a Unicode character input event.
 *  @param[in] window The window that received the event.
- *  @param[in] character The Unicode code point of the input character.
+ *  @param[in] codepoint The Unicode code point of the input character.
 *  @ingroup event
 */
-void _glfwInputChar(_GLFWwindow* window, unsigned int character);
+void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint);
 /*! @brief Notifies shared code of a scroll event.
 *  @param[in] window The window that received the event.
@@ -750,11 +754,18 @@ void _glfwAllocGammaArrays(GLFWgammaramp* ramp, unsigned int size);
 */
 void _glfwFreeGammaArrays(GLFWgammaramp* ramp);
-/*! @ingroup utility
+/*! @brief Allocates and returns a monitor object with the specified name
 *  and dimensions.
 *  @param[in] name The name of the monitor.
 *  @param[in] widthMM The width, in mm, of the monitor's display area.
 *  @param[in] heightMM The height, in mm, of the monitor's display area.
 *  @return The newly created object.
 *  @ingroup utility
 */
 _GLFWmonitor* _glfwCreateMonitor(const char* name, int widthMM, int heightMM);
-/*! @ingroup utility
+/*! @brief Frees a monitor object and any data associated with it.
 *  @ingroup utility
  */
 void _glfwDestroyMonitor(_GLFWmonitor* monitor);
@@ -178,7 +178,7 @@ int _glfwCreateContext(_GLFWwindow* window,
    }
    // NOTE: All NSOpenGLPixelFormats on the relevant cards support sRGB
-    // frambuffer, so there's no need (and no way) to request it
+    //       frambuffer, so there's no need (and no way) to request it
    ADD_ATTR(0);
@@ -272,9 +272,21 @@ static GLboolean choosePixelFormat(_GLFWwindow* window,
        usableCount++;
    }
    if (!usableCount)
    {
        _glfwInputError(GLFW_API_UNAVAILABLE,
                        "WGL: The driver does not appear to support OpenGL");
        free(usableConfigs);
        return GL_FALSE;
    }
    closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
    if (!closest)
    {
        _glfwInputError(GLFW_PLATFORM_ERROR,
                        "WGL: Failed to find a suitable pixel format");
        free(usableConfigs);
        return GL_FALSE;
    }
@@ -355,11 +367,7 @@ int _glfwCreateContext(_GLFWwindow* window,
    }
    if (!choosePixelFormat(window, fbconfig, &pixelFormat))
    {
        _glfwInputError(GLFW_PLATFORM_ERROR,
                        "WGL: Failed to find a suitable pixel format");
        return GL_FALSE;
    }
    if (!DescribePixelFormat(window->wgl.dc, pixelFormat, sizeof(pfd), &pfd))
    {
@@ -598,7 +606,7 @@ void _glfwPlatformSwapInterval(int interval)
    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
 #if !defined(_GLFW_USE_DWM_SWAP_INTERVAL)
-    if (_glfwIsCompositionEnabled())
+    if (_glfwIsCompositionEnabled() && interval)
    {
        // Don't enabled vsync when desktop compositing is enabled, as it leads
        // to frame jitter
@@ -243,7 +243,7 @@ void _glfwPlatformTerminate(void)
 const char* _glfwPlatformGetVersionString(void)
 {
-    const char* version = _GLFW_VERSION_FULL " Win32"
+    const char* version = _GLFW_VERSION_NUMBER " Win32"
 #if defined(_GLFW_WGL)
        " WGL"
 #elif defined(_GLFW_EGL)
@@ -252,7 +252,7 @@ const char* _glfwPlatformGetVersionString(void)
 #if defined(__MINGW32__)
        " MinGW"
 #elif defined(_MSC_VER)
-        " VisualC "
+        " VisualC"
 #elif defined(__BORLANDC__)
        " BorlandC"
 #endif
@@ -97,7 +97,7 @@ const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
        return NULL;
    axes[(*count)++] = calcJoystickPos(ji.dwXpos, jc.wXmin, jc.wXmax);
-    axes[(*count)++] = -calcJoystickPos(ji.dwYpos, jc.wYmin, jc.wYmax);
+    axes[(*count)++] = calcJoystickPos(ji.dwYpos, jc.wYmin, jc.wYmax);
    if (jc.wCaps & JOYCAPS_HASZ)
        axes[(*count)++] = calcJoystickPos(ji.dwZpos, jc.wZmin, jc.wZmax);
@@ -109,7 +109,7 @@ const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
        axes[(*count)++] = calcJoystickPos(ji.dwUpos, jc.wUmin, jc.wUmax);
    if (jc.wCaps & JOYCAPS_HASV)
-        axes[(*count)++] = -calcJoystickPos(ji.dwVpos, jc.wVmin, jc.wVmax);
+        axes[(*count)++] = calcJoystickPos(ji.dwVpos, jc.wVmin, jc.wVmax);
    return axes;
 }
@@ -157,7 +157,7 @@ typedef struct _GLFWwindowWin32
    GLboolean           cursorCentered;
    GLboolean           cursorInside;
    GLboolean           cursorHidden;
-    double              oldCursorX, oldCursorY;
+    int                 oldCursorX, oldCursorY;
 } _GLFWwindowWin32;
@@ -174,8 +174,7 @@ typedef struct _GLFWlibraryWin32
    struct {
        GLboolean       hasPC;
        double          resolution;
-        unsigned int    t0_32;
+        unsigned __int64 base;
        __int64         t0_64;
    } timer;
 #ifndef _GLFW_NO_DLOAD_WINMM
@@ -28,6 +28,21 @@
 #include "internal.h"
 // Return raw time
 //
 static unsigned __int64 getRawTime(void)
 {
    if (_glfw.win32.timer.hasPC)
    {
        unsigned __int64 time;
        QueryPerformanceCounter((LARGE_INTEGER*) &time);
        return time;
    }
    else
        return (unsigned __int64) _glfw_timeGetTime();
 }
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
@@ -36,20 +51,20 @@
 //
 void _glfwInitTimer(void)
 {
-    __int64 freq;
+    unsigned __int64 frequency;
-    if (QueryPerformanceFrequency((LARGE_INTEGER*) &freq))
+    if (QueryPerformanceFrequency((LARGE_INTEGER*) &frequency))
    {
        _glfw.win32.timer.hasPC = GL_TRUE;
-        _glfw.win32.timer.resolution = 1.0 / (double) freq;
+        _glfw.win32.timer.resolution = 1.0 / (double) frequency;
        QueryPerformanceCounter((LARGE_INTEGER*) &_glfw.win32.timer.t0_64);
    }
    else
    {
        _glfw.win32.timer.hasPC = GL_FALSE;
        _glfw.win32.timer.resolution = 0.001; // winmm resolution is 1 ms
        _glfw.win32.timer.t0_32 = _glfw_timeGetTime();
    }
    _glfw.win32.timer.base = getRawTime();
 }
@@ -59,30 +74,13 @@ void _glfwInitTimer(void)
 double _glfwPlatformGetTime(void)
 {
-    double t;
+    return (double) (getRawTime() - _glfw.win32.timer.base) *
-    __int64 t_64;
+        _glfw.win32.timer.resolution;
    if (_glfw.win32.timer.hasPC)
    {
        QueryPerformanceCounter((LARGE_INTEGER*) &t_64);
        t =  (double)(t_64 - _glfw.win32.timer.t0_64);
    }
    else
        t = (double)(_glfw_timeGetTime() - _glfw.win32.timer.t0_32);
    return t * _glfw.win32.timer.resolution;
 }
-void _glfwPlatformSetTime(double t)
+void _glfwPlatformSetTime(double time)
 {
-    __int64 t_64;
+    _glfw.win32.timer.base = getRawTime() -
-
+        (unsigned __int64) (time / _glfw.win32.timer.resolution);
    if (_glfw.win32.timer.hasPC)
    {
        QueryPerformanceCounter((LARGE_INTEGER*) &t_64);
        _glfw.win32.timer.t0_64 = t_64 - (__int64) (t / _glfw.win32.timer.resolution);
    }
    else
        _glfw.win32.timer.t0_32 = _glfw_timeGetTime() - (int)(t * 1000.0);
 }
@@ -145,7 +145,7 @@ static int translateKey(WPARAM wParam, LPARAM lParam)
 {
    // Check for numeric keypad keys
    // NOTE: This way we always force "NumLock = ON", which is intentional since
-    // the returned key code should correspond to a physical location.
+    //       the returned key code should correspond to a physical location.
    if ((HIWORD(lParam) & 0x100) == 0)
    {
        switch (MapVirtualKey(HIWORD(lParam) & 0xFF, 1))
@@ -388,10 +388,21 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
            if (focused && iconified)
            {
-                // This is a workaround for window iconification using the
+                if (window->iconified && _glfw.focusedWindow != window)
-                // taskbar leading to windows being told they're focused and
+                {
-                // iconified and then never told they're defocused
+                    // This is a workaround for window restoration using the
-                focused = FALSE;
+                    // Win+D hot key leading to windows being told they're
                    // focused and iconified and then never told they're
                    // restored
                    iconified = FALSE;
                }
                else
                {
                    // This is a workaround for window iconification using the
                    // taskbar leading to windows being told they're focused and
                    // iconified and then never told they're defocused
                    focused = FALSE;
                }
            }
            if (!focused && _glfw.focusedWindow == window)
@@ -431,6 +442,19 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
            return 0;
        }
        case WM_ACTIVATEAPP:
        {
            if (!wParam && IsIconic(hWnd))
            {
                // This is a workaround for full screen windows losing focus
                // through Alt+Tab leading to windows being told they're
                // unfocused and restored and then never told they're iconified
                _glfwInputWindowIconify(window, GL_TRUE);
            }
            return 0;
        }
        case WM_SHOWWINDOW:
        {
            _glfwInputWindowVisibility(window, wParam ? GL_TRUE : GL_FALSE);
@@ -593,7 +617,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
            if (newCursorX != window->win32.oldCursorX ||
                newCursorY != window->win32.oldCursorY)
            {
-                double x, y;
+                int x, y;
                if (window->cursorMode == GLFW_CURSOR_DISABLED)
                {
@@ -654,8 +678,11 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
        case WM_SIZE:
        {
-            if (window->cursorMode == GLFW_CURSOR_DISABLED)
+            if (window->cursorMode == GLFW_CURSOR_DISABLED &&
                _glfw.focusedWindow == window)
            {
                updateClipRect(window);
            }
            _glfwInputFramebufferSize(window, LOWORD(lParam), HIWORD(lParam));
            _glfwInputWindowSize(window, LOWORD(lParam), HIWORD(lParam));
@@ -664,10 +691,17 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
        case WM_MOVE:
        {
-            if (window->cursorMode == GLFW_CURSOR_DISABLED)
+            if (window->cursorMode == GLFW_CURSOR_DISABLED &&
                _glfw.focusedWindow == window)
            {
                updateClipRect(window);
            }
-            _glfwInputWindowPos(window, LOWORD(lParam), HIWORD(lParam));
+            // NOTE: This cannot use LOWORD/HIWORD recommended by MSDN, as
            // those macros do not handle negative window positions correctly
            _glfwInputWindowPos(window,
                                GET_X_LPARAM(lParam),
                                GET_Y_LPARAM(lParam));
            return 0;
        }
@@ -679,8 +713,8 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
        case WM_SETCURSOR:
        {
-            if (window->cursorMode == GLFW_CURSOR_HIDDEN &&
+            if (window->cursorMode != GLFW_CURSOR_NORMAL &&
-                window->win32.handle == GetForegroundWindow() &&
+                _glfw.focusedWindow == window &&
                LOWORD(lParam) == HTCLIENT)
            {
                SetCursor(NULL);
@@ -902,7 +936,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
        // 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
+        // full GLFW window destruction, it's duplicated here
        _glfwPlatformMakeContextCurrent(NULL);
        // Next destroy the Win32 window and WGL context (without resetting or
@@ -1000,7 +1034,7 @@ void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
        SetWindowPos(window->win32.handle, HWND_TOP,
                     0, 0, fullWidth, fullHeight,
-                     SWP_NOOWNERZORDER | SWP_NOMOVE | SWP_NOZORDER);
+                     SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOMOVE | SWP_NOZORDER);
    }
 }
@@ -1104,8 +1138,8 @@ void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos)
    ClientToScreen(window->win32.handle, &pos);
    SetCursorPos(pos.x, pos.y);
-    window->win32.oldCursorX = xpos;
+    window->win32.oldCursorX = (int) xpos;
-    window->win32.oldCursorY = ypos;
+    window->win32.oldCursorY = (int) ypos;
 }
 void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
@@ -129,7 +129,7 @@ void _glfwInputWindowDamage(_GLFWwindow* window)
 void _glfwInputWindowCloseRequest(_GLFWwindow* window)
 {
-        window->closed = GL_TRUE;
+    window->closed = GL_TRUE;
    if (window->callbacks.close)
        window->callbacks.close((GLFWwindow*) window);
@@ -213,10 +213,10 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
        window->videoMode.refreshRate = Max(_glfw.hints.refreshRate, 0);
    }
-    window->monitor     = wndconfig.monitor;
+    window->monitor    = wndconfig.monitor;
-    window->resizable   = wndconfig.resizable;
+    window->resizable  = wndconfig.resizable;
-    window->decorated   = wndconfig.decorated;
+    window->decorated  = wndconfig.decorated;
-    window->cursorMode  = GLFW_CURSOR_NORMAL;
+    window->cursorMode = GLFW_CURSOR_NORMAL;
    // Save the currently current context so it can be restored later
    previous = (_GLFWwindow*) glfwGetCurrentContext();
@@ -409,6 +409,8 @@ static void detectEWMH(void)
        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_PING");
    _glfw.x11.NET_ACTIVE_WINDOW =
        getSupportedAtom(supportedAtoms, atomCount, "_NET_ACTIVE_WINDOW");
    _glfw.x11.NET_WM_BYPASS_COMPOSITOR =
        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_BYPASS_COMPOSITOR");
    XFree(supportedAtoms);
@@ -680,7 +682,7 @@ void _glfwPlatformTerminate(void)
 const char* _glfwPlatformGetVersionString(void)
 {
-    const char* version = _GLFW_VERSION_FULL " X11"
+    const char* version = _GLFW_VERSION_NUMBER " X11"
 #if defined(_GLFW_GLX)
        " GLX"
 #elif defined(_GLFW_EGL)
@@ -125,15 +125,6 @@ static void pollJoystickEvents(void)
                case JS_EVENT_AXIS:
                    _glfw.x11.joystick[i].axes[e.number] =
                        (float) e.value / 32767.0f;
                    // We need to change the sign for the Y axes, so that
                    // positive = up/forward, according to the GLFW spec.
                    if (e.number & 1)
                    {
                        _glfw.x11.joystick[i].axes[e.number] =
                            -_glfw.x11.joystick[i].axes[e.number];
                    }
                    break;
                case JS_EVENT_BUTTON:
@@ -111,6 +111,9 @@ void _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
            }
        }
        if (bestMode == ci->mode)
            return;
        if (monitor->x11.oldMode == None)
            monitor->x11.oldMode = ci->mode;
@@ -117,6 +117,7 @@ typedef struct _GLFWlibraryX11
    Atom            NET_WM_PING;
    Atom            NET_WM_STATE;
    Atom            NET_WM_STATE_FULLSCREEN;
    Atom            NET_WM_BYPASS_COMPOSITOR;
    Atom            NET_ACTIVE_WINDOW;
    Atom            MOTIF_WM_HINTS;
@@ -129,13 +129,15 @@ static GLboolean createWindow(_GLFWwindow* window,
        if (wndconfig->monitor == NULL)
        {
            // HACK: This is a workaround for windows without a background pixel
-            // not getting any decorations on certain older versions of Compiz
+            //       not getting any decorations on certain older versions of
-            // running on Intel hardware
+            //       Compiz running on Intel hardware
            wa.background_pixel = BlackPixel(_glfw.x11.display,
                                             _glfw.x11.screen);
            wamask |= CWBackPixel;
        }
        _glfwGrabXErrorHandler();
        window->x11.handle = XCreateWindow(_glfw.x11.display,
                                           _glfw.x11.root,
                                           0, 0,
@@ -147,12 +149,12 @@ static GLboolean createWindow(_GLFWwindow* window,
                                           wamask,
                                           &wa);
        _glfwReleaseXErrorHandler();
        if (!window->x11.handle)
        {
-            // TODO: Handle all the various error codes here and translate them
+            _glfwInputXError(GLFW_PLATFORM_ERROR,
-            // to GLFW errors
+                             "X11: Failed to create window");
            _glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to create window");
            return GL_FALSE;
        }
@@ -203,13 +205,13 @@ static GLboolean createWindow(_GLFWwindow* window,
        // The WM_DELETE_WINDOW ICCCM protocol
        // Basic window close notification protocol
-        if (_glfw.x11.WM_DELETE_WINDOW != None)
+        if (_glfw.x11.WM_DELETE_WINDOW)
            protocols[count++] = _glfw.x11.WM_DELETE_WINDOW;
        // The _NET_WM_PING EWMH protocol
        // Tells the WM to ping the GLFW window and flag the application as
        // unresponsive if the WM doesn't get a reply within a few seconds
-        if (_glfw.x11.NET_WM_PING != None)
+        if (_glfw.x11.NET_WM_PING)
            protocols[count++] = _glfw.x11.NET_WM_PING;
        if (count > 0)
@@ -219,7 +221,7 @@ static GLboolean createWindow(_GLFWwindow* window,
        }
    }
-    if (_glfw.x11.NET_WM_PID != None)
+    if (_glfw.x11.NET_WM_PID)
    {
        const pid_t pid = getpid();
@@ -256,6 +258,14 @@ static GLboolean createWindow(_GLFWwindow* window,
            hints->flags |= PPosition;
            _glfwPlatformGetMonitorPos(wndconfig->monitor, &hints->x, &hints->y);
        }
        else
        {
            // HACK: Explicitly setting PPosition to any value causes some WMs,
            //       notably Compiz and Metacity, to honor the position of
            //       unmapped windows set by XMoveWindow
            hints->flags |= PPosition;
            hints->x = hints->y = 0;
        }
        if (!wndconfig->resizable)
        {
@@ -268,6 +278,19 @@ static GLboolean createWindow(_GLFWwindow* window,
        XFree(hints);
    }
    // Set ICCCM WM_CLASS property
    // HACK: Until a mechanism for specifying the application name is added, the
    //       initial window title is used as the window class name
    if (strlen(wndconfig->title))
    {
        XClassHint* hint = XAllocClassHint();
        hint->res_name = (char*) wndconfig->title;
        hint->res_class = (char*) wndconfig->title;
        XSetClassHint(_glfw.x11.display, window->x11.handle, hint);
        XFree(hint);
    }
    if (_glfw.x11.xi.available)
    {
        // Select for XInput2 events
@@ -376,15 +399,22 @@ static void enterFullscreenMode(_GLFWwindow* window)
    _glfwSetVideoMode(window->monitor, &window->videoMode);
-    if (_glfw.x11.hasEWMH &&
+    if (_glfw.x11.NET_WM_BYPASS_COMPOSITOR)
-        _glfw.x11.NET_WM_STATE != None &&
+    {
-        _glfw.x11.NET_WM_STATE_FULLSCREEN != None)
+        const unsigned long value = 1;
        XChangeProperty(_glfw.x11.display,  window->x11.handle,
                        _glfw.x11.NET_WM_BYPASS_COMPOSITOR, XA_CARDINAL, 32,
                        PropModeReplace, (unsigned char*) &value, 1);
    }
    if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_FULLSCREEN)
    {
        int x, y;
        _glfwPlatformGetMonitorPos(window->monitor, &x, &y);
        _glfwPlatformSetWindowPos(window, x, y);
-        if (_glfw.x11.NET_ACTIVE_WINDOW != None)
+        if (_glfw.x11.NET_ACTIVE_WINDOW)
        {
            // Ask the window manager to raise and focus the GLFW window
            // Only focused windows with the _NET_WM_STATE_FULLSCREEN state end
@@ -464,9 +494,16 @@ static void leaveFullscreenMode(_GLFWwindow* window)
                        _glfw.x11.saver.exposure);
    }
-    if (_glfw.x11.hasEWMH &&
+    if (_glfw.x11.NET_WM_BYPASS_COMPOSITOR)
-        _glfw.x11.NET_WM_STATE != None &&
+    {
-        _glfw.x11.NET_WM_STATE_FULLSCREEN != None)
+        const unsigned long value = 0;
        XChangeProperty(_glfw.x11.display,  window->x11.handle,
                        _glfw.x11.NET_WM_BYPASS_COMPOSITOR, XA_CARDINAL, 32,
                        PropModeReplace, (unsigned char*) &value, 1);
    }
    if (_glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_FULLSCREEN)
    {
        // Ask the window manager to make the GLFW window a normal window
        // Normal windows usually have frames and other decorations
@@ -694,7 +731,7 @@ static void processEvent(XEvent *event)
                _glfwInputWindowCloseRequest(window);
            }
-            else if (_glfw.x11.NET_WM_PING != None &&
+            else if (_glfw.x11.NET_WM_PING &&
                     (Atom) event->xclient.data.l[0] == _glfw.x11.NET_WM_PING)
            {
                // The window manager is pinging the application to ensure it's
@@ -976,7 +1013,7 @@ void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
                       NULL, NULL, NULL);
 #endif
-    if (_glfw.x11.NET_WM_NAME != None)
+    if (_glfw.x11.NET_WM_NAME)
    {
        XChangeProperty(_glfw.x11.display,  window->x11.handle,
                        _glfw.x11.NET_WM_NAME, _glfw.x11.UTF8_STRING, 8,
@@ -984,7 +1021,7 @@ void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
                        (unsigned char*) title, strlen(title));
    }
-    if (_glfw.x11.NET_WM_ICON_NAME != None)
+    if (_glfw.x11.NET_WM_ICON_NAME)
    {
        XChangeProperty(_glfw.x11.display,  window->x11.handle,
                        _glfw.x11.NET_WM_ICON_NAME, _glfw.x11.UTF8_STRING, 8,
@@ -1001,7 +1038,7 @@ void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos)
    XTranslateCoordinates(_glfw.x11.display, window->x11.handle, _glfw.x11.root,
                          0, 0, &x, &y, &child);
-    if (child != None)
+    if (child)
    {
        int left, top;
@@ -1082,6 +1119,9 @@ void _glfwPlatformIconifyWindow(_GLFWwindow* window)
    {
        // Override-redirect windows cannot be iconified or restored, as those
        // tasks are performed by the window manager
        _glfwInputError(GLFW_API_UNAVAILABLE,
                        "X11: Iconification of full screen windows requires "
                        "a WM that supports EWMH");
        return;
    }
@@ -1094,6 +1134,9 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window)
    {
        // Override-redirect windows cannot be iconified or restored, as those
        // tasks are performed by the window manager
        _glfwInputError(GLFW_API_UNAVAILABLE,
                        "X11: Iconification of full screen windows requires "
                        "a WM that supports EWMH");
        return;
    }
@@ -1135,10 +1178,8 @@ void _glfwPlatformWaitEvents(void)
 {
    if (!XPending(_glfw.x11.display))
    {
        int fd;
        fd_set fds;
-
+        const int fd = ConnectionNumber(_glfw.x11.display);
        fd = ConnectionNumber(_glfw.x11.display);
        FD_ZERO(&fds);
        FD_SET(fd, &fds);
@@ -23,7 +23,7 @@ set(TINYCTHREAD ${GLFW_SOURCE_DIR}/deps/tinycthread.h
 add_executable(clipboard clipboard.c ${GETOPT})
 add_executable(defaults defaults.c)
-add_executable(events events.c)
+add_executable(events events.c ${GETOPT})
 add_executable(fsaa fsaa.c ${GETOPT})
 add_executable(gamma gamma.c ${GETOPT})
 add_executable(glfwinfo glfwinfo.c ${GETOPT})
@@ -39,6 +39,8 @@
 #include <string.h>
 #include <locale.h>
 #include "getopt.h"
 // These must match the input mode defaults
 static GLboolean closeable = GL_TRUE;
@@ -226,12 +228,12 @@ static const char* get_mods_name(int mods)
    return name;
 }
-static const char* get_character_string(int character)
+static const char* get_character_string(int codepoint)
 {
    // This assumes UTF-8, which is stupid
    static char result[6 + 1];
-    int length = wctomb(result, character);
+    int length = wctomb(result, codepoint);
    if (length == -1)
        length = 0;
@@ -370,13 +372,13 @@ static void key_callback(GLFWwindow* window, int key, int scancode, int action,
    }
 }
-static void char_callback(GLFWwindow* window, unsigned int character)
+static void char_callback(GLFWwindow* window, unsigned int codepoint)
 {
    printf("%08x at %0.3f: Character 0x%08x (%s) input\n",
           counter++,
           glfwGetTime(),
-           character,
+           codepoint,
-           get_character_string(character));
+           get_character_string(codepoint));
 }
 void monitor_callback(GLFWmonitor* monitor, int event)
@@ -406,10 +408,11 @@ void monitor_callback(GLFWmonitor* monitor, int event)
    }
 }
-int main(void)
+int main(int argc, char** argv)
 {
    GLFWwindow* window;
-    int width, height;
+    GLFWmonitor* monitor = NULL;
    int ch, width, height;
    setlocale(LC_ALL, "");
@@ -420,7 +423,17 @@ int main(void)
    printf("Library initialized\n");
-    window = glfwCreateWindow(640, 480, "Event Linter", NULL, NULL);
+    while ((ch = getopt(argc, argv, "f")) != -1)
    {
        switch (ch)
        {
            case 'f':
                monitor = glfwGetPrimaryMonitor();
                break;
        }
    }
    window = glfwCreateWindow(640, 480, "Event Linter", monitor, NULL);
    if (!window)
    {
        glfwTerminate();
@@ -54,9 +54,16 @@
 static void usage(void)
 {
    printf("Usage: glfwinfo [-h] [-a API] [-m MAJOR] [-n MINOR] [-d] [-l] [-f] [-p PROFILE] [-r STRATEGY]\n");
-    printf("available APIs: " API_OPENGL " " API_OPENGL_ES "\n");
+    printf("Options:\n");
-    printf("available profiles: " PROFILE_NAME_CORE " " PROFILE_NAME_COMPAT "\n");
+    printf("  -a the client API to use (" API_OPENGL " or " API_OPENGL_ES ")\n");
-    printf("available strategies: " STRATEGY_NAME_NONE " " STRATEGY_NAME_LOSE "\n");
+    printf("  -d request a debug context\n");
    printf("  -f require a forward-compatible context\n");
    printf("  -h show this help\n");
    printf("  -l list all client API extensions after context creation\n");
    printf("  -m the major number of the requred client API version\n");
    printf("  -n the minor number of the requred client API version\n");
    printf("  -p the OpenGL profile to use (" PROFILE_NAME_CORE " or " PROFILE_NAME_COMPAT ")\n");
    printf("  -r the robustness strategy to use (" STRATEGY_NAME_NONE " or " STRATEGY_NAME_LOSE ")\n");
 }
 static void error_callback(int error, const char* description)
@@ -186,9 +193,6 @@ int main(int argc, char** argv)
    GLint flags, mask;
    GLFWwindow* window;
    if (!valid_version())
        exit(EXIT_FAILURE);
    while ((ch = getopt(argc, argv, "a:dfhlm:n:p:r:")) != -1)
    {
        switch (ch)
@@ -249,11 +253,11 @@ int main(int argc, char** argv)
        }
    }
    argc -= optind;
    argv += optind;
    // Initialize GLFW and create window
    if (!valid_version())
        exit(EXIT_FAILURE);
    glfwSetErrorCallback(error_callback);
    if (!glfwInit())
@@ -64,43 +64,47 @@ static void framebuffer_size_callback(GLFWwindow* window, int width, int height)
 static void draw_joystick(Joystick* j, int x, int y, int width, int height)
 {
    int i;
-    int axis_width, axis_height;
+    const int axis_height = 3 * height / 4;
-    int button_width, button_height;
+    const int button_height = height / 4;
-    axis_width = width / j->axis_count;
+    if (j->axis_count)
    axis_height = 3 * height / 4;
    button_width = width / j->button_count;
    button_height = height / 4;
    for (i = 0;  i < j->axis_count;  i++)
    {
-        float value = j->axes[i] / 2.f + 0.5f;
+        const int axis_width = width / j->axis_count;
-        glColor3f(0.3f, 0.3f, 0.3f);
+        for (i = 0;  i < j->axis_count;  i++)
-        glRecti(x + i * axis_width,
+        {
-                y,
+            float value = j->axes[i] / 2.f + 0.5f;
                x + (i + 1) * axis_width,
                y + axis_height);
-        glColor3f(1.f, 1.f, 1.f);
+            glColor3f(0.3f, 0.3f, 0.3f);
-        glRecti(x + i * axis_width,
+            glRecti(x + i * axis_width,
-                y + (int) (value * (axis_height - 5)),
+                    y,
-                x + (i + 1) * axis_width,
+                    x + (i + 1) * axis_width,
-                y + 5 + (int) (value * (axis_height - 5)));
+                    y + axis_height);
            glColor3f(1.f, 1.f, 1.f);
            glRecti(x + i * axis_width,
                    y + (int) (value * (axis_height - 5)),
                    x + (i + 1) * axis_width,
                    y + 5 + (int) (value * (axis_height - 5)));
        }
    }
-    for (i = 0;  i < j->button_count;  i++)
+    if (j->button_count)
    {
-        if (j->buttons[i])
+        const int button_width = width / j->button_count;
            glColor3f(1.f, 1.f, 1.f);
        else
            glColor3f(0.3f, 0.3f, 0.3f);
-        glRecti(x + i * button_width,
+        for (i = 0;  i < j->button_count;  i++)
-                y + axis_height,
+        {
-                x + (i + 1) * button_width,
+            if (j->buttons[i])
-                y + axis_height + button_height);
+                glColor3f(1.f, 1.f, 1.f);
            else
                glColor3f(0.3f, 0.3f, 0.3f);
            glRecti(x + i * button_width,
                    y + axis_height,
                    x + (i + 1) * button_width,
                    y + axis_height + button_height);
        }
    }
 }
@@ -218,9 +218,6 @@ int main(int argc, char** argv)
        }
    }
    argc -= optind;
    argv += optind;
    glfwSetErrorCallback(error_callback);
    if (!glfwInit())
@@ -35,7 +35,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 #include <assert.h>
 typedef struct
 {
@@ -57,8 +56,6 @@ static int thread_main(void* data)
    const Thread* thread = (const Thread*) data;
    glfwMakeContextCurrent(thread->window);
    assert(glfwGetCurrentContext() == thread->window);
    glfwSwapInterval(1);
    while (running)
@@ -118,8 +115,6 @@ int main(void)
    while (running)
    {
        assert(glfwGetCurrentContext() == NULL);
        glfwWaitEvents();
        for (i = 0;  i < count;  i++)
Author	SHA1	Message	Date
Camilla Berglund	eab31f228f	Added description of 3.0.4 release.	2013-12-31 20:06:18 +01:00
Camilla Berglund	d937b74b8f	Fixed glfwSetWindowSize stealing focus.	2013-12-28 20:56:57 +01:00
Camilla Berglund	0e8dace18c	Removed stray whitespace in version string.	2013-12-24 00:48:28 +01:00
Camilla Berglund	b17bed28c8	Added note on gdi32 as non-defaultlib on MinGW. Some versions of MinGW do not include gdi32 among the default libraries for Win32 subsystem binaries.	2013-12-23 00:53:04 +01:00
Camilla Berglund	4eea3175f1	Re-worded OS X context creation limits.	2013-12-18 12:42:05 +01:00
Camilla Berglund	cf458fa7a2	Formatting.	2013-12-11 14:41:51 +01:00
Camilla Berglund	8ac7cab100	Added notes on API headers.	2013-12-11 14:38:27 +01:00
Camilla Berglund	0108a6bdeb	Added credit.	2013-12-10 13:45:21 +01:00
Camilla Berglund	402189ba14	Fixed pthread.h not included by GLX header.	2013-12-10 00:47:19 +01:00
Camilla Berglund	61ccb034d0	Formatting.	2013-12-09 00:27:36 +01:00
Camilla Berglund	50c694fab4	Added errors for override redirect iconification.	2013-12-08 14:59:52 +01:00
Camilla Berglund	a18b187494	Expanded cursor mode descriptions.	2013-12-05 03:27:12 +01:00
Camilla Berglund	5668eb0732	Added paragraph on object sharing.	2013-12-05 03:17:45 +01:00
Camilla Berglund	56e600d7a1	Fixed iconify callback not triggered by Alt+Tab.	2013-12-05 02:19:41 +01:00
Camilla Berglund	2ae46fa90a	Added notes on window refresh.	2013-12-04 19:14:33 +01:00
Camilla Berglund	0c0bb28d39	Allow setting swap interval to zero on DWM.	2013-12-04 08:00:53 +01:00
Camilla Berglund	ed98e06651	Clarified WGL missing OpenGL error.	2013-12-04 05:35:36 +01:00
Camilla Berglund	06289110e7	Documented utility functions.	2013-11-24 23:31:26 +01:00
Camilla Berglund	8443848637	Updated swap interval notes.	2013-11-24 23:31:15 +01:00
Camilla Berglund	823cc38ac1	Cleanup.	2013-11-20 20:04:00 +01:00
Camilla Berglund	5ef4f77fb5	Added support for _NET_WM_BYPASS_COMPOSITOR.	2013-11-20 19:59:17 +01:00
Camilla Berglund	e0ee90d50c	Fixed news item tag name.	2013-11-20 15:37:08 +01:00
Camilla Berglund	171538d01c	Grammar fix.	2013-11-20 15:33:40 +01:00
Camilla Berglund	c21745c886	Added reference to manual compilation guide.	2013-11-20 15:28:30 +01:00
Camilla Berglund	2db0401a57	Removed excuse.	2013-11-20 15:08:53 +01:00
Camilla Berglund	9979da59e3	Manual compilation guide work.	2013-11-20 14:37:04 +01:00
Camilla Berglund	8b1b322771	Added manual compilation guide.	2013-11-20 14:27:05 +01:00
Camilla Berglund	0ccbddf767	Moved version number macro to internal.h. This lets alternative build environments avoid having to manually keep track of which version of GLFW is being built.	2013-11-20 13:58:57 +01:00
Camilla Berglund	23021422f3	Added explicit configuration header macro.	2013-11-20 12:06:07 +01:00
Camilla Berglund	bb3f29d8bc	Added note on profile detection.	2013-11-19 17:57:08 +01:00
Camilla Berglund	87e6417353	Added hack detecting ARB_compatibility.	2013-11-18 12:14:51 +01:00
Camilla Berglund	95c7029e19	Formatting.	2013-11-18 12:06:39 +01:00
Camilla Berglund	45368f410a	Fixed warnings from Clang static analysis.	2013-11-14 13:42:29 +01:00
Camilla Berglund	a79b93f5bc	Avoid X11 video mode setting if modes match. This matches the behavior of the Windows port.	2013-11-14 12:59:08 +01:00
Camilla Berglund	4fe88a52fa	Added credit.	2013-11-13 12:59:49 +01:00
Camilla Berglund	a5b6a306ae	Added note.	2013-11-13 12:47:44 +01:00
Camilla Berglund	109e3d13ed	Fixed reporting of negative window positions. MSDN recommends LOWORD and HIWORD for WM_MOVE, but these do not handle negative window positions correctly. Fixes #172.	2013-11-13 12:39:41 +01:00
Camilla Berglund	7af99bce88	Fixed cursor centering for odd window sizes.	2013-11-13 12:39:40 +01:00
Camilla Berglund	d82095d7ea	Changed from PREFIX to CMAKE_INSTALL_PREFIX.	2013-11-10 15:43:25 +01:00
Camilla Berglund	76afd41727	Added X error reporting to window creation failure.	2013-11-10 14:12:07 +01:00
Camilla Berglund	bc625b21b3	Removed completed todo.	2013-11-10 14:03:34 +01:00
Camilla Berglund	adbd52ba27	Formatted todos and notes.	2013-11-10 14:03:07 +01:00
Camilla Berglund	b9d4875f3e	Improved documentation of hacks.	2013-11-10 13:56:27 +01:00
Camilla Berglund	a79c844c4d	Oh dear.	2013-11-10 03:31:10 +01:00
Camilla Berglund	b13c84f854	Removed joystick axis value negation on OS X.	2013-11-07 20:45:29 +01:00
Camilla Berglund	b410cff68c	Updated change log.	2013-11-07 20:36:45 +01:00
Camilla Berglund	4013f733fe	Reverted change of IOKit functions. The previously used set of functions caused a regression where no axes or buttons were reported. Fixes #78.	2013-11-07 20:19:30 +01:00
Camilla Berglund	cc4c7167fd	Fixed joysticks test segfault.	2013-11-07 19:29:33 +01:00
Camilla Berglund	6c12ffc902	Added the GLFW_BUILD_DOCS CMake option.	2013-11-07 18:23:54 +01:00
Camilla Berglund	a83d257ac6	Moved application activation to window showing. Fixes #93.	2013-11-07 18:07:46 +01:00
Camilla Berglund	ec5cb9c6f7	Moved to Cocoa for transformation and activation.	2013-11-07 18:03:39 +01:00
Camilla Berglund	e7c7ebf665	Added workaround for 10.9 SDK type definitions.	2013-11-07 17:20:06 +01:00
Camilla Berglund	cc7f0bd532	Fixed crash retrieving the name of some displays.	2013-11-07 16:28:07 +01:00
Camilla Berglund	97ae40496d	Added reporting of extension string retrieval failure.	2013-11-07 15:17:25 +01:00
Camilla Berglund	e4a87b8a1c	Added Compiz to bug fix entry.	2013-11-03 16:08:35 +01:00
Camilla Berglund	f18aef4aec	Removed fixed @bug.	2013-11-03 14:17:03 +01:00
Camilla Berglund	1cbd06c8a2	Fixed hidden window positioning on Metacity.	2013-11-03 13:51:34 +01:00
Camilla Berglund	785e68bb0d	Added flag descriptions to glfwinfo -h.	2013-11-03 13:38:45 +01:00
Camilla Berglund	86e50b1044	Placed glfwinfo version test after getopt.	2013-11-03 13:29:21 +01:00
Camilla Berglund	eabbb20d17	Added NULL test for glGetStringi.	2013-11-01 13:55:33 +01:00
Camilla Berglund	0153dab346	Clarified WGL re-creation comment.	2013-10-28 14:50:33 +01:00
Camilla Berglund	1a4ffa497a	Added credit.	2013-10-28 13:22:34 +01:00
Camilla Berglund	58045a5c07	Added Lion full scren menu item.	2013-10-28 13:01:58 +01:00
Camilla Berglund	7d1ae7aea7	Cleaned up Win32 timer.	2013-10-28 12:14:50 +01:00
Camilla Berglund	174c72f2c0	Moved GLFW compilation guide to docs.	2013-10-27 12:53:50 +01:00
Camilla Berglund	b9fb45f408	Documentation updates.	2013-10-27 11:03:47 +01:00
Camilla Berglund	9c4b925a96	Updated extension headers.	2013-10-27 09:45:15 +01:00
Camilla Berglund	394c44ccf9	More words on window closing.	2013-10-25 15:55:24 +02:00
Camilla Berglund	baf100f78c	Merge pull request #159 from metajack/fix-10-7-build Fixed build on OS X 10.7.	2013-10-24 01:31:29 -07:00
Jack Moffitt	5be45d214b	Fix build on Mac OS X 10.7 Lion. `CVDisplayLinkRef` needs an extra header file, and `NSAppKitVersionNumber10_7` wasn't added until 10.8so use `> NSAppKitVersionNumber10_6` instead.	2013-10-24 02:24:34 -06:00
Camilla Berglund	e309a784d1	Documentation work.	2013-10-21 22:39:51 +02:00
Camilla Berglund	99f40ede1b	Documentation work.	2013-10-21 22:35:22 +02:00
Camilla Berglund	db8e6bed7a	Cross-linked build guides.	2013-10-21 22:23:15 +02:00
Camilla Berglund	6172e2cfcc	Fixed change log entry.	2013-10-21 17:46:05 +02:00
Camilla Berglund	bc8ff545ca	Fixed mode enumeration for Thunderbolt monitors.	2013-10-17 20:43:39 +02:00
Camilla Berglund	e576bdc894	Removed joystick axis value negation.	2013-10-17 20:09:00 +02:00
Camilla Berglund	d78510457c	Added hack for full screen focus on OS X.	2013-10-17 19:59:34 +02:00
Camilla Berglund	dbdf01d4a0	Added getopt dependency to events text.	2013-10-17 15:35:01 +02:00
Camilla Berglund	7ef7beb9fb	Formatting.	2013-10-17 15:16:27 +02:00
Camilla Berglund	16e63adc40	Tenative setting of install_name.	2013-10-16 20:56:59 +02:00
Camilla Berglund	e85455719d	Point made.	2013-10-16 20:33:28 +02:00
Camilla Berglund	23ff318f59	Replaced find_library with CMAKE_DL_LIBS.	2013-10-13 16:24:33 +02:00
Camilla Berglund	0041699048	Fixed glfw3.pc not using LIB_SUFFIX.	2013-10-12 20:22:48 +02:00
Camilla Berglund	a5df39e14f	Added section on user pointer to window guide.	2013-10-12 20:00:16 +02:00
Camilla Berglund	4175c9edea	Merge pull request #155 from siavashserver/master Fixed page header background image location.	2013-10-12 10:20:40 -07:00
siavash	1695fd08f0	Fixed page header background image location.	2013-10-11 23:11:11 +03:30
Camilla Berglund	2c920fbb8b	Clarified character callback parameter.	2013-10-10 19:41:56 +02:00
Camilla Berglund	7dd8770e6f	Added full screen option to events test.	2013-10-10 00:17:53 +02:00
Camilla Berglund	9c15e2ff86	Enabled Lion full screen.	2013-10-10 00:09:03 +02:00
Camilla Berglund	7775c87cd6	Cleanup and change log update.	2013-10-09 23:58:43 +02:00
Camilla Berglund	1047d5646d	Merge pull request #139 from Pieroman/patch-1 Fixed full screen windows blanking unused monitors.	2013-10-09 14:47:41 -07:00
Camilla Berglund	fa765ee719	Removed DOS line breaks.	2013-10-09 21:35:35 +02:00
Camilla Berglund	50850602b2	Clarified change log entries.	2013-10-09 21:12:03 +02:00
Camilla Berglund	553cc8ac96	Clarified change log entry.	2013-10-09 20:24:57 +02:00
Camilla Berglund	f2a04a56a4	Added CoreVideo dependency to change log.	2013-10-09 20:23:20 +02:00
Camilla Berglund	a8ff81fd8a	Updated .gitignore.	2013-10-09 19:46:44 +02:00
Camilla Berglund	aab08712dd	Fixed zero refresh rate on some monitors.	2013-10-09 19:45:39 +02:00
Andri Pálsson	99784fb8f0	Fixed hidden cursor positioning corner case.	2013-10-09 19:06:03 +02:00
Camilla Berglund	0e7c6e1d82	Updated change log.	2013-10-09 11:58:08 +02:00
Camilla Berglund	4e3c990656	Updated change log.	2013-10-08 19:45:17 +02:00
Camilla Berglund	e9694cca47	Merge pull request #152 from sjml/master Fixed minor Xcode 5 warnings.	2013-10-08 10:43:55 -07:00
Shane Liesegang	9e0c07b7ba	Fixing Xcode 5 warning Xcode 5 has gotten more pedantic about undeclared selectors, by default.	2013-10-08 10:49:00 -04:00
Shane Liesegang	209de7b56d	Removing warnings when building Cocoa in 64-bit NSInteger is defined as the native integer width, so these changes remove implicit conversions that were causing precision warnings.	2013-10-08 10:42:17 -04:00
Camilla Berglund	16a8fafab2	Made disabled mode disable Win32 cursor image.	2013-10-07 16:28:19 +02:00
Camilla Berglund	6e68d89e0f	Fixed focus for Win+D window restoration.	2013-10-07 16:12:23 +02:00
Camilla Berglund	9c5d9f8614	Fixed clip rect being set for unfocused windows.	2013-10-07 15:30:57 +02:00
Camilla Berglund	161065ac19	Clarified configuration header comments.	2013-10-06 11:45:28 +02:00
Camilla Berglund	2053767709	Added credit.	2013-10-06 11:37:16 +02:00
Camilla Berglund	55530dbd14	Merge pull request #149 from andrewcorrigan/master Added glfw_ prefix to configuration header.	2013-10-04 08:47:29 -07:00
Camilla Berglund	12f0d8d4ca	Build documentation grammar fix.	2013-10-04 17:08:04 +02:00
Andrew Corrigan	34f1c298b6	config.h.in --> glfw_config.h.in	2013-10-04 09:41:08 -04:00
Camilla Berglund	8194f1e2ae	Added hack for setting WM_CLASS.	2013-10-04 13:41:19 +02:00
Camilla Berglund	a7af3b2c8f	Put GLFW_CLIENT_LIBRARY into correct section.	2013-10-04 13:13:16 +02:00
Camilla Berglund	6d9d85670f	Clarified unit of cursor positions.	2013-09-28 22:12:50 +02:00
Camilla Berglund	521fa7d005	Added crossrefs for window and fb size.	2013-09-26 20:02:19 +02:00
Camilla Berglund	5759d0fdf2	Fixed F13 being reported as PrtSc on OS X.	2013-09-26 19:58:35 +02:00
Camilla Berglund	07db5daa61	Added note on GDI software OpenGL.	2013-09-26 19:15:45 +02:00
Camilla Berglund	201d0a78b1	Fixed Grave and World 1 being flipped.	2013-09-26 00:00:07 +02:00
Camilla Berglund	1f6696d433	Added references to build guide.	2013-09-24 22:17:35 +02:00
Camilla Berglund	59422ec980	Started 3.0.4.	2013-09-24 21:36:11 +02:00
Camilla Berglund	fd3813f0d9	Updated notes referring to Mac OS X.	2013-09-24 21:34:46 +02:00
Camilla Berglund	25eb8dc277	Removed index.html from URL.	2013-09-24 21:32:21 +02:00
Camilla Berglund	ebe38eedd8	Merge pull request #141 from siavashserver/doxygen-theme Added Doxygen documentation theme.	2013-09-21 12:49:41 -07:00
siavash	96c5aea3ba	Removed invisible element.	2013-09-21 15:18:49 +04:30
siavash	cca61d752d	New theme for doxygen generated documentations.	2013-09-21 15:14:37 +04:30
Camilla Berglund	6af51e049f	Added more detailed notes on some CMake options.	2013-09-19 22:24:03 +02:00
Camilla Berglund	3af1c411ca	Added notes on swap interval defaults.	2013-09-19 21:37:01 +02:00
Pieroman	d3f22b8a04	Fixed Mac OS X bug where request for one fullscreen window blacks out other monitors	2013-09-19 21:33:44 +02:00