Made release description match website.

Fixed error code for missing GLES.
Fixed potential segfault on init.
2026-09-17 14:22:50 +00:00 · 2013-08-25 21:40:06 +02:00 · 2013-08-21 11:56:48 +02:00 · 2013-08-21 10:15:52 +02:00 · 2013-08-20 12:46:32 +02:00 · 2013-08-19 13:08:35 +02:00
62 changed files with 11521 additions and 13357 deletions
@@ -38,6 +38,7 @@ src/libglfw3.a
 src/glfw3.lib
 src/glfw3.dll
 src/glfw3dll.lib
+src/glfw3dll.a
 examples/*.app
 examples/*.exe
 examples/boing
@@ -1,18 +0,0 @@
-This directory contains a collection of toolchain definitions for
-cross-compiling for Windows using MinGW on various other systems.
-
-To use these files you add a special parameter when configuring the source tree:
-
-  cmake -DCMAKE_TOOLCHAIN_FILE=<toolchain-file> .
-
-The exact file to use depends on the prefix used by the MinGW binaries on your
-system.  You can usually see this in the /usr directory, i.e. the Ubuntu
-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 this article:
-
-  http://www.paraview.org/Wiki/CMake_Cross_Compiling 
-
@@ -4,32 +4,39 @@ cmake_minimum_required(VERSION 2.8)

 set(GLFW_VERSION_MAJOR "3")
 set(GLFW_VERSION_MINOR "0")
-set(GLFW_VERSION_PATCH "1")
+set(GLFW_VERSION_PATCH "2")
 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}")
 set(LIB_SUFFIX "" CACHE STRING "Takes an empty string or 64. Directory where lib will be installed: lib or lib64")

+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(BUILD_SHARED_LIBS "Build shared libraries" OFF)
 option(GLFW_INSTALL "Generate installation target" ON)
-
-set(DOXYGEN_SKIP_DOT TRUE)
-find_package(Doxygen)
-
 option(GLFW_DOCUMENT_INTERNALS "Include internals in documentation" OFF)
-if (GLFW_DOCUMENT_INTERNALS)
-    set(GLFW_INTERNAL_DOCS "${GLFW_SOURCE_DIR}/src/internal.h ${GLFW_SOURCE_DIR}/docs/internal.dox")
+
+if (WIN32)
+    option(GLFW_USE_DWM_SWAP_INTERVAL "Set swap interval even when DWM compositing is enabled" OFF)
+    option(GLFW_USE_OPTIMUS_HPG "Force use of high-performance GPU on Optimus systems" OFF)
 endif()

 if (APPLE)
+    option(GLFW_BUILD_UNIVERSAL "Build GLFW as a Universal Binary" OFF)
    option(GLFW_USE_CHDIR "Make glfwInit chdir to Contents/Resources" ON)
    option(GLFW_USE_MENUBAR "Populate the menu bar on first window creation" ON)
 else()
    option(GLFW_USE_EGL "Use EGL for context creation" OFF)
 endif()

+if (MSVC)
+    option(USE_MSVC_RUNTIME_LIBRARY_DLL "Use MSVC runtime library DLL" ON)
+endif()
+
+if (BUILD_SHARED_LIBS)
+    set(_GLFW_BUILD_DLL 1)
+endif()
+
 if (GLFW_USE_EGL)
    set(GLFW_CLIENT_LIBRARY "opengl" CACHE STRING
        "The client library to use; one of opengl, glesv1 or glesv2")
@@ -66,23 +73,45 @@ endif()

 find_package(Threads REQUIRED)

-#--------------------------------------------------------------------
-# Enable all warnings on GCC, regardless of OS
-#--------------------------------------------------------------------
-if (CMAKE_COMPILER_IS_GNUCC)
-    add_definitions(-Wall)
+set(DOXYGEN_SKIP_DOT TRUE)
+find_package(Doxygen)
+
+if (GLFW_DOCUMENT_INTERNALS)
+    set(GLFW_INTERNAL_DOCS "${GLFW_SOURCE_DIR}/src/internal.h ${GLFW_SOURCE_DIR}/docs/internal.dox")
 endif()

 #--------------------------------------------------------------------
-# Export shared library / dynamic library / DLL build option
+# Set compiler specific flags
 #--------------------------------------------------------------------
-if (BUILD_SHARED_LIBS)
-    set(_GLFW_BUILD_DLL 1)
-    if (UNIX)
+if (UNIX)
+    add_definitions(-Wall)
+
+    if (BUILD_SHARED_LIBS)
        add_definitions(-fvisibility=hidden)
    endif()
 endif()

+if (MSVC)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+
+    if (NOT USE_MSVC_RUNTIME_LIBRARY_DLL)
+        foreach (flag CMAKE_C_FLAGS
+                        CMAKE_C_FLAGS_DEBUG
+                        CMAKE_C_FLAGS_RELEASE
+                        CMAKE_C_FLAGS_MINSIZEREL
+                        CMAKE_C_FLAGS_RELWITHDEBINFO)
+
+            if (${flag} MATCHES "/MD")
+                string(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
+            endif()
+            if (${flag} MATCHES "/MDd")
+                string(REGEX REPLACE "/MDd" "/MTd" ${flag} "${${flag}}")
+            endif()
+
+        endforeach()
+    endif()
+endif()
+
 #--------------------------------------------------------------------
 # Detect and select backend APIs
 #--------------------------------------------------------------------
@@ -121,32 +150,18 @@ endif()
 # Use Win32 for window creation
 #--------------------------------------------------------------------
 if (_GLFW_WIN32)
-
-    if (MSVC)
-        option(USE_MSVC_RUNTIME_LIBRARY_DLL "Use MSVC runtime library DLL" ON)
-
-        if (NOT USE_MSVC_RUNTIME_LIBRARY_DLL)
-            foreach (flag CMAKE_C_FLAGS
-                          CMAKE_C_FLAGS_DEBUG
-                          CMAKE_C_FLAGS_RELEASE
-                          CMAKE_C_FLAGS_MINSIZEREL
-                          CMAKE_C_FLAGS_RELWITHDEBINFO)
-
-                if (${flag} MATCHES "/MD")
-                    string(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
-                endif()
-                if (${flag} MATCHES "/MDd")
-                    string(REGEX REPLACE "/MDd" "/MTd" ${flag} "${${flag}}")
-                endif()
-
-            endforeach()
-        endif()
+    # The DLL links against winmm; the static library loads it
+    # That way, both code paths receive testing
+    if (BUILD_SHARED_LIBS)
+        set(_GLFW_NO_DLOAD_WINMM 1)
+        list(APPEND glfw_LIBRARIES winmm)
    endif()

-    set(_GLFW_NO_DLOAD_WINMM ${BUILD_SHARED_LIBS})
-
-    if (BUILD_SHARED_LIBS)
-        list(APPEND glfw_LIBRARIES winmm)
+    if (GLFW_USE_DWM_SWAP_INTERVAL)
+        set(_GLFW_USE_DWM_SWAP_INTERVAL 1)
+    endif()
+    if (GLFW_USE_OPTIMUS_HPG)
+        set(_GLFW_USE_OPTIMUS_HPG 1)
    endif()
 endif()

@@ -243,16 +258,9 @@ if (_GLFW_GLX)
    include(CheckFunctionExists)

    set(CMAKE_REQUIRED_LIBRARIES ${OPENGL_gl_LIBRARY})
-
    check_function_exists(glXGetProcAddress _GLFW_HAS_GLXGETPROCADDRESS)
-
-    if (NOT _GLFW_HAS_GLXGETPROCADDRESS)
-        check_function_exists(glXGetProcAddressARB _GLFW_HAS_GLXGETPROCADDRESSARB)
-    endif()
-
-    if (NOT _GLFW_HAS_GLXGETPROCADDRESS AND NOT _GLFW_HAS_GLXGETPROCADDRESSARB)
-        check_function_exists(glXGetProcAddressEXT _GLFW_HAS_GLXGETPROCADDRESSEXT)
-    endif()
+    check_function_exists(glXGetProcAddressARB _GLFW_HAS_GLXGETPROCADDRESSARB)
+    check_function_exists(glXGetProcAddressEXT _GLFW_HAS_GLXGETPROCADDRESSEXT)

    if (NOT _GLFW_HAS_GLXGETPROCADDRESS AND
        NOT _GLFW_HAS_GLXGETPROCADDRESSARB AND
@@ -291,8 +299,6 @@ if (_GLFW_EGL)
    list(APPEND glfw_INCLUDE_DIRS ${EGL_INCLUDE_DIR})
    list(APPEND glfw_LIBRARIES ${EGL_LIBRARY})

-    set(CMAKE_REQUIRED_LIBRARIES ${EGL_LIBRARY})
-
    if (UNIX)
        set(GLFW_PKG_DEPS "${GLFW_PKG_DEPS} egl")
    endif()
@@ -318,8 +324,6 @@ endif()
 #--------------------------------------------------------------------
 if (_GLFW_COCOA AND _GLFW_NSGL)
        
-    option(GLFW_BUILD_UNIVERSAL "Build GLFW as a Universal Binary" OFF)
-
    if (GLFW_USE_MENUBAR)
        set(_GLFW_USE_MENUBAR 1)
    endif()
@@ -328,7 +332,6 @@ if (_GLFW_COCOA AND _GLFW_NSGL)
        set(_GLFW_USE_CHDIR 1)
    endif()

-    # Universal build
    if (GLFW_BUILD_UNIVERSAL)
        message(STATUS "Building GLFW as Universal Binaries")
        set(CMAKE_OSX_ARCHITECTURES i386;x86_64)
@@ -364,23 +367,6 @@ else()
    set(GLFW_LIB_NAME glfw3)
 endif()

-#--------------------------------------------------------------------
-# Add subdirectories
-#--------------------------------------------------------------------
-add_subdirectory(src)
-
-if (GLFW_BUILD_EXAMPLES)
-    add_subdirectory(examples)
-endif()
-
-if (GLFW_BUILD_TESTS)
-    add_subdirectory(tests)
-endif()
-
-if (DOXYGEN_FOUND)
-    add_subdirectory(docs)
-endif()
-
 #--------------------------------------------------------------------
 # Create generated files
 #--------------------------------------------------------------------
@@ -402,7 +388,24 @@ if (UNIX)
 endif()

 #--------------------------------------------------------------------
-# Install files
+# Add subdirectories
+#--------------------------------------------------------------------
+add_subdirectory(src)
+
+if (GLFW_BUILD_EXAMPLES)
+    add_subdirectory(examples)
+endif()
+
+if (GLFW_BUILD_TESTS)
+    add_subdirectory(tests)
+endif()
+
+if (DOXYGEN_FOUND)
+    add_subdirectory(docs)
+endif()
+
+#--------------------------------------------------------------------
+# Install files other than the library
 # The library is installed by src/CMakeLists.txt
 #--------------------------------------------------------------------
 if (GLFW_INSTALL)
@@ -418,18 +421,15 @@ if (GLFW_INSTALL)
        install(FILES ${GLFW_BINARY_DIR}/src/glfw3.pc
                DESTINATION lib${LIB_SUFFIX}/pkgconfig)
    endif()
-endif()
-
-#--------------------------------------------------------------------
-# Uninstall operation
-# Don't generate this target if a higher-level project already has
-#--------------------------------------------------------------------
-if (GLFW_INSTALL AND NOT TARGET uninstall)
-    configure_file(${GLFW_SOURCE_DIR}/cmake_uninstall.cmake.in
-                   ${GLFW_BINARY_DIR}/cmake_uninstall.cmake IMMEDIATE @ONLY)
-
-    add_custom_target(uninstall
-                      ${CMAKE_COMMAND} -P
-                      ${GLFW_BINARY_DIR}/cmake_uninstall.cmake)
+
+    # Only generate this target if no higher-level project already has
+    if (NOT TARGET uninstall)
+        configure_file(${GLFW_SOURCE_DIR}/cmake_uninstall.cmake.in
+                       ${GLFW_BINARY_DIR}/cmake_uninstall.cmake IMMEDIATE @ONLY)
+
+        add_custom_target(uninstall
+                          ${CMAKE_COMMAND} -P
+                          ${GLFW_BINARY_DIR}/cmake_uninstall.cmake)
+    endif()
 endif()

@@ -6,40 +6,137 @@ 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.1 adds fixes for a number of bugs that together affect all supported
-platforms.  As this is a patch release, there are no API changes.
+Version 3.0.2 adds support for OpenGL 4 on and precise scrolling deltas on OS
+X and fixes for a number of bugs that together affect all supported platforms.
+As this is 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/3.0/quick.html) for GLFW
-3 useful.  If
-you have used GLFW 2 in the past, there is a
-[transition guide](http://www.glfw.org/docs/3.0/moving.html) for moving to the
-GLFW 3 API.
+[introductory tutorial](http://www.glfw.org/docs/latest/quick.html) for GLFW
+3 useful.  If you have used GLFW 2 in the past, there is a
+[transition guide](http://www.glfw.org/docs/latest/moving.html) for moving to
+the GLFW 3 API.


 ## Compiling GLFW

-To compile GLFW and the accompanying example programs, you will need the
-[CMake](http://www.cmake.org/) build system.
-
-
 ### Dependencies

-#### X11 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/).

-To compile GLFW for X11 and GLX, you need to have the X and OpenGL header
-packages installed.  For example, on Ubuntu and other distributions based on
-Debian GNU/Linux, you need to install the `xorg-dev` and `libglu1-mesa-dev`
-packages.  Note that using header files from Mesa *will not* tie your binary to
-the Mesa implementation of OpenGL.
+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

-There are a number of CMake build options for GLFW, although not all are
+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

@@ -57,7 +154,7 @@ along with the library.
 built along with the library.


-#### Mac OS X specific options
+#### OS X specific options

 `GLFW_USE_CHDIR` determines whether `glfwInit` changes the current
 directory of bundled applications to the `Contents/Resources` directory.
@@ -70,8 +167,16 @@ directory of bundled applications to the `Contents/Resources` directory.

 #### Windows specific options

-`USE_MSVC_RUNTIME_LIBRARY_DLL` determines whether to use the DLL version of the
-Visual C++ runtime library.
+`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
@@ -95,23 +200,40 @@ CMake.

 ## Using GLFW

-See the [GLFW 3.0 documentation](http://www.glfw.org/docs/3.0/).
+See the [GLFW documentation](http://www.glfw.org/docs/latest/).


 ## Changelog

- - Bugfix: The wrong name was used for the CMake variable for the Xxf86vm
-           library
- - [Cocoa] Bugfix: `glfwGetFramebufferSize` return the size in screen
-                   coordinates
- - [Cocoa] Bugfix: Messages not supported on Mac OS X 10.6 were used without
-                   tests for precence
- - [Cocoa] Bugfix: Process transformation was not performed if menu bar creation
-                   was disabled
- - [Win32] Bugfix: Context creation was attempted even if no valid pixel formats
-                   had been found
- - [X11] Bugfix: Duplicate window position and window and framebuffer size
-                 events were reported
+ - Allowed character callback to be triggered regardless of modifier keys
+ - Bugfix: The `-Wall` flag was not used with Clang and other GCC compatibles
+ - Bugfix: The default for `GLFW_ALPHA_BITS` was set to zero
+ - Bugfix: `glfwInit` would segfault if monitor enumeration failed and no error
+           callback was set
+ - [Win32] Added `_GLFW_USE_DWM_SWAP_INTERVAL` for forcing the swap interval
+           to be set even when DWM compositing is enabled
+ - [Win32] Added support for forcing the use of the high-performance GPU
+           on nVidia Optimus systems
+ - [Win32] Bugfix: The clipboard string was not freed on terminate
+ - [Win32] Bugfix: Entry points for OpenGL 1.0 and 1.1 functions were not
+                   returned by `glfwGetProcAddress`
+ - [Win32] Bugfix: The `user32` and `dwmapi` module handles were not freed on
+                   library termination
+ - [Cocoa] Added support for precise scrolling deltas on OS X 10.7 and later
+ - [Cocoa] Enabled explicit creation of OpenGL 3.x and 4.x contexts as supported
+           by OS X 10.9
+ - [Cocoa] Bugfix: The clipboard string was not freed on terminate
+ - [Cocoa] Bugfix: Selectors were used that are not declared by the 10.6 SDK
+ - [Cocoa] Bugfix: The position set by `glfwSetWindowPos` was incorrect
+ - [X11] Bugfix: Override-redirect windows were resized to the desired instead
+                 of the actual resolution of the selected video mode
+ - [X11] Bugfix: Screensaver override for full screen windows had a possible
+                 race condition
+ - [X11] Bugfix: The reported window position did not account for the size of
+                 the window frame on some WMs
+ - [X11] Bugfix: The original video mode of a monitor was overwritten by calls
+                 to `glfwSetWindowSize`
+ - [X11] Bugfix: Key release events for `GLFW_KEY_KP_5` were discarded.


 ## Contact
@@ -125,11 +247,11 @@ If you have questions related to the use of GLFW, we have a
 channel `#glfw` on [Freenode](http://freenode.net/).

 If you have a bug to report, a patch to submit or a feature you'd like to
-request, please file it in one of the
-[issue trackers](https://sourceforge.net/p/glfw/_list/tickets) on SF.net.
+request, please file it in the
+[issue tracker](https://github.com/glfw/glfw/issues) on GitHub.

 Finally, if you're interested in helping out with the development of GLFW or
-porting it to your favorite platform, we have a
+porting it to your favorite platform, we have an occasionally active
 [developer's mailing list](https://lists.stacken.kth.se/mailman/listinfo/glfw-dev),
 or you could join us on `#glfw`.

@@ -141,11 +263,13 @@ skills.

 - Bobyshev Alexander
 - artblanc
+ - arturo
 - Matt Arsenault
 - Keith Bauer
 - John Bartholomew
 - Niklas Behrens
 - Niklas Bergström
+ - Doug Binks
 - blanco
 - Lambert Clara
 - Noel Cower
@@ -177,10 +301,11 @@ skills.
 - Jonathan Mercier
 - Marcel Metz
 - Kenneth Miller
+ - Bruce Mitchener
 - Jeff Molofee
 - Jon Morton
 - Julian Møller
- - Ozzy at Orkysquad
+ - Ozzy
 - Peoro
 - Braden Pellett
 - Arturo J. Pérez
@@ -196,6 +321,7 @@ skills.
 - Bradley Smith
 - Julian Squires
 - Johannes Stein
+ - Justin Stoecker
 - Nathan Sweet
 - TTK-Bandit
 - Sergey Tikhomirov
@@ -51,7 +51,7 @@ These macros may be defined before the inclusion of the GLFW header and affect
 how that header behaves.

 `GLFW_INCLUDE_GLCOREARB` makes the header include the modern `GL/glcorearb.h`
-header (`OpenGL/gl3.h` on Mac OS X) instead of the regular OpenGL header.
+header (`OpenGL/gl3.h` on OS X) instead of the regular OpenGL header.

 `GLFW_INCLUDE_ES1` makes the header include the OpenGL ES 1.x `GLES/gl.h` header
 instead of the regular OpenGL header.
@@ -64,28 +64,18 @@ header instead of the regular OpenGL header.

 `GLFW_INCLUDE_NONE` makes the header not include any client API header.

-`GLFW_INCLUDE_GLU` makes the header include the GLU header.  This only makes
-sense if you are using OpenGL.
+`GLFW_INCLUDE_GLU` makes the header include the GLU header *in addition to* the
+OpenGL header.  This should only be used with the default `GL/gl.h` header
+(`OpenGL/gl.h` on OS X), i.e. if you are not using any of the above macros.

 `GLFW_DLL` is necessary when using the GLFW DLL on Windows, in order to explain
 to the compiler that the GLFW functions will be coming from another executable.
+It has no function on other platforms.


@section build_link Link with the right libraries

-@subsection build_link_cmake Using GLFW from CMake
-
-The `GLFW_LIBRARIES` cache variable contains all link-time dependencies of GLFW
-as it is currently configured, so to link against GLFW simply do:
-
-    target_link_libraries(myapp glfw ${GLFW_LIBRARIES})
-
-Note that this does not include GLU, as GLFW does not use it.  If your
-application needs GLU, you can add it to the list of dependencies with the
-`OPENGL_glu_LIBRARY` cache variable.
-
-
-@subsection build_link_win32 Windows
+@subsection build_link_win32 With MinGW or Visual C++ on Windows

 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.
@@ -104,12 +94,72 @@ dependencies, but you still have to link against `opengl32` if your program uses
 OpenGL and `glu32` if it uses GLU.


-@subsection build_link_unix Unix with X11
+@subsection build_link_cmake_source With CMake and GLFW source
+
+You can use the GLFW source tree directly from a project that uses CMake.  This
+way, GLFW will be built along with your application as needed.
+
+Firstly, add the root directory of the GLFW source tree to your project.  This
+will add the `glfw` target and the necessary cache variables to your project.
+
+    add_subdirectory(path/to/glfw)
+
+To be able to include the GLFW header from your code, you need to tell the
+compiler where to find it.
+
+    include_directories(path/to/glfw/include)
+
+Once GLFW has been added to the project, the `GLFW_LIBRARIES` cache variable
+contains all link-time dependencies of GLFW as it is currently configured.  To
+link against GLFW, link against them and the `glfw` target.
+
+    target_link_libraries(myapp glfw ${GLFW_LIBRARIES})
+
+Note that `GLFW_LIBRARIES` does not include GLU, as GLFW does not use it.  If
+your application needs GLU, you can add it to the list of dependencies with the
+`OPENGL_glu_LIBRARY` cache variable, which is implicitly created when the GLFW
+CMake files look for OpenGL.
+
+    target_link_libraries(myapp glfw ${OPENGL_glu_LIBRARY} ${GLFW_LIBRARIES})
+
+
+@subsection build_link_cmake_pkgconfig With CMake on Unix and installed GLFW binaries
+
+CMake can import settings from pkg-config, which GLFW supports.  When you
+installed GLFW, the pkg-config file `glfw3.pc` was installed along with it.
+
+First you need to find the PkgConfig package.  If this fails, you may need to
+install the pkg-config package for your distribution.
+
+    find_package(PkgConfig REQUIRED)
+
+This creates the CMake commands to find pkg-config packages.  Then you need to
+find the GLFW package.
+
+    pkg_search_module(GLFW REQUIRED glfw3)
+
+This creates the CMake variables you need to use GLFW.  To be able to include
+the GLFW header, you need to tell your compiler where it is.
+
+    include_directories(${GLFW_INCLUDE_DIRS})
+
+You also need to link against the correct libraries.  If you are using the
+shared library version of GLFW, use the `GLFW_LIBRARIES` variable.
+
+    target_link_libraries(simple ${GLFW_LIBRARIES})
+
+
+If you are using the static library version of GLFW, use the
+`GLFW_STATIC_LIBRARIES` variable instead.
+
+    target_link_libraries(simple ${GLFW_STATIC_LIBRARIES})
+
+
+@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 library is built and installed along
-with it.  You can use it without installation using the `PKG_CONFIG_PATH`
-environment variable.  See the documentation for pkg-config for more details.
+and `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:

@@ -117,31 +167,32 @@ A typical compile and link command-line when using the static may look like this

 If you are using the shared library, simply omit the `--static` flag.

-If you are using GLU, you should also add `-lGLU` to your link flags.
+    cc `pkg-config --cflags glfw3` -o myprog myprog.c `pkg-config --libs glfw3`
+
+You can also use the `glfw3.pc` file without installing it first, by using the
+`PKG_CONFIG_PATH` environment variable.
+
+    env PKG_CONFIG_PATH=path/to/glfw/src cc `pkg-config --cflags glfw3` -o myprog myprog.c `pkg-config --static --libs glfw3`
+
+The dependencies do not include GLU, as GLFW does not need it.  On OS X, GLU is
+built into the OpenGL framework, so if you need GLU you don't need to do
+anything extra.  If you need GLU and are using Linux or BSD, you should add
+`-lGLU` to your link flags.
+
+See the manpage and other documentation for pkg-config and your compiler and
+linker for more information on how to link programs.


-@subsection build_link_osx Mac OS X
+@subsection build_link_xcode With Xcode on OS X

-GLFW on Mac OS X uses the Cocoa, OpenGL and IOKit frameworks.
+If you are using the dynamic library version of GLFW, simply add it to the
+project dependencies.

-If you are using Xcode, you can simply add the GLFW library and these frameworks
-as 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.

-If you are building from the
-command-line, it is recommended that you use pkg-config

-GLFW supports [pkg-config](http://www.freedesktop.org/wiki/Software/pkg-config/),
-and `glfw3.pc` file is generated when the library is built and installed along
-with it.  You can use it without installation using the `PKG_CONFIG_PATH`
-environment variable.  See the documentation for pkg-config for more details.
-
-You can find pkg-config in most package systems such as
-[Fink](http://www.finkproject.org/) and [MacPorts](http://www.macports.org/), so
-if you have one of them installed, simply install pkg-config.  Once you have
-pkg-config available, the command-line for compiling and linking your
-program is:
-
-    cc `pkg-config --cflags glfw3` -o myprog myprog.c `pkg-config --static --libs glfw3`
+@subsection build_link_osx With command-line on OS X

 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,
@@ -152,10 +203,9 @@ i.e.:
 Note that you do not add the `.framework` extension to a framework when adding
 it from the command-line.

-The OpenGL framework contains both the OpenGL and GLU APIs, so there is no need
-to add additional libraries or frameworks when using GLU.  Also note that even
-though your machine may have `libGL`-style OpenGL libraries, they are for use
-with the X Window System and will *not* work with the Mac OS X native version of
-GLFW.
+The OpenGL framework contains both the OpenGL and GLU APIs, so there is nothing
+special to do when using GLU.  Also note that even though your machine may have
+`libGL`-style OpenGL libraries, they are for use with the X Window System and
+will *not* work with the OS X native version of GLFW.

 */
