Changed toolset to vs11, for future Havok implementation.

libs/glfw-3.0.4/src/CMakeLists.txt

@@ -0,0 +1,88 @@
+
+include_directories(${GLFW_SOURCE_DIR}/src
+                    ${GLFW_BINARY_DIR}/src
+                    ${glfw_INCLUDE_DIRS})
+
+add_definitions(-D_GLFW_USE_CONFIG_H)
+
+set(common_HEADERS ${GLFW_BINARY_DIR}/src/glfw_config.h internal.h
+                   ${GLFW_SOURCE_DIR}/include/GLFW/glfw3.h
+                   ${GLFW_SOURCE_DIR}/include/GLFW/glfw3native.h)
+set(common_SOURCES clipboard.c context.c gamma.c init.c input.c joystick.c
+                   monitor.c time.c window.c)
+
+if (_GLFW_COCOA)
+    set(glfw_HEADERS ${common_HEADERS} cocoa_platform.h)
+    set(glfw_SOURCES ${common_SOURCES} cocoa_clipboard.m cocoa_gamma.c
+                     cocoa_init.m cocoa_joystick.m cocoa_monitor.m cocoa_time.c
+                     cocoa_window.m)
+elseif (_GLFW_WIN32)
+    set(glfw_HEADERS ${common_HEADERS} win32_platform.h)
+    set(glfw_SOURCES ${common_SOURCES} win32_clipboard.c win32_gamma.c
+                     win32_init.c win32_joystick.c win32_monitor.c win32_time.c
+                     win32_window.c)
+elseif (_GLFW_X11)
+    set(glfw_HEADERS ${common_HEADERS} x11_platform.h)
+    set(glfw_SOURCES ${common_SOURCES} x11_clipboard.c x11_gamma.c x11_init.c
+                     x11_joystick.c x11_monitor.c x11_time.c x11_window.c
+                     x11_unicode.c)
+endif()
+
+if (_GLFW_EGL)
+    list(APPEND glfw_HEADERS ${common_HEADERS} egl_platform.h)
+    list(APPEND glfw_SOURCES ${common_SOURCES} egl_context.c)
+elseif (_GLFW_NSGL)
+    list(APPEND glfw_HEADERS ${common_HEADERS} nsgl_platform.h)
+    list(APPEND glfw_SOURCES ${common_SOURCES} nsgl_context.m)
+elseif (_GLFW_WGL)
+    list(APPEND glfw_HEADERS ${common_HEADERS} wgl_platform.h)
+    list(APPEND glfw_SOURCES ${common_SOURCES} wgl_context.c)
+elseif (_GLFW_X11)
+    list(APPEND glfw_HEADERS ${common_HEADERS} glx_platform.h)
+    list(APPEND glfw_SOURCES ${common_SOURCES} glx_context.c)
+endif()
+
+if (APPLE)
+    # For some reason, CMake doesn't know about .m
+    set_source_files_properties(${glfw_SOURCES} PROPERTIES LANGUAGE C)
+endif()
+
+add_library(glfw ${glfw_SOURCES} ${glfw_HEADERS})
+set_target_properties(glfw PROPERTIES OUTPUT_NAME "${GLFW_LIB_NAME}")
+
+if (BUILD_SHARED_LIBS)
+    # Include version information in the output
+    set_target_properties(glfw PROPERTIES VERSION ${GLFW_VERSION})
+    if (UNIX)
+        set_target_properties(glfw PROPERTIES SOVERSION ${GLFW_VERSION_MAJOR})
+    endif()
+
+    if (WIN32)
+        # The GLFW DLL needs a special compile-time macro and import library name
+        set_target_properties(glfw PROPERTIES PREFIX "" IMPORT_PREFIX "")
+
+        if (MINGW)
+            set_target_properties(glfw PROPERTIES IMPORT_SUFFIX "dll.a")
+        else()
+            set_target_properties(glfw PROPERTIES IMPORT_SUFFIX "dll.lib")
+        endif()
+    elseif (APPLE)
+        # Append -fno-common to the compile flags to work around a bug in
+        # Apple's GCC
+        get_target_property(glfw_CFLAGS glfw COMPILE_FLAGS)
+        if (NOT glfw_CFLAGS)
+            set(glfw_CFLAGS "")
+        endif()
+        set_target_properties(glfw PROPERTIES
+                              COMPILE_FLAGS "${glfw_CFLAGS} -fno-common"
+                              INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}")
+    endif()
+
+    target_link_libraries(glfw ${glfw_LIBRARIES})
+    target_link_libraries(glfw LINK_INTERFACE_LIBRARIES)
+endif()
+
+if (GLFW_INSTALL)
+    install(TARGETS glfw EXPORT glfwTargets DESTINATION lib${LIB_SUFFIX})
+endif()
+

libs/glfw-3.0.4/src/clipboard.c

@@ -0,0 +1,50 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <math.h>
+#include <string.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI void glfwSetClipboardString(GLFWwindow* handle, const char* string)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformSetClipboardString(window, string);
+}
+
+GLFWAPI const char* glfwGetClipboardString(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return _glfwPlatformGetClipboardString(window);
+}
+

libs/glfw-3.0.4/src/cocoa_clipboard.m

@@ -0,0 +1,70 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+#include <string.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
+{
+    NSArray* types = [NSArray arrayWithObjects:NSStringPboardType, nil];
+
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+    [pasteboard declareTypes:types owner:nil];
+    [pasteboard setString:[NSString stringWithUTF8String:string]
+                  forType:NSStringPboardType];
+}
+
+const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
+{
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+
+    if (![[pasteboard types] containsObject:NSStringPboardType])
+    {
+        _glfwInputError(GLFW_FORMAT_UNAVAILABLE, NULL);
+        return NULL;
+    }
+
+    NSString* object = [pasteboard stringForType:NSStringPboardType];
+    if (!object)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to retrieve object from pasteboard");
+        return NULL;
+    }
+
+    free(_glfw.ns.clipboardString);
+    _glfw.ns.clipboardString = strdup([object UTF8String]);
+
+    return _glfw.ns.clipboardString;
+}
+

libs/glfw-3.0.4/src/cocoa_gamma.c

@@ -0,0 +1,84 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <ApplicationServices/ApplicationServices.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+{
+    uint32_t i, size = CGDisplayGammaTableCapacity(monitor->ns.displayID);
+    CGGammaValue* values = calloc(size * 3, sizeof(CGGammaValue));
+
+    CGGetDisplayTransferByTable(monitor->ns.displayID,
+                                size,
+                                values,
+                                values + size,
+                                values + size * 2,
+                                &size);
+
+    _glfwAllocGammaArrays(ramp, size);
+
+    for (i = 0; i < size; i++)
+    {
+        ramp->red[i]   = (unsigned short) (values[i] * 65535);
+        ramp->green[i] = (unsigned short) (values[i + size] * 65535);
+        ramp->blue[i]  = (unsigned short) (values[i + size * 2] * 65535);
+    }
+
+    free(values);
+}
+
+void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
+{
+    int i;
+    CGGammaValue* values = calloc(ramp->size * 3, sizeof(CGGammaValue));
+
+    for (i = 0;  i < ramp->size;  i++)
+    {
+        values[i]                  = ramp->red[i] / 65535.f;
+        values[i + ramp->size]     = ramp->green[i] / 65535.f;
+        values[i + ramp->size * 2] = ramp->blue[i] / 65535.f;
+    }
+
+    CGSetDisplayTransferByTable(monitor->ns.displayID,
+                                ramp->size,
+                                values,
+                                values + ramp->size,
+                                values + ramp->size * 2);
+
+    free(values);
+}
+

libs/glfw-3.0.4/src/cocoa_init.m

@@ -0,0 +1,142 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+#include <sys/param.h> // For MAXPATHLEN
+
+
+#if defined(_GLFW_USE_CHDIR)
+
+// Change to our application bundle's resources directory, if present
+//
+static void changeToResourcesDirectory(void)
+{
+    char resourcesPath[MAXPATHLEN];
+
+    CFBundleRef bundle = CFBundleGetMainBundle();
+    if (!bundle)
+        return;
+
+    CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(bundle);
+
+    CFStringRef last = CFURLCopyLastPathComponent(resourcesURL);
+    if (CFStringCompare(CFSTR("Resources"), last, 0) != kCFCompareEqualTo)
+    {
+        CFRelease(last);
+        CFRelease(resourcesURL);
+        return;
+    }
+
+    CFRelease(last);
+
+    if (!CFURLGetFileSystemRepresentation(resourcesURL,
+                                          true,
+                                          (UInt8*) resourcesPath,
+                                          MAXPATHLEN))
+    {
+        CFRelease(resourcesURL);
+        return;
+    }
+
+    CFRelease(resourcesURL);
+
+    chdir(resourcesPath);
+}
+
+#endif /* _GLFW_USE_CHDIR */
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformInit(void)
+{
+    _glfw.ns.autoreleasePool = [[NSAutoreleasePool alloc] init];
+
+#if defined(_GLFW_USE_CHDIR)
+    changeToResourcesDirectory();
+#endif
+
+    _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;
+}
+
+void _glfwPlatformTerminate(void)
+{
+    if (_glfw.ns.eventSource)
+    {
+        CFRelease(_glfw.ns.eventSource);
+        _glfw.ns.eventSource = NULL;
+    }
+
+    [NSApp setDelegate:nil];
+    [_glfw.ns.delegate release];
+    _glfw.ns.delegate = nil;
+
+    [_glfw.ns.autoreleasePool release];
+    _glfw.ns.autoreleasePool = nil;
+
+    [_glfw.ns.cursor release];
+    _glfw.ns.cursor = nil;
+
+    free(_glfw.ns.clipboardString);
+
+    _glfwTerminateJoysticks();
+    _glfwTerminateContextAPI();
+}
+
+const char* _glfwPlatformGetVersionString(void)
+{
+    const char* version = _GLFW_VERSION_NUMBER " Cocoa"
+#if defined(_GLFW_NSGL)
+        " NSGL"
+#endif
+#if defined(_GLFW_USE_CHDIR)
+        " chdir"
+#endif
+#if defined(_GLFW_USE_MENUBAR)
+        " menubar"
+#endif
+#if defined(_GLFW_BUILD_DLL)
+        " dynamic"
+#endif
+        ;
+
+    return version;
+}
+

libs/glfw-3.0.4/src/cocoa_joystick.m

@@ -0,0 +1,492 @@
+//========================================================================
+// 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>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <unistd.h>
+#include <ctype.h>
+
+#include <mach/mach.h>
+#include <mach/mach_error.h>
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <Kernel/IOKit/hidsystem/IOHIDUsageTables.h>
+
+
+//------------------------------------------------------------------------
+// Joystick element information
+//------------------------------------------------------------------------
+typedef struct
+{
+    IOHIDElementCookie cookie;
+
+    long min;
+    long max;
+
+    long minReport;
+    long maxReport;
+
+} _GLFWjoyelement;
+
+
+static void getElementsCFArrayHandler(const void* value, void* parameter);
+
+
+// Adds an element to the specified joystick
+//
+static void addJoystickElement(_GLFWjoy* joystick, CFTypeRef elementRef)
+{
+    long elementType, usagePage, usage;
+    CFMutableArrayRef elementsArray = NULL;
+
+    CFNumberGetValue(CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementTypeKey)),
+                     kCFNumberLongType, &elementType);
+    CFNumberGetValue(CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementUsagePageKey)),
+                     kCFNumberLongType, &usagePage);
+    CFNumberGetValue(CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementUsageKey)),
+                     kCFNumberLongType, &usage);
+
+    if ((elementType == kIOHIDElementTypeInput_Axis) ||
+        (elementType == kIOHIDElementTypeInput_Button) ||
+        (elementType == kIOHIDElementTypeInput_Misc))
+    {
+        switch (usagePage)
+        {
+            case kHIDPage_GenericDesktop:
+            {
+                switch (usage)
+                {
+                    case kHIDUsage_GD_X:
+                    case kHIDUsage_GD_Y:
+                    case kHIDUsage_GD_Z:
+                    case kHIDUsage_GD_Rx:
+                    case kHIDUsage_GD_Ry:
+                    case kHIDUsage_GD_Rz:
+                    case kHIDUsage_GD_Slider:
+                    case kHIDUsage_GD_Dial:
+                    case kHIDUsage_GD_Wheel:
+                        elementsArray = joystick->axisElements;
+                        break;
+                    case kHIDUsage_GD_Hatswitch:
+                        elementsArray = joystick->hatElements;
+                        break;
+                }
+
+                break;
+            }
+
+            case kHIDPage_Button:
+                elementsArray = joystick->buttonElements;
+                break;
+            default:
+                break;
+        }
+
+        if (elementsArray)
+        {
+            long number;
+            CFTypeRef numberRef;
+            _GLFWjoyelement* element = calloc(1, sizeof(_GLFWjoyelement));
+
+            CFArrayAppendValue(elementsArray, element);
+
+            numberRef = CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementCookieKey));
+            if (numberRef && CFNumberGetValue(numberRef, kCFNumberLongType, &number))
+                element->cookie = (IOHIDElementCookie) number;
+
+            numberRef = CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementMinKey));
+            if (numberRef && CFNumberGetValue(numberRef, kCFNumberLongType, &number))
+                element->minReport = element->min = number;
+
+            numberRef = CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementMaxKey));
+            if (numberRef && CFNumberGetValue(numberRef, kCFNumberLongType, &number))
+                element->maxReport = element->max = number;
+        }
+    }
+    else
+    {
+        CFTypeRef array = CFDictionaryGetValue(elementRef, CFSTR(kIOHIDElementKey));
+        if (array)
+        {
+            if (CFGetTypeID(array) == CFArrayGetTypeID())
+            {
+                CFRange range = { 0, CFArrayGetCount(array) };
+                CFArrayApplyFunction(array, range, getElementsCFArrayHandler, joystick);
+            }
+        }
+    }
+}
+
+// Adds an element to the specified joystick
+//
+static void getElementsCFArrayHandler(const void* value, void* parameter)
+{
+    if (CFGetTypeID(value) == CFDictionaryGetTypeID())
+        addJoystickElement((_GLFWjoy*) parameter, (CFTypeRef) value);
+}
+
+// Returns the value of the specified element of the specified joystick
+//
+static long getElementValue(_GLFWjoy* joystick, _GLFWjoyelement* element)
+{
+    IOReturn result = kIOReturnSuccess;
+    IOHIDEventStruct hidEvent;
+    hidEvent.value = 0;
+
+    if (joystick && element && joystick->interface)
+    {
+        result = (*(joystick->interface))->getElementValue(joystick->interface,
+                                                           element->cookie,
+                                                           &hidEvent);
+        if (kIOReturnSuccess == result)
+        {
+            // Record min and max for auto calibration
+            if (hidEvent.value < element->minReport)
+                element->minReport = hidEvent.value;
+            if (hidEvent.value > element->maxReport)
+                element->maxReport = hidEvent.value;
+        }
+    }
+
+    // Auto user scale
+    return (long) hidEvent.value;
+}
+
+// Removes the specified joystick
+//
+static void removeJoystick(_GLFWjoy* joystick)
+{
+    int i;
+
+    if (!joystick->present)
+        return;
+
+    for (i = 0;  i < CFArrayGetCount(joystick->axisElements);  i++)
+        free((void*) CFArrayGetValueAtIndex(joystick->axisElements, i));
+    CFArrayRemoveAllValues(joystick->axisElements);
+
+    for (i = 0;  i < CFArrayGetCount(joystick->buttonElements);  i++)
+        free((void*) CFArrayGetValueAtIndex(joystick->buttonElements, i));
+    CFArrayRemoveAllValues(joystick->buttonElements);
+
+    for (i = 0;  i < CFArrayGetCount(joystick->hatElements);  i++)
+        free((void*) CFArrayGetValueAtIndex(joystick->hatElements, i));
+    CFArrayRemoveAllValues(joystick->hatElements);
+
+    free(joystick->axes);
+    free(joystick->buttons);
+
+    (*(joystick->interface))->close(joystick->interface);
+    (*(joystick->interface))->Release(joystick->interface);
+
+    memset(joystick, 0, sizeof(_GLFWjoy));
+}
+
+// Callback for user-initiated joystick removal
+//
+static void removalCallback(void* target, IOReturn result, void* refcon, void* sender)
+{
+    removeJoystick((_GLFWjoy*) refcon);
+}
+
+// Polls for joystick events and updates GLFW state
+//
+static void pollJoystickEvents(void)
+{
+    int joy;
+
+    for (joy = 0;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    {
+        CFIndex i;
+        int buttonIndex = 0;
+        _GLFWjoy* joystick = _glfw.ns.joysticks + joy;
+
+        if (!joystick->present)
+            continue;
+
+        for (i = 0;  i < CFArrayGetCount(joystick->buttonElements);  i++)
+        {
+            _GLFWjoyelement* button =
+                (_GLFWjoyelement*) CFArrayGetValueAtIndex(joystick->buttonElements, i);
+
+            if (getElementValue(joystick, button))
+                joystick->buttons[buttonIndex++] = GLFW_PRESS;
+            else
+                joystick->buttons[buttonIndex++] = GLFW_RELEASE;
+        }
+
+        for (i = 0;  i < CFArrayGetCount(joystick->axisElements);  i++)
+        {
+            _GLFWjoyelement* axis =
+                (_GLFWjoyelement*) CFArrayGetValueAtIndex(joystick->axisElements, i);
+
+            long value = getElementValue(joystick, axis);
+            long readScale = axis->maxReport - axis->minReport;
+
+            if (readScale == 0)
+                joystick->axes[i] = value;
+            else
+                joystick->axes[i] = (2.f * (value - axis->minReport) / readScale) - 1.f;
+        }
+
+        for (i = 0;  i < CFArrayGetCount(joystick->hatElements);  i++)
+        {
+            _GLFWjoyelement* hat =
+                (_GLFWjoyelement*) CFArrayGetValueAtIndex(joystick->hatElements, i);
+
+            // Bit fields of button presses for each direction, including nil
+            const int directions[9] = { 1, 3, 2, 6, 4, 12, 8, 9, 0 };
+
+            long j, value = getElementValue(joystick, hat);
+            if (value < 0 || value > 8)
+                value = 8;
+
+            for (j = 0;  j < 4;  j++)
+            {
+                if (directions[value] & (1 << j))
+                    joystick->buttons[buttonIndex++] = GLFW_PRESS;
+                else
+                    joystick->buttons[buttonIndex++] = GLFW_RELEASE;
+            }
+        }
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize joystick interface
+//
+void _glfwInitJoysticks(void)
+{
+    int joy = 0;
+    IOReturn result = kIOReturnSuccess;
+    mach_port_t masterPort = 0;
+    io_iterator_t objectIterator = 0;
+    CFMutableDictionaryRef hidMatchDictionary = NULL;
+    io_object_t ioHIDDeviceObject = 0;
+
+    result = IOMasterPort(bootstrap_port, &masterPort);
+    hidMatchDictionary = IOServiceMatching(kIOHIDDeviceKey);
+    if (kIOReturnSuccess != result || !hidMatchDictionary)
+    {
+        if (hidMatchDictionary)
+            CFRelease(hidMatchDictionary);
+
+        return;
+    }
+
+    result = IOServiceGetMatchingServices(masterPort,
+                                          hidMatchDictionary,
+                                          &objectIterator);
+    if (result != kIOReturnSuccess)
+        return;
+
+    if (!objectIterator)
+    {
+        // There are no joysticks
+        return;
+    }
+
+    while ((ioHIDDeviceObject = IOIteratorNext(objectIterator)))
+    {
+        CFMutableDictionaryRef propsRef = NULL;
+        CFTypeRef valueRef = NULL;
+        kern_return_t result;
+
+        IOCFPlugInInterface** ppPlugInInterface = NULL;
+        HRESULT plugInResult = S_OK;
+        SInt32 score = 0;
+
+        long usagePage, usage;
+
+        // Check device type
+        result = IORegistryEntryCreateCFProperties(ioHIDDeviceObject,
+                                                   &propsRef,
+                                                   kCFAllocatorDefault,
+                                                   kNilOptions);
+
+        if (result != kIOReturnSuccess)
+            continue;
+
+        valueRef = CFDictionaryGetValue(propsRef, CFSTR(kIOHIDPrimaryUsagePageKey));
+        if (valueRef)
+        {
+            CFNumberGetValue(valueRef, kCFNumberLongType, &usagePage);
+            if (usagePage != kHIDPage_GenericDesktop)
+            {
+                // This device is not relevant to GLFW
+                CFRelease(valueRef);
+                continue;
+            }
+
+            CFRelease(valueRef);
+        }
+
+        valueRef = CFDictionaryGetValue(propsRef, CFSTR(kIOHIDPrimaryUsageKey));
+        if (valueRef)
+        {
+            CFNumberGetValue(valueRef, kCFNumberLongType, &usage);
+
+            if ((usage != kHIDUsage_GD_Joystick &&
+                 usage != kHIDUsage_GD_GamePad &&
+                 usage != kHIDUsage_GD_MultiAxisController))
+            {
+                // This device is not relevant to GLFW
+                CFRelease(valueRef);
+                continue;
+            }
+
+            CFRelease(valueRef);
+        }
+
+        _GLFWjoy* joystick = _glfw.ns.joysticks + joy;
+        joystick->present = GL_TRUE;
+
+        result = IOCreatePlugInInterfaceForService(ioHIDDeviceObject,
+                                                   kIOHIDDeviceUserClientTypeID,
+                                                   kIOCFPlugInInterfaceID,
+                                                   &ppPlugInInterface,
+                                                   &score);
+
+        if (kIOReturnSuccess != result)
+            return;
+
+        plugInResult = (*ppPlugInInterface)->QueryInterface(
+                            ppPlugInInterface,
+                            CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID),
+                            (void *) &(joystick->interface));
+
+        if (plugInResult != S_OK)
+            return;
+
+        (*ppPlugInInterface)->Release(ppPlugInInterface);
+
+        (*(joystick->interface))->open(joystick->interface, 0);
+        (*(joystick->interface))->setRemovalCallback(joystick->interface,
+                                                     removalCallback,
+                                                     joystick,
+                                                     joystick);
+
+        // Get product string
+        valueRef = CFDictionaryGetValue(propsRef, CFSTR(kIOHIDProductKey));
+        if (valueRef)
+        {
+            CFStringGetCString(valueRef,
+                               joystick->name,
+                               sizeof(joystick->name),
+                               kCFStringEncodingUTF8);
+            CFRelease(valueRef);
+        }
+
+        joystick->axisElements = CFArrayCreateMutable(NULL, 0, NULL);
+        joystick->buttonElements = CFArrayCreateMutable(NULL, 0, NULL);
+        joystick->hatElements = CFArrayCreateMutable(NULL, 0, NULL);
+
+        valueRef = CFDictionaryGetValue(propsRef, CFSTR(kIOHIDElementKey));
+        if (CFGetTypeID(valueRef) == CFArrayGetTypeID())
+        {
+            CFRange range = { 0, CFArrayGetCount(valueRef) };
+            CFArrayApplyFunction(valueRef,
+                                 range,
+                                 getElementsCFArrayHandler,
+                                 (void*) joystick);
+            CFRelease(valueRef);
+        }
+
+        joystick->axes = calloc(CFArrayGetCount(joystick->axisElements),
+                                         sizeof(float));
+        joystick->buttons = calloc(CFArrayGetCount(joystick->buttonElements) +
+                                   CFArrayGetCount(joystick->hatElements) * 4, 1);
+
+        joy++;
+        if (joy > GLFW_JOYSTICK_LAST)
+            break;
+    }
+}
+
+// Close all opened joystick handles
+//
+void _glfwTerminateJoysticks(void)
+{
+    int i;
+
+    for (i = 0;  i < GLFW_JOYSTICK_LAST + 1;  i++)
+    {
+        _GLFWjoy* joystick = &_glfw.ns.joysticks[i];
+        removeJoystick(joystick);
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformJoystickPresent(int joy)
+{
+    pollJoystickEvents();
+
+    return _glfw.ns.joysticks[joy].present;
+}
+
+const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+{
+    _GLFWjoy* joystick = _glfw.ns.joysticks + joy;
+
+    pollJoystickEvents();
+
+    if (!joystick->present)
+        return NULL;
+
+    *count = (int) CFArrayGetCount(joystick->axisElements);
+    return joystick->axes;
+}
+
+const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
+{
+    _GLFWjoy* joystick = _glfw.ns.joysticks + joy;
+
+    pollJoystickEvents();
+
+    if (!joystick->present)
+        return NULL;
+
+    *count = (int) CFArrayGetCount(joystick->buttonElements) +
+             (int) CFArrayGetCount(joystick->hatElements) * 4;
+    return joystick->buttons;
+}
+
+const char* _glfwPlatformGetJoystickName(int joy)
+{
+    pollJoystickEvents();
+
+    return _glfw.ns.joysticks[joy].name;
+}
+

libs/glfw-3.0.4/src/cocoa_monitor.m

@@ -0,0 +1,388 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdlib.h>
+#include <limits.h>
+
+#include <IOKit/graphics/IOGraphicsLib.h>
+#include <IOKit/graphics/IOGraphicsLib.h>
+#include <CoreVideo/CVBase.h>
+#include <CoreVideo/CVDisplayLink.h>
+
+
+// Get the name of the specified display
+//
+static const char* getDisplayName(CGDirectDisplayID displayID)
+{
+    char* name;
+    CFDictionaryRef info, names;
+    CFStringRef value;
+    CFIndex size;
+
+    info = IODisplayCreateInfoDictionary(CGDisplayIOServicePort(displayID),
+                                         kIODisplayOnlyPreferredName);
+    names = CFDictionaryGetValue(info, CFSTR(kDisplayProductName));
+
+    if (!names || !CFDictionaryGetValueIfPresent(names, CFSTR("en_US"),
+                                                 (const void**) &value))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Failed to retrieve display name");
+
+        CFRelease(info);
+        return strdup("Unknown");
+    }
+
+    size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(value),
+                                             kCFStringEncodingUTF8);
+    name = calloc(size + 1, sizeof(char));
+    CFStringGetCString(value, name, size, kCFStringEncodingUTF8);
+
+    CFRelease(info);
+
+    return name;
+}
+
+// Check whether the display mode should be included in enumeration
+//
+static GLboolean modeIsGood(CGDisplayModeRef mode)
+{
+    uint32_t flags = CGDisplayModeGetIOFlags(mode);
+    if (!(flags & kDisplayModeValidFlag) || !(flags & kDisplayModeSafeFlag))
+        return GL_FALSE;
+
+    if (flags & kDisplayModeInterlacedFlag)
+        return GL_FALSE;
+
+    if (flags & kDisplayModeStretchedFlag)
+        return GL_FALSE;
+
+    CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
+    if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) &&
+        CFStringCompare(format, CFSTR(IO32BitDirectPixels), 0))
+    {
+        CFRelease(format);
+        return GL_FALSE;
+    }
+
+    CFRelease(format);
+    return GL_TRUE;
+}
+
+// Convert Core Graphics display mode to GLFW video mode
+//
+static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode,
+                                            CVDisplayLinkRef link)
+{
+    GLFWvidmode result;
+    result.width = (int) CGDisplayModeGetWidth(mode);
+    result.height = (int) CGDisplayModeGetHeight(mode);
+    result.refreshRate = (int) CGDisplayModeGetRefreshRate(mode);
+
+    if (result.refreshRate == 0)
+    {
+        const CVTime time = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(link);
+        if (!(time.flags & kCVTimeIsIndefinite))
+            result.refreshRate = (int) (time.timeScale / (double) time.timeValue);
+    }
+
+    CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
+
+    if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) == 0)
+    {
+        result.redBits = 5;
+        result.greenBits = 5;
+        result.blueBits = 5;
+    }
+    else
+    {
+        result.redBits = 8;
+        result.greenBits = 8;
+        result.blueBits = 8;
+    }
+
+    CFRelease(format);
+    return result;
+}
+
+// Starts reservation for display fading
+//
+static CGDisplayFadeReservationToken beginFadeReservation(void)
+{
+    CGDisplayFadeReservationToken token = kCGDisplayFadeReservationInvalidToken;
+
+    if (CGAcquireDisplayFadeReservation(5, &token) == kCGErrorSuccess)
+        CGDisplayFade(token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0.0, 0.0, 0.0, TRUE);
+
+    return token;
+}
+
+// Ends reservation for display fading
+//
+static void endFadeReservation(CGDisplayFadeReservationToken token)
+{
+    if (token != kCGDisplayFadeReservationInvalidToken)
+    {
+        CGDisplayFade(token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
+        CGReleaseDisplayFadeReservation(token);
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Change the current video mode
+//
+GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
+{
+    CGDisplayModeRef bestMode = NULL;
+    CFArrayRef modes;
+    CFIndex count, i;
+    unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
+    unsigned int rateDiff, leastRateDiff = UINT_MAX;
+    const int bpp = desired->redBits - desired->greenBits - desired->blueBits;
+
+    modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
+    count = CFArrayGetCount(modes);
+
+    for (i = 0;  i < count;  i++)
+    {
+        CGDisplayModeRef mode = (CGDisplayModeRef) CFArrayGetValueAtIndex(modes, i);
+        if (!modeIsGood(mode))
+            continue;
+
+        int modeBPP;
+
+        // Identify display mode pixel encoding
+        {
+            CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
+
+            if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) == 0)
+                modeBPP = 16;
+            else
+                modeBPP = 32;
+
+            CFRelease(format);
+        }
+
+        const int modeWidth = (int) CGDisplayModeGetWidth(mode);
+        const int modeHeight = (int) CGDisplayModeGetHeight(mode);
+        const int modeRate = (int) CGDisplayModeGetRefreshRate(mode);
+
+        sizeDiff = (abs(modeBPP - bpp) << 25) |
+                   ((modeWidth - desired->width) * (modeWidth - desired->width) +
+                    (modeHeight - desired->height) * (modeHeight - desired->height));
+
+        if (desired->refreshRate)
+            rateDiff = abs(modeRate - desired->refreshRate);
+        else
+            rateDiff = UINT_MAX - modeRate;
+
+        if ((sizeDiff < leastSizeDiff) ||
+            (sizeDiff == leastSizeDiff && rateDiff < leastRateDiff))
+        {
+            bestMode = mode;
+            leastSizeDiff = sizeDiff;
+            leastRateDiff = rateDiff;
+        }
+    }
+
+    if (!bestMode)
+    {
+        CFRelease(modes);
+        return GL_FALSE;
+    }
+
+    monitor->ns.previousMode = CGDisplayCopyDisplayMode(monitor->ns.displayID);
+
+    CGDisplayFadeReservationToken token = beginFadeReservation();
+
+    CGDisplayCapture(monitor->ns.displayID);
+    CGDisplaySetDisplayMode(monitor->ns.displayID, bestMode, NULL);
+
+    endFadeReservation(token);
+
+    CFRelease(modes);
+    return GL_TRUE;
+}
+
+// Restore the previously saved (original) video mode
+//
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
+{
+    CGDisplayFadeReservationToken token = beginFadeReservation();
+
+    CGDisplaySetDisplayMode(monitor->ns.displayID, monitor->ns.previousMode, NULL);
+    CGDisplayRelease(monitor->ns.displayID);
+
+    endFadeReservation(token);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
+{
+    uint32_t i, found = 0, monitorCount;
+    _GLFWmonitor** monitors;
+    CGDirectDisplayID* displays;
+
+    *count = 0;
+
+    CGGetActiveDisplayList(0, NULL, &monitorCount);
+
+    displays = calloc(monitorCount, sizeof(CGDirectDisplayID));
+    monitors = calloc(monitorCount, sizeof(_GLFWmonitor*));
+
+    CGGetActiveDisplayList(monitorCount, displays, &monitorCount);
+
+    for (i = 0;  i < monitorCount;  i++)
+    {
+        const CGSize size = CGDisplayScreenSize(displays[i]);
+
+        monitors[found] = _glfwCreateMonitor(getDisplayName(displays[i]),
+                                             size.width, size.height);
+
+        monitors[found]->ns.displayID = displays[i];
+        found++;
+    }
+
+    free(displays);
+
+    for (i = 0;  i < monitorCount;  i++)
+    {
+        if (CGDisplayIsMain(monitors[i]->ns.displayID))
+        {
+            _GLFWmonitor* temp = monitors[0];
+            monitors[0] = monitors[i];
+            monitors[i] = temp;
+            break;
+        }
+    }
+
+    NSArray* screens = [NSScreen screens];
+
+    for (i = 0;  i < monitorCount;  i++)
+    {
+        int j;
+
+        for (j = 0;  j < [screens count];  j++)
+        {
+            NSScreen* screen = [screens objectAtIndex:j];
+            NSDictionary* dictionary = [screen deviceDescription];
+            NSNumber* number = [dictionary objectForKey:@"NSScreenNumber"];
+
+            if (monitors[i]->ns.displayID == [number unsignedIntegerValue])
+            {
+                monitors[i]->ns.screen = screen;
+                break;
+            }
+        }
+
+        if (monitors[i]->ns.screen == nil)
+        {
+            _glfwDestroyMonitors(monitors, monitorCount);
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Cocoa: Failed to find NSScreen for CGDisplay %s",
+                            monitors[i]->name);
+
+            free(monitors);
+            return NULL;
+        }
+    }
+
+    *count = monitorCount;
+    return monitors;
+}
+
+GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
+{
+    return first->ns.displayID == second->ns.displayID;
+}
+
+void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
+{
+    const CGRect bounds = CGDisplayBounds(monitor->ns.displayID);
+
+    if (xpos)
+        *xpos = (int) bounds.origin.x;
+    if (ypos)
+        *ypos = (int) bounds.origin.y;
+}
+
+GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
+{
+    CFArrayRef modes;
+    CFIndex count, i;
+    GLFWvidmode* result;
+    CVDisplayLinkRef link;
+
+    CVDisplayLinkCreateWithCGDisplay(monitor->ns.displayID, &link);
+
+    modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
+    count = CFArrayGetCount(modes);
+
+    result = calloc(count, sizeof(GLFWvidmode));
+    *found = 0;
+
+    for (i = 0;  i < count;  i++)
+    {
+        CGDisplayModeRef mode;
+
+        mode = (CGDisplayModeRef) CFArrayGetValueAtIndex(modes, i);
+        if (modeIsGood(mode))
+        {
+            result[*found] = vidmodeFromCGDisplayMode(mode, link);
+            (*found)++;
+        }
+    }
+
+    CFRelease(modes);
+
+    CVDisplayLinkRelease(link);
+    return result;
+}
+
+void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode *mode)
+{
+    CGDisplayModeRef displayMode;
+    CVDisplayLinkRef link;
+
+    CVDisplayLinkCreateWithCGDisplay(monitor->ns.displayID, &link);
+
+    displayMode = CGDisplayCopyDisplayMode(monitor->ns.displayID);
+    *mode = vidmodeFromCGDisplayMode(displayMode, link);
+    CGDisplayModeRelease(displayMode);
+
+    CVDisplayLinkRelease(link);
+}
+

libs/glfw-3.0.4/src/cocoa_platform.h

@@ -0,0 +1,149 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _cocoa_platform_h_
+#define _cocoa_platform_h_
+
+
+#include <stdint.h>
+
+#if defined(__OBJC__)
+#import <Cocoa/Cocoa.h>
+#else
+#include <ApplicationServices/ApplicationServices.h>
+typedef void* id;
+#endif
+
+#if defined(_GLFW_NSGL)
+ #include "nsgl_platform.h"
+#else
+ #error "No supported context creation API selected"
+#endif
+
+#include <IOKit/IOKitLib.h>
+#include <IOKit/IOCFPlugIn.h>
+#include <IOKit/hid/IOHIDLib.h>
+#include <IOKit/hid/IOHIDKeys.h>
+
+#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowNS  ns
+#define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryNS ns
+#define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorNS ns
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+
+//------------------------------------------------------------------------
+// Platform-specific window structure
+//------------------------------------------------------------------------
+typedef struct _GLFWwindowNS
+{
+    id              object;
+    id	            delegate;
+    id              view;
+    unsigned int    modifierFlags;
+} _GLFWwindowNS;
+
+
+//------------------------------------------------------------------------
+// Joystick information & state
+//------------------------------------------------------------------------
+typedef struct
+{
+    int             present;
+    char            name[256];
+
+    IOHIDDeviceInterface** interface;
+
+    CFMutableArrayRef axisElements;
+    CFMutableArrayRef buttonElements;
+    CFMutableArrayRef hatElements;
+
+    float*          axes;
+    unsigned char*  buttons;
+
+} _GLFWjoy;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for Cocoa
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryNS
+{
+    struct {
+        double      base;
+        double      resolution;
+    } timer;
+
+    CGEventSourceRef eventSource;
+    id              delegate;
+    id              autoreleasePool;
+    id              cursor;
+
+    char*           clipboardString;
+
+    _GLFWjoy        joysticks[GLFW_JOYSTICK_LAST + 1];
+} _GLFWlibraryNS;
+
+
+//------------------------------------------------------------------------
+// Platform-specific monitor structure
+//------------------------------------------------------------------------
+typedef struct _GLFWmonitorNS
+{
+    CGDirectDisplayID   displayID;
+    CGDisplayModeRef    previousMode;
+    id                  screen;
+
+} _GLFWmonitorNS;
+
+
+//========================================================================
+// Prototypes for platform specific internal functions
+//========================================================================
+
+// Time
+void _glfwInitTimer(void);
+
+// Joystick input
+void _glfwInitJoysticks(void);
+void _glfwTerminateJoysticks(void);
+
+// Fullscreen
+GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired);
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor);
+
+// OpenGL support
+int _glfwInitContextAPI(void);
+void _glfwTerminateContextAPI(void);
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig);
+void _glfwDestroyContext(_GLFWwindow* window);
+
+#endif // _cocoa_platform_h_

libs/glfw-3.0.4/src/cocoa_time.c

@@ -0,0 +1,71 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <mach/mach_time.h>
+
+
+// Return raw time
+//
+static uint64_t getRawTime(void)
+{
+    return mach_absolute_time();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialise timer
+//
+void _glfwInitTimer(void)
+{
+    mach_timebase_info_data_t info;
+    mach_timebase_info(&info);
+
+    _glfw.ns.timer.resolution = (double) info.numer / (info.denom * 1.0e9);
+    _glfw.ns.timer.base = getRawTime();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+double _glfwPlatformGetTime(void)
+{
+    return (double) (getRawTime() - _glfw.ns.timer.base) *
+        _glfw.ns.timer.resolution;
+}
+
+void _glfwPlatformSetTime(double time)
+{
+    _glfw.ns.timer.base = getRawTime() -
+        (uint64_t) (time / _glfw.ns.timer.resolution);
+}
+

libs/glfw-3.0.4/src/context.c

@@ -0,0 +1,640 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <stdio.h>
+
+
+// Parses the client API version string and extracts the version number
+//
+static GLboolean parseGLVersion(int* api, int* major, int* minor, int* rev)
+{
+    int i, _api = GLFW_OPENGL_API, _major, _minor = 0, _rev = 0;
+    const char* version;
+    const char* prefixes[] =
+    {
+        "OpenGL ES-CM ",
+        "OpenGL ES-CL ",
+        "OpenGL ES ",
+        NULL
+    };
+
+    version = (const char*) glGetString(GL_VERSION);
+    if (!version)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Failed to retrieve context version string");
+        return GL_FALSE;
+    }
+
+    for (i = 0;  prefixes[i];  i++)
+    {
+        const size_t length = strlen(prefixes[i]);
+
+        if (strncmp(version, prefixes[i], length) == 0)
+        {
+            version += length;
+            _api = GLFW_OPENGL_ES_API;
+            break;
+        }
+    }
+
+    if (!sscanf(version, "%d.%d.%d", &_major, &_minor, &_rev))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "No version found in context version string");
+        return GL_FALSE;
+    }
+
+    *api = _api;
+    *major = _major;
+    *minor = _minor;
+    *rev = _rev;
+
+    return GL_TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
+{
+    if (wndconfig->clientAPI != GLFW_OPENGL_API &&
+        wndconfig->clientAPI != GLFW_OPENGL_ES_API)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid client API requested");
+        return GL_FALSE;
+    }
+
+    if (wndconfig->clientAPI == GLFW_OPENGL_API)
+    {
+        if ((wndconfig->glMajor < 1 || wndconfig->glMinor < 0) ||
+            (wndconfig->glMajor == 1 && wndconfig->glMinor > 5) ||
+            (wndconfig->glMajor == 2 && wndconfig->glMinor > 1) ||
+            (wndconfig->glMajor == 3 && wndconfig->glMinor > 3))
+        {
+            // OpenGL 1.0 is the smallest valid version
+            // OpenGL 1.x series ended with version 1.5
+            // OpenGL 2.x series ended with version 2.1
+            // OpenGL 3.x series ended with version 3.3
+
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Invalid OpenGL version %i.%i requested",
+                            wndconfig->glMajor, wndconfig->glMinor);
+            return GL_FALSE;
+        }
+        else
+        {
+            // For now, let everything else through
+        }
+
+        if (wndconfig->glProfile)
+        {
+            if (wndconfig->glProfile != GLFW_OPENGL_CORE_PROFILE &&
+                wndconfig->glProfile != GLFW_OPENGL_COMPAT_PROFILE)
+            {
+                _glfwInputError(GLFW_INVALID_ENUM,
+                                "Invalid OpenGL profile requested");
+                return GL_FALSE;
+            }
+
+            if (wndconfig->glMajor < 3 ||
+                (wndconfig->glMajor == 3 && wndconfig->glMinor < 2))
+            {
+                // Desktop OpenGL context profiles are only defined for version 3.2
+                // and above
+
+                _glfwInputError(GLFW_INVALID_VALUE,
+                                "Context profiles only exist for "
+                                "OpenGL version 3.2 and above");
+                return GL_FALSE;
+            }
+        }
+
+        if (wndconfig->glForward && wndconfig->glMajor < 3)
+        {
+            // Forward-compatible contexts are only defined for OpenGL version 3.0 and above
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Forward compatibility only exist for OpenGL "
+                            "version 3.0 and above");
+            return GL_FALSE;
+        }
+    }
+    else if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+    {
+        if (wndconfig->glMajor < 1 || wndconfig->glMinor < 0 ||
+            (wndconfig->glMajor == 1 && wndconfig->glMinor > 1) ||
+            (wndconfig->glMajor == 2 && wndconfig->glMinor > 0))
+        {
+            // OpenGL ES 1.0 is the smallest valid version
+            // OpenGL ES 1.x series ended with version 1.1
+            // OpenGL ES 2.x series ended with version 2.0
+
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Invalid OpenGL ES version %i.%i requested",
+                            wndconfig->glMajor, wndconfig->glMinor);
+            return GL_FALSE;
+        }
+        else
+        {
+            // For now, let everything else through
+        }
+
+        if (wndconfig->glProfile)
+        {
+            // OpenGL ES does not support profiles
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Context profiles are not supported by OpenGL ES");
+            return GL_FALSE;
+        }
+
+        if (wndconfig->glForward)
+        {
+            // OpenGL ES does not support forward-compatibility
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Forward compatibility is not supported by OpenGL ES");
+            return GL_FALSE;
+        }
+    }
+
+    if (wndconfig->glRobustness)
+    {
+        if (wndconfig->glRobustness != GLFW_NO_RESET_NOTIFICATION &&
+            wndconfig->glRobustness != GLFW_LOSE_CONTEXT_ON_RESET)
+        {
+            _glfwInputError(GLFW_INVALID_VALUE,
+                            "Invalid context robustness mode requested");
+            return GL_FALSE;
+        }
+    }
+
+    return GL_TRUE;
+}
+
+const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
+                                         const _GLFWfbconfig* alternatives,
+                                         unsigned int count)
+{
+    unsigned int i;
+    unsigned int missing, leastMissing = UINT_MAX;
+    unsigned int colorDiff, leastColorDiff = UINT_MAX;
+    unsigned int extraDiff, leastExtraDiff = UINT_MAX;
+    const _GLFWfbconfig* current;
+    const _GLFWfbconfig* closest = NULL;
+
+    for (i = 0;  i < count;  i++)
+    {
+        current = alternatives + i;
+
+        if (desired->stereo > 0 && current->stereo == 0)
+        {
+            // Stereo is a hard constraint
+            continue;
+        }
+
+        // Count number of missing buffers
+        {
+            missing = 0;
+
+            if (desired->alphaBits > 0 && current->alphaBits == 0)
+                missing++;
+
+            if (desired->depthBits > 0 && current->depthBits == 0)
+                missing++;
+
+            if (desired->stencilBits > 0 && current->stencilBits == 0)
+                missing++;
+
+            if (desired->auxBuffers > 0 && current->auxBuffers < desired->auxBuffers)
+                missing += desired->auxBuffers - current->auxBuffers;
+
+            if (desired->samples > 0 && current->samples == 0)
+            {
+                // Technically, several multisampling buffers could be
+                // involved, but that's a lower level implementation detail and
+                // not important to us here, so we count them as one
+                missing++;
+            }
+        }
+
+        // These polynomials make many small channel size differences matter
+        // less than one large channel size difference
+
+        // Calculate color channel size difference value
+        {
+            colorDiff = 0;
+
+            if (desired->redBits > 0)
+            {
+                colorDiff += (desired->redBits - current->redBits) *
+                             (desired->redBits - current->redBits);
+            }
+
+            if (desired->greenBits > 0)
+            {
+                colorDiff += (desired->greenBits - current->greenBits) *
+                             (desired->greenBits - current->greenBits);
+            }
+
+            if (desired->blueBits > 0)
+            {
+                colorDiff += (desired->blueBits - current->blueBits) *
+                             (desired->blueBits - current->blueBits);
+            }
+        }
+
+        // Calculate non-color channel size difference value
+        {
+            extraDiff = 0;
+
+            if (desired->alphaBits > 0)
+            {
+                extraDiff += (desired->alphaBits - current->alphaBits) *
+                             (desired->alphaBits - current->alphaBits);
+            }
+
+            if (desired->depthBits > 0)
+            {
+                extraDiff += (desired->depthBits - current->depthBits) *
+                             (desired->depthBits - current->depthBits);
+            }
+
+            if (desired->stencilBits > 0)
+            {
+                extraDiff += (desired->stencilBits - current->stencilBits) *
+                             (desired->stencilBits - current->stencilBits);
+            }
+
+            if (desired->accumRedBits > 0)
+            {
+                extraDiff += (desired->accumRedBits - current->accumRedBits) *
+                             (desired->accumRedBits - current->accumRedBits);
+            }
+
+            if (desired->accumGreenBits > 0)
+            {
+                extraDiff += (desired->accumGreenBits - current->accumGreenBits) *
+                             (desired->accumGreenBits - current->accumGreenBits);
+            }
+
+            if (desired->accumBlueBits > 0)
+            {
+                extraDiff += (desired->accumBlueBits - current->accumBlueBits) *
+                             (desired->accumBlueBits - current->accumBlueBits);
+            }
+
+            if (desired->accumAlphaBits > 0)
+            {
+                extraDiff += (desired->accumAlphaBits - current->accumAlphaBits) *
+                             (desired->accumAlphaBits - current->accumAlphaBits);
+            }
+
+            if (desired->samples > 0)
+            {
+                extraDiff += (desired->samples - current->samples) *
+                             (desired->samples - current->samples);
+            }
+
+            if (desired->sRGB)
+            {
+                if (!current->sRGB)
+                    extraDiff++;
+            }
+        }
+
+        // Figure out if the current one is better than the best one found so far
+        // Least number of missing buffers is the most important heuristic,
+        // then color buffer size match and lastly size match for other buffers
+
+        if (missing < leastMissing)
+            closest = current;
+        else if (missing == leastMissing)
+        {
+            if ((colorDiff < leastColorDiff) ||
+                (colorDiff == leastColorDiff && extraDiff < leastExtraDiff))
+            {
+                closest = current;
+            }
+        }
+
+        if (current == closest)
+        {
+            leastMissing = missing;
+            leastColorDiff = colorDiff;
+            leastExtraDiff = extraDiff;
+        }
+    }
+
+    return closest;
+}
+
+GLboolean _glfwRefreshContextAttribs(void)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    if (!parseGLVersion(&window->clientAPI,
+                        &window->glMajor,
+                        &window->glMinor,
+                        &window->glRevision))
+    {
+        return GL_FALSE;
+    }
+
+#if defined(_GLFW_USE_OPENGL)
+    if (window->glMajor > 2)
+    {
+        // OpenGL 3.0+ uses a different function for extension string retrieval
+        // We cache it here instead of in glfwExtensionSupported mostly to alert
+        // users as early as possible that their build may be broken
+
+        window->GetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress("glGetStringi");
+        if (!window->GetStringi)
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Entry point retrieval is broken");
+            return GL_FALSE;
+        }
+    }
+
+    if (window->clientAPI == GLFW_OPENGL_API)
+    {
+        // Read back context flags (OpenGL 3.0 and above)
+        if (window->glMajor >= 3)
+        {
+            GLint flags;
+            glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
+
+            if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
+                window->glForward = GL_TRUE;
+
+            if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
+                window->glDebug = GL_TRUE;
+            else if (glfwExtensionSupported("GL_ARB_debug_output"))
+            {
+                // HACK: This is a workaround for older drivers (pre KHR_debug)
+                //       not setting the debug bit in the context flags for
+                //       debug contexts
+                window->glDebug = GL_TRUE;
+            }
+        }
+
+        // Read back OpenGL context profile (OpenGL 3.2 and above)
+        if (window->glMajor > 3 ||
+            (window->glMajor == 3 && window->glMinor >= 2))
+        {
+            GLint mask;
+            glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
+
+            if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
+                window->glProfile = GLFW_OPENGL_COMPAT_PROFILE;
+            else if (mask & GL_CONTEXT_CORE_PROFILE_BIT)
+                window->glProfile = GLFW_OPENGL_CORE_PROFILE;
+            else if (glfwExtensionSupported("GL_ARB_compatibility"))
+            {
+                // HACK: This is a workaround for the compatibility profile bit
+                //       not being set in the context flags if an OpenGL 3.2+
+                //       context was created without having requested a specific
+                //       version
+                window->glProfile = GLFW_OPENGL_COMPAT_PROFILE;
+            }
+        }
+
+        // Read back robustness strategy
+        if (glfwExtensionSupported("GL_ARB_robustness"))
+        {
+            // NOTE: We avoid using the context flags for detection, as they are
+            //       only present from 3.0 while the extension applies from 1.1
+
+            GLint strategy;
+            glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
+
+            if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
+                window->glRobustness = GLFW_LOSE_CONTEXT_ON_RESET;
+            else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
+                window->glRobustness = GLFW_NO_RESET_NOTIFICATION;
+        }
+    }
+    else
+    {
+        // Read back robustness strategy
+        if (glfwExtensionSupported("GL_EXT_robustness"))
+        {
+            // NOTE: The values of these constants match those of the OpenGL ARB
+            //       one, so we can reuse them here
+
+            GLint strategy;
+            glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
+
+            if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
+                window->glRobustness = GLFW_LOSE_CONTEXT_ON_RESET;
+            else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
+                window->glRobustness = GLFW_NO_RESET_NOTIFICATION;
+        }
+    }
+#endif // _GLFW_USE_OPENGL
+
+    return GL_TRUE;
+}
+
+GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    if (window->glMajor < wndconfig->glMajor ||
+        (window->glMajor == wndconfig->glMajor &&
+         window->glMinor < wndconfig->glMinor))
+    {
+        // The desired OpenGL version is greater than the actual version
+        // This only happens if the machine lacks {GLX|WGL}_ARB_create_context
+        // /and/ the user has requested an OpenGL version greater than 1.0
+
+        // For API consistency, we emulate the behavior of the
+        // {GLX|WGL}_ARB_create_context extension and fail here
+
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE, NULL);
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+int _glfwStringInExtensionString(const char* string, const GLubyte* extensions)
+{
+    const GLubyte* start;
+    GLubyte* where;
+    GLubyte* terminator;
+
+    // It takes a bit of care to be fool-proof about parsing the
+    // OpenGL extensions string. Don't be fooled by sub-strings,
+    // etc.
+    start = extensions;
+    for (;;)
+    {
+        where = (GLubyte*) strstr((const char*) start, string);
+        if (!where)
+            return GL_FALSE;
+
+        terminator = where + strlen(string);
+        if (where == start || *(where - 1) == ' ')
+        {
+            if (*terminator == ' ' || *terminator == '\0')
+                break;
+        }
+
+        start = terminator;
+    }
+
+    return GL_TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI void glfwMakeContextCurrent(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (_glfwPlatformGetCurrentContext() == window)
+        return;
+
+    _glfwPlatformMakeContextCurrent(window);
+}
+
+GLFWAPI GLFWwindow* glfwGetCurrentContext(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return (GLFWwindow*) _glfwPlatformGetCurrentContext();
+}
+
+GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformSwapBuffers(window);
+}
+
+GLFWAPI void glfwSwapInterval(int interval)
+{
+    _GLFW_REQUIRE_INIT();
+
+    if (!_glfwPlatformGetCurrentContext())
+    {
+        _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
+        return;
+    }
+
+    _glfwPlatformSwapInterval(interval);
+}
+
+GLFWAPI int glfwExtensionSupported(const char* extension)
+{
+    const GLubyte* extensions;
+    _GLFWwindow* window;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GL_FALSE);
+
+    window = _glfwPlatformGetCurrentContext();
+    if (!window)
+    {
+        _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
+        return GL_FALSE;
+    }
+
+    if (!extension || *extension == '\0')
+    {
+        _glfwInputError(GLFW_INVALID_VALUE, NULL);
+        return GL_FALSE;
+    }
+
+    if (window->glMajor < 3)
+    {
+        // Check if extension is in the old style OpenGL extensions string
+
+        extensions = glGetString(GL_EXTENSIONS);
+        if (!extensions)
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Failed to retrieve extension string");
+            return GL_FALSE;
+        }
+
+        if (_glfwStringInExtensionString(extension, extensions))
+            return GL_TRUE;
+    }
+#if defined(_GLFW_USE_OPENGL)
+    else
+    {
+        int i;
+        GLint count;
+
+        // Check if extension is in the modern OpenGL extensions string list
+
+        glGetIntegerv(GL_NUM_EXTENSIONS, &count);
+
+        for (i = 0;  i < count;  i++)
+        {
+            const char* en = (const char*) window->GetStringi(GL_EXTENSIONS, i);
+            if (!en)
+            {
+                _glfwInputError(GLFW_PLATFORM_ERROR,
+                                "Failed to retrieve extension string %i", i);
+                return GL_FALSE;
+            }
+
+            if (strcmp(en, extension) == 0)
+                return GL_TRUE;
+        }
+    }
+#endif // _GLFW_USE_OPENGL
+
+    // Check if extension is in the platform-specific string
+    return _glfwPlatformExtensionSupported(extension);
+}
+
+GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (!_glfwPlatformGetCurrentContext())
+    {
+        _glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
+        return NULL;
+    }
+
+    return _glfwPlatformGetProcAddress(procname);
+}
+

libs/glfw-3.0.4/src/egl_context.c

@@ -0,0 +1,546 @@
+//========================================================================
+// GLFW 3.0 EGL - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+
+// Thread local storage attribute macro
+//
+#if defined(_MSC_VER)
+ #define _GLFW_TLS __declspec(thread)
+#elif defined(__GNUC__)
+ #define _GLFW_TLS __thread
+#else
+ #define _GLFW_TLS
+#endif
+
+
+// The per-thread current context/window pointer
+//
+static _GLFW_TLS _GLFWwindow* _glfwCurrentWindow = NULL;
+
+
+// Return a description of the specified EGL error
+//
+static const char* getErrorString(EGLint error)
+{
+    switch (error)
+    {
+        case EGL_SUCCESS:
+            return "Success";
+        case EGL_NOT_INITIALIZED:
+            return "EGL is not or could not be initialized";
+        case EGL_BAD_ACCESS:
+            return "EGL cannot access a requested resource";
+        case EGL_BAD_ALLOC:
+            return "EGL failed to allocate resources for the requested operation";
+        case EGL_BAD_ATTRIBUTE:
+            return "An unrecognized attribute or attribute value was passed "
+                   "in the attribute list";
+        case EGL_BAD_CONTEXT:
+            return "An EGLContext argument does not name a valid EGL "
+                   "rendering context";
+        case EGL_BAD_CONFIG:
+            return "An EGLConfig argument does not name a valid EGL frame "
+                   "buffer configuration";
+        case EGL_BAD_CURRENT_SURFACE:
+            return "The current surface of the calling thread is a window, pixel "
+                   "buffer or pixmap that is no longer valid";
+        case EGL_BAD_DISPLAY:
+            return "An EGLDisplay argument does not name a valid EGL display "
+                   "connection";
+        case EGL_BAD_SURFACE:
+            return "An EGLSurface argument does not name a valid surface "
+                   "configured for GL rendering";
+        case EGL_BAD_MATCH:
+            return "Arguments are inconsistent";
+        case EGL_BAD_PARAMETER:
+            return "One or more argument values are invalid";
+        case EGL_BAD_NATIVE_PIXMAP:
+            return "A NativePixmapType argument does not refer to a valid "
+                   "native pixmap";
+        case EGL_BAD_NATIVE_WINDOW:
+            return "A NativeWindowType argument does not refer to a valid "
+                   "native window";
+        case EGL_CONTEXT_LOST:
+            return "The application must destroy all contexts and reinitialise";
+    }
+
+    return "UNKNOWN EGL ERROR";
+}
+
+// Returns the specified attribute of the specified EGLConfig
+//
+static int getConfigAttrib(EGLConfig config, int attrib)
+{
+    int value;
+    eglGetConfigAttrib(_glfw.egl.display, config, attrib, &value);
+    return value;
+}
+
+// Return a list of available and usable framebuffer configs
+//
+static GLboolean chooseFBConfigs(const _GLFWwndconfig* wndconfig,
+                                 const _GLFWfbconfig* desired,
+                                 EGLConfig* result)
+{
+    EGLConfig* nativeConfigs;
+    _GLFWfbconfig* usableConfigs;
+    const _GLFWfbconfig* closest;
+    int i, nativeCount, usableCount;
+
+    eglGetConfigs(_glfw.egl.display, NULL, 0, &nativeCount);
+    if (!nativeCount)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "EGL: No EGLConfigs returned");
+        return GL_FALSE;
+    }
+
+    nativeConfigs = calloc(nativeCount, sizeof(EGLConfig));
+    eglGetConfigs(_glfw.egl.display, nativeConfigs, nativeCount, &nativeCount);
+
+    usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
+    usableCount = 0;
+
+    for (i = 0;  i < nativeCount;  i++)
+    {
+        const EGLConfig n = nativeConfigs[i];
+        _GLFWfbconfig* u = usableConfigs + usableCount;
+
+#if defined(_GLFW_X11)
+        if (!getConfigAttrib(n, EGL_NATIVE_VISUAL_ID))
+        {
+            // Only consider EGLConfigs with associated visuals
+            continue;
+        }
+#endif // _GLFW_X11
+
+        if (!(getConfigAttrib(n, EGL_COLOR_BUFFER_TYPE) & EGL_RGB_BUFFER))
+        {
+            // Only consider RGB(A) EGLConfigs
+            continue;
+        }
+
+        if (!(getConfigAttrib(n, EGL_SURFACE_TYPE) & EGL_WINDOW_BIT))
+        {
+            // Only consider window EGLConfigs
+            continue;
+        }
+
+        if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+        {
+            if (wndconfig->glMajor == 1)
+            {
+                if (!(getConfigAttrib(n, EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES_BIT))
+                    continue;
+            }
+            else
+            {
+                if (!(getConfigAttrib(n, EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT))
+                    continue;
+            }
+        }
+        else if (wndconfig->clientAPI == GLFW_OPENGL_API)
+        {
+            if (!(getConfigAttrib(n, EGL_RENDERABLE_TYPE) & EGL_OPENGL_BIT))
+                continue;
+        }
+
+        u->redBits = getConfigAttrib(n, EGL_RED_SIZE);
+        u->greenBits = getConfigAttrib(n, EGL_GREEN_SIZE);
+        u->blueBits = getConfigAttrib(n, EGL_BLUE_SIZE);
+
+        u->alphaBits = getConfigAttrib(n, EGL_ALPHA_SIZE);
+        u->depthBits = getConfigAttrib(n, EGL_DEPTH_SIZE);
+        u->stencilBits = getConfigAttrib(n, EGL_STENCIL_SIZE);
+
+        u->samples = getConfigAttrib(n, EGL_SAMPLES);
+
+        u->egl = n;
+        usableCount++;
+    }
+
+    closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
+    if (closest)
+        *result = closest->egl;
+
+    free(nativeConfigs);
+    free(usableConfigs);
+
+    return closest ? GL_TRUE : GL_FALSE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize EGL
+//
+int _glfwInitContextAPI(void)
+{
+    _glfw.egl.display = eglGetDisplay((EGLNativeDisplayType)_GLFW_EGL_NATIVE_DISPLAY);
+    if (_glfw.egl.display == EGL_NO_DISPLAY)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "EGL: Failed to get EGL display: %s",
+                        getErrorString(eglGetError()));
+        return GL_FALSE;
+    }
+
+    if (!eglInitialize(_glfw.egl.display,
+                       &_glfw.egl.versionMajor,
+                       &_glfw.egl.versionMinor))
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "EGL: Failed to initialize EGL: %s",
+                        getErrorString(eglGetError()));
+        return GL_FALSE;
+    }
+
+    if (_glfwPlatformExtensionSupported("EGL_KHR_create_context"))
+        _glfw.egl.KHR_create_context = GL_TRUE;
+
+    return GL_TRUE;
+}
+
+// Terminate EGL
+//
+void _glfwTerminateContextAPI(void)
+{
+    eglTerminate(_glfw.egl.display);
+}
+
+#define setEGLattrib(attribName, attribValue) \
+{ \
+    attribs[index++] = attribName; \
+    attribs[index++] = attribValue; \
+    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
+}
+
+// Prepare for creation of the OpenGL context
+//
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig)
+{
+    int attribs[40];
+    EGLint count = 0;
+    EGLConfig config;
+    EGLContext share = NULL;
+
+    if (wndconfig->share)
+        share = wndconfig->share->egl.context;
+
+    if (!chooseFBConfigs(wndconfig, fbconfig, &config))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "EGL: Failed to find a suitable EGLConfig");
+        return GL_FALSE;
+    }
+
+#if defined(_GLFW_X11)
+    // Retrieve the visual corresponding to the chosen EGL config
+    {
+        int mask;
+        EGLint redBits, greenBits, blueBits, alphaBits, visualID = 0;
+        XVisualInfo info;
+
+        eglGetConfigAttrib(_glfw.egl.display, config,
+                           EGL_NATIVE_VISUAL_ID, &visualID);
+
+        info.screen = _glfw.x11.screen;
+        mask = VisualScreenMask;
+
+        if (visualID)
+        {
+            // The X window visual must match the EGL config
+            info.visualid = visualID;
+            mask |= VisualIDMask;
+        }
+        else
+        {
+            // some EGL drivers don't implement the EGL_NATIVE_VISUAL_ID
+            // attribute, so attempt to find the closest match.
+
+            eglGetConfigAttrib(_glfw.egl.display, config,
+                               EGL_RED_SIZE, &redBits);
+            eglGetConfigAttrib(_glfw.egl.display, config,
+                               EGL_GREEN_SIZE, &greenBits);
+            eglGetConfigAttrib(_glfw.egl.display, config,
+                               EGL_BLUE_SIZE, &blueBits);
+            eglGetConfigAttrib(_glfw.egl.display, config,
+                               EGL_ALPHA_SIZE, &alphaBits);
+
+            info.depth = redBits + greenBits + blueBits + alphaBits;
+            mask |= VisualDepthMask;
+        }
+
+        window->egl.visual = XGetVisualInfo(_glfw.x11.display,
+                                            mask, &info, &count);
+
+        if (window->egl.visual == NULL)
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "EGL: Failed to retrieve visual for EGLConfig");
+            return GL_FALSE;
+        }
+    }
+#endif // _GLFW_X11
+
+    if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+    {
+        if (!eglBindAPI(EGL_OPENGL_ES_API))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "EGL: Failed to bind OpenGL ES: %s",
+                            getErrorString(eglGetError()));
+            return GL_FALSE;
+        }
+    }
+    else
+    {
+        if (!eglBindAPI(EGL_OPENGL_API))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "EGL: Failed to bind OpenGL: %s",
+                            getErrorString(eglGetError()));
+            return GL_FALSE;
+        }
+    }
+
+    if (_glfw.egl.KHR_create_context)
+    {
+        int index = 0, mask = 0, flags = 0, strategy = 0;
+
+        if (wndconfig->clientAPI == GLFW_OPENGL_API)
+        {
+            if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
+                mask |= EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
+            else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
+                mask |= EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
+
+            if (wndconfig->glForward)
+                flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
+
+            if (wndconfig->glDebug)
+                flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
+        }
+
+        if (wndconfig->glRobustness != GLFW_NO_ROBUSTNESS)
+        {
+            if (wndconfig->glRobustness == GLFW_NO_RESET_NOTIFICATION)
+                strategy = EGL_NO_RESET_NOTIFICATION_KHR;
+            else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET)
+                strategy = EGL_LOSE_CONTEXT_ON_RESET_KHR;
+
+            flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
+        }
+
+        if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
+        {
+            setEGLattrib(EGL_CONTEXT_MAJOR_VERSION_KHR, wndconfig->glMajor);
+            setEGLattrib(EGL_CONTEXT_MINOR_VERSION_KHR, wndconfig->glMinor);
+        }
+
+        if (mask)
+            setEGLattrib(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, mask);
+
+        if (flags)
+            setEGLattrib(EGL_CONTEXT_FLAGS_KHR, flags);
+
+        if (strategy)
+            setEGLattrib(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, strategy);
+
+        setEGLattrib(EGL_NONE, EGL_NONE);
+    }
+    else
+    {
+        int index = 0;
+
+        if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+            setEGLattrib(EGL_CONTEXT_CLIENT_VERSION, wndconfig->glMajor);
+
+        setEGLattrib(EGL_NONE, EGL_NONE);
+    }
+
+    window->egl.context = eglCreateContext(_glfw.egl.display,
+                                           config, share, attribs);
+
+    if (window->egl.context == EGL_NO_CONTEXT)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "EGL: Failed to create context: %s",
+                        getErrorString(eglGetError()));
+        return GL_FALSE;
+    }
+
+    window->egl.config = config;
+
+    return GL_TRUE;
+}
+
+#undef setEGLattrib
+
+// Destroy the OpenGL context
+//
+void _glfwDestroyContext(_GLFWwindow* window)
+{
+#if defined(_GLFW_X11)
+    if (window->egl.visual)
+    {
+       XFree(window->egl.visual);
+       window->egl.visual = NULL;
+    }
+#endif // _GLFW_X11
+
+    if (window->egl.surface)
+    {
+        eglDestroySurface(_glfw.egl.display, window->egl.surface);
+        window->egl.surface = EGL_NO_SURFACE;
+    }
+
+    if (window->egl.context)
+    {
+        eglDestroyContext(_glfw.egl.display, window->egl.context);
+        window->egl.context = EGL_NO_CONTEXT;
+    }
+}
+
+// Analyzes the specified context for possible recreation
+//
+int _glfwAnalyzeContext(const _GLFWwindow* window,
+                        const _GLFWwndconfig* wndconfig,
+                        const _GLFWfbconfig* fbconfig)
+{
+#if defined(_GLFW_WIN32)
+    return _GLFW_RECREATION_NOT_NEEDED;
+#else
+    return 0;
+#endif
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+    {
+        if (window->egl.surface == EGL_NO_SURFACE)
+        {
+            window->egl.surface = eglCreateWindowSurface(_glfw.egl.display,
+                                                         window->egl.config,
+                                                         (EGLNativeWindowType)_GLFW_EGL_NATIVE_WINDOW,
+                                                         NULL);
+            if (window->egl.surface == EGL_NO_SURFACE)
+            {
+                _glfwInputError(GLFW_PLATFORM_ERROR,
+                                "EGL: Failed to create window surface: %s",
+                                getErrorString(eglGetError()));
+            }
+        }
+
+        eglMakeCurrent(_glfw.egl.display,
+                       window->egl.surface,
+                       window->egl.surface,
+                       window->egl.context);
+    }
+    else
+    {
+        eglMakeCurrent(_glfw.egl.display,
+                       EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    }
+
+    _glfwCurrentWindow = window;
+}
+
+_GLFWwindow* _glfwPlatformGetCurrentContext(void)
+{
+    return _glfwCurrentWindow;
+}
+
+void _glfwPlatformSwapBuffers(_GLFWwindow* window)
+{
+    eglSwapBuffers(_glfw.egl.display, window->egl.surface);
+}
+
+void _glfwPlatformSwapInterval(int interval)
+{
+    eglSwapInterval(_glfw.egl.display, interval);
+}
+
+int _glfwPlatformExtensionSupported(const char* extension)
+{
+    const char* extensions;
+
+    extensions = eglQueryString(_glfw.egl.display, EGL_EXTENSIONS);
+    if (extensions != NULL)
+    {
+        if (_glfwStringInExtensionString(extension, (unsigned char*) extensions))
+            return GL_TRUE;
+    }
+
+    return GL_FALSE;
+}
+
+GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
+{
+    return eglGetProcAddress(procname);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI EGLDisplay glfwGetEGLDisplay(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return _glfw.egl.display;
+}
+
+GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return window->egl.context;
+}
+
+GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+    return window->egl.surface;
+}
+

libs/glfw-3.0.4/src/egl_platform.h

@@ -0,0 +1,80 @@
+//========================================================================
+// GLFW 3.0 EGL - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _egl_platform_h_
+#define _egl_platform_h_
+
+#include <EGL/egl.h>
+
+// This path may need to be changed if you build GLFW using your own setup
+// We ship and use our own copy of eglext.h since GLFW uses fairly new
+// extensions and not all operating systems come with an up-to-date version
+#include "../deps/EGL/eglext.h"
+
+// Do we have support for dlopen/dlsym?
+#if defined(_GLFW_HAS_DLOPEN)
+ #include <dlfcn.h>
+#endif
+
+#define _GLFW_PLATFORM_FBCONFIG             EGLConfig       egl
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextEGL egl
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryEGL egl
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextEGL
+{
+   EGLConfig      config;
+   EGLContext     context;
+   EGLSurface     surface;
+
+#if defined(_GLFW_X11)
+   XVisualInfo*   visual;
+#endif
+} _GLFWcontextEGL;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for EGL
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryEGL
+{
+    EGLDisplay      display;
+    EGLint          versionMajor, versionMinor;
+
+    GLboolean       KHR_create_context;
+
+} _GLFWlibraryEGL;
+
+
+#endif // _egl_platform_h_

libs/glfw-3.0.4/src/gamma.c

@@ -0,0 +1,126 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_MSC_VER)
+ #include <malloc.h>
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwAllocGammaArrays(GLFWgammaramp* ramp, unsigned int size)
+{
+    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 _glfwFreeGammaArrays(GLFWgammaramp* ramp)
+{
+    free(ramp->red);
+    free(ramp->green);
+    free(ramp->blue);
+
+    memset(ramp, 0, sizeof(GLFWgammaramp));
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
+{
+    int i;
+    unsigned short values[256];
+    GLFWgammaramp ramp;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (gamma <= 0.f)
+    {
+        _glfwInputError(GLFW_INVALID_VALUE,
+                        "Gamma value must be greater than zero");
+        return;
+    }
+
+    for (i = 0;  i < 256;  i++)
+    {
+        double value;
+
+        // Calculate intensity
+        value = i / 255.0;
+        // Apply gamma curve
+        value = pow(value, 1.0 / gamma) * 65535.0 + 0.5;
+
+        // Clamp to value range
+        if (value > 65535.0)
+            value = 65535.0;
+
+        values[i] = (unsigned short) value;
+    }
+
+    ramp.red = values;
+    ramp.green = values;
+    ramp.blue = values;
+    ramp.size = 256;
+
+    glfwSetGammaRamp(handle, &ramp);
+}
+
+GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* handle)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    _glfwFreeGammaArrays(&monitor->currentRamp);
+    _glfwPlatformGetGammaRamp(monitor, &monitor->currentRamp);
+
+    return &monitor->currentRamp;
+}
+
+GLFWAPI void glfwSetGammaRamp(GLFWmonitor* handle, const GLFWgammaramp* ramp)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (!monitor->originalRamp.size)
+        _glfwPlatformGetGammaRamp(monitor, &monitor->originalRamp);
+
+    _glfwPlatformSetGammaRamp(monitor, ramp);
+}
+

libs/glfw-3.0.4/src/glfw3.pc.in

@@ -0,0 +1,13 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+includedir=${prefix}/include
+libdir=${exec_prefix}/lib@LIB_SUFFIX@
+
+Name: GLFW
+Description: A portable library for OpenGL, window and input
+Version: @GLFW_VERSION_FULL@
+URL: http://www.glfw.org/
+Requires.private: @GLFW_PKG_DEPS@
+Libs: -L${libdir} -l@GLFW_LIB_NAME@
+Libs.private: @GLFW_PKG_LIBS@
+Cflags: -I${includedir}

libs/glfw-3.0.4/src/glfwConfig.cmake.in

@@ -0,0 +1,10 @@
+# - Config file for the glfw package
+# It defines the following variables
+#   GLFW_INCLUDE_DIR, the path where GLFW headers are located
+#   GLFW_LIBRARY_DIR, folder in which the GLFW library is located
+#   GLFW_LIBRARY, library to link against to use GLFW
+
+set(GLFW_INCLUDE_DIR "@CMAKE_INSTALL_PREFIX@/include")
+set(GLFW_LIBRARY_DIR "@CMAKE_INSTALL_PREFIX@/lib@LIB_SUFFIX@")
+
+find_library(GLFW_LIBRARY "@GLFW_LIB_NAME@" HINTS ${GLFW_LIBRARY_DIR})

libs/glfw-3.0.4/src/glfwConfigVersion.cmake.in

@@ -0,0 +1,12 @@
+
+set(PACKAGE_VERSION "@GLFW_VERSION_FULL@")
+
+if ("${PACKAGE_FIND_VERSION_MAJOR}" EQUAL "@GLFW_VERSION_MAJOR@")
+	set(PACKAGE_VERSION_COMPATIBLE TRUE)
+	if ("${PACKAGE_FIND_VERSION_MINOR}" EQUAL @GLFW_VERSION_MINOR@)
+		set(PACKAGE_VERSION_EXACT TRUE)
+	endif()
+else()
+	set(PACKAGE_VERSION_COMPATIBLE FALSE)
+endif()
+

libs/glfw-3.0.4/src/glfw_config.h.in

@@ -0,0 +1,83 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+// As glfw_config.h.in, this file is used by CMake to produce the
+// glfw_config.h configuration header file.  If you are adding a feature
+// requiring conditional compilation, this is where to add the macro.
+//========================================================================
+// As glfw_config.h, this file defines compile-time option macros for a
+// specific platform and development environment.  If you are using the
+// GLFW CMake files, modify glfw_config.h.in instead of this file.  If you
+// are using your own build system, make this file define the appropriate
+// macros in whatever way is suitable.
+//========================================================================
+
+// Define this to 1 if building GLFW for X11
+#cmakedefine _GLFW_X11
+// Define this to 1 if building GLFW for Win32
+#cmakedefine _GLFW_WIN32
+// Define this to 1 if building GLFW for Cocoa
+#cmakedefine _GLFW_COCOA
+
+// Define this to 1 if building GLFW for EGL
+#cmakedefine _GLFW_EGL
+// Define this to 1 if building GLFW for GLX
+#cmakedefine _GLFW_GLX
+// Define this to 1 if building GLFW for WGL
+#cmakedefine _GLFW_WGL
+// Define this to 1 if building GLFW for NSGL
+#cmakedefine _GLFW_NSGL
+
+// Define this to 1 if building as a shared library / dynamic library / DLL
+#cmakedefine _GLFW_BUILD_DLL
+
+// 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
+// Define this to 1 if glXGetProcAddressARB is available
+#cmakedefine _GLFW_HAS_GLXGETPROCADDRESSARB
+// Define this to 1 if glXGetProcAddressEXT is available
+#cmakedefine _GLFW_HAS_GLXGETPROCADDRESSEXT
+// Define this to 1 if dlopen is available
+#cmakedefine _GLFW_HAS_DLOPEN
+
+// Define this to 1 if glfwInit should change the current directory
+#cmakedefine _GLFW_USE_CHDIR
+// Define this to 1 if glfwCreateWindow should populate the menu bar
+#cmakedefine _GLFW_USE_MENUBAR
+
+// Define this to 1 if using OpenGL as the client library
+#cmakedefine _GLFW_USE_OPENGL
+// Define this to 1 if using OpenGL ES 1.1 as the client library
+#cmakedefine _GLFW_USE_GLESV1
+// Define this to 1 if using OpenGL ES 2.0 as the client library
+#cmakedefine _GLFW_USE_GLESV2
+

libs/glfw-3.0.4/src/glx_context.c

@@ -0,0 +1,612 @@
+//========================================================================
+// GLFW 3.0 GLX - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+
+// This is the only glXGetProcAddress variant not declared by glxext.h
+void (*glXGetProcAddressEXT(const GLubyte* procName))();
+
+
+#ifndef GLXBadProfileARB
+ #define GLXBadProfileARB 13
+#endif
+
+
+// Returns the specified attribute of the specified GLXFBConfig
+// NOTE: Do not call this unless we have found GLX 1.3+ or GLX_SGIX_fbconfig
+//
+static int getFBConfigAttrib(GLXFBConfig fbconfig, int attrib)
+{
+    int value;
+
+    if (_glfw.glx.SGIX_fbconfig)
+    {
+        _glfw.glx.GetFBConfigAttribSGIX(_glfw.x11.display,
+                                        fbconfig, attrib, &value);
+    }
+    else
+        glXGetFBConfigAttrib(_glfw.x11.display, fbconfig, attrib, &value);
+
+    return value;
+}
+
+// Return a list of available and usable framebuffer configs
+//
+static GLboolean chooseFBConfig(const _GLFWfbconfig* desired, GLXFBConfig* result)
+{
+    GLXFBConfig* nativeConfigs;
+    _GLFWfbconfig* usableConfigs;
+    const _GLFWfbconfig* closest;
+    int i, nativeCount, usableCount;
+    const char* vendor;
+    GLboolean trustWindowBit = GL_TRUE;
+
+    vendor = glXGetClientString(_glfw.x11.display, GLX_VENDOR);
+    if (strcmp(vendor, "Chromium") == 0)
+    {
+        // HACK: This is a (hopefully temporary) workaround for Chromium
+        //       (VirtualBox GL) not setting the window bit on any GLXFBConfigs
+        trustWindowBit = GL_FALSE;
+    }
+
+    if (_glfw.glx.SGIX_fbconfig)
+    {
+        nativeConfigs = _glfw.glx.ChooseFBConfigSGIX(_glfw.x11.display,
+                                                     _glfw.x11.screen,
+                                                     NULL,
+                                                     &nativeCount);
+    }
+    else
+    {
+        nativeConfigs = glXGetFBConfigs(_glfw.x11.display,
+                                        _glfw.x11.screen,
+                                        &nativeCount);
+    }
+
+    if (!nativeCount)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "GLX: No GLXFBConfigs returned");
+        return GL_FALSE;
+    }
+
+    usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
+    usableCount = 0;
+
+    for (i = 0;  i < nativeCount;  i++)
+    {
+        const GLXFBConfig n = nativeConfigs[i];
+        _GLFWfbconfig* u = usableConfigs + usableCount;
+
+        if (!getFBConfigAttrib(n, GLX_DOUBLEBUFFER) ||
+            !getFBConfigAttrib(n, GLX_VISUAL_ID))
+        {
+            // Only consider double-buffered GLXFBConfigs with associated visuals
+            continue;
+        }
+
+        if (!(getFBConfigAttrib(n, GLX_RENDER_TYPE) & GLX_RGBA_BIT))
+        {
+            // Only consider RGBA GLXFBConfigs
+            continue;
+        }
+
+        if (!(getFBConfigAttrib(n, GLX_DRAWABLE_TYPE) & GLX_WINDOW_BIT))
+        {
+            if (trustWindowBit)
+            {
+                // Only consider window GLXFBConfigs
+                continue;
+            }
+        }
+
+        u->redBits = getFBConfigAttrib(n, GLX_RED_SIZE);
+        u->greenBits = getFBConfigAttrib(n, GLX_GREEN_SIZE);
+        u->blueBits = getFBConfigAttrib(n, GLX_BLUE_SIZE);
+
+        u->alphaBits = getFBConfigAttrib(n, GLX_ALPHA_SIZE);
+        u->depthBits = getFBConfigAttrib(n, GLX_DEPTH_SIZE);
+        u->stencilBits = getFBConfigAttrib(n, GLX_STENCIL_SIZE);
+
+        u->accumRedBits = getFBConfigAttrib(n, GLX_ACCUM_RED_SIZE);
+        u->accumGreenBits = getFBConfigAttrib(n, GLX_ACCUM_GREEN_SIZE);
+        u->accumBlueBits = getFBConfigAttrib(n, GLX_ACCUM_BLUE_SIZE);
+        u->accumAlphaBits = getFBConfigAttrib(n, GLX_ACCUM_ALPHA_SIZE);
+
+        u->auxBuffers = getFBConfigAttrib(n, GLX_AUX_BUFFERS);
+        u->stereo = getFBConfigAttrib(n, GLX_STEREO);
+
+        if (_glfw.glx.ARB_multisample)
+            u->samples = getFBConfigAttrib(n, GLX_SAMPLES);
+
+        if (_glfw.glx.ARB_framebuffer_sRGB)
+            u->sRGB = getFBConfigAttrib(n, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB);
+
+        u->glx = n;
+        usableCount++;
+    }
+
+    closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
+    if (closest)
+        *result = closest->glx;
+
+    XFree(nativeConfigs);
+    free(usableConfigs);
+
+    return closest ? GL_TRUE : GL_FALSE;
+}
+
+// Create the OpenGL context using legacy API
+//
+static GLXContext createLegacyContext(_GLFWwindow* window,
+                                      GLXFBConfig fbconfig,
+                                      GLXContext share)
+{
+    if (_glfw.glx.SGIX_fbconfig)
+    {
+        return _glfw.glx.CreateContextWithConfigSGIX(_glfw.x11.display,
+                                                     fbconfig,
+                                                     GLX_RGBA_TYPE,
+                                                     share,
+                                                     True);
+    }
+
+    return glXCreateNewContext(_glfw.x11.display,
+                               fbconfig,
+                               GLX_RGBA_TYPE,
+                               share,
+                               True);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize GLX
+//
+int _glfwInitContextAPI(void)
+{
+#ifdef _GLFW_DLOPEN_LIBGL
+    int i;
+    char* libGL_names[ ] =
+    {
+        "libGL.so",
+        "libGL.so.1",
+        "/usr/lib/libGL.so",
+        "/usr/lib/libGL.so.1",
+        NULL
+    };
+
+    for (i = 0;  libGL_names[i] != NULL;  i++)
+    {
+        _glfw.glx.libGL = dlopen(libGL_names[i], RTLD_LAZY | RTLD_GLOBAL);
+        if (_glfw.glx.libGL)
+            break;
+    }
+
+    if (!_glfw.glx.libGL)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "GLX: Failed to find libGL");
+        return GL_FALSE;
+    }
+#endif
+
+    if (pthread_key_create(&_glfw.glx.current, NULL) != 0)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "GLX: Failed to create context TLS");
+        return GL_FALSE;
+    }
+
+    // Check if GLX is supported on this display
+    if (!glXQueryExtension(_glfw.x11.display,
+                           &_glfw.glx.errorBase,
+                           &_glfw.glx.eventBase))
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: GLX support not found");
+        return GL_FALSE;
+    }
+
+    if (!glXQueryVersion(_glfw.x11.display,
+                         &_glfw.glx.versionMajor,
+                         &_glfw.glx.versionMinor))
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "GLX: Failed to query GLX version");
+        return GL_FALSE;
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_EXT_swap_control"))
+    {
+        _glfw.glx.SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)
+            _glfwPlatformGetProcAddress("glXSwapIntervalEXT");
+
+        if (_glfw.glx.SwapIntervalEXT)
+            _glfw.glx.EXT_swap_control = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_SGI_swap_control"))
+    {
+        _glfw.glx.SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)
+            _glfwPlatformGetProcAddress("glXSwapIntervalSGI");
+
+        if (_glfw.glx.SwapIntervalSGI)
+            _glfw.glx.SGI_swap_control = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_MESA_swap_control"))
+    {
+        _glfw.glx.SwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)
+            _glfwPlatformGetProcAddress("glXSwapIntervalMESA");
+
+        if (_glfw.glx.SwapIntervalMESA)
+            _glfw.glx.MESA_swap_control = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_SGIX_fbconfig"))
+    {
+        _glfw.glx.GetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)
+            _glfwPlatformGetProcAddress("glXGetFBConfigAttribSGIX");
+        _glfw.glx.ChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)
+            _glfwPlatformGetProcAddress("glXChooseFBConfigSGIX");
+        _glfw.glx.CreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)
+            _glfwPlatformGetProcAddress("glXCreateContextWithConfigSGIX");
+        _glfw.glx.GetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)
+            _glfwPlatformGetProcAddress("glXGetVisualFromFBConfigSGIX");
+
+        if (_glfw.glx.GetFBConfigAttribSGIX &&
+            _glfw.glx.ChooseFBConfigSGIX &&
+            _glfw.glx.CreateContextWithConfigSGIX &&
+            _glfw.glx.GetVisualFromFBConfigSGIX)
+        {
+            _glfw.glx.SGIX_fbconfig = GL_TRUE;
+        }
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_ARB_multisample"))
+        _glfw.glx.ARB_multisample = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("GLX_ARB_framebuffer_sRGB"))
+        _glfw.glx.ARB_framebuffer_sRGB = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("GLX_ARB_create_context"))
+    {
+        _glfw.glx.CreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)
+            _glfwPlatformGetProcAddress("glXCreateContextAttribsARB");
+
+        if (_glfw.glx.CreateContextAttribsARB)
+            _glfw.glx.ARB_create_context = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("GLX_ARB_create_context_robustness"))
+        _glfw.glx.ARB_create_context_robustness = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("GLX_ARB_create_context_profile"))
+        _glfw.glx.ARB_create_context_profile = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("GLX_EXT_create_context_es2_profile"))
+        _glfw.glx.EXT_create_context_es2_profile = GL_TRUE;
+
+    return GL_TRUE;
+}
+
+// Terminate GLX
+//
+void _glfwTerminateContextAPI(void)
+{
+    // Unload libGL.so if necessary
+#ifdef _GLFW_DLOPEN_LIBGL
+    if (_glfw.glx.libGL != NULL)
+    {
+        dlclose(_glfw.glx.libGL);
+        _glfw.glx.libGL = NULL;
+    }
+#endif
+
+    pthread_key_delete(_glfw.glx.current);
+}
+
+#define setGLXattrib(attribName, attribValue) \
+{ \
+    attribs[index++] = attribName; \
+    attribs[index++] = attribValue; \
+    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
+}
+
+// Prepare for creation of the OpenGL context
+//
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig)
+{
+    int attribs[40];
+    GLXFBConfig native;
+    GLXContext share = NULL;
+
+    if (wndconfig->share)
+        share = wndconfig->share->glx.context;
+
+    if (!chooseFBConfig(fbconfig, &native))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "GLX: Failed to find a suitable GLXFBConfig");
+        return GL_FALSE;
+    }
+
+    // Retrieve the corresponding visual
+    if (_glfw.glx.SGIX_fbconfig)
+    {
+        window->glx.visual =
+            _glfw.glx.GetVisualFromFBConfigSGIX(_glfw.x11.display, native);
+    }
+    else
+        window->glx.visual = glXGetVisualFromFBConfig(_glfw.x11.display, native);
+
+    if (window->glx.visual == NULL)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "GLX: Failed to retrieve visual for GLXFBConfig");
+        return GL_FALSE;
+    }
+
+    if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+    {
+        if (!_glfw.glx.ARB_create_context ||
+            !_glfw.glx.ARB_create_context_profile ||
+            !_glfw.glx.EXT_create_context_es2_profile)
+        {
+            _glfwInputError(GLFW_API_UNAVAILABLE,
+                            "GLX: OpenGL ES requested but "
+                            "GLX_EXT_create_context_es2_profile is unavailable");
+            return GL_FALSE;
+        }
+    }
+
+    if (wndconfig->glForward)
+    {
+        if (!_glfw.glx.ARB_create_context)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "GLX: Forward compatibility requested but "
+                            "GLX_ARB_create_context_profile is unavailable");
+            return GL_FALSE;
+        }
+    }
+
+    if (wndconfig->glProfile)
+    {
+        if (!_glfw.glx.ARB_create_context ||
+            !_glfw.glx.ARB_create_context_profile)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "GLX: An OpenGL profile requested but "
+                            "GLX_ARB_create_context_profile is unavailable");
+            return GL_FALSE;
+        }
+    }
+
+    _glfwGrabXErrorHandler();
+
+    if (_glfw.glx.ARB_create_context)
+    {
+        int index = 0, mask = 0, flags = 0, strategy = 0;
+
+        if (wndconfig->clientAPI == GLFW_OPENGL_API)
+        {
+            if (wndconfig->glForward)
+                flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
+
+            if (wndconfig->glDebug)
+                flags |= GLX_CONTEXT_DEBUG_BIT_ARB;
+
+            if (wndconfig->glProfile)
+            {
+                if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
+                    mask |= GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
+                else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
+                    mask |= GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
+            }
+        }
+        else
+            mask |= GLX_CONTEXT_ES2_PROFILE_BIT_EXT;
+
+        if (wndconfig->glRobustness != GLFW_NO_ROBUSTNESS)
+        {
+            if (_glfw.glx.ARB_create_context_robustness)
+            {
+                if (wndconfig->glRobustness == GLFW_NO_RESET_NOTIFICATION)
+                    strategy = GLX_NO_RESET_NOTIFICATION_ARB;
+                else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET)
+                    strategy = GLX_LOSE_CONTEXT_ON_RESET_ARB;
+
+                flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB;
+            }
+        }
+
+        if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
+        {
+            // NOTE: Only request an explicitly versioned context when
+            //       necessary, as explicitly requesting version 1.0 does not
+            //       always return the highest available version
+
+            setGLXattrib(GLX_CONTEXT_MAJOR_VERSION_ARB, wndconfig->glMajor);
+            setGLXattrib(GLX_CONTEXT_MINOR_VERSION_ARB, wndconfig->glMinor);
+        }
+
+        if (mask)
+            setGLXattrib(GLX_CONTEXT_PROFILE_MASK_ARB, mask);
+
+        if (flags)
+            setGLXattrib(GLX_CONTEXT_FLAGS_ARB, flags);
+
+        if (strategy)
+            setGLXattrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, strategy);
+
+        setGLXattrib(None, None);
+
+        window->glx.context =
+            _glfw.glx.CreateContextAttribsARB(_glfw.x11.display,
+                                              native,
+                                              share,
+                                              True,
+                                              attribs);
+
+        if (window->glx.context == NULL)
+        {
+            // HACK: This is a fallback for the broken Mesa implementation of
+            //       GLX_ARB_create_context_profile, which fails default 1.0
+            //       context creation with a GLXBadProfileARB error in violation
+            //       of the extension spec
+            if (_glfw.x11.errorCode == _glfw.glx.errorBase + GLXBadProfileARB &&
+                wndconfig->clientAPI == GLFW_OPENGL_API &&
+                wndconfig->glProfile == GLFW_OPENGL_ANY_PROFILE &&
+                wndconfig->glForward == GL_FALSE)
+            {
+                window->glx.context = createLegacyContext(window, native, share);
+            }
+        }
+    }
+    else
+        window->glx.context = createLegacyContext(window, native, share);
+
+    _glfwReleaseXErrorHandler();
+
+    if (window->glx.context == NULL)
+    {
+        _glfwInputXError(GLFW_PLATFORM_ERROR, "GLX: Failed to create context");
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+#undef setGLXattrib
+
+// Destroy the OpenGL context
+//
+void _glfwDestroyContext(_GLFWwindow* window)
+{
+    if (window->glx.visual)
+    {
+        XFree(window->glx.visual);
+        window->glx.visual = NULL;
+    }
+
+    if (window->glx.context)
+    {
+        glXDestroyContext(_glfw.x11.display, window->glx.context);
+        window->glx.context = NULL;
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+    {
+        glXMakeCurrent(_glfw.x11.display,
+                       window->x11.handle,
+                       window->glx.context);
+    }
+    else
+        glXMakeCurrent(_glfw.x11.display, None, NULL);
+
+    pthread_setspecific(_glfw.glx.current, window);
+}
+
+_GLFWwindow* _glfwPlatformGetCurrentContext(void)
+{
+    return (_GLFWwindow*) pthread_getspecific(_glfw.glx.current);
+}
+
+void _glfwPlatformSwapBuffers(_GLFWwindow* window)
+{
+    glXSwapBuffers(_glfw.x11.display, window->x11.handle);
+}
+
+void _glfwPlatformSwapInterval(int interval)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    if (_glfw.glx.EXT_swap_control)
+    {
+        _glfw.glx.SwapIntervalEXT(_glfw.x11.display,
+                                  window->x11.handle,
+                                  interval);
+    }
+    else if (_glfw.glx.MESA_swap_control)
+        _glfw.glx.SwapIntervalMESA(interval);
+    else if (_glfw.glx.SGI_swap_control)
+    {
+        if (interval > 0)
+            _glfw.glx.SwapIntervalSGI(interval);
+    }
+}
+
+int _glfwPlatformExtensionSupported(const char* extension)
+{
+    const GLubyte* extensions;
+
+    // Get list of GLX extensions
+    extensions = (const GLubyte*) glXQueryExtensionsString(_glfw.x11.display,
+                                                           _glfw.x11.screen);
+    if (extensions != NULL)
+    {
+        if (_glfwStringInExtensionString(extension, extensions))
+            return GL_TRUE;
+    }
+
+    return GL_FALSE;
+}
+
+GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
+{
+    return _glfw_glXGetProcAddress((const GLubyte*) procname);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return window->glx.context;
+}
+

libs/glfw-3.0.4/src/glx_platform.h

@@ -0,0 +1,125 @@
+//========================================================================
+// GLFW 3.0 GLX - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _glx_platform_h_
+#define _glx_platform_h_
+
+#define GLX_GLXEXT_LEGACY
+#include <GL/glx.h>
+
+// This path may need to be changed if you build GLFW using your own setup
+// We ship and use our own copy of glxext.h since GLFW uses fairly new
+// extensions and not all operating systems come with an up-to-date version
+#include "../deps/GL/glxext.h"
+
+// Do we have support for dlopen/dlsym?
+#if defined(_GLFW_HAS_DLOPEN)
+ #include <dlfcn.h>
+#endif
+
+#include <pthread.h>
+
+// We support four different ways for getting addresses for GL/GLX
+// extension functions: glXGetProcAddress, glXGetProcAddressARB,
+// glXGetProcAddressEXT, and dlsym
+#if defined(_GLFW_HAS_GLXGETPROCADDRESSARB)
+ #define _glfw_glXGetProcAddress(x) glXGetProcAddressARB(x)
+#elif defined(_GLFW_HAS_GLXGETPROCADDRESS)
+ #define _glfw_glXGetProcAddress(x) glXGetProcAddress(x)
+#elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
+ #define _glfw_glXGetProcAddress(x) glXGetProcAddressEXT(x)
+#elif defined(_GLFW_HAS_DLOPEN)
+ #define _glfw_glXGetProcAddress(x) dlsym(_glfw.glx.libGL, x)
+ #define _GLFW_DLOPEN_LIBGL
+#else
+ #error "No OpenGL entry point retrieval mechanism was enabled"
+#endif
+
+#define _GLFW_PLATFORM_FBCONFIG             GLXFBConfig     glx
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextGLX glx
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryGLX glx
+
+#ifndef GLX_MESA_swap_control
+typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
+#endif
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextGLX
+{
+    GLXContext      context; // OpenGL rendering context
+    XVisualInfo*    visual;  // Visual for selected GLXFBConfig
+
+} _GLFWcontextGLX;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for GLX
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryGLX
+{
+    // Server-side GLX version
+    int             versionMajor, versionMinor;
+    int             eventBase;
+    int             errorBase;
+
+    // TLS key for per-thread current context/window
+    pthread_key_t   current;
+
+    // GLX extensions
+    PFNGLXSWAPINTERVALSGIPROC             SwapIntervalSGI;
+    PFNGLXSWAPINTERVALEXTPROC             SwapIntervalEXT;
+    PFNGLXSWAPINTERVALMESAPROC            SwapIntervalMESA;
+    PFNGLXGETFBCONFIGATTRIBSGIXPROC       GetFBConfigAttribSGIX;
+    PFNGLXCHOOSEFBCONFIGSGIXPROC          ChooseFBConfigSGIX;
+    PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC CreateContextWithConfigSGIX;
+    PFNGLXGETVISUALFROMFBCONFIGSGIXPROC   GetVisualFromFBConfigSGIX;
+    PFNGLXCREATECONTEXTATTRIBSARBPROC     CreateContextAttribsARB;
+    GLboolean       SGIX_fbconfig;
+    GLboolean       SGI_swap_control;
+    GLboolean       EXT_swap_control;
+    GLboolean       MESA_swap_control;
+    GLboolean       ARB_multisample;
+    GLboolean       ARB_framebuffer_sRGB;
+    GLboolean       ARB_create_context;
+    GLboolean       ARB_create_context_profile;
+    GLboolean       ARB_create_context_robustness;
+    GLboolean       EXT_create_context_es2_profile;
+
+#if defined(_GLFW_DLOPEN_LIBGL)
+    void*           libGL;  // dlopen handle for libGL.so
+#endif
+} _GLFWlibraryGLX;
+
+
+#endif // _glx_platform_h_

libs/glfw-3.0.4/src/init.c

@@ -0,0 +1,197 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+
+// Global state shared between compilation units of GLFW
+// These are documented in internal.h
+//
+GLboolean _glfwInitialized = GL_FALSE;
+_GLFWlibrary _glfw;
+
+
+// The current error callback
+// This is outside of _glfw so it can be initialized and usable before
+// glfwInit is called, which lets that function report errors
+//
+static GLFWerrorfun _glfwErrorCallback = NULL;
+
+
+// Returns a generic string representation of the specified error
+//
+static const char* getErrorString(int error)
+{
+    switch (error)
+    {
+        case GLFW_NOT_INITIALIZED:
+            return "The GLFW library is not initialized";
+        case GLFW_NO_CURRENT_CONTEXT:
+            return "There is no current context";
+        case GLFW_INVALID_ENUM:
+            return "Invalid argument for enum parameter";
+        case GLFW_INVALID_VALUE:
+            return "Invalid value for parameter";
+        case GLFW_OUT_OF_MEMORY:
+            return "Out of memory";
+        case GLFW_API_UNAVAILABLE:
+            return "The requested client API is unavailable";
+        case GLFW_VERSION_UNAVAILABLE:
+            return "The requested client API version is unavailable";
+        case GLFW_PLATFORM_ERROR:
+            return "A platform-specific error occurred";
+        case GLFW_FORMAT_UNAVAILABLE:
+            return "The requested format is unavailable";
+    }
+
+    return "ERROR: UNKNOWN ERROR TOKEN PASSED TO glfwErrorString";
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                         GLFW event API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwInputError(int error, const char* format, ...)
+{
+    if (_glfwErrorCallback)
+    {
+        char buffer[16384];
+        const char* description;
+
+        if (format)
+        {
+            int count;
+            va_list vl;
+
+            va_start(vl, format);
+            count = vsnprintf(buffer, sizeof(buffer), format, vl);
+            va_end(vl);
+
+            if (count < 0)
+                buffer[sizeof(buffer) - 1] = '\0';
+
+            description = buffer;
+        }
+        else
+            description = getErrorString(error);
+
+        _glfwErrorCallback(error, description);
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI int glfwInit(void)
+{
+    if (_glfwInitialized)
+        return GL_TRUE;
+
+    memset(&_glfw, 0, sizeof(_glfw));
+
+    if (!_glfwPlatformInit())
+    {
+        _glfwPlatformTerminate();
+        return GL_FALSE;
+    }
+
+    _glfw.monitors = _glfwPlatformGetMonitors(&_glfw.monitorCount);
+    if (_glfw.monitors == NULL)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "No monitors found");
+        _glfwPlatformTerminate();
+        return GL_FALSE;
+    }
+
+    _glfwInitialized = GL_TRUE;
+
+    // Not all window hints have zero as their default value
+    glfwDefaultWindowHints();
+
+    return GL_TRUE;
+}
+
+GLFWAPI void glfwTerminate(void)
+{
+    int i;
+
+    if (!_glfwInitialized)
+        return;
+
+    memset(&_glfw.callbacks, 0, sizeof(_glfw.callbacks));
+
+    // Close all remaining windows
+    while (_glfw.windowListHead)
+        glfwDestroyWindow((GLFWwindow*) _glfw.windowListHead);
+
+    for (i = 0;  i < _glfw.monitorCount;  i++)
+    {
+        _GLFWmonitor* monitor = _glfw.monitors[i];
+        if (monitor->originalRamp.size)
+            _glfwPlatformSetGammaRamp(monitor, &monitor->originalRamp);
+    }
+
+    _glfwDestroyMonitors(_glfw.monitors, _glfw.monitorCount);
+    _glfw.monitors = NULL;
+    _glfw.monitorCount = 0;
+
+    _glfwPlatformTerminate();
+
+    _glfwInitialized = GL_FALSE;
+}
+
+GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev)
+{
+    if (major != NULL)
+        *major = GLFW_VERSION_MAJOR;
+
+    if (minor != NULL)
+        *minor = GLFW_VERSION_MINOR;
+
+    if (rev != NULL)
+        *rev = GLFW_VERSION_REVISION;
+}
+
+GLFWAPI const char* glfwGetVersionString(void)
+{
+    return _glfwPlatformGetVersionString();
+}
+
+GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun cbfun)
+{
+    _GLFW_SWAP_POINTERS(_glfwErrorCallback, cbfun);
+    return cbfun;
+}
+

libs/glfw-3.0.4/src/input.c

@@ -0,0 +1,396 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+// Internal key state used for sticky keys
+#define _GLFW_STICK 3
+
+
+// Sets the cursor mode for the specified window
+//
+static void setCursorMode(_GLFWwindow* window, int newMode)
+{
+    const int oldMode = window->cursorMode;
+
+    if (newMode != GLFW_CURSOR_NORMAL &&
+        newMode != GLFW_CURSOR_HIDDEN &&
+        newMode != GLFW_CURSOR_DISABLED)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, NULL);
+        return;
+    }
+
+    if (oldMode == newMode)
+        return;
+
+    window->cursorMode = 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;
+
+            _glfw.cursorPosX = window->cursorPosX;
+            _glfw.cursorPosY = window->cursorPosY;
+
+            _glfwPlatformGetWindowSize(window, &width, &height);
+            _glfwPlatformSetCursorPos(window, width / 2.0, height / 2.0);
+        }
+
+        _glfwPlatformSetCursorMode(window, newMode);
+    }
+}
+
+// Set sticky keys mode for the specified window
+//
+static void setStickyKeys(_GLFWwindow* window, int enabled)
+{
+    if (window->stickyKeys == enabled)
+        return;
+
+    if (!enabled)
+    {
+        int i;
+
+        // Release all sticky keys
+        for (i = 0;  i <= GLFW_KEY_LAST;  i++)
+        {
+            if (window->key[i] == _GLFW_STICK)
+                window->key[i] = GLFW_RELEASE;
+        }
+    }
+
+    window->stickyKeys = enabled;
+}
+
+// Set sticky mouse buttons mode for the specified window
+//
+static void setStickyMouseButtons(_GLFWwindow* window, int enabled)
+{
+    if (window->stickyMouseButtons == enabled)
+        return;
+
+    if (!enabled)
+    {
+        int i;
+
+        // Release all sticky mouse buttons
+        for (i = 0;  i <= GLFW_MOUSE_BUTTON_LAST;  i++)
+        {
+            if (window->mouseButton[i] == _GLFW_STICK)
+                window->mouseButton[i] = GLFW_RELEASE;
+        }
+    }
+
+    window->stickyMouseButtons = enabled;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                         GLFW event API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    GLboolean repeated = GL_FALSE;
+
+    if (action == GLFW_RELEASE && window->key[key] == GLFW_RELEASE)
+        return;
+
+    if (key >= 0 && key <= GLFW_KEY_LAST)
+    {
+        if (action == GLFW_PRESS && window->key[key] == GLFW_PRESS)
+            repeated = GL_TRUE;
+
+        if (action == GLFW_RELEASE && window->stickyKeys)
+            window->key[key] = _GLFW_STICK;
+        else
+            window->key[key] = (char) action;
+    }
+
+    if (repeated)
+        action = GLFW_REPEAT;
+
+    if (window->callbacks.key)
+        window->callbacks.key((GLFWwindow*) window, key, scancode, action, mods);
+}
+
+void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint)
+{
+    if (codepoint < 32 || (codepoint > 126 && codepoint < 160))
+        return;
+
+    if (window->callbacks.character)
+        window->callbacks.character((GLFWwindow*) window, codepoint);
+}
+
+void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset)
+{
+    if (window->callbacks.scroll)
+        window->callbacks.scroll((GLFWwindow*) window, xoffset, yoffset);
+}
+
+void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
+{
+    if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
+        return;
+
+    // Register mouse button action
+    if (action == GLFW_RELEASE && window->stickyMouseButtons)
+        window->mouseButton[button] = _GLFW_STICK;
+    else
+        window->mouseButton[button] = (char) action;
+
+    if (window->callbacks.mouseButton)
+        window->callbacks.mouseButton((GLFWwindow*) window, button, action, mods);
+}
+
+void _glfwInputCursorMotion(_GLFWwindow* window, double x, double y)
+{
+    if (window->cursorMode == GLFW_CURSOR_DISABLED)
+    {
+        if (x == 0.0 && y == 0.0)
+            return;
+
+        window->cursorPosX += x;
+        window->cursorPosY += y;
+    }
+    else
+    {
+        if (window->cursorPosX == x && window->cursorPosY == y)
+            return;
+
+        window->cursorPosX = x;
+        window->cursorPosY = y;
+    }
+
+    if (window->callbacks.cursorPos)
+    {
+        window->callbacks.cursorPos((GLFWwindow*) window,
+                                    window->cursorPosX,
+                                    window->cursorPosY);
+    }
+}
+
+void _glfwInputCursorEnter(_GLFWwindow* window, int entered)
+{
+    if (window->callbacks.cursorEnter)
+        window->callbacks.cursorEnter((GLFWwindow*) window, entered);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+
+    switch (mode)
+    {
+        case GLFW_CURSOR:
+            return window->cursorMode;
+        case GLFW_STICKY_KEYS:
+            return window->stickyKeys;
+        case GLFW_STICKY_MOUSE_BUTTONS:
+            return window->stickyMouseButtons;
+        default:
+            _glfwInputError(GLFW_INVALID_ENUM, NULL);
+            return 0;
+    }
+}
+
+GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    switch (mode)
+    {
+        case GLFW_CURSOR:
+            setCursorMode(window, value);
+            break;
+        case GLFW_STICKY_KEYS:
+            setStickyKeys(window, value ? GL_TRUE : GL_FALSE);
+            break;
+        case GLFW_STICKY_MOUSE_BUTTONS:
+            setStickyMouseButtons(window, value ? GL_TRUE : GL_FALSE);
+            break;
+        default:
+            _glfwInputError(GLFW_INVALID_ENUM, NULL);
+            break;
+    }
+}
+
+GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
+
+    if (key < 0 || key > GLFW_KEY_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, "The specified key is invalid");
+        return GLFW_RELEASE;
+    }
+
+    if (window->key[key] == _GLFW_STICK)
+    {
+        // Sticky mode: release key now
+        window->key[key] = GLFW_RELEASE;
+        return GLFW_PRESS;
+    }
+
+    return (int) window->key[key];
+}
+
+GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
+
+    if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM,
+                        "The specified mouse button is invalid");
+        return GLFW_RELEASE;
+    }
+
+    if (window->mouseButton[button] == _GLFW_STICK)
+    {
+        // Sticky mode: release mouse button now
+        window->mouseButton[button] = GLFW_RELEASE;
+        return GLFW_PRESS;
+    }
+
+    return (int) window->mouseButton[button];
+}
+
+GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (xpos)
+        *xpos = window->cursorPosX;
+
+    if (ypos)
+        *ypos = window->cursorPosY;
+}
+
+GLFWAPI void glfwSetCursorPos(GLFWwindow* handle, double xpos, double ypos)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (_glfw.focusedWindow != window)
+        return;
+
+    // Don't do anything if the cursor position did not change
+    if (xpos == window->cursorPosX && ypos == window->cursorPosY)
+        return;
+
+    // Set GLFW cursor position
+    window->cursorPosX = xpos;
+    window->cursorPosY = ypos;
+
+    // Do not move physical cursor if it is disabled
+    if (window->cursorMode == GLFW_CURSOR_DISABLED)
+        return;
+
+    // Update physical cursor position
+    _glfwPlatformSetCursorPos(window, xpos, ypos);
+}
+
+GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* handle, GLFWkeyfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.key, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* handle, GLFWcharfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.character, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* handle,
+                                                      GLFWmousebuttonfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.mouseButton, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* handle,
+                                                  GLFWcursorposfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.cursorPos, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* handle,
+                                                      GLFWcursorenterfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.cursorEnter, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* handle,
+                                            GLFWscrollfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.scroll, cbfun);
+    return cbfun;
+}
+

libs/glfw-3.0.4/src/internal.h

@@ -0,0 +1,776 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _internal_h_
+#define _internal_h_
+
+
+#if defined(_GLFW_USE_CONFIG_H)
+ #include "glfw_config.h"
+#endif
+
+#define _GLFW_VERSION_NUMBER "3.0.4"
+
+#if defined(_GLFW_USE_OPENGL)
+ // This is the default for glfw3.h
+#elif defined(_GLFW_USE_GLESV1)
+ #define GLFW_INCLUDE_ES1
+#elif defined(_GLFW_USE_GLESV2)
+ #define GLFW_INCLUDE_ES2
+#else
+ #error "No supported client library selected"
+#endif
+
+// Disable the inclusion of the platform glext.h by gl.h to allow proper
+// inclusion of our own, newer glext.h below
+#define GL_GLEXT_LEGACY
+
+#include "../include/GLFW/glfw3.h"
+
+#if defined(_GLFW_USE_OPENGL)
+ // This path may need to be changed if you build GLFW using your own setup
+ // GLFW comes with its own copy of glext.h since it uses fairly new extensions
+ // and not all development environments come with an up-to-date version
+ #include "../deps/GL/glext.h"
+#endif
+
+typedef struct _GLFWhints       _GLFWhints;
+typedef struct _GLFWwndconfig   _GLFWwndconfig;
+typedef struct _GLFWfbconfig    _GLFWfbconfig;
+typedef struct _GLFWwindow      _GLFWwindow;
+typedef struct _GLFWlibrary     _GLFWlibrary;
+typedef struct _GLFWmonitor     _GLFWmonitor;
+
+#if defined(_GLFW_COCOA)
+ #include "cocoa_platform.h"
+#elif defined(_GLFW_WIN32)
+ #include "win32_platform.h"
+#elif defined(_GLFW_X11)
+ #include "x11_platform.h"
+#else
+ #error "No supported window creation API selected"
+#endif
+
+
+//========================================================================
+// Doxygen group definitions
+//========================================================================
+
+/*! @defgroup platform Platform interface
+ *  @brief The interface implemented by the platform-specific code.
+ *
+ *  The platform API is the interface exposed by the platform-specific code for
+ *  each platform and is called by the shared code of the public API It mirrors
+ *  the public API except it uses objects instead of handles.
+ */
+/*! @defgroup event Event interface
+ *  @brief The interface used by the platform-specific code to report events.
+ *
+ *  The event API is used by the platform-specific code to notify the shared
+ *  code of events that can be translated into state changes and/or callback
+ *  calls.
+ */
+/*! @defgroup utility Utility functions
+ *  @brief Various utility functions for internal use.
+ *
+ *  These functions are shared code and may be used by any part of GLFW
+ *  Each platform may add its own utility functions, but those may only be
+ *  called by the platform-specific code
+ */
+
+
+//========================================================================
+// Helper macros
+//========================================================================
+
+// Checks for whether the library has been intitalized
+#define _GLFW_REQUIRE_INIT()                         \
+    if (!_glfwInitialized)                           \
+    {                                                \
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
+        return;                                      \
+    }
+#define _GLFW_REQUIRE_INIT_OR_RETURN(x)              \
+    if (!_glfwInitialized)                           \
+    {                                                \
+        _glfwInputError(GLFW_NOT_INITIALIZED, NULL); \
+        return x;                                    \
+    }
+
+// Swaps the provided pointers
+#define _GLFW_SWAP_POINTERS(x, y) \
+    {                             \
+        void* t;                  \
+        t = x;                    \
+        x = y;                    \
+        y = t;                    \
+    }
+
+
+//========================================================================
+// Internal types
+//========================================================================
+
+/*! @brief Window and context configuration.
+ *
+ *  Parameters relating to the creation of the context and window but not
+ *  directly related to the framebuffer.  This is used to pass window and
+ *  context creation parameters from shared code to the platform API.
+ */
+struct _GLFWwndconfig
+{
+    int           width;
+    int           height;
+    const char*   title;
+    GLboolean     resizable;
+    GLboolean     visible;
+    GLboolean     decorated;
+    int           clientAPI;
+    int           glMajor;
+    int           glMinor;
+    GLboolean     glForward;
+    GLboolean     glDebug;
+    int           glProfile;
+    int           glRobustness;
+    _GLFWmonitor* monitor;
+    _GLFWwindow*  share;
+};
+
+
+/*! @brief Framebuffer configuration.
+ *
+ *  This describes buffers and their sizes.  It also contains
+ *  a platform-specific ID used to map back to the backend API's object.
+ *
+ *  It is used to pass framebuffer parameters from shared code to the platform
+ *  API and also to enumerate and select available framebuffer configs.
+ */
+struct _GLFWfbconfig
+{
+    int         redBits;
+    int         greenBits;
+    int         blueBits;
+    int         alphaBits;
+    int         depthBits;
+    int         stencilBits;
+    int         accumRedBits;
+    int         accumGreenBits;
+    int         accumBlueBits;
+    int         accumAlphaBits;
+    int         auxBuffers;
+    GLboolean   stereo;
+    int         samples;
+    GLboolean   sRGB;
+
+    // This is defined in the context API's platform.h
+    _GLFW_PLATFORM_FBCONFIG;
+};
+
+
+/*! @brief Window and context structure.
+ */
+struct _GLFWwindow
+{
+    struct _GLFWwindow* next;
+
+    // Window settings and state
+    GLboolean           iconified;
+    GLboolean           resizable;
+    GLboolean           decorated;
+    GLboolean           visible;
+    GLboolean           closed;
+    void*               userPointer;
+    GLFWvidmode         videoMode;
+    _GLFWmonitor*       monitor;
+
+    // Window input state
+    GLboolean           stickyKeys;
+    GLboolean           stickyMouseButtons;
+    double              cursorPosX, cursorPosY;
+    int                 cursorMode;
+    char                mouseButton[GLFW_MOUSE_BUTTON_LAST + 1];
+    char                key[GLFW_KEY_LAST + 1];
+
+    // OpenGL extensions and context attributes
+    int                 clientAPI;
+    int                 glMajor, glMinor, glRevision;
+    GLboolean           glForward, glDebug;
+    int                 glProfile;
+    int                 glRobustness;
+#if defined(_GLFW_USE_OPENGL)
+    PFNGLGETSTRINGIPROC GetStringi;
+#endif
+
+    struct {
+        GLFWwindowposfun        pos;
+        GLFWwindowsizefun       size;
+        GLFWwindowclosefun      close;
+        GLFWwindowrefreshfun    refresh;
+        GLFWwindowfocusfun      focus;
+        GLFWwindowiconifyfun    iconify;
+        GLFWframebuffersizefun  fbsize;
+        GLFWmousebuttonfun      mouseButton;
+        GLFWcursorposfun        cursorPos;
+        GLFWcursorenterfun      cursorEnter;
+        GLFWscrollfun           scroll;
+        GLFWkeyfun              key;
+        GLFWcharfun             character;
+    } callbacks;
+
+    // This is defined in the window API's platform.h
+    _GLFW_PLATFORM_WINDOW_STATE;
+    // This is defined in the context API's platform.h
+    _GLFW_PLATFORM_CONTEXT_STATE;
+};
+
+
+/*! @brief Monitor structure.
+ */
+struct _GLFWmonitor
+{
+    char*           name;
+
+    // Physical dimensions in millimeters.
+    int             widthMM, heightMM;
+
+    GLFWvidmode*    modes;
+    int             modeCount;
+    GLFWvidmode     currentMode;
+
+    GLFWgammaramp   originalRamp;
+    GLFWgammaramp   currentRamp;
+
+    // This is defined in the window API's platform.h
+    _GLFW_PLATFORM_MONITOR_STATE;
+};
+
+
+/*! @brief Library global data.
+ */
+struct _GLFWlibrary
+{
+    struct {
+        int         redBits;
+        int         greenBits;
+        int         blueBits;
+        int         alphaBits;
+        int         depthBits;
+        int         stencilBits;
+        int         accumRedBits;
+        int         accumGreenBits;
+        int         accumBlueBits;
+        int         accumAlphaBits;
+        int         auxBuffers;
+        GLboolean   stereo;
+        GLboolean   resizable;
+        GLboolean   visible;
+        GLboolean   decorated;
+        int         samples;
+        GLboolean   sRGB;
+        int         refreshRate;
+        int         clientAPI;
+        int         glMajor;
+        int         glMinor;
+        GLboolean   glForward;
+        GLboolean   glDebug;
+        int         glProfile;
+        int         glRobustness;
+    } hints;
+
+    double          cursorPosX, cursorPosY;
+
+    _GLFWwindow*    windowListHead;
+    _GLFWwindow*    focusedWindow;
+
+    _GLFWmonitor**  monitors;
+    int             monitorCount;
+
+    struct {
+        GLFWmonitorfun  monitor;
+    } callbacks;
+
+    // This is defined in the window API's platform.h
+    _GLFW_PLATFORM_LIBRARY_WINDOW_STATE;
+    // This is defined in the context API's platform.h
+    _GLFW_PLATFORM_LIBRARY_OPENGL_STATE;
+};
+
+
+//========================================================================
+// Global state shared between compilation units of GLFW
+//========================================================================
+
+/*! @brief Flag indicating whether GLFW has been successfully initialized.
+ */
+extern GLboolean _glfwInitialized;
+
+/*! @brief All global data protected by @ref _glfwInitialized.
+ *  This should only be touched after a call to @ref glfwInit that has not been
+ *  followed by a call to @ref glfwTerminate.
+ */
+extern _GLFWlibrary _glfw;
+
+
+//========================================================================
+// Platform API functions
+//========================================================================
+
+/*! @brief Initializes the platform-specific part of the library.
+ *  @return `GL_TRUE` if successful, or `GL_FALSE` if an error occurred.
+ *  @ingroup platform
+ */
+int _glfwPlatformInit(void);
+
+/*! @brief Terminates the platform-specific part of the library.
+ *  @ingroup platform
+ */
+void _glfwPlatformTerminate(void);
+
+/*! @copydoc glfwGetVersionString
+ *  @ingroup platform
+ *
+ *  @note The returned string must be available for the duration of the program.
+ *
+ *  @note The returned string must not change for the duration of the program.
+ */
+const char* _glfwPlatformGetVersionString(void);
+
+/*! @copydoc glfwSetCursorPos
+ *  @ingroup platform
+ */
+void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos);
+
+/*! @brief Sets up the specified cursor mode for the specified window.
+ *  @param[in] window The window whose cursor mode to change.
+ *  @param[in] mode The desired cursor mode.
+ *  @ingroup platform
+ */
+void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode);
+
+/*! @copydoc glfwGetMonitors
+ *  @ingroup platform
+ */
+_GLFWmonitor** _glfwPlatformGetMonitors(int* count);
+
+/*! @brief Checks whether two monitor objects represent the same monitor.
+ *
+ *  @param[in] first The first monitor.
+ *  @param[in] second The second monitor.
+ *  @return @c GL_TRUE if the monitor objects represent the same monitor, or @c
+ *  GL_FALSE otherwise.
+ *  @ingroup platform
+ */
+GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second);
+
+/*! @copydoc glfwGetMonitorPos
+ *  @ingroup platform
+ */
+void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos);
+
+/*! @copydoc glfwGetVideoModes
+ *  @ingroup platform
+ */
+GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count);
+
+/*! @ingroup platform
+ */
+void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode);
+
+/*! @copydoc glfwGetGammaRamp
+ *  @ingroup platform
+ */
+void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp);
+
+/*! @copydoc glfwSetGammaRamp
+ *  @ingroup platform
+ */
+void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp);
+
+/*! @copydoc glfwSetClipboardString
+ *  @ingroup platform
+ */
+void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string);
+
+/*! @copydoc glfwGetClipboardString
+ *  @ingroup platform
+ *
+ *  @note The returned string must be valid until the next call to @ref
+ *  _glfwPlatformGetClipboardString or @ref _glfwPlatformSetClipboardString.
+ */
+const char* _glfwPlatformGetClipboardString(_GLFWwindow* window);
+
+/*! @copydoc glfwJoystickPresent
+ *  @ingroup platform
+ */
+int _glfwPlatformJoystickPresent(int joy);
+
+/*! @copydoc glfwGetJoystickAxes
+ *  @ingroup platform
+ */
+const float* _glfwPlatformGetJoystickAxes(int joy, int* count);
+
+/*! @copydoc glfwGetJoystickButtons
+ *  @ingroup platform
+ */
+const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count);
+
+/*! @copydoc glfwGetJoystickName
+ *  @ingroup platform
+ */
+const char* _glfwPlatformGetJoystickName(int joy);
+
+/*! @copydoc glfwGetTime
+ *  @ingroup platform
+ */
+double _glfwPlatformGetTime(void);
+
+/*! @copydoc glfwSetTime
+ *  @ingroup platform
+ */
+void _glfwPlatformSetTime(double time);
+
+/*! @ingroup platform
+ */
+int _glfwPlatformCreateWindow(_GLFWwindow* window,
+                              const _GLFWwndconfig* wndconfig,
+                              const _GLFWfbconfig* fbconfig);
+
+/*! @ingroup platform
+ */
+void _glfwPlatformDestroyWindow(_GLFWwindow* window);
+
+/*! @copydoc glfwSetWindowTitle
+ *  @ingroup platform
+ */
+void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title);
+
+/*! @copydoc glfwGetWindowPos
+ *  @ingroup platform
+ */
+void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos);
+
+/*! @copydoc glfwSetWindowPos
+ *  @ingroup platform
+ */
+void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos);
+
+/*! @copydoc glfwGetWindowSize
+ *  @ingroup platform
+ */
+void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height);
+
+/*! @copydoc glfwSetWindowSize
+ *  @ingroup platform
+ */
+void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height);
+
+/*! @copydoc glfwGetFramebufferSize
+ *  @ingroup platform
+ */
+void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height);
+
+/*! @copydoc glfwIconifyWindow
+ *  @ingroup platform
+ */
+void _glfwPlatformIconifyWindow(_GLFWwindow* window);
+
+/*! @copydoc glfwRestoreWindow
+ *  @ingroup platform
+ */
+void _glfwPlatformRestoreWindow(_GLFWwindow* window);
+
+/*! @copydoc glfwShowWindow
+ *  @ingroup platform
+ */
+void _glfwPlatformShowWindow(_GLFWwindow* window);
+
+/*! @copydoc glfwHideWindow
+ *  @ingroup platform
+ */
+void _glfwPlatformHideWindow(_GLFWwindow* window);
+
+/*! @copydoc glfwPollEvents
+ *  @ingroup platform
+ */
+void _glfwPlatformPollEvents(void);
+
+/*! @copydoc glfwWaitEvents
+ *  @ingroup platform
+ */
+void _glfwPlatformWaitEvents(void);
+
+/*! @copydoc glfwMakeContextCurrent
+ *  @ingroup platform
+ */
+void _glfwPlatformMakeContextCurrent(_GLFWwindow* window);
+
+/*! @copydoc glfwGetCurrentContext
+ *  @ingroup platform
+ */
+_GLFWwindow* _glfwPlatformGetCurrentContext(void);
+
+/*! @copydoc glfwSwapBuffers
+ *  @ingroup platform
+ */
+void _glfwPlatformSwapBuffers(_GLFWwindow* window);
+
+/*! @copydoc glfwSwapInterval
+ *  @ingroup platform
+ */
+void _glfwPlatformSwapInterval(int interval);
+
+/*! @ingroup platform
+ */
+int _glfwPlatformExtensionSupported(const char* extension);
+
+/*! @copydoc glfwGetProcAddress
+ *  @ingroup platform
+ */
+GLFWglproc _glfwPlatformGetProcAddress(const char* procname);
+
+
+//========================================================================
+// Event API functions
+//========================================================================
+
+/*! @brief Notifies shared code of a window focus event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] focused `GL_TRUE` if the window received focus, or `GL_FALSE`
+ *  if it lost focus.
+ *  @ingroup event
+ */
+void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused);
+
+/*! @brief Notifies shared code of a window movement event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] xpos The new x-coordinate of the client area of the window.
+ *  @param[in] ypos The new y-coordinate of the client area of the window.
+ *  @ingroup event
+ */
+void _glfwInputWindowPos(_GLFWwindow* window, int xpos, int ypos);
+
+/*! @brief Notifies shared code of a window resize event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] width The new width of the client area of the window.
+ *  @param[in] height The new height of the client area of the window.
+ *  @ingroup event
+ */
+void _glfwInputWindowSize(_GLFWwindow* window, int width, int height);
+
+/*! @brief Notifies shared code of a framebuffer resize event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] width The new width, in pixels, of the framebuffer.
+ *  @param[in] height The new height, in pixels, of the framebuffer.
+ *  @ingroup event
+ */
+void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height);
+
+/*! @brief Notifies shared code of a window iconification event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] iconified `GL_TRUE` if the window was iconified, or `GL_FALSE`
+ *  if it was restored.
+ *  @ingroup event
+ */
+void _glfwInputWindowIconify(_GLFWwindow* window, int iconified);
+
+/*! @brief Notifies shared code of a window show/hide event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] visible `GL_TRUE` if the window was shown, or `GL_FALSE` if it
+ *  was hidden.
+ *  @ingroup event
+ */
+void _glfwInputWindowVisibility(_GLFWwindow* window, int visible);
+
+/*! @brief Notifies shared code of a window damage event.
+ *  @param[in] window The window that received the event.
+ */
+void _glfwInputWindowDamage(_GLFWwindow* window);
+
+/*! @brief Notifies shared code of a window close request event
+ *  @param[in] window The window that received the event.
+ *  @ingroup event
+ */
+void _glfwInputWindowCloseRequest(_GLFWwindow* window);
+
+/*! @brief Notifies shared code of a physical key event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] key The key that was pressed or released.
+ *  @param[in] scancode The system-specific scan code of the key.
+ *  @param[in] action @ref GLFW_PRESS or @ref GLFW_RELEASE.
+ *  @param[in] mods The modifiers pressed when the event was generated.
+ *  @ingroup event
+ */
+void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods);
+
+/*! @brief Notifies shared code of a Unicode character input event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] codepoint The Unicode code point of the input character.
+ *  @ingroup event
+ */
+void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint);
+
+/*! @brief Notifies shared code of a scroll event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] x The scroll offset along the x-axis.
+ *  @param[in] y The scroll offset along the y-axis.
+ *  @ingroup event
+ */
+void _glfwInputScroll(_GLFWwindow* window, double x, double y);
+
+/*! @brief Notifies shared code of a mouse button click event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] button The button that was pressed or released.
+ *  @param[in] action @ref GLFW_PRESS or @ref GLFW_RELEASE.
+ *  @ingroup event
+ */
+void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods);
+
+/*! @brief Notifies shared code of a cursor motion event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] x The new x-coordinate of the cursor, relative to the left edge
+ *  of the client area of the window.
+ *  @param[in] y The new y-coordinate of the cursor, relative to the top edge
+ *  of the client area of the window.
+ *  @ingroup event
+ */
+void _glfwInputCursorMotion(_GLFWwindow* window, double x, double y);
+
+/*! @brief Notifies shared code of a cursor enter/leave event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] entered `GL_TRUE` if the cursor entered the client area of the
+ *  window, or `GL_FALSE` if it left it.
+ *  @ingroup event
+ */
+void _glfwInputCursorEnter(_GLFWwindow* window, int entered);
+
+/*! @ingroup event
+ */
+void _glfwInputMonitorChange(void);
+
+/*! @brief Notifies shared code of an error.
+ *  @param[in] error The error code most suitable for the error.
+ *  @param[in] format The `printf` style format string of the error
+ *  description.
+ *  @ingroup event
+ */
+void _glfwInputError(int error, const char* format, ...);
+
+
+//========================================================================
+// Utility functions
+//========================================================================
+
+/*! @ingroup utility
+ */
+const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
+                                        const GLFWvidmode* desired);
+
+/*! @brief Performs lexical comparison between two @ref GLFWvidmode structures.
+ *  @ingroup utility
+ */
+int _glfwCompareVideoModes(const GLFWvidmode* first, const GLFWvidmode* second);
+
+/*! @brief Splits a color depth into red, green and blue bit depths.
+ *  @ingroup utility
+ */
+void _glfwSplitBPP(int bpp, int* red, int* green, int* blue);
+
+/*! @brief Searches an extension string for the specified extension.
+ *  @param[in] string The extension string to search.
+ *  @param[in] extensions The extension to search for.
+ *  @return `GL_TRUE` if the extension was found, or `GL_FALSE` otherwise.
+ *  @ingroup utility
+ */
+int _glfwStringInExtensionString(const char* string, const GLubyte* extensions);
+
+/*! @brief Chooses the framebuffer config that best matches the desired one.
+ *  @param[in] desired The desired framebuffer config.
+ *  @param[in] alternatives The framebuffer configs supported by the system.
+ *  @param[in] count The number of entries in the alternatives array.
+ *  @return The framebuffer config most closely matching the desired one, or @c
+ *  NULL if none fulfilled the hard constraints of the desired values.
+ *  @ingroup utility
+ */
+const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
+                                         const _GLFWfbconfig* alternatives,
+                                         unsigned int count);
+
+/*! @brief Retrieves the attributes of the current context.
+ *  @return `GL_TRUE` if successful, or `GL_FALSE` if the context is unusable.
+ *  @ingroup utility
+ */
+GLboolean _glfwRefreshContextAttribs(void);
+
+/*! @brief Checks whether the desired context attributes are valid.
+ *  @param[in] wndconfig The context attributes to check.
+ *  @return `GL_TRUE` if the context attributes are valid, or `GL_FALSE`
+ *  otherwise.
+ *  @ingroup utility
+ *
+ *  This function checks things like whether the specified client API version
+ *  exists and whether all relevant options have supported and non-conflicting
+ *  values.
+ */
+GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig);
+
+/*! @brief Checks whether the current context fulfils the specified hard
+ *  constraints.
+ *  @param[in] wndconfig The desired context attributes.
+ *  @return `GL_TRUE` if the context fulfils the hard constraints, or `GL_FALSE`
+ *  otherwise.
+ *  @ingroup utility
+ */
+GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig);
+
+/*! @ingroup utility
+ */
+void _glfwAllocGammaArrays(GLFWgammaramp* ramp, unsigned int size);
+
+/*! @ingroup utility
+ */
+void _glfwFreeGammaArrays(GLFWgammaramp* ramp);
+
+/*! @brief Allocates and returns a monitor object with the specified name
+ *  and dimensions.
+ *  @param[in] name The name of the monitor.
+ *  @param[in] widthMM The width, in mm, of the monitor's display area.
+ *  @param[in] heightMM The height, in mm, of the monitor's display area.
+ *  @return The newly created object.
+ *  @ingroup utility
+ */
+_GLFWmonitor* _glfwCreateMonitor(const char* name, int widthMM, int heightMM);
+
+/*! @brief Frees a monitor object and any data associated with it.
+ *  @ingroup utility
+  */
+void _glfwDestroyMonitor(_GLFWmonitor* monitor);
+
+/*! @ingroup utility
+  */
+void _glfwDestroyMonitors(_GLFWmonitor** monitors, int count);
+
+#endif // _internal_h_

libs/glfw-3.0.4/src/joystick.c

@@ -0,0 +1,90 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI int glfwJoystickPresent(int joy)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+
+    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, NULL);
+        return 0;
+    }
+
+    return _glfwPlatformJoystickPresent(joy);
+}
+
+GLFWAPI const float* glfwGetJoystickAxes(int joy, int* count)
+{
+    *count = 0;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, NULL);
+        return NULL;
+    }
+
+    return _glfwPlatformGetJoystickAxes(joy, count);
+}
+
+GLFWAPI const unsigned char* glfwGetJoystickButtons(int joy, int* count)
+{
+    *count = 0;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, NULL);
+        return NULL;
+    }
+
+    return _glfwPlatformGetJoystickButtons(joy, count);
+}
+
+GLFWAPI const char* glfwGetJoystickName(int joy)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, NULL);
+        return NULL;
+    }
+
+    return _glfwPlatformGetJoystickName(joy);
+}
+

libs/glfw-3.0.4/src/monitor.c

@@ -0,0 +1,357 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <limits.h>
+
+#if defined(_MSC_VER)
+ #include <malloc.h>
+ #define strdup _strdup
+#endif
+
+
+// Lexical comparison function for GLFW video modes, used by qsort
+//
+static int compareVideoModes(const void* firstPtr, const void* secondPtr)
+{
+    int firstBPP, secondBPP, firstSize, secondSize;
+    GLFWvidmode* first = (GLFWvidmode*) firstPtr;
+    GLFWvidmode* second = (GLFWvidmode*) secondPtr;
+
+    // First sort on color bits per pixel
+
+    firstBPP = first->redBits +
+               first->greenBits +
+               first->blueBits;
+    secondBPP = second->redBits +
+                second->greenBits +
+                second->blueBits;
+
+    if (firstBPP != secondBPP)
+        return firstBPP - secondBPP;
+
+    // Then sort on screen area, in pixels
+
+    firstSize = first->width * first->height;
+    secondSize = second->width * second->height;
+
+    if (firstSize != secondSize)
+        return firstSize - secondSize;
+
+    // Lastly sort on refresh rate
+
+    return first->refreshRate - second->refreshRate;
+}
+
+// Retrieves the available modes for the specified monitor
+//
+static int refreshVideoModes(_GLFWmonitor* monitor)
+{
+    int modeCount;
+    GLFWvidmode* modes;
+
+    if (monitor->modes)
+        return GL_TRUE;
+
+    modes = _glfwPlatformGetVideoModes(monitor, &modeCount);
+    if (!modes)
+        return GL_FALSE;
+
+    qsort(modes, modeCount, sizeof(GLFWvidmode), compareVideoModes);
+
+    free(monitor->modes);
+    monitor->modes = modes;
+    monitor->modeCount = modeCount;
+
+    return GL_TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                         GLFW event API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwInputMonitorChange(void)
+{
+    int i, j, monitorCount = _glfw.monitorCount;
+    _GLFWmonitor** monitors = _glfw.monitors;
+
+    _glfw.monitors = _glfwPlatformGetMonitors(&_glfw.monitorCount);
+
+    // Re-use still connected monitor objects
+
+    for (i = 0;  i < _glfw.monitorCount;  i++)
+    {
+        for (j = 0;  j < monitorCount;  j++)
+        {
+            if (_glfwPlatformIsSameMonitor(_glfw.monitors[i], monitors[j]))
+            {
+                _glfwDestroyMonitor(_glfw.monitors[i]);
+                _glfw.monitors[i] = monitors[j];
+                break;
+            }
+        }
+    }
+
+    // Find and report disconnected monitors (not in the new list)
+
+    for (i = 0;  i < monitorCount;  i++)
+    {
+        _GLFWwindow* window;
+
+        for (j = 0;  j < _glfw.monitorCount;  j++)
+        {
+            if (monitors[i] == _glfw.monitors[j])
+                break;
+        }
+
+        if (j < _glfw.monitorCount)
+            continue;
+
+        for (window = _glfw.windowListHead;  window;  window = window->next)
+        {
+            if (window->monitor == monitors[i])
+                window->monitor = NULL;
+        }
+
+        if (_glfw.callbacks.monitor)
+            _glfw.callbacks.monitor((GLFWmonitor*) monitors[i], GLFW_DISCONNECTED);
+    }
+
+    // Find and report newly connected monitors (not in the old list)
+    // Re-used monitor objects are then removed from the old list to avoid
+    // having them destroyed at the end of this function
+
+    for (i = 0;  i < _glfw.monitorCount;  i++)
+    {
+        for (j = 0;  j < monitorCount;  j++)
+        {
+            if (_glfw.monitors[i] == monitors[j])
+            {
+                monitors[j] = NULL;
+                break;
+            }
+        }
+
+        if (j < monitorCount)
+            continue;
+
+        if (_glfw.callbacks.monitor)
+            _glfw.callbacks.monitor((GLFWmonitor*) _glfw.monitors[i], GLFW_CONNECTED);
+    }
+
+    _glfwDestroyMonitors(monitors, monitorCount);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+_GLFWmonitor* _glfwCreateMonitor(const char* name, int widthMM, int heightMM)
+{
+    _GLFWmonitor* monitor = calloc(1, sizeof(_GLFWmonitor));
+    monitor->name = strdup(name);
+    monitor->widthMM = widthMM;
+    monitor->heightMM = heightMM;
+
+    return monitor;
+}
+
+void _glfwDestroyMonitor(_GLFWmonitor* monitor)
+{
+    if (monitor == NULL)
+        return;
+
+    _glfwFreeGammaArrays(&monitor->originalRamp);
+    _glfwFreeGammaArrays(&monitor->currentRamp);
+
+    free(monitor->modes);
+    free(monitor->name);
+    free(monitor);
+}
+
+void _glfwDestroyMonitors(_GLFWmonitor** monitors, int count)
+{
+    int i;
+
+    for (i = 0;  i < count;  i++)
+        _glfwDestroyMonitor(monitors[i]);
+
+    free(monitors);
+}
+
+const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
+                                        const GLFWvidmode* desired)
+{
+    int i;
+    unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
+    unsigned int rateDiff, leastRateDiff = UINT_MAX;
+    unsigned int colorDiff, leastColorDiff = UINT_MAX;
+    const GLFWvidmode* current;
+    const GLFWvidmode* closest = NULL;
+
+    if (!refreshVideoModes(monitor))
+        return NULL;
+
+    for (i = 0;  i < monitor->modeCount;  i++)
+    {
+        current = monitor->modes + i;
+
+        colorDiff = abs((current->redBits + current->greenBits + current->blueBits) -
+                        (desired->redBits + desired->greenBits + desired->blueBits));
+
+        sizeDiff = abs((current->width - desired->width) *
+                       (current->width - desired->width) +
+                       (current->height - desired->height) *
+                       (current->height - desired->height));
+
+        if (desired->refreshRate)
+            rateDiff = abs(current->refreshRate - desired->refreshRate);
+        else
+            rateDiff = UINT_MAX - current->refreshRate;
+
+        if ((colorDiff < leastColorDiff) ||
+            (colorDiff == leastColorDiff && sizeDiff < leastSizeDiff) ||
+            (colorDiff == leastColorDiff && sizeDiff == leastSizeDiff && rateDiff < leastRateDiff))
+        {
+            closest = current;
+            leastSizeDiff = sizeDiff;
+            leastRateDiff = rateDiff;
+            leastColorDiff = colorDiff;
+        }
+    }
+
+    return closest;
+}
+
+int _glfwCompareVideoModes(const GLFWvidmode* first, const GLFWvidmode* second)
+{
+    return compareVideoModes(first, second);
+}
+
+void _glfwSplitBPP(int bpp, int* red, int* green, int* blue)
+{
+    int delta;
+
+    // We assume that by 32 the user really meant 24
+    if (bpp == 32)
+        bpp = 24;
+
+    // Convert "bits per pixel" to red, green & blue sizes
+
+    *red = *green = *blue = bpp / 3;
+    delta = bpp - (*red * 3);
+    if (delta >= 1)
+        *green = *green + 1;
+
+    if (delta == 2)
+        *red = *red + 1;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI GLFWmonitor** glfwGetMonitors(int* count)
+{
+    *count = 0;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    *count = _glfw.monitorCount;
+    return (GLFWmonitor**) _glfw.monitors;
+}
+
+GLFWAPI GLFWmonitor* glfwGetPrimaryMonitor(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return (GLFWmonitor*) _glfw.monitors[0];
+}
+
+GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformGetMonitorPos(monitor, xpos, ypos);
+}
+
+GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* width, int* height)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (width)
+        *width = monitor->widthMM;
+    if (height)
+        *height = monitor->heightMM;
+}
+
+GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* handle)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return monitor->name;
+}
+
+GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun cbfun)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(_glfw.callbacks.monitor, cbfun);
+    return cbfun;
+}
+
+GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+
+    *count = 0;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (!refreshVideoModes(monitor))
+        return NULL;
+
+    *count = monitor->modeCount;
+    return monitor->modes;
+}
+
+GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* handle)
+{
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    _glfwPlatformGetVideoMode(monitor, &monitor->currentMode);
+    return &monitor->currentMode;
+}
+

libs/glfw-3.0.4/src/nsgl_context.m

@@ -0,0 +1,291 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <pthread.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize OpenGL support
+//
+int _glfwInitContextAPI(void)
+{
+    if (pthread_key_create(&_glfw.nsgl.current, NULL) != 0)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "NSGL: Failed to create context TLS");
+        return GL_FALSE;
+    }
+
+    _glfw.nsgl.framework =
+        CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengl"));
+    if (_glfw.nsgl.framework == NULL)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "NSGL: Failed to locate OpenGL framework");
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+// Terminate OpenGL support
+//
+void _glfwTerminateContextAPI(void)
+{
+    pthread_key_delete(_glfw.nsgl.current);
+}
+
+// Create the OpenGL context
+//
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig)
+{
+    unsigned int attributeCount = 0;
+
+    // OS X needs non-zero color size, so set resonable values
+    int colorBits = fbconfig->redBits + fbconfig->greenBits + fbconfig->blueBits;
+    if (colorBits == 0)
+        colorBits = 24;
+    else if (colorBits < 15)
+        colorBits = 15;
+
+    if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
+    {
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                        "NSGL: This API does not support OpenGL ES");
+        return GL_FALSE;
+    }
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
+    if (wndconfig->glMajor == 3 && wndconfig->glMinor < 2)
+    {
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                        "NSGL: The targeted version of OS X does not "
+                        "support OpenGL 3.0 or 3.1");
+        return GL_FALSE;
+    }
+
+    if (wndconfig->glMajor > 2)
+    {
+        if (!wndconfig->glForward)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "NSGL: 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,
+                            "NSGL: The targeted version of OS X only "
+                            "supports OpenGL 3.2 and later versions if they "
+                            "use the core profile");
+            return GL_FALSE;
+        }
+    }
+#else
+    // Fail if OpenGL 3.0 or above was requested
+    if (wndconfig->glMajor > 2)
+    {
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                        "NSGL: The targeted version of OS X does not "
+                        "support OpenGL version 3.0 or above");
+        return GL_FALSE;
+    }
+#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
+
+    // Fail if a robustness strategy was requested
+    if (wndconfig->glRobustness)
+    {
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                        "NSGL: OS X does not support OpenGL robustness "
+                        "strategies");
+        return GL_FALSE;
+    }
+
+#define ADD_ATTR(x) { attributes[attributeCount++] = x; }
+#define ADD_ATTR2(x, y) { ADD_ATTR(x); ADD_ATTR(y); }
+
+    // Arbitrary array size here
+    NSOpenGLPixelFormatAttribute attributes[40];
+
+    ADD_ATTR(NSOpenGLPFADoubleBuffer);
+    ADD_ATTR(NSOpenGLPFAClosestPolicy);
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
+    if (wndconfig->glMajor > 2)
+        ADD_ATTR2(NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core);
+#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
+
+    ADD_ATTR2(NSOpenGLPFAColorSize, colorBits);
+
+    if (fbconfig->alphaBits > 0)
+        ADD_ATTR2(NSOpenGLPFAAlphaSize, fbconfig->alphaBits);
+
+    if (fbconfig->depthBits > 0)
+        ADD_ATTR2(NSOpenGLPFADepthSize, fbconfig->depthBits);
+
+    if (fbconfig->stencilBits > 0)
+        ADD_ATTR2(NSOpenGLPFAStencilSize, fbconfig->stencilBits);
+
+    int accumBits = fbconfig->accumRedBits + fbconfig->accumGreenBits +
+                    fbconfig->accumBlueBits + fbconfig->accumAlphaBits;
+
+    if (accumBits > 0)
+        ADD_ATTR2(NSOpenGLPFAAccumSize, accumBits);
+
+    if (fbconfig->auxBuffers > 0)
+        ADD_ATTR2(NSOpenGLPFAAuxBuffers, fbconfig->auxBuffers);
+
+    if (fbconfig->stereo)
+        ADD_ATTR(NSOpenGLPFAStereo);
+
+    if (fbconfig->samples > 0)
+    {
+        ADD_ATTR2(NSOpenGLPFASampleBuffers, 1);
+        ADD_ATTR2(NSOpenGLPFASamples, fbconfig->samples);
+    }
+
+    // NOTE: All NSOpenGLPixelFormats on the relevant cards support sRGB
+    //       frambuffer, so there's no need (and no way) to request it
+
+    ADD_ATTR(0);
+
+#undef ADD_ATTR
+#undef ADD_ATTR2
+
+    window->nsgl.pixelFormat =
+        [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
+    if (window->nsgl.pixelFormat == nil)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "NSGL: Failed to create OpenGL pixel format");
+        return GL_FALSE;
+    }
+
+    NSOpenGLContext* share = NULL;
+
+    if (wndconfig->share)
+        share = wndconfig->share->nsgl.context;
+
+    window->nsgl.context =
+        [[NSOpenGLContext alloc] initWithFormat:window->nsgl.pixelFormat
+                                   shareContext:share];
+    if (window->nsgl.context == nil)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "NSGL: Failed to create OpenGL context");
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+// Destroy the OpenGL context
+//
+void _glfwDestroyContext(_GLFWwindow* window)
+{
+    [window->nsgl.pixelFormat release];
+    window->nsgl.pixelFormat = nil;
+
+    [window->nsgl.context release];
+    window->nsgl.context = nil;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+        [window->nsgl.context makeCurrentContext];
+    else
+        [NSOpenGLContext clearCurrentContext];
+
+    pthread_setspecific(_glfw.nsgl.current, window);
+}
+
+_GLFWwindow* _glfwPlatformGetCurrentContext(void)
+{
+    return (_GLFWwindow*) pthread_getspecific(_glfw.nsgl.current);
+}
+
+void _glfwPlatformSwapBuffers(_GLFWwindow* window)
+{
+    // ARP appears to be unnecessary, but this is future-proof
+    [window->nsgl.context flushBuffer];
+}
+
+void _glfwPlatformSwapInterval(int interval)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    GLint sync = interval;
+    [window->nsgl.context setValues:&sync forParameter:NSOpenGLCPSwapInterval];
+}
+
+int _glfwPlatformExtensionSupported(const char* extension)
+{
+    // There are no NSGL extensions
+    return GL_FALSE;
+}
+
+GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
+{
+    CFStringRef symbolName = CFStringCreateWithCString(kCFAllocatorDefault,
+                                                       procname,
+                                                       kCFStringEncodingASCII);
+
+    GLFWglproc symbol = CFBundleGetFunctionPointerForName(_glfw.nsgl.framework,
+                                                          symbolName);
+
+    CFRelease(symbolName);
+
+    return symbol;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI id glfwGetNSGLContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(nil);
+    return window->nsgl.context;
+}
+

libs/glfw-3.0.4/src/nsgl_platform.h

@@ -0,0 +1,64 @@
+//========================================================================
+// GLFW 3.0 OS X - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2009-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _nsgl_platform_h_
+#define _nsgl_platform_h_
+
+
+#define _GLFW_PLATFORM_FBCONFIG
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextNSGL nsgl
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryNSGL nsgl
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextNSGL
+{
+    id           pixelFormat;
+    id	         context;
+} _GLFWcontextNSGL;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for NSGL
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryNSGL
+{
+    // dlopen handle for dynamically loading OpenGL extension entry points
+    void*           framework;
+
+    // TLS key for per-thread current context/window
+    pthread_key_t   current;
+
+} _GLFWlibraryNSGL;
+
+
+#endif // _nsgl_platform_h_

libs/glfw-3.0.4/src/time.c

@@ -0,0 +1,46 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI double glfwGetTime(void)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(0.0);
+    return _glfwPlatformGetTime();
+}
+
+GLFWAPI void glfwSetTime(double time)
+{
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformSetTime(time);
+}
+

libs/glfw-3.0.4/src/wgl_context.c

@@ -0,0 +1,670 @@
+//========================================================================
+// GLFW 3.0 WGL - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdlib.h>
+#include <malloc.h>
+#include <assert.h>
+
+
+// Initialize WGL-specific extensions
+// This function is called once before initial context creation, i.e. before
+// any WGL extensions could be present.  This is done in order to have both
+// extension variable clearing and loading in the same place, hopefully
+// decreasing the possibility of forgetting to add one without the other.
+//
+static void initWGLExtensions(_GLFWwindow* window)
+{
+    // This needs to include every function pointer loaded below
+    window->wgl.SwapIntervalEXT = NULL;
+    window->wgl.GetPixelFormatAttribivARB = NULL;
+    window->wgl.GetExtensionsStringARB = NULL;
+    window->wgl.GetExtensionsStringEXT = NULL;
+    window->wgl.CreateContextAttribsARB = NULL;
+
+    // This needs to include every extension used below except for
+    // WGL_ARB_extensions_string and WGL_EXT_extensions_string
+    window->wgl.ARB_multisample = GL_FALSE;
+    window->wgl.ARB_framebuffer_sRGB = GL_FALSE;
+    window->wgl.ARB_create_context = GL_FALSE;
+    window->wgl.ARB_create_context_profile = GL_FALSE;
+    window->wgl.EXT_create_context_es2_profile = GL_FALSE;
+    window->wgl.ARB_create_context_robustness = GL_FALSE;
+    window->wgl.EXT_swap_control = GL_FALSE;
+    window->wgl.ARB_pixel_format = GL_FALSE;
+
+    window->wgl.GetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)
+        wglGetProcAddress("wglGetExtensionsStringEXT");
+    if (!window->wgl.GetExtensionsStringEXT)
+    {
+        window->wgl.GetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)
+            wglGetProcAddress("wglGetExtensionsStringARB");
+        if (!window->wgl.GetExtensionsStringARB)
+            return;
+    }
+
+    if (_glfwPlatformExtensionSupported("WGL_ARB_multisample"))
+        window->wgl.ARB_multisample = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("WGL_ARB_framebuffer_sRGB"))
+        window->wgl.ARB_framebuffer_sRGB = GL_TRUE;
+
+    if (_glfwPlatformExtensionSupported("WGL_ARB_create_context"))
+    {
+        window->wgl.CreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)
+            wglGetProcAddress("wglCreateContextAttribsARB");
+
+        if (window->wgl.CreateContextAttribsARB)
+            window->wgl.ARB_create_context = GL_TRUE;
+    }
+
+    if (window->wgl.ARB_create_context)
+    {
+        if (_glfwPlatformExtensionSupported("WGL_ARB_create_context_profile"))
+            window->wgl.ARB_create_context_profile = GL_TRUE;
+    }
+
+    if (window->wgl.ARB_create_context &&
+        window->wgl.ARB_create_context_profile)
+    {
+        if (_glfwPlatformExtensionSupported("WGL_EXT_create_context_es2_profile"))
+            window->wgl.EXT_create_context_es2_profile = GL_TRUE;
+    }
+
+    if (window->wgl.ARB_create_context)
+    {
+        if (_glfwPlatformExtensionSupported("WGL_ARB_create_context_robustness"))
+            window->wgl.ARB_create_context_robustness = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("WGL_EXT_swap_control"))
+    {
+        window->wgl.SwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)
+            wglGetProcAddress("wglSwapIntervalEXT");
+
+        if (window->wgl.SwapIntervalEXT)
+            window->wgl.EXT_swap_control = GL_TRUE;
+    }
+
+    if (_glfwPlatformExtensionSupported("WGL_ARB_pixel_format"))
+    {
+        window->wgl.GetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)
+            wglGetProcAddress("wglGetPixelFormatAttribivARB");
+
+        if (window->wgl.GetPixelFormatAttribivARB)
+            window->wgl.ARB_pixel_format = GL_TRUE;
+    }
+}
+
+// Returns the specified attribute of the specified pixel format
+// NOTE: Do not call this unless we have found WGL_ARB_pixel_format
+//
+static int getPixelFormatAttrib(_GLFWwindow* window, int pixelFormat, int attrib)
+{
+    int value = 0;
+
+    if (!window->wgl.GetPixelFormatAttribivARB(window->wgl.dc,
+                                               pixelFormat,
+                                               0, 1, &attrib, &value))
+    {
+        // NOTE: We should probably handle this error somehow
+        return 0;
+    }
+
+    return value;
+}
+
+// Return a list of available and usable framebuffer configs
+//
+static GLboolean choosePixelFormat(_GLFWwindow* window,
+                                   const _GLFWfbconfig* desired,
+                                   int* result)
+{
+    _GLFWfbconfig* usableConfigs;
+    const _GLFWfbconfig* closest;
+    int i, nativeCount, usableCount;
+
+    if (window->wgl.ARB_pixel_format)
+    {
+        nativeCount = getPixelFormatAttrib(window,
+                                         1,
+                                         WGL_NUMBER_PIXEL_FORMATS_ARB);
+    }
+    else
+    {
+        nativeCount = DescribePixelFormat(window->wgl.dc,
+                                          1,
+                                          sizeof(PIXELFORMATDESCRIPTOR),
+                                          NULL);
+    }
+
+    if (!nativeCount)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "WGL: No pixel formats found");
+        return GL_FALSE;
+    }
+
+    usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
+    usableCount = 0;
+
+    for (i = 0;  i < nativeCount;  i++)
+    {
+        const int n = i + 1;
+        _GLFWfbconfig* u = usableConfigs + usableCount;
+
+        if (window->wgl.ARB_pixel_format)
+        {
+            // Get pixel format attributes through WGL_ARB_pixel_format
+            if (!getPixelFormatAttrib(window, n, WGL_SUPPORT_OPENGL_ARB) ||
+                !getPixelFormatAttrib(window, n, WGL_DRAW_TO_WINDOW_ARB) ||
+                !getPixelFormatAttrib(window, n, WGL_DOUBLE_BUFFER_ARB))
+            {
+                continue;
+            }
+
+            if (getPixelFormatAttrib(window, n, WGL_PIXEL_TYPE_ARB) !=
+                WGL_TYPE_RGBA_ARB)
+            {
+                continue;
+            }
+
+            if (getPixelFormatAttrib(window, n, WGL_ACCELERATION_ARB) ==
+                 WGL_NO_ACCELERATION_ARB)
+            {
+                continue;
+            }
+
+            u->redBits = getPixelFormatAttrib(window, n, WGL_RED_BITS_ARB);
+            u->greenBits = getPixelFormatAttrib(window, n, WGL_GREEN_BITS_ARB);
+            u->blueBits = getPixelFormatAttrib(window, n, WGL_BLUE_BITS_ARB);
+            u->alphaBits = getPixelFormatAttrib(window, n, WGL_ALPHA_BITS_ARB);
+
+            u->depthBits = getPixelFormatAttrib(window, n, WGL_DEPTH_BITS_ARB);
+            u->stencilBits = getPixelFormatAttrib(window, n, WGL_STENCIL_BITS_ARB);
+
+            u->accumRedBits = getPixelFormatAttrib(window, n, WGL_ACCUM_RED_BITS_ARB);
+            u->accumGreenBits = getPixelFormatAttrib(window, n, WGL_ACCUM_GREEN_BITS_ARB);
+            u->accumBlueBits = getPixelFormatAttrib(window, n, WGL_ACCUM_BLUE_BITS_ARB);
+            u->accumAlphaBits = getPixelFormatAttrib(window, n, WGL_ACCUM_ALPHA_BITS_ARB);
+
+            u->auxBuffers = getPixelFormatAttrib(window, n, WGL_AUX_BUFFERS_ARB);
+            u->stereo = getPixelFormatAttrib(window, n, WGL_STEREO_ARB);
+
+            if (window->wgl.ARB_multisample)
+                u->samples = getPixelFormatAttrib(window, n, WGL_SAMPLES_ARB);
+
+            if (window->wgl.ARB_framebuffer_sRGB)
+                u->sRGB = getPixelFormatAttrib(window, n, WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB);
+        }
+        else
+        {
+            PIXELFORMATDESCRIPTOR pfd;
+
+            // Get pixel format attributes through old-fashioned PFDs
+
+            if (!DescribePixelFormat(window->wgl.dc,
+                                     n,
+                                     sizeof(PIXELFORMATDESCRIPTOR),
+                                     &pfd))
+            {
+                continue;
+            }
+
+            if (!(pfd.dwFlags & PFD_DRAW_TO_WINDOW) ||
+                !(pfd.dwFlags & PFD_SUPPORT_OPENGL) ||
+                !(pfd.dwFlags & PFD_DOUBLEBUFFER))
+            {
+                continue;
+            }
+
+            if (!(pfd.dwFlags & PFD_GENERIC_ACCELERATED) &&
+                (pfd.dwFlags & PFD_GENERIC_FORMAT))
+            {
+                continue;
+            }
+
+            if (pfd.iPixelType != PFD_TYPE_RGBA)
+                continue;
+
+            u->redBits = pfd.cRedBits;
+            u->greenBits = pfd.cGreenBits;
+            u->blueBits = pfd.cBlueBits;
+            u->alphaBits = pfd.cAlphaBits;
+
+            u->depthBits = pfd.cDepthBits;
+            u->stencilBits = pfd.cStencilBits;
+
+            u->accumRedBits = pfd.cAccumRedBits;
+            u->accumGreenBits = pfd.cAccumGreenBits;
+            u->accumBlueBits = pfd.cAccumBlueBits;
+            u->accumAlphaBits = pfd.cAccumAlphaBits;
+
+            u->auxBuffers = pfd.cAuxBuffers;
+            u->stereo = (pfd.dwFlags & PFD_STEREO) ? GL_TRUE : GL_FALSE;
+        }
+
+        u->wgl = n;
+        usableCount++;
+    }
+
+    if (!usableCount)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "WGL: The driver does not appear to support OpenGL");
+
+        free(usableConfigs);
+        return GL_FALSE;
+    }
+
+    closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
+    if (!closest)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "WGL: Failed to find a suitable pixel format");
+
+        free(usableConfigs);
+        return GL_FALSE;
+    }
+
+    *result = closest->wgl;
+    free(usableConfigs);
+
+    return GL_TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize WGL
+//
+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)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "WGL: Failed to allocate TLS index");
+        return GL_FALSE;
+    }
+
+    _glfw.wgl.hasTLS = GL_TRUE;
+
+    return GL_TRUE;
+}
+
+// Terminate WGL
+//
+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((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
+}
+
+// Prepare for creation of the OpenGL context
+//
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig)
+{
+    int attribs[40];
+    int pixelFormat = 0;
+    PIXELFORMATDESCRIPTOR pfd;
+    HGLRC share = NULL;
+
+    if (wndconfig->share)
+        share = wndconfig->share->wgl.context;
+
+    window->wgl.dc = GetDC(window->win32.handle);
+    if (!window->wgl.dc)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to retrieve DC for window");
+        return GL_FALSE;
+    }
+
+    if (!choosePixelFormat(window, fbconfig, &pixelFormat))
+        return GL_FALSE;
+
+    if (!DescribePixelFormat(window->wgl.dc, pixelFormat, sizeof(pfd), &pfd))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to retrieve PFD for selected pixel "
+                        "format");
+        return GL_FALSE;
+    }
+
+    if (!SetPixelFormat(window->wgl.dc, pixelFormat, &pfd))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to set selected pixel format");
+        return GL_FALSE;
+    }
+
+    if (window->wgl.ARB_create_context)
+    {
+        int index = 0, mask = 0, flags = 0, strategy = 0;
+
+        if (wndconfig->clientAPI == GLFW_OPENGL_API)
+        {
+            if (wndconfig->glForward)
+                flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
+
+            if (wndconfig->glDebug)
+                flags |= WGL_CONTEXT_DEBUG_BIT_ARB;
+
+            if (wndconfig->glProfile)
+            {
+                if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
+                    mask |= WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
+                else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
+                    mask |= WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
+            }
+        }
+        else
+            mask |= WGL_CONTEXT_ES2_PROFILE_BIT_EXT;
+
+        if (wndconfig->glRobustness)
+        {
+            if (window->wgl.ARB_create_context_robustness)
+            {
+                if (wndconfig->glRobustness == GLFW_NO_RESET_NOTIFICATION)
+                    strategy = WGL_NO_RESET_NOTIFICATION_ARB;
+                else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET)
+                    strategy = WGL_LOSE_CONTEXT_ON_RESET_ARB;
+
+                flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB;
+            }
+        }
+
+        if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
+        {
+            setWGLattrib(WGL_CONTEXT_MAJOR_VERSION_ARB, wndconfig->glMajor);
+            setWGLattrib(WGL_CONTEXT_MINOR_VERSION_ARB, wndconfig->glMinor);
+        }
+
+        if (flags)
+            setWGLattrib(WGL_CONTEXT_FLAGS_ARB, flags);
+
+        if (mask)
+            setWGLattrib(WGL_CONTEXT_PROFILE_MASK_ARB, mask);
+
+        if (strategy)
+            setWGLattrib(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, strategy);
+
+        setWGLattrib(0, 0);
+
+        window->wgl.context = window->wgl.CreateContextAttribsARB(window->wgl.dc,
+                                                                  share,
+                                                                  attribs);
+        if (!window->wgl.context)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "WGL: Failed to create OpenGL context");
+            return GL_FALSE;
+        }
+    }
+    else
+    {
+        window->wgl.context = wglCreateContext(window->wgl.dc);
+        if (!window->wgl.context)
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "WGL: Failed to create OpenGL context");
+            return GL_FALSE;
+        }
+
+        if (share)
+        {
+            if (!wglShareLists(share, window->wgl.context))
+            {
+                _glfwInputError(GLFW_PLATFORM_ERROR,
+                                "WGL: Failed to enable sharing with specified "
+                                "OpenGL context");
+                return GL_FALSE;
+            }
+        }
+    }
+
+    _glfwPlatformMakeContextCurrent(window);
+    initWGLExtensions(window);
+
+    return GL_TRUE;
+}
+
+#undef setWGLattrib
+
+// Destroy the OpenGL context
+//
+void _glfwDestroyContext(_GLFWwindow* window)
+{
+    if (window->wgl.context)
+    {
+        wglDeleteContext(window->wgl.context);
+        window->wgl.context = NULL;
+    }
+
+    if (window->wgl.dc)
+    {
+        ReleaseDC(window->win32.handle, window->wgl.dc);
+        window->wgl.dc = NULL;
+    }
+}
+
+// Analyzes the specified context for possible recreation
+//
+int _glfwAnalyzeContext(const _GLFWwindow* window,
+                        const _GLFWwndconfig* wndconfig,
+                        const _GLFWfbconfig* fbconfig)
+{
+    GLboolean required = GL_FALSE;
+
+    if (wndconfig->clientAPI == GLFW_OPENGL_API)
+    {
+        if (wndconfig->glForward)
+        {
+            if (!window->wgl.ARB_create_context)
+            {
+                _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                                "WGL: A forward compatible OpenGL context "
+                                "requested but WGL_ARB_create_context is "
+                                "unavailable");
+                return _GLFW_RECREATION_IMPOSSIBLE;
+            }
+
+            required = GL_TRUE;
+        }
+
+        if (wndconfig->glProfile)
+        {
+            if (!window->wgl.ARB_create_context_profile)
+            {
+                _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                                "WGL: OpenGL profile requested but "
+                                "WGL_ARB_create_context_profile is unavailable");
+                return _GLFW_RECREATION_IMPOSSIBLE;
+            }
+
+            required = GL_TRUE;
+        }
+    }
+    else
+    {
+        if (!window->wgl.ARB_create_context ||
+            !window->wgl.ARB_create_context_profile ||
+            !window->wgl.EXT_create_context_es2_profile)
+        {
+            _glfwInputError(GLFW_API_UNAVAILABLE,
+                            "WGL: OpenGL ES requested but "
+                            "WGL_ARB_create_context_es2_profile is unavailable");
+            return _GLFW_RECREATION_IMPOSSIBLE;
+        }
+
+        required = GL_TRUE;
+    }
+
+    if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
+    {
+        if (window->wgl.ARB_create_context)
+            required = GL_TRUE;
+    }
+
+    if (wndconfig->glDebug)
+    {
+        if (window->wgl.ARB_create_context)
+            required = GL_TRUE;
+    }
+
+    if (fbconfig->samples > 0)
+    {
+        // We want FSAA, but can we get it?
+        // FSAA is not a hard constraint, so otherwise we just don't care
+
+        if (window->wgl.ARB_multisample && window->wgl.ARB_pixel_format)
+        {
+            // We appear to have both the extension and the means to ask for it
+            required = GL_TRUE;
+        }
+    }
+
+    if (required)
+        return _GLFW_RECREATION_REQUIRED;
+
+    return _GLFW_RECREATION_NOT_NEEDED;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
+{
+    if (window)
+        wglMakeCurrent(window->wgl.dc, window->wgl.context);
+    else
+        wglMakeCurrent(NULL, NULL);
+
+    TlsSetValue(_glfw.wgl.current, window);
+}
+
+_GLFWwindow* _glfwPlatformGetCurrentContext(void)
+{
+    return TlsGetValue(_glfw.wgl.current);
+}
+
+void _glfwPlatformSwapBuffers(_GLFWwindow* window)
+{
+    SwapBuffers(window->wgl.dc);
+}
+
+void _glfwPlatformSwapInterval(int interval)
+{
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+#if !defined(_GLFW_USE_DWM_SWAP_INTERVAL)
+    if (_glfwIsCompositionEnabled() && interval)
+    {
+        // 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);
+}
+
+int _glfwPlatformExtensionSupported(const char* extension)
+{
+    const GLubyte* extensions;
+
+    _GLFWwindow* window = _glfwPlatformGetCurrentContext();
+
+    if (window->wgl.GetExtensionsStringEXT != NULL)
+    {
+        extensions = (GLubyte*) window->wgl.GetExtensionsStringEXT();
+        if (extensions != NULL)
+        {
+            if (_glfwStringInExtensionString(extension, extensions))
+                return GL_TRUE;
+        }
+    }
+
+    if (window->wgl.GetExtensionsStringARB != NULL)
+    {
+        extensions = (GLubyte*) window->wgl.GetExtensionsStringARB(window->wgl.dc);
+        if (extensions != NULL)
+        {
+            if (_glfwStringInExtensionString(extension, extensions))
+                return GL_TRUE;
+        }
+    }
+
+    return GL_FALSE;
+}
+
+GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
+{
+    const GLFWglproc proc = (GLFWglproc) wglGetProcAddress(procname);
+    if (proc)
+        return proc;
+
+    return (GLFWglproc) GetProcAddress(_glfw.wgl.opengl32.instance, procname);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return window->wgl.context;
+}
+

libs/glfw-3.0.4/src/wgl_platform.h

@@ -0,0 +1,88 @@
+//========================================================================
+// GLFW 3.0 WGL - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _wgl_platform_h_
+#define _wgl_platform_h_
+
+// This path may need to be changed if you build GLFW using your own setup
+// We ship and use our own copy of wglext.h since GLFW uses fairly new
+// extensions and not all operating systems come with an up-to-date version
+#include "../deps/GL/wglext.h"
+
+
+#define _GLFW_PLATFORM_FBCONFIG             int             wgl
+#define _GLFW_PLATFORM_CONTEXT_STATE        _GLFWcontextWGL wgl
+#define _GLFW_PLATFORM_LIBRARY_OPENGL_STATE _GLFWlibraryWGL wgl
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+//------------------------------------------------------------------------
+// Platform-specific OpenGL context structure
+//------------------------------------------------------------------------
+typedef struct _GLFWcontextWGL
+{
+    // Platform specific window resources
+    HDC       dc;              // Private GDI device context
+    HGLRC     context;         // Permanent rendering context
+
+    // Platform specific extensions (context specific)
+    PFNWGLSWAPINTERVALEXTPROC           SwapIntervalEXT;
+    PFNWGLGETPIXELFORMATATTRIBIVARBPROC GetPixelFormatAttribivARB;
+    PFNWGLGETEXTENSIONSSTRINGEXTPROC    GetExtensionsStringEXT;
+    PFNWGLGETEXTENSIONSSTRINGARBPROC    GetExtensionsStringARB;
+    PFNWGLCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
+    GLboolean                           EXT_swap_control;
+    GLboolean                           ARB_multisample;
+    GLboolean                           ARB_framebuffer_sRGB;
+    GLboolean                           ARB_pixel_format;
+    GLboolean                           ARB_create_context;
+    GLboolean                           ARB_create_context_profile;
+    GLboolean                           EXT_create_context_es2_profile;
+    GLboolean                           ARB_create_context_robustness;
+} _GLFWcontextWGL;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for WGL
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryWGL
+{
+    GLboolean       hasTLS;
+    DWORD           current;
+
+    // opengl32.dll
+    struct {
+        HINSTANCE   instance;
+    } opengl32;
+
+} _GLFWlibraryWGL;
+
+
+#endif // _wgl_platform_h_

libs/glfw-3.0.4/src/win32_clipboard.c

@@ -0,0 +1,127 @@
+//========================================================================
+// GLFW 3.0 Win32 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+#include <string.h>
+#include <stdlib.h>
+#include <malloc.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
+{
+    WCHAR* wideString;
+    HANDLE stringHandle;
+    size_t wideSize;
+
+    wideString = _glfwCreateWideStringFromUTF8(string);
+    if (!wideString)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to convert clipboard string to "
+                        "wide string");
+        return;
+    }
+
+    wideSize = (wcslen(wideString) + 1) * sizeof(WCHAR);
+
+    stringHandle = GlobalAlloc(GMEM_MOVEABLE, wideSize);
+    if (!stringHandle)
+    {
+        free(wideString);
+
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to allocate global handle for clipboard");
+        return;
+    }
+
+    memcpy(GlobalLock(stringHandle), wideString, wideSize);
+    GlobalUnlock(stringHandle);
+
+    if (!OpenClipboard(window->win32.handle))
+    {
+        GlobalFree(stringHandle);
+        free(wideString);
+
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to open clipboard");
+        return;
+    }
+
+    EmptyClipboard();
+    SetClipboardData(CF_UNICODETEXT, stringHandle);
+    CloseClipboard();
+
+    free(wideString);
+}
+
+const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
+{
+    HANDLE stringHandle;
+
+    if (!IsClipboardFormatAvailable(CF_UNICODETEXT))
+    {
+        _glfwInputError(GLFW_FORMAT_UNAVAILABLE, NULL);
+        return NULL;
+    }
+
+    if (!OpenClipboard(window->win32.handle))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to open clipboard");
+        return NULL;
+    }
+
+    stringHandle = GetClipboardData(CF_UNICODETEXT);
+    if (!stringHandle)
+    {
+        CloseClipboard();
+
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to retrieve clipboard data");
+        return NULL;
+    }
+
+    free(_glfw.win32.clipboardString);
+    _glfw.win32.clipboardString =
+        _glfwCreateUTF8FromWideString(GlobalLock(stringHandle));
+
+    GlobalUnlock(stringHandle);
+    CloseClipboard();
+
+    if (!_glfw.win32.clipboardString)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Failed to convert wide string to UTF-8");
+        return NULL;
+    }
+
+    return _glfw.win32.clipboardString;
+}
+

libs/glfw-3.0.4/src/win32_gamma.c

@@ -0,0 +1,82 @@
+//========================================================================
+// GLFW 3.0 Win32 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+{
+    HDC dc;
+    WORD values[768];
+    DISPLAY_DEVICE display;
+
+    ZeroMemory(&display, sizeof(DISPLAY_DEVICE));
+    display.cb = sizeof(DISPLAY_DEVICE);
+    EnumDisplayDevices(monitor->win32.name, 0, &display, 0);
+
+    dc = CreateDC(L"DISPLAY", display.DeviceString, NULL, NULL);
+    GetDeviceGammaRamp(dc, values);
+    DeleteDC(dc);
+
+    _glfwAllocGammaArrays(ramp, 256);
+
+    memcpy(ramp->red,   values +   0, 256 * sizeof(unsigned short));
+    memcpy(ramp->green, values + 256, 256 * sizeof(unsigned short));
+    memcpy(ramp->blue,  values + 512, 256 * sizeof(unsigned short));
+}
+
+void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
+{
+    HDC dc;
+    WORD values[768];
+    DISPLAY_DEVICE display;
+
+    if (ramp->size != 256)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Win32: Gamma ramp size must be 256");
+        return;
+    }
+
+    memcpy(values +   0, ramp->red,   256 * sizeof(unsigned short));
+    memcpy(values + 256, ramp->green, 256 * sizeof(unsigned short));
+    memcpy(values + 512, ramp->blue,  256 * sizeof(unsigned short));
+
+    ZeroMemory(&display, sizeof(DISPLAY_DEVICE));
+    display.cb = sizeof(DISPLAY_DEVICE);
+    EnumDisplayDevices(monitor->win32.name, 0, &display, 0);
+
+    dc = CreateDC(L"DISPLAY", display.DeviceString, NULL, NULL);
+    SetDeviceGammaRamp(dc, values);
+    DeleteDC(dc);
+}
+

libs/glfw-3.0.4/src/win32_init.c

@@ -0,0 +1,269 @@
+//========================================================================
+// GLFW 3.0 Win32 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdlib.h>
+#include <malloc.h>
+
+#ifdef __BORLANDC__
+// With the Borland C++ compiler, we want to disable FPU exceptions
+#include <float.h>
+#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
+//
+BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
+{
+    return TRUE;
+}
+
+#endif // _GLFW_BUILD_DLL
+
+// Load necessary libraries (DLLs)
+//
+static GLboolean initLibraries(void)
+{
+#ifndef _GLFW_NO_DLOAD_WINMM
+    // winmm.dll (for joystick and timer support)
+
+    _glfw.win32.winmm.instance = LoadLibrary(L"winmm.dll");
+    if (!_glfw.win32.winmm.instance)
+        return GL_FALSE;
+
+    _glfw.win32.winmm.joyGetDevCaps = (JOYGETDEVCAPS_T)
+        GetProcAddress(_glfw.win32.winmm.instance, "joyGetDevCapsW");
+    _glfw.win32.winmm.joyGetPos = (JOYGETPOS_T)
+        GetProcAddress(_glfw.win32.winmm.instance, "joyGetPos");
+    _glfw.win32.winmm.joyGetPosEx = (JOYGETPOSEX_T)
+        GetProcAddress(_glfw.win32.winmm.instance, "joyGetPosEx");
+    _glfw.win32.winmm.timeGetTime = (TIMEGETTIME_T)
+        GetProcAddress(_glfw.win32.winmm.instance, "timeGetTime");
+
+    if (!_glfw.win32.winmm.joyGetDevCaps ||
+        !_glfw.win32.winmm.joyGetPos ||
+        !_glfw.win32.winmm.joyGetPosEx ||
+        !_glfw.win32.winmm.timeGetTime)
+    {
+        return GL_FALSE;
+    }
+#endif // _GLFW_NO_DLOAD_WINMM
+
+    _glfw.win32.user32.instance = LoadLibrary(L"user32.dll");
+    if (_glfw.win32.user32.instance)
+    {
+        _glfw.win32.user32.SetProcessDPIAware = (SETPROCESSDPIAWARE_T)
+            GetProcAddress(_glfw.win32.user32.instance, "SetProcessDPIAware");
+    }
+
+    _glfw.win32.dwmapi.instance = LoadLibrary(L"dwmapi.dll");
+    if (_glfw.win32.dwmapi.instance)
+    {
+        _glfw.win32.dwmapi.DwmIsCompositionEnabled = (DWMISCOMPOSITIONENABLED_T)
+            GetProcAddress(_glfw.win32.dwmapi.instance, "DwmIsCompositionEnabled");
+    }
+
+    return GL_TRUE;
+}
+
+// Unload used libraries (DLLs)
+//
+static void terminateLibraries(void)
+{
+#ifndef _GLFW_NO_DLOAD_WINMM
+    if (_glfw.win32.winmm.instance != NULL)
+    {
+        FreeLibrary(_glfw.win32.winmm.instance);
+        _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);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Returns whether desktop compositing is enabled
+//
+BOOL _glfwIsCompositionEnabled(void)
+{
+    BOOL enabled;
+
+    if (!_glfw_DwmIsCompositionEnabled)
+        return FALSE;
+
+    if (_glfw_DwmIsCompositionEnabled(&enabled) != S_OK)
+        return FALSE;
+
+    return enabled;
+}
+
+// Returns a wide string version of the specified UTF-8 string
+//
+WCHAR* _glfwCreateWideStringFromUTF8(const char* source)
+{
+    WCHAR* target;
+    int length;
+
+    length = MultiByteToWideChar(CP_UTF8, 0, source, -1, NULL, 0);
+    if (!length)
+        return NULL;
+
+    target = calloc(length + 1, sizeof(WCHAR));
+
+    if (!MultiByteToWideChar(CP_UTF8, 0, source, -1, target, length + 1))
+    {
+        free(target);
+        return NULL;
+    }
+
+    return target;
+}
+
+// Returns a UTF-8 string version of the specified wide string
+//
+char* _glfwCreateUTF8FromWideString(const WCHAR* source)
+{
+    char* target;
+    int length;
+
+    length = WideCharToMultiByte(CP_UTF8, 0, source, -1, NULL, 0, NULL, NULL);
+    if (!length)
+        return NULL;
+
+    target = calloc(length + 1, sizeof(char));
+
+    if (!WideCharToMultiByte(CP_UTF8, 0, source, -1, target, length + 1, NULL, NULL))
+    {
+        free(target);
+        return NULL;
+    }
+
+    return target;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformInit(void)
+{
+    // To make SetForegroundWindow work as we want, we need to fiddle
+    // with the FOREGROUNDLOCKTIMEOUT system setting (we do this as early
+    // as possible in the hope of still being the foreground process)
+    SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT, 0,
+                         &_glfw.win32.foregroundLockTimeout, 0);
+    SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, UIntToPtr(0),
+                         SPIF_SENDCHANGE);
+
+    if (!initLibraries())
+        return GL_FALSE;
+
+    if (_glfw_SetProcessDPIAware)
+        _glfw_SetProcessDPIAware();
+
+#ifdef __BORLANDC__
+    // With the Borland C++ compiler, we want to disable FPU exceptions
+    // (this is recommended for OpenGL applications under Windows)
+    _control87(MCW_EM, MCW_EM);
+#endif
+
+    if (!_glfwInitContextAPI())
+        return GL_FALSE;
+
+    _glfwInitTimer();
+    _glfwInitJoysticks();
+
+    return GL_TRUE;
+}
+
+void _glfwPlatformTerminate(void)
+{
+    if (_glfw.win32.classAtom)
+    {
+        UnregisterClass(_GLFW_WNDCLASSNAME, GetModuleHandle(NULL));
+        _glfw.win32.classAtom = 0;
+    }
+
+    // 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)
+{
+    const char* version = _GLFW_VERSION_NUMBER " Win32"
+#if defined(_GLFW_WGL)
+        " WGL"
+#elif defined(_GLFW_EGL)
+        " EGL"
+#endif
+#if defined(__MINGW32__)
+        " MinGW"
+#elif defined(_MSC_VER)
+        " VisualC"
+#elif defined(__BORLANDC__)
+        " BorlandC"
+#endif
+#if !defined(_GLFW_NO_DLOAD_WINMM)
+        " LoadLibrary(winmm)"
+#endif
+#if defined(_GLFW_BUILD_DLL)
+        " DLL"
+#endif
+        ;
+
+    return version;
+}
+

libs/glfw-3.0.4/src/win32_joystick.c

@@ -0,0 +1,177 @@
+//========================================================================
+// GLFW 3.0 Win32 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdlib.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Calculate normalized joystick position
+//
+static float calcJoystickPos(DWORD pos, DWORD min, DWORD max)
+{
+    float fpos = (float) pos;
+    float fmin = (float) min;
+    float fmax = (float) max;
+
+    return (2.f * (fpos - fmin) / (fmax - fmin)) - 1.f;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize joystick interface
+//
+void _glfwInitJoysticks(void)
+{
+}
+
+// Close all opened joystick handles
+//
+void _glfwTerminateJoysticks(void)
+{
+    int i;
+
+    for (i = 0;  i < GLFW_JOYSTICK_LAST;  i++)
+        free(_glfw.win32.joystick[i].name);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformJoystickPresent(int joy)
+{
+    JOYINFO ji;
+
+    if (_glfw_joyGetPos(joy, &ji) != JOYERR_NOERROR)
+        return GL_FALSE;
+
+    return GL_TRUE;
+}
+
+const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+{
+    JOYCAPS jc;
+    JOYINFOEX ji;
+    float* axes = _glfw.win32.joystick[joy].axes;
+
+    if (_glfw_joyGetDevCaps(joy, &jc, sizeof(JOYCAPS)) != JOYERR_NOERROR)
+        return NULL;
+
+    ji.dwSize = sizeof(JOYINFOEX);
+    ji.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ |
+                 JOY_RETURNR | JOY_RETURNU | JOY_RETURNV;
+    if (_glfw_joyGetPosEx(joy, &ji) != JOYERR_NOERROR)
+        return NULL;
+
+    axes[(*count)++] = calcJoystickPos(ji.dwXpos, jc.wXmin, jc.wXmax);
+    axes[(*count)++] = calcJoystickPos(ji.dwYpos, jc.wYmin, jc.wYmax);
+
+    if (jc.wCaps & JOYCAPS_HASZ)
+        axes[(*count)++] = calcJoystickPos(ji.dwZpos, jc.wZmin, jc.wZmax);
+
+    if (jc.wCaps & JOYCAPS_HASR)
+        axes[(*count)++] = calcJoystickPos(ji.dwRpos, jc.wRmin, jc.wRmax);
+
+    if (jc.wCaps & JOYCAPS_HASU)
+        axes[(*count)++] = calcJoystickPos(ji.dwUpos, jc.wUmin, jc.wUmax);
+
+    if (jc.wCaps & JOYCAPS_HASV)
+        axes[(*count)++] = calcJoystickPos(ji.dwVpos, jc.wVmin, jc.wVmax);
+
+    return axes;
+}
+
+const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
+{
+    JOYCAPS jc;
+    JOYINFOEX ji;
+    unsigned char* buttons = _glfw.win32.joystick[joy].buttons;
+
+    if (_glfw_joyGetDevCaps(joy, &jc, sizeof(JOYCAPS)) != JOYERR_NOERROR)
+        return NULL;
+
+    ji.dwSize = sizeof(JOYINFOEX);
+    ji.dwFlags = JOY_RETURNBUTTONS | JOY_RETURNPOV;
+    if (_glfw_joyGetPosEx(joy, &ji) != JOYERR_NOERROR)
+        return NULL;
+
+    while (*count < (int) jc.wNumButtons)
+    {
+        buttons[*count] = (unsigned char)
+            (ji.dwButtons & (1UL << *count) ? GLFW_PRESS : GLFW_RELEASE);
+        (*count)++;
+    }
+
+    // Virtual buttons - Inject data from hats
+    // Each hat is exposed as 4 buttons which exposes 8 directions with
+    // concurrent button presses
+    // NOTE: this API exposes only one hat
+
+    if ((jc.wCaps & JOYCAPS_HASPOV) && (jc.wCaps & JOYCAPS_POV4DIR))
+    {
+        int i, value = ji.dwPOV / 100 / 45;
+
+        // Bit fields of button presses for each direction, including nil
+        const int directions[9] = { 1, 3, 2, 6, 4, 12, 8, 9, 0 };
+
+        if (value < 0 || value > 8)
+            value = 8;
+
+        for (i = 0;  i < 4;  i++)
+        {
+            if (directions[value] & (1 << i))
+                buttons[(*count)++] = GLFW_PRESS;
+            else
+                buttons[(*count)++] = GLFW_RELEASE;
+        }
+    }
+
+    return buttons;
+}
+
+const char* _glfwPlatformGetJoystickName(int joy)
+{
+    JOYCAPS jc;
+
+    if (_glfw_joyGetDevCaps(joy, &jc, sizeof(JOYCAPS)) != JOYERR_NOERROR)
+        return NULL;
+
+    free(_glfw.win32.joystick[joy].name);
+    _glfw.win32.joystick[joy].name = _glfwCreateUTF8FromWideString(jc.szPname);
+
+    return _glfw.win32.joystick[joy].name;
+}
+

libs/glfw-3.0.4/src/win32_monitor.c

@@ -0,0 +1,284 @@
+//========================================================================
+// GLFW 3.0 Win32 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <malloc.h>
+
+// These constants are missing on MinGW
+#ifndef EDS_ROTATEDMODE
+ #define EDS_ROTATEDMODE 0x00000004
+#endif
+#ifndef DISPLAY_DEVICE_ACTIVE
+ #define DISPLAY_DEVICE_ACTIVE 0x00000001
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Change the current video mode
+//
+GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
+{
+    GLFWvidmode current;
+    const GLFWvidmode* best;
+    DEVMODE dm;
+
+    best = _glfwChooseVideoMode(monitor, desired);
+
+    _glfwPlatformGetVideoMode(monitor, &current);
+    if (_glfwCompareVideoModes(&current, best) == 0)
+        return GL_TRUE;
+
+    ZeroMemory(&dm, sizeof(dm));
+    dm.dmSize = sizeof(DEVMODE);
+    dm.dmFields           = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL |
+                            DM_DISPLAYFREQUENCY;
+    dm.dmPelsWidth        = best->width;
+    dm.dmPelsHeight       = best->height;
+    dm.dmBitsPerPel       = best->redBits + best->greenBits + best->blueBits;
+    dm.dmDisplayFrequency = best->refreshRate;
+
+    if (dm.dmBitsPerPel < 15 || dm.dmBitsPerPel >= 24)
+        dm.dmBitsPerPel = 32;
+
+    if (ChangeDisplaySettingsEx(monitor->win32.name,
+                                &dm,
+                                NULL,
+                                CDS_FULLSCREEN,
+                                NULL) != DISP_CHANGE_SUCCESSFUL)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to set video mode");
+        return GL_FALSE;
+    }
+
+    return GL_TRUE;
+}
+
+// Restore the previously saved (original) video mode
+//
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
+{
+    ChangeDisplaySettingsEx(monitor->win32.name,
+                            NULL, NULL, CDS_FULLSCREEN, NULL);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
+{
+    int size = 0, found = 0;
+    _GLFWmonitor** monitors = NULL;
+    DWORD adapterIndex = 0;
+    int primaryIndex = 0;
+
+    *count = 0;
+
+    for (;;)
+    {
+        DISPLAY_DEVICE adapter, display;
+        char* name;
+        HDC dc;
+
+        ZeroMemory(&adapter, sizeof(DISPLAY_DEVICE));
+        adapter.cb = sizeof(DISPLAY_DEVICE);
+
+        if (!EnumDisplayDevices(NULL, adapterIndex, &adapter, 0))
+            break;
+
+        adapterIndex++;
+
+        if ((adapter.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) ||
+            !(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
+        {
+            continue;
+        }
+
+        if (found == size)
+        {
+            if (size)
+                size *= 2;
+            else
+                size = 4;
+
+            monitors = (_GLFWmonitor**) realloc(monitors, sizeof(_GLFWmonitor*) * size);
+        }
+
+        ZeroMemory(&display, sizeof(DISPLAY_DEVICE));
+        display.cb = sizeof(DISPLAY_DEVICE);
+
+        EnumDisplayDevices(adapter.DeviceName, 0, &display, 0);
+        dc = CreateDC(L"DISPLAY", display.DeviceString, NULL, NULL);
+
+        if (adapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
+            primaryIndex = found;
+
+        name = _glfwCreateUTF8FromWideString(display.DeviceString);
+        if (!name)
+        {
+            _glfwDestroyMonitors(monitors, found);
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Failed to convert string to UTF-8");
+
+            free(monitors);
+            return NULL;
+        }
+
+        monitors[found] = _glfwCreateMonitor(name,
+                                             GetDeviceCaps(dc, HORZSIZE),
+                                             GetDeviceCaps(dc, VERTSIZE));
+
+        free(name);
+        DeleteDC(dc);
+
+        wcscpy(monitors[found]->win32.name, adapter.DeviceName);
+        found++;
+    }
+
+    if (primaryIndex > 0)
+    {
+        _GLFWmonitor* temp = monitors[0];
+        monitors[0] = monitors[primaryIndex];
+        monitors[primaryIndex] = temp;
+    }
+
+    *count = found;
+    return monitors;
+}
+
+GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
+{
+    return wcscmp(first->win32.name, second->win32.name) == 0;
+}
+
+void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
+{
+    DEVMODE settings;
+    ZeroMemory(&settings, sizeof(DEVMODE));
+    settings.dmSize = sizeof(DEVMODE);
+
+    EnumDisplaySettingsEx(monitor->win32.name,
+                          ENUM_CURRENT_SETTINGS,
+                          &settings,
+                          EDS_ROTATEDMODE);
+
+    if (xpos)
+        *xpos = settings.dmPosition.x;
+    if (ypos)
+        *ypos = settings.dmPosition.y;
+}
+
+GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
+{
+    int modeIndex = 0, count = 0;
+    GLFWvidmode* result = NULL;
+
+    *found = 0;
+
+    for (;;)
+    {
+        int i;
+        GLFWvidmode mode;
+        DEVMODE dm;
+
+        ZeroMemory(&dm, sizeof(DEVMODE));
+        dm.dmSize = sizeof(DEVMODE);
+
+        if (!EnumDisplaySettings(monitor->win32.name, modeIndex, &dm))
+            break;
+
+        modeIndex++;
+
+        if (dm.dmBitsPerPel < 15)
+        {
+            // Skip modes with less than 15 BPP
+            continue;
+        }
+
+        mode.width  = dm.dmPelsWidth;
+        mode.height = dm.dmPelsHeight;
+        mode.refreshRate = dm.dmDisplayFrequency;
+        _glfwSplitBPP(dm.dmBitsPerPel,
+                      &mode.redBits,
+                      &mode.greenBits,
+                      &mode.blueBits);
+
+        for (i = 0;  i < *found;  i++)
+        {
+            if (_glfwCompareVideoModes(result + i, &mode) == 0)
+                break;
+        }
+
+        if (i < *found)
+        {
+            // This is a duplicate, so skip it
+            continue;
+        }
+
+        if (*found == count)
+        {
+            if (count)
+                count *= 2;
+            else
+                count = 128;
+
+            result = (GLFWvidmode*) realloc(result, count * sizeof(GLFWvidmode));
+        }
+
+        result[*found] = mode;
+        (*found)++;
+    }
+
+    return result;
+}
+
+void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
+{
+    DEVMODE dm;
+
+    ZeroMemory(&dm, sizeof(DEVMODE));
+    dm.dmSize = sizeof(DEVMODE);
+
+    EnumDisplaySettings(monitor->win32.name, ENUM_CURRENT_SETTINGS, &dm);
+
+    mode->width  = dm.dmPelsWidth;
+    mode->height = dm.dmPelsHeight;
+    mode->refreshRate = dm.dmDisplayFrequency;
+    _glfwSplitBPP(dm.dmBitsPerPel,
+                  &mode->redBits,
+                  &mode->greenBits,
+                  &mode->blueBits);
+}
+

libs/glfw-3.0.4/src/win32_platform.h

@@ -0,0 +1,257 @@
+//========================================================================
+// GLFW 3.0 Win32 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _win32_platform_h_
+#define _win32_platform_h_
+
+
+// We don't need all the fancy stuff
+#ifndef NOMINMAX
+ #define NOMINMAX
+#endif
+
+#ifndef VC_EXTRALEAN
+ #define VC_EXTRALEAN
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+ #define WIN32_LEAN_AND_MEAN
+#endif
+
+// This is a workaround for the fact that glfw3.h needs to export APIENTRY (to
+// correctly declare a GL_ARB_debug_output callback, for example) but windows.h
+// thinks it is the only one that gets to do so
+#undef APIENTRY
+
+// GLFW on Windows is Unicode only and does not work in MBCS mode
+#ifndef UNICODE
+ #define UNICODE
+#endif
+
+// GLFW requires Windows XP or later
+#if WINVER < 0x0501
+ #undef WINVER
+ #define WINVER 0x0501
+#endif
+#if _WIN32_WINNT < 0x0501
+ #undef _WIN32_WINNT
+ #define _WIN32_WINNT 0x0501
+#endif
+
+#include <windows.h>
+#include <mmsystem.h>
+#include <dbt.h>
+
+
+//========================================================================
+// Hack: Define things that some windows.h variants don't
+//========================================================================
+
+#ifndef WM_MOUSEHWHEEL
+ #define WM_MOUSEHWHEEL 0x020E
+#endif
+#ifndef WM_DWMCOMPOSITIONCHANGED
+ #define WM_DWMCOMPOSITIONCHANGED 0x031E
+#endif
+
+
+//========================================================================
+// DLLs that are loaded at glfwInit()
+//========================================================================
+
+// winmm.dll function pointer typedefs
+#ifndef _GLFW_NO_DLOAD_WINMM
+typedef MMRESULT (WINAPI * JOYGETDEVCAPS_T) (UINT,LPJOYCAPS,UINT);
+typedef MMRESULT (WINAPI * JOYGETPOS_T) (UINT,LPJOYINFO);
+typedef MMRESULT (WINAPI * JOYGETPOSEX_T) (UINT,LPJOYINFOEX);
+typedef DWORD (WINAPI * TIMEGETTIME_T) (void);
+#endif // _GLFW_NO_DLOAD_WINMM
+
+
+// winmm.dll shortcuts
+#ifndef _GLFW_NO_DLOAD_WINMM
+ #define _glfw_joyGetDevCaps _glfw.win32.winmm.joyGetDevCaps
+ #define _glfw_joyGetPos     _glfw.win32.winmm.joyGetPos
+ #define _glfw_joyGetPosEx   _glfw.win32.winmm.joyGetPosEx
+ #define _glfw_timeGetTime   _glfw.win32.winmm.timeGetTime
+#else
+ #define _glfw_joyGetDevCaps joyGetDevCaps
+ #define _glfw_joyGetPos     joyGetPos
+ #define _glfw_joyGetPosEx   joyGetPosEx
+ #define _glfw_timeGetTime   timeGetTime
+#endif // _GLFW_NO_DLOAD_WINMM
+
+// user32.dll function pointer typedefs
+typedef BOOL (WINAPI * SETPROCESSDPIAWARE_T)(void);
+#define _glfw_SetProcessDPIAware _glfw.win32.user32.SetProcessDPIAware
+
+// dwmapi.dll function pointer typedefs
+typedef HRESULT (WINAPI * DWMISCOMPOSITIONENABLED_T)(BOOL*);
+#define _glfw_DwmIsCompositionEnabled _glfw.win32.dwmapi.DwmIsCompositionEnabled
+
+
+// We use versioned window class names in order not to cause conflicts
+// between applications using different versions of GLFW
+#define _GLFW_WNDCLASSNAME L"GLFW30"
+
+#define _GLFW_RECREATION_NOT_NEEDED 0
+#define _GLFW_RECREATION_REQUIRED   1
+#define _GLFW_RECREATION_IMPOSSIBLE 2
+
+
+#if defined(_GLFW_WGL)
+ #include "wgl_platform.h"
+#elif defined(_GLFW_EGL)
+ #define _GLFW_EGL_NATIVE_WINDOW  window->win32.handle
+ #define _GLFW_EGL_NATIVE_DISPLAY EGL_DEFAULT_DISPLAY
+ #include "egl_platform.h"
+#else
+ #error "No supported context creation API selected"
+#endif
+
+#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowWin32  win32
+#define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryWin32 win32
+#define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorWin32 win32
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+
+//------------------------------------------------------------------------
+// Platform-specific window structure
+//------------------------------------------------------------------------
+typedef struct _GLFWwindowWin32
+{
+    // Platform specific window resources
+    HWND                handle;    // Window handle
+    DWORD               dwStyle;   // Window styles used for window creation
+    DWORD               dwExStyle; // --"--
+
+    // Various platform specific internal variables
+    GLboolean           cursorCentered;
+    GLboolean           cursorInside;
+    GLboolean           cursorHidden;
+    int                 oldCursorX, oldCursorY;
+} _GLFWwindowWin32;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for Win32
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryWin32
+{
+    ATOM                classAtom;
+    DWORD               foregroundLockTimeout;
+    char*               clipboardString;
+
+    // Timer data
+    struct {
+        GLboolean       hasPC;
+        double          resolution;
+        unsigned __int64 base;
+    } timer;
+
+#ifndef _GLFW_NO_DLOAD_WINMM
+    // winmm.dll
+    struct {
+        HINSTANCE       instance;
+        JOYGETDEVCAPS_T joyGetDevCaps;
+        JOYGETPOS_T     joyGetPos;
+        JOYGETPOSEX_T   joyGetPosEx;
+        TIMEGETTIME_T   timeGetTime;
+    } winmm;
+#endif // _GLFW_NO_DLOAD_WINMM
+
+    // user32.dll
+    struct {
+        HINSTANCE       instance;
+        SETPROCESSDPIAWARE_T SetProcessDPIAware;
+    } user32;
+
+    // dwmapi.dll
+    struct {
+        HINSTANCE       instance;
+        DWMISCOMPOSITIONENABLED_T DwmIsCompositionEnabled;
+    } dwmapi;
+
+    struct {
+        float           axes[6];
+        unsigned char   buttons[36]; // 32 buttons plus one hat
+        char*           name;
+    } joystick[GLFW_JOYSTICK_LAST + 1];
+
+} _GLFWlibraryWin32;
+
+
+//------------------------------------------------------------------------
+// Platform-specific monitor structure
+//------------------------------------------------------------------------
+typedef struct _GLFWmonitorWin32
+{
+    // This size matches the static size of DISPLAY_DEVICE.DeviceName
+    WCHAR               name[32];
+
+} _GLFWmonitorWin32;
+
+
+//========================================================================
+// Prototypes for platform specific internal functions
+//========================================================================
+
+// Desktop compositing
+BOOL _glfwIsCompositionEnabled(void);
+
+// Wide strings
+WCHAR* _glfwCreateWideStringFromUTF8(const char* source);
+char* _glfwCreateUTF8FromWideString(const WCHAR* source);
+
+// Time
+void _glfwInitTimer(void);
+
+// Joystick input
+void _glfwInitJoysticks(void);
+void _glfwTerminateJoysticks(void);
+
+// OpenGL support
+int _glfwInitContextAPI(void);
+void _glfwTerminateContextAPI(void);
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig);
+void _glfwDestroyContext(_GLFWwindow* window);
+int _glfwAnalyzeContext(const _GLFWwindow* window,
+                        const _GLFWwndconfig* wndconfig,
+                        const _GLFWfbconfig* fbconfig);
+
+// Fullscreen support
+GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired);
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor);
+
+
+#endif // _win32_platform_h_

libs/glfw-3.0.4/src/win32_time.c

@@ -0,0 +1,86 @@
+//========================================================================
+// GLFW 3.0 Win32 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+// Return raw time
+//
+static unsigned __int64 getRawTime(void)
+{
+    if (_glfw.win32.timer.hasPC)
+    {
+        unsigned __int64 time;
+        QueryPerformanceCounter((LARGE_INTEGER*) &time);
+        return time;
+    }
+    else
+        return (unsigned __int64) _glfw_timeGetTime();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialise timer
+//
+void _glfwInitTimer(void)
+{
+    unsigned __int64 frequency;
+
+    if (QueryPerformanceFrequency((LARGE_INTEGER*) &frequency))
+    {
+        _glfw.win32.timer.hasPC = GL_TRUE;
+        _glfw.win32.timer.resolution = 1.0 / (double) frequency;
+    }
+    else
+    {
+        _glfw.win32.timer.hasPC = GL_FALSE;
+        _glfw.win32.timer.resolution = 0.001; // winmm resolution is 1 ms
+    }
+
+    _glfw.win32.timer.base = getRawTime();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+double _glfwPlatformGetTime(void)
+{
+    return (double) (getRawTime() - _glfw.win32.timer.base) *
+        _glfw.win32.timer.resolution;
+}
+
+void _glfwPlatformSetTime(double time)
+{
+    _glfw.win32.timer.base = getRawTime() -
+        (unsigned __int64) (time / _glfw.win32.timer.resolution);
+}
+

libs/glfw-3.0.4/src/window.c

@@ -0,0 +1,674 @@
+//========================================================================
+// GLFW 3.0 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+// Copyright (c) 2012 Torsten Walluhn <tw@mad-cad.net>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <string.h>
+#include <stdlib.h>
+#if defined(_MSC_VER)
+ #include <malloc.h>
+#endif
+
+
+// Return the maxiumum of the specified values
+//
+static int Max(int a, int b)
+{
+    return (a > b) ? a : b;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                         GLFW event API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwInputWindowFocus(_GLFWwindow* window, GLboolean focused)
+{
+    if (focused)
+    {
+        if (_glfw.focusedWindow != window)
+        {
+            _glfw.focusedWindow = window;
+
+            if (window->callbacks.focus)
+                window->callbacks.focus((GLFWwindow*) window, focused);
+        }
+    }
+    else
+    {
+        if (_glfw.focusedWindow == window)
+        {
+            int i;
+
+            _glfw.focusedWindow = NULL;
+
+            if (window->callbacks.focus)
+                window->callbacks.focus((GLFWwindow*) window, focused);
+
+            // Release all pressed keyboard keys
+            for (i = 0;  i <= GLFW_KEY_LAST;  i++)
+            {
+                if (window->key[i] == GLFW_PRESS)
+                    _glfwInputKey(window, i, 0, GLFW_RELEASE, 0);
+            }
+
+            // Release all pressed mouse buttons
+            for (i = 0;  i <= GLFW_MOUSE_BUTTON_LAST;  i++)
+            {
+                if (window->mouseButton[i] == GLFW_PRESS)
+                    _glfwInputMouseClick(window, i, GLFW_RELEASE, 0);
+            }
+        }
+    }
+}
+
+void _glfwInputWindowPos(_GLFWwindow* window, int x, int y)
+{
+    if (window->callbacks.pos)
+        window->callbacks.pos((GLFWwindow*) window, x, y);
+}
+
+void _glfwInputWindowSize(_GLFWwindow* window, int width, int height)
+{
+    if (window->callbacks.size)
+        window->callbacks.size((GLFWwindow*) window, width, height);
+}
+
+void _glfwInputWindowIconify(_GLFWwindow* window, int iconified)
+{
+    if (window->iconified == iconified)
+        return;
+
+    window->iconified = iconified;
+
+    if (window->callbacks.iconify)
+        window->callbacks.iconify((GLFWwindow*) window, iconified);
+}
+
+void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height)
+{
+    if (window->callbacks.fbsize)
+        window->callbacks.fbsize((GLFWwindow*) window, width, height);
+}
+
+void _glfwInputWindowVisibility(_GLFWwindow* window, int visible)
+{
+    window->visible = visible;
+}
+
+void _glfwInputWindowDamage(_GLFWwindow* window)
+{
+    if (window->callbacks.refresh)
+        window->callbacks.refresh((GLFWwindow*) window);
+}
+
+void _glfwInputWindowCloseRequest(_GLFWwindow* window)
+{
+    window->closed = GL_TRUE;
+
+    if (window->callbacks.close)
+        window->callbacks.close((GLFWwindow*) window);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW public API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
+                                     const char* title,
+                                     GLFWmonitor* monitor,
+                                     GLFWwindow* share)
+{
+    _GLFWfbconfig fbconfig;
+    _GLFWwndconfig wndconfig;
+    _GLFWwindow* window;
+    _GLFWwindow* previous;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (width <= 0 || height <= 0)
+    {
+        _glfwInputError(GLFW_INVALID_VALUE, "Invalid window size");
+        return NULL;
+    }
+
+    // Set up desired framebuffer config
+    fbconfig.redBits        = Max(_glfw.hints.redBits, 0);
+    fbconfig.greenBits      = Max(_glfw.hints.greenBits, 0);
+    fbconfig.blueBits       = Max(_glfw.hints.blueBits, 0);
+    fbconfig.alphaBits      = Max(_glfw.hints.alphaBits, 0);
+    fbconfig.depthBits      = Max(_glfw.hints.depthBits, 0);
+    fbconfig.stencilBits    = Max(_glfw.hints.stencilBits, 0);
+    fbconfig.accumRedBits   = Max(_glfw.hints.accumRedBits, 0);
+    fbconfig.accumGreenBits = Max(_glfw.hints.accumGreenBits, 0);
+    fbconfig.accumBlueBits  = Max(_glfw.hints.accumBlueBits, 0);
+    fbconfig.accumAlphaBits = Max(_glfw.hints.accumAlphaBits, 0);
+    fbconfig.auxBuffers     = Max(_glfw.hints.auxBuffers, 0);
+    fbconfig.stereo         = _glfw.hints.stereo ? GL_TRUE : GL_FALSE;
+    fbconfig.samples        = Max(_glfw.hints.samples, 0);
+    fbconfig.sRGB           = _glfw.hints.sRGB ? GL_TRUE : GL_FALSE;
+
+    // Set up desired window config
+    wndconfig.width         = width;
+    wndconfig.height        = height;
+    wndconfig.title         = title;
+    wndconfig.resizable     = _glfw.hints.resizable ? GL_TRUE : GL_FALSE;
+    wndconfig.visible       = _glfw.hints.visible ? GL_TRUE : GL_FALSE;
+    wndconfig.decorated     = _glfw.hints.decorated ? GL_TRUE : GL_FALSE;
+    wndconfig.clientAPI     = _glfw.hints.clientAPI;
+    wndconfig.glMajor       = _glfw.hints.glMajor;
+    wndconfig.glMinor       = _glfw.hints.glMinor;
+    wndconfig.glForward     = _glfw.hints.glForward ? GL_TRUE : GL_FALSE;
+    wndconfig.glDebug       = _glfw.hints.glDebug ? GL_TRUE : GL_FALSE;
+    wndconfig.glProfile     = _glfw.hints.glProfile;
+    wndconfig.glRobustness  = _glfw.hints.glRobustness;
+    wndconfig.monitor       = (_GLFWmonitor*) monitor;
+    wndconfig.share         = (_GLFWwindow*) share;
+
+    // Check the OpenGL bits of the window config
+    if (!_glfwIsValidContextConfig(&wndconfig))
+        return NULL;
+
+    window = calloc(1, sizeof(_GLFWwindow));
+    window->next = _glfw.windowListHead;
+    _glfw.windowListHead = window;
+
+    if (wndconfig.monitor)
+    {
+        wndconfig.resizable = GL_TRUE;
+        wndconfig.visible   = GL_TRUE;
+
+        // Set up desired video mode
+        window->videoMode.width       = width;
+        window->videoMode.height      = height;
+        window->videoMode.redBits     = Max(_glfw.hints.redBits, 0);
+        window->videoMode.greenBits   = Max(_glfw.hints.greenBits, 0);
+        window->videoMode.blueBits    = Max(_glfw.hints.blueBits, 0);
+        window->videoMode.refreshRate = Max(_glfw.hints.refreshRate, 0);
+    }
+
+    window->monitor    = wndconfig.monitor;
+    window->resizable  = wndconfig.resizable;
+    window->decorated  = wndconfig.decorated;
+    window->cursorMode = GLFW_CURSOR_NORMAL;
+
+    // Save the currently current context so it can be restored later
+    previous = (_GLFWwindow*) glfwGetCurrentContext();
+
+    // Open the actual window and create its context
+    if (!_glfwPlatformCreateWindow(window, &wndconfig, &fbconfig))
+    {
+        glfwDestroyWindow((GLFWwindow*) window);
+        glfwMakeContextCurrent((GLFWwindow*) previous);
+        return NULL;
+    }
+
+    glfwMakeContextCurrent((GLFWwindow*) window);
+
+    // Retrieve the actual (as opposed to requested) context attributes
+    if (!_glfwRefreshContextAttribs())
+    {
+        glfwDestroyWindow((GLFWwindow*) window);
+        glfwMakeContextCurrent((GLFWwindow*) previous);
+        return NULL;
+    }
+
+    // Verify the context against the requested parameters
+    if (!_glfwIsValidContext(&wndconfig))
+    {
+        glfwDestroyWindow((GLFWwindow*) window);
+        glfwMakeContextCurrent((GLFWwindow*) previous);
+        return NULL;
+    }
+
+    // Clearing the front buffer to black to avoid garbage pixels left over
+    // from previous uses of our bit of VRAM
+    glClear(GL_COLOR_BUFFER_BIT);
+    _glfwPlatformSwapBuffers(window);
+
+    // Restore the previously current context (or NULL)
+    glfwMakeContextCurrent((GLFWwindow*) previous);
+
+    if (wndconfig.monitor == NULL && wndconfig.visible)
+        glfwShowWindow((GLFWwindow*) window);
+
+    return (GLFWwindow*) window;
+}
+
+void glfwDefaultWindowHints(void)
+{
+    _GLFW_REQUIRE_INIT();
+
+    memset(&_glfw.hints, 0, sizeof(_glfw.hints));
+
+    // The default is OpenGL with minimum version 1.0
+    _glfw.hints.clientAPI = GLFW_OPENGL_API;
+    _glfw.hints.glMajor = 1;
+    _glfw.hints.glMinor = 0;
+
+    // The default is a visible, resizable window with decorations
+    _glfw.hints.resizable = GL_TRUE;
+    _glfw.hints.visible   = GL_TRUE;
+    _glfw.hints.decorated = GL_TRUE;
+
+    // The default is 24 bits of color, 24 bits of depth and 8 bits of stencil
+    _glfw.hints.redBits     = 8;
+    _glfw.hints.greenBits   = 8;
+    _glfw.hints.blueBits    = 8;
+    _glfw.hints.alphaBits   = 8;
+    _glfw.hints.depthBits   = 24;
+    _glfw.hints.stencilBits = 8;
+}
+
+GLFWAPI void glfwWindowHint(int target, int hint)
+{
+    _GLFW_REQUIRE_INIT();
+
+    switch (target)
+    {
+        case GLFW_RED_BITS:
+            _glfw.hints.redBits = hint;
+            break;
+        case GLFW_GREEN_BITS:
+            _glfw.hints.greenBits = hint;
+            break;
+        case GLFW_BLUE_BITS:
+            _glfw.hints.blueBits = hint;
+            break;
+        case GLFW_ALPHA_BITS:
+            _glfw.hints.alphaBits = hint;
+            break;
+        case GLFW_DEPTH_BITS:
+            _glfw.hints.depthBits = hint;
+            break;
+        case GLFW_STENCIL_BITS:
+            _glfw.hints.stencilBits = hint;
+            break;
+        case GLFW_ACCUM_RED_BITS:
+            _glfw.hints.accumRedBits = hint;
+            break;
+        case GLFW_ACCUM_GREEN_BITS:
+            _glfw.hints.accumGreenBits = hint;
+            break;
+        case GLFW_ACCUM_BLUE_BITS:
+            _glfw.hints.accumBlueBits = hint;
+            break;
+        case GLFW_ACCUM_ALPHA_BITS:
+            _glfw.hints.accumAlphaBits = hint;
+            break;
+        case GLFW_AUX_BUFFERS:
+            _glfw.hints.auxBuffers = hint;
+            break;
+        case GLFW_STEREO:
+            _glfw.hints.stereo = hint;
+            break;
+        case GLFW_REFRESH_RATE:
+            _glfw.hints.refreshRate = hint;
+            break;
+        case GLFW_RESIZABLE:
+            _glfw.hints.resizable = hint;
+            break;
+        case GLFW_DECORATED:
+            _glfw.hints.decorated = hint;
+            break;
+        case GLFW_VISIBLE:
+            _glfw.hints.visible = hint;
+            break;
+        case GLFW_SAMPLES:
+            _glfw.hints.samples = hint;
+            break;
+        case GLFW_SRGB_CAPABLE:
+            _glfw.hints.sRGB = hint;
+            break;
+        case GLFW_CLIENT_API:
+            _glfw.hints.clientAPI = hint;
+            break;
+        case GLFW_CONTEXT_VERSION_MAJOR:
+            _glfw.hints.glMajor = hint;
+            break;
+        case GLFW_CONTEXT_VERSION_MINOR:
+            _glfw.hints.glMinor = hint;
+            break;
+        case GLFW_CONTEXT_ROBUSTNESS:
+            _glfw.hints.glRobustness = hint;
+            break;
+        case GLFW_OPENGL_FORWARD_COMPAT:
+            _glfw.hints.glForward = hint;
+            break;
+        case GLFW_OPENGL_DEBUG_CONTEXT:
+            _glfw.hints.glDebug = hint;
+            break;
+        case GLFW_OPENGL_PROFILE:
+            _glfw.hints.glProfile = hint;
+            break;
+        default:
+            _glfwInputError(GLFW_INVALID_ENUM, NULL);
+            break;
+    }
+}
+
+GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    // Allow closing of NULL (to match the behavior of free)
+    if (window == NULL)
+        return;
+
+    // Clear all callbacks to avoid exposing a half torn-down window object
+    memset(&window->callbacks, 0, sizeof(window->callbacks));
+
+    // The window's context must not be current on another thread when the
+    // window is destroyed
+    if (window == _glfwPlatformGetCurrentContext())
+        _glfwPlatformMakeContextCurrent(NULL);
+
+    // Clear the focused window pointer if this is the focused window
+    if (window == _glfw.focusedWindow)
+        _glfw.focusedWindow = NULL;
+
+    _glfwPlatformDestroyWindow(window);
+
+    // Unlink window from global linked list
+    {
+        _GLFWwindow** prev = &_glfw.windowListHead;
+
+        while (*prev != window)
+            prev = &((*prev)->next);
+
+        *prev = window->next;
+    }
+
+    free(window);
+}
+
+GLFWAPI int glfwWindowShouldClose(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+    return window->closed;
+}
+
+GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* handle, int value)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    window->closed = value;
+}
+
+GLFWAPI void glfwSetWindowTitle(GLFWwindow* handle, const char* title)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformSetWindowTitle(window, title);
+}
+
+GLFWAPI void glfwGetWindowPos(GLFWwindow* handle, int* xpos, int* ypos)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformGetWindowPos(window, xpos, ypos);
+}
+
+GLFWAPI void glfwSetWindowPos(GLFWwindow* handle, int xpos, int ypos)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (window->monitor)
+    {
+        _glfwInputError(GLFW_INVALID_VALUE,
+                        "Fullscreen windows cannot be positioned");
+        return;
+    }
+
+    _glfwPlatformSetWindowPos(window, xpos, ypos);
+}
+
+GLFWAPI void glfwGetWindowSize(GLFWwindow* handle, int* width, int* height)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformGetWindowSize(window, width, height);
+}
+
+GLFWAPI void glfwSetWindowSize(GLFWwindow* handle, int width, int height)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (window->iconified)
+        return;
+
+    if (window->monitor)
+    {
+        window->videoMode.width  = width;
+        window->videoMode.height = height;
+    }
+
+    _glfwPlatformSetWindowSize(window, width, height);
+}
+
+GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    _glfwPlatformGetFramebufferSize(window, width, height);
+}
+
+GLFWAPI void glfwIconifyWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (window->iconified)
+        return;
+
+    _glfwPlatformIconifyWindow(window);
+}
+
+GLFWAPI void glfwRestoreWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (!window->iconified)
+        return;
+
+    _glfwPlatformRestoreWindow(window);
+}
+
+GLFWAPI void glfwShowWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (window->monitor)
+        return;
+
+    _glfwPlatformShowWindow(window);
+}
+
+GLFWAPI void glfwHideWindow(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT();
+
+    if (window->monitor)
+        return;
+
+    _glfwPlatformHideWindow(window);
+}
+
+GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+
+    switch (attrib)
+    {
+        case GLFW_FOCUSED:
+            return window == _glfw.focusedWindow;
+        case GLFW_ICONIFIED:
+            return window->iconified;
+        case GLFW_RESIZABLE:
+            return window->resizable;
+        case GLFW_DECORATED:
+            return window->decorated;
+        case GLFW_VISIBLE:
+            return window->visible;
+        case GLFW_CLIENT_API:
+            return window->clientAPI;
+        case GLFW_CONTEXT_VERSION_MAJOR:
+            return window->glMajor;
+        case GLFW_CONTEXT_VERSION_MINOR:
+            return window->glMinor;
+        case GLFW_CONTEXT_REVISION:
+            return window->glRevision;
+        case GLFW_CONTEXT_ROBUSTNESS:
+            return window->glRobustness;
+        case GLFW_OPENGL_FORWARD_COMPAT:
+            return window->glForward;
+        case GLFW_OPENGL_DEBUG_CONTEXT:
+            return window->glDebug;
+        case GLFW_OPENGL_PROFILE:
+            return window->glProfile;
+    }
+
+    _glfwInputError(GLFW_INVALID_ENUM, NULL);
+    return 0;
+}
+
+GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return (GLFWmonitor*) window->monitor;
+}
+
+GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* handle, void* pointer)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT();
+    window->userPointer = pointer;
+}
+
+GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    return window->userPointer;
+}
+
+GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* handle,
+                                                  GLFWwindowposfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.pos, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* handle,
+                                                    GLFWwindowsizefun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.size, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* handle,
+                                                      GLFWwindowclosefun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.close, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* handle,
+                                                          GLFWwindowrefreshfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.refresh, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* handle,
+                                                      GLFWwindowfocusfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.focus, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* handle,
+                                                          GLFWwindowiconifyfun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.iconify, cbfun);
+    return cbfun;
+}
+
+GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* handle,
+                                                              GLFWframebuffersizefun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.fbsize, cbfun);
+    return cbfun;
+}
+
+GLFWAPI void glfwPollEvents(void)
+{
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformPollEvents();
+}
+
+GLFWAPI void glfwWaitEvents(void)
+{
+    _GLFW_REQUIRE_INIT();
+    _glfwPlatformWaitEvents();
+}
+

libs/glfw-3.0.4/src/x11_clipboard.c

@@ -0,0 +1,335 @@
+//========================================================================
+// GLFW 3.0 X11 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <stdio.h>
+#include <limits.h>
+#include <string.h>
+#include <stdlib.h>
+
+
+// Returns whether the event is a selection event
+//
+static Bool isSelectionMessage(Display* display, XEvent* event, XPointer pointer)
+{
+    return event->type == SelectionRequest ||
+           event->type == SelectionNotify ||
+           event->type == SelectionClear;
+}
+
+// Set the specified property to the selection converted to the requested target
+//
+static Atom writeTargetToProperty(const XSelectionRequestEvent* request)
+{
+    int i;
+    const Atom formats[] = { _glfw.x11.UTF8_STRING,
+                             _glfw.x11.COMPOUND_STRING,
+                             XA_STRING };
+    const int formatCount = sizeof(formats) / sizeof(formats[0]);
+
+    if (request->property == None)
+    {
+        // The requestor is a legacy client (ICCCM section 2.2)
+        // We don't support legacy clients, so fail here
+        return None;
+    }
+
+    if (request->target == _glfw.x11.TARGETS)
+    {
+        // The list of supported targets was requested
+
+        const Atom targets[] = { _glfw.x11.TARGETS,
+                                 _glfw.x11.MULTIPLE,
+                                 _glfw.x11.UTF8_STRING,
+                                 _glfw.x11.COMPOUND_STRING,
+                                 XA_STRING };
+
+        XChangeProperty(_glfw.x11.display,
+                        request->requestor,
+                        request->property,
+                        XA_ATOM,
+                        32,
+                        PropModeReplace,
+                        (unsigned char*) targets,
+                        sizeof(targets) / sizeof(targets[0]));
+
+        return request->property;
+    }
+
+    if (request->target == _glfw.x11.MULTIPLE)
+    {
+        // Multiple conversions were requested
+
+        Atom* targets;
+        unsigned long i, count;
+
+        count = _glfwGetWindowProperty(request->requestor,
+                                       request->property,
+                                       _glfw.x11.ATOM_PAIR,
+                                       (unsigned char**) &targets);
+
+        for (i = 0;  i < count;  i += 2)
+        {
+            int j;
+
+            for (j = 0;  j < formatCount;  j++)
+            {
+                if (targets[i] == formats[j])
+                    break;
+            }
+
+            if (j < formatCount)
+            {
+                XChangeProperty(_glfw.x11.display,
+                                request->requestor,
+                                targets[i + 1],
+                                targets[i],
+                                8,
+                                PropModeReplace,
+                                (unsigned char*) _glfw.x11.selection.string,
+                                strlen(_glfw.x11.selection.string));
+            }
+            else
+                targets[i + 1] = None;
+        }
+
+        XChangeProperty(_glfw.x11.display,
+                        request->requestor,
+                        request->property,
+                        _glfw.x11.ATOM_PAIR,
+                        32,
+                        PropModeReplace,
+                        (unsigned char*) targets,
+                        count);
+
+        XFree(targets);
+
+        return request->property;
+    }
+
+    if (request->target == _glfw.x11.SAVE_TARGETS)
+    {
+        // The request is a check whether we support SAVE_TARGETS
+        // It should be handled as a no-op side effect target
+
+        XChangeProperty(_glfw.x11.display,
+                        request->requestor,
+                        request->property,
+                        XInternAtom(_glfw.x11.display, "NULL", False),
+                        32,
+                        PropModeReplace,
+                        NULL,
+                        0);
+
+        return request->property;
+    }
+
+    // Conversion to a data target was requested
+
+    for (i = 0;  i < formatCount;  i++)
+    {
+        if (request->target == formats[i])
+        {
+            // The requested target is one we support
+
+            XChangeProperty(_glfw.x11.display,
+                            request->requestor,
+                            request->property,
+                            request->target,
+                            8,
+                            PropModeReplace,
+                            (unsigned char*) _glfw.x11.selection.string,
+                            strlen(_glfw.x11.selection.string));
+
+            return request->property;
+        }
+    }
+
+    // The requested target is not supported
+
+    return None;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwHandleSelectionClear(XEvent* event)
+{
+    free(_glfw.x11.selection.string);
+    _glfw.x11.selection.string = NULL;
+}
+
+void _glfwHandleSelectionRequest(XEvent* event)
+{
+    const XSelectionRequestEvent* request = &event->xselectionrequest;
+
+    XEvent response;
+    memset(&response, 0, sizeof(response));
+
+    response.xselection.property = writeTargetToProperty(request);
+    response.xselection.type = SelectionNotify;
+    response.xselection.display = request->display;
+    response.xselection.requestor = request->requestor;
+    response.xselection.selection = request->selection;
+    response.xselection.target = request->target;
+    response.xselection.time = request->time;
+
+    XSendEvent(_glfw.x11.display, request->requestor, False, 0, &response);
+}
+
+void _glfwPushSelectionToManager(_GLFWwindow* window)
+{
+    XConvertSelection(_glfw.x11.display,
+                      _glfw.x11.CLIPBOARD_MANAGER,
+                      _glfw.x11.SAVE_TARGETS,
+                      None,
+                      window->x11.handle,
+                      CurrentTime);
+
+    for (;;)
+    {
+        XEvent event;
+
+        if (!XCheckIfEvent(_glfw.x11.display, &event, isSelectionMessage, NULL))
+            continue;
+
+        switch (event.type)
+        {
+            case SelectionRequest:
+                _glfwHandleSelectionRequest(&event);
+                break;
+
+            case SelectionClear:
+                _glfwHandleSelectionClear(&event);
+                break;
+
+            case SelectionNotify:
+            {
+                if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
+                {
+                    // This means one of two things; either the selection was
+                    // not owned, which means there is no clipboard manager, or
+                    // the transfer to the clipboard manager has completed
+                    // In either case, it means we are done here
+                    return;
+                }
+
+                break;
+            }
+        }
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
+{
+    free(_glfw.x11.selection.string);
+    _glfw.x11.selection.string = strdup(string);
+
+    XSetSelectionOwner(_glfw.x11.display,
+                       _glfw.x11.CLIPBOARD,
+                       window->x11.handle, CurrentTime);
+
+    if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) !=
+        window->x11.handle)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "X11: Failed to become owner of the clipboard selection");
+    }
+}
+
+const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
+{
+    size_t i;
+    const Atom formats[] = { _glfw.x11.UTF8_STRING,
+                             _glfw.x11.COMPOUND_STRING,
+                             XA_STRING };
+    const size_t formatCount = sizeof(formats) / sizeof(formats[0]);
+
+    if (_glfwFindWindowByHandle(XGetSelectionOwner(_glfw.x11.display,
+                                                   _glfw.x11.CLIPBOARD)))
+    {
+        // Instead of doing a large number of X round-trips just to put this
+        // string into a window property and then read it back, just return it
+        return _glfw.x11.selection.string;
+    }
+
+    free(_glfw.x11.selection.string);
+    _glfw.x11.selection.string = NULL;
+
+    for (i = 0;  i < formatCount;  i++)
+    {
+        char* data;
+        XEvent event;
+
+        XConvertSelection(_glfw.x11.display,
+                          _glfw.x11.CLIPBOARD,
+                          formats[i],
+                          _glfw.x11.GLFW_SELECTION,
+                          window->x11.handle, CurrentTime);
+
+        // XCheckTypedEvent is used instead of XIfEvent in order not to lock
+        // other threads out from the display during the entire wait period
+        while (!XCheckTypedEvent(_glfw.x11.display, SelectionNotify, &event))
+            ;
+
+        if (event.xselection.property == None)
+            continue;
+
+        if (_glfwGetWindowProperty(event.xselection.requestor,
+                                   event.xselection.property,
+                                   event.xselection.target,
+                                   (unsigned char**) &data))
+        {
+            _glfw.x11.selection.string = strdup(data);
+        }
+
+        XFree(data);
+
+        XDeleteProperty(_glfw.x11.display,
+                        event.xselection.requestor,
+                        event.xselection.property);
+
+        if (_glfw.x11.selection.string)
+            break;
+    }
+
+    if (_glfw.x11.selection.string == NULL)
+    {
+        _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
+                        "X11: Failed to convert selection to string");
+    }
+
+    return _glfw.x11.selection.string;
+}
+

libs/glfw-3.0.4/src/x11_gamma.c

@@ -0,0 +1,123 @@
+//========================================================================
+// GLFW 3.0 X11 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+#include <string.h>
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Detect gamma ramp support
+//
+void _glfwInitGammaRamp(void)
+{
+    // RandR gamma support is only available with version 1.2 and above
+    if (_glfw.x11.randr.available &&
+        (_glfw.x11.randr.versionMajor > 1 ||
+         (_glfw.x11.randr.versionMajor == 1 &&
+          _glfw.x11.randr.versionMinor >= 2)))
+    {
+        // FIXME: Assumes that all monitors have the same size gamma tables
+        // This is reasonable as I suspect the that if they did differ, it
+        // would imply that setting the gamma size to an arbitary size is
+        // possible as well.
+        XRRScreenResources* rr = XRRGetScreenResources(_glfw.x11.display,
+                                                       _glfw.x11.root);
+
+        if (XRRGetCrtcGammaSize(_glfw.x11.display, rr->crtcs[0]) == 0)
+        {
+            // This is probably older Nvidia RandR with broken gamma support
+            // Flag it as useless and try Xf86VidMode below, if available
+            _glfw.x11.randr.gammaBroken = GL_TRUE;
+        }
+
+        XRRFreeScreenResources(rr);
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+{
+    if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
+    {
+        const size_t size = XRRGetCrtcGammaSize(_glfw.x11.display,
+                                                monitor->x11.crtc);
+        XRRCrtcGamma* gamma = XRRGetCrtcGamma(_glfw.x11.display,
+                                              monitor->x11.crtc);
+
+        _glfwAllocGammaArrays(ramp, size);
+
+        memcpy(ramp->red, gamma->red, size * sizeof(unsigned short));
+        memcpy(ramp->green, gamma->green, size * sizeof(unsigned short));
+        memcpy(ramp->blue, gamma->blue, size * sizeof(unsigned short));
+
+        XRRFreeGamma(gamma);
+    }
+    else if (_glfw.x11.vidmode.available)
+    {
+        int size;
+        XF86VidModeGetGammaRampSize(_glfw.x11.display, _glfw.x11.screen, &size);
+
+        _glfwAllocGammaArrays(ramp, size);
+
+        XF86VidModeGetGammaRamp(_glfw.x11.display,
+                                _glfw.x11.screen,
+                                ramp->size, ramp->red, ramp->green, ramp->blue);
+    }
+}
+
+void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
+{
+    if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
+    {
+        XRRCrtcGamma* gamma = XRRAllocGamma(ramp->size);
+
+        memcpy(gamma->red, ramp->red, ramp->size * sizeof(unsigned short));
+        memcpy(gamma->green, ramp->green, ramp->size * sizeof(unsigned short));
+        memcpy(gamma->blue, ramp->blue, ramp->size * sizeof(unsigned short));
+
+        XRRSetCrtcGamma(_glfw.x11.display, monitor->x11.crtc, gamma);
+        XRRFreeGamma(gamma);
+    }
+    else if (_glfw.x11.vidmode.available)
+    {
+        XF86VidModeSetGammaRamp(_glfw.x11.display,
+                                _glfw.x11.screen,
+                                ramp->size,
+                                (unsigned short*) ramp->red,
+                                (unsigned short*) ramp->green,
+                                (unsigned short*) ramp->blue);
+    }
+}
+

libs/glfw-3.0.4/src/x11_init.c

@@ -0,0 +1,713 @@
+//========================================================================
+// GLFW 3.0 X11 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <X11/Xresource.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+
+// Translate an X11 key code to a GLFW key code.
+//
+static int translateKey(int keyCode)
+{
+    int keySym;
+
+    // Valid key code range is  [8,255], according to the XLib manual
+    if (keyCode < 8 || keyCode > 255)
+        return GLFW_KEY_UNKNOWN;
+
+    // Try secondary keysym, for numeric keypad keys
+    // Note: This way we always force "NumLock = ON", which is intentional
+    // since the returned key code should correspond to a physical
+    // location.
+    keySym = XkbKeycodeToKeysym(_glfw.x11.display, keyCode, 0, 1);
+    switch (keySym)
+    {
+        case XK_KP_0:           return GLFW_KEY_KP_0;
+        case XK_KP_1:           return GLFW_KEY_KP_1;
+        case XK_KP_2:           return GLFW_KEY_KP_2;
+        case XK_KP_3:           return GLFW_KEY_KP_3;
+        case XK_KP_4:           return GLFW_KEY_KP_4;
+        case XK_KP_5:           return GLFW_KEY_KP_5;
+        case XK_KP_6:           return GLFW_KEY_KP_6;
+        case XK_KP_7:           return GLFW_KEY_KP_7;
+        case XK_KP_8:           return GLFW_KEY_KP_8;
+        case XK_KP_9:           return GLFW_KEY_KP_9;
+        case XK_KP_Separator:
+        case XK_KP_Decimal:     return GLFW_KEY_KP_DECIMAL;
+        case XK_KP_Equal:       return GLFW_KEY_KP_EQUAL;
+        case XK_KP_Enter:       return GLFW_KEY_KP_ENTER;
+        default:                break;
+    }
+
+    // Now try pimary keysym for function keys (non-printable keys). These
+    // should not be layout dependent (i.e. US layout and international
+    // layouts should give the same result).
+    keySym = XkbKeycodeToKeysym(_glfw.x11.display, keyCode, 0, 0);
+    switch (keySym)
+    {
+        case XK_Escape:         return GLFW_KEY_ESCAPE;
+        case XK_Tab:            return GLFW_KEY_TAB;
+        case XK_Shift_L:        return GLFW_KEY_LEFT_SHIFT;
+        case XK_Shift_R:        return GLFW_KEY_RIGHT_SHIFT;
+        case XK_Control_L:      return GLFW_KEY_LEFT_CONTROL;
+        case XK_Control_R:      return GLFW_KEY_RIGHT_CONTROL;
+        case XK_Meta_L:
+        case XK_Alt_L:          return GLFW_KEY_LEFT_ALT;
+        case XK_Mode_switch: // Mapped to Alt_R on many keyboards
+        case XK_ISO_Level3_Shift: // AltGr on at least some machines
+        case XK_Meta_R:
+        case XK_Alt_R:          return GLFW_KEY_RIGHT_ALT;
+        case XK_Super_L:        return GLFW_KEY_LEFT_SUPER;
+        case XK_Super_R:        return GLFW_KEY_RIGHT_SUPER;
+        case XK_Menu:           return GLFW_KEY_MENU;
+        case XK_Num_Lock:       return GLFW_KEY_NUM_LOCK;
+        case XK_Caps_Lock:      return GLFW_KEY_CAPS_LOCK;
+        case XK_Print:          return GLFW_KEY_PRINT_SCREEN;
+        case XK_Scroll_Lock:    return GLFW_KEY_SCROLL_LOCK;
+        case XK_Pause:          return GLFW_KEY_PAUSE;
+        case XK_Delete:         return GLFW_KEY_DELETE;
+        case XK_BackSpace:      return GLFW_KEY_BACKSPACE;
+        case XK_Return:         return GLFW_KEY_ENTER;
+        case XK_Home:           return GLFW_KEY_HOME;
+        case XK_End:            return GLFW_KEY_END;
+        case XK_Page_Up:        return GLFW_KEY_PAGE_UP;
+        case XK_Page_Down:      return GLFW_KEY_PAGE_DOWN;
+        case XK_Insert:         return GLFW_KEY_INSERT;
+        case XK_Left:           return GLFW_KEY_LEFT;
+        case XK_Right:          return GLFW_KEY_RIGHT;
+        case XK_Down:           return GLFW_KEY_DOWN;
+        case XK_Up:             return GLFW_KEY_UP;
+        case XK_F1:             return GLFW_KEY_F1;
+        case XK_F2:             return GLFW_KEY_F2;
+        case XK_F3:             return GLFW_KEY_F3;
+        case XK_F4:             return GLFW_KEY_F4;
+        case XK_F5:             return GLFW_KEY_F5;
+        case XK_F6:             return GLFW_KEY_F6;
+        case XK_F7:             return GLFW_KEY_F7;
+        case XK_F8:             return GLFW_KEY_F8;
+        case XK_F9:             return GLFW_KEY_F9;
+        case XK_F10:            return GLFW_KEY_F10;
+        case XK_F11:            return GLFW_KEY_F11;
+        case XK_F12:            return GLFW_KEY_F12;
+        case XK_F13:            return GLFW_KEY_F13;
+        case XK_F14:            return GLFW_KEY_F14;
+        case XK_F15:            return GLFW_KEY_F15;
+        case XK_F16:            return GLFW_KEY_F16;
+        case XK_F17:            return GLFW_KEY_F17;
+        case XK_F18:            return GLFW_KEY_F18;
+        case XK_F19:            return GLFW_KEY_F19;
+        case XK_F20:            return GLFW_KEY_F20;
+        case XK_F21:            return GLFW_KEY_F21;
+        case XK_F22:            return GLFW_KEY_F22;
+        case XK_F23:            return GLFW_KEY_F23;
+        case XK_F24:            return GLFW_KEY_F24;
+        case XK_F25:            return GLFW_KEY_F25;
+
+        // Numeric keypad
+        case XK_KP_Divide:      return GLFW_KEY_KP_DIVIDE;
+        case XK_KP_Multiply:    return GLFW_KEY_KP_MULTIPLY;
+        case XK_KP_Subtract:    return GLFW_KEY_KP_SUBTRACT;
+        case XK_KP_Add:         return GLFW_KEY_KP_ADD;
+
+        // These should have been detected in secondary keysym test above!
+        case XK_KP_Insert:      return GLFW_KEY_KP_0;
+        case XK_KP_End:         return GLFW_KEY_KP_1;
+        case XK_KP_Down:        return GLFW_KEY_KP_2;
+        case XK_KP_Page_Down:   return GLFW_KEY_KP_3;
+        case XK_KP_Left:        return GLFW_KEY_KP_4;
+        case XK_KP_Right:       return GLFW_KEY_KP_6;
+        case XK_KP_Home:        return GLFW_KEY_KP_7;
+        case XK_KP_Up:          return GLFW_KEY_KP_8;
+        case XK_KP_Page_Up:     return GLFW_KEY_KP_9;
+        case XK_KP_Delete:      return GLFW_KEY_KP_DECIMAL;
+        case XK_KP_Equal:       return GLFW_KEY_KP_EQUAL;
+        case XK_KP_Enter:       return GLFW_KEY_KP_ENTER;
+
+        // Last resort: Check for printable keys (should not happen if the XKB
+        // extension is available). This will give a layout dependent mapping
+        // (which is wrong, and we may miss some keys, especially on non-US
+        // keyboards), but it's better than nothing...
+        case XK_a:              return GLFW_KEY_A;
+        case XK_b:              return GLFW_KEY_B;
+        case XK_c:              return GLFW_KEY_C;
+        case XK_d:              return GLFW_KEY_D;
+        case XK_e:              return GLFW_KEY_E;
+        case XK_f:              return GLFW_KEY_F;
+        case XK_g:              return GLFW_KEY_G;
+        case XK_h:              return GLFW_KEY_H;
+        case XK_i:              return GLFW_KEY_I;
+        case XK_j:              return GLFW_KEY_J;
+        case XK_k:              return GLFW_KEY_K;
+        case XK_l:              return GLFW_KEY_L;
+        case XK_m:              return GLFW_KEY_M;
+        case XK_n:              return GLFW_KEY_N;
+        case XK_o:              return GLFW_KEY_O;
+        case XK_p:              return GLFW_KEY_P;
+        case XK_q:              return GLFW_KEY_Q;
+        case XK_r:              return GLFW_KEY_R;
+        case XK_s:              return GLFW_KEY_S;
+        case XK_t:              return GLFW_KEY_T;
+        case XK_u:              return GLFW_KEY_U;
+        case XK_v:              return GLFW_KEY_V;
+        case XK_w:              return GLFW_KEY_W;
+        case XK_x:              return GLFW_KEY_X;
+        case XK_y:              return GLFW_KEY_Y;
+        case XK_z:              return GLFW_KEY_Z;
+        case XK_1:              return GLFW_KEY_1;
+        case XK_2:              return GLFW_KEY_2;
+        case XK_3:              return GLFW_KEY_3;
+        case XK_4:              return GLFW_KEY_4;
+        case XK_5:              return GLFW_KEY_5;
+        case XK_6:              return GLFW_KEY_6;
+        case XK_7:              return GLFW_KEY_7;
+        case XK_8:              return GLFW_KEY_8;
+        case XK_9:              return GLFW_KEY_9;
+        case XK_0:              return GLFW_KEY_0;
+        case XK_space:          return GLFW_KEY_SPACE;
+        case XK_minus:          return GLFW_KEY_MINUS;
+        case XK_equal:          return GLFW_KEY_EQUAL;
+        case XK_bracketleft:    return GLFW_KEY_LEFT_BRACKET;
+        case XK_bracketright:   return GLFW_KEY_RIGHT_BRACKET;
+        case XK_backslash:      return GLFW_KEY_BACKSLASH;
+        case XK_semicolon:      return GLFW_KEY_SEMICOLON;
+        case XK_apostrophe:     return GLFW_KEY_APOSTROPHE;
+        case XK_grave:          return GLFW_KEY_GRAVE_ACCENT;
+        case XK_comma:          return GLFW_KEY_COMMA;
+        case XK_period:         return GLFW_KEY_PERIOD;
+        case XK_slash:          return GLFW_KEY_SLASH;
+        case XK_less:           return GLFW_KEY_WORLD_1; // At least in some layouts...
+        default:                break;
+    }
+
+    // No matching translation was found
+    return GLFW_KEY_UNKNOWN;
+}
+
+// Update the key code LUT
+//
+static void updateKeyCodeLUT(void)
+{
+    int i, keyCode, keyCodeGLFW;
+    char name[XkbKeyNameLength + 1];
+    XkbDescPtr descr;
+
+    // Clear the LUT
+    for (keyCode = 0;  keyCode < 256;  keyCode++)
+        _glfw.x11.keyCodeLUT[keyCode] = GLFW_KEY_UNKNOWN;
+
+    // Use XKB to determine physical key locations independently of the current
+    // keyboard layout
+
+    // Get keyboard description
+    descr = XkbGetKeyboard(_glfw.x11.display,
+                            XkbAllComponentsMask,
+                            XkbUseCoreKbd);
+
+    // Find the X11 key code -> GLFW key code mapping
+    for (keyCode = descr->min_key_code; keyCode <= descr->max_key_code; ++keyCode)
+    {
+        // Get the key name
+        for (i = 0;  i < XkbKeyNameLength;  i++)
+            name[i] = descr->names->keys[keyCode].name[i];
+
+        name[XkbKeyNameLength] = 0;
+
+        // Map the key name to a GLFW key code. Note: We only map printable
+        // keys here, and we use the US keyboard layout. The rest of the
+        // keys (function keys) are mapped using traditional KeySym
+        // translations.
+        if (strcmp(name, "TLDE") == 0) keyCodeGLFW = GLFW_KEY_GRAVE_ACCENT;
+        else if (strcmp(name, "AE01") == 0) keyCodeGLFW = GLFW_KEY_1;
+        else if (strcmp(name, "AE02") == 0) keyCodeGLFW = GLFW_KEY_2;
+        else if (strcmp(name, "AE03") == 0) keyCodeGLFW = GLFW_KEY_3;
+        else if (strcmp(name, "AE04") == 0) keyCodeGLFW = GLFW_KEY_4;
+        else if (strcmp(name, "AE05") == 0) keyCodeGLFW = GLFW_KEY_5;
+        else if (strcmp(name, "AE06") == 0) keyCodeGLFW = GLFW_KEY_6;
+        else if (strcmp(name, "AE07") == 0) keyCodeGLFW = GLFW_KEY_7;
+        else if (strcmp(name, "AE08") == 0) keyCodeGLFW = GLFW_KEY_8;
+        else if (strcmp(name, "AE09") == 0) keyCodeGLFW = GLFW_KEY_9;
+        else if (strcmp(name, "AE10") == 0) keyCodeGLFW = GLFW_KEY_0;
+        else if (strcmp(name, "AE11") == 0) keyCodeGLFW = GLFW_KEY_MINUS;
+        else if (strcmp(name, "AE12") == 0) keyCodeGLFW = GLFW_KEY_EQUAL;
+        else if (strcmp(name, "AD01") == 0) keyCodeGLFW = GLFW_KEY_Q;
+        else if (strcmp(name, "AD02") == 0) keyCodeGLFW = GLFW_KEY_W;
+        else if (strcmp(name, "AD03") == 0) keyCodeGLFW = GLFW_KEY_E;
+        else if (strcmp(name, "AD04") == 0) keyCodeGLFW = GLFW_KEY_R;
+        else if (strcmp(name, "AD05") == 0) keyCodeGLFW = GLFW_KEY_T;
+        else if (strcmp(name, "AD06") == 0) keyCodeGLFW = GLFW_KEY_Y;
+        else if (strcmp(name, "AD07") == 0) keyCodeGLFW = GLFW_KEY_U;
+        else if (strcmp(name, "AD08") == 0) keyCodeGLFW = GLFW_KEY_I;
+        else if (strcmp(name, "AD09") == 0) keyCodeGLFW = GLFW_KEY_O;
+        else if (strcmp(name, "AD10") == 0) keyCodeGLFW = GLFW_KEY_P;
+        else if (strcmp(name, "AD11") == 0) keyCodeGLFW = GLFW_KEY_LEFT_BRACKET;
+        else if (strcmp(name, "AD12") == 0) keyCodeGLFW = GLFW_KEY_RIGHT_BRACKET;
+        else if (strcmp(name, "AC01") == 0) keyCodeGLFW = GLFW_KEY_A;
+        else if (strcmp(name, "AC02") == 0) keyCodeGLFW = GLFW_KEY_S;
+        else if (strcmp(name, "AC03") == 0) keyCodeGLFW = GLFW_KEY_D;
+        else if (strcmp(name, "AC04") == 0) keyCodeGLFW = GLFW_KEY_F;
+        else if (strcmp(name, "AC05") == 0) keyCodeGLFW = GLFW_KEY_G;
+        else if (strcmp(name, "AC06") == 0) keyCodeGLFW = GLFW_KEY_H;
+        else if (strcmp(name, "AC07") == 0) keyCodeGLFW = GLFW_KEY_J;
+        else if (strcmp(name, "AC08") == 0) keyCodeGLFW = GLFW_KEY_K;
+        else if (strcmp(name, "AC09") == 0) keyCodeGLFW = GLFW_KEY_L;
+        else if (strcmp(name, "AC10") == 0) keyCodeGLFW = GLFW_KEY_SEMICOLON;
+        else if (strcmp(name, "AC11") == 0) keyCodeGLFW = GLFW_KEY_APOSTROPHE;
+        else if (strcmp(name, "AB01") == 0) keyCodeGLFW = GLFW_KEY_Z;
+        else if (strcmp(name, "AB02") == 0) keyCodeGLFW = GLFW_KEY_X;
+        else if (strcmp(name, "AB03") == 0) keyCodeGLFW = GLFW_KEY_C;
+        else if (strcmp(name, "AB04") == 0) keyCodeGLFW = GLFW_KEY_V;
+        else if (strcmp(name, "AB05") == 0) keyCodeGLFW = GLFW_KEY_B;
+        else if (strcmp(name, "AB06") == 0) keyCodeGLFW = GLFW_KEY_N;
+        else if (strcmp(name, "AB07") == 0) keyCodeGLFW = GLFW_KEY_M;
+        else if (strcmp(name, "AB08") == 0) keyCodeGLFW = GLFW_KEY_COMMA;
+        else if (strcmp(name, "AB09") == 0) keyCodeGLFW = GLFW_KEY_PERIOD;
+        else if (strcmp(name, "AB10") == 0) keyCodeGLFW = GLFW_KEY_SLASH;
+        else if (strcmp(name, "BKSL") == 0) keyCodeGLFW = GLFW_KEY_BACKSLASH;
+        else if (strcmp(name, "LSGT") == 0) keyCodeGLFW = GLFW_KEY_WORLD_1;
+        else keyCodeGLFW = GLFW_KEY_UNKNOWN;
+
+        // Update the key code LUT
+        if ((keyCode >= 0) && (keyCode < 256))
+            _glfw.x11.keyCodeLUT[keyCode] = keyCodeGLFW;
+    }
+
+    // Free the keyboard description
+    XkbFreeKeyboard(descr, 0, True);
+
+    // Translate the un-translated key codes using traditional X11 KeySym
+    // lookups
+    for (keyCode = 0;  keyCode < 256;  keyCode++)
+    {
+        if (_glfw.x11.keyCodeLUT[keyCode] < 0)
+            _glfw.x11.keyCodeLUT[keyCode] = translateKey(keyCode);
+    }
+}
+
+// Check whether the specified atom is supported
+//
+static Atom getSupportedAtom(Atom* supportedAtoms,
+                             unsigned long atomCount,
+                             const char* atomName)
+{
+    Atom atom = XInternAtom(_glfw.x11.display, atomName, True);
+    if (atom != None)
+    {
+        unsigned long i;
+
+        for (i = 0;  i < atomCount;  i++)
+        {
+            if (supportedAtoms[i] == atom)
+                return atom;
+        }
+    }
+
+    return None;
+}
+
+// Check whether the running window manager is EWMH-compliant
+//
+static void detectEWMH(void)
+{
+    Window* windowFromRoot = NULL;
+    Window* windowFromChild = NULL;
+
+    // First we need a couple of atoms, which should already be there
+    Atom supportingWmCheck =
+        XInternAtom(_glfw.x11.display, "_NET_SUPPORTING_WM_CHECK", True);
+    Atom wmSupported =
+        XInternAtom(_glfw.x11.display, "_NET_SUPPORTED", True);
+    if (supportingWmCheck == None || wmSupported == None)
+        return;
+
+    // Then we look for the _NET_SUPPORTING_WM_CHECK property of the root window
+    if (_glfwGetWindowProperty(_glfw.x11.root,
+                               supportingWmCheck,
+                               XA_WINDOW,
+                               (unsigned char**) &windowFromRoot) != 1)
+    {
+        XFree(windowFromRoot);
+        return;
+    }
+
+    // It should be the ID of a child window (of the root)
+    // Then we look for the same property on the child window
+    if (_glfwGetWindowProperty(*windowFromRoot,
+                               supportingWmCheck,
+                               XA_WINDOW,
+                               (unsigned char**) &windowFromChild) != 1)
+    {
+        XFree(windowFromRoot);
+        XFree(windowFromChild);
+        return;
+    }
+
+    // It should be the ID of that same child window
+    if (*windowFromRoot != *windowFromChild)
+    {
+        XFree(windowFromRoot);
+        XFree(windowFromChild);
+        return;
+    }
+
+    XFree(windowFromRoot);
+    XFree(windowFromChild);
+
+    // We are now fairly sure that an EWMH-compliant window manager is running
+
+    Atom* supportedAtoms;
+    unsigned long atomCount;
+
+    // Now we need to check the _NET_SUPPORTED property of the root window
+    // It should be a list of supported WM protocol and state atoms
+    atomCount = _glfwGetWindowProperty(_glfw.x11.root,
+                                       wmSupported,
+                                       XA_ATOM,
+                                       (unsigned char**) &supportedAtoms);
+
+    // See which of the atoms we support that are supported by the WM
+
+    _glfw.x11.NET_WM_STATE =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE");
+    _glfw.x11.NET_WM_STATE_FULLSCREEN =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_STATE_FULLSCREEN");
+    _glfw.x11.NET_WM_NAME =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_NAME");
+    _glfw.x11.NET_WM_ICON_NAME =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_ICON_NAME");
+    _glfw.x11.NET_WM_PID =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_PID");
+    _glfw.x11.NET_WM_PING =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_PING");
+    _glfw.x11.NET_ACTIVE_WINDOW =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_ACTIVE_WINDOW");
+    _glfw.x11.NET_WM_BYPASS_COMPOSITOR =
+        getSupportedAtom(supportedAtoms, atomCount, "_NET_WM_BYPASS_COMPOSITOR");
+
+    XFree(supportedAtoms);
+
+    _glfw.x11.hasEWMH = GL_TRUE;
+}
+
+// Initialize X11 display and look for supported X11 extensions
+//
+static GLboolean initExtensions(void)
+{
+    Bool supported;
+
+    // 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,
+                                             "WM_DELETE_WINDOW",
+                                             False);
+    _glfw.x11.MOTIF_WM_HINTS = XInternAtom(_glfw.x11.display,
+                                           "_MOTIF_WM_HINTS",
+                                           False);
+
+    // Check for XF86VidMode extension
+    _glfw.x11.vidmode.available =
+        XF86VidModeQueryExtension(_glfw.x11.display,
+                                  &_glfw.x11.vidmode.eventBase,
+                                  &_glfw.x11.vidmode.errorBase);
+
+    // Check for RandR extension
+    _glfw.x11.randr.available =
+        XRRQueryExtension(_glfw.x11.display,
+                          &_glfw.x11.randr.eventBase,
+                          &_glfw.x11.randr.errorBase);
+
+    if (_glfw.x11.randr.available)
+    {
+        if (!XRRQueryVersion(_glfw.x11.display,
+                             &_glfw.x11.randr.versionMajor,
+                             &_glfw.x11.randr.versionMinor))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "X11: Failed to query RandR version");
+            return GL_FALSE;
+        }
+
+        // The GLFW RandR path requires at least version 1.3
+        if (_glfw.x11.randr.versionMajor == 1 &&
+            _glfw.x11.randr.versionMinor < 3)
+        {
+            _glfw.x11.randr.available = GL_FALSE;
+        }
+    }
+
+    if (XQueryExtension(_glfw.x11.display,
+                        "XInputExtension",
+                        &_glfw.x11.xi.majorOpcode,
+                        &_glfw.x11.xi.eventBase,
+                        &_glfw.x11.xi.errorBase))
+    {
+        _glfw.x11.xi.versionMajor = 2;
+        _glfw.x11.xi.versionMinor = 0;
+
+        if (XIQueryVersion(_glfw.x11.display,
+                           &_glfw.x11.xi.versionMajor,
+                           &_glfw.x11.xi.versionMinor) != BadRequest)
+        {
+            _glfw.x11.xi.available = GL_TRUE;
+        }
+    }
+
+    // Check if Xkb is supported on this display
+    _glfw.x11.xkb.versionMajor = 1;
+    _glfw.x11.xkb.versionMinor = 0;
+    if (!XkbQueryExtension(_glfw.x11.display,
+                           &_glfw.x11.xkb.majorOpcode,
+                           &_glfw.x11.xkb.eventBase,
+                           &_glfw.x11.xkb.errorBase,
+                           &_glfw.x11.xkb.versionMajor,
+                           &_glfw.x11.xkb.versionMinor))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "X11: The keyboard extension is not available");
+        return GL_FALSE;
+    }
+
+    if (!XkbSetDetectableAutoRepeat(_glfw.x11.display, True, &supported))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "X11: Failed to set detectable key repeat");
+        return GL_FALSE;
+    }
+
+    if (!supported)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "X11: Detectable key repeat is not supported");
+        return GL_FALSE;
+    }
+
+    // Update the key code LUT
+    // FIXME: We should listen to XkbMapNotify events to track changes to
+    // the keyboard mapping.
+    updateKeyCodeLUT();
+
+    // Detect whether an EWMH-conformant window manager is running
+    detectEWMH();
+
+    // Find or create string format atoms
+    _glfw.x11.UTF8_STRING =
+        XInternAtom(_glfw.x11.display, "UTF8_STRING", False);
+    _glfw.x11.COMPOUND_STRING =
+        XInternAtom(_glfw.x11.display, "COMPOUND_STRING", False);
+    _glfw.x11.ATOM_PAIR = XInternAtom(_glfw.x11.display, "ATOM_PAIR", False);
+
+    // Find or create selection property atom
+    _glfw.x11.GLFW_SELECTION =
+        XInternAtom(_glfw.x11.display, "GLFW_SELECTION", False);
+
+    // Find or create standard clipboard atoms
+    _glfw.x11.TARGETS = XInternAtom(_glfw.x11.display, "TARGETS", False);
+    _glfw.x11.MULTIPLE = XInternAtom(_glfw.x11.display, "MULTIPLE", False);
+    _glfw.x11.CLIPBOARD = XInternAtom(_glfw.x11.display, "CLIPBOARD", False);
+
+    // Find or create clipboard manager atoms
+    _glfw.x11.CLIPBOARD_MANAGER =
+        XInternAtom(_glfw.x11.display, "CLIPBOARD_MANAGER", False);
+    _glfw.x11.SAVE_TARGETS =
+        XInternAtom(_glfw.x11.display, "SAVE_TARGETS", False);
+
+    return GL_TRUE;
+}
+
+// Create a blank cursor (for locked mouse mode)
+//
+static Cursor createNULLCursor(void)
+{
+    Pixmap cursormask;
+    XGCValues xgc;
+    GC gc;
+    XColor col;
+    Cursor cursor;
+
+    _glfwGrabXErrorHandler();
+
+    cursormask = XCreatePixmap(_glfw.x11.display, _glfw.x11.root, 1, 1, 1);
+    xgc.function = GXclear;
+    gc = XCreateGC(_glfw.x11.display, cursormask, GCFunction, &xgc);
+    XFillRectangle(_glfw.x11.display, cursormask, gc, 0, 0, 1, 1);
+    col.pixel = 0;
+    col.red = 0;
+    col.flags = 4;
+    cursor = XCreatePixmapCursor(_glfw.x11.display,
+                                 cursormask, cursormask,
+                                 &col, &col, 0, 0);
+    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;
+}
+
+// Terminate X11 display
+//
+static void terminateDisplay(void)
+{
+    if (_glfw.x11.display)
+    {
+        XCloseDisplay(_glfw.x11.display);
+        _glfw.x11.display = NULL;
+    }
+}
+
+// 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                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformInit(void)
+{
+    XInitThreads();
+
+    _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();
+
+    if (!initExtensions())
+        return GL_FALSE;
+
+    _glfw.x11.cursor = createNULLCursor();
+
+    if (!_glfwInitContextAPI())
+        return GL_FALSE;
+
+    _glfwInitTimer();
+    _glfwInitJoysticks();
+    _glfwInitGammaRamp();
+
+    return GL_TRUE;
+}
+
+void _glfwPlatformTerminate(void)
+{
+    if (_glfw.x11.cursor)
+    {
+        XFreeCursor(_glfw.x11.display, _glfw.x11.cursor);
+        _glfw.x11.cursor = (Cursor) 0;
+    }
+
+    free(_glfw.x11.selection.string);
+
+    _glfwTerminateJoysticks();
+    _glfwTerminateContextAPI();
+    terminateDisplay();
+}
+
+const char* _glfwPlatformGetVersionString(void)
+{
+    const char* version = _GLFW_VERSION_NUMBER " X11"
+#if defined(_GLFW_GLX)
+        " GLX"
+#elif defined(_GLFW_EGL)
+        " EGL"
+#endif
+#if defined(_GLFW_HAS_GLXGETPROCADDRESS)
+        " glXGetProcAddress"
+#elif defined(_GLFW_HAS_GLXGETPROCADDRESSARB)
+        " glXGetProcAddressARB"
+#elif defined(_GLFW_HAS_GLXGETPROCADDRESSEXT)
+        " glXGetProcAddressEXT"
+#elif defined(_GLFW_DLOPEN_LIBGL)
+        " dlsym(libGL)"
+#endif
+#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
+        " clock_gettime"
+#endif
+#if defined(__linux__)
+        " /dev/js"
+#endif
+#if defined(_GLFW_BUILD_DLL)
+        " shared"
+#endif
+        ;
+
+    return version;
+}
+

libs/glfw-3.0.4/src/x11_joystick.c

@@ -0,0 +1,259 @@
+//========================================================================
+// GLFW 3.0 X11 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#ifdef __linux__
+#include <linux/joystick.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <regex.h>
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#endif // __linux__
+
+
+// Attempt to open the specified joystick device
+//
+static int openJoystickDevice(int joy, const char* path)
+{
+#ifdef __linux__
+    char axisCount, buttonCount;
+    char name[256];
+    int fd, version;
+
+    fd = open(path, O_RDONLY | O_NONBLOCK);
+    if (fd == -1)
+        return GL_FALSE;
+
+    _glfw.x11.joystick[joy].fd = fd;
+
+    // Verify that the joystick driver version is at least 1.0
+    ioctl(fd, JSIOCGVERSION, &version);
+    if (version < 0x010000)
+    {
+        // It's an old 0.x interface (we don't support it)
+        close(fd);
+        return GL_FALSE;
+    }
+
+    if (ioctl(fd, JSIOCGNAME(sizeof(name)), name) < 0)
+        strncpy(name, "Unknown", sizeof(name));
+
+    _glfw.x11.joystick[joy].name = strdup(name);
+
+    ioctl(fd, JSIOCGAXES, &axisCount);
+    _glfw.x11.joystick[joy].axisCount = (int) axisCount;
+
+    ioctl(fd, JSIOCGBUTTONS, &buttonCount);
+    _glfw.x11.joystick[joy].buttonCount = (int) buttonCount;
+
+    _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__
+
+    return GL_TRUE;
+}
+
+// Polls for and processes events for all present joysticks
+//
+static void pollJoystickEvents(void)
+{
+#ifdef __linux__
+    int i;
+    ssize_t result;
+    struct js_event e;
+
+    for (i = 0;  i <= GLFW_JOYSTICK_LAST;  i++)
+    {
+        if (!_glfw.x11.joystick[i].present)
+            continue;
+
+        // Read all queued events (non-blocking)
+        for (;;)
+        {
+            errno = 0;
+            result = read(_glfw.x11.joystick[i].fd, &e, sizeof(e));
+
+            if (errno == ENODEV)
+            {
+                free(_glfw.x11.joystick[i].axes);
+                free(_glfw.x11.joystick[i].buttons);
+                free(_glfw.x11.joystick[i].name);
+                _glfw.x11.joystick[i].present = GL_FALSE;
+            }
+
+            if (result == -1)
+                break;
+
+            // We don't care if it's an init event or not
+            e.type &= ~JS_EVENT_INIT;
+
+            switch (e.type)
+            {
+                case JS_EVENT_AXIS:
+                    _glfw.x11.joystick[i].axes[e.number] =
+                        (float) e.value / 32767.0f;
+                    break;
+
+                case JS_EVENT_BUTTON:
+                    _glfw.x11.joystick[i].buttons[e.number] =
+                        e.value ? GLFW_PRESS : GLFW_RELEASE;
+                    break;
+
+                default:
+                    break;
+            }
+        }
+    }
+#endif // __linux__
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialize joystick interface
+//
+void _glfwInitJoysticks(void)
+{
+#ifdef __linux__
+    int joy = 0;
+    size_t i;
+    regex_t regex;
+    DIR* dir;
+    const char* dirs[] =
+    {
+        "/dev/input",
+        "/dev"
+    };
+
+    if (regcomp(&regex, "^js[0-9]\\+$", 0) != 0)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to compile regex");
+        return;
+    }
+
+    for (i = 0;  i < sizeof(dirs) / sizeof(dirs[0]);  i++)
+    {
+        struct dirent* entry;
+
+        dir = opendir(dirs[i]);
+        if (!dir)
+            continue;
+
+        while ((entry = readdir(dir)))
+        {
+            char path[20];
+            regmatch_t match;
+
+            if (regexec(&regex, entry->d_name, 1, &match, 0) != 0)
+                continue;
+
+            snprintf(path, sizeof(path), "%s/%s", dirs[i], entry->d_name);
+            if (openJoystickDevice(joy, path))
+                joy++;
+        }
+
+        closedir(dir);
+    }
+
+    regfree(&regex);
+#endif // __linux__
+}
+
+// Close all opened joystick handles
+//
+void _glfwTerminateJoysticks(void)
+{
+#ifdef __linux__
+    int i;
+
+    for (i = 0;  i <= GLFW_JOYSTICK_LAST;  i++)
+    {
+        if (_glfw.x11.joystick[i].present)
+        {
+            close(_glfw.x11.joystick[i].fd);
+            free(_glfw.x11.joystick[i].axes);
+            free(_glfw.x11.joystick[i].buttons);
+            free(_glfw.x11.joystick[i].name);
+
+            _glfw.x11.joystick[i].present = GL_FALSE;
+        }
+    }
+#endif // __linux__
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformJoystickPresent(int joy)
+{
+    pollJoystickEvents();
+
+    return _glfw.x11.joystick[joy].present;
+}
+
+const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+{
+    pollJoystickEvents();
+
+    if (!_glfw.x11.joystick[joy].present)
+        return NULL;
+
+    *count = _glfw.x11.joystick[joy].axisCount;
+    return _glfw.x11.joystick[joy].axes;
+}
+
+const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
+{
+    pollJoystickEvents();
+
+    if (!_glfw.x11.joystick[joy].present)
+        return NULL;
+
+    *count = _glfw.x11.joystick[joy].buttonCount;
+    return _glfw.x11.joystick[joy].buttons;
+}
+
+const char* _glfwPlatformGetJoystickName(int joy)
+{
+    pollJoystickEvents();
+
+    return _glfw.x11.joystick[joy].name;
+}
+

libs/glfw-3.0.4/src/x11_monitor.c

@@ -0,0 +1,404 @@
+//========================================================================
+// GLFW 3.0 X11 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+static int calculateRefreshRate(const XRRModeInfo* mi)
+{
+    if (!mi->hTotal || !mi->vTotal)
+        return 0;
+
+    return (int) ((double) mi->dotClock / ((double) mi->hTotal * (double) mi->vTotal));
+}
+
+static const XRRModeInfo* getModeInfo(const XRRScreenResources* sr, RRMode id)
+{
+    int i;
+
+    for (i = 0;  i < sr->nmode;  i++)
+    {
+        if (sr->modes[i].id == id)
+            return sr->modes + i;
+    }
+
+    return NULL;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Set the current video mode for the specified monitor
+//
+void _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
+{
+    if (_glfw.x11.randr.available)
+    {
+        int i, j;
+        XRRScreenResources* sr;
+        XRRCrtcInfo* ci;
+        XRROutputInfo* oi;
+        RRMode bestMode = 0;
+        unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
+        unsigned int rateDiff, leastRateDiff = UINT_MAX;
+
+        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
+        oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
+
+        for (i = 0;  i < sr->nmode;  i++)
+        {
+            const XRRModeInfo* mi = sr->modes + i;
+
+            if (mi->modeFlags & RR_Interlace)
+                continue;
+
+            for (j = 0;  j < oi->nmode;  j++)
+            {
+                if (oi->modes[j] == mi->id)
+                    break;
+            }
+
+            if (j == oi->nmode)
+                continue;
+
+            sizeDiff = (mi->width - desired->width) *
+                       (mi->width - desired->width) +
+                       (mi->height - desired->height) *
+                       (mi->height - desired->height);
+
+            if (desired->refreshRate)
+                rateDiff = abs(calculateRefreshRate(mi) - desired->refreshRate);
+            else
+                rateDiff = UINT_MAX - calculateRefreshRate(mi);
+
+            if ((sizeDiff < leastSizeDiff) ||
+                (sizeDiff == leastSizeDiff && rateDiff < leastRateDiff))
+            {
+                bestMode = mi->id;
+                leastSizeDiff = sizeDiff;
+                leastRateDiff = rateDiff;
+            }
+        }
+
+        if (bestMode == ci->mode)
+            return;
+
+        if (monitor->x11.oldMode == None)
+            monitor->x11.oldMode = ci->mode;
+
+        XRRSetCrtcConfig(_glfw.x11.display,
+                         sr, monitor->x11.crtc,
+                         CurrentTime,
+                         ci->x, ci->y,
+                         bestMode,
+                         ci->rotation,
+                         ci->outputs,
+                         ci->noutput);
+
+        XRRFreeOutputInfo(oi);
+        XRRFreeCrtcInfo(ci);
+        XRRFreeScreenResources(sr);
+    }
+}
+
+// Restore the saved (original) video mode for the specified monitor
+//
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
+{
+    if (_glfw.x11.randr.available)
+    {
+        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);
+
+        XRRSetCrtcConfig(_glfw.x11.display,
+                         sr, monitor->x11.crtc,
+                         CurrentTime,
+                         ci->x, ci->y,
+                         monitor->x11.oldMode,
+                         ci->rotation,
+                         ci->outputs,
+                         ci->noutput);
+
+        XRRFreeCrtcInfo(ci);
+        XRRFreeScreenResources(sr);
+
+        monitor->x11.oldMode = None;
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
+{
+    _GLFWmonitor** monitors = NULL;
+
+    *count = 0;
+
+    if (_glfw.x11.randr.available)
+    {
+        int i, found = 0;
+        RROutput primary;
+        XRRScreenResources* sr;
+
+        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        primary = XRRGetOutputPrimary(_glfw.x11.display, _glfw.x11.root);
+
+        monitors = calloc(sr->ncrtc, sizeof(_GLFWmonitor*));
+
+        for (i = 0;  i < sr->ncrtc;  i++)
+        {
+            int j;
+            XRROutputInfo* oi;
+            XRRCrtcInfo* ci;
+            RROutput output;
+
+            ci = XRRGetCrtcInfo(_glfw.x11.display, sr, sr->crtcs[i]);
+            if (ci->noutput == 0)
+            {
+                XRRFreeCrtcInfo(ci);
+                continue;
+            }
+
+            output = ci->outputs[0];
+
+            for (j = 0;  j < ci->noutput;  j++)
+            {
+                if (ci->outputs[j] == primary)
+                {
+                    output = primary;
+                    break;
+                }
+            }
+
+            oi = XRRGetOutputInfo(_glfw.x11.display, sr, output);
+            if (oi->connection != RR_Connected)
+            {
+                XRRFreeOutputInfo(oi);
+                XRRFreeCrtcInfo(ci);
+                continue;
+            }
+
+            monitors[found] = _glfwCreateMonitor(oi->name,
+                                                 oi->mm_width, oi->mm_height);
+
+            monitors[found]->x11.output = output;
+            monitors[found]->x11.crtc   = oi->crtc;
+
+            XRRFreeOutputInfo(oi);
+            XRRFreeCrtcInfo(ci);
+
+            found++;
+        }
+
+        XRRFreeScreenResources(sr);
+
+        for (i = 0;  i < found;  i++)
+        {
+            if (monitors[i]->x11.output == primary)
+            {
+                _GLFWmonitor* temp = monitors[0];
+                monitors[0] = monitors[i];
+                monitors[i] = temp;
+                break;
+            }
+        }
+
+        if (found == 0)
+        {
+            free(monitors);
+            monitors = NULL;
+        }
+
+        *count = found;
+    }
+    else
+    {
+        monitors = calloc(1, sizeof(_GLFWmonitor*));
+        monitors[0] = _glfwCreateMonitor("Display",
+                                         DisplayWidthMM(_glfw.x11.display,
+                                                        _glfw.x11.screen),
+                                         DisplayHeightMM(_glfw.x11.display,
+                                                         _glfw.x11.screen));
+        *count = 1;
+    }
+
+    return monitors;
+}
+
+GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
+{
+    return first->x11.crtc == second->x11.crtc;
+}
+
+void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
+{
+    if (_glfw.x11.randr.available)
+    {
+        XRRScreenResources* sr;
+        XRRCrtcInfo* ci;
+
+        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
+
+        if (xpos)
+            *xpos = ci->x;
+        if (ypos)
+            *ypos = ci->y;
+
+        XRRFreeCrtcInfo(ci);
+        XRRFreeScreenResources(sr);
+    }
+    else
+    {
+        if (xpos)
+            *xpos = 0;
+        if (ypos)
+            *ypos = 0;
+    }
+}
+
+GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
+{
+    GLFWvidmode* result;
+    int depth, r, g, b;
+
+    depth = DefaultDepth(_glfw.x11.display, _glfw.x11.screen);
+    _glfwSplitBPP(depth, &r, &g, &b);
+
+    *found = 0;
+
+    // Build array of available resolutions
+
+    if (_glfw.x11.randr.available)
+    {
+        int i, j;
+        XRRScreenResources* sr;
+        XRROutputInfo* oi;
+
+        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
+
+        result = calloc(oi->nmode, sizeof(GLFWvidmode));
+
+        for (i = 0;  i < oi->nmode;  i++)
+        {
+            GLFWvidmode mode;
+            const XRRModeInfo* mi = getModeInfo(sr, oi->modes[i]);
+
+            mode.width  = mi->width;
+            mode.height = mi->height;
+            mode.refreshRate = calculateRefreshRate(mi);
+
+            for (j = 0;  j < *found;  j++)
+            {
+                if (result[j].width == mode.width &&
+                    result[j].height == mode.height &&
+                    result[j].refreshRate == mode.refreshRate)
+                {
+                    break;
+                }
+            }
+
+            if (j < *found)
+            {
+                // This is a duplicate, so skip it
+                continue;
+            }
+
+            mode.redBits = r;
+            mode.greenBits = g;
+            mode.blueBits = b;
+
+            result[*found] = mode;
+            (*found)++;
+        }
+
+        XRRFreeOutputInfo(oi);
+        XRRFreeScreenResources(sr);
+    }
+    else
+    {
+        *found = 1;
+
+        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);
+        result[0].redBits = r;
+        result[0].greenBits = g;
+        result[0].blueBits = b;
+        result[0].refreshRate = 0;
+    }
+
+    return result;
+}
+
+void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
+{
+    if (_glfw.x11.randr.available)
+    {
+        XRRScreenResources* sr;
+        XRRCrtcInfo* ci;
+
+        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
+
+        mode->width = ci->width;
+        mode->height = ci->height;
+
+        mode->refreshRate = calculateRefreshRate(getModeInfo(sr, ci->mode));
+
+        XRRFreeCrtcInfo(ci);
+        XRRFreeScreenResources(sr);
+    }
+    else
+    {
+        mode->width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
+        mode->height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
+        mode->refreshRate = 0;
+    }
+
+    _glfwSplitBPP(DefaultDepth(_glfw.x11.display, _glfw.x11.screen),
+                  &mode->redBits, &mode->greenBits, &mode->blueBits);
+}
+

libs/glfw-3.0.4/src/x11_platform.h

@@ -0,0 +1,265 @@
+//========================================================================
+// GLFW 3.0 X11 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _x11_platform_h_
+#define _x11_platform_h_
+
+#include <unistd.h>
+#include <signal.h>
+#include <stdint.h>
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+#include <X11/Xatom.h>
+
+// The Xf86VidMode extension provides fallback gamma control
+#include <X11/extensions/xf86vmode.h>
+
+// The XRandR extension provides mode setting and gamma control
+#include <X11/extensions/Xrandr.h>
+
+// The XInput2 extension provides improved input events
+#include <X11/extensions/XInput2.h>
+
+// The Xkb extension provides improved keyboard support
+#include <X11/XKBlib.h>
+
+#if defined(_GLFW_GLX)
+ #define _GLFW_X11_CONTEXT_VISUAL window->glx.visual
+ #include "glx_platform.h"
+#elif defined(_GLFW_EGL)
+ #define _GLFW_X11_CONTEXT_VISUAL window->egl.visual
+ #define _GLFW_EGL_NATIVE_WINDOW  window->x11.handle
+ #define _GLFW_EGL_NATIVE_DISPLAY _glfw.x11.display
+ #include "egl_platform.h"
+#else
+ #error "No supported context creation API selected"
+#endif
+
+#define _GLFW_PLATFORM_WINDOW_STATE         _GLFWwindowX11  x11
+#define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE _GLFWlibraryX11 x11
+#define _GLFW_PLATFORM_MONITOR_STATE        _GLFWmonitorX11 x11
+
+
+//========================================================================
+// GLFW platform specific types
+//========================================================================
+
+
+//------------------------------------------------------------------------
+// Platform-specific window structure
+//------------------------------------------------------------------------
+typedef struct _GLFWwindowX11
+{
+    // Platform specific window resources
+    Colormap        colormap;          // Window colormap
+    Window          handle;            // Window handle
+
+    // Various platform specific internal variables
+    GLboolean       overrideRedirect; // True if window is OverrideRedirect
+    GLboolean       cursorGrabbed;    // True if cursor is currently grabbed
+    GLboolean       cursorHidden;     // True if cursor is currently hidden
+
+    // Cached position and size used to filter out duplicate events
+    int             width, height;
+    int             xpos, ypos;
+
+    // The last received cursor position, regardless of source
+    double          cursorPosX, cursorPosY;
+    // The last position the cursor was warped to by GLFW
+    int             warpPosX, warpPosY;
+
+} _GLFWwindowX11;
+
+
+//------------------------------------------------------------------------
+// Platform-specific library global data for X11
+//------------------------------------------------------------------------
+typedef struct _GLFWlibraryX11
+{
+    Display*        display;
+    int             screen;
+    Window          root;
+
+    // Invisible cursor for hidden cursor mode
+    Cursor          cursor;
+    XContext        context;
+
+    // Window manager atoms
+    Atom            WM_STATE;
+    Atom            WM_DELETE_WINDOW;
+    Atom            NET_WM_NAME;
+    Atom            NET_WM_ICON_NAME;
+    Atom            NET_WM_PID;
+    Atom            NET_WM_PING;
+    Atom            NET_WM_STATE;
+    Atom            NET_WM_STATE_FULLSCREEN;
+    Atom            NET_WM_BYPASS_COMPOSITOR;
+    Atom            NET_ACTIVE_WINDOW;
+    Atom            MOTIF_WM_HINTS;
+
+    // Selection atoms
+    Atom            TARGETS;
+    Atom            MULTIPLE;
+    Atom            CLIPBOARD;
+    Atom            CLIPBOARD_MANAGER;
+    Atom            SAVE_TARGETS;
+    Atom            UTF8_STRING;
+    Atom            COMPOUND_STRING;
+    Atom            ATOM_PAIR;
+    Atom            GLFW_SELECTION;
+
+    // True if window manager supports EWMH
+    GLboolean       hasEWMH;
+
+    // Error code received by the X error handler
+    int             errorCode;
+
+    struct {
+        GLboolean   available;
+        int         eventBase;
+        int         errorBase;
+    } vidmode;
+
+    struct {
+        GLboolean   available;
+        int         eventBase;
+        int         errorBase;
+        int         versionMajor;
+        int         versionMinor;
+        GLboolean   gammaBroken;
+    } randr;
+
+    struct {
+        int         majorOpcode;
+        int         eventBase;
+        int         errorBase;
+        int         versionMajor;
+        int         versionMinor;
+    } xkb;
+
+    struct {
+        GLboolean   available;
+        int         majorOpcode;
+        int         eventBase;
+        int         errorBase;
+        int         versionMajor;
+        int         versionMinor;
+    } xi;
+
+    // LUT for mapping X11 key codes to GLFW key codes
+    int             keyCodeLUT[256];
+
+    struct {
+        int         count;
+        int         timeout;
+        int         interval;
+        int         blanking;
+        int         exposure;
+    } saver;
+
+    struct {
+        GLboolean   monotonic;
+        double      resolution;
+        uint64_t    base;
+    } timer;
+
+    struct {
+        char*       string;
+    } selection;
+
+    struct {
+        int         present;
+        int         fd;
+        float*      axes;
+        int         axisCount;
+        unsigned char* buttons;
+        int         buttonCount;
+        char*       name;
+    } joystick[GLFW_JOYSTICK_LAST + 1];
+
+} _GLFWlibraryX11;
+
+
+//------------------------------------------------------------------------
+// Platform-specific monitor structure
+//------------------------------------------------------------------------
+typedef struct _GLFWmonitorX11
+{
+    RROutput        output;
+    RRCrtc          crtc;
+    RRMode          oldMode;
+
+} _GLFWmonitorX11;
+
+
+//========================================================================
+// Prototypes for platform specific internal functions
+//========================================================================
+
+// Time
+void _glfwInitTimer(void);
+
+// Gamma
+void _glfwInitGammaRamp(void);
+
+// OpenGL support
+int _glfwInitContextAPI(void);
+void _glfwTerminateContextAPI(void);
+int _glfwCreateContext(_GLFWwindow* window,
+                       const _GLFWwndconfig* wndconfig,
+                       const _GLFWfbconfig* fbconfig);
+void _glfwDestroyContext(_GLFWwindow* window);
+
+// Fullscreen support
+void _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired);
+void _glfwRestoreVideoMode(_GLFWmonitor* monitor);
+
+// Joystick input
+void _glfwInitJoysticks(void);
+void _glfwTerminateJoysticks(void);
+
+// Unicode support
+long _glfwKeySym2Unicode(KeySym keysym);
+
+// Clipboard handling
+void _glfwHandleSelectionClear(XEvent* event);
+void _glfwHandleSelectionRequest(XEvent* event);
+void _glfwPushSelectionToManager(_GLFWwindow* window);
+
+// Window support
+_GLFWwindow* _glfwFindWindowByHandle(Window handle);
+unsigned long _glfwGetWindowProperty(Window window,
+                                     Atom property,
+                                     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_

libs/glfw-3.0.4/src/x11_time.c

@@ -0,0 +1,98 @@
+//========================================================================
+// GLFW 3.0 X11 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+#include <sys/time.h>
+#include <time.h>
+
+
+// Return raw time
+//
+static uint64_t getRawTime(void)
+{
+#if defined(CLOCK_MONOTONIC)
+    if (_glfw.x11.timer.monotonic)
+    {
+        struct timespec ts;
+
+        clock_gettime(CLOCK_MONOTONIC, &ts);
+        return (uint64_t) ts.tv_sec * (uint64_t) 1000000000 + (uint64_t) ts.tv_nsec;
+    }
+    else
+#endif
+    {
+        struct timeval tv;
+
+        gettimeofday(&tv, NULL);
+        return (uint64_t) tv.tv_sec * (uint64_t) 1000000 + (uint64_t) tv.tv_usec;
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Initialise timer
+//
+void _glfwInitTimer(void)
+{
+#if defined(CLOCK_MONOTONIC)
+    struct timespec ts;
+
+    if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
+    {
+        _glfw.x11.timer.monotonic = GL_TRUE;
+        _glfw.x11.timer.resolution = 1e-9;
+    }
+    else
+#endif
+    {
+        _glfw.x11.timer.resolution = 1e-6;
+    }
+
+    _glfw.x11.timer.base = getRawTime();
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+double _glfwPlatformGetTime(void)
+{
+    return (double) (getRawTime() - _glfw.x11.timer.base) *
+        _glfw.x11.timer.resolution;
+}
+
+void _glfwPlatformSetTime(double time)
+{
+    _glfw.x11.timer.base = getRawTime() -
+        (uint64_t) (time / _glfw.x11.timer.resolution);
+}
+

libs/glfw-3.0.4/src/x11_unicode.c

@@ -0,0 +1,891 @@
+//========================================================================
+// GLFW 3.0 X11 - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2002-2006 Marcus Geelnard
+// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+/*
+ * Marcus: This code was originally written by Markus G. Kuhn.
+ * I have made some slight changes (trimmed it down a bit from >60 KB to
+ * 20 KB), but the functionality is the same.
+ */
+
+/*
+ * This module converts keysym values into the corresponding ISO 10646
+ * (UCS, Unicode) values.
+ *
+ * The array keysymtab[] contains pairs of X11 keysym values for graphical
+ * characters and the corresponding Unicode value. The function
+ * _glfwKeySym2Unicode() maps a keysym onto a Unicode value using a binary
+ * search, therefore keysymtab[] must remain SORTED by keysym value.
+ *
+ * We allow to represent any UCS character in the range U-00000000 to
+ * U-00FFFFFF by a keysym value in the range 0x01000000 to 0x01ffffff.
+ * This admittedly does not cover the entire 31-bit space of UCS, but
+ * it does cover all of the characters up to U-10FFFF, which can be
+ * represented by UTF-16, and more, and it is very unlikely that higher
+ * UCS codes will ever be assigned by ISO. So to get Unicode character
+ * U+ABCD you can directly use keysym 0x0100abcd.
+ *
+ * Original author: Markus G. Kuhn <mkuhn@acm.org>, University of
+ *                  Cambridge, April 2001
+ *
+ * Special thanks to Richard Verhoeven <river@win.tue.nl> for preparing
+ * an initial draft of the mapping table.
+ *
+ */
+
+
+//************************************************************************
+//****                KeySym to Unicode mapping table                 ****
+//************************************************************************
+
+static struct codepair {
+  unsigned short keysym;
+  unsigned short ucs;
+} keysymtab[] = {
+  { 0x01a1, 0x0104 },
+  { 0x01a2, 0x02d8 },
+  { 0x01a3, 0x0141 },
+  { 0x01a5, 0x013d },
+  { 0x01a6, 0x015a },
+  { 0x01a9, 0x0160 },
+  { 0x01aa, 0x015e },
+  { 0x01ab, 0x0164 },
+  { 0x01ac, 0x0179 },
+  { 0x01ae, 0x017d },
+  { 0x01af, 0x017b },
+  { 0x01b1, 0x0105 },
+  { 0x01b2, 0x02db },
+  { 0x01b3, 0x0142 },
+  { 0x01b5, 0x013e },
+  { 0x01b6, 0x015b },
+  { 0x01b7, 0x02c7 },
+  { 0x01b9, 0x0161 },
+  { 0x01ba, 0x015f },
+  { 0x01bb, 0x0165 },
+  { 0x01bc, 0x017a },
+  { 0x01bd, 0x02dd },
+  { 0x01be, 0x017e },
+  { 0x01bf, 0x017c },
+  { 0x01c0, 0x0154 },
+  { 0x01c3, 0x0102 },
+  { 0x01c5, 0x0139 },
+  { 0x01c6, 0x0106 },
+  { 0x01c8, 0x010c },
+  { 0x01ca, 0x0118 },
+  { 0x01cc, 0x011a },
+  { 0x01cf, 0x010e },
+  { 0x01d0, 0x0110 },
+  { 0x01d1, 0x0143 },
+  { 0x01d2, 0x0147 },
+  { 0x01d5, 0x0150 },
+  { 0x01d8, 0x0158 },
+  { 0x01d9, 0x016e },
+  { 0x01db, 0x0170 },
+  { 0x01de, 0x0162 },
+  { 0x01e0, 0x0155 },
+  { 0x01e3, 0x0103 },
+  { 0x01e5, 0x013a },
+  { 0x01e6, 0x0107 },
+  { 0x01e8, 0x010d },
+  { 0x01ea, 0x0119 },
+  { 0x01ec, 0x011b },
+  { 0x01ef, 0x010f },
+  { 0x01f0, 0x0111 },
+  { 0x01f1, 0x0144 },
+  { 0x01f2, 0x0148 },
+  { 0x01f5, 0x0151 },
+  { 0x01f8, 0x0159 },
+  { 0x01f9, 0x016f },
+  { 0x01fb, 0x0171 },
+  { 0x01fe, 0x0163 },
+  { 0x01ff, 0x02d9 },
+  { 0x02a1, 0x0126 },
+  { 0x02a6, 0x0124 },
+  { 0x02a9, 0x0130 },
+  { 0x02ab, 0x011e },
+  { 0x02ac, 0x0134 },
+  { 0x02b1, 0x0127 },
+  { 0x02b6, 0x0125 },
+  { 0x02b9, 0x0131 },
+  { 0x02bb, 0x011f },
+  { 0x02bc, 0x0135 },
+  { 0x02c5, 0x010a },
+  { 0x02c6, 0x0108 },
+  { 0x02d5, 0x0120 },
+  { 0x02d8, 0x011c },
+  { 0x02dd, 0x016c },
+  { 0x02de, 0x015c },
+  { 0x02e5, 0x010b },
+  { 0x02e6, 0x0109 },
+  { 0x02f5, 0x0121 },
+  { 0x02f8, 0x011d },
+  { 0x02fd, 0x016d },
+  { 0x02fe, 0x015d },
+  { 0x03a2, 0x0138 },
+  { 0x03a3, 0x0156 },
+  { 0x03a5, 0x0128 },
+  { 0x03a6, 0x013b },
+  { 0x03aa, 0x0112 },
+  { 0x03ab, 0x0122 },
+  { 0x03ac, 0x0166 },
+  { 0x03b3, 0x0157 },
+  { 0x03b5, 0x0129 },
+  { 0x03b6, 0x013c },
+  { 0x03ba, 0x0113 },
+  { 0x03bb, 0x0123 },
+  { 0x03bc, 0x0167 },
+  { 0x03bd, 0x014a },
+  { 0x03bf, 0x014b },
+  { 0x03c0, 0x0100 },
+  { 0x03c7, 0x012e },
+  { 0x03cc, 0x0116 },
+  { 0x03cf, 0x012a },
+  { 0x03d1, 0x0145 },
+  { 0x03d2, 0x014c },
+  { 0x03d3, 0x0136 },
+  { 0x03d9, 0x0172 },
+  { 0x03dd, 0x0168 },
+  { 0x03de, 0x016a },
+  { 0x03e0, 0x0101 },
+  { 0x03e7, 0x012f },
+  { 0x03ec, 0x0117 },
+  { 0x03ef, 0x012b },
+  { 0x03f1, 0x0146 },
+  { 0x03f2, 0x014d },
+  { 0x03f3, 0x0137 },
+  { 0x03f9, 0x0173 },
+  { 0x03fd, 0x0169 },
+  { 0x03fe, 0x016b },
+  { 0x047e, 0x203e },
+  { 0x04a1, 0x3002 },
+  { 0x04a2, 0x300c },
+  { 0x04a3, 0x300d },
+  { 0x04a4, 0x3001 },
+  { 0x04a5, 0x30fb },
+  { 0x04a6, 0x30f2 },
+  { 0x04a7, 0x30a1 },
+  { 0x04a8, 0x30a3 },
+  { 0x04a9, 0x30a5 },
+  { 0x04aa, 0x30a7 },
+  { 0x04ab, 0x30a9 },
+  { 0x04ac, 0x30e3 },
+  { 0x04ad, 0x30e5 },
+  { 0x04ae, 0x30e7 },
+  { 0x04af, 0x30c3 },
+  { 0x04b0, 0x30fc },
+  { 0x04b1, 0x30a2 },
+  { 0x04b2, 0x30a4 },
+  { 0x04b3, 0x30a6 },
+  { 0x04b4, 0x30a8 },
+  { 0x04b5, 0x30aa },
+  { 0x04b6, 0x30ab },
+  { 0x04b7, 0x30ad },
+  { 0x04b8, 0x30af },
+  { 0x04b9, 0x30b1 },
+  { 0x04ba, 0x30b3 },
+  { 0x04bb, 0x30b5 },
+  { 0x04bc, 0x30b7 },
+  { 0x04bd, 0x30b9 },
+  { 0x04be, 0x30bb },
+  { 0x04bf, 0x30bd },
+  { 0x04c0, 0x30bf },
+  { 0x04c1, 0x30c1 },
+  { 0x04c2, 0x30c4 },
+  { 0x04c3, 0x30c6 },
+  { 0x04c4, 0x30c8 },
+  { 0x04c5, 0x30ca },
+  { 0x04c6, 0x30cb },
+  { 0x04c7, 0x30cc },
+  { 0x04c8, 0x30cd },
+  { 0x04c9, 0x30ce },
+  { 0x04ca, 0x30cf },
+  { 0x04cb, 0x30d2 },
+  { 0x04cc, 0x30d5 },
+  { 0x04cd, 0x30d8 },
+  { 0x04ce, 0x30db },
+  { 0x04cf, 0x30de },
+  { 0x04d0, 0x30df },
+  { 0x04d1, 0x30e0 },
+  { 0x04d2, 0x30e1 },
+  { 0x04d3, 0x30e2 },
+  { 0x04d4, 0x30e4 },
+  { 0x04d5, 0x30e6 },
+  { 0x04d6, 0x30e8 },
+  { 0x04d7, 0x30e9 },
+  { 0x04d8, 0x30ea },
+  { 0x04d9, 0x30eb },
+  { 0x04da, 0x30ec },
+  { 0x04db, 0x30ed },
+  { 0x04dc, 0x30ef },
+  { 0x04dd, 0x30f3 },
+  { 0x04de, 0x309b },
+  { 0x04df, 0x309c },
+  { 0x05ac, 0x060c },
+  { 0x05bb, 0x061b },
+  { 0x05bf, 0x061f },
+  { 0x05c1, 0x0621 },
+  { 0x05c2, 0x0622 },
+  { 0x05c3, 0x0623 },
+  { 0x05c4, 0x0624 },
+  { 0x05c5, 0x0625 },
+  { 0x05c6, 0x0626 },
+  { 0x05c7, 0x0627 },
+  { 0x05c8, 0x0628 },
+  { 0x05c9, 0x0629 },
+  { 0x05ca, 0x062a },
+  { 0x05cb, 0x062b },
+  { 0x05cc, 0x062c },
+  { 0x05cd, 0x062d },
+  { 0x05ce, 0x062e },
+  { 0x05cf, 0x062f },
+  { 0x05d0, 0x0630 },
+  { 0x05d1, 0x0631 },
+  { 0x05d2, 0x0632 },
+  { 0x05d3, 0x0633 },
+  { 0x05d4, 0x0634 },
+  { 0x05d5, 0x0635 },
+  { 0x05d6, 0x0636 },
+  { 0x05d7, 0x0637 },
+  { 0x05d8, 0x0638 },
+  { 0x05d9, 0x0639 },
+  { 0x05da, 0x063a },
+  { 0x05e0, 0x0640 },
+  { 0x05e1, 0x0641 },
+  { 0x05e2, 0x0642 },
+  { 0x05e3, 0x0643 },
+  { 0x05e4, 0x0644 },
+  { 0x05e5, 0x0645 },
+  { 0x05e6, 0x0646 },
+  { 0x05e7, 0x0647 },
+  { 0x05e8, 0x0648 },
+  { 0x05e9, 0x0649 },
+  { 0x05ea, 0x064a },
+  { 0x05eb, 0x064b },
+  { 0x05ec, 0x064c },
+  { 0x05ed, 0x064d },
+  { 0x05ee, 0x064e },
+  { 0x05ef, 0x064f },
+  { 0x05f0, 0x0650 },
+  { 0x05f1, 0x0651 },
+  { 0x05f2, 0x0652 },
+  { 0x06a1, 0x0452 },
+  { 0x06a2, 0x0453 },
+  { 0x06a3, 0x0451 },
+  { 0x06a4, 0x0454 },
+  { 0x06a5, 0x0455 },
+  { 0x06a6, 0x0456 },
+  { 0x06a7, 0x0457 },
+  { 0x06a8, 0x0458 },
+  { 0x06a9, 0x0459 },
+  { 0x06aa, 0x045a },
+  { 0x06ab, 0x045b },
+  { 0x06ac, 0x045c },
+  { 0x06ae, 0x045e },
+  { 0x06af, 0x045f },
+  { 0x06b0, 0x2116 },
+  { 0x06b1, 0x0402 },
+  { 0x06b2, 0x0403 },
+  { 0x06b3, 0x0401 },
+  { 0x06b4, 0x0404 },
+  { 0x06b5, 0x0405 },
+  { 0x06b6, 0x0406 },
+  { 0x06b7, 0x0407 },
+  { 0x06b8, 0x0408 },
+  { 0x06b9, 0x0409 },
+  { 0x06ba, 0x040a },
+  { 0x06bb, 0x040b },
+  { 0x06bc, 0x040c },
+  { 0x06be, 0x040e },
+  { 0x06bf, 0x040f },
+  { 0x06c0, 0x044e },
+  { 0x06c1, 0x0430 },
+  { 0x06c2, 0x0431 },
+  { 0x06c3, 0x0446 },
+  { 0x06c4, 0x0434 },
+  { 0x06c5, 0x0435 },
+  { 0x06c6, 0x0444 },
+  { 0x06c7, 0x0433 },
+  { 0x06c8, 0x0445 },
+  { 0x06c9, 0x0438 },
+  { 0x06ca, 0x0439 },
+  { 0x06cb, 0x043a },
+  { 0x06cc, 0x043b },
+  { 0x06cd, 0x043c },
+  { 0x06ce, 0x043d },
+  { 0x06cf, 0x043e },
+  { 0x06d0, 0x043f },
+  { 0x06d1, 0x044f },
+  { 0x06d2, 0x0440 },
+  { 0x06d3, 0x0441 },
+  { 0x06d4, 0x0442 },
+  { 0x06d5, 0x0443 },
+  { 0x06d6, 0x0436 },
+  { 0x06d7, 0x0432 },
+  { 0x06d8, 0x044c },
+  { 0x06d9, 0x044b },
+  { 0x06da, 0x0437 },
+  { 0x06db, 0x0448 },
+  { 0x06dc, 0x044d },
+  { 0x06dd, 0x0449 },
+  { 0x06de, 0x0447 },
+  { 0x06df, 0x044a },
+  { 0x06e0, 0x042e },
+  { 0x06e1, 0x0410 },
+  { 0x06e2, 0x0411 },
+  { 0x06e3, 0x0426 },
+  { 0x06e4, 0x0414 },
+  { 0x06e5, 0x0415 },
+  { 0x06e6, 0x0424 },
+  { 0x06e7, 0x0413 },
+  { 0x06e8, 0x0425 },
+  { 0x06e9, 0x0418 },
+  { 0x06ea, 0x0419 },
+  { 0x06eb, 0x041a },
+  { 0x06ec, 0x041b },
+  { 0x06ed, 0x041c },
+  { 0x06ee, 0x041d },
+  { 0x06ef, 0x041e },
+  { 0x06f0, 0x041f },
+  { 0x06f1, 0x042f },
+  { 0x06f2, 0x0420 },
+  { 0x06f3, 0x0421 },
+  { 0x06f4, 0x0422 },
+  { 0x06f5, 0x0423 },
+  { 0x06f6, 0x0416 },
+  { 0x06f7, 0x0412 },
+  { 0x06f8, 0x042c },
+  { 0x06f9, 0x042b },
+  { 0x06fa, 0x0417 },
+  { 0x06fb, 0x0428 },
+  { 0x06fc, 0x042d },
+  { 0x06fd, 0x0429 },
+  { 0x06fe, 0x0427 },
+  { 0x06ff, 0x042a },
+  { 0x07a1, 0x0386 },
+  { 0x07a2, 0x0388 },
+  { 0x07a3, 0x0389 },
+  { 0x07a4, 0x038a },
+  { 0x07a5, 0x03aa },
+  { 0x07a7, 0x038c },
+  { 0x07a8, 0x038e },
+  { 0x07a9, 0x03ab },
+  { 0x07ab, 0x038f },
+  { 0x07ae, 0x0385 },
+  { 0x07af, 0x2015 },
+  { 0x07b1, 0x03ac },
+  { 0x07b2, 0x03ad },
+  { 0x07b3, 0x03ae },
+  { 0x07b4, 0x03af },
+  { 0x07b5, 0x03ca },
+  { 0x07b6, 0x0390 },
+  { 0x07b7, 0x03cc },
+  { 0x07b8, 0x03cd },
+  { 0x07b9, 0x03cb },
+  { 0x07ba, 0x03b0 },
+  { 0x07bb, 0x03ce },
+  { 0x07c1, 0x0391 },
+  { 0x07c2, 0x0392 },
+  { 0x07c3, 0x0393 },
+  { 0x07c4, 0x0394 },
+  { 0x07c5, 0x0395 },
+  { 0x07c6, 0x0396 },
+  { 0x07c7, 0x0397 },
+  { 0x07c8, 0x0398 },
+  { 0x07c9, 0x0399 },
+  { 0x07ca, 0x039a },
+  { 0x07cb, 0x039b },
+  { 0x07cc, 0x039c },
+  { 0x07cd, 0x039d },
+  { 0x07ce, 0x039e },
+  { 0x07cf, 0x039f },
+  { 0x07d0, 0x03a0 },
+  { 0x07d1, 0x03a1 },
+  { 0x07d2, 0x03a3 },
+  { 0x07d4, 0x03a4 },
+  { 0x07d5, 0x03a5 },
+  { 0x07d6, 0x03a6 },
+  { 0x07d7, 0x03a7 },
+  { 0x07d8, 0x03a8 },
+  { 0x07d9, 0x03a9 },
+  { 0x07e1, 0x03b1 },
+  { 0x07e2, 0x03b2 },
+  { 0x07e3, 0x03b3 },
+  { 0x07e4, 0x03b4 },
+  { 0x07e5, 0x03b5 },
+  { 0x07e6, 0x03b6 },
+  { 0x07e7, 0x03b7 },
+  { 0x07e8, 0x03b8 },
+  { 0x07e9, 0x03b9 },
+  { 0x07ea, 0x03ba },
+  { 0x07eb, 0x03bb },
+  { 0x07ec, 0x03bc },
+  { 0x07ed, 0x03bd },
+  { 0x07ee, 0x03be },
+  { 0x07ef, 0x03bf },
+  { 0x07f0, 0x03c0 },
+  { 0x07f1, 0x03c1 },
+  { 0x07f2, 0x03c3 },
+  { 0x07f3, 0x03c2 },
+  { 0x07f4, 0x03c4 },
+  { 0x07f5, 0x03c5 },
+  { 0x07f6, 0x03c6 },
+  { 0x07f7, 0x03c7 },
+  { 0x07f8, 0x03c8 },
+  { 0x07f9, 0x03c9 },
+  { 0x08a1, 0x23b7 },
+  { 0x08a2, 0x250c },
+  { 0x08a3, 0x2500 },
+  { 0x08a4, 0x2320 },
+  { 0x08a5, 0x2321 },
+  { 0x08a6, 0x2502 },
+  { 0x08a7, 0x23a1 },
+  { 0x08a8, 0x23a3 },
+  { 0x08a9, 0x23a4 },
+  { 0x08aa, 0x23a6 },
+  { 0x08ab, 0x239b },
+  { 0x08ac, 0x239d },
+  { 0x08ad, 0x239e },
+  { 0x08ae, 0x23a0 },
+  { 0x08af, 0x23a8 },
+  { 0x08b0, 0x23ac },
+  { 0x08bc, 0x2264 },
+  { 0x08bd, 0x2260 },
+  { 0x08be, 0x2265 },
+  { 0x08bf, 0x222b },
+  { 0x08c0, 0x2234 },
+  { 0x08c1, 0x221d },
+  { 0x08c2, 0x221e },
+  { 0x08c5, 0x2207 },
+  { 0x08c8, 0x223c },
+  { 0x08c9, 0x2243 },
+  { 0x08cd, 0x21d4 },
+  { 0x08ce, 0x21d2 },
+  { 0x08cf, 0x2261 },
+  { 0x08d6, 0x221a },
+  { 0x08da, 0x2282 },
+  { 0x08db, 0x2283 },
+  { 0x08dc, 0x2229 },
+  { 0x08dd, 0x222a },
+  { 0x08de, 0x2227 },
+  { 0x08df, 0x2228 },
+  { 0x08ef, 0x2202 },
+  { 0x08f6, 0x0192 },
+  { 0x08fb, 0x2190 },
+  { 0x08fc, 0x2191 },
+  { 0x08fd, 0x2192 },
+  { 0x08fe, 0x2193 },
+  { 0x09e0, 0x25c6 },
+  { 0x09e1, 0x2592 },
+  { 0x09e2, 0x2409 },
+  { 0x09e3, 0x240c },
+  { 0x09e4, 0x240d },
+  { 0x09e5, 0x240a },
+  { 0x09e8, 0x2424 },
+  { 0x09e9, 0x240b },
+  { 0x09ea, 0x2518 },
+  { 0x09eb, 0x2510 },
+  { 0x09ec, 0x250c },
+  { 0x09ed, 0x2514 },
+  { 0x09ee, 0x253c },
+  { 0x09ef, 0x23ba },
+  { 0x09f0, 0x23bb },
+  { 0x09f1, 0x2500 },
+  { 0x09f2, 0x23bc },
+  { 0x09f3, 0x23bd },
+  { 0x09f4, 0x251c },
+  { 0x09f5, 0x2524 },
+  { 0x09f6, 0x2534 },
+  { 0x09f7, 0x252c },
+  { 0x09f8, 0x2502 },
+  { 0x0aa1, 0x2003 },
+  { 0x0aa2, 0x2002 },
+  { 0x0aa3, 0x2004 },
+  { 0x0aa4, 0x2005 },
+  { 0x0aa5, 0x2007 },
+  { 0x0aa6, 0x2008 },
+  { 0x0aa7, 0x2009 },
+  { 0x0aa8, 0x200a },
+  { 0x0aa9, 0x2014 },
+  { 0x0aaa, 0x2013 },
+  { 0x0aae, 0x2026 },
+  { 0x0aaf, 0x2025 },
+  { 0x0ab0, 0x2153 },
+  { 0x0ab1, 0x2154 },
+  { 0x0ab2, 0x2155 },
+  { 0x0ab3, 0x2156 },
+  { 0x0ab4, 0x2157 },
+  { 0x0ab5, 0x2158 },
+  { 0x0ab6, 0x2159 },
+  { 0x0ab7, 0x215a },
+  { 0x0ab8, 0x2105 },
+  { 0x0abb, 0x2012 },
+  { 0x0abc, 0x2329 },
+  { 0x0abe, 0x232a },
+  { 0x0ac3, 0x215b },
+  { 0x0ac4, 0x215c },
+  { 0x0ac5, 0x215d },
+  { 0x0ac6, 0x215e },
+  { 0x0ac9, 0x2122 },
+  { 0x0aca, 0x2613 },
+  { 0x0acc, 0x25c1 },
+  { 0x0acd, 0x25b7 },
+  { 0x0ace, 0x25cb },
+  { 0x0acf, 0x25af },
+  { 0x0ad0, 0x2018 },
+  { 0x0ad1, 0x2019 },
+  { 0x0ad2, 0x201c },
+  { 0x0ad3, 0x201d },
+  { 0x0ad4, 0x211e },
+  { 0x0ad6, 0x2032 },
+  { 0x0ad7, 0x2033 },
+  { 0x0ad9, 0x271d },
+  { 0x0adb, 0x25ac },
+  { 0x0adc, 0x25c0 },
+  { 0x0add, 0x25b6 },
+  { 0x0ade, 0x25cf },
+  { 0x0adf, 0x25ae },
+  { 0x0ae0, 0x25e6 },
+  { 0x0ae1, 0x25ab },
+  { 0x0ae2, 0x25ad },
+  { 0x0ae3, 0x25b3 },
+  { 0x0ae4, 0x25bd },
+  { 0x0ae5, 0x2606 },
+  { 0x0ae6, 0x2022 },
+  { 0x0ae7, 0x25aa },
+  { 0x0ae8, 0x25b2 },
+  { 0x0ae9, 0x25bc },
+  { 0x0aea, 0x261c },
+  { 0x0aeb, 0x261e },
+  { 0x0aec, 0x2663 },
+  { 0x0aed, 0x2666 },
+  { 0x0aee, 0x2665 },
+  { 0x0af0, 0x2720 },
+  { 0x0af1, 0x2020 },
+  { 0x0af2, 0x2021 },
+  { 0x0af3, 0x2713 },
+  { 0x0af4, 0x2717 },
+  { 0x0af5, 0x266f },
+  { 0x0af6, 0x266d },
+  { 0x0af7, 0x2642 },
+  { 0x0af8, 0x2640 },
+  { 0x0af9, 0x260e },
+  { 0x0afa, 0x2315 },
+  { 0x0afb, 0x2117 },
+  { 0x0afc, 0x2038 },
+  { 0x0afd, 0x201a },
+  { 0x0afe, 0x201e },
+  { 0x0ba3, 0x003c },
+  { 0x0ba6, 0x003e },
+  { 0x0ba8, 0x2228 },
+  { 0x0ba9, 0x2227 },
+  { 0x0bc0, 0x00af },
+  { 0x0bc2, 0x22a5 },
+  { 0x0bc3, 0x2229 },
+  { 0x0bc4, 0x230a },
+  { 0x0bc6, 0x005f },
+  { 0x0bca, 0x2218 },
+  { 0x0bcc, 0x2395 },
+  { 0x0bce, 0x22a4 },
+  { 0x0bcf, 0x25cb },
+  { 0x0bd3, 0x2308 },
+  { 0x0bd6, 0x222a },
+  { 0x0bd8, 0x2283 },
+  { 0x0bda, 0x2282 },
+  { 0x0bdc, 0x22a2 },
+  { 0x0bfc, 0x22a3 },
+  { 0x0cdf, 0x2017 },
+  { 0x0ce0, 0x05d0 },
+  { 0x0ce1, 0x05d1 },
+  { 0x0ce2, 0x05d2 },
+  { 0x0ce3, 0x05d3 },
+  { 0x0ce4, 0x05d4 },
+  { 0x0ce5, 0x05d5 },
+  { 0x0ce6, 0x05d6 },
+  { 0x0ce7, 0x05d7 },
+  { 0x0ce8, 0x05d8 },
+  { 0x0ce9, 0x05d9 },
+  { 0x0cea, 0x05da },
+  { 0x0ceb, 0x05db },
+  { 0x0cec, 0x05dc },
+  { 0x0ced, 0x05dd },
+  { 0x0cee, 0x05de },
+  { 0x0cef, 0x05df },
+  { 0x0cf0, 0x05e0 },
+  { 0x0cf1, 0x05e1 },
+  { 0x0cf2, 0x05e2 },
+  { 0x0cf3, 0x05e3 },
+  { 0x0cf4, 0x05e4 },
+  { 0x0cf5, 0x05e5 },
+  { 0x0cf6, 0x05e6 },
+  { 0x0cf7, 0x05e7 },
+  { 0x0cf8, 0x05e8 },
+  { 0x0cf9, 0x05e9 },
+  { 0x0cfa, 0x05ea },
+  { 0x0da1, 0x0e01 },
+  { 0x0da2, 0x0e02 },
+  { 0x0da3, 0x0e03 },
+  { 0x0da4, 0x0e04 },
+  { 0x0da5, 0x0e05 },
+  { 0x0da6, 0x0e06 },
+  { 0x0da7, 0x0e07 },
+  { 0x0da8, 0x0e08 },
+  { 0x0da9, 0x0e09 },
+  { 0x0daa, 0x0e0a },
+  { 0x0dab, 0x0e0b },
+  { 0x0dac, 0x0e0c },
+  { 0x0dad, 0x0e0d },
+  { 0x0dae, 0x0e0e },
+  { 0x0daf, 0x0e0f },
+  { 0x0db0, 0x0e10 },
+  { 0x0db1, 0x0e11 },
+  { 0x0db2, 0x0e12 },
+  { 0x0db3, 0x0e13 },
+  { 0x0db4, 0x0e14 },
+  { 0x0db5, 0x0e15 },
+  { 0x0db6, 0x0e16 },
+  { 0x0db7, 0x0e17 },
+  { 0x0db8, 0x0e18 },
+  { 0x0db9, 0x0e19 },
+  { 0x0dba, 0x0e1a },
+  { 0x0dbb, 0x0e1b },
+  { 0x0dbc, 0x0e1c },
+  { 0x0dbd, 0x0e1d },
+  { 0x0dbe, 0x0e1e },
+  { 0x0dbf, 0x0e1f },
+  { 0x0dc0, 0x0e20 },
+  { 0x0dc1, 0x0e21 },
+  { 0x0dc2, 0x0e22 },
+  { 0x0dc3, 0x0e23 },
+  { 0x0dc4, 0x0e24 },
+  { 0x0dc5, 0x0e25 },
+  { 0x0dc6, 0x0e26 },
+  { 0x0dc7, 0x0e27 },
+  { 0x0dc8, 0x0e28 },
+  { 0x0dc9, 0x0e29 },
+  { 0x0dca, 0x0e2a },
+  { 0x0dcb, 0x0e2b },
+  { 0x0dcc, 0x0e2c },
+  { 0x0dcd, 0x0e2d },
+  { 0x0dce, 0x0e2e },
+  { 0x0dcf, 0x0e2f },
+  { 0x0dd0, 0x0e30 },
+  { 0x0dd1, 0x0e31 },
+  { 0x0dd2, 0x0e32 },
+  { 0x0dd3, 0x0e33 },
+  { 0x0dd4, 0x0e34 },
+  { 0x0dd5, 0x0e35 },
+  { 0x0dd6, 0x0e36 },
+  { 0x0dd7, 0x0e37 },
+  { 0x0dd8, 0x0e38 },
+  { 0x0dd9, 0x0e39 },
+  { 0x0dda, 0x0e3a },
+  { 0x0ddf, 0x0e3f },
+  { 0x0de0, 0x0e40 },
+  { 0x0de1, 0x0e41 },
+  { 0x0de2, 0x0e42 },
+  { 0x0de3, 0x0e43 },
+  { 0x0de4, 0x0e44 },
+  { 0x0de5, 0x0e45 },
+  { 0x0de6, 0x0e46 },
+  { 0x0de7, 0x0e47 },
+  { 0x0de8, 0x0e48 },
+  { 0x0de9, 0x0e49 },
+  { 0x0dea, 0x0e4a },
+  { 0x0deb, 0x0e4b },
+  { 0x0dec, 0x0e4c },
+  { 0x0ded, 0x0e4d },
+  { 0x0df0, 0x0e50 },
+  { 0x0df1, 0x0e51 },
+  { 0x0df2, 0x0e52 },
+  { 0x0df3, 0x0e53 },
+  { 0x0df4, 0x0e54 },
+  { 0x0df5, 0x0e55 },
+  { 0x0df6, 0x0e56 },
+  { 0x0df7, 0x0e57 },
+  { 0x0df8, 0x0e58 },
+  { 0x0df9, 0x0e59 },
+  { 0x0ea1, 0x3131 },
+  { 0x0ea2, 0x3132 },
+  { 0x0ea3, 0x3133 },
+  { 0x0ea4, 0x3134 },
+  { 0x0ea5, 0x3135 },
+  { 0x0ea6, 0x3136 },
+  { 0x0ea7, 0x3137 },
+  { 0x0ea8, 0x3138 },
+  { 0x0ea9, 0x3139 },
+  { 0x0eaa, 0x313a },
+  { 0x0eab, 0x313b },
+  { 0x0eac, 0x313c },
+  { 0x0ead, 0x313d },
+  { 0x0eae, 0x313e },
+  { 0x0eaf, 0x313f },
+  { 0x0eb0, 0x3140 },
+  { 0x0eb1, 0x3141 },
+  { 0x0eb2, 0x3142 },
+  { 0x0eb3, 0x3143 },
+  { 0x0eb4, 0x3144 },
+  { 0x0eb5, 0x3145 },
+  { 0x0eb6, 0x3146 },
+  { 0x0eb7, 0x3147 },
+  { 0x0eb8, 0x3148 },
+  { 0x0eb9, 0x3149 },
+  { 0x0eba, 0x314a },
+  { 0x0ebb, 0x314b },
+  { 0x0ebc, 0x314c },
+  { 0x0ebd, 0x314d },
+  { 0x0ebe, 0x314e },
+  { 0x0ebf, 0x314f },
+  { 0x0ec0, 0x3150 },
+  { 0x0ec1, 0x3151 },
+  { 0x0ec2, 0x3152 },
+  { 0x0ec3, 0x3153 },
+  { 0x0ec4, 0x3154 },
+  { 0x0ec5, 0x3155 },
+  { 0x0ec6, 0x3156 },
+  { 0x0ec7, 0x3157 },
+  { 0x0ec8, 0x3158 },
+  { 0x0ec9, 0x3159 },
+  { 0x0eca, 0x315a },
+  { 0x0ecb, 0x315b },
+  { 0x0ecc, 0x315c },
+  { 0x0ecd, 0x315d },
+  { 0x0ece, 0x315e },
+  { 0x0ecf, 0x315f },
+  { 0x0ed0, 0x3160 },
+  { 0x0ed1, 0x3161 },
+  { 0x0ed2, 0x3162 },
+  { 0x0ed3, 0x3163 },
+  { 0x0ed4, 0x11a8 },
+  { 0x0ed5, 0x11a9 },
+  { 0x0ed6, 0x11aa },
+  { 0x0ed7, 0x11ab },
+  { 0x0ed8, 0x11ac },
+  { 0x0ed9, 0x11ad },
+  { 0x0eda, 0x11ae },
+  { 0x0edb, 0x11af },
+  { 0x0edc, 0x11b0 },
+  { 0x0edd, 0x11b1 },
+  { 0x0ede, 0x11b2 },
+  { 0x0edf, 0x11b3 },
+  { 0x0ee0, 0x11b4 },
+  { 0x0ee1, 0x11b5 },
+  { 0x0ee2, 0x11b6 },
+  { 0x0ee3, 0x11b7 },
+  { 0x0ee4, 0x11b8 },
+  { 0x0ee5, 0x11b9 },
+  { 0x0ee6, 0x11ba },
+  { 0x0ee7, 0x11bb },
+  { 0x0ee8, 0x11bc },
+  { 0x0ee9, 0x11bd },
+  { 0x0eea, 0x11be },
+  { 0x0eeb, 0x11bf },
+  { 0x0eec, 0x11c0 },
+  { 0x0eed, 0x11c1 },
+  { 0x0eee, 0x11c2 },
+  { 0x0eef, 0x316d },
+  { 0x0ef0, 0x3171 },
+  { 0x0ef1, 0x3178 },
+  { 0x0ef2, 0x317f },
+  { 0x0ef3, 0x3181 },
+  { 0x0ef4, 0x3184 },
+  { 0x0ef5, 0x3186 },
+  { 0x0ef6, 0x318d },
+  { 0x0ef7, 0x318e },
+  { 0x0ef8, 0x11eb },
+  { 0x0ef9, 0x11f0 },
+  { 0x0efa, 0x11f9 },
+  { 0x0eff, 0x20a9 },
+  { 0x13a4, 0x20ac },
+  { 0x13bc, 0x0152 },
+  { 0x13bd, 0x0153 },
+  { 0x13be, 0x0178 },
+  { 0x20ac, 0x20ac },
+  // Numeric keypad with numlock on
+  { XK_KP_Space, ' ' },
+  { XK_KP_Equal, '=' },
+  { XK_KP_Multiply, '*' },
+  { XK_KP_Add, '+' },
+  { XK_KP_Separator, ',' },
+  { XK_KP_Subtract, '-' },
+  { XK_KP_Decimal, '.' },
+  { XK_KP_Divide, '/' },
+  { XK_KP_0, 0x0030 },
+  { XK_KP_1, 0x0031 },
+  { XK_KP_2, 0x0032 },
+  { XK_KP_3, 0x0033 },
+  { XK_KP_4, 0x0034 },
+  { XK_KP_5, 0x0035 },
+  { XK_KP_6, 0x0036 },
+  { XK_KP_7, 0x0037 },
+  { XK_KP_8, 0x0038 },
+  { XK_KP_9, 0x0039 }
+};
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+// Convert X11 KeySym to Unicode
+//
+long _glfwKeySym2Unicode( KeySym keysym )
+{
+    int min = 0;
+    int max = sizeof(keysymtab) / sizeof(struct codepair) - 1;
+    int mid;
+
+    /* First check for Latin-1 characters (1:1 mapping) */
+    if( (keysym >= 0x0020 && keysym <= 0x007e) ||
+        (keysym >= 0x00a0 && keysym <= 0x00ff) )
+    { return keysym;
+    }
+
+    /* Also check for directly encoded 24-bit UCS characters */
+    if( (keysym & 0xff000000) == 0x01000000 )
+        return keysym & 0x00ffffff;
+
+    /* Binary search in table */
+    while( max >= min )
+    {
+        mid = (min + max) / 2;
+        if( keysymtab[mid].keysym < keysym )
+            min = mid + 1;
+        else if( keysymtab[mid].keysym > keysym )
+            max = mid - 1;
+        else
+        {
+            /* Found it! */
+            return keysymtab[mid].ucs;
+        }
+    }
+
+    /* No matching Unicode value found */
+    return -1;
+}
+