@@ -112,19 +112,21 @@ context profiles.  Where this extension is unavailable, setting the
 `GLFW_OPENGL_PROFILE` hint to anything but zero will cause @ref glfwCreateWindow
 to fail.

-@section cmopat_osx OpenGL 3.2 on Mac OS X
+@section compat_osx OpenGL 3.2 and later on OS X

-Support for OpenGL 3.0 and above was introduced with Mac OS X 10.7, and even
-then only forward-compatible OpenGL 3.2 core profile contexts are supported.
-There is also still no mechanism for requesting debug contexts.  Versions of
-Mac OS X earlier than 10.7 support at most OpenGL version 2.1.
+Support for OpenGL 3.2 and above was introduced with OS X 10.7 and even then
+only forward-compatible, core profile contexts are supported.  Support for
+OpenGL 4.1 was introduced with OS X 10.9, also limited to forward-compatible,
+core profile contexts.  There is also still no mechanism for requesting debug
+contexts.  Versions of Mac OS X earlier than 10.7 support at most OpenGL
+version 2.1.

-Because of this, on Mac OS X 10.7, the `GLFW_CONTEXT_VERSION_MAJOR` and
-`GLFW_CONTEXT_VERSION_MINOR` hints will fail if given a version above 3.2, the
-`GLFW_OPENGL_FORWARD_COMPAT` is required for creating OpenGL 3.2 contexts, the
-`GLFW_OPENGL_DEBUG_CONTEXT` hint is ignored and setting the
-`GLFW_OPENGL_PROFILE` hint to anything except `GLFW_OPENGL_CORE_PROFILE` will
-cause @ref glfwCreateWindow to fail.                      
+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
+creating contexts for OpenGL 3.2 and later, the `GLFW_OPENGL_DEBUG_CONTEXT` hint
+is ignored and setting the `GLFW_OPENGL_PROFILE` hint to anything except
+`GLFW_OPENGL_CORE_PROFILE` will cause @ref glfwCreateWindow to fail.

 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
@@ -9,6 +9,9 @@

 The @ref GLFWmonitor object represents a currently connected monitor.

+
+@section monitor_monitors Retrieving monitors
+
 The primary monitor is returned by @ref glfwGetPrimaryMonitor.  It is usually
 the user's preferred monitor and the one with global UI elements like task bar
 or menu bar.
@@ -25,7 +28,7 @@ GLFWmonitor** monitors = glfwGetMonitors(&count);
@endcode


-@section monitor_modes Querying video modes
+@section monitor_modes Retrieving video modes

 Although GLFW generally does a good job at selecting a suitable video
 mode for you when you open a full screen window, it is sometimes useful to
@@ -49,14 +52,20 @@ const GLFWvidmode* mode = glfwGetVideoMode(monitor);
@section monitor_size Monitor physical size

 The physical size in millimetres of a monitor, or an approximation of it, can be
-retrieved with @ref glfwGetMonitorPhysicalSize.  This can, for example, be used
-together with the current video mode to calculate DPI.
+retrieved with @ref glfwGetMonitorPhysicalSize.  

@code
 int widthMM, heightMM;
 glfwGetMonitorPhysicalSize(monitor, &widthMM, &heightMM);
@endcode

+This can, for example, be used together with the current video mode to calculate
+the DPI of a monitor. 
+
+@code
+const double dpi = mode->width / (widthMM / 25.4);
+@endcode
+

@section monitor_name Monitor name

@@ -125,6 +125,14 @@ or something else, are nowadays expected to be good desktop citizens and allow
 these hotkeys to function even when running in full screen mode.


+@subsection moving_opened Window open parameter
+
+The `GLFW_OPENED` window parameter has been removed.  As long as the
+[window object](@ref window_object) is around, the window is "open".  To detect
+when the user attempts to close the window, see @ref glfwWindowShouldClose and
+the [close callback](@ref GLFWwindowclosefun).
+
+
@subsection moving_autopoll Automatic polling of events

 GLFW 3 does not automatically poll for events on @ref glfwSwapBuffers, which
@@ -140,9 +140,9 @@ full screen, just pass along the monitor handle:
 GLFWwindow* window = glfwCreateWindow(640, 480, "My Title", glfwGetPrimaryMonitor(), NULL);
@endcode

-Full screen windows cover the entire screen, have no border or decorations, and
-change the monitor's resolution to the one most closely matching the requested
-window size.
+Full screen windows cover the entire display area of a monitor, have no border
+or decorations, and change the monitor's resolution to the one most closely
+matching the requested window size.

 When you are done with the window, destroy it with the @ref glfwDestroyWindow
 function.
@@ -6,7 +6,7 @@

 The primary purpose of GLFW is to provide a simple interface to window
 management and OpenGL and OpenGL ES context creation.  GLFW supports multiple
-windows, which can be either a normal desktop window or a fullscreen window.
+windows, which can be either a normal desktop window or a full screen window.


@section window_object Window handles
@@ -17,6 +17,51 @@ created with @ref glfwCreateWindow and destroyed with @ref glfwDestroyWindow (or
 linked, the object pointer is used as both a context and window handle.


+@section window_creation Window creation
+
+The window and its context are created with @ref glfwCreateWindow, which
+returns a handle to the created window object.  For example, this creates a 640
+by 480 windowed mode window:
+
+@code
+GLFWwindow* window = glfwCreateWindow(640, 480, "My Title", NULL, NULL);
+@endcode
+
+If window creation fails, `NULL` will be returned, so you need to check whether
+it did.
+
+This handle is then passed to all window related functions, and is provided to
+you along with input events, so you know which window received the input.
+
+To create a full screen window, you need to specify which monitor the window
+should use.  In most cases, the user's primary monitor is a good choice.  For
+more information about monitors, see the @ref monitor.
+
+@code
+GLFWwindow* window = glfwCreateWindow(640, 480, "My Title", glfwGetPrimaryMonitor(), NULL);
+@endcode
+
+Full screen windows cover the entire display area of a monitor, have no border
+or decorations, and change the monitor's resolution to the one most closely
+matching the requested window size.
+
+For more control over how the window and its context are created, see @ref
+window_hints below.
+
+
+@section window_destruction Window destruction
+
+When you are done with the window, destroy it with the @ref glfwDestroyWindow
+function.
+
+@code
+glfwDestroyWindow(window);
+@endcode
+
+Once this function is called, no more events will be delivered for that window
+and its handle becomes invalid.
+
+
@section window_hints Window creation hints

 There are a number of hints that can be set before the creation of a window and
@@ -54,14 +99,14 @@ Hints that do not apply to a given type of window or context are ignored.

 The `GLFW_RESIZABLE` hint specifies whether the window will be resizable *by the
 user*.  The window will still be resizable using the @ref glfwSetWindowSize
-function.  This hint is ignored for fullscreen windows.
+function.  This hint is ignored for full screen windows.

 The `GLFW_VISIBLE` hint specifies whether the window will be initially
-visible.  This hint is ignored for fullscreen windows.
+visible.  This hint is ignored for full screen windows.

 The `GLFW_DECORATED` hint specifies whether the window will have window
 decorations such as a border, a close widget, etc.  This hint is ignored for
-fullscreen windows.  Note that even though a window may lack a close widget, it
+full screen windows.  Note that even though a window may lack a close widget, it
 is usually still possible for the user to generate close events.


@@ -227,13 +272,11 @@ the system, you can set the size callback with @ref glfwSetWindowSizeCallback.
 glfwSetWindowSizeCallback(window, window_size_callback);
@endcode

-The callback function receives the new size of the client area of the window,
-which can for example be used to update the viewport.
+The callback function receives the new size of the client area of the window.

@code
 void window_size_callback(GLFWwindow* window, int width, int height)
 {
-    glViewport(0, 0, width, height);
 }
@endcode

@@ -243,9 +286,49 @@ a window.
@code
 int width, height;
 glfwGetWindowSize(window, &width, &height);
+@endcode
+
+
+@section window_fbsize Window framebuffer size
+
+While the size of a window is measured in screen coordinates, OpenGL works with
+pixels.  The size you pass into `glViewport`, for example, should be in pixels
+and not screen coordinates.  On some platforms screen coordinates and pixels are
+the same, but this is not the case on all platforms supported by GLFW.  There is
+a second set of functions to retrieve the size in pixels of the framebuffer of
+a window.
+
+If you wish to be notified when the framebuffer of a window is resized, whether
+by the user or the system, you can set the size callback with @ref
+glfwSetFramebufferSizeCallback.
+
+@code
+glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
+@endcode
+
+The callback function receives the new size of the client area of the window,
+which can for example be used to update the OpenGL viewport.
+
+@code
+void framebuffer_size_callback(GLFWwindow* window, int width, int height)
+{
+    glViewport(0, 0, width, height);
+}
+@endcode
+
+There is also @ref glfwGetFramebufferSize for directly retrieving the current
+size of the framebuffer of a window.
+
+@code
+int width, height;
+glfwGetFramebufferSize(window, &width, &height);
 glViewport(0, 0, width, height);
@endcode

+Note that the size of a framebuffer may change independently of the size of
+a window, for example if the window is dragged between a regular monitor and
+a high-DPI one.
+

@section window_pos Window position

@@ -11,10 +11,6 @@ endif()
 include_directories(${GLFW_SOURCE_DIR}/include
                    ${GLFW_SOURCE_DIR}/deps)

-if (MSVC)
-    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-endif()
-
 if (NOT APPLE)
    # HACK: This is NOTFOUND on OS X 10.8
    include_directories(${OPENGL_INCLUDE_DIR})
@@ -1,7 +1,6 @@
 /*************************************************************************
- * GLFW - An OpenGL library
- * API version: 3.0
- * WWW:         http://www.glfw.org/
+ * GLFW 3.0 - www.glfw.org
+ * A library for OpenGL, window and input
 *------------------------------------------------------------------------
 * Copyright (c) 2002-2006 Marcus Geelnard
 * Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -45,21 +44,22 @@ extern "C" {
 */
 /*! @defgroup error Error handling
 */
-/*! @defgroup gamma Gamma ramp support
- */
 /*! @defgroup init Initialization and version information
 */
 /*! @defgroup input Input handling
 */
 /*! @defgroup monitor Monitor handling
+ *
+ *  This is the reference documentation for monitor related functions and types.
+ *  For more information, see the @ref monitor.
 */
 /*! @defgroup time Time input
 */
 /*! @defgroup window Window handling
 *
- *  This is the reference documentation for the window handling API, including
- *  creation, deletion and event polling.  For more information, see the
- *  [article on window handling](@ref window).
+ *  This is the reference documentation for window related functions and types,
+ *  including creation, deletion and event polling.  For more information, see
+ *  the @ref window.
 */


@@ -131,15 +131,18 @@ extern "C" {
 #define GLFW_CALLBACK_DEFINED
 #endif /* CALLBACK */

-/* Most <GL/glu.h> variants on Windows need wchar_t */
-#if defined(_WIN32)
- #include <stddef.h>
-#endif
+/* Most GL/glu.h variants on Windows need wchar_t
+ * OpenGL/gl.h blocks the definition of ptrdiff_t by glext.h on OS X */
+#include <stddef.h>


 /* ---------------- GLFW related system specific defines ----------------- */

 #if defined(GLFW_DLL) && defined(_GLFW_BUILD_DLL)
+ /* GLFW_DLL is defined by users of GLFW when compiling programs that will link
+  * to the DLL version of the GLFW library.  _GLFW_BUILD_DLL is defined by the
+  * GLFW configuration header when compiling the DLL version of the library.
+  */
 #error "You must not have both GLFW_DLL and _GLFW_BUILD_DLL defined"
 #endif

@@ -225,7 +228,7 @@ extern "C" {
 *  API changes.
 *  @ingroup init
 */
-#define GLFW_VERSION_REVISION       1
+#define GLFW_VERSION_REVISION       2
 /*! @} */

 /*! @name Key and button actions
@@ -818,7 +821,7 @@ typedef struct
 *
 *  @sa glfwGetGammaRamp glfwSetGammaRamp
 *
- *  @ingroup gamma
+ *  @ingroup monitor
 */
 typedef struct
 {
@@ -1124,7 +1127,7 @@ GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* monitor);
 *  @param[in] monitor The monitor whose gamma ramp to set.
 *  @param[in] gamma The desired exponent.
 *
- *  @ingroup gamma
+ *  @ingroup monitor
 */
 GLFWAPI void glfwSetGamma(GLFWmonitor* monitor, float gamma);

@@ -1138,7 +1141,7 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* monitor, float gamma);
 *  @note The value arrays of the returned ramp are allocated and freed by GLFW.
 *  You should not free them yourself.
 *
- *  @ingroup gamma
+ *  @ingroup monitor
 */
 GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* monitor);

@@ -1151,7 +1154,7 @@ GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* monitor);
 *
 *  @note Gamma ramp sizes other than 256 are not supported by all hardware.
 *
- *  @ingroup gamma
+ *  @ingroup monitor
 */
 GLFWAPI void glfwSetGammaRamp(GLFWmonitor* monitor, const GLFWgammaramp* ramp);

@@ -1207,10 +1210,16 @@ GLFWAPI void glfwWindowHint(int target, int hint);
 *  attributes of the created window and context, use queries like @ref
 *  glfwGetWindowAttrib and @ref glfwGetWindowSize.
 *
+ *  To create a full screen window, you need to specify the monitor to use.  If
+ *  no monitor is specified, windowed mode will be used.  Unless you have a way
+ *  for the user to choose a specific monitor, it is recommended that you pick
+ *  the primary monitor.  For more information on how to retrieve monitors, see
+ *  @ref monitor_monitors.
+ *
 *  To create the window at a specific position, make it initially invisible
 *  using the `GLFW_VISIBLE` window hint, set its position and then show it.
 *
- *  If a fullscreen window is active, the screensaver is prohibited from
+ *  If a full screen window is active, the screensaver is prohibited from
 *  starting.
 *
 *  @param[in] width The desired width, in screen coordinates, of the window.
@@ -1272,6 +1281,8 @@ GLFWAPI void glfwDestroyWindow(GLFWwindow* window);
 *  @param[in] window The window to query.
 *  @return The value of the close flag.
 *
+ *  @remarks This function may be called from secondary threads.
+ *
 *  @ingroup window
 */
 GLFWAPI int glfwWindowShouldClose(GLFWwindow* window);
@@ -1285,6 +1296,8 @@ GLFWAPI int glfwWindowShouldClose(GLFWwindow* window);
 *  @param[in] window The window whose flag to change.
 *  @param[in] value The new value.
 *
+ *  @remarks This function may be called from secondary threads.
+ *
 *  @ingroup window
 */
 GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* window, int value);
@@ -1688,7 +1701,7 @@ GLFWAPI void glfwPollEvents(void);
 /*! @brief Waits until events are pending and processes them.
 *
 *  This function puts the calling thread to sleep until at least one event has
- *  been received.  Once one or more events have been recevied, it behaves as if
+ *  been received.  Once one or more events have been received, it behaves as if
 *  @ref glfwPollEvents was called, i.e. the events are processed and the
 *  function then returns immediately.  Processing events will cause the window
 *  and input callbacks associated with those events to be called.
@@ -1,7 +1,6 @@
 /*************************************************************************
- * GLFW - An OpenGL library
- * API version: 3.0
- * WWW:         http://www.glfw.org/
+ * GLFW 3.0 - www.glfw.org
+ * A library for OpenGL, window and input
 *------------------------------------------------------------------------
 * Copyright (c) 2002-2006 Marcus Geelnard
 * Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -41,7 +40,7 @@ extern "C" {

 /*! @defgroup native Native access
 *
- *  **By using the native API, you assert that you know what you are doing and
+ *  **By using the native API, you assert that you know what you're doing and
 *  how to fix problems caused by using it.  If you don't, you shouldn't be
 *  using it.**
 *
@@ -3,11 +3,9 @@ include_directories(${GLFW_SOURCE_DIR}/src
                    ${GLFW_BINARY_DIR}/src
                    ${glfw_INCLUDE_DIRS})

-if (MSVC)
-    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-endif()
-
-set(common_HEADERS ${GLFW_SOURCE_DIR}/include/GLFW/glfw3.h internal.h)
+set(common_HEADERS ${GLFW_BINARY_DIR}/src/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
                   monitor.c time.c window.c)

@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Any
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Cocoa
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 OS X - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Cocoa
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 OS X - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -43,7 +40,7 @@
 void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
 {
    uint32_t i, size = CGDisplayGammaTableCapacity(monitor->ns.displayID);
-    CGGammaValue* values = (CGGammaValue*) malloc(size * 3 * sizeof(CGGammaValue));
+    CGGammaValue* values = calloc(size * 3, sizeof(CGGammaValue));

    CGGetDisplayTransferByTable(monitor->ns.displayID,
                                size,
@@ -52,7 +49,7 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
                                values + size * 2,
                                &size);

-    _glfwAllocGammaRamp(ramp, size);
+    _glfwAllocGammaArrays(ramp, size);

    for (i = 0; i < size; i++)
    {
@@ -67,7 +64,7 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
 {
    int i;
-    CGGammaValue* values = (CGGammaValue*) malloc(ramp->size * 3 * sizeof(CGGammaValue));
+    CGGammaValue* values = calloc(ramp->size * 3, sizeof(CGGammaValue));

    for (i = 0;  i < ramp->size;  i++)
    {
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
-// API Version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 OS X - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -84,19 +81,18 @@ int _glfwPlatformInit(void)
    changeToResourcesDirectory();
 #endif

-    _glfwInitTimer();
-
-    _glfwInitJoysticks();
-
-    if (!_glfwInitContextAPI())
-        return GL_FALSE;
-
    _glfw.ns.eventSource = CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
    if (!_glfw.ns.eventSource)
        return GL_FALSE;

    CGEventSourceSetLocalEventsSuppressionInterval(_glfw.ns.eventSource, 0.0);

+    if (!_glfwInitContextAPI())
+        return GL_FALSE;
+
+    _glfwInitTimer();
+    _glfwInitJoysticks();
+
    return GL_TRUE;
 }

@@ -118,8 +114,9 @@ void _glfwPlatformTerminate(void)
    [_glfw.ns.cursor release];
    _glfw.ns.cursor = nil;

-    _glfwTerminateJoysticks();
+    free(_glfw.ns.clipboardString);

+    _glfwTerminateJoysticks();
    _glfwTerminateContextAPI();
 }

@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Cocoa
-// API Version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 OS X - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
 // Copyright (c) 2012 Torsten Walluhn <tw@mad-cad.net>
@@ -113,7 +110,7 @@ static void addJoystickElement(_GLFWjoy* joystick, CFTypeRef elementRef)
        {
            long number;
            CFTypeRef numberRef;
-            _GLFWjoyelement* element = (_GLFWjoyelement*) malloc(sizeof(_GLFWjoyelement));
+            _GLFWjoyelement* element = calloc(1, sizeof(_GLFWjoyelement));

            CFArrayAppendValue(elementsArray, element);

@@ -427,10 +424,10 @@ void _glfwInitJoysticks(void)
            CFRelease(valueRef);
        }

-        joystick->axes = (float*) calloc(CFArrayGetCount(joystick->axisElements),
+        joystick->axes = calloc(CFArrayGetCount(joystick->axisElements),
                                         sizeof(float));
-        joystick->buttons = (unsigned char*) calloc(CFArrayGetCount(joystick->buttonElements) +
-                                                    CFArrayGetCount(joystick->hatElements) * 4, 1);
+        joystick->buttons = calloc(CFArrayGetCount(joystick->buttonElements) +
+                                   CFArrayGetCount(joystick->hatElements) * 4, 1);

        joy++;
        if (joy > GLFW_JOYSTICK_LAST)
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Cocoa
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 OS X - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -58,7 +55,7 @@ static const char* getDisplayName(CGDirectDisplayID displayID)

    size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(value),
                                             kCFStringEncodingUTF8);
-    name = (char*) malloc(size + 1);
+    name = calloc(size + 1, sizeof(char));
    CFStringGetCString(value, name, size, kCFStringEncodingUTF8);

    CFRelease(info);
@@ -253,8 +250,8 @@ _GLFWmonitor** _glfwPlatformGetMonitors(int* count)

    CGGetActiveDisplayList(0, NULL, &monitorCount);

-    displays = (CGDirectDisplayID*) calloc(monitorCount, sizeof(CGDirectDisplayID));
-    monitors = (_GLFWmonitor**) calloc(monitorCount, sizeof(_GLFWmonitor*));
+    displays = calloc(monitorCount, sizeof(CGDirectDisplayID));
+    monitors = calloc(monitorCount, sizeof(_GLFWmonitor*));

    CGGetActiveDisplayList(monitorCount, displays, &monitorCount);

@@ -341,7 +338,7 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
    modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
    count = CFArrayGetCount(modes);

-    result = (GLFWvidmode*) malloc(sizeof(GLFWvidmode) * count);
+    result = calloc(count, sizeof(GLFWvidmode));
    *found = 0;

    for (i = 0;  i < count;  i++)
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Cocoa
-// API Version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 OS X - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Cocoa
-// API Version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 OS X - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
-// API Version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 OS X - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -73,9 +70,11 @@ static float transformY(float y)
 //
 static NSRect convertRectToBacking(_GLFWwindow* window, NSRect contentRect)
 {
-    if ([window->ns.view respondsToSelector:@selector(convertRectToBacking:)])
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
+    if (floor(NSAppKitVersionNumber) >= NSAppKitVersionNumber10_7)
        return [window->ns.view convertRectToBacking:contentRect];
    else
+#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
        return contentRect;
 }

@@ -218,7 +217,7 @@ static void centerCursor(_GLFWwindow *window)

@end

-// Translates Mac OS X key modifiers into GLFW ones
+// Translates OS X key modifiers into GLFW ones
 //
 static int translateFlags(NSUInteger flags)
 {
@@ -236,7 +235,7 @@ static int translateFlags(NSUInteger flags)
    return mods;
 }

-// Translates a Mac OS X keycode to a GLFW keycode
+// Translates a OS X keycode to a GLFW keycode
 //
 static int translateKey(unsigned int key)
 {
@@ -558,7 +557,7 @@ static int translateKey(unsigned int key)
                                               userInfo:nil];

    [self addTrackingArea:trackingArea];
-	[super updateTrackingAreas];
+    [super updateTrackingAreas];
 }

 - (void)keyDown:(NSEvent *)event
@@ -567,9 +566,6 @@ static int translateKey(unsigned int key)
    const int mods = translateFlags([event modifierFlags]);
    _glfwInputKey(window, key, [event keyCode], GLFW_PRESS, mods);

-    if (mods & GLFW_MOD_SUPER)
-        return;
-
    NSString* characters = [event characters];
    NSUInteger i, length = [characters length];

@@ -604,8 +600,26 @@ static int translateKey(unsigned int key)

 - (void)scrollWheel:(NSEvent *)event
 {
-    double deltaX = [event deltaX];
-    double deltaY = [event deltaY];
+    double deltaX, deltaY;
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
+    if (floor(NSAppKitVersionNumber) >= NSAppKitVersionNumber10_7)
+    {
+        deltaX = [event scrollingDeltaX];
+        deltaY = [event scrollingDeltaY];
+
+        if ([event hasPreciseScrollingDeltas])
+        {
+            deltaX *= 0.1;
+            deltaY *= 0.1;
+        }
+    }
+    else
+#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
+    {
+        deltaX = [event deltaX];
+        deltaY = [event deltaY];
+    }

    if (fabs(deltaX) > 0.0 || fabs(deltaY) > 0.0)
        _glfwInputScroll(window, deltaX, deltaY);
@@ -666,7 +680,7 @@ static int translateKey(unsigned int key)
 //
 static NSString* findAppName(void)
 {
-    unsigned int i;
+    size_t i;
    NSDictionary* infoDictionary = [[NSBundle mainBundle] infoDictionary];

    // Keys to search for as potential application names
@@ -825,8 +839,10 @@ static GLboolean createWindow(_GLFWwindow* window,

    window->ns.view = [[GLFWContentView alloc] initWithGlfwWindow:window];

-    if ([window->ns.view respondsToSelector:@selector(setWantsBestResolutionOpenGLSurface:)])
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
+    if (floor(NSAppKitVersionNumber) >= NSAppKitVersionNumber10_7)
        [window->ns.view setWantsBestResolutionOpenGLSurface:YES];
+#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/

    [window->ns.object setTitle:[NSString stringWithUTF8String:wndconfig->title]];
    [window->ns.object setContentView:window->ns.view];
@@ -835,8 +851,10 @@ static GLboolean createWindow(_GLFWwindow* window,
    [window->ns.object disableCursorRects];
    [window->ns.object center];

-    if ([window->ns.object respondsToSelector:@selector(setRestorable:)])
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
+    if (floor(NSAppKitVersionNumber) >= NSAppKitVersionNumber10_7)
        [window->ns.object setRestorable:NO];
+#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/

    return GL_TRUE;
 }
@@ -931,8 +949,9 @@ void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos)

 void _glfwPlatformSetWindowPos(_GLFWwindow* window, int x, int y)
 {
-    const NSRect frameRect =
-        [window->ns.object frameRectForContentRect:NSMakeRect(x, y, 0, 0)];
+    const NSRect contentRect = [window->ns.view frame];
+    const NSRect dummyRect = NSMakeRect(x, transformY(y + contentRect.size.height), 0, 0);
+    const NSRect frameRect = [window->ns.object frameRectForContentRect:dummyRect];
    [window->ns.object setFrameOrigin:frameRect.origin];
 }

@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Any
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -56,6 +53,10 @@

 // Define this to 1 to disable dynamic loading of winmm
 #cmakedefine _GLFW_NO_DLOAD_WINMM
+// Define this to 1 if glfwSwapInterval should ignore DWM compositing status
+#cmakedefine _GLFW_USE_DWM_SWAP_INTERVAL
+// Define this to 1 to force use of high-performance GPU on Optimus systems
+#cmakedefine _GLFW_USE_OPTIMUS_HPG

 // Define this to 1 if glXGetProcAddress is available
 #cmakedefine _GLFW_HAS_GLXGETPROCADDRESS
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Any
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    EGL
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 EGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -127,10 +124,10 @@ static GLboolean chooseFBConfigs(const _GLFWwndconfig* wndconfig,
        return GL_FALSE;
    }

-    nativeConfigs = (EGLConfig*) calloc(nativeCount, sizeof(EGLConfig));
+    nativeConfigs = calloc(nativeCount, sizeof(EGLConfig));
    eglGetConfigs(_glfw.egl.display, nativeConfigs, nativeCount, &nativeCount);

-    usableConfigs = (_GLFWfbconfig*) calloc(nativeCount, sizeof(_GLFWfbconfig));
+    usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
    usableCount = 0;

    for (i = 0;  i < nativeCount;  i++)
@@ -210,7 +207,7 @@ static GLboolean chooseFBConfigs(const _GLFWwndconfig* wndconfig,
 //
 int _glfwInitContextAPI(void)
 {
-    _glfw.egl.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
+    _glfw.egl.display = eglGetDisplay((EGLNativeDisplayType)_GLFW_EGL_NATIVE_DISPLAY);
    if (_glfw.egl.display == EGL_NO_DISPLAY)
    {
        _glfwInputError(GLFW_API_UNAVAILABLE,
@@ -246,7 +243,7 @@ void _glfwTerminateContextAPI(void)
 { \
    attribs[index++] = attribName; \
    attribs[index++] = attribValue; \
-    assert(index < sizeof(attribs) / sizeof(attribs[0])); \
+    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
 }

 // Prepare for creation of the OpenGL context
@@ -464,7 +461,7 @@ void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
        {
            window->egl.surface = eglCreateWindowSurface(_glfw.egl.display,
                                                         window->egl.config,
-                                                         _GLFW_EGL_NATIVE_WINDOW,
+                                                         (EGLNativeWindowType)_GLFW_EGL_NATIVE_WINDOW,
                                                         NULL);
            if (window->egl.surface == EGL_NO_SURFACE)
            {
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    EGL
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 EGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Any
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -42,15 +39,15 @@
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////

-void _glfwAllocGammaRamp(GLFWgammaramp* ramp, unsigned int size)
+void _glfwAllocGammaArrays(GLFWgammaramp* ramp, unsigned int size)
 {
-    ramp->red = (unsigned short*) malloc(size * sizeof(unsigned short));
-    ramp->green = (unsigned short*) malloc(size * sizeof(unsigned short));
-    ramp->blue = (unsigned short*) malloc(size * sizeof(unsigned short));
+    ramp->red = calloc(size, sizeof(unsigned short));
+    ramp->green = calloc(size, sizeof(unsigned short));
+    ramp->blue = calloc(size, sizeof(unsigned short));
    ramp->size = size;
 }

-void _glfwFreeGammaRamp(GLFWgammaramp* ramp)
+void _glfwFreeGammaArrays(GLFWgammaramp* ramp)
 {
    free(ramp->red);
    free(ramp->green);
@@ -81,18 +78,16 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)

    for (i = 0;  i < 256;  i++)
    {
-        float value;
+        double value;

        // Calculate intensity
-        value = i / 255.f;
+        value = i / 255.0;
        // Apply gamma curve
-        value = (float) pow(value, 1.f / gamma) * 65535.f + 0.5f;
+        value = pow(value, 1.0 / gamma) * 65535.0 + 0.5;

        // Clamp to value range
-        if (value < 0.f)
-            value = 0.f;
-        else if (value > 65535.f)
-            value = 65535.f;
+        if (value > 65535.0)
+            value = 65535.0;

        values[i] = (unsigned short) value;
    }
@@ -111,7 +106,7 @@ GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* handle)

    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);

-    _glfwFreeGammaRamp(&monitor->currentRamp);
+    _glfwFreeGammaArrays(&monitor->currentRamp);
    _glfwPlatformGetGammaRamp(monitor, &monitor->currentRamp);

    return &monitor->currentRamp;
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11/GLX
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 GLX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -45,14 +42,6 @@ void (*glXGetProcAddressEXT(const GLubyte* procName))();
 #endif


-// Error handler used when creating a context
-//
-static int errorHandler(Display *display, XErrorEvent* event)
-{
-    _glfw.glx.errorCode = event->error_code;
-    return 0;
-}
-
 // Returns the specified attribute of the specified GLXFBConfig
 // NOTE: Do not call this unless we have found GLX 1.3+ or GLX_SGIX_fbconfig
 //
@@ -111,7 +100,7 @@ static GLboolean chooseFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* resul
        return GL_FALSE;
    }

-    usableConfigs = (_GLFWfbconfig*) calloc(nativeCount, sizeof(_GLFWfbconfig));
+    usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
    usableCount = 0;

    for (i = 0;  i < nativeCount;  i++)
@@ -191,14 +180,12 @@ static GLXContext createLegacyContext(_GLFWwindow* window,
                                                     share,
                                                     True);
    }
-    else
-    {
-        return glXCreateNewContext(_glfw.x11.display,
-                                   fbconfig,
-                                   GLX_RGBA_TYPE,
-                                   share,
-                                   True);
-    }
+
+    return glXCreateNewContext(_glfw.x11.display,
+                               fbconfig,
+                               GLX_RGBA_TYPE,
+                               share,
+                               True);
 }


@@ -354,7 +341,7 @@ void _glfwTerminateContextAPI(void)
 { \
    attribs[index++] = attribName; \
    attribs[index++] = attribValue; \
-    assert(index < sizeof(attribs) / sizeof(attribs[0])); \
+    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
 }

 // Prepare for creation of the OpenGL context
@@ -399,7 +386,7 @@ int _glfwCreateContext(_GLFWwindow* window,
            !_glfw.glx.ARB_create_context_profile ||
            !_glfw.glx.EXT_create_context_es2_profile)
        {
-            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+            _glfwInputError(GLFW_API_UNAVAILABLE,
                            "GLX: OpenGL ES requested but "
                            "GLX_EXT_create_context_es2_profile is unavailable");
            return GL_FALSE;
@@ -429,8 +416,7 @@ int _glfwCreateContext(_GLFWwindow* window,
        }
    }

-    _glfw.glx.errorCode = Success;
-    XSetErrorHandler(errorHandler);
+    _glfwGrabXErrorHandler();

    if (_glfw.glx.ARB_create_context)
    {
@@ -501,7 +487,7 @@ int _glfwCreateContext(_GLFWwindow* window,
            // HACK: This is a fallback for the broken Mesa implementation of
            // GLX_ARB_create_context_profile, which fails default 1.0 context
            // creation with a GLXBadProfileARB error in violation of the spec
-            if (_glfw.glx.errorCode == _glfw.glx.errorBase + GLXBadProfileARB &&
+            if (_glfw.x11.errorCode == _glfw.glx.errorBase + GLXBadProfileARB &&
                wndconfig->clientAPI == GLFW_OPENGL_API &&
                wndconfig->glProfile == GLFW_OPENGL_ANY_PROFILE &&
                wndconfig->glForward == GL_FALSE)
@@ -513,19 +499,11 @@ int _glfwCreateContext(_GLFWwindow* window,
    else
        window->glx.context = createLegacyContext(window, native, share);

-    XSetErrorHandler(NULL);
+    _glfwReleaseXErrorHandler();

    if (window->glx.context == NULL)
    {
-        char buffer[8192];
-        XGetErrorText(_glfw.x11.display,
-                      _glfw.glx.errorCode,
-                      buffer, sizeof(buffer));
-
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "GLX: Failed to create context: %s",
-                        buffer);
-
+        _glfwInputXError(GLFW_PLATFORM_ERROR, "GLX: Failed to create context");
        return GL_FALSE;
    }

@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11/GLX
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 GLX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -97,9 +94,6 @@ typedef struct _GLFWlibraryGLX
    // TLS key for per-thread current context/window
    pthread_key_t   current;

-    // GLX error code received by Xlib error callback
-    int             errorCode;
-
    // GLX extensions
    PFNGLXSWAPINTERVALSGIPROC             SwapIntervalSGI;
    PFNGLXSWAPINTERVALEXTPROC             SwapIntervalEXT;
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Any
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -133,7 +130,7 @@ GLFWAPI int glfwInit(void)
    _glfw.monitors = _glfwPlatformGetMonitors(&_glfw.monitorCount);
    if (_glfw.monitors == NULL)
    {
-        _glfwErrorCallback(GLFW_PLATFORM_ERROR, "No monitors found");
+        _glfwInputError(GLFW_PLATFORM_ERROR, "No monitors found");
        _glfwPlatformTerminate();
        return GL_FALSE;
    }
@@ -153,6 +150,8 @@ GLFWAPI void glfwTerminate(void)
    if (!_glfwInitialized)
        return;

+    memset(&_glfw.callbacks, 0, sizeof(_glfw.callbacks));
+
    // Close all remaining windows
    while (_glfw.windowListHead)
        glfwDestroyWindow((GLFWwindow*) _glfw.windowListHead);
@@ -192,8 +191,7 @@ GLFWAPI const char* glfwGetVersionString(void)

 GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun cbfun)
 {
-    GLFWerrorfun previous = _glfwErrorCallback;
-    _glfwErrorCallback = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(_glfwErrorCallback, cbfun);
+    return cbfun;
 }

@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Any
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -55,7 +52,12 @@ static void setCursorMode(_GLFWwindow* window, int newMode)
    if (window == _glfw.focusedWindow)
    {
        if (oldMode == GLFW_CURSOR_DISABLED)
+        {
+            window->cursorPosX = _glfw.cursorPosX;
+            window->cursorPosY = _glfw.cursorPosY;
+
            _glfwPlatformSetCursorPos(window, _glfw.cursorPosX, _glfw.cursorPosY);
+        }
        else if (newMode == GLFW_CURSOR_DISABLED)
        {
            int width, height;
@@ -149,9 +151,6 @@ void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int m

 void _glfwInputChar(_GLFWwindow* window, unsigned int character)
 {
-    if (character == -1)
-        return;
-
    if (character < 32 || (character > 126 && character < 160))
        return;

@@ -347,76 +346,52 @@ GLFWAPI void glfwSetCursorPos(GLFWwindow* handle, double xpos, double ypos)
 GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* handle, GLFWkeyfun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWkeyfun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.key;
-    window->callbacks.key = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.key, cbfun);
+    return cbfun;
 }

 GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* handle, GLFWcharfun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWcharfun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.character;
-    window->callbacks.character = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.character, cbfun);
+    return cbfun;
 }

 GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* handle,
                                                      GLFWmousebuttonfun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWmousebuttonfun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.mouseButton;
-    window->callbacks.mouseButton = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.mouseButton, cbfun);
+    return cbfun;
 }

 GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* handle,
                                                  GLFWcursorposfun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWcursorposfun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.cursorPos;
-    window->callbacks.cursorPos = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.cursorPos, cbfun);
+    return cbfun;
 }

 GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* handle,
                                                      GLFWcursorenterfun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWcursorenterfun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.cursorEnter;
-    window->callbacks.cursorEnter = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.cursorEnter, cbfun);
+    return cbfun;
 }

 GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* handle,
                                            GLFWscrollfun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWscrollfun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.scroll;
-    window->callbacks.scroll = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.scroll, cbfun);
+    return cbfun;
 }

@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Any
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -120,6 +117,15 @@ typedef struct _GLFWmonitor     _GLFWmonitor;
        return x;                                    \
    }

+// Swaps the provided pointers
+#define _GLFW_SWAP_POINTERS(x, y) \
+    {                             \
+        void* t;                  \
+        t = x;                    \
+        x = y;                    \
+        y = t;                    \
+    }
+

 //========================================================================
 // Internal types
@@ -298,7 +304,10 @@ struct _GLFWlibrary

    _GLFWmonitor**  monitors;
    int             monitorCount;
-    GLFWmonitorfun  monitorCallback;
+
+    struct {
+        GLFWmonitorfun  monitor;
+    } callbacks;

    // This is defined in the window API's platform.h
    _GLFW_PLATFORM_LIBRARY_WINDOW_STATE;
@@ -735,11 +744,11 @@ GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig);

 /*! @ingroup utility
 */
-void _glfwAllocGammaRamp(GLFWgammaramp* ramp, unsigned int size);
+void _glfwAllocGammaArrays(GLFWgammaramp* ramp, unsigned int size);

 /*! @ingroup utility
 */
-void _glfwFreeGammaRamp(GLFWgammaramp* ramp);
+void _glfwFreeGammaArrays(GLFWgammaramp* ramp);

 /*! @ingroup utility
 */
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Any
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL framework
-// Platform:    Any
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -144,8 +141,8 @@ void _glfwInputMonitorChange(void)
                window->monitor = NULL;
        }

-        if (_glfw.monitorCallback)
-            _glfw.monitorCallback((GLFWmonitor*) monitors[i], GLFW_DISCONNECTED);
+        if (_glfw.callbacks.monitor)
+            _glfw.callbacks.monitor((GLFWmonitor*) monitors[i], GLFW_DISCONNECTED);
    }

    // Find and report newly connected monitors (not in the old list)
@@ -166,8 +163,8 @@ void _glfwInputMonitorChange(void)
        if (j < monitorCount)
            continue;

-        if (_glfw.monitorCallback)
-            _glfw.monitorCallback((GLFWmonitor*) _glfw.monitors[i], GLFW_CONNECTED);
+        if (_glfw.callbacks.monitor)
+            _glfw.callbacks.monitor((GLFWmonitor*) _glfw.monitors[i], GLFW_CONNECTED);
    }

    _glfwDestroyMonitors(monitors, monitorCount);
@@ -180,7 +177,7 @@ void _glfwInputMonitorChange(void)

 _GLFWmonitor* _glfwCreateMonitor(const char* name, int widthMM, int heightMM)
 {
-    _GLFWmonitor* monitor = (_GLFWmonitor*) calloc(1, sizeof(_GLFWmonitor));
+    _GLFWmonitor* monitor = calloc(1, sizeof(_GLFWmonitor));
    monitor->name = strdup(name);
    monitor->widthMM = widthMM;
    monitor->heightMM = heightMM;
@@ -193,8 +190,8 @@ void _glfwDestroyMonitor(_GLFWmonitor* monitor)
    if (monitor == NULL)
        return;

-    _glfwFreeGammaRamp(&monitor->originalRamp);
-    _glfwFreeGammaRamp(&monitor->currentRamp);
+    _glfwFreeGammaArrays(&monitor->originalRamp);
+    _glfwFreeGammaArrays(&monitor->currentRamp);

    free(monitor->modes);
    free(monitor->name);
@@ -328,12 +325,9 @@ GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* handle)

 GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun cbfun)
 {
-    GLFWmonitorfun previous;
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = _glfw.monitorCallback;
-    _glfw.monitorCallback = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(_glfw.callbacks.monitor, cbfun);
+    return cbfun;
 }

 GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Cocoa/NSOpenGL
-// API Version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 OS X - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -74,7 +71,7 @@ int _glfwCreateContext(_GLFWwindow* window,
 {
    unsigned int attributeCount = 0;

-    // Mac OS X needs non-zero color size, so set resonable values
+    // OS X needs non-zero color size, so set resonable values
    int colorBits = fbconfig->redBits + fbconfig->greenBits + fbconfig->blueBits;
    if (colorBits == 0)
        colorBits = 24;
@@ -90,12 +87,11 @@ int _glfwCreateContext(_GLFWwindow* window,

 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
    // Fail if any OpenGL version above 2.1 other than 3.2 was requested
-    if (wndconfig->glMajor > 3 ||
-        (wndconfig->glMajor == 3 && wndconfig->glMinor != 2))
+    if (wndconfig->glMajor == 3 && wndconfig->glMinor < 2)
    {
        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                        "NSOpenGL: The targeted version of Mac OS X does not "
-                        "support any OpenGL version above 2.1 except 3.2");
+                        "NSOpenGL: The targeted version of OS X does not "
+                        "support OpenGL 3.0 or 3.1");
        return GL_FALSE;
    }

@@ -104,18 +100,18 @@ int _glfwCreateContext(_GLFWwindow* window,
        if (!wndconfig->glForward)
        {
            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                            "NSOpenGL: The targeted version of Mac OS X only "
-                            "supports OpenGL 3.2 contexts if they are "
-                            "forward-compatible");
+                            "NSOpenGL: The targeted version of OS X only "
+                            "supports OpenGL 3.2 and later versions if they "
+                            "are forward-compatible");
            return GL_FALSE;
        }

        if (wndconfig->glProfile != GLFW_OPENGL_CORE_PROFILE)
        {
            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                            "NSOpenGL: The targeted version of Mac OS X only "
-                            "supports OpenGL 3.2 contexts if they use the "
-                            "core profile");
+                            "NSOpenGL: The targeted version of OS X only "
+                            "supports OpenGL 3.2 and later versions if they "
+                            "use the core profile");
            return GL_FALSE;
        }
    }
@@ -124,7 +120,7 @@ int _glfwCreateContext(_GLFWwindow* window,
    if (wndconfig->glMajor > 2)
    {
        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                        "NSOpenGL: The targeted version of Mac OS X does not "
+                        "NSOpenGL: The targeted version of OS X does not "
                        "support OpenGL version 3.0 or above");
        return GL_FALSE;
    }
@@ -134,7 +130,7 @@ int _glfwCreateContext(_GLFWwindow* window,
    if (wndconfig->glRobustness)
    {
        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                        "NSOpenGL: Mac OS X does not support OpenGL robustness "
+                        "NSOpenGL: OS X does not support OpenGL robustness "
                        "strategies");
        return GL_FALSE;
    }
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    NSOpenGL
-// API Version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 OS X - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Any
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Win32/WGL
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 WGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -172,7 +169,7 @@ static GLboolean choosePixelFormat(_GLFWwindow* window,
        return GL_FALSE;
    }

-    usableConfigs = (_GLFWfbconfig*) calloc(nativeCount, sizeof(_GLFWfbconfig));
+    usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
    usableCount = 0;

    for (i = 0;  i < nativeCount;  i++)
@@ -297,6 +294,13 @@ static GLboolean choosePixelFormat(_GLFWwindow* window,
 //
 int _glfwInitContextAPI(void)
 {
+    _glfw.wgl.opengl32.instance = LoadLibrary(L"opengl32.dll");
+    if (!_glfw.wgl.opengl32.instance)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to load opengl32.dll");
+        return GL_FALSE;
+    }
+
    _glfw.wgl.current = TlsAlloc();
    if (_glfw.wgl.current == TLS_OUT_OF_INDEXES)
    {
@@ -316,13 +320,16 @@ void _glfwTerminateContextAPI(void)
 {
    if (_glfw.wgl.hasTLS)
        TlsFree(_glfw.wgl.current);
+
+    if (_glfw.wgl.opengl32.instance)
+        FreeLibrary(_glfw.wgl.opengl32.instance);
 }

 #define setWGLattrib(attribName, attribValue) \
 { \
    attribs[index++] = attribName; \
    attribs[index++] = attribValue; \
-    assert(index < sizeof(attribs) / sizeof(attribs[0])); \
+    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
 }

 // Prepare for creation of the OpenGL context
@@ -522,7 +529,7 @@ int _glfwAnalyzeContext(const _GLFWwindow* window,
            !window->wgl.ARB_create_context_profile ||
            !window->wgl.EXT_create_context_es2_profile)
        {
-            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+            _glfwInputError(GLFW_API_UNAVAILABLE,
                            "WGL: OpenGL ES requested but "
                            "WGL_ARB_create_context_es2_profile is unavailable");
            return _GLFW_RECREATION_IMPOSSIBLE;
@@ -590,12 +597,14 @@ void _glfwPlatformSwapInterval(int interval)
 {
    _GLFWwindow* window = _glfwPlatformGetCurrentContext();

+#if !defined(_GLFW_USE_DWM_SWAP_INTERVAL)
    if (_glfwIsCompositionEnabled())
    {
        // Don't enabled vsync when desktop compositing is enabled, as it leads
        // to frame jitter
        return;
    }
+#endif

    if (window->wgl.EXT_swap_control)
        window->wgl.SwapIntervalEXT(interval);
@@ -632,7 +641,11 @@ int _glfwPlatformExtensionSupported(const char* extension)

 GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
 {
-    return (GLFWglproc) wglGetProcAddress(procname);
+    const GLFWglproc proc = (GLFWglproc) wglGetProcAddress(procname);
+    if (proc)
+        return proc;
+
+    return (GLFWglproc) GetProcAddress(_glfw.wgl.opengl32.instance, procname);
 }


@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    WGL
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 WGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -77,8 +74,13 @@ typedef struct _GLFWcontextWGL
 //------------------------------------------------------------------------
 typedef struct _GLFWlibraryWGL
 {
-    GLboolean   hasTLS;
-    DWORD       current;
+    GLboolean       hasTLS;
+    DWORD           current;
+
+    // opengl32.dll
+    struct {
+        HINSTANCE   instance;
+    } opengl32;

 } _GLFWlibraryWGL;

@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Win32
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Win32
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -50,7 +47,7 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
    GetDeviceGammaRamp(dc, values);
    DeleteDC(dc);

-    _glfwAllocGammaRamp(ramp, 256);
+    _glfwAllocGammaArrays(ramp, 256);

    memcpy(ramp->red,   values +   0, 256 * sizeof(unsigned short));
    memcpy(ramp->green, values + 256, 256 * sizeof(unsigned short));
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Win32/WGL
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -39,6 +36,15 @@
 #endif // __BORLANDC__


+#if defined(_GLFW_USE_OPTIMUS_HPG)
+
+// Applications exporting this symbol with this value will be automatically
+// directed to the high-performance GPU on nVidia Optimus systems
+//
+GLFWAPI DWORD NvOptimusEnablement = 0x00000001;
+
+#endif // _GLFW_USE_OPTIMUS_HPG
+
 #if defined(_GLFW_BUILD_DLL)

 // GLFW DLL entry point
@@ -98,7 +104,7 @@ static GLboolean initLibraries(void)

 // Unload used libraries (DLLs)
 //
-static void freeLibraries(void)
+static void terminateLibraries(void)
 {
 #ifndef _GLFW_NO_DLOAD_WINMM
    if (_glfw.win32.winmm.instance != NULL)
@@ -107,6 +113,12 @@ static void freeLibraries(void)
        _glfw.win32.winmm.instance = NULL;
    }
 #endif // _GLFW_NO_DLOAD_WINMM
+
+    if (_glfw.win32.user32.instance)
+        FreeLibrary(_glfw.win32.user32.instance);
+
+    if (_glfw.win32.dwmapi.instance)
+        FreeLibrary(_glfw.win32.dwmapi.instance);
 }


@@ -140,7 +152,7 @@ WCHAR* _glfwCreateWideStringFromUTF8(const char* source)
    if (!length)
        return NULL;

-    target = (WCHAR*) malloc(sizeof(WCHAR) * (length + 1));
+    target = calloc(length + 1, sizeof(WCHAR));

    if (!MultiByteToWideChar(CP_UTF8, 0, source, -1, target, length + 1))
    {
@@ -162,7 +174,7 @@ char* _glfwCreateUTF8FromWideString(const WCHAR* source)
    if (!length)
        return NULL;

-    target = (char*) malloc(length + 1);
+    target = calloc(length + 1, sizeof(char));

    if (!WideCharToMultiByte(CP_UTF8, 0, source, -1, target, length + 1, NULL, NULL))
    {
@@ -204,7 +216,6 @@ int _glfwPlatformInit(void)
        return GL_FALSE;

    _glfwInitTimer();
-
    _glfwInitJoysticks();

    return GL_TRUE;
@@ -218,16 +229,16 @@ void _glfwPlatformTerminate(void)
        _glfw.win32.classAtom = 0;
    }

-    _glfwTerminateContextAPI();
-
-    _glfwTerminateJoysticks();
-
-    freeLibraries();
-
-    // Restore previous FOREGROUNDLOCKTIMEOUT system setting
+    // Restore previous foreground lock timeout system setting
    SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0,
                         UIntToPtr(_glfw.win32.foregroundLockTimeout),
                         SPIF_SENDCHANGE);
+
+    free(_glfw.win32.clipboardString);
+
+    _glfwTerminateJoysticks();
+    _glfwTerminateContextAPI();
+    terminateLibraries();
 }

 const char* _glfwPlatformGetVersionString(void)
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Win32
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11 (Unix)
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Win32
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Win32
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Win32/WGL
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -483,6 +480,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
        }

        case WM_CHAR:
+        case WM_SYSCHAR:
        {
            _glfwInputChar(window, (unsigned int) wParam);
            return 0;
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    Any
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -158,7 +155,7 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
    if (width <= 0 || height <= 0)
    {
        _glfwInputError(GLFW_INVALID_VALUE, "Invalid window size");
-        return GL_FALSE;
+        return NULL;
    }

    // Set up desired framebuffer config
@@ -196,9 +193,9 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,

    // Check the OpenGL bits of the window config
    if (!_glfwIsValidContextConfig(&wndconfig))
-        return GL_FALSE;
+        return NULL;

-    window = (_GLFWwindow*) calloc(1, sizeof(_GLFWwindow));
+    window = calloc(1, sizeof(_GLFWwindow));
    window->next = _glfw.windowListHead;
    _glfw.windowListHead = window;

@@ -229,7 +226,7 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
    {
        glfwDestroyWindow((GLFWwindow*) window);
        glfwMakeContextCurrent((GLFWwindow*) previous);
-        return GL_FALSE;
+        return NULL;
    }

    glfwMakeContextCurrent((GLFWwindow*) window);
@@ -239,7 +236,7 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
    {
        glfwDestroyWindow((GLFWwindow*) window);
        glfwMakeContextCurrent((GLFWwindow*) previous);
-        return GL_FALSE;
+        return NULL;
    }

    // Verify the context against the requested parameters
@@ -247,7 +244,7 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
    {
        glfwDestroyWindow((GLFWwindow*) window);
        glfwMakeContextCurrent((GLFWwindow*) previous);
-        return GL_FALSE;
+        return NULL;
    }

    // Clearing the front buffer to black to avoid garbage pixels left over
@@ -284,6 +281,7 @@ void glfwDefaultWindowHints(void)
    _glfw.hints.redBits     = 8;
    _glfw.hints.greenBits   = 8;
    _glfw.hints.blueBits    = 8;
+    _glfw.hints.alphaBits   = 8;
    _glfw.hints.depthBits   = 24;
    _glfw.hints.stencilBits = 8;
 }
@@ -603,91 +601,63 @@ GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* handle,
                                                  GLFWwindowposfun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWwindowposfun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.pos;
-    window->callbacks.pos = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.pos, cbfun);
+    return cbfun;
 }

 GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* handle,
                                                    GLFWwindowsizefun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWwindowsizefun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.size;
-    window->callbacks.size = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.size, cbfun);
+    return cbfun;
 }

 GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* handle,
                                                      GLFWwindowclosefun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWwindowclosefun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.close;
-    window->callbacks.close = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.close, cbfun);
+    return cbfun;
 }

 GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* handle,
                                                          GLFWwindowrefreshfun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWwindowrefreshfun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.refresh;
-    window->callbacks.refresh = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.refresh, cbfun);
+    return cbfun;
 }

 GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* handle,
                                                      GLFWwindowfocusfun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWwindowfocusfun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.focus;
-    window->callbacks.focus = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.focus, cbfun);
+    return cbfun;
 }

 GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* handle,
                                                          GLFWwindowiconifyfun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWwindowiconifyfun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.iconify;
-    window->callbacks.iconify = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.iconify, cbfun);
+    return cbfun;
 }

 GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* handle,
                                                              GLFWframebuffersizefun cbfun)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
-    GLFWframebuffersizefun previous;
-
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
-    previous = window->callbacks.fbsize;
-    window->callbacks.fbsize = cbfun;
-    return previous;
+    _GLFW_SWAP_POINTERS(window->callbacks.fbsize, cbfun);
+    return cbfun;
 }

 GLFWAPI void glfwPollEvents(void)
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -273,11 +270,11 @@ void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)

 const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
 {
-    int i;
+    size_t i;
    const Atom formats[] = { _glfw.x11.UTF8_STRING,
                             _glfw.x11.COMPOUND_STRING,
                             XA_STRING };
-    const int formatCount = sizeof(formats) / sizeof(formats[0]);
+    const size_t formatCount = sizeof(formats) / sizeof(formats[0]);

    if (_glfwFindWindowByHandle(XGetSelectionOwner(_glfw.x11.display,
                                                   _glfw.x11.CLIPBOARD)))
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
 //
@@ -79,7 +76,7 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
        XRRCrtcGamma* gamma = XRRGetCrtcGamma(_glfw.x11.display,
                                              monitor->x11.crtc);

-        _glfwAllocGammaRamp(ramp, size);
+        _glfwAllocGammaArrays(ramp, size);

        memcpy(ramp->red, gamma->red, size * sizeof(unsigned short));
        memcpy(ramp->green, gamma->green, size * sizeof(unsigned short));
@@ -92,7 +89,7 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
        int size;
        XF86VidModeGetGammaRampSize(_glfw.x11.display, _glfw.x11.screen, &size);

-        _glfwAllocGammaRamp(ramp, size);
+        _glfwAllocGammaArrays(ramp, size);

        XF86VidModeGetGammaRamp(_glfw.x11.display,
                                _glfw.x11.screen,
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11/GLX
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -51,7 +48,7 @@ static int translateKey(int keyCode)
    // Note: This way we always force "NumLock = ON", which is intentional
    // since the returned key code should correspond to a physical
    // location.
-    keySym = XkbKeycodeToKeysym(_glfw.x11.display, keyCode, 1, 0);
+    keySym = XkbKeycodeToKeysym(_glfw.x11.display, keyCode, 0, 1);
    switch (keySym)
    {
        case XK_KP_0:           return GLFW_KEY_KP_0;
@@ -420,21 +417,10 @@ static void detectEWMH(void)

 // Initialize X11 display and look for supported X11 extensions
 //
-static GLboolean initDisplay(void)
+static GLboolean initExtensions(void)
 {
    Bool supported;

-    _glfw.x11.display = XOpenDisplay(NULL);
-    if (!_glfw.x11.display)
-    {
-        _glfwInputError(GLFW_API_UNAVAILABLE, "X11: Failed to open X display");
-        return GL_FALSE;
-    }
-
-    _glfw.x11.screen = DefaultScreen(_glfw.x11.display);
-    _glfw.x11.root = RootWindow(_glfw.x11.display, _glfw.x11.screen);
-    _glfw.x11.context = XUniqueContext();
-
    // Find or create window manager atoms
    _glfw.x11.WM_STATE = XInternAtom(_glfw.x11.display, "WM_STATE", False);
    _glfw.x11.WM_DELETE_WINDOW = XInternAtom(_glfw.x11.display,
@@ -564,7 +550,7 @@ static Cursor createNULLCursor(void)
    XColor col;
    Cursor cursor;

-    // TODO: Add error checks
+    _glfwGrabXErrorHandler();

    cursormask = XCreatePixmap(_glfw.x11.display, _glfw.x11.root, 1, 1, 1);
    xgc.function = GXclear;
@@ -579,6 +565,14 @@ static Cursor createNULLCursor(void)
    XFreePixmap(_glfw.x11.display, cursormask);
    XFreeGC(_glfw.x11.display, gc);

+    _glfwReleaseXErrorHandler();
+
+    if (cursor == None)
+    {
+        _glfwInputXError(GLFW_PLATFORM_ERROR,
+                         "X11: Failed to create null cursor");
+    }
+
    return cursor;
 }

@@ -593,6 +587,47 @@ static void terminateDisplay(void)
    }
 }

+// X error handler
+//
+static int errorHandler(Display *display, XErrorEvent* event)
+{
+    _glfw.x11.errorCode = event->error_code;
+    return 0;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Install the X error handler
+//
+void _glfwGrabXErrorHandler(void)
+{
+    _glfw.x11.errorCode = Success;
+    XSetErrorHandler(errorHandler);
+}
+
+// Remove the X error handler
+//
+void _glfwReleaseXErrorHandler(void)
+{
+    // Synchronize to make sure all commands are processed
+    XSync(_glfw.x11.display, False);
+    XSetErrorHandler(NULL);
+}
+
+// Report X error
+//
+void _glfwInputXError(int error, const char* message)
+{
+    char buffer[8192];
+    XGetErrorText(_glfw.x11.display, _glfw.x11.errorCode,
+                  buffer, sizeof(buffer));
+
+    _glfwInputError(error, "%s: %s", message, buffer);
+}
+

 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
@@ -602,20 +637,28 @@ int _glfwPlatformInit(void)
 {
    XInitThreads();

-    if (!initDisplay())
+    _glfw.x11.display = XOpenDisplay(NULL);
+    if (!_glfw.x11.display)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "X11: Failed to open X display");
        return GL_FALSE;
+    }

-    _glfwInitGammaRamp();
+    _glfw.x11.screen = DefaultScreen(_glfw.x11.display);
+    _glfw.x11.root = RootWindow(_glfw.x11.display, _glfw.x11.screen);
+    _glfw.x11.context = XUniqueContext();

-    if (!_glfwInitContextAPI())
+    if (!initExtensions())
        return GL_FALSE;

    _glfw.x11.cursor = createNULLCursor();

-    if (!_glfwInitJoysticks())
+    if (!_glfwInitContextAPI())
        return GL_FALSE;

    _glfwInitTimer();
+    _glfwInitJoysticks();
+    _glfwInitGammaRamp();

    return GL_TRUE;
 }
@@ -628,14 +671,11 @@ void _glfwPlatformTerminate(void)
        _glfw.x11.cursor = (Cursor) 0;
    }

+    free(_glfw.x11.selection.string);
+
    _glfwTerminateJoysticks();
-
    _glfwTerminateContextAPI();
-
    terminateDisplay();
-
-    if (_glfw.x11.selection.string)
-        free(_glfw.x11.selection.string);
 }

 const char* _glfwPlatformGetVersionString(void)
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -80,8 +77,8 @@ static int openJoystickDevice(int joy, const char* path)
    ioctl(fd, JSIOCGBUTTONS, &buttonCount);
    _glfw.x11.joystick[joy].buttonCount = (int) buttonCount;

-    _glfw.x11.joystick[joy].axes = (float*) calloc(axisCount, sizeof(float));
-    _glfw.x11.joystick[joy].buttons = (unsigned char*) calloc(buttonCount, 1);
+    _glfw.x11.joystick[joy].axes = calloc(axisCount, sizeof(float));
+    _glfw.x11.joystick[joy].buttons = calloc(buttonCount, 1);

    _glfw.x11.joystick[joy].present = GL_TRUE;
 #endif // __linux__
@@ -159,10 +156,11 @@ static void pollJoystickEvents(void)

 // Initialize joystick interface
 //
-int _glfwInitJoysticks(void)
+void _glfwInitJoysticks(void)
 {
 #ifdef __linux__
-    int i, joy = 0;
+    int joy = 0;
+    size_t i;
    regex_t regex;
    DIR* dir;
    const char* dirs[] =
@@ -174,7 +172,7 @@ int _glfwInitJoysticks(void)
    if (regcomp(&regex, "^js[0-9]\\+$", 0) != 0)
    {
        _glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to compile regex");
-        return GL_FALSE;
+        return;
    }

    for (i = 0;  i < sizeof(dirs) / sizeof(dirs[0]);  i++)
@@ -203,8 +201,6 @@ int _glfwInitJoysticks(void)

    regfree(&regex);
 #endif // __linux__
-
-    return GL_TRUE;
 }

 // Close all opened joystick handles
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11 (Unix)
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -114,7 +111,8 @@ void _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
            }
        }

-        monitor->x11.oldMode = ci->mode;
+        if (monitor->x11.oldMode == None)
+            monitor->x11.oldMode = ci->mode;

        XRRSetCrtcConfig(_glfw.x11.display,
                         sr, monitor->x11.crtc,
@@ -140,6 +138,9 @@ void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
        XRRScreenResources* sr;
        XRRCrtcInfo* ci;

+        if (monitor->x11.oldMode == None)
+            return;
+
        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
        ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);

@@ -154,6 +155,8 @@ void _glfwRestoreVideoMode(_GLFWmonitor* monitor)

        XRRFreeCrtcInfo(ci);
        XRRFreeScreenResources(sr);
+
+        monitor->x11.oldMode = None;
    }
 }

@@ -177,7 +180,7 @@ _GLFWmonitor** _glfwPlatformGetMonitors(int* count)
        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
        primary = XRRGetOutputPrimary(_glfw.x11.display, _glfw.x11.root);

-        monitors = (_GLFWmonitor**) calloc(sr->ncrtc, sizeof(_GLFWmonitor*));
+        monitors = calloc(sr->ncrtc, sizeof(_GLFWmonitor*));

        for (i = 0;  i < sr->ncrtc;  i++)
        {
@@ -247,7 +250,7 @@ _GLFWmonitor** _glfwPlatformGetMonitors(int* count)
    }
    else
    {
-        monitors = (_GLFWmonitor**) calloc(1, sizeof(_GLFWmonitor*));
+        monitors = calloc(1, sizeof(_GLFWmonitor*));
        monitors[0] = _glfwCreateMonitor("Display",
                                         DisplayWidthMM(_glfw.x11.display,
                                                        _glfw.x11.screen),
@@ -312,7 +315,7 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
        oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);

-        result = (GLFWvidmode*) malloc(sizeof(GLFWvidmode) * oi->nmode);
+        result = calloc(oi->nmode, sizeof(GLFWvidmode));

        for (i = 0;  i < oi->nmode;  i++)
        {
@@ -354,7 +357,7 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
    {
        *found = 1;

-        result = (GLFWvidmode*) malloc(sizeof(GLFWvidmode));
+        result = calloc(1, sizeof(GLFWvidmode));

        result[0].width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
        result[0].height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -137,6 +134,9 @@ typedef struct _GLFWlibraryX11
    // True if window manager supports EWMH
    GLboolean       hasEWMH;

+    // Error code received by the X error handler
+    int             errorCode;
+
    struct {
        GLboolean   available;
        int         eventBase;
@@ -173,7 +173,7 @@ typedef struct _GLFWlibraryX11
    int             keyCodeLUT[256];

    struct {
-        GLboolean   changed;
+        int         count;
        int         timeout;
        int         interval;
        int         blanking;
@@ -238,7 +238,7 @@ void _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired);
 void _glfwRestoreVideoMode(_GLFWmonitor* monitor);

 // Joystick input
-int  _glfwInitJoysticks(void);
+void _glfwInitJoysticks(void);
 void _glfwTerminateJoysticks(void);

 // Unicode support
@@ -256,4 +256,9 @@ unsigned long _glfwGetWindowProperty(Window window,
                                     Atom type,
                                     unsigned char** value);

+// X11 error handler
+void _glfwGrabXErrorHandler(void);
+void _glfwReleaseXErrorHandler(void);
+void _glfwInputXError(int error, const char* message);
+
 #endif // _x11_platform_h_
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -1,8 +1,5 @@
 //========================================================================
-// GLFW - An OpenGL library
-// Platform:    X11
-// API version: 3.0
-// WWW:         http://www.glfw.org/
+// GLFW 3.0 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
@@ -361,7 +358,7 @@ static void showCursor(_GLFWwindow* window)
 //
 static void enterFullscreenMode(_GLFWwindow* window)
 {
-    if (!_glfw.x11.saver.changed)
+    if (_glfw.x11.saver.count == 0)
    {
        // Remember old screen saver settings
        XGetScreenSaver(_glfw.x11.display,
@@ -373,10 +370,10 @@ static void enterFullscreenMode(_GLFWwindow* window)
        // Disable screen saver
        XSetScreenSaver(_glfw.x11.display, 0, 0, DontPreferBlanking,
                        DefaultExposures);
-
-        _glfw.x11.saver.changed = GL_TRUE;
    }

+    _glfw.x11.saver.count++;
+
    _glfwSetVideoMode(window->monitor, &window->videoMode);

    if (_glfw.x11.hasEWMH &&
@@ -455,7 +452,9 @@ static void leaveFullscreenMode(_GLFWwindow* window)
 {
    _glfwRestoreVideoMode(window->monitor);

-    if (_glfw.x11.saver.changed)
+    _glfw.x11.saver.count--;
+
+    if (_glfw.x11.saver.count == 0)
    {
        // Restore old screen saver settings
        XSetScreenSaver(_glfw.x11.display,
@@ -463,8 +462,6 @@ static void leaveFullscreenMode(_GLFWwindow* window)
                        _glfw.x11.saver.interval,
                        _glfw.x11.saver.blanking,
                        _glfw.x11.saver.exposure);
-
-        _glfw.x11.saver.changed = GL_FALSE;
    }

    if (_glfw.x11.hasEWMH &&
@@ -505,8 +502,7 @@ static void processEvent(XEvent *event)
        window = _glfwFindWindowByHandle(event->xany.window);
        if (window == NULL)
        {
-            // This is either an event for a destroyed GLFW window or an event
-            // of a type not currently supported by GLFW
+            // This is an event for a window that has already been destroyed
            return;
        }
    }
@@ -517,11 +513,12 @@ static void processEvent(XEvent *event)
        {
            const int key = translateKey(event->xkey.keycode);
            const int mods = translateState(event->xkey.state);
+            const int character = translateChar(&event->xkey);

            _glfwInputKey(window, key, event->xkey.keycode, GLFW_PRESS, mods);

-            if (!(mods & GLFW_MOD_CONTROL) && !(mods & GLFW_MOD_ALT))
-                _glfwInputChar(window, translateChar(&event->xkey));
+            if (character != -1)
+                _glfwInputChar(window, character);

            break;
        }
@@ -985,6 +982,17 @@ 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)
+    {
+        int left, top;
+
+        XTranslateCoordinates(_glfw.x11.display, window->x11.handle, child,
+                              0, 0, &left, &top, &child);
+
+        x -= left;
+        y -= top;
+    }
+
    if (xpos)
        *xpos = x;
    if (ypos)
@@ -1010,34 +1018,36 @@ void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)

 void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
 {
-    if (!window->resizable)
-    {
-        // Update window size restrictions to match new window size
-
-        XSizeHints* hints = XAllocSizeHints();
-
-        hints->flags |= (PMinSize | PMaxSize);
-        hints->min_width  = hints->max_width  = width;
-        hints->min_height = hints->max_height = height;
-
-        XSetWMNormalHints(_glfw.x11.display, window->x11.handle, hints);
-        XFree(hints);
-    }
-
    if (window->monitor)
    {
+        _glfwSetVideoMode(window->monitor, &window->videoMode);
+
        if (window->x11.overrideRedirect)
        {
            GLFWvidmode mode;
            _glfwPlatformGetVideoMode(window->monitor, &mode);
            XResizeWindow(_glfw.x11.display, window->x11.handle,
-                          window->videoMode.width, window->videoMode.height);
+                          mode.width, mode.height);
        }
-
-        _glfwSetVideoMode(window->monitor, &window->videoMode);
    }
    else
+    {
+        if (!window->resizable)
+        {
+            // Update window size restrictions to match new window size
+
+            XSizeHints* hints = XAllocSizeHints();
+
+            hints->flags |= (PMinSize | PMaxSize);
+            hints->min_width  = hints->max_width  = width;
+            hints->min_height = hints->max_height = height;
+
+            XSetWMNormalHints(_glfw.x11.display, window->x11.handle, hints);
+            XFree(hints);
+        }
+
        XResizeWindow(_glfw.x11.display, window->x11.handle, width, height);
+    }

    XFlush(_glfw.x11.display);
 }
@@ -1093,24 +1103,12 @@ void _glfwPlatformPollEvents(void)
        processEvent(&event);
    }

-    // Check whether the cursor has moved inside an focused window that has
-    // captured the cursor (because then it needs to be re-centered)
-
-    _GLFWwindow* window;
-    window = _glfw.focusedWindow;
-    if (window)
+    _GLFWwindow* window = _glfw.focusedWindow;
+    if (window && window->cursorMode == GLFW_CURSOR_DISABLED)
    {
-        if (window->cursorMode == GLFW_CURSOR_DISABLED)
-        {
-            int width, height;
-            _glfwPlatformGetWindowSize(window, &width, &height);
-            _glfwPlatformSetCursorPos(window, width / 2, height / 2);
-
-            // NOTE: This is a temporary fix.  It works as long as you use
-            //       offsets accumulated over the course of a frame, instead of
-            //       performing the necessary actions per callback call.
-            XFlush(_glfw.x11.display);
-        }
+        int width, height;
+        _glfwPlatformGetWindowSize(window, &width, &height);
+        _glfwPlatformSetCursorPos(window, width / 2, height / 2);
    }
 }

@@ -11,10 +11,6 @@ endif()
 include_directories(${GLFW_SOURCE_DIR}/include
                    ${GLFW_SOURCE_DIR}/deps)

-if (MSVC)
-    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-endif()
-
 if (NOT APPLE)
    # HACK: This is NOTFOUND on OS X 10.8
    include_directories(${OPENGL_INCLUDE_DIR})
Author	SHA1	Message	Date
Camilla Berglund	58aef89521	Made release description match website.	2013-08-25 21:40:06 +02:00
Camilla Berglund	f54b4e174d	Fixed error code for missing GLES.	2013-08-21 11:56:48 +02:00
Camilla Berglund	83f57ff0ce	Fixed potential segfault on init.	2013-08-21 10:15:52 +02:00
Camilla Berglund	71c07feffd	Added description of 3.0.2 release.	2013-08-20 12:46:32 +02:00
Camilla Berglund	9c20737b60	Allowed characters regardless of modifier keys.	2013-08-19 13:08:35 +02:00
Camilla Berglund	951f02acf3	Fixed keypad 5 release events.	2013-08-16 17:48:11 +02:00
Camilla Berglund	735bc2d815	Added NvOptimusEnablement.	2013-08-07 18:11:58 +02:00
Camilla Berglund	a024e61bf8	Build documentation improvements.	2013-08-07 17:53:19 +02:00
Camilla Berglund	082fc019c7	Build documentation improvements.	2013-08-07 17:17:15 +02:00
Camilla Berglund	ffb699fb06	Build documentation improvements.	2013-08-07 17:05:32 +02:00
Camilla Berglund	d318de7c00	Expanded section on X11 and Mesa packages.	2013-08-07 16:01:38 +02:00
Camilla Berglund	68bd6687d6	Formatting.	2013-08-07 15:30:15 +02:00
Camilla Berglund	a3ca7ad93a	Removed cursor centering XFlush hack.	2013-08-06 20:48:31 +02:00
Camilla Berglund	261f290abf	Fixed original video mode being overwritten.	2013-08-06 19:52:09 +02:00
Camilla Berglund	63a191eb8d	Added clearing of callbacks on terminate.	2013-07-30 17:06:06 +02:00
arturo	a6a5fa937c	Fixed window position being incorrect on some WMs.	2013-07-30 15:52:47 +02:00
Camilla Berglund	670070e61a	Updated change log.	2013-07-30 15:02:08 +02:00
Camilla Berglund	3cfc400cf9	Simplified source file comment headers.	2013-07-30 14:46:52 +02:00
Camilla Berglund	6e85924bd3	Replaced selector test with NSAppKitVersionNumber.	2013-07-30 14:46:51 +02:00
Camilla Berglund	f7282e86c0	Added pointer swap macro for callback setters.	2013-07-30 14:44:56 +02:00
Camilla Berglund	9d0e102135	Fixed glfwCreateWindow return value semantics.	2013-07-30 14:44:56 +02:00
Camilla Berglund	5b8ff4a2fc	Merge pull request #102 from shurcooL/patch-1 Fixed OS X precise scrolling delta logic.	2013-07-25 03:44:36 -07:00
Dmitri Shuralyov	c99b7fe7da	Fixed #if-guard logic and signature for hasPreciseScrollingDeltas.	2013-07-24 23:06:58 -07:00
Camilla Berglund	bd2d571c31	Added explanation for #error.	2013-07-23 13:44:39 +02:00
Camilla Berglund	bea59f64b2	Enabled inclusion of stddef.h on all platforms. The OS X gl.h defines section macros that prevents glext.h from including stddef.h, leaving it undeclared when it's later used.	2013-07-23 00:20:23 +02:00
Camilla Berglund	00d004a528	Updated extension headers.	2013-07-23 00:12:09 +02:00
Camilla Berglund	53cf4a3b4d	Merge pull request #95 from shurcooL/master Added support for Cocoa precise scrolling deltas.	2013-07-21 14:08:50 -07:00
Camilla Berglund	7e8c7843c5	Updated extension headers.	2013-07-21 14:08:55 +02:00
Dmitri Shuralyov	5655e26315	Changed scrollWheel to use precise scrolling deltas when available. Use precise scrolling deltas only on supported versions of OS X; hasPreciseScrollingDeltas, scrollingDeltaX, scrollingDeltaY are available in OS X v10.7 and later. Replaced a single occurence of a tab character with 4 spaces for consistency in src/socoa_window.m.	2013-07-17 19:36:43 -07:00
siavash	0463e196b4	Cleanup of size_t use.	2013-07-15 18:37:02 +02:00
siavash	b12c973922	Moved X11 character translation failure test.	2013-07-15 18:28:09 +02:00
Camilla Berglund	f1397843ee	Added GLFW_OPENED to transition guide.	2013-07-11 14:01:06 +02:00
Camilla Berglund	6632cc7c1d	Tagged close flag for use from secondary threads.	2013-07-11 02:00:48 +02:00
Camilla Berglund	45653c5549	Cleaned up X error handler work.	2013-07-11 01:32:46 +02:00
Camilla Berglund	f67c7b49ab	Merge pull request #86 from siavashserver/master Added utility functions for X11 error handler.	2013-07-10 15:46:49 -07:00
Camilla Berglund	50b2961d34	Moved to auto-updated docs URLs.	2013-07-10 17:00:09 +02:00
Camilla Berglund	d10eff4531	Updated OS X OpenGL compatibility docs.	2013-07-10 15:47:32 +02:00
Camilla Berglund	e67ee935a2	Fixed documentation tag name.	2013-07-10 15:39:08 +02:00
Camilla Berglund	41a1374744	Updated references to OS X (previously Mac OS X).	2013-07-10 15:38:31 +02:00
Camilla Berglund	c8b01f61d6	Enabled OpenGL 3.x and 4.x context on OS X 10.9.	2013-07-10 15:03:14 +02:00
siavash	3b4eb2f0a0	Added blank cursor creation error checking on X11.	2013-07-09 21:08:21 +04:30
Camilla Berglund	d20aa0428a	Fixed window positioning on OS X.	2013-07-09 17:08:26 +02:00
Camilla Berglund	1c80e99008	Added forcing of swap interval on DWM composition.	2013-07-08 00:32:23 +02:00
Camilla Berglund	0e12fb869c	Merge pull request #84 from Nibe/cursor-fix Fixed saved cursor position not being restored.	2013-07-07 15:31:17 -07:00
Niklas Behrens	a55c3f48eb	Fix incorrect cursor position When reactivating the cursor its position was updated visually but not internally which caused glfwGetCursorPos to return wrong values.	2013-07-07 22:05:29 +02:00
Camilla Berglund	4b7ae4918b	Documentation work.	2013-07-07 12:59:30 +02:00
siavash	763ec6cbcb	Cleanup.	2013-07-05 14:29:12 +02:00
Camilla Berglund	dcb4d8ee32	Fixed possible X11 screensaver race condition.	2013-07-04 17:52:15 +02:00
Camilla Berglund	58c69a9ac4	Enabled compilation on OS X 10.6 SDK.	2013-07-04 15:02:01 +02:00
Camilla Berglund	7a03ca8dbc	Removed superflous casts of allocated memory.	2013-07-04 14:54:07 +02:00
Camilla Berglund	d7512f529c	Clarified names of gamma array helper functions.	2013-07-04 14:52:58 +02:00
Camilla Berglund	209a470a5f	Replaced all uses of malloc with calloc.	2013-07-04 14:20:14 +02:00
Camilla Berglund	1947557eb1	Documentation work.	2013-07-04 13:05:19 +02:00
Camilla Berglund	621753e8a8	Added credit.	2013-07-01 13:18:05 +02:00
Camilla Berglund	fca5a4687c	Merge pull request #73 from waywardmonkeys/typo-fixes Fixed typo.	2013-06-30 11:47:44 -07:00
Bruce Mitchener	5f37d36d4a	Fix typo.	2013-06-27 17:28:31 +07:00
Camilla Berglund	2656bf8f9f	Added missing module handle freeing.	2013-06-26 14:04:07 +02:00
Camilla Berglund	194e22dbbe	Fixed retrieval of OpenGL 1.0 and 1.1 on WGL.	2013-06-26 13:57:09 +02:00
Camilla Berglund	4883073b91	Cleanup.	2013-06-24 14:38:00 +02:00
Camilla Berglund	a17dad4f44	Updated contact information.	2013-06-24 14:28:42 +02:00
Camilla Berglund	2ce9e8e6b2	Fixed clipboard string leaks. The clipboard string was not by the Win32 and Cocoa ports on terminate.	2013-06-24 14:08:55 +02:00
Camilla Berglund	b6b57b5249	Documentation work.	2013-06-23 15:17:43 +02:00
Camilla Berglund	659157928e	Client build documentation work.	2013-06-21 13:04:47 +02:00
Camilla Berglund	933005a022	Corrected comment.	2013-06-19 13:49:51 +02:00
Camilla Berglund	3be3f58a92	Cleanup.	2013-06-19 13:47:19 +02:00
Camilla Berglund	e11a5e3973	Fixed resizing for full screen override redirect.	2013-06-19 13:47:19 +02:00
Camilla Berglund	96259004be	Merge pull request #60 from Cloudef/EGL Explicitly cast default EGL display.	2013-06-19 03:09:07 -07:00
Jari Vetoniemi	5c54987285	Typecast EGL types to get rid of compile warnings	2013-06-17 19:25:41 +03:00
Camilla Berglund	c10bf9ba9c	Fixed incorrect hint default. The default for the GLFW_ALPHA_BITS hint was zero instead of 8.	2013-06-17 17:42:25 +02:00
Camilla Berglund	5ae2e376a2	Added missing file to .gitignore.	2013-06-17 17:36:52 +02:00
Camilla Berglund	f5f55e3ff8	Documentation work.	2013-06-17 14:15:35 +02:00
Camilla Berglund	10017b27bb	Cleanup.	2013-06-17 12:46:51 +02:00
Camilla Berglund	1de60a4ff7	Started 3.0.2.	2013-06-17 12:46:44 +02:00
Camilla Berglund	01ccc56423	Added missing headers to library target.	2013-06-17 10:31:25 +02:00
Camilla Berglund	305c66db31	Cleanup.	2013-06-17 10:25:17 +02:00