packages feed

GLFW-b 0.1.0.5 → 3.3.9.1

raw patch · 55 files changed

Files

GLFW-b.cabal view
@@ -1,140 +1,89 @@ name:         GLFW-b-version:      0.1.0.5-+version:      3.3.9.1 category:     Graphics -synopsis:     GLFW bindings-description:  Bindings to GLFW, a free, open source, multi-platform library for-              creating OpenGL contexts and managing input, including keyboard,-              mouse, joystick and time.-              .-              GLFW-b works on Windows, Mac OS X, and many Unix-like operating-              systems.-              .-              Please see README.md-              (<http://github.com/bsl/GLFW-b/blob/master/README.md>) for-              information about how these bindings differ from the ones in the-              GLFW package (<http://hackage.haskell.org/package/GLFW>).-              .-              For more information about the library on which these bindings-              are based, please see <http://glfw.sourceforge.net>.- author:       Brian Lewis <brian@lorf.org> maintainer:   Brian Lewis <brian@lorf.org>+            , Schell Scivally <schell.scivally@synapsegroup.com>+            , Pavel Krajcevski <krajcevski@gmail.com>  license:      BSD3 license-file: LICENSE --- -- -- -- -- -- -- -- -- --+synopsis:     Bindings to GLFW OpenGL library+description:+  Bindings to GLFW (<http://www.glfw.org/>), an open source, multi-platform+  library for creating windows with OpenGL contexts and managing input and+  events.+  .+  GLFW-b depends on bindings-GLFW+  (<http://hackage.haskell.org/package/bindings-GLFW>), which, as of the time+  of this writing, binds to GLFW 3.3.9, released 2023-12-13+  (<http://www.glfw.org/Version-3.3.0-released.html>+  <http://www.glfw.org/changelog.html>).+  .+  If you've used GLFW < 3 before, you should read the transition guide+  (<http://www.glfw.org/docs/3.0/moving.html>). -cabal-version: >= 1.6-build-type:    Custom +cabal-version: >= 1.10+build-type:    Simple --- -- -- -- -- -- -- -- -- --+--------------------------------------------------------------------------------  extra-source-files:-  Makefile   README.md-  ./build/glfw/lib/cocoa/.build-tag-  glfw/include/GL/glfw.h-  glfw/lib/internal.h-  glfw/lib/cocoa/platform.h-  glfw/lib/win32/platform.h-  glfw/lib/x11/platform.h-  -- We can't explicitly list these as-  -- C sources so we list them here.-  glfw/lib/cocoa/cocoa_enable.m-  glfw/lib/cocoa/cocoa_joystick.m-  glfw/lib/cocoa/cocoa_fullscreen.m-  glfw/lib/cocoa/cocoa_time.m-  glfw/lib/cocoa/cocoa_glext.m-  glfw/lib/cocoa/cocoa_window.m-  glfw/lib/cocoa/cocoa_init.m-  glfw/lib/cocoa/cocoa_thread.c--- -- -- -- -- -- -- -- -- --+  TODO +--------------------------------------------------------------------------------+ library+  default-language: Haskell2010++  ghc-options: -Wall+  if impl(ghc >= 6.8)+    ghc-options: -fwarn-tabs+   exposed-modules:     Graphics.UI.GLFW+    Graphics.UI.GLFW.C -  build-depends:-    base == 4.*+  other-modules:+    Graphics.UI.GLFW.Types -  hs-source-dirs:-    src+  build-depends:+      base          <  5+    , deepseq       >= 1.1.0.0+    , array         >= 0.5.3.0+    , bindings-GLFW >= 3.3.9.2 -  include-dirs:-    glfw/include-    glfw/lib-  if !os(darwin)-    c-sources:-      glfw/lib/enable.c-      glfw/lib/fullscreen.c-      glfw/lib/glext.c-      glfw/lib/image.c-      glfw/lib/init.c-      glfw/lib/input.c-      glfw/lib/joystick.c-      glfw/lib/stream.c-      glfw/lib/tga.c-      glfw/lib/thread.c-      glfw/lib/time.c-      glfw/lib/window.c+-------------------------------------------------------------------------------- -  if os(linux) || os(freebsd)-    include-dirs:-      glfw/lib/x11-    c-sources:-      glfw/lib/x11/x11_enable.c-      glfw/lib/x11/x11_fullscreen.c-      glfw/lib/x11/x11_glext.c-      glfw/lib/x11/x11_init.c-      glfw/lib/x11/x11_joystick.c-      glfw/lib/x11/x11_keysym2unicode.c-      glfw/lib/x11/x11_thread.c-      glfw/lib/x11/x11_time.c-      glfw/lib/x11/x11_window.c-    cc-options:-      -D_GLFW_USE_LINUX_JOYSTICKS-      -D_GLFW_HAS_XRANDR---    -D_GLFW_HAS_PTHREAD---    -D_GLFW_HAS_SCHED_YIELD-      -D_GLFW_HAS_GLXGETPROCADDRESS---    -D_GLFW_HAS_DLOPEN---    -D_GLFW_HAS_SYSCONF---    -pthread-    extra-libraries:-      GL-      GLU-      X11-      Xrandr-  else-    if os(darwin)-      extra-libraries: glfw-      extra-lib-dirs: build-      ghc-options: -fPIC-    else-      if os(mingw32)-        include-dirs:-          glfw/lib/win32-        c-sources:-          glfw/lib/win32/win32_dllmain.c-          glfw/lib/win32/win32_enable.c-          glfw/lib/win32/win32_fullscreen.c-          glfw/lib/win32/win32_glext.c-          glfw/lib/win32/win32_init.c-          glfw/lib/win32/win32_joystick.c-          glfw/lib/win32/win32_thread.c-          glfw/lib/win32/win32_time.c-          glfw/lib/win32/win32_window.c-        extra-libraries:-          opengl32+test-suite main+  default-language: Haskell2010 -  ghc-options: -Wall -O2+  ghc-options: -Wall   if impl(ghc >= 6.8)     ghc-options: -fwarn-tabs --- -- -- -- -- -- -- -- -- --+  type: exitcode-stdio-1.0++  main-is: Test.hs++  other-modules:+    Graphics.UI.GLFW+    Graphics.UI.GLFW.Types++  build-depends:+      GLFW-b+    , HUnit                >= 1.3 && < 1.7+    , base                 <  5+    , array                >= 0.5.3.0+    , bindings-GLFW        >= 3.3.9.2+    , deepseq              >= 1.1.0.0+    , test-framework       == 0.8.*+    , test-framework-hunit == 0.3.*++--------------------------------------------------------------------------------  source-repository head   type:     git
+ Graphics/UI/GLFW.hs view
@@ -0,0 +1,2067 @@+{-# LANGUAGE ScopedTypeVariables #-}+{-|++Threading restrictions which apply to the C version of GLFW still apply when+writing @GLFW-b@ programs. See+<http://www.glfw.org/docs/3.3/intro.html#thread_safety GLFW thread safety documentation>+(applies here).++Current context restructions which apply to the C version of GLFW still apply.+See <http://www.glfw.org/docs/3.3/context.html#context_current  GLFW current context documentation>+(applies here).++@GLFW-b@ wraps callbacks and schedules them to be run after 'pollEvents' and+'waitEvents' in the normal GHC runtime where they aren't subject to the usual+GLFW reentrancy restrictions. See+<http://www.glfw.org/docs/3.3/intro.html#reentrancy GLFW reentrancy documentation>+(does not apply here).++-}+module Graphics.UI.GLFW+  ( -- * Error handling+    Error (..)+    --+  , setErrorCallback, ErrorCallback++    -- * Initialization and version information+  , Version (..)+    --+  , init+  , InitHint(..)+  , initHint+  , terminate+  , getVersion+  , getVersionString+  , getError+  , clearError+  , rawMouseMotionSupported++    -- * Monitor handling+  , Monitor+  , MonitorState (..)+  , VideoMode    (..)+  , GammaRamp    (gammaRampRed, gammaRampGreen, gammaRampBlue)+  , makeGammaRamp+    --+  , getMonitors+  , getPrimaryMonitor+  , getMonitorPos+  , getMonitorPhysicalSize+  , getMonitorContentScale+  , getMonitorWorkarea+  , getMonitorName+  , setMonitorCallback, MonitorCallback+  , getVideoModes+  , getVideoMode+  , setGamma+  , getGammaRamp+  , setGammaRamp++    -- * Window handling+  , Window+  , WindowHint             (..)+  , WindowAttrib           (..)+  , ContextRobustness      (..)+  , OpenGLProfile          (..)+  , ClientAPI              (..)+  , ContextCreationAPI     (..)+  , ContextReleaseBehavior (..)+    --+  , defaultWindowHints+  , windowHint+  , setWindowAttrib+  , getWindowAttrib+  , createWindow+  , destroyWindow+  , windowShouldClose+  , setWindowShouldClose+  , getWindowOpacity+  , setWindowOpacity+  , setWindowTitle+  , getWindowPos+  , setWindowPos+  , getWindowSize+  , setWindowSize+  , setWindowSizeLimits+  , setWindowAspectRatio+  , getWindowFrameSize+  , getWindowContentScale+  , getFramebufferSize+  , setWindowIcon+  , iconifyWindow+  , restoreWindow+  , focusWindow+  , maximizeWindow+  , showWindow+  , hideWindow+  , requestWindowAttention+  , getWindowMonitor+  , setCursorPos+  , setFullscreen+  , setWindowed+    -- related to c'glfwGetWindowAttrib --.+  , getWindowFocused                   -- |+  , getWindowMaximized                 -- |+  , getWindowFloating                  -- |+  , getWindowIconified                 -- |+  , getWindowResizable                 -- |+  , getWindowDecorated                 -- |+  , getWindowVisible                   -- |+  , getWindowClientAPI                 -- |+  , getWindowContextCreationAPI        -- |+  , getWindowContextVersionMajor       -- |+  , getWindowContextVersionMinor       -- |+  , getWindowContextVersionRevision    -- |+  , getWindowContextRobustness         -- |+  , getWindowContextReleaseBehavior    -- |+  , getWindowContextNoError            -- |+  , getWindowOpenGLForwardCompat       -- |+  , getWindowOpenGLDebugContext        -- |+  , getWindowOpenGLProfile  --------------'+  , setWindowPosCallback,          WindowPosCallback+  , setWindowSizeCallback,         WindowSizeCallback+  , setWindowCloseCallback,        WindowCloseCallback+  , setWindowRefreshCallback,      WindowRefreshCallback+  , setWindowFocusCallback,        WindowFocusCallback+  , setWindowIconifyCallback,      WindowIconifyCallback+  , setFramebufferSizeCallback,    FramebufferSizeCallback+  , setWindowContentScaleCallback, WindowContentScaleCallback+  , setWindowMaximizeCallback,     WindowMaximizeCallback+  , pollEvents+  , waitEvents+  , waitEventsTimeout+  , postEmptyEvent++    -- * Input handling+  , Key                         (..)+  , KeyState                    (..)+  , Joystick                    (..)+  , JoystickState               (..)+  , JoystickButtonState         (..)+  , MouseButton                 (..)+  , MouseButtonState            (..)+  , CursorState                 (..)+  , CursorInputMode             (..)+  , StickyKeysInputMode         (..)+  , StickyMouseButtonsInputMode (..)+  , ModifierKeys                (..)+  , GamepadButton               (..)+  , GamepadAxis                 (..)+  , GamepadButtonState          (..)+  , GamepadState                (..)+  , Image+  , mkImage+  , Cursor                      (..)+  , StandardCursorShape         (..)+    --+    -- related to c'glfwSetInputMode ----.+  , getCursorInputMode                -- |+  , setCursorInputMode                -- |+  , getRawMouseMotion                 -- |+  , setRawMouseMotion                 -- |+  , getStickyKeysInputMode            -- |+  , setStickyKeysInputMode            -- |+  , getStickyMouseButtonsInputMode    -- |+  , setStickyMouseButtonsInputMode  -----'+  , getKey+  , getKeyName+  , getKeyScancode+  , getMouseButton+  , getCursorPos+  , setKeyCallback,         KeyCallback+  , setCharCallback,        CharCallback+  , setCharModsCallback,    CharModsCallback+  , setMouseButtonCallback, MouseButtonCallback+  , setCursorPosCallback,   CursorPosCallback+  , setCursorEnterCallback, CursorEnterCallback+  , createCursor+  , createStandardCursor+  , setCursor+  , destroyCursor+  , setScrollCallback,      ScrollCallback+  , setDropCallback,        DropCallback+  , joystickPresent+  , joystickIsGamepad+  , getJoystickAxes+  , getJoystickButtons+  , getJoystickHats,        JoystickHatState(..)+  , getJoystickName+  , getJoystickGUID+  , setJoystickCallback,    JoystickCallback+  , getGamepadName+  , getGamepadState+  , updateGamepadMappings++    -- * Time+  , getTime+  , setTime+  , getTimerValue+  , getTimerFrequency++    -- * Context+  , makeContextCurrent+  , getCurrentContext+  , swapBuffers+  , swapInterval+  , extensionSupported++    -- * Clipboard+  , getClipboardString+  , setClipboardString++    -- * Vulkan-related functions+  , vulkanSupported+  , getRequiredInstanceExtensions+  , getInstanceProcAddress+  , getPhysicalDevicePresentationSupport+  , createWindowSurface++    -- * Native access functions+    -- $nativeaccess+  , getWin32Adapter+  , getWin32Monitor+  , getWin32Window+  , getWGLContext+  , getCocoaMonitor+  , getCocoaWindow+  , getNSGLContext+  , getX11Display+  , getX11Adapter+  , getX11Monitor+  , getX11Window+  , getX11SelectionString+  , setX11SelectionString+  , getGLXContext+  , getGLXWindow+  , getWaylandDisplay+  , getWaylandMonitor+  , getWaylandWindow+  , getEGLDisplay+  , getEGLContext+  , getEGLSurface+  , getOSMesaContext+  , getOSMesaColorBuffer,   OSMesaColorBuffer, OSMesaRGBA+  , getOSMesaDepthBuffer,   OSMesaDepthBuffer+  ) where++--------------------------------------------------------------------------------++import Prelude hiding (init)++import Control.Monad         (when, liftM, forM)+import Data.Array.IArray     (Array, array)+import Data.Bits             (shiftR, shiftL, (.&.), (.|.))+import Data.IORef            (IORef, atomicModifyIORef, newIORef, readIORef)+import Data.List             (foldl')+import Data.Word             (Word8, Word16, Word32, Word64)+import Foreign.C.String      (peekCString, withCString, CString)+import Foreign.C.Types       (CUInt, CInt, CUShort, CFloat(..))+import Foreign.Marshal.Alloc (alloca, allocaBytes)+import Foreign.Marshal.Array (advancePtr, allocaArray, peekArray, withArray)+import Foreign.Ptr           ( FunPtr, freeHaskellFunPtr, nullFunPtr, nullPtr+                             , Ptr, castPtr, plusPtr)+import Foreign.StablePtr+import Foreign.Storable      (Storable (..))+import System.IO.Unsafe      (unsafePerformIO)++import Graphics.UI.GLFW.C+import Graphics.UI.GLFW.Types++import Bindings.GLFW++--------------------------------------------------------------------------------+-- Helper functions++-- C to haskell float.+hFloat :: CFloat -> Float+hFloat (CFloat f) = f++--------------------------------------------------------------------------------++-- We store FunPtrs from mk'GLFW*fun in these stored*Fun IORefs. Initialized+-- with unsafePerformIO, they are basically mutable global variables.++storedErrorFun           :: IORef C'GLFWerrorfun+storedMonitorFun         :: IORef C'GLFWmonitorfun+storedJoystickFun        :: IORef C'GLFWjoystickfun++storedErrorFun           = unsafePerformIO $ newIORef nullFunPtr+storedMonitorFun         = unsafePerformIO $ newIORef nullFunPtr+storedJoystickFun        = unsafePerformIO $ newIORef nullFunPtr++-- These NOINLINE pragmas are due to use of unsafePerformIO.+-- See http://hackage.haskell.org/packages/archive/base/latest/doc/html/System-IO-Unsafe.html#v:unsafePerformIO .++{-# NOINLINE storedErrorFun           #-}+{-# NOINLINE storedMonitorFun         #-}+{-# NOINLINE storedJoystickFun         #-}++setWindowCallback+  :: (c -> IO (FunPtr c))                    -- wf   wrapper function+  -> (h -> c)                                -- af   adapter function+  -> (FunPtr c -> IO (FunPtr c))             -- gf   c'glfwSet*Callback function+  -> (WindowCallbacks -> IORef (FunPtr c))   -- ior  accessor for storage location+  -> Window                                  -- win  window+  -> Maybe h                                 -- mcb  Haskell callback+  -> IO ()+setWindowCallback wr af gf ior win mcb = do+    pcallbacks <- castPtrToStablePtr `liftM` c'glfwGetWindowUserPointer (unWindow win)+    callbacks <- deRefStablePtr pcallbacks+    setCallback wr af gf (ior callbacks) mcb++setCallback+  :: (c -> IO (FunPtr c))          -- wf   wrapper function+  -> (h -> c)                      -- af   adapter function+  -> (FunPtr c -> IO (FunPtr c))   -- gf   c'glfwSet*Callback function+  -> IORef (FunPtr c)              -- ior  storage location+  -> Maybe h                       -- mcb  Haskell callback+  -> IO ()+setCallback wf af gf ior mcb = do+    -- If mcb is Just, make ccb the FunPtr of the adapted callback. Otherwise a+    -- null FunPtr.+    ccb <- maybe (return nullFunPtr) (wf . af) mcb+    -- Call the GLFW callback-setting function.+    _ <- gf ccb+    -- Store it.+    storeCallback ior ccb++storeCallback :: IORef (FunPtr a) -> FunPtr a -> IO ()+storeCallback ior new = do+    -- Store the new FunPtr, retrieve the previous one.+    prev <- atomicModifyIORef ior (\cur -> (new, cur))+    -- Free the old FunPtr if necessary.+    when (prev /= nullFunPtr) $ freeHaskellFunPtr prev++--------------------------------------------------------------------------------++-- | The error code and also a human-readable error message.+type ErrorCallback              = Error -> String                                           -> IO ()+-- | Fires when the window position changes.+type WindowPosCallback          = Window -> Int -> Int                                      -> IO ()+-- | Fires when the window is resized (in Screen Coordinates, which might not map 1:1 with pixels).+type WindowSizeCallback         = Window -> Int -> Int                                      -> IO ()+-- | Fires when the user is attempting to close the window+type WindowCloseCallback        = Window                                                    -> IO ()+-- | Fires when the contents of the window are damaged and they must be refreshed.+type WindowRefreshCallback      = Window                                                    -> IO ()+-- | Fires when the window gains or loses input focus.+type WindowFocusCallback        = Window -> Bool                                            -> IO ()+-- | Fires when the window is iconified (minimized) or not.+type WindowIconifyCallback      = Window -> Bool                                            -> IO ()+-- | Fires when the size of the framebuffer for the window changes (in Pixels).+type FramebufferSizeCallback    = Window -> Int -> Int                                      -> IO ()+-- | Fires whenever a mouse button is clicked.+type MouseButtonCallback        = Window -> MouseButton -> MouseButtonState -> ModifierKeys -> IO ()+-- | Fires every time the cursor position changes. Sub-pixel accuracy is used, when available.+type CursorPosCallback          = Window -> Double -> Double                                -> IO ()+-- | Fires when the cursor enters or exits the client area of the window.+type CursorEnterCallback        = Window -> CursorState                                     -> IO ()+-- | Fires when the user scrolls the mouse wheel or via touch gesture.+type ScrollCallback             = Window -> Double -> Double                                -> IO ()+-- | Fires for each press or repeat of keyboard keys (regardless of if it has textual meaning or not, eg Shift)+type KeyCallback                = Window -> Key -> Int -> KeyState -> ModifierKeys          -> IO ()+-- | Fires when a complete character codepoint is typed by the user, Shift then "b" generates "B".+type CharCallback               = Window -> Char                                            -> IO ()+-- | Similar to 'CharCallback', fires when a complete unicode codepoint is typed by the user.+type CharModsCallback           = Window -> Char -> ModifierKeys                            -> IO ()+-- | Fires when a monitor is connected or disconnected.+type MonitorCallback            = Monitor -> MonitorState                                   -> IO ()+-- | Fires when a joystick is connected or disconnected.+type JoystickCallback           = Joystick -> JoystickState                                 -> IO ()+-- | Fires when a window is rescaled+type WindowContentScaleCallback = Window -> Float -> Float                                  -> IO ()+-- | Fires when a window is maximized or restored. Returns True if the window+-- was maximized and False if the window was restored.+type WindowMaximizeCallback = Window -> Bool                                                -> IO ()+--------------------------------------------------------------------------------+-- CB scheduling++data ScheduledCallbacks = ScheduledCallbacks+  { _forward :: [IO ()] -- Execution iterates this list+  , _backward :: [IO ()] -- New schedules prepend here+  }++storedScheduledCallbacks :: IORef ScheduledCallbacks+storedScheduledCallbacks = unsafePerformIO . newIORef $ ScheduledCallbacks [] []++-- This NOINLINE pragma is due to use of unsafePerformIO.+-- See http://hackage.haskell.org/packages/archive/base/latest/doc/html/System-IO-Unsafe.html#v:unsafePerformIO .++{-# NOINLINE storedScheduledCallbacks #-}++-- This is provided in newer "base" versions. To avoid depending on+-- it, it's reimplemented here. Should remove if/when compatibility+-- with older base is not an issue:+atomicModifyIORef' :: IORef a -> (a -> (a,b)) -> IO b+atomicModifyIORef' ref f = do+    b <- atomicModifyIORef ref+            (\x -> let (a, b) = f x+                    in (a, a `seq` b))+    b `seq` return b++schedule :: IO () -> IO ()+schedule act =+  atomicModifyIORef' storedScheduledCallbacks $+  \(ScheduledCallbacks oldForward oldBackward) ->+  (ScheduledCallbacks oldForward (act : oldBackward), ())++splitFirst :: [a] -> (Maybe a, [a])+splitFirst [] = (Nothing, [])+splitFirst (x:xs) = (Just x, xs)++getNextScheduled :: IO (Maybe (IO ()))+getNextScheduled =+  atomicModifyIORef storedScheduledCallbacks $+  \(ScheduledCallbacks oldForward oldBackward) ->+  case oldForward of+    [] ->+      let (mCb, newForward) = splitFirst (reverse oldBackward)+      in (ScheduledCallbacks newForward [], mCb)+    (cb:rest) ->                -- Eat forward first+      (ScheduledCallbacks rest oldBackward, Just cb)++executeScheduled :: IO ()+executeScheduled = do+  mcb <- getNextScheduled+  case mcb of+    Nothing -> return ()+    Just cb -> cb >> executeScheduled++--------------------------------------------------------------------------------+-- Error handling++-- | Can (and probably should) be used before GLFW initialization.+-- See <http://www.glfw.org/docs/3.3/group__init.html#gaa5d796c3cf7c1a7f02f845486333fb5f glfwSetErrorCallback>+setErrorCallback :: Maybe ErrorCallback -> IO ()+setErrorCallback = setCallback+    mk'GLFWerrorfun+    (\cb a0 a1 -> do+        s <- peekCString a1+        schedule $ cb (fromC a0) s)+    c'glfwSetErrorCallback+    storedErrorFun++--------------------------------------------------------------------------------+-- Image utility functions++withGLFWImage :: Image -> (Ptr C'GLFWimage -> IO a) -> IO a+withGLFWImage (Image w h pxs) f =+  alloca        $ \p'img ->+  withArray pxs $ \p'pxs -> do+    poke p'img $ C'GLFWimage (toC w) (toC h) p'pxs+    f p'img++--------------------------------------------------------------------------------+-- Initialization and version information++-- | Attempts to initialize the GLFW library. When the library is not initialized, the only+-- allowed functions to call are 'getVersion', 'getVersionString', 'setErrorCallback',+-- 'init', and 'terminate'. Returns if the initialization was successful or not.+-- See <http://www.glfw.org/docs/3.3/group__init.html#ga317aac130a235ab08c6db0834907d85e glfwInit>+-- and <http://www.glfw.org/docs/3.3/intro.html#intro_init Initialization and Termination>+init :: IO Bool+init = fromC `fmap` c'glfwInit++-- | This function sets hints for the next initialization of GLFW. See+-- <https://www.glfw.org/docs/3.3/group__init.html#ga110fd1d3f0412822b4f1908c026f724a glfwInitHint>+initHint :: InitHint -> Bool -> IO ()+initHint hint val = c'glfwInitHint (toC hint) (toC val)++-- | Cleans up GLFW and puts the library into an uninitialized state.+-- Once you call this, you must initilize the library again.+-- Warning: No window's context may be current in another thread when this is called.+-- See <http://www.glfw.org/docs/3.3/group__init.html#gaaae48c0a18607ea4a4ba951d939f0901 glfwTerminate>+-- and <http://www.glfw.org/docs/3.3/intro.html#intro_init Initialization and Termination>. This+-- function is not <https://www.glfw.org/docs/latest/intro.html#reentrancy reentrant>.+terminate :: IO ()+terminate = do+    c'glfwTerminate+    -- Free all stored FunPtrs.+    storeCallback storedErrorFun           nullFunPtr+    storeCallback storedMonitorFun         nullFunPtr+    storeCallback storedJoystickFun         nullFunPtr++-- | Gets the version of the GLFW library that's being used with the current program.+-- See <http://www.glfw.org/docs/3.3/group__init.html#ga9f8ffaacf3c269cc48eafbf8b9b71197 glfwGetVersion>+getVersion :: IO Version+getVersion =+    allocaArray 3 $ \p -> do+        let p0 = p+            p1 = p `advancePtr` 1+            p2 = p `advancePtr` 2+        c'glfwGetVersion p0 p1 p2+        v0 <- fromC `fmap` peek p0+        v1 <- fromC `fmap` peek p1+        v2 <- fromC `fmap` peek p2+        return $ Version v0 v1 v2++-- | Gets the compile-time version string of the GLFW library binary.+-- Gives extra info like platform and compile time options used, but you should not+-- attempt to parse this to get the GLFW version number. Use 'getVersion' instead.+-- See <http://www.glfw.org/docs/3.3/group__init.html#ga23d47dc013fce2bf58036da66079a657 glfwGetVersionString>+getVersionString :: IO (Maybe String)+getVersionString = do+    p'vs <- c'glfwGetVersionString+    if p'vs /= nullPtr+      then Just `fmap` peekCString p'vs+      else return Nothing++-- | Returns and clears the error code of the last error that occurred on the+-- calling thread and a UTF-8 encoded human-readable description of it.  If no+-- error has occurred since the last call, it returns Nothing.+getError :: IO (Maybe (Error, String))+getError = alloca $ \errStr -> do+  err <- c'glfwGetError errStr+  if err == c'GLFW_NO_ERROR+    then return Nothing+    else peek errStr+         >>= peekCString+         >>= (\s -> return $ Just (fromC err, s))++-- | Clears the last error as would be retreived by 'getError'.+clearError :: IO ()+clearError = c'glfwGetError nullPtr >> pure ()++-- | Returns true if raw mouse motion is supported on the current system.+-- See <https://www.glfw.org/docs/3.3/group__input.html#gae4ee0dbd0d256183e1ea4026d897e1c2 glfwRawMouseMotionSupported>+rawMouseMotionSupported :: IO Bool+rawMouseMotionSupported = fromC <$> c'glfwRawMouseMotionSupported++--------------------------------------------------------------------------------+-- Monitor handling++-- | Gets the list of available monitors, if possible.+-- See <http://www.glfw.org/docs/3.3/group__monitor.html#ga3fba51c8bd36491d4712aa5bd074a537 glfwGetMonitors>+getMonitors :: IO (Maybe [Monitor])+getMonitors =+    alloca $ \p'n -> do+        p'mon <- c'glfwGetMonitors p'n+        n <- fromC `fmap` peek p'n+        if p'mon == nullPtr || n <= 0+          then return Nothing+          else (Just . map fromC) `fmap` peekArray n p'mon++-- | Gets the primary monitor.+-- See <http://www.glfw.org/docs/3.3/group__monitor.html#ga721867d84c6d18d6790d64d2847ca0b1 glfwGetPrimaryMonitor>+getPrimaryMonitor :: IO (Maybe Monitor)+getPrimaryMonitor = do+    p'mon <- c'glfwGetPrimaryMonitor+    return $+      if p'mon == nullPtr+        then Nothing+        else Just $ fromC p'mon++-- | Gets the position of the specified monitor within the coordinate space.+-- See <http://www.glfw.org/docs/3.3/group__monitor.html#ga102f54e7acc9149edbcf0997152df8c9 glfwGetMonitorPos>+getMonitorPos :: Monitor -> IO (Int, Int)+getMonitorPos mon =+    allocaArray 2 $ \p -> do+        let p'x = p+            p'y = p `advancePtr` 1+        c'glfwGetMonitorPos (toC mon) p'x p'y+        x <- fromC `fmap` peek p'x+        y <- fromC `fmap` peek p'y+        return (x, y)++-- | The physical width and height of the monitor.+-- See <http://www.glfw.org/docs/3.3/group__monitor.html#ga7d8bffc6c55539286a6bd20d32a8d7ea glfwGetMonitorPhysicalSize>+getMonitorPhysicalSize :: Monitor -> IO (Int, Int)+getMonitorPhysicalSize mon =+    allocaArray 2 $ \p -> do+        let p'w = p+            p'h = p `advancePtr` 1+        c'glfwGetMonitorPhysicalSize (toC mon) p'w p'h+        w <- fromC `fmap` peek p'w+        h <- fromC `fmap` peek p'h+        return (w, h)++-- | A human-readable name for the monitor specified.+-- See <http://www.glfw.org/docs/3.3/group__monitor.html#ga79a34ee22ff080ca954a9663e4679daf getMonitorName>+getMonitorName :: Monitor -> IO (Maybe String)+getMonitorName mon = do+    p'name <- c'glfwGetMonitorName (toC mon)+    if p'name == nullPtr+      then return Nothing+      else Just `fmap` peekCString p'name++-- | Sets a callback for when a monitor is connected or disconnected.+-- See <http://www.glfw.org/docs/3.3/group__monitor.html#gac3fe0f647f68b731f99756cd81897378 glfwSetMonitorCallback>+setMonitorCallback :: Maybe MonitorCallback -> IO ()+setMonitorCallback = setCallback+    mk'GLFWmonitorfun+    (\cb a0 a1 -> schedule $ cb (fromC a0) (fromC a1))+    c'glfwSetMonitorCallback+    storedMonitorFun++-- | Obtains the possible video modes of the monitor.+-- See <http://www.glfw.org/docs/3.3/group__monitor.html#ga820b0ce9a5237d645ea7cbb4bd383458 glfwGetVideoModes>+getVideoModes :: Monitor -> IO (Maybe [VideoMode])+getVideoModes mon =+    alloca $ \p'n -> do+        p'vms <- c'glfwGetVideoModes (toC mon) p'n+        n <- fromC `fmap` peek p'n+        if p'vms == nullPtr || n <= 0+          then return Nothing+          else (Just . map fromC) `fmap` peekArray n p'vms++-- | Gets the active video mode of the monitor.+-- See <http://www.glfw.org/docs/3.3/group__monitor.html#gafc1bb972a921ad5b3bd5d63a95fc2d52 glfwGetVideoMode>+getVideoMode :: Monitor -> IO (Maybe VideoMode)+getVideoMode mon = do+    p'vm <- c'glfwGetVideoMode (toC mon)+    if p'vm == nullPtr+      then return Nothing+      else (Just . fromC) `fmap` peek p'vm++-- | Sets the gamma of a monitor.+-- See <http://www.glfw.org/docs/3.3/group__monitor.html#ga6ac582625c990220785ddd34efa3169a glfwSetGamma>+setGamma :: Monitor -> Double -> IO ()+setGamma mon e =+    c'glfwSetGamma (toC mon) (toC e)++-- | Gets the gamma ramp in use with the monitor.+-- See <http://www.glfw.org/docs/3.3/group__monitor.html#gab7c41deb2219bde3e1eb756ddaa9ec80 glfwGetGammaRamp>+getGammaRamp :: Monitor -> IO (Maybe GammaRamp)+getGammaRamp m = do+    p'ggr <- c'glfwGetGammaRamp (toC m)+    if p'ggr == nullPtr+      then return Nothing+      else do+          ggr <- peek p'ggr+          let p'rs = c'GLFWgammaramp'red   ggr+              p'gs = c'GLFWgammaramp'green ggr+              p'bs = c'GLFWgammaramp'blue  ggr+              cn   = c'GLFWgammaramp'size  ggr+              n    = fromC cn+          if n == 0 || nullPtr `elem` [p'rs, p'gs, p'bs]+            then return Nothing+            else do+                rs <- map fromC `fmap` peekArray n p'rs+                gs <- map fromC `fmap` peekArray n p'gs+                bs <- map fromC `fmap` peekArray n p'bs+                return $ Just GammaRamp+                  { gammaRampRed   = rs+                  , gammaRampGreen = gs+                  , gammaRampBlue  = bs+                  }++-- | Assigns a gamma ramp to use with the given monitor.+-- See <http://www.glfw.org/docs/3.3/group__monitor.html#ga583f0ffd0d29613d8cd172b996bbf0dd glfwSetGammaRamp>+setGammaRamp :: Monitor -> GammaRamp -> IO ()+setGammaRamp mon gr =+    let rs = map toC $ gammaRampRed   gr :: [CUShort]+        gs = map toC $ gammaRampGreen gr :: [CUShort]+        bs = map toC $ gammaRampBlue  gr :: [CUShort]+        -- GammaRamp's smart constructor ensures that the RGB lists all have+        -- equal length, so just use the number of reds.+        cn = toC $ length rs :: CUInt+    in alloca       $ \p'ggr ->+       withArray rs $ \p'rs  ->+       withArray gs $ \p'gs  ->+       withArray bs $ \p'bs  -> do+          let ggr = C'GLFWgammaramp+                      { c'GLFWgammaramp'red   = p'rs+                      , c'GLFWgammaramp'green = p'gs+                      , c'GLFWgammaramp'blue  = p'bs+                      , c'GLFWgammaramp'size  = cn+                      }+          poke p'ggr ggr+          c'glfwSetGammaRamp (toC mon) p'ggr++-- | This function retrieves the content scale for the specified monitor. The+-- content scale is the ratio between the current DPI and the platform's default+-- DPI.+-- See <https://www.glfw.org/docs/3.3/group__monitor.html#gad3152e84465fa620b601265ebfcdb21b glfwGetMonitorContentScale>+getMonitorContentScale :: Monitor -> IO (Float, Float)+getMonitorContentScale mon =+  alloca $ \p'x ->+  alloca $ \p'y -> do+    c'glfwGetMonitorContentScale (toC mon) p'x p'y+    CFloat x <- peek p'x+    CFloat y <- peek p'y+    return (x, y)++-- | This function returns the position, in screen coordinates, of the+-- upper-left corner of the work area of the specified monitor along with the+-- work area size in screen coordinates. Returned tuple is:+-- (xPos, yPos, width, height)+-- See <https://www.glfw.org/docs/3.3/group__monitor.html#ga7387a3bdb64bfe8ebf2b9e54f5b6c9d0 glfwGetMonitorWorkarea>+getMonitorWorkarea :: Monitor -> IO (Int, Int, Int, Int)+getMonitorWorkarea mon =+  alloca $ \p'x ->+  alloca $ \p'y ->+  alloca $ \p'w ->+  alloca $ \p'h -> do+    c'glfwGetMonitorWorkarea (toC mon) p'x p'y p'w p'h+    x <- fromC <$> peek p'x+    y <- fromC <$> peek p'y+    w <- fromC <$> peek p'w+    h <- fromC <$> peek p'h+    return (x, y, w, h)++--------------------------------------------------------------------------------+-- Window handling++-- | Sets all the window hints to default.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gaa77c4898dfb83344a6b4f76aa16b9a4a glfwDefaultWindowHints>+defaultWindowHints :: IO ()+defaultWindowHints =+    c'glfwDefaultWindowHints++setStringHint :: CInt -> String -> IO ()+setStringHint hint = flip withCString (c'glfwWindowHintString hint)++-- | Hints something to the GLFW windowing system.+-- See+-- <http://www.glfw.org/docs/3.3/group__window.html#ga7d9c8c62384b1e2821c4dc48952d2033 glfwWindowHint>+-- and+-- <https://www.glfw.org/docs/3.3/group__window.html#ga8cb2782861c9d997bcf2dea97f363e5f glfwWindowHintString>+windowHint :: WindowHint -> IO ()+windowHint (WindowHint'Resizable              x) =+  c'glfwWindowHint c'GLFW_RESIZABLE                (toC x)+windowHint (WindowHint'Visible                x) =+  c'glfwWindowHint c'GLFW_VISIBLE                  (toC x)+windowHint (WindowHint'Decorated              x) =+  c'glfwWindowHint c'GLFW_DECORATED                (toC x)+windowHint (WindowHint'RedBits                x) =+  c'glfwWindowHint c'GLFW_RED_BITS                 (toC x)+windowHint (WindowHint'GreenBits              x) =+  c'glfwWindowHint c'GLFW_GREEN_BITS               (toC x)+windowHint (WindowHint'BlueBits               x) =+  c'glfwWindowHint c'GLFW_BLUE_BITS                (toC x)+windowHint (WindowHint'AlphaBits              x) =+  c'glfwWindowHint c'GLFW_ALPHA_BITS               (toC x)+windowHint (WindowHint'DepthBits              x) =+  c'glfwWindowHint c'GLFW_DEPTH_BITS               (toC x)+windowHint (WindowHint'StencilBits            x) =+  c'glfwWindowHint c'GLFW_STENCIL_BITS             (toC x)+windowHint (WindowHint'AccumRedBits           x) =+  c'glfwWindowHint c'GLFW_ACCUM_RED_BITS           (toC x)+windowHint (WindowHint'AccumGreenBits         x) =+  c'glfwWindowHint c'GLFW_ACCUM_GREEN_BITS         (toC x)+windowHint (WindowHint'AccumBlueBits          x) =+  c'glfwWindowHint c'GLFW_ACCUM_BLUE_BITS          (toC x)+windowHint (WindowHint'AccumAlphaBits         x) =+  c'glfwWindowHint c'GLFW_ACCUM_ALPHA_BITS         (toC x)+windowHint (WindowHint'AuxBuffers             x) =+  c'glfwWindowHint c'GLFW_AUX_BUFFERS              (toC x)+windowHint (WindowHint'Samples                x) =+  c'glfwWindowHint c'GLFW_SAMPLES                  (toC x)+windowHint (WindowHint'RefreshRate            x) =+  c'glfwWindowHint c'GLFW_REFRESH_RATE             (toC x)+windowHint (WindowHint'DoubleBuffer           x) =+  c'glfwWindowHint c'GLFW_DOUBLEBUFFER             (toC x)+windowHint (WindowHint'Stereo                 x) =+  c'glfwWindowHint c'GLFW_STEREO                   (toC x)+windowHint (WindowHint'sRGBCapable            x) =+  c'glfwWindowHint c'GLFW_SRGB_CAPABLE             (toC x)+windowHint (WindowHint'Floating               x) =+  c'glfwWindowHint c'GLFW_FLOATING                 (toC x)+windowHint (WindowHint'Focused                x) =+  c'glfwWindowHint c'GLFW_FOCUSED                  (toC x)+windowHint (WindowHint'Maximized              x) =+  c'glfwWindowHint c'GLFW_MAXIMIZED                (toC x)+windowHint (WindowHint'AutoIconify            x) =+  c'glfwWindowHint c'GLFW_AUTO_ICONIFY             (toC x)+windowHint (WindowHint'ClientAPI              x) =+  c'glfwWindowHint c'GLFW_CLIENT_API               (toC x)+windowHint (WindowHint'ContextCreationAPI     x) =+  c'glfwWindowHint c'GLFW_CONTEXT_CREATION_API     (toC x)+windowHint (WindowHint'ContextVersionMajor    x) =+  c'glfwWindowHint c'GLFW_CONTEXT_VERSION_MAJOR    (toC x)+windowHint (WindowHint'ContextVersionMinor    x) =+  c'glfwWindowHint c'GLFW_CONTEXT_VERSION_MINOR    (toC x)+windowHint (WindowHint'ContextRobustness      x) =+  c'glfwWindowHint c'GLFW_CONTEXT_ROBUSTNESS       (toC x)+windowHint (WindowHint'ContextReleaseBehavior x) =+  c'glfwWindowHint c'GLFW_CONTEXT_RELEASE_BEHAVIOR (toC x)+windowHint (WindowHint'ContextNoError         x) =+  c'glfwWindowHint c'GLFW_CONTEXT_NO_ERROR         (toC x)+windowHint (WindowHint'OpenGLForwardCompat    x) =+  c'glfwWindowHint c'GLFW_OPENGL_FORWARD_COMPAT    (toC x)+windowHint (WindowHint'OpenGLDebugContext     x) =+  c'glfwWindowHint c'GLFW_OPENGL_DEBUG_CONTEXT     (toC x)+windowHint (WindowHint'OpenGLProfile          x) =+  c'glfwWindowHint c'GLFW_OPENGL_PROFILE           (toC x)+windowHint (WindowHint'TransparentFramebuffer x) =+  c'glfwWindowHint c'GLFW_TRANSPARENT_FRAMEBUFFER  (toC x)+windowHint (WindowHint'CenterCursor           x) =+  c'glfwWindowHint c'GLFW_CENTER_CURSOR            (toC x)+windowHint (WindowHint'FocusOnShow            x) =+  c'glfwWindowHint c'GLFW_FOCUS_ON_SHOW            (toC x)+windowHint (WindowHint'ScaleToMonitor         x) =+  c'glfwWindowHint c'GLFW_SCALE_TO_MONITOR         (toC x)+windowHint (WindowHint'CocoaRetinaFramebuffer x) =+  c'glfwWindowHint c'GLFW_COCOA_RETINA_FRAMEBUFFER (toC x)+windowHint (WindowHint'CocoaGraphicsSwitching x) =+  c'glfwWindowHint c'GLFW_COCOA_GRAPHICS_SWITCHING (toC x)+windowHint (WindowHint'CocoaFrameName  x) = setStringHint c'GLFW_COCOA_FRAME_NAME  x+windowHint (WindowHint'X11ClassName    x) = setStringHint c'GLFW_X11_CLASS_NAME    x+windowHint (WindowHint'X11InstanceName x) = setStringHint c'GLFW_X11_INSTANCE_NAME x++-- | Creates a new window.+-- Note: If running in GHCI don't forget to @:set -fno-ghci-sandbox@ or you+-- may run into an assertion failure, segfault or other nasty crash.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga5c336fddf2cbb5b92f65f10fb6043344 glfwCreateWindow>+createWindow :: Int -- ^ Desired width for the window.+             -> Int -- ^ Desired height for the window.+             -> String -- ^ Desired title for the window.+             -> Maybe Monitor -- ^ Monitor to use in fullscreen mode.+             -> Maybe Window  -- ^ Window for context object sharing, see+                              -- <http://www.glfw.org/docs/3.3/context.html#context_sharing here>.+             -> IO (Maybe Window)+createWindow w h title mmon mwin =+    withCString title $ \ptitle -> do+        charFun               <- newIORef nullFunPtr+        charModsFun           <- newIORef nullFunPtr+        cursorEnterFun        <- newIORef nullFunPtr+        cursorPosFun          <- newIORef nullFunPtr+        framebufferSizeFun    <- newIORef nullFunPtr+        keyFun                <- newIORef nullFunPtr+        mouseButtonFun        <- newIORef nullFunPtr+        scrollFun             <- newIORef nullFunPtr+        windowCloseFun        <- newIORef nullFunPtr+        windowFocusFun        <- newIORef nullFunPtr+        windowIconifyFun      <- newIORef nullFunPtr+        windowPosFun          <- newIORef nullFunPtr+        windowRefreshFun      <- newIORef nullFunPtr+        windowSizeFun         <- newIORef nullFunPtr+        windowContentScaleFun <- newIORef nullFunPtr+        windowMaximizeFun     <- newIORef nullFunPtr+        dropFun               <- newIORef nullFunPtr+        let callbacks = WindowCallbacks+              { storedCharFun               = charFun+              , storedCharModsFun           = charModsFun+              , storedCursorEnterFun        = cursorEnterFun+              , storedCursorPosFun          = cursorPosFun+              , storedFramebufferSizeFun    = framebufferSizeFun+              , storedKeyFun                = keyFun+              , storedMouseButtonFun        = mouseButtonFun+              , storedScrollFun             = scrollFun+              , storedWindowCloseFun        = windowCloseFun+              , storedWindowFocusFun        = windowFocusFun+              , storedWindowIconifyFun      = windowIconifyFun+              , storedWindowPosFun          = windowPosFun+              , storedWindowRefreshFun      = windowRefreshFun+              , storedWindowSizeFun         = windowSizeFun+              , storedWindowContentScaleFun = windowContentScaleFun+              , storedWindowMaximizeFun     = windowMaximizeFun+              , storedDropFun               = dropFun+              }+        p'win <- c'glfwCreateWindow+          (toC w)+          (toC h)+          ptitle+          (maybe nullPtr toC mmon)+          (maybe nullPtr toC mwin)+        if p'win == nullPtr+          then return Nothing+          else do callbackPtr <- newStablePtr callbacks+                  c'glfwSetWindowUserPointer p'win (castStablePtrToPtr callbackPtr)+                  -- Not sure why this isn't the default...+                  c'glfwSetInputMode p'win c'GLFW_LOCK_KEY_MODS (toC True)+                  return $ Just $ fromC p'win++-- | Cleans up a window and all associated resources+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacdf43e51376051d2c091662e9fe3d7b2 glfwDestroyWindow>.+-- This function is not <https://www.glfw.org/docs/latest/intro.html#reentrancy reentrant>.+destroyWindow :: Window -> IO ()+destroyWindow win = do+    pcb <- castPtrToStablePtr `liftM` c'glfwGetWindowUserPointer (toC win)+    cbs <- deRefStablePtr pcb+    c'glfwDestroyWindow (toC win)++    let free callback = do funptr <- readIORef (callback cbs)+                           when (funptr /= nullFunPtr) $ freeHaskellFunPtr funptr+    free storedCharFun+    free storedCharModsFun+    free storedCursorEnterFun+    free storedCursorPosFun+    free storedFramebufferSizeFun+    free storedKeyFun+    free storedMouseButtonFun+    free storedScrollFun+    free storedWindowCloseFun+    free storedWindowFocusFun+    free storedWindowIconifyFun+    free storedWindowPosFun+    free storedWindowRefreshFun+    free storedWindowSizeFun+    freeStablePtr pcb++-- | Returns the value of an attribute of the specified window or its OpenGL or+-- OpenGL ES context.+-- See <https://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowAttrib :: Window -> WindowAttrib -> IO Bool+getWindowAttrib win attrib =+  fromC <$> c'glfwGetWindowAttrib (toC win) (toC attrib)++-- | Sets the value of an attribute of the specified window.+-- See <https://www.glfw.org/docs/3.3/group__window.html#gace2afda29b4116ec012e410a6819033e glfwSetWindowAttrib>+setWindowAttrib :: Window -> WindowAttrib -> Bool -> IO ()+setWindowAttrib win attrib = c'glfwSetWindowAttrib (toC win) (toC attrib) . toC++-- | If the window should close or not.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga24e02fbfefbb81fc45320989f8140ab5 glfwWindowShouldClose>+windowShouldClose :: Window -> IO Bool+windowShouldClose win =+    fromC `fmap` c'glfwWindowShouldClose (toC win)++-- | Sets if the window should close or not.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga49c449dde2a6f87d996f4daaa09d6708 glfwSetWindowShouldClose>+setWindowShouldClose :: Window -> Bool -> IO ()+setWindowShouldClose win b =+    c'glfwSetWindowShouldClose (toC win) (toC b)++-- | Returns the opacity of the window, including any decorations.+-- See <https://www.glfw.org/docs/3.3/group__window.html#gad09f0bd7a6307c4533b7061828480a84 glfwGetWindowOpacity+getWindowOpacity :: Window -> IO Float+getWindowOpacity = fmap hFloat . c'glfwGetWindowOpacity . toC++-- | Sets the opacity of the window, including any decorations+-- See <https://www.glfw.org/docs/3.3/group__window.html#gac31caeb3d1088831b13d2c8a156802e9 glfwSetWindowOpacity>+setWindowOpacity :: Window -> Float -> IO ()+setWindowOpacity win op = c'glfwSetWindowOpacity (toC win) (CFloat op)++-- | Sets the Title string of the window.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga5d877f09e968cef7a360b513306f17ff glfwSetWindowTitle>+setWindowTitle :: Window -> String -> IO ()+setWindowTitle win title =+    withCString title $ c'glfwSetWindowTitle (toC win)++-- | Gets the window's position (in screen coordinates).+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga73cb526c000876fd8ddf571570fdb634 glfwGetWindowPos>+getWindowPos :: Window -> IO (Int, Int)+getWindowPos win =+    allocaArray 2 $ \p -> do+        let p'x = p+            p'y = p `advancePtr` 1+        c'glfwGetWindowPos (toC win) p'x p'y+        x <- fromC `fmap` peek p'x+        y <- fromC `fmap` peek p'y+        return (x, y)++-- | Sets the window's position (in screen coordinates).+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga1abb6d690e8c88e0c8cd1751356dbca8 glfwSetWindowPos>+setWindowPos :: Window -> Int -> Int -> IO ()+setWindowPos win x y =+    c'glfwSetWindowPos (toC win) (toC x) (toC y)++-- | Gets the size of the window (in screen coordinates).+-- See <http://www.glfw.org/docs/3.3/group__window.html#gaeea7cbc03373a41fb51cfbf9f2a5d4c6 glfwGetWindowSize>+getWindowSize :: Window -> IO (Int, Int)+getWindowSize win =+    allocaArray 2 $ \p -> do+        let p'w = p+            p'h = p `advancePtr` 1+        c'glfwGetWindowSize (toC win) p'w p'h+        w <- fromC `fmap` peek p'w+        h <- fromC `fmap` peek p'h+        return (w, h)++-- | Gets the size of the frame around the window (in screen coordinates). This+-- size includes the title bar, if the window has one. Not to be confused with+-- 'getFramebufferSize', which gets the size of the rendering area.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga1a9fd382058c53101b21cf211898f1f1 glfwGetWindowFrameSize>+getWindowFrameSize :: Window -> IO (Int, Int, Int, Int)+getWindowFrameSize win =+    allocaArray 4 $ \p -> do+        let p'l = p+            p't = p `advancePtr` 1+            p'r = p `advancePtr` 2+            p'b = p `advancePtr` 3+        c'glfwGetWindowFrameSize (toC win) p'l p't p'r p'b+        l <- fromC `fmap` peek p'l+        t <- fromC `fmap` peek p't+        r <- fromC `fmap` peek p'r+        b <- fromC `fmap` peek p'b+        return (l, t, r, b)++-- | Sets the size of the client area for the window (in screen coordinates).+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga371911f12c74c504dd8d47d832d095cb glfwSetWindowSize>+setWindowSize :: Window -> Int -> Int -> IO ()+setWindowSize win w h =+    c'glfwSetWindowSize (toC win) (toC w) (toC h)++-- | Sets the size limits of the client area of the specified window. If the+-- window is full screen, the size limits only take effect once it is made+-- windowed. If the window is not resizable this function does nothing. Pass+-- 'Nothing' in any argument to disable the limit.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gac314fa6cec7d2d307be9963e2709cc90 glfwSetWindowSizeLimits>+setWindowSizeLimits :: Window+                    -> Maybe Int+                    -- ^ The minimum width, in screen coordinates, of the client+                    --   area.+                    -> Maybe Int+                    -- ^ The minimum height, in screen coordinates, of the+                    --   client area.+                    -> Maybe Int+                    -- ^ The maximum width, in screen coordinates, of the client+                    --   area.+                    -> Maybe Int+                    -- ^ The maximum height, in screen coordinates, of the+                    --   client area.+                    -> IO ()+setWindowSizeLimits win min'w min'h max'w max'h =+  c'glfwSetWindowSizeLimits (toC win) (toC min'w) (toC min'h)+                                      (toC max'w) (toC max'h)++-- | Sets the required aspect ratio of the client area of the specified window.+-- Pass Nothing to disable the limit.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga72ac8cb1ee2e312a878b55153d81b937 glfwSetWindowAspectRatio>+setWindowAspectRatio :: Window -> Maybe (Int, Int) -> IO ()+setWindowAspectRatio win Nothing =+  c'glfwSetWindowAspectRatio (toC win) c'GLFW_DONT_CARE c'GLFW_DONT_CARE+setWindowAspectRatio win (Just (w, h)) =+  c'glfwSetWindowAspectRatio (toC win) (toC w) (toC h)++-- | This function retrieves the content scale for the specified window. The+-- content scale is the ratio between the current DPI and the platform's+-- default DPI.+-- See <https://www.glfw.org/docs/3.3/group__window.html#gaf5d31de9c19c4f994facea64d2b3106c glfwGetWindowContentScale>+getWindowContentScale :: Window -> IO (Float, Float)+getWindowContentScale win =+    alloca $ \p'x ->+    alloca $ \p'y -> do+        c'glfwGetWindowContentScale (toC win) p'x p'y+        CFloat x <- peek p'x+        CFloat y <- peek p'y+        return (x, y)++-- | The size of the framebuffer (in Pixels)+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga0e2637a4161afb283f5300c7f94785c9 glfwGetFramebufferSize>+getFramebufferSize :: Window -> IO (Int, Int)+getFramebufferSize win =+    allocaArray 2 $ \p -> do+        let p'w = p+            p'h = p `advancePtr` 1+        c'glfwGetFramebufferSize (toC win) p'w p'h+        w <- fromC `fmap` peek p'w+        h <- fromC `fmap` peek p'h+        return (w, h)++-- | Sets the icon of the specified window. The system will try to find the+-- image with the dimensions closest to the ones required by the platform. This+-- image is then scaled and used as the icon for that size. Good sizes are+-- 16x16, 32x32, and 48x48. Pass the empty list to reset to the default icon.+-- Has no effect on OS X (See the <https://developer.apple.com/library/content/documentation/CoreFoundation/Conceptual/CFBundles/Introduction/Introduction.html Bundle Programming Guide>)+setWindowIcon :: Window -> [Image] -> IO ()+setWindowIcon win [] = c'glfwSetWindowIcon (toC win) 0 nullPtr+setWindowIcon win imgs =+  let arrSizeBytes = length imgs * sizeOf (undefined :: C'GLFWimage)++      addNextImage :: [Image] -> Int -> Ptr C'GLFWimage -> IO ()+      addNextImage [] numImages ptr =+        c'glfwSetWindowIcon (toC win) (toC numImages) ptr++      addNextImage (img:rest) idx ptr =+        withGLFWImage img $ \p'img -> do+          c'img <- peek p'img+          pokeElemOff ptr idx c'img+          addNextImage rest (idx + 1) ptr+  in allocaBytes arrSizeBytes $ addNextImage imgs 0++-- | Iconifies (minimizes) the window.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga1bb559c0ebaad63c5c05ad2a066779c4 glfwIconifyWindow>+iconifyWindow :: Window -> IO ()+iconifyWindow = c'glfwIconifyWindow . toC++-- | Restores the window from an iconified/minimized state.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga52527a5904b47d802b6b4bb519cdebc7 glfwRestoreWindow>+restoreWindow :: Window -> IO ()+restoreWindow = c'glfwRestoreWindow . toC++-- | Brings the specified window to front and sets input focus. The window+-- should already be visible and not iconified.+-- See <http://www.glfw.org/docs/latest/group__window.html#ga873780357abd3f3a081d71a40aae45a1 glfwFocusWindow>+focusWindow :: Window -> IO ()+focusWindow = c'glfwFocusWindow . toC++-- | Maximizes the specified window if it was not already maximized.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga3f541387449d911274324ae7f17ec56b glfwMaximizeWindow>+maximizeWindow :: Window -> IO ()+maximizeWindow = c'glfwMaximizeWindow . toC++-- | Shows the window.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga61be47917b72536a148300f46494fc66 glfwShowWindow>+showWindow :: Window -> IO ()+showWindow = c'glfwShowWindow . toC++-- | Hides the window.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga49401f82a1ba5f15db5590728314d47c glfwHideWindow>+hideWindow :: Window -> IO ()+hideWindow = c'glfwHideWindow . toC++-- | Requests user attention to the specified window.+-- See <https://www.glfw.org/docs/3.3/group__window.html#ga2f8d59323fc4692c1d54ba08c863a703 glfwRequestWindowAttention>+requestWindowAttention :: Window -> IO ()+requestWindowAttention = c'glfwRequestWindowAttention . toC++-- | Gets the monitor that this window is running on, provided the window is+-- fullscreen.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gaeac25e64789974ccbe0811766bd91a16 glfwGetWindowMonitor>+getWindowMonitor :: Window -> IO (Maybe Monitor)+getWindowMonitor win = do+    p'mon <- c'glfwGetWindowMonitor (toC win)+    return $ if p'mon == nullPtr+      then Nothing+      else Just $ fromC p'mon++-- | Sets the position of the cursor within the window.+-- See <http://www.glfw.org/docs/3.3/group__input.html#ga04b03af936d906ca123c8f4ee08b39e7 glfwSetCursorPos>+setCursorPos :: Window -> Double -> Double -> IO ()+setCursorPos win x y =+    c'glfwSetCursorPos (toC win) (toC x) (toC y)++-- | Makes a window fullscreen on the given monitor. The number of red, green,+-- and blue bits is ignored. Note, this shouldn't be used to update the+-- resolution of a fullscreen window. Use 'setWindowSize' instead.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga81c76c418af80a1cce7055bccb0ae0a7 glfwSetWindowMonitor>+setFullscreen :: Window -> Monitor -> VideoMode -> IO ()+setFullscreen win mon (VideoMode width height _ _ _ refresh) =+  c'glfwSetWindowMonitor (toC win) (toC mon) 0 0 (toC width) (toC height) (toC refresh)++-- | Updates a window to be windowed instead of fullscreen. Note, this shouldn't+-- be used to update the position or size of a window. Use 'setWindowPos' and+-- 'setWindowSize' instead.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga81c76c418af80a1cce7055bccb0ae0a7 glfwSetWindowMonitor>+setWindowed :: Window+            -> Int  -- ^ The width of the client area+            -> Int  -- ^ The height of the client area+            -> Int  -- ^ The x position of the window+            -> Int  -- ^ The y position of the window+            -> IO ()+setWindowed win width height x y =+  c'glfwSetWindowMonitor (toC win) nullPtr (toC x) (toC y) (toC width) (toC height) 0++-- start of functions related to c'glfwGetWindowAttrib++-- | If the window has focus or not.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowFocused :: Window -> IO Bool+getWindowFocused win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_FOCUSED++-- | If the window is maximized or not.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowMaximized :: Window -> IO Bool+getWindowMaximized win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_MAXIMIZED++-- | If the window has been set to be 'always on top' or not.+-- See <http://www.glfw.org/docs/latest/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowFloating :: Window -> IO Bool+getWindowFloating win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_FLOATING++-- | If the window is iconified (minimized) or not.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowIconified :: Window -> IO Bool+getWindowIconified win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_ICONIFIED++-- | If the window is resizable or not.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowResizable :: Window -> IO Bool+getWindowResizable win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_RESIZABLE++-- | If the window is decorated or not.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowDecorated :: Window -> IO Bool+getWindowDecorated win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_DECORATED++-- | If the window is visible or not.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowVisible :: Window -> IO Bool+getWindowVisible win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_VISIBLE++-- | The client api for this window.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowClientAPI :: Window -> IO ClientAPI+getWindowClientAPI win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CLIENT_API++-- | Returns the context creation API used to create the specified window.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowContextCreationAPI :: Window -> IO ContextCreationAPI+getWindowContextCreationAPI win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CONTEXT_CREATION_API++-- | The context's "major" version, x.0.0+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowContextVersionMajor :: Window -> IO Int+getWindowContextVersionMajor win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CONTEXT_VERSION_MAJOR++-- | The context's "minor" version, 0.y.0+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowContextVersionMinor :: Window -> IO Int+getWindowContextVersionMinor win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CONTEXT_VERSION_MINOR++-- | The context's "revision" version, 0.0.z+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowContextVersionRevision :: Window -> IO Int+getWindowContextVersionRevision win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CONTEXT_REVISION++-- | The context robustness of this window.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowContextRobustness :: Window -> IO ContextRobustness+getWindowContextRobustness win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CONTEXT_ROBUSTNESS++-- | Returns the context release behavior.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowContextReleaseBehavior :: Window -> IO ContextReleaseBehavior+getWindowContextReleaseBehavior win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CONTEXT_RELEASE_BEHAVIOR++-- | Returns true if the window is set to NO_ERROR (see the+-- <https://www.khronos.org/registry/OpenGL/extensions/KHR/KHR_no_error.txt KHR_no_error>+-- extension.+getWindowContextNoError :: Window -> IO Bool+getWindowContextNoError win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CONTEXT_NO_ERROR++-- | If this window is set for opengl to be forward compatible.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowOpenGLForwardCompat :: Window -> IO Bool+getWindowOpenGLForwardCompat win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_OPENGL_FORWARD_COMPAT++-- | If the window has an opengl debug context+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowOpenGLDebugContext :: Window -> IO Bool+getWindowOpenGLDebugContext win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_OPENGL_DEBUG_CONTEXT++-- | Obtains the current opengl profile.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gacccb29947ea4b16860ebef42c2cb9337 glfwGetWindowAttrib>+getWindowOpenGLProfile :: Window -> IO OpenGLProfile+getWindowOpenGLProfile win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_OPENGL_PROFILE++-- end of functions related to c'glfwGetWindowAttrib++-- | Sets the callback to use when the window position changes.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga2837d4d240659feb4268fcb6530a6ba1 glfwSetWindowPosCallback>+setWindowPosCallback :: Window -> Maybe WindowPosCallback -> IO ()+setWindowPosCallback win = setWindowCallback+    mk'GLFWwindowposfun+    (\cb a0 a1 a2 ->+      schedule $ cb (fromC a0) (fromC a1) (fromC a2))+    (c'glfwSetWindowPosCallback (toC win))+    storedWindowPosFun+    win++-- | Sets the callback to use when the window's size changes.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gaa40cd24840daa8c62f36cafc847c72b6 glfwSetWindowSizeCallback>+setWindowSizeCallback :: Window -> Maybe WindowSizeCallback -> IO ()+setWindowSizeCallback win = setWindowCallback+    mk'GLFWwindowsizefun+    (\cb a0 a1 a2 ->+      schedule $ cb (fromC a0) (fromC a1) (fromC a2))+    (c'glfwSetWindowSizeCallback (toC win))+    storedWindowSizeFun+    win++-- | Sets the callback to use when the user attempts to close the window.+-- See <http://www.glfw.org/docs/3.3/group__window.html#gaade9264e79fae52bdb78e2df11ee8d6a glfwSetWindowCloseCallback>+setWindowCloseCallback :: Window -> Maybe WindowCloseCallback -> IO ()+setWindowCloseCallback win = setWindowCallback+    mk'GLFWwindowclosefun+    (. fromC)+    (c'glfwSetWindowCloseCallback (toC win))+    storedWindowCloseFun+    win++-- | Sets the callback to use when the window's data is partly dead and it should refresh.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga4569b76e8ac87c55b53199e6becd97eb glfwSetWindowRefreshCallback>+setWindowRefreshCallback :: Window -> Maybe WindowRefreshCallback -> IO ()+setWindowRefreshCallback win = setWindowCallback+    mk'GLFWwindowrefreshfun+    (. fromC)+    (c'glfwSetWindowRefreshCallback (toC win))+    storedWindowRefreshFun+    win++-- | Sets the callback to use when the window gains or loses focus.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga25d1c584edb375d7711c5c3548ba711f glfwSetWindowFocusCallback>+setWindowFocusCallback :: Window -> Maybe WindowFocusCallback -> IO ()+setWindowFocusCallback win = setWindowCallback+    mk'GLFWwindowfocusfun+    (\cb a0 a1 -> schedule $ cb (fromC a0) (fromC a1))+    (c'glfwSetWindowFocusCallback (toC win))+    storedWindowFocusFun+    win++-- | Sets the callback to use when the window is iconified or not (aka, minimized or not).+-- See <http://www.glfw.org/docs/3.3/group__window.html#gab1ea7263081c0e073b8d5b91d6ffd367 glfwSetWindowIconifyCallback>+setWindowIconifyCallback :: Window -> Maybe WindowIconifyCallback -> IO ()+setWindowIconifyCallback win = setWindowCallback+    mk'GLFWwindowiconifyfun+    (\cb a0 a1 -> schedule $ cb (fromC a0) (fromC a1))+    (c'glfwSetWindowIconifyCallback (toC win))+    storedWindowIconifyFun+    win++-- | Sets the callback for when the content scale of the window changes.+-- See <https://www.glfw.org/docs/3.3/window_guide.html#window_scale Window Content Scale>+setWindowContentScaleCallback :: Window -> Maybe WindowContentScaleCallback -> IO ()+setWindowContentScaleCallback win = setWindowCallback+    mk'GLFWwindowcontentscalefun+    (\cb w (CFloat f1) (CFloat f2) -> schedule $ cb (fromC w) f1 f2)+    (c'glfwSetWindowContentScaleCallback (toC win))+    storedWindowContentScaleFun+    win++-- | Sets the maximization callback of the specified window, which is called+-- when the window is maximized or restored.+-- See <https://www.glfw.org/docs/3.3/window_guide.html#window_maximize Window maximization>+setWindowMaximizeCallback :: Window -> Maybe WindowMaximizeCallback -> IO ()+setWindowMaximizeCallback win = setWindowCallback+    mk'GLFWwindowmaximizefun+    (\cb w x -> schedule $ cb (fromC w) (fromC x))+    (c'glfwSetWindowMaximizeCallback (toC win))+    storedWindowMaximizeFun+    win++-- | Sets the callback to use when the framebuffer's size changes.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga3203461a5303bf289f2e05f854b2f7cf glfwSetFramebufferSizeCallback>+setFramebufferSizeCallback :: Window -> Maybe FramebufferSizeCallback -> IO ()+setFramebufferSizeCallback win = setWindowCallback+    mk'GLFWframebuffersizefun+    (\cb a0 a1 a2 -> schedule $ cb (fromC a0) (fromC a1) (fromC a2))+    (c'glfwSetFramebufferSizeCallback (toC win))+    storedFramebufferSizeFun+    win++-- | Checks for any pending events, processes them, and then immediately returns.+-- This is most useful for continual rendering, such as games.+-- See the <http://www.glfw.org/docs/3.3/input.html#events Event Processing Guide>. This+-- function is not <https://www.glfw.org/docs/latest/intro.html#reentrancy reentrant>.+pollEvents :: IO ()+pollEvents = c'glfwPollEvents >> executeScheduled++-- | Waits until at least one event is in the queue then processes the queue and returns.+-- Requires at least one window to be active for it to sleep. This saves a lot of CPU, and+-- is better if you're doing only periodic rendering, such as with an editor program.+-- See the <http://www.glfw.org/docs/3.3/input.html#events Event Processing Guide>. This+-- function is not <https://www.glfw.org/docs/latest/intro.html#reentrancy reentrant>.+waitEvents :: IO ()+waitEvents = c'glfwWaitEvents >> executeScheduled++-- | Same as 'waitEvents', with a timeout after which the function returns.+-- See the <http://www.glfw.org/docs/3.3/input.html#events Event Processing Guide>. This+-- function is not <https://www.glfw.org/docs/latest/intro.html#reentrancy reentrant>.+waitEventsTimeout :: Double -> IO ()+waitEventsTimeout seconds =+  c'glfwWaitEventsTimeout (toC seconds) >> executeScheduled++-- | Creates an empty event within the event queue. Can be called from any+-- thread, so you can use this to wake up the main thread that's using+-- 'waitEvents' from a secondary thread.+-- See the <http://www.glfw.org/docs/3.3/input.html#events Event Processing Guide>+postEmptyEvent :: IO ()+postEmptyEvent = c'glfwPostEmptyEvent++--------------------------------------------------------------------------------+-- Input handling++-- start of glfw{GS}etInputMode-related functions++-- | Gets the current cursor input mode.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gaa92336e173da9c8834558b54ee80563b glfwSetInputMode>+getCursorInputMode :: Window -> IO CursorInputMode+getCursorInputMode win =+    fromC `fmap` c'glfwGetInputMode (toC win) c'GLFW_CURSOR++-- | Set the cursor input mode.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gaa92336e173da9c8834558b54ee80563b glfwSetInputMode>+setCursorInputMode :: Window -> CursorInputMode -> IO ()+setCursorInputMode win c =+    c'glfwSetInputMode (toC win) c'GLFW_CURSOR (toC c)++-- | Sets the cursor to receive raw input, if available (See+-- rawMouseMotionSupported and+-- <https://www.glfw.org/docs/3.3/input_guide.html#raw_mouse_motion Raw Mouse Motion>+setRawMouseMotion :: Window -> Bool -> IO ()+setRawMouseMotion win toggle = do+    supported <- rawMouseMotionSupported+    if not supported+      then putStrLn "WARNING -- Asked to set raw mouse motion but is unsupported"+      else c'glfwSetInputMode (toC win) c'GLFW_RAW_MOUSE_MOTION (toC toggle)++-- | Returns whether or not we've currently enabled raw mouse motion.+-- See <https://www.glfw.org/docs/3.3/input_guide.html#raw_mouse_motion Raw Mouse Motion>+getRawMouseMotion :: Window -> IO Bool+getRawMouseMotion win =+    fromC <$> c'glfwGetInputMode (toC win) c'GLFW_RAW_MOUSE_MOTION++-- | Gets the current sticky keys mode.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gaa92336e173da9c8834558b54ee80563b glfwSetInputMode>+getStickyKeysInputMode :: Window -> IO StickyKeysInputMode+getStickyKeysInputMode win =+    fromC `fmap` c'glfwGetInputMode (toC win) c'GLFW_STICKY_KEYS++-- | Sets if sticky keys should be used or not.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gaa92336e173da9c8834558b54ee80563b glfwSetInputMode>+setStickyKeysInputMode :: Window -> StickyKeysInputMode -> IO ()+setStickyKeysInputMode win sk =+    c'glfwSetInputMode (toC win) c'GLFW_STICKY_KEYS (toC sk)++-- | Gets if sticky mouse buttons are on or not.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gaa92336e173da9c8834558b54ee80563b glfwSetInputMode>+getStickyMouseButtonsInputMode :: Window -> IO StickyMouseButtonsInputMode+getStickyMouseButtonsInputMode win =+    fromC `fmap` c'glfwGetInputMode (toC win) c'GLFW_STICKY_MOUSE_BUTTONS++-- | Sets if sticky mouse buttons should be used or not.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gaa92336e173da9c8834558b54ee80563b glfwSetInputMode>+setStickyMouseButtonsInputMode :: Window -> StickyMouseButtonsInputMode -> IO ()+setStickyMouseButtonsInputMode win smb =+    c'glfwSetInputMode (toC win) c'GLFW_STICKY_MOUSE_BUTTONS (toC smb)++-- end of glfw{GS}etInputMode-related functions++-- | Gets the state of the specified key. If Stickey Keys isn't enabled then it's possible for+-- keyboard polling to miss individual key presses. Use the callback to avoid this.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gadd341da06bc8d418b4dc3a3518af9ad2 glfwGetKey>+getKey :: Window -> Key -> IO KeyState+getKey win k =+    fromC `fmap` c'glfwGetKey (toC win) (toC k)++-- | Returns the localized name of the specified printable key. This is intended+-- for displaying key bindings to the user. The scancode is used if the provided+-- 'Key' isn't printable. If the scancode maps to a non-printable key as well,+-- then 'Nothing' is returned.+-- See <http://www.glfw.org/docs/3.3/group__input.html#ga237a182e5ec0b21ce64543f3b5e7e2be glfwGetKeyName>+getKeyName :: Key -> Int -> IO (Maybe String)+getKeyName k scancode = do+  cstr <- c'glfwGetKeyName (toC k) (toC scancode)+  if cstr == nullPtr+    then return Nothing+    else Just `fmap` peekCString cstr++-- | This function returns the platform-specific scancode of the specified key.+-- See <https://www.glfw.org/docs/3.3/group__input.html#ga67ddd1b7dcbbaff03e4a76c0ea67103a glfwGetKeyScancode>+getKeyScancode :: Key -> IO Int+getKeyScancode = fmap fromC . c'glfwGetKeyScancode . toC++-- | Gets the state of a single specified mouse button. If sticky mouse button+-- mode isn't enabled it's possible for mouse polling to miss individual mouse events. Use+-- the call back to avoid this.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gac1473feacb5996c01a7a5a33b5066704 glfwGetMouseButton>+getMouseButton :: Window -> MouseButton -> IO MouseButtonState+getMouseButton win b =+    fromC `fmap` c'glfwGetMouseButton (toC win) (toC b)++-- | Returns the position, in screen coodinates, relative to the upper left.+-- If the 'CursorInputMode' is "disabled", then results are unbounded by the window size.+-- See <http://www.glfw.org/docs/3.3/group__input.html#ga01d37b6c40133676b9cea60ca1d7c0cc glfwGetCursorPos>+getCursorPos :: Window -> IO (Double, Double)+getCursorPos win =+    allocaArray 2 $ \p -> do+        let p'x = p+            p'y = p `advancePtr` 1+        c'glfwGetCursorPos (toC win) p'x p'y+        x <- fromC `fmap` peek p'x+        y <- fromC `fmap` peek p'y+        return (x, y)++-- | Assigns the given callback to use for all keyboard presses and repeats.+-- See <http://www.glfw.org/docs/3.3/group__input.html#ga7e496507126f35ea72f01b2e6ef6d155 glfwSetKeyCallback>+setKeyCallback :: Window -> Maybe KeyCallback -> IO ()+setKeyCallback win = setWindowCallback+    mk'GLFWkeyfun+    (\cb a0 a1 a2 a3 a4 ->+      schedule $ cb (fromC a0) (fromC a1) (fromC a2) (fromC a3) (fromC a4))+    (c'glfwSetKeyCallback (toC win))+    storedKeyFun+    win++-- | Sets the callback to use when the user types a character+-- See <http://www.glfw.org/docs/3.3/group__input.html#ga556239421c6a5a243c66fca28da9f742 glfwSetCharCallback>+setCharCallback :: Window -> Maybe CharCallback -> IO ()+setCharCallback win = setWindowCallback+    mk'GLFWcharfun+    (\cb a0 a1 -> schedule $ cb (fromC a0) (fromC a1))+    (c'glfwSetCharCallback (toC win))+    storedCharFun+    win++-- | Sets the callback to use with Unicode characters regardless of what+-- modifier keys are used.+-- See <http://www.glfw.org/docs/3.3/group__input.html#ga3f55ef5dc03a374e567f068b13c94afc glfwSetCharModsCallback>+setCharModsCallback :: Window -> Maybe CharModsCallback -> IO ()+setCharModsCallback win = setWindowCallback+    mk'GLFWcharmodsfun+    (\cb a0 a1 a2 -> schedule $ cb (fromC a0) (fromC a1) (fromC a2))+    (c'glfwSetCharModsCallback (toC win))+    storedCharModsFun+    win++-- | Assigns the callback to run whenver a mouse button is clicked.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gaef49b72d84d615bca0a6ed65485e035d glfwSetMouseButtonCallback>+setMouseButtonCallback :: Window -> Maybe MouseButtonCallback -> IO ()+setMouseButtonCallback win = setWindowCallback+    mk'GLFWmousebuttonfun+    (\cb a0 a1 a2 a3 -> schedule $ cb (fromC a0) (fromC a1) (fromC a2) (fromC a3))+    (c'glfwSetMouseButtonCallback (toC win))+    storedMouseButtonFun+    win++-- | Assigns the callback to run whenver the cursor position changes.+-- See <http://www.glfw.org/docs/3.3/group__input.html#ga7dad39486f2c7591af7fb25134a2501d glfwSetCursorPosCallback>+setCursorPosCallback :: Window -> Maybe CursorPosCallback -> IO ()+setCursorPosCallback win = setWindowCallback+    mk'GLFWcursorposfun+    (\cb a0 a1 a2 -> schedule $ cb (fromC a0) (fromC a1) (fromC a2))+    (c'glfwSetCursorPosCallback (toC win))+    storedCursorPosFun+    win++-- | Sets the callback for when the cursor enters or leaves the client area.+-- See <http://www.glfw.org/docs/3.3/input.html#cursor_enter Cursor Enter/Leave Events>+setCursorEnterCallback :: Window -> Maybe CursorEnterCallback -> IO ()+setCursorEnterCallback win = setWindowCallback+    mk'GLFWcursorenterfun+    (\cb a0 a1 -> schedule $ cb (fromC a0) (fromC a1))+    (c'glfwSetCursorEnterCallback (toC win))+    storedCursorEnterFun+    win++-- | Sets the callback to run when the user scrolls with the mouse wheel or a touch gesture.+-- See <http://www.glfw.org/docs/3.3/input.html#scrolling Scroll Input>+setScrollCallback :: Window -> Maybe ScrollCallback -> IO ()+setScrollCallback win = setWindowCallback+    mk'GLFWscrollfun+    (\cb a0 a1 a2 -> schedule $ cb (fromC a0) (fromC a1) (fromC a2))+    (c'glfwSetScrollCallback (toC win))+    storedScrollFun+    win++-- | Tests if the joystick is present at all+-- See <http://www.glfw.org/docs/3.3/group__input.html#gaffcbd9ac8ee737fcdd25475123a3c790 glfwJoystickPresent>+joystickPresent :: Joystick -> IO Bool+joystickPresent = fmap fromC . c'glfwJoystickPresent . toC++-- | Returns the values of all axes of the specified joystick, normalized to between -1.0 and 1.0+-- See <http://www.glfw.org/docs/3.3/group__input.html#ga6271d46a5901ec2c99601ccf4dd14731 glfwGetJoystickAxes>+getJoystickAxes :: Joystick -> IO (Maybe [Double])+getJoystickAxes js = alloca $ \p'n -> do+    p'axes <- c'glfwGetJoystickAxes (toC js) p'n+    n <- fromC <$> peek p'n+    if p'axes == nullPtr || n <= 0+      then return Nothing+      else (Just . map fromC) <$> peekArray n p'axes++-- | Returns a list of all joystick button states for the specified joystick.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gace54cd930dcd502e118fe4021384ce1b glfwGetJoystickButtons>+getJoystickButtons :: Joystick -> IO (Maybe [JoystickButtonState])+getJoystickButtons js = alloca $ \p'n -> do+    p'buttons <- c'glfwGetJoystickButtons (toC js) p'n+    n <- fromC <$> peek p'n+    if p'buttons == nullPtr || n <= 0+      then return Nothing+      else (Just . map fromC) <$> peekArray n p'buttons++-- | Returns a list of all hats of the specified joystick.+-- See <https://www.glfw.org/docs/3.3/group__input.html#ga2d8d0634bb81c180899aeb07477a67ea glfwGetJoystickHats>+getJoystickHats :: Joystick -> IO (Maybe [JoystickHatState])+getJoystickHats js = alloca $ \p'n -> do+    p'hats <- c'glfwGetJoystickHats (toC js) p'n+    n <- fromC <$> peek p'n+    if p'hats == nullPtr || n <= 0+      then return Nothing+      else (Just . map fromC) <$> peekArray n p'hats++-- | A human-readable name for a Joystick. Not guranteed to be unique.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gac8d7f6107e05cfd106cfba973ab51e19 glfwGetJoystickName>+getJoystickName :: Joystick -> IO (Maybe String)+getJoystickName js = do+    p'name <- c'glfwGetJoystickName (toC js)+    if p'name == nullPtr+      then return Nothing+      else Just <$> peekCString p'name++-- | Sets a callback for when a joystick is connected or disconnected.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gab1dc8379f1b82bb660a6b9c9fa06ca07 glfwSetJoystickCallback>+setJoystickCallback :: Maybe JoystickCallback -> IO ()+setJoystickCallback = setCallback+    mk'GLFWjoystickfun+    (\cb a0 a1 -> schedule $ cb (fromC a0) (fromC a1))+    c'glfwSetJoystickCallback+    storedJoystickFun++-- | Adds the specified SDL_GameControllerDB gamepad mappings.+-- See <https://www.glfw.org/docs/3.3/group__input.html#gaed5104612f2fa8e66aa6e846652ad00f glfwUpdateGamepadMappings>+updateGamepadMappings :: String -> IO Bool+updateGamepadMappings =+    flip withCString $ \s -> fromC <$> c'glfwUpdateGamepadMappings s++-- | This function returns whether the specified joystick is both present and+-- has a gamepad mapping.+-- See <https://www.glfw.org/docs/3.3/group__input.html#gad0f676860f329d80f7e47e9f06a96f00 glfwJoystickIsGamepad>+joystickIsGamepad :: Joystick -> IO Bool+joystickIsGamepad = fmap (== c'GLFW_TRUE) . c'glfwJoystickIsGamepad . toC++-- | This function returns the SDL compatible GUID of the specified joystick.+-- See <https://www.glfw.org/docs/3.3/group__input.html#gae168c2c0b8cf2a1cb67c6b3c00bdd543 glfwGetJoystickGUID>+getJoystickGUID :: Joystick -> IO (Maybe String)+getJoystickGUID js = do+  p'guid <- c'glfwGetJoystickGUID (toC js)+  if p'guid == nullPtr+    then return Nothing+    else Just <$> peekCString p'guid++-- | This function returns the human-readable name of the gamepad from the+-- gamepad mapping assigned to the specified joystick.+-- See <https://www.glfw.org/docs/3.3/group__input.html#ga5c71e3533b2d384db9317fcd7661b210 glfwGetGamepadName>+getGamepadName :: Joystick -> IO (Maybe String)+getGamepadName js = do+  p'name <- c'glfwGetGamepadName (toC js)+  if p'name == nullPtr+    then return Nothing+    else Just <$> peekCString p'name++-- | This function retrives the state of the specified joystick remapped to an+-- Xbox-like gamepad.+-- See <https://www.glfw.org/docs/3.3/group__input.html#gadccddea8bce6113fa459de379ddaf051 glfwGetGamepadState>+getGamepadState :: Joystick -> IO (Maybe GamepadState)+getGamepadState js = alloca $ \p'gps -> do+  hasGamepad <- fromC <$> c'glfwGetGamepadState (toC js) p'gps+  if hasGamepad+    then do+      gps <- peek p'gps+      return $ Just GamepadState+        { getButtonState = fromC . (c'GLFWgamepadstate'buttons gps !!)+                         . (fromIntegral :: CInt -> Int)+                         . toC+        , getAxisState = hFloat+                       . (c'GLFWgamepadstate'axes gps !!)+                       . (fromIntegral :: CInt -> Int)+                       . toC+        }+    else return Nothing++--------------------------------------------------------------------------------+-- Time++-- | Returns the time (in seconds) of the GLFW timer.+-- This is the amount of time since GLFW was initialized, unless 'setTime' was used.+-- The exact resolution is system dependent.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gaa6cf4e7a77158a3b8fd00328b1720a4a glfwGetTime>+getTime :: IO (Maybe Double)+getTime = do+    t <- fromC `fmap` c'glfwGetTime+    return $ if t == 0+      then Nothing+      else Just t++-- | Sets the GLFW timer to the specified value, which is measured in seconds, and must be positive.+-- The value must also be less than ~584 years in seconds (18446744073.0).+-- After this the timer begins to count upward at the normal rate.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gaf59589ef6e8b8c8b5ad184b25afd4dc0 glfwSetTime>+setTime :: Double -> IO ()+setTime = c'glfwSetTime . toC++-- | Returns the current value of the raw timer, measured in 1 / frequency+-- seconds. The frequency can be queried using getTimerFrequency.+-- See <http://www.glfw.org/docs/3.3/input_guide.html#time Timer input>+getTimerValue :: IO Word64+getTimerValue = c'glfwGetTimerValue++-- | Returns the frequency, in Hz, of the raw timer.+-- See <http://www.glfw.org/docs/3.3/input_guide.html#time Timer input>+getTimerFrequency :: IO Word64+getTimerFrequency = c'glfwGetTimerFrequency++--------------------------------------------------------------------------------+-- Context++-- | Makes the context of the specified window the current one for the calling thread.+-- A context can only be made current on a single thread at a time,+-- and each thread can have only a single current context at a time.+-- See <http://www.glfw.org/docs/3.3/group__context.html#ga1c04dc242268f827290fe40aa1c91157 glfwMakeContextCurrent>+makeContextCurrent :: Maybe Window -> IO ()+makeContextCurrent =+    c'glfwMakeContextCurrent . maybe nullPtr toC++-- | Obtains which window owns the current context of the calling thread.+-- See <http://www.glfw.org/docs/3.3/group__context.html#gac84759b1f6c2d271a4fea8ae89ec980d glfwGetCurrentContext>+getCurrentContext :: IO (Maybe Window)+getCurrentContext = do+    p'win <- c'glfwGetCurrentContext+    return $ if p'win == nullPtr+      then Nothing+      else Just $ fromC p'win++-- | Swaps the front and back buffers of the window.+-- See <http://www.glfw.org/docs/3.3/group__window.html#ga15a5a1ee5b3c2ca6b15ca209a12efd14 glfwSwapBuffers>+swapBuffers :: Window -> IO ()+swapBuffers =+    c'glfwSwapBuffers . toC++-- | Sets the number of screen updates that the GPU should wait after 'swapBuffers' before actually swapping the buffers.+-- Generates 'Error'NoCurrentContext' if no context is current.+-- See <http://www.glfw.org/docs/3.3/group__context.html#ga6d4e0cdf151b5e579bd67f13202994ed glfwSwapInterval>+swapInterval :: Int -> IO ()+swapInterval =+    c'glfwSwapInterval . toC++-- | If the current OpenGL or OpenGL ES context supports the extension specified.+-- Generates 'Error'NoCurrentContext' if no context is current.+-- See <http://www.glfw.org/docs/3.3/group__context.html#ga87425065c011cef1ebd6aac75e059dfa glfwExtensionSupported>+extensionSupported :: String -> IO Bool+extensionSupported ext =+    withCString ext $ \p'ext ->+      fromC `fmap` c'glfwExtensionSupported p'ext++--------------------------------------------------------------------------------+-- Clipboard+-- http://www.glfw.org/docs/3.3/input.html#clipboard++-- | The window that will own the clipboard contents, and also the clipboard string.+-- See <http://www.glfw.org/docs/3.3/group__input.html#gaba1f022c5eb07dfac421df34cdcd31dd glfwSetClipboardString>+setClipboardString :: Window -> String -> IO ()+setClipboardString win s =+    withCString s (c'glfwSetClipboardString (toC win))++-- | Obtains the contents of the system keyboard, if possible.+-- Generates 'Error'FormatUnavailable' if the system clipboard is empty or if it's not a UTF-8 string.+-- See <http://www.glfw.org/docs/3.3/group__input.html#ga5aba1d704d9ab539282b1fbe9f18bb94 glfwGetClipboardString>+getClipboardString :: Window -> IO (Maybe String)+getClipboardString win = do+    p's <- c'glfwGetClipboardString (toC win)+    if p's == nullPtr+      then return Nothing+      else Just `fmap` peekCString p's++--------------------------------------------------------------------------------+-- 3.1 additions (http://www.glfw.org/docs/3.1/news.html#news_31)+--------------------------------------------------------------------------------++-- Cursor Objects+-- http://www.glfw.org/docs/3.3/input.html#cursor_object++-- | Creates a new cursor.+createCursor :: Image -- ^ The desired cursor image.+             -> Int   -- ^ The desired x-coordinate, in pixels, of the cursor+                      --   hotspot.+             -> Int   -- ^ The desired y-coordinate, in pixels, of the cursor+                      --   hotspot.+             -> IO Cursor+createCursor img x y =+  withGLFWImage img $ \p'img ->+    Cursor `fmap` c'glfwCreateCursor p'img (toC x) (toC y)++-- | Creates a cursor with a standard shape that can be set for a window with+-- setCursor.+createStandardCursor :: StandardCursorShape -> IO Cursor+createStandardCursor = (fmap Cursor) . c'glfwCreateStandardCursor . toC++-- | Sets the cursor image to be used when the cursor is over the client area+-- of the specified window. The set cursor will only be visible when the cursor+-- mode of the window is @GLFW_CURSOR_NORMAL@.++-- On some platforms, the set cursor may not be visible unless the window also+-- has input focus.+setCursor :: Window -> Cursor -> IO ()+setCursor (Window wptr) (Cursor cptr) = c'glfwSetCursor wptr cptr++-- | Destroys a cursor previously created with `createCursor`. Any remaining+-- cursors will be destroyed by `terminate`. This function is not+-- <https://www.glfw.org/docs/latest/intro.html#reentrancy reentrant>.+destroyCursor :: Cursor -> IO ()+destroyCursor = c'glfwDestroyCursor . unCursor++-- | A callback that allows for drag and drop support.+type DropCallback = Window    -- ^ The window that received the event.+                  -> [String] -- ^ The file and/or directory path names+                  -> IO ()++-- | Sets the file drop callback of the specified window, which is called when+-- one or more dragged files are dropped on the window.+setDropCallback :: Window -> Maybe DropCallback -> IO ()+setDropCallback win = setWindowCallback+    mk'GLFWdropfun+    (\cb w c fs -> do+        let count = fromC c+        fps <- flip mapM [0..count-1] $ \i -> do+            let p = advancePtr fs i+            p' <- peek p+            peekCString p'+        schedule $ cb (fromC w) fps)+    (c'glfwSetDropCallback (toC win))+    storedDropFun+    win++--------------------------------------------------------------------------------+-- Vulkan-related functions+--------------------------------------------------------------------------------++-- | This function returns whether the Vulkan loader has been found.+--   This check is performed by `init`.+vulkanSupported :: IO Bool+vulkanSupported = (c'GLFW_TRUE ==) <$> c'glfwVulkanSupported++-- | Get required vulkan extensions;+--   Pointer memory is managed by GLFW, destroyed by `terminate` call.+--+--   The returned extension names are kept in `CString` type, because+--   they are expected to be consumed by vulkan device initialization functions.+getRequiredInstanceExtensions :: IO [CString]+getRequiredInstanceExtensions = alloca $ \countPtr -> do+    extsPtrPtr <- c'glfwGetRequiredInstanceExtensions countPtr+    count <- fromIntegral <$> peek countPtr+    peekArray count extsPtrPtr++-- | Returns the address of the specified Vulkan instance function.+getInstanceProcAddress :: Ptr vkInstance+                          -- ^ VkInstance.+                          --   Note, the returned function must be used+                          --   with the same instance or its child.+                       -> String+                          -- ^ Function name+                       -> IO (FunPtr vkProc)+getInstanceProcAddress i procName+  = withCString procName (c'glfwGetInstanceProcAddress i)++-- | Returns whether the specified queue family can present images.+getPhysicalDevicePresentationSupport ::+       Ptr vkInstance+       -- ^ VkInstance+    -> Ptr vkPhysicalDevice+       -- ^ VkPhysicalDevice+    -> Word32+       -- ^ Index of a queue family to query.+       --   This is an index in the array returned by+       --   @vkGetPhysicalDeviceQueueFamilyProperties@ function.+    -> IO Bool+getPhysicalDevicePresentationSupport inst dev i+  = (c'GLFW_TRUE ==) <$> c'glfwGetPhysicalDevicePresentationSupport inst dev i++-- | Creates a Vulkan surface for the specified window+createWindowSurface :: Enum vkResult+                    => Ptr vkInstance+                       -- ^ VkInstance+                    -> Window+                       -- ^ GLFWwindow *window+                    -> Ptr vkAllocationCallbacks+                       -- ^ const VkAllocationCallbacks *allocator+                    -> Ptr vkSurfaceKHR+                       -- ^ VkSurfaceKHR *surface+                    -> IO vkResult+createWindowSurface i win acs s+  = toEnum . fromIntegral+  <$> c'glfwCreateWindowSurface i (toC win) acs s++--------------------------------------------------------------------------------+-- Native APIs+--------------------------------------------------------------------------------++-- $nativeaccess+-- The low level native-access bindings are exposed here via bindings-GLFW.+-- These must be enabled with the @ExposeNative@ flag passed to bindings-GLFW.+-- The return values of these functions are used as a best-guess and are not+-- coupled with any other implementation. They should be used with caution+-- and at your own risk.++-- | See <http://www.glfw.org/docs/3.3/group__native.html#gac84f63a3f9db145b9435e5e0dbc4183d glfwGetWin32Adapter>+getWin32Adapter :: Window -> IO CString+getWin32Adapter = c'glfwGetWin32Adapter . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#gac408b09a330749402d5d1fa1f5894dd9 glfwGetWin32Monitor>+getWin32Monitor :: Window -> IO CString+getWin32Monitor = c'glfwGetWin32Monitor . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#gafe5079aa79038b0079fc09d5f0a8e667 glfwGetWin32Window>+getWin32Window  :: Window -> IO (Ptr ())+getWin32Window = c'glfwGetWin32Window . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#gadc4010d91d9cc1134d040eeb1202a143 glfwGetWGLContext>+getWGLContext :: Window -> IO (Ptr ())+getWGLContext = c'glfwGetWGLContext . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#gaf22f429aec4b1aab316142d66d9be3e6 glfwGetCocoaMonitor>+getCocoaMonitor :: Window -> IO (Ptr Word32)+getCocoaMonitor = c'glfwGetCocoaMonitor . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#gac3ed9d495d0c2bb9652de5a50c648715 glfwGetCocoaWindow>+getCocoaWindow :: Window -> IO (Ptr ())+getCocoaWindow = c'glfwGetCocoaWindow . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#ga559e002e3cd63c979881770cd4dc63bc glfwGetNSGLContext>+getNSGLContext :: Window -> IO (Ptr ())+getNSGLContext = c'glfwGetNSGLContext . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#ga8519b66594ea3ef6eeafaa2e3ee37406 glfwGetX11Display>+getX11Display :: IO (Ptr display)+getX11Display = c'glfwGetX11Display++-- | See <http://www.glfw.org/docs/3.3/group__native.html#ga088fbfa80f50569402b41be71ad66e40 glfwGetX11Adapter>+getX11Adapter :: Window -> IO Word64+getX11Adapter = c'glfwGetX11Adapter . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#gab2f8cc043905e9fa9b12bfdbbcfe874c glfwGetX11Monitor>+getX11Monitor :: Window -> IO Word64+getX11Monitor = c'glfwGetX11Monitor . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#ga90ca676322740842db446999a1b1f21d glfwGetX11Window>+getX11Window  :: Window -> IO Word64+getX11Window = c'glfwGetX11Window . toC++-- | See <https://www.glfw.org/docs/3.3/group__native.html#ga72f23e3980b83788c70aa854eca31430 glfwGetX11SelectionString>+getX11SelectionString :: IO String+getX11SelectionString = c'glfwGetX11SelectionString >>= peekCString++-- | See <https://www.glfw.org/docs/3.3/group__native.html#ga55f879ab02d93367f966186b6f0133f7 glfwSetX11SelectionString>+setX11SelectionString :: String -> IO ()+setX11SelectionString = flip withCString c'glfwSetX11SelectionString++-- | See <http://www.glfw.org/docs/3.3/group__native.html#ga62d884114b0abfcdc2930e89f20867e2 glfwGetGLXContext>+getGLXContext :: Window -> IO (Ptr ())+getGLXContext = c'glfwGetGLXContext . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#ga1ed27b8766e859a21381e8f8ce18d049 glfwGetGLXWindow>+getGLXWindow  :: Window -> IO Word64+getGLXWindow = c'glfwGetGLXWindow . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#gaaf8118a3c877f3a6bc8e7a649519de5e glfwGetWaylandDisplay>+getWaylandDisplay :: IO (Ptr wl_display)+getWaylandDisplay = c'glfwGetWaylandDisplay++-- | See <http://www.glfw.org/docs/3.3/group__native.html#gab10427a667b6cd91eec7709f7a906bd3 glfwGetWaylandMonitor>+getWaylandMonitor :: Window -> IO (Ptr wl_output)+getWaylandMonitor = c'glfwGetWaylandMonitor . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#ga4738d7aca4191363519a9a641c3ab64c glfwGetWaylandWindow>+getWaylandWindow :: Window -> IO (Ptr wl_surface)+getWaylandWindow = c'glfwGetWaylandWindow . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#ga1cd8d973f47aacb5532d368147cc3138 glfwGetEGLDisplay>+getEGLDisplay :: IO (Ptr ())+getEGLDisplay = c'glfwGetEGLDisplay++-- | See <http://www.glfw.org/docs/3.3/group__native.html#ga671c5072becd085f4ab5771a9c8efcf1 glfwGetEGLContext>+getEGLContext :: Window -> IO (Ptr ())+getEGLContext = c'glfwGetEGLContext . toC++-- | See <http://www.glfw.org/docs/3.3/group__native.html#ga2199b36117a6a695fec8441d8052eee6 glfwGetEGLSurface>+getEGLSurface :: Window -> IO (Ptr ())+getEGLSurface = c'glfwGetEGLSurface . toC++-- | See <https://www.glfw.org/docs/3.3/group__native.html#ga9e47700080094eb569cb053afaa88773 glfwGetOSMesaContext>+getOSMesaContext :: Window -> IO (Ptr ())+getOSMesaContext = c'glfwGetOSMesaContext . toC++-- | An RGBA type is a low-dynamic range representation of a color, represented+-- by a 32-bit value. The channels here are in order: R, G, B, A+type OSMesaRGBA = (Word8, Word8, Word8, Word8)++-- | A color buffer is a two dimensional array of RGBA values. The first+-- dimension is width, and the second is height.+--+-- TODO: It's a shame this is an Array and not a UArray.+type OSMesaColorBuffer = Array (Int, Int) OSMesaRGBA++-- | A depth buffer is a two dimensional array of depth values. The range is+-- usually determined by a parameter returned from the query function.+type OSMesaDepthBuffer = Array (Int, Int) Word32++-- | Returns the color buffer of the offscreen context provided by OSMesa. The+-- color buffer is returned as an array whose integers are unsigned and+-- represent the (R, G, B, A) values. For formats that do not have alpha, A+-- will always be 255.+getOSMesaColorBuffer :: Window -> IO (Maybe OSMesaColorBuffer)+getOSMesaColorBuffer win =+    alloca $ \p'width ->+    alloca $ \p'height ->+    alloca $ \p'format ->+    alloca $ \p'buf -> do+        result <- fromC <$> c'glfwGetOSMesaColorBuffer (toC win)+                                p'width p'height p'format p'buf+        if not result then return Nothing else do+            w <- fromIntegral <$> peek p'width+            h <- fromIntegral <$> peek p'height+            format <- peek p'format+            buf <- peek p'buf+            Just . array ((0, 0), (w, h)) <$> sequence+              [ fmap (\rgba -> ((x, y), rgba)) $+                  mkRGBA format (castPtr buf) (y * w + x)+              | x <- [0..w]+              , y <- [0..h]+              ]+  where+    getByte :: Int -> Word32 -> Word8+    getByte i x = fromIntegral $ (x `shiftR` (i * 8)) .&. 0xFF++    mkRGBA :: CInt -> Ptr Word8 -> Int -> IO OSMesaRGBA+    mkRGBA 0x1908 buf offset = do+        -- OSMESA_RGBA+        (rgba :: Word32) <- peekElemOff (castPtr buf) offset+        return (getByte 0 rgba, getByte 1 rgba, getByte 2 rgba, getByte 3 rgba)+    mkRGBA 0x1 buf offset = do+        -- OSMESA_BGRA+        (bgra :: Word32) <- peekElemOff (castPtr buf) offset+        return (getByte 2 bgra, getByte 1 bgra, getByte 0 bgra, getByte 3 bgra)+    mkRGBA 0x2 buf offset = do+        -- OSMESA_ARGB+        (argb :: Word32) <- peekElemOff (castPtr buf) offset+        return (getByte 1 argb, getByte 2 argb, getByte 3 argb, getByte 0 argb)+    mkRGBA 0x1907 buf offset = do+        -- OSMESA_RGB+        r <- peek (buf `plusPtr` (offset * 3 + 0))+        g <- peek (buf `plusPtr` (offset * 3 + 1))+        b <- peek (buf `plusPtr` (offset * 3 + 2))+        return (r, g, b, 255)+    mkRGBA 0x4 buf offset = do+        -- OSMESA_BGR+        b <- peek (buf `plusPtr` (offset * 3 + 0))+        g <- peek (buf `plusPtr` (offset * 3 + 1))+        r <- peek (buf `plusPtr` (offset * 3 + 2))+        return (r, g, b, 255)+    mkRGBA 0x5 buf offset = do+        -- OSMESA_RGB_565+        (rgb :: Word16) <- peekElemOff (castPtr buf) offset+        return (+          fromIntegral $ rgb .&. 0x1F,+          fromIntegral $ (rgb `shiftR` 5) .&. 0x3F,+          fromIntegral $ (rgb `shiftR` 11) .&. 0x1F,+          255)+    mkRGBA fmt _ _ = error $ "Unrecognized OSMESA_FORMAT: " ++ show fmt++-- | Returns the depth buffer and maximum depth value of the offscreen render+-- target that's provided by OSMesa.+getOSMesaDepthBuffer :: Window -> IO (Maybe (OSMesaDepthBuffer, Word32))+getOSMesaDepthBuffer win =+    alloca $ \p'width ->+    alloca $ \p'height ->+    alloca $ \p'bytesPerVal ->+    alloca $ \p'buf -> do+        result <- fromC <$> c'glfwGetOSMesaDepthBuffer (toC win)+                                p'width p'height p'bytesPerVal p'buf+        if not result then return Nothing else do+            w <- fromIntegral <$> peek p'width+            h <- fromIntegral <$> peek p'height+            bytesPerVal <- fromIntegral <$> peek p'bytesPerVal+            buf <- peek p'buf+            depthBuffer <- array ((0, 0), (w, h)) <$> sequence+              [ fmap (\d -> ((x, y), d)) $+                  mkDepth bytesPerVal (castPtr buf) (y * w + x)+              | x <- [0..w]+              , y <- [0..h]+              ]+            return (Just (depthBuffer, (1 `shiftL` (8 * bytesPerVal)) - 1))+  where+    mkDepth :: Int -> Ptr Word8 -> Int -> IO Word32+    mkDepth bpv ptr offset = do+        -- Assumes little-endian?+        bytes <- forM [0..(bpv - 1)] $ \i -> peekElemOff ptr (offset * bpv + i)+        return $ foldl' (\d -> ((d `shiftL` 8) .|.) . fromIntegral) 0 bytes+
+ Graphics/UI/GLFW/C.hs view
@@ -0,0 +1,686 @@+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, FlexibleContexts #-}++--------------------------------------------------------------------------------++-- This code is generated by util/genC.hs.++--------------------------------------------------------------------------------++module Graphics.UI.GLFW.C where++--------------------------------------------------------------------------------++import Data.Bits       ((.&.))+import Data.Char       (chr, ord)+import Foreign.C.Types (CDouble, CFloat, CInt, CUChar, CUInt, CUShort)+import Foreign.Ptr     (Ptr)++import Bindings.GLFW+import Graphics.UI.GLFW.Types++--------------------------------------------------------------------------------++class C c h where+  fromC :: c -> h+  toC   :: h -> c++--------------------------------------------------------------------------------++instance (C CInt b) => C CInt (Maybe b) where+  fromC i | i == c'GLFW_DONT_CARE = Nothing+          | otherwise = Just $ fromC i+  toC = maybe c'GLFW_DONT_CARE toC++--------------------------------------------------------------------------------++instance C CInt Char where+  fromC = chr . fromIntegral+  toC = fromIntegral . ord++instance C CUInt Char where+  fromC = chr . fromIntegral+  toC = fromIntegral . ord++instance C CDouble Double where+  fromC = realToFrac+  toC = realToFrac++instance C CInt Int where+  fromC = fromIntegral+  toC = fromIntegral++instance C CUInt Int where+  fromC = fromIntegral+  toC = fromIntegral++instance C CUShort Int where+  fromC = fromIntegral+  toC = fromIntegral++instance C CFloat Double where+  fromC = realToFrac+  toC = realToFrac++instance C (Ptr C'GLFWmonitor) Monitor where+  fromC = Monitor+  toC = unMonitor++instance C (Ptr C'GLFWwindow) Window where+  fromC = Window+  toC = unWindow++instance C CInt ModifierKeys where+  fromC v = ModifierKeys+    { modifierKeysShift    = (v .&. c'GLFW_MOD_SHIFT)     /= 0+    , modifierKeysControl  = (v .&. c'GLFW_MOD_CONTROL)   /= 0+    , modifierKeysAlt      = (v .&. c'GLFW_MOD_ALT)       /= 0+    , modifierKeysSuper    = (v .&. c'GLFW_MOD_SUPER)     /= 0+    , modifierKeysCapsLock = (v .&. c'GLFW_MOD_CAPS_LOCK) /= 0+    , modifierKeysNumLock  = (v .&. c'GLFW_MOD_NUM_LOCK)  /= 0+    }+  toC = undefined++instance C C'GLFWvidmode VideoMode where+  fromC gvm = VideoMode+    { videoModeWidth       = fromIntegral $ c'GLFWvidmode'width       gvm+    , videoModeHeight      = fromIntegral $ c'GLFWvidmode'height      gvm+    , videoModeRedBits     = fromIntegral $ c'GLFWvidmode'redBits     gvm+    , videoModeGreenBits   = fromIntegral $ c'GLFWvidmode'greenBits   gvm+    , videoModeBlueBits    = fromIntegral $ c'GLFWvidmode'blueBits    gvm+    , videoModeRefreshRate = fromIntegral $ c'GLFWvidmode'refreshRate gvm+    }+  toC = undefined++instance C CInt StandardCursorShape where+  fromC v+    | v == c'GLFW_ARROW_CURSOR     = StandardCursorShape'Arrow+    | v == c'GLFW_IBEAM_CURSOR     = StandardCursorShape'IBeam+    | v == c'GLFW_CROSSHAIR_CURSOR = StandardCursorShape'Crosshair+    | v == c'GLFW_HAND_CURSOR      = StandardCursorShape'Hand+    | v == c'GLFW_HRESIZE_CURSOR   = StandardCursorShape'HResize+    | v == c'GLFW_VRESIZE_CURSOR   = StandardCursorShape'VResize+    | otherwise = error $ "C CInt StandardCursorShape fromC: " ++ show v+  toC  StandardCursorShape'Arrow     = c'GLFW_ARROW_CURSOR+  toC  StandardCursorShape'IBeam     = c'GLFW_IBEAM_CURSOR+  toC  StandardCursorShape'Crosshair = c'GLFW_CROSSHAIR_CURSOR+  toC  StandardCursorShape'Hand      = c'GLFW_HAND_CURSOR+  toC  StandardCursorShape'HResize   = c'GLFW_HRESIZE_CURSOR+  toC  StandardCursorShape'VResize   = c'GLFW_VRESIZE_CURSOR++--------------------------------------------------------------------------------++instance C CInt Bool where+  fromC v+    | v == c'GLFW_FALSE = False+    | v == c'GLFW_TRUE = True+    | otherwise = error $ "C CInt Bool fromC: " ++ show v+  toC False = c'GLFW_FALSE+  toC True = c'GLFW_TRUE++instance C CInt Error where+  fromC v+    | v == c'GLFW_NOT_INITIALIZED = Error'NotInitialized+    | v == c'GLFW_NO_CURRENT_CONTEXT = Error'NoCurrentContext+    | v == c'GLFW_INVALID_ENUM = Error'InvalidEnum+    | v == c'GLFW_INVALID_VALUE = Error'InvalidValue+    | v == c'GLFW_OUT_OF_MEMORY = Error'OutOfMemory+    | v == c'GLFW_API_UNAVAILABLE = Error'ApiUnavailable+    | v == c'GLFW_VERSION_UNAVAILABLE = Error'VersionUnavailable+    | v == c'GLFW_PLATFORM_ERROR = Error'PlatformError+    | v == c'GLFW_FORMAT_UNAVAILABLE = Error'FormatUnavailable+    | otherwise = error $ "C CInt Error fromC: " ++ show v+  toC Error'NotInitialized = c'GLFW_NOT_INITIALIZED+  toC Error'NoCurrentContext = c'GLFW_NO_CURRENT_CONTEXT+  toC Error'InvalidEnum = c'GLFW_INVALID_ENUM+  toC Error'InvalidValue = c'GLFW_INVALID_VALUE+  toC Error'OutOfMemory = c'GLFW_OUT_OF_MEMORY+  toC Error'ApiUnavailable = c'GLFW_API_UNAVAILABLE+  toC Error'VersionUnavailable = c'GLFW_VERSION_UNAVAILABLE+  toC Error'PlatformError = c'GLFW_PLATFORM_ERROR+  toC Error'FormatUnavailable = c'GLFW_FORMAT_UNAVAILABLE++instance C CInt InitHint where+  fromC v+    | v == c'GLFW_JOYSTICK_HAT_BUTTONS = InitHint'JoystickHatButtons+    | v == c'GLFW_COCOA_CHDIR_RESOURCES = InitHint'CocoaChdirResources+    | v == c'GLFW_COCOA_MENUBAR = InitHint'CocoaMenubar+    | otherwise = error $ "C CInt InitHint fromC: " ++ show v+  toC InitHint'JoystickHatButtons = c'GLFW_JOYSTICK_HAT_BUTTONS+  toC InitHint'CocoaChdirResources = c'GLFW_COCOA_CHDIR_RESOURCES+  toC InitHint'CocoaMenubar = c'GLFW_COCOA_MENUBAR++instance C CInt MonitorState where+  fromC v+    | v == c'GLFW_CONNECTED = MonitorState'Connected+    | v == c'GLFW_DISCONNECTED = MonitorState'Disconnected+    | otherwise = error $ "C CInt MonitorState fromC: " ++ show v+  toC MonitorState'Connected = c'GLFW_CONNECTED+  toC MonitorState'Disconnected = c'GLFW_DISCONNECTED++instance C CInt ContextRobustness where+  fromC v+    | v == c'GLFW_NO_ROBUSTNESS = ContextRobustness'NoRobustness+    | v == c'GLFW_NO_RESET_NOTIFICATION = ContextRobustness'NoResetNotification+    | v == c'GLFW_LOSE_CONTEXT_ON_RESET = ContextRobustness'LoseContextOnReset+    | otherwise = error $ "C CInt ContextRobustness fromC: " ++ show v+  toC ContextRobustness'NoRobustness = c'GLFW_NO_ROBUSTNESS+  toC ContextRobustness'NoResetNotification = c'GLFW_NO_RESET_NOTIFICATION+  toC ContextRobustness'LoseContextOnReset = c'GLFW_LOSE_CONTEXT_ON_RESET++instance C CInt ContextReleaseBehavior where+  fromC v+    | v == c'GLFW_ANY_RELEASE_BEHAVIOR = ContextReleaseBehavior'Any+    | v == c'GLFW_RELEASE_BEHAVIOR_NONE = ContextReleaseBehavior'None+    | v == c'GLFW_RELEASE_BEHAVIOR_FLUSH = ContextReleaseBehavior'Flush+    | otherwise = error $ "C CInt ContextReleaseBehavior fromC: " ++ show v+  toC ContextReleaseBehavior'Any = c'GLFW_ANY_RELEASE_BEHAVIOR+  toC ContextReleaseBehavior'None = c'GLFW_RELEASE_BEHAVIOR_NONE+  toC ContextReleaseBehavior'Flush = c'GLFW_RELEASE_BEHAVIOR_FLUSH++instance C CInt OpenGLProfile where+  fromC v+    | v == c'GLFW_OPENGL_ANY_PROFILE = OpenGLProfile'Any+    | v == c'GLFW_OPENGL_COMPAT_PROFILE = OpenGLProfile'Compat+    | v == c'GLFW_OPENGL_CORE_PROFILE = OpenGLProfile'Core+    | otherwise = error $ "C CInt OpenGLProfile fromC: " ++ show v+  toC OpenGLProfile'Any = c'GLFW_OPENGL_ANY_PROFILE+  toC OpenGLProfile'Compat = c'GLFW_OPENGL_COMPAT_PROFILE+  toC OpenGLProfile'Core = c'GLFW_OPENGL_CORE_PROFILE++instance C CInt ClientAPI where+  fromC v+    | v == c'GLFW_NO_API = ClientAPI'NoAPI+    | v == c'GLFW_OPENGL_API = ClientAPI'OpenGL+    | v == c'GLFW_OPENGL_ES_API = ClientAPI'OpenGLES+    | otherwise = error $ "C CInt ClientAPI fromC: " ++ show v+  toC ClientAPI'NoAPI = c'GLFW_NO_API+  toC ClientAPI'OpenGL = c'GLFW_OPENGL_API+  toC ClientAPI'OpenGLES = c'GLFW_OPENGL_ES_API++instance C CInt ContextCreationAPI where+  fromC v+    | v == c'GLFW_NATIVE_CONTEXT_API = ContextCreationAPI'Native+    | v == c'GLFW_EGL_CONTEXT_API = ContextCreationAPI'EGL+    | v == c'GLFW_OSMESA_CONTEXT_API = ContextCreationAPI'OSMesa+    | otherwise = error $ "C CInt ContextCreationAPI fromC: " ++ show v+  toC ContextCreationAPI'Native = c'GLFW_NATIVE_CONTEXT_API+  toC ContextCreationAPI'EGL = c'GLFW_EGL_CONTEXT_API+  toC ContextCreationAPI'OSMesa = c'GLFW_OSMESA_CONTEXT_API++instance C CInt Key where+  fromC v+    | v == c'GLFW_KEY_UNKNOWN = Key'Unknown+    | v == c'GLFW_KEY_SPACE = Key'Space+    | v == c'GLFW_KEY_APOSTROPHE = Key'Apostrophe+    | v == c'GLFW_KEY_COMMA = Key'Comma+    | v == c'GLFW_KEY_MINUS = Key'Minus+    | v == c'GLFW_KEY_PERIOD = Key'Period+    | v == c'GLFW_KEY_SLASH = Key'Slash+    | v == c'GLFW_KEY_0 = Key'0+    | v == c'GLFW_KEY_1 = Key'1+    | v == c'GLFW_KEY_2 = Key'2+    | v == c'GLFW_KEY_3 = Key'3+    | v == c'GLFW_KEY_4 = Key'4+    | v == c'GLFW_KEY_5 = Key'5+    | v == c'GLFW_KEY_6 = Key'6+    | v == c'GLFW_KEY_7 = Key'7+    | v == c'GLFW_KEY_8 = Key'8+    | v == c'GLFW_KEY_9 = Key'9+    | v == c'GLFW_KEY_SEMICOLON = Key'Semicolon+    | v == c'GLFW_KEY_EQUAL = Key'Equal+    | v == c'GLFW_KEY_A = Key'A+    | v == c'GLFW_KEY_B = Key'B+    | v == c'GLFW_KEY_C = Key'C+    | v == c'GLFW_KEY_D = Key'D+    | v == c'GLFW_KEY_E = Key'E+    | v == c'GLFW_KEY_F = Key'F+    | v == c'GLFW_KEY_G = Key'G+    | v == c'GLFW_KEY_H = Key'H+    | v == c'GLFW_KEY_I = Key'I+    | v == c'GLFW_KEY_J = Key'J+    | v == c'GLFW_KEY_K = Key'K+    | v == c'GLFW_KEY_L = Key'L+    | v == c'GLFW_KEY_M = Key'M+    | v == c'GLFW_KEY_N = Key'N+    | v == c'GLFW_KEY_O = Key'O+    | v == c'GLFW_KEY_P = Key'P+    | v == c'GLFW_KEY_Q = Key'Q+    | v == c'GLFW_KEY_R = Key'R+    | v == c'GLFW_KEY_S = Key'S+    | v == c'GLFW_KEY_T = Key'T+    | v == c'GLFW_KEY_U = Key'U+    | v == c'GLFW_KEY_V = Key'V+    | v == c'GLFW_KEY_W = Key'W+    | v == c'GLFW_KEY_X = Key'X+    | v == c'GLFW_KEY_Y = Key'Y+    | v == c'GLFW_KEY_Z = Key'Z+    | v == c'GLFW_KEY_LEFT_BRACKET = Key'LeftBracket+    | v == c'GLFW_KEY_BACKSLASH = Key'Backslash+    | v == c'GLFW_KEY_RIGHT_BRACKET = Key'RightBracket+    | v == c'GLFW_KEY_GRAVE_ACCENT = Key'GraveAccent+    | v == c'GLFW_KEY_WORLD_1 = Key'World1+    | v == c'GLFW_KEY_WORLD_2 = Key'World2+    | v == c'GLFW_KEY_ESCAPE = Key'Escape+    | v == c'GLFW_KEY_ENTER = Key'Enter+    | v == c'GLFW_KEY_TAB = Key'Tab+    | v == c'GLFW_KEY_BACKSPACE = Key'Backspace+    | v == c'GLFW_KEY_INSERT = Key'Insert+    | v == c'GLFW_KEY_DELETE = Key'Delete+    | v == c'GLFW_KEY_RIGHT = Key'Right+    | v == c'GLFW_KEY_LEFT = Key'Left+    | v == c'GLFW_KEY_DOWN = Key'Down+    | v == c'GLFW_KEY_UP = Key'Up+    | v == c'GLFW_KEY_PAGE_UP = Key'PageUp+    | v == c'GLFW_KEY_PAGE_DOWN = Key'PageDown+    | v == c'GLFW_KEY_HOME = Key'Home+    | v == c'GLFW_KEY_END = Key'End+    | v == c'GLFW_KEY_CAPS_LOCK = Key'CapsLock+    | v == c'GLFW_KEY_SCROLL_LOCK = Key'ScrollLock+    | v == c'GLFW_KEY_NUM_LOCK = Key'NumLock+    | v == c'GLFW_KEY_PRINT_SCREEN = Key'PrintScreen+    | v == c'GLFW_KEY_PAUSE = Key'Pause+    | v == c'GLFW_KEY_F1 = Key'F1+    | v == c'GLFW_KEY_F2 = Key'F2+    | v == c'GLFW_KEY_F3 = Key'F3+    | v == c'GLFW_KEY_F4 = Key'F4+    | v == c'GLFW_KEY_F5 = Key'F5+    | v == c'GLFW_KEY_F6 = Key'F6+    | v == c'GLFW_KEY_F7 = Key'F7+    | v == c'GLFW_KEY_F8 = Key'F8+    | v == c'GLFW_KEY_F9 = Key'F9+    | v == c'GLFW_KEY_F10 = Key'F10+    | v == c'GLFW_KEY_F11 = Key'F11+    | v == c'GLFW_KEY_F12 = Key'F12+    | v == c'GLFW_KEY_F13 = Key'F13+    | v == c'GLFW_KEY_F14 = Key'F14+    | v == c'GLFW_KEY_F15 = Key'F15+    | v == c'GLFW_KEY_F16 = Key'F16+    | v == c'GLFW_KEY_F17 = Key'F17+    | v == c'GLFW_KEY_F18 = Key'F18+    | v == c'GLFW_KEY_F19 = Key'F19+    | v == c'GLFW_KEY_F20 = Key'F20+    | v == c'GLFW_KEY_F21 = Key'F21+    | v == c'GLFW_KEY_F22 = Key'F22+    | v == c'GLFW_KEY_F23 = Key'F23+    | v == c'GLFW_KEY_F24 = Key'F24+    | v == c'GLFW_KEY_F25 = Key'F25+    | v == c'GLFW_KEY_KP_0 = Key'Pad0+    | v == c'GLFW_KEY_KP_1 = Key'Pad1+    | v == c'GLFW_KEY_KP_2 = Key'Pad2+    | v == c'GLFW_KEY_KP_3 = Key'Pad3+    | v == c'GLFW_KEY_KP_4 = Key'Pad4+    | v == c'GLFW_KEY_KP_5 = Key'Pad5+    | v == c'GLFW_KEY_KP_6 = Key'Pad6+    | v == c'GLFW_KEY_KP_7 = Key'Pad7+    | v == c'GLFW_KEY_KP_8 = Key'Pad8+    | v == c'GLFW_KEY_KP_9 = Key'Pad9+    | v == c'GLFW_KEY_KP_DECIMAL = Key'PadDecimal+    | v == c'GLFW_KEY_KP_DIVIDE = Key'PadDivide+    | v == c'GLFW_KEY_KP_MULTIPLY = Key'PadMultiply+    | v == c'GLFW_KEY_KP_SUBTRACT = Key'PadSubtract+    | v == c'GLFW_KEY_KP_ADD = Key'PadAdd+    | v == c'GLFW_KEY_KP_ENTER = Key'PadEnter+    | v == c'GLFW_KEY_KP_EQUAL = Key'PadEqual+    | v == c'GLFW_KEY_LEFT_SHIFT = Key'LeftShift+    | v == c'GLFW_KEY_LEFT_CONTROL = Key'LeftControl+    | v == c'GLFW_KEY_LEFT_ALT = Key'LeftAlt+    | v == c'GLFW_KEY_LEFT_SUPER = Key'LeftSuper+    | v == c'GLFW_KEY_RIGHT_SHIFT = Key'RightShift+    | v == c'GLFW_KEY_RIGHT_CONTROL = Key'RightControl+    | v == c'GLFW_KEY_RIGHT_ALT = Key'RightAlt+    | v == c'GLFW_KEY_RIGHT_SUPER = Key'RightSuper+    | v == c'GLFW_KEY_MENU = Key'Menu+    | otherwise = error $ "C CInt Key fromC: " ++ show v+  toC Key'Unknown = c'GLFW_KEY_UNKNOWN+  toC Key'Space = c'GLFW_KEY_SPACE+  toC Key'Apostrophe = c'GLFW_KEY_APOSTROPHE+  toC Key'Comma = c'GLFW_KEY_COMMA+  toC Key'Minus = c'GLFW_KEY_MINUS+  toC Key'Period = c'GLFW_KEY_PERIOD+  toC Key'Slash = c'GLFW_KEY_SLASH+  toC Key'0 = c'GLFW_KEY_0+  toC Key'1 = c'GLFW_KEY_1+  toC Key'2 = c'GLFW_KEY_2+  toC Key'3 = c'GLFW_KEY_3+  toC Key'4 = c'GLFW_KEY_4+  toC Key'5 = c'GLFW_KEY_5+  toC Key'6 = c'GLFW_KEY_6+  toC Key'7 = c'GLFW_KEY_7+  toC Key'8 = c'GLFW_KEY_8+  toC Key'9 = c'GLFW_KEY_9+  toC Key'Semicolon = c'GLFW_KEY_SEMICOLON+  toC Key'Equal = c'GLFW_KEY_EQUAL+  toC Key'A = c'GLFW_KEY_A+  toC Key'B = c'GLFW_KEY_B+  toC Key'C = c'GLFW_KEY_C+  toC Key'D = c'GLFW_KEY_D+  toC Key'E = c'GLFW_KEY_E+  toC Key'F = c'GLFW_KEY_F+  toC Key'G = c'GLFW_KEY_G+  toC Key'H = c'GLFW_KEY_H+  toC Key'I = c'GLFW_KEY_I+  toC Key'J = c'GLFW_KEY_J+  toC Key'K = c'GLFW_KEY_K+  toC Key'L = c'GLFW_KEY_L+  toC Key'M = c'GLFW_KEY_M+  toC Key'N = c'GLFW_KEY_N+  toC Key'O = c'GLFW_KEY_O+  toC Key'P = c'GLFW_KEY_P+  toC Key'Q = c'GLFW_KEY_Q+  toC Key'R = c'GLFW_KEY_R+  toC Key'S = c'GLFW_KEY_S+  toC Key'T = c'GLFW_KEY_T+  toC Key'U = c'GLFW_KEY_U+  toC Key'V = c'GLFW_KEY_V+  toC Key'W = c'GLFW_KEY_W+  toC Key'X = c'GLFW_KEY_X+  toC Key'Y = c'GLFW_KEY_Y+  toC Key'Z = c'GLFW_KEY_Z+  toC Key'LeftBracket = c'GLFW_KEY_LEFT_BRACKET+  toC Key'Backslash = c'GLFW_KEY_BACKSLASH+  toC Key'RightBracket = c'GLFW_KEY_RIGHT_BRACKET+  toC Key'GraveAccent = c'GLFW_KEY_GRAVE_ACCENT+  toC Key'World1 = c'GLFW_KEY_WORLD_1+  toC Key'World2 = c'GLFW_KEY_WORLD_2+  toC Key'Escape = c'GLFW_KEY_ESCAPE+  toC Key'Enter = c'GLFW_KEY_ENTER+  toC Key'Tab = c'GLFW_KEY_TAB+  toC Key'Backspace = c'GLFW_KEY_BACKSPACE+  toC Key'Insert = c'GLFW_KEY_INSERT+  toC Key'Delete = c'GLFW_KEY_DELETE+  toC Key'Right = c'GLFW_KEY_RIGHT+  toC Key'Left = c'GLFW_KEY_LEFT+  toC Key'Down = c'GLFW_KEY_DOWN+  toC Key'Up = c'GLFW_KEY_UP+  toC Key'PageUp = c'GLFW_KEY_PAGE_UP+  toC Key'PageDown = c'GLFW_KEY_PAGE_DOWN+  toC Key'Home = c'GLFW_KEY_HOME+  toC Key'End = c'GLFW_KEY_END+  toC Key'CapsLock = c'GLFW_KEY_CAPS_LOCK+  toC Key'ScrollLock = c'GLFW_KEY_SCROLL_LOCK+  toC Key'NumLock = c'GLFW_KEY_NUM_LOCK+  toC Key'PrintScreen = c'GLFW_KEY_PRINT_SCREEN+  toC Key'Pause = c'GLFW_KEY_PAUSE+  toC Key'F1 = c'GLFW_KEY_F1+  toC Key'F2 = c'GLFW_KEY_F2+  toC Key'F3 = c'GLFW_KEY_F3+  toC Key'F4 = c'GLFW_KEY_F4+  toC Key'F5 = c'GLFW_KEY_F5+  toC Key'F6 = c'GLFW_KEY_F6+  toC Key'F7 = c'GLFW_KEY_F7+  toC Key'F8 = c'GLFW_KEY_F8+  toC Key'F9 = c'GLFW_KEY_F9+  toC Key'F10 = c'GLFW_KEY_F10+  toC Key'F11 = c'GLFW_KEY_F11+  toC Key'F12 = c'GLFW_KEY_F12+  toC Key'F13 = c'GLFW_KEY_F13+  toC Key'F14 = c'GLFW_KEY_F14+  toC Key'F15 = c'GLFW_KEY_F15+  toC Key'F16 = c'GLFW_KEY_F16+  toC Key'F17 = c'GLFW_KEY_F17+  toC Key'F18 = c'GLFW_KEY_F18+  toC Key'F19 = c'GLFW_KEY_F19+  toC Key'F20 = c'GLFW_KEY_F20+  toC Key'F21 = c'GLFW_KEY_F21+  toC Key'F22 = c'GLFW_KEY_F22+  toC Key'F23 = c'GLFW_KEY_F23+  toC Key'F24 = c'GLFW_KEY_F24+  toC Key'F25 = c'GLFW_KEY_F25+  toC Key'Pad0 = c'GLFW_KEY_KP_0+  toC Key'Pad1 = c'GLFW_KEY_KP_1+  toC Key'Pad2 = c'GLFW_KEY_KP_2+  toC Key'Pad3 = c'GLFW_KEY_KP_3+  toC Key'Pad4 = c'GLFW_KEY_KP_4+  toC Key'Pad5 = c'GLFW_KEY_KP_5+  toC Key'Pad6 = c'GLFW_KEY_KP_6+  toC Key'Pad7 = c'GLFW_KEY_KP_7+  toC Key'Pad8 = c'GLFW_KEY_KP_8+  toC Key'Pad9 = c'GLFW_KEY_KP_9+  toC Key'PadDecimal = c'GLFW_KEY_KP_DECIMAL+  toC Key'PadDivide = c'GLFW_KEY_KP_DIVIDE+  toC Key'PadMultiply = c'GLFW_KEY_KP_MULTIPLY+  toC Key'PadSubtract = c'GLFW_KEY_KP_SUBTRACT+  toC Key'PadAdd = c'GLFW_KEY_KP_ADD+  toC Key'PadEnter = c'GLFW_KEY_KP_ENTER+  toC Key'PadEqual = c'GLFW_KEY_KP_EQUAL+  toC Key'LeftShift = c'GLFW_KEY_LEFT_SHIFT+  toC Key'LeftControl = c'GLFW_KEY_LEFT_CONTROL+  toC Key'LeftAlt = c'GLFW_KEY_LEFT_ALT+  toC Key'LeftSuper = c'GLFW_KEY_LEFT_SUPER+  toC Key'RightShift = c'GLFW_KEY_RIGHT_SHIFT+  toC Key'RightControl = c'GLFW_KEY_RIGHT_CONTROL+  toC Key'RightAlt = c'GLFW_KEY_RIGHT_ALT+  toC Key'RightSuper = c'GLFW_KEY_RIGHT_SUPER+  toC Key'Menu = c'GLFW_KEY_MENU++instance C CInt KeyState where+  fromC v+    | v == c'GLFW_PRESS = KeyState'Pressed+    | v == c'GLFW_RELEASE = KeyState'Released+    | v == c'GLFW_REPEAT = KeyState'Repeating+    | otherwise = error $ "C CInt KeyState fromC: " ++ show v+  toC KeyState'Pressed = c'GLFW_PRESS+  toC KeyState'Released = c'GLFW_RELEASE+  toC KeyState'Repeating = c'GLFW_REPEAT++instance C CInt Joystick where+  fromC v+    | v == c'GLFW_JOYSTICK_1 = Joystick'1+    | v == c'GLFW_JOYSTICK_2 = Joystick'2+    | v == c'GLFW_JOYSTICK_3 = Joystick'3+    | v == c'GLFW_JOYSTICK_4 = Joystick'4+    | v == c'GLFW_JOYSTICK_5 = Joystick'5+    | v == c'GLFW_JOYSTICK_6 = Joystick'6+    | v == c'GLFW_JOYSTICK_7 = Joystick'7+    | v == c'GLFW_JOYSTICK_8 = Joystick'8+    | v == c'GLFW_JOYSTICK_9 = Joystick'9+    | v == c'GLFW_JOYSTICK_10 = Joystick'10+    | v == c'GLFW_JOYSTICK_11 = Joystick'11+    | v == c'GLFW_JOYSTICK_12 = Joystick'12+    | v == c'GLFW_JOYSTICK_13 = Joystick'13+    | v == c'GLFW_JOYSTICK_14 = Joystick'14+    | v == c'GLFW_JOYSTICK_15 = Joystick'15+    | v == c'GLFW_JOYSTICK_16 = Joystick'16+    | otherwise = error $ "C CInt Joystick fromC: " ++ show v+  toC Joystick'1 = c'GLFW_JOYSTICK_1+  toC Joystick'2 = c'GLFW_JOYSTICK_2+  toC Joystick'3 = c'GLFW_JOYSTICK_3+  toC Joystick'4 = c'GLFW_JOYSTICK_4+  toC Joystick'5 = c'GLFW_JOYSTICK_5+  toC Joystick'6 = c'GLFW_JOYSTICK_6+  toC Joystick'7 = c'GLFW_JOYSTICK_7+  toC Joystick'8 = c'GLFW_JOYSTICK_8+  toC Joystick'9 = c'GLFW_JOYSTICK_9+  toC Joystick'10 = c'GLFW_JOYSTICK_10+  toC Joystick'11 = c'GLFW_JOYSTICK_11+  toC Joystick'12 = c'GLFW_JOYSTICK_12+  toC Joystick'13 = c'GLFW_JOYSTICK_13+  toC Joystick'14 = c'GLFW_JOYSTICK_14+  toC Joystick'15 = c'GLFW_JOYSTICK_15+  toC Joystick'16 = c'GLFW_JOYSTICK_16++instance C CUChar JoystickHatState where+  fromC v+    | v == c'GLFW_HAT_CENTERED = JoystickHatState'Centered+    | v == c'GLFW_HAT_UP = JoystickHatState'Up+    | v == c'GLFW_HAT_RIGHT = JoystickHatState'Right+    | v == c'GLFW_HAT_DOWN = JoystickHatState'Down+    | v == c'GLFW_HAT_LEFT = JoystickHatState'Left+    | v == c'GLFW_HAT_RIGHT_UP = JoystickHatState'RightUp+    | v == c'GLFW_HAT_RIGHT_DOWN = JoystickHatState'RightDown+    | v == c'GLFW_HAT_LEFT_UP = JoystickHatState'LeftUp+    | v == c'GLFW_HAT_LEFT_DOWN = JoystickHatState'LeftDown+    | otherwise = error $ "C CUChar JoystickHatState fromC: " ++ show v+  toC JoystickHatState'Centered = c'GLFW_HAT_CENTERED+  toC JoystickHatState'Up = c'GLFW_HAT_UP+  toC JoystickHatState'Right = c'GLFW_HAT_RIGHT+  toC JoystickHatState'Down = c'GLFW_HAT_DOWN+  toC JoystickHatState'Left = c'GLFW_HAT_LEFT+  toC JoystickHatState'RightUp = c'GLFW_HAT_RIGHT_UP+  toC JoystickHatState'RightDown = c'GLFW_HAT_RIGHT_DOWN+  toC JoystickHatState'LeftUp = c'GLFW_HAT_LEFT_UP+  toC JoystickHatState'LeftDown = c'GLFW_HAT_LEFT_DOWN++instance C CUChar JoystickButtonState where+  fromC v+    | v == c'GLFW_PRESS = JoystickButtonState'Pressed+    | v == c'GLFW_RELEASE = JoystickButtonState'Released+    | otherwise = error $ "C CUChar JoystickButtonState fromC: " ++ show v+  toC JoystickButtonState'Pressed = c'GLFW_PRESS+  toC JoystickButtonState'Released = c'GLFW_RELEASE++instance C CInt JoystickState where+  fromC v+    | v == c'GLFW_CONNECTED = JoystickState'Connected+    | v == c'GLFW_DISCONNECTED = JoystickState'Disconnected+    | otherwise = error $ "C CInt JoystickState fromC: " ++ show v+  toC JoystickState'Connected = c'GLFW_CONNECTED+  toC JoystickState'Disconnected = c'GLFW_DISCONNECTED++instance C CInt GamepadButton where+  fromC v+    | v == c'GLFW_GAMEPAD_BUTTON_A = GamepadButton'A+    | v == c'GLFW_GAMEPAD_BUTTON_B = GamepadButton'B+    | v == c'GLFW_GAMEPAD_BUTTON_X = GamepadButton'X+    | v == c'GLFW_GAMEPAD_BUTTON_Y = GamepadButton'Y+    | v == c'GLFW_GAMEPAD_BUTTON_LEFT_BUMPER = GamepadButton'LeftBumper+    | v == c'GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER = GamepadButton'RightBumper+    | v == c'GLFW_GAMEPAD_BUTTON_BACK = GamepadButton'Back+    | v == c'GLFW_GAMEPAD_BUTTON_START = GamepadButton'Start+    | v == c'GLFW_GAMEPAD_BUTTON_GUIDE = GamepadButton'Guide+    | v == c'GLFW_GAMEPAD_BUTTON_LEFT_THUMB = GamepadButton'LeftThumb+    | v == c'GLFW_GAMEPAD_BUTTON_RIGHT_THUMB = GamepadButton'RightThumb+    | v == c'GLFW_GAMEPAD_BUTTON_DPAD_UP = GamepadButton'DpadUp+    | v == c'GLFW_GAMEPAD_BUTTON_DPAD_RIGHT = GamepadButton'DpadRight+    | v == c'GLFW_GAMEPAD_BUTTON_DPAD_DOWN = GamepadButton'DpadDown+    | v == c'GLFW_GAMEPAD_BUTTON_DPAD_LEFT = GamepadButton'DpadLeft+    | v == c'GLFW_GAMEPAD_BUTTON_CROSS = GamepadButton'Cross+    | v == c'GLFW_GAMEPAD_BUTTON_CIRCLE = GamepadButton'Circle+    | v == c'GLFW_GAMEPAD_BUTTON_SQUARE = GamepadButton'Square+    | v == c'GLFW_GAMEPAD_BUTTON_TRIANGLE = GamepadButton'Triangle+    | otherwise = error $ "C CInt GamepadButton fromC: " ++ show v+  toC GamepadButton'A = c'GLFW_GAMEPAD_BUTTON_A+  toC GamepadButton'B = c'GLFW_GAMEPAD_BUTTON_B+  toC GamepadButton'X = c'GLFW_GAMEPAD_BUTTON_X+  toC GamepadButton'Y = c'GLFW_GAMEPAD_BUTTON_Y+  toC GamepadButton'LeftBumper = c'GLFW_GAMEPAD_BUTTON_LEFT_BUMPER+  toC GamepadButton'RightBumper = c'GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER+  toC GamepadButton'Back = c'GLFW_GAMEPAD_BUTTON_BACK+  toC GamepadButton'Start = c'GLFW_GAMEPAD_BUTTON_START+  toC GamepadButton'Guide = c'GLFW_GAMEPAD_BUTTON_GUIDE+  toC GamepadButton'LeftThumb = c'GLFW_GAMEPAD_BUTTON_LEFT_THUMB+  toC GamepadButton'RightThumb = c'GLFW_GAMEPAD_BUTTON_RIGHT_THUMB+  toC GamepadButton'DpadUp = c'GLFW_GAMEPAD_BUTTON_DPAD_UP+  toC GamepadButton'DpadRight = c'GLFW_GAMEPAD_BUTTON_DPAD_RIGHT+  toC GamepadButton'DpadDown = c'GLFW_GAMEPAD_BUTTON_DPAD_DOWN+  toC GamepadButton'DpadLeft = c'GLFW_GAMEPAD_BUTTON_DPAD_LEFT+  toC GamepadButton'Cross = c'GLFW_GAMEPAD_BUTTON_CROSS+  toC GamepadButton'Circle = c'GLFW_GAMEPAD_BUTTON_CIRCLE+  toC GamepadButton'Square = c'GLFW_GAMEPAD_BUTTON_SQUARE+  toC GamepadButton'Triangle = c'GLFW_GAMEPAD_BUTTON_TRIANGLE++instance C CUChar GamepadButtonState where+  fromC v+    | v == c'GLFW_PRESS = GamepadButtonState'Pressed+    | v == c'GLFW_RELEASE = GamepadButtonState'Released+    | otherwise = error $ "C CUChar GamepadButtonState fromC: " ++ show v+  toC GamepadButtonState'Pressed = c'GLFW_PRESS+  toC GamepadButtonState'Released = c'GLFW_RELEASE++instance C CInt GamepadAxis where+  fromC v+    | v == c'GLFW_GAMEPAD_AXIS_LEFT_X = GamepadAxis'LeftX+    | v == c'GLFW_GAMEPAD_AXIS_RIGHT_X = GamepadAxis'RightX+    | v == c'GLFW_GAMEPAD_AXIS_LEFT_Y = GamepadAxis'LeftY+    | v == c'GLFW_GAMEPAD_AXIS_RIGHT_Y = GamepadAxis'RightY+    | v == c'GLFW_GAMEPAD_AXIS_LEFT_TRIGGER = GamepadAxis'LeftTrigger+    | v == c'GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER = GamepadAxis'RightTrigger+    | otherwise = error $ "C CInt GamepadAxis fromC: " ++ show v+  toC GamepadAxis'LeftX = c'GLFW_GAMEPAD_AXIS_LEFT_X+  toC GamepadAxis'RightX = c'GLFW_GAMEPAD_AXIS_RIGHT_X+  toC GamepadAxis'LeftY = c'GLFW_GAMEPAD_AXIS_LEFT_Y+  toC GamepadAxis'RightY = c'GLFW_GAMEPAD_AXIS_RIGHT_Y+  toC GamepadAxis'LeftTrigger = c'GLFW_GAMEPAD_AXIS_LEFT_TRIGGER+  toC GamepadAxis'RightTrigger = c'GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER++instance C CInt MouseButton where+  fromC v+    | v == c'GLFW_MOUSE_BUTTON_1 = MouseButton'1+    | v == c'GLFW_MOUSE_BUTTON_2 = MouseButton'2+    | v == c'GLFW_MOUSE_BUTTON_3 = MouseButton'3+    | v == c'GLFW_MOUSE_BUTTON_4 = MouseButton'4+    | v == c'GLFW_MOUSE_BUTTON_5 = MouseButton'5+    | v == c'GLFW_MOUSE_BUTTON_6 = MouseButton'6+    | v == c'GLFW_MOUSE_BUTTON_7 = MouseButton'7+    | v == c'GLFW_MOUSE_BUTTON_8 = MouseButton'8+    | otherwise = error $ "C CInt MouseButton fromC: " ++ show v+  toC MouseButton'1 = c'GLFW_MOUSE_BUTTON_1+  toC MouseButton'2 = c'GLFW_MOUSE_BUTTON_2+  toC MouseButton'3 = c'GLFW_MOUSE_BUTTON_3+  toC MouseButton'4 = c'GLFW_MOUSE_BUTTON_4+  toC MouseButton'5 = c'GLFW_MOUSE_BUTTON_5+  toC MouseButton'6 = c'GLFW_MOUSE_BUTTON_6+  toC MouseButton'7 = c'GLFW_MOUSE_BUTTON_7+  toC MouseButton'8 = c'GLFW_MOUSE_BUTTON_8++instance C CInt MouseButtonState where+  fromC v+    | v == c'GLFW_PRESS = MouseButtonState'Pressed+    | v == c'GLFW_RELEASE = MouseButtonState'Released+    | otherwise = error $ "C CInt MouseButtonState fromC: " ++ show v+  toC MouseButtonState'Pressed = c'GLFW_PRESS+  toC MouseButtonState'Released = c'GLFW_RELEASE++instance C CInt CursorState where+  fromC v+    | v == c'GLFW_TRUE = CursorState'InWindow+    | v == c'GLFW_FALSE = CursorState'NotInWindow+    | otherwise = error $ "C CInt CursorState fromC: " ++ show v+  toC CursorState'InWindow = c'GLFW_TRUE+  toC CursorState'NotInWindow = c'GLFW_FALSE++instance C CInt CursorInputMode where+  fromC v+    | v == c'GLFW_CURSOR_NORMAL = CursorInputMode'Normal+    | v == c'GLFW_CURSOR_HIDDEN = CursorInputMode'Hidden+    | v == c'GLFW_CURSOR_DISABLED = CursorInputMode'Disabled+    | otherwise = error $ "C CInt CursorInputMode fromC: " ++ show v+  toC CursorInputMode'Normal = c'GLFW_CURSOR_NORMAL+  toC CursorInputMode'Hidden = c'GLFW_CURSOR_HIDDEN+  toC CursorInputMode'Disabled = c'GLFW_CURSOR_DISABLED++instance C CInt StickyKeysInputMode where+  fromC v+    | v == c'GLFW_TRUE = StickyKeysInputMode'Enabled+    | v == c'GLFW_FALSE = StickyKeysInputMode'Disabled+    | otherwise = error $ "C CInt StickyKeysInputMode fromC: " ++ show v+  toC StickyKeysInputMode'Enabled = c'GLFW_TRUE+  toC StickyKeysInputMode'Disabled = c'GLFW_FALSE++instance C CInt StickyMouseButtonsInputMode where+  fromC v+    | v == c'GLFW_TRUE = StickyMouseButtonsInputMode'Enabled+    | v == c'GLFW_FALSE = StickyMouseButtonsInputMode'Disabled+    | otherwise = error $ "C CInt StickyMouseButtonsInputMode fromC: " ++ show v+  toC StickyMouseButtonsInputMode'Enabled = c'GLFW_TRUE+  toC StickyMouseButtonsInputMode'Disabled = c'GLFW_FALSE++instance C CInt WindowAttrib where+  fromC v+    | v == c'GLFW_DECORATED = WindowAttrib'Decorated+    | v == c'GLFW_RESIZABLE = WindowAttrib'Resizable+    | v == c'GLFW_FLOATING = WindowAttrib'Floating+    | v == c'GLFW_AUTO_ICONIFY = WindowAttrib'AutoIconify+    | v == c'GLFW_FOCUS_ON_SHOW = WindowAttrib'FocusOnShow+    | v == c'GLFW_HOVERED = WindowAttrib'Hovered+    | otherwise = error $ "C CInt WindowAttrib fromC: " ++ show v+  toC WindowAttrib'Decorated = c'GLFW_DECORATED+  toC WindowAttrib'Resizable = c'GLFW_RESIZABLE+  toC WindowAttrib'Floating = c'GLFW_FLOATING+  toC WindowAttrib'AutoIconify = c'GLFW_AUTO_ICONIFY+  toC WindowAttrib'FocusOnShow = c'GLFW_FOCUS_ON_SHOW+  toC WindowAttrib'Hovered = c'GLFW_HOVERED++--------------------------------------------------------------------------------++{-# ANN module "HLint: ignore Use camelCase" #-}
+ Graphics/UI/GLFW/Types.hs view
@@ -0,0 +1,647 @@+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE StandaloneDeriving #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}++-- | The types of the package. This module is considered "internal", and the+-- types are re-exported from Graphics.UI.GLFW as necessary.+module Graphics.UI.GLFW.Types where++--------------------------------------------------------------------------------++import Control.DeepSeq  (NFData)+import Data.Data        (Data)+import Data.IORef       (IORef)+import Data.Typeable    (Typeable)+import Data.Word        (Word8)+import Foreign.Ptr      (Ptr)+import Foreign.C.Types  (CUChar(..))+import GHC.Generics++import Bindings.GLFW++--------------------------------------------------------------------------------+-- Error handling++-- | An enum for one of the <http://www.glfw.org/docs/3.3/group__errors.html#ga196e125ef261d94184e2b55c05762f14 GLFW error codes>.+data Error =+    Error'NotInitialized -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#ga2374ee02c177f12e1fa76ff3ed15e14a doc>+  | Error'NoCurrentContext -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#gaa8290386e9528ccb9e42a3a4e16fc0d0 doc>+  | Error'InvalidEnum -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#ga76f6bb9c4eea73db675f096b404593ce doc>+  | Error'InvalidValue -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#gaaf2ef9aa8202c2b82ac2d921e554c687 doc>+  | Error'OutOfMemory -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#ga9023953a2bcb98c2906afd071d21ee7f doc>+  | Error'ApiUnavailable -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#ga56882b290db23261cc6c053c40c2d08e doc>+  | Error'VersionUnavailable -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#gad16c5565b4a69f9c2a9ac2c0dbc89462 doc>+  | Error'PlatformError -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#gad44162d78100ea5e87cdd38426b8c7a1 doc>+  | Error'FormatUnavailable -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#ga196e125ef261d94184e2b55c05762f14 doc>+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData Error++--------------------------------------------------------------------------------+-- Initialization and version information++-- | Initialization hints are set before glfwInit and affect how the library+-- behaves until termination. Hints are set with glfwInitHint. See+-- <https://www.glfw.org/docs/3.3/intro_guide.html#init_hints Init Hints>+data InitHint+  = InitHint'JoystickHatButtons+  | InitHint'CocoaChdirResources+  | InitHint'CocoaMenubar+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData InitHint++-- | The library version of the GLFW implementation in use.+-- See <http://www.glfw.org/docs/3.3/intro.html#intro_version Version Management>+data Version = Version+  { versionMajor    :: {-# UNPACK #-} !Int+  , versionMinor    :: {-# UNPACK #-} !Int+  , versionRevision :: {-# UNPACK #-} !Int+  } deriving (Data, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData Version++--------------------------------------------------------------------------------+-- Monitor handling++-- | Represents a physical monitor that's currently connected.+-- See the <http://www.glfw.org/docs/3.3/monitor.html Monitor Guide>+newtype Monitor = Monitor+  { unMonitor :: Ptr C'GLFWmonitor+  } deriving (Data, Eq, Ord, Show, Typeable, Generic)++-- | Part of the t'Graphics.UI.GLFW.MonitorCallback', for when a monitor gets+-- connected or disconnected.+data MonitorState =+    MonitorState'Connected+  | MonitorState'Disconnected+  deriving (Data, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData MonitorState++-- | See <http://www.glfw.org/docs/3.3/monitor.html#monitor_modes Video Modes>+data VideoMode = VideoMode+  { videoModeWidth       :: {-# UNPACK #-} !Int+  , videoModeHeight      :: {-# UNPACK #-} !Int+  , videoModeRedBits     :: {-# UNPACK #-} !Int+  , videoModeGreenBits   :: {-# UNPACK #-} !Int+  , videoModeBlueBits    :: {-# UNPACK #-} !Int+  , videoModeRefreshRate :: {-# UNPACK #-} !Int+  } deriving (Data, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData VideoMode++-- | Lets you adjust the gamma of a monitor. To ensure that only valid values are created, use 'makeGammaRamp'.+-- See <http://www.glfw.org/docs/3.3/monitor.html#monitor_gamma Gamma Ramp>.+data GammaRamp = GammaRamp+  -- NOTE: It would be bad to give clients a way to construct invalid gamma ramps+  -- with lists of unequal length, so this constructor should not be exported.+  { gammaRampRed   :: [Int]+  , gammaRampGreen :: [Int]+  , gammaRampBlue  :: [Int]+  } deriving (Data, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData GammaRamp++-- | Smart constructor for a 'GammaRamp'.+makeGammaRamp :: [Int] -> [Int] -> [Int] -> Maybe GammaRamp+makeGammaRamp rs gs bs+    | lengthsEqual = Just $ GammaRamp rs gs bs+    | otherwise    = Nothing+  where+    lengthsEqual =+      let rsl = length rs+          gsl = length gs+          bsl = length bs+      in rsl == gsl && gsl == bsl++--------------------------------------------------------------------------------+-- Window handling++-- | Collects all the callbacks that can be associated with a Window into a single place.+data WindowCallbacks = WindowCallbacks+  { storedCharFun               :: !(IORef C'GLFWcharfun)+  , storedCharModsFun           :: !(IORef C'GLFWcharmodsfun)+  , storedCursorEnterFun        :: !(IORef C'GLFWcursorenterfun)+  , storedCursorPosFun          :: !(IORef C'GLFWcursorposfun)+  , storedFramebufferSizeFun    :: !(IORef C'GLFWframebuffersizefun)+  , storedKeyFun                :: !(IORef C'GLFWkeyfun)+  , storedMouseButtonFun        :: !(IORef C'GLFWmousebuttonfun)+  , storedScrollFun             :: !(IORef C'GLFWscrollfun)+  , storedWindowCloseFun        :: !(IORef C'GLFWwindowclosefun)+  , storedWindowFocusFun        :: !(IORef C'GLFWwindowfocusfun)+  , storedWindowIconifyFun      :: !(IORef C'GLFWwindowiconifyfun)+  , storedWindowPosFun          :: !(IORef C'GLFWwindowposfun)+  , storedWindowRefreshFun      :: !(IORef C'GLFWwindowrefreshfun)+  , storedWindowSizeFun         :: !(IORef C'GLFWwindowsizefun)+  , storedWindowContentScaleFun :: !(IORef C'GLFWwindowcontentscalefun)+  , storedWindowMaximizeFun     :: !(IORef C'GLFWwindowmaximizefun)+  , storedDropFun               :: !(IORef C'GLFWdropfun)+  }++-- | Represents a GLFW window value.+-- See the <http://www.glfw.org/docs/3.3/window.html Window Guide>+newtype Window = Window+  { unWindow :: Ptr C'GLFWwindow+  } deriving (Data, Eq, Ord, Show, Typeable, Generic)++-- | Lets you set various window hints before creating a 'Window'.+-- See <http://www.glfw.org/docs/3.3/window.html#window_hints Window Hints>,+-- particularly <http://www.glfw.org/docs/3.3/window.html#window_hints_values Supported and Default Values>.+data WindowHint =+    WindowHint'Resizable              !Bool+  | WindowHint'Visible                !Bool+  | WindowHint'Decorated              !Bool+  | WindowHint'RedBits                !(Maybe Int)+  | WindowHint'GreenBits              !(Maybe Int)+  | WindowHint'BlueBits               !(Maybe Int)+  | WindowHint'AlphaBits              !(Maybe Int)+  | WindowHint'DepthBits              !(Maybe Int)+  | WindowHint'StencilBits            !(Maybe Int)+  | WindowHint'AccumRedBits           !(Maybe Int)+  | WindowHint'AccumGreenBits         !(Maybe Int)+  | WindowHint'AccumBlueBits          !(Maybe Int)+  | WindowHint'AccumAlphaBits         !(Maybe Int)+  | WindowHint'AuxBuffers             !(Maybe Int)+  | WindowHint'Samples                !(Maybe Int)+  | WindowHint'RefreshRate            !(Maybe Int)+  | WindowHint'DoubleBuffer           !Bool+  | WindowHint'Stereo                 !Bool+  | WindowHint'sRGBCapable            !Bool+  | WindowHint'Floating               !Bool+  | WindowHint'Focused                !Bool+  | WindowHint'Maximized              !Bool+  | WindowHint'AutoIconify            !Bool+  | WindowHint'ClientAPI              !ClientAPI+  | WindowHint'ContextCreationAPI     !ContextCreationAPI+  | WindowHint'ContextVersionMajor    {-# UNPACK #-} !Int+  | WindowHint'ContextVersionMinor    {-# UNPACK #-} !Int+  | WindowHint'ContextRobustness      !ContextRobustness+  | WindowHint'ContextReleaseBehavior !ContextReleaseBehavior+  | WindowHint'ContextNoError         !Bool+  | WindowHint'OpenGLForwardCompat    !Bool+  | WindowHint'OpenGLDebugContext     !Bool+  | WindowHint'OpenGLProfile          !OpenGLProfile+  | WindowHint'TransparentFramebuffer !Bool+  | WindowHint'CenterCursor           !Bool+  | WindowHint'FocusOnShow            !Bool+  | WindowHint'ScaleToMonitor         !Bool+  | WindowHint'CocoaRetinaFramebuffer !Bool+  | WindowHint'CocoaGraphicsSwitching !Bool+  | WindowHint'CocoaFrameName         !String+  | WindowHint'X11ClassName           !String+  | WindowHint'X11InstanceName        !String+  deriving (Data, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData WindowHint++-- | A window-specific attribute.+-- See <https://www.glfw.org/docs/3.3/window_guide.html#window_attribs Window Attributes>+data WindowAttrib+  = WindowAttrib'Decorated+  | WindowAttrib'Resizable+  | WindowAttrib'Floating+  | WindowAttrib'AutoIconify+  | WindowAttrib'FocusOnShow+  | WindowAttrib'Hovered+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData WindowAttrib++-- | The OpenGL robustness strategy.+data ContextRobustness =+    ContextRobustness'NoRobustness+  | ContextRobustness'NoResetNotification+  | ContextRobustness'LoseContextOnReset+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData ContextRobustness++-- | The OpenGL profile.+data OpenGLProfile =+    OpenGLProfile'Any+  | OpenGLProfile'Compat+  | OpenGLProfile'Core+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData OpenGLProfile++-- | The type of OpenGL to create a context for.+data ClientAPI =+    ClientAPI'NoAPI+  | ClientAPI'OpenGL+  | ClientAPI'OpenGLES+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData ClientAPI++-- | The type of API to use for context creation.+-- See the <http://www.glfw.org/docs/latest/window_guide.html Window Guide> for+-- more information.+--+-- This is a hard constraint. If no client API is requested, this hint is+-- ignored. Best practice is to stick to one API or the other, otherwise may+-- segfault on Linux. OS X does not support the EGL API and will fail if this+-- hint is used.+data ContextCreationAPI+  = ContextCreationAPI'Native+  | ContextCreationAPI'EGL+  | ContextCreationAPI'OSMesa+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData ContextCreationAPI++-- | The context release behavior.+-- See the <http://www.glfw.org/docs/latest/window_guide.html Window Guide> for+-- more information.+--+-- Context release behaviors are described in detail by the+-- <https://www.khronos.org/registry/OpenGL/extensions/KHR/KHR_context_flush_control.txt KHR_context_flush_control>+-- extension.+data ContextReleaseBehavior+  = ContextReleaseBehavior'Any+  | ContextReleaseBehavior'None+  | ContextReleaseBehavior'Flush+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData ContextReleaseBehavior++--------------------------------------------------------------------------------+-- Input handling++-- | Part of the <http://www.glfw.org/docs/3.3/input.html#input_keyboard Keyboard Input> system.+data Key =+    Key'Unknown+  | Key'Space+  | Key'Apostrophe+  | Key'Comma+  | Key'Minus+  | Key'Period+  | Key'Slash+  | Key'0+  | Key'1+  | Key'2+  | Key'3+  | Key'4+  | Key'5+  | Key'6+  | Key'7+  | Key'8+  | Key'9+  | Key'Semicolon+  | Key'Equal+  | Key'A+  | Key'B+  | Key'C+  | Key'D+  | Key'E+  | Key'F+  | Key'G+  | Key'H+  | Key'I+  | Key'J+  | Key'K+  | Key'L+  | Key'M+  | Key'N+  | Key'O+  | Key'P+  | Key'Q+  | Key'R+  | Key'S+  | Key'T+  | Key'U+  | Key'V+  | Key'W+  | Key'X+  | Key'Y+  | Key'Z+  | Key'LeftBracket+  | Key'Backslash+  | Key'RightBracket+  | Key'GraveAccent+  | Key'World1+  | Key'World2+  | Key'Escape+  | Key'Enter+  | Key'Tab+  | Key'Backspace+  | Key'Insert+  | Key'Delete+  | Key'Right+  | Key'Left+  | Key'Down+  | Key'Up+  | Key'PageUp+  | Key'PageDown+  | Key'Home+  | Key'End+  | Key'CapsLock+  | Key'ScrollLock+  | Key'NumLock+  | Key'PrintScreen+  | Key'Pause+  | Key'F1+  | Key'F2+  | Key'F3+  | Key'F4+  | Key'F5+  | Key'F6+  | Key'F7+  | Key'F8+  | Key'F9+  | Key'F10+  | Key'F11+  | Key'F12+  | Key'F13+  | Key'F14+  | Key'F15+  | Key'F16+  | Key'F17+  | Key'F18+  | Key'F19+  | Key'F20+  | Key'F21+  | Key'F22+  | Key'F23+  | Key'F24+  | Key'F25+  | Key'Pad0+  | Key'Pad1+  | Key'Pad2+  | Key'Pad3+  | Key'Pad4+  | Key'Pad5+  | Key'Pad6+  | Key'Pad7+  | Key'Pad8+  | Key'Pad9+  | Key'PadDecimal+  | Key'PadDivide+  | Key'PadMultiply+  | Key'PadSubtract+  | Key'PadAdd+  | Key'PadEnter+  | Key'PadEqual+  | Key'LeftShift+  | Key'LeftControl+  | Key'LeftAlt+  | Key'LeftSuper+  | Key'RightShift+  | Key'RightControl+  | Key'RightAlt+  | Key'RightSuper+  | Key'Menu+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData Key++-- | The state of an individual key when 'Graphics.UI.GLFW.getKey' is called.+data KeyState =+    KeyState'Pressed+  | KeyState'Released+  | KeyState'Repeating+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData KeyState++-- | For use with the <http://www.glfw.org/docs/3.3/input.html#joystick Joystick Input> system.+data Joystick =+    Joystick'1+  | Joystick'2+  | Joystick'3+  | Joystick'4+  | Joystick'5+  | Joystick'6+  | Joystick'7+  | Joystick'8+  | Joystick'9+  | Joystick'10+  | Joystick'11+  | Joystick'12+  | Joystick'13+  | Joystick'14+  | Joystick'15+  | Joystick'16+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData Joystick++-- | If a given joystick button is pressed or not when+-- 'Graphics.UI.GLFW.getJoystickButtons' is called.+data JoystickButtonState =+    JoystickButtonState'Pressed+  | JoystickButtonState'Released+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData JoystickButtonState++-- | Part of the t'Graphics.UI.GLFW.JoystickCallback', for when a monitor gets+-- connected or disconnected.+data JoystickState+  = JoystickState'Connected+  | JoystickState'Disconnected+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData JoystickState++-- | The valid hat states of a joystick. Part of the+-- <https://www.glfw.org/docs/3.3/input_guide.html#joystick_hat joystick hat>+-- system.+data JoystickHatState+  = JoystickHatState'Centered+  | JoystickHatState'Up+  | JoystickHatState'Right+  | JoystickHatState'Down+  | JoystickHatState'Left+  | JoystickHatState'RightUp+  | JoystickHatState'RightDown+  | JoystickHatState'LeftUp+  | JoystickHatState'LeftDown+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData JoystickHatState++-- | Part of the <http://www.Graphics.UI.GLFW.org/docs/3.3/input.html#input_mouse Mouse Input> system.+data MouseButton =+    MouseButton'1+  | MouseButton'2+  | MouseButton'3+  | MouseButton'4+  | MouseButton'5+  | MouseButton'6+  | MouseButton'7+  | MouseButton'8+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData MouseButton++-- | If the mouse button is pressed or not when 'Graphics.UI.GLFW.getMouseButton' is+-- called.+data MouseButtonState =+    MouseButtonState'Pressed+  | MouseButtonState'Released+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData MouseButtonState++-- | If the mouse's cursor is in the window or not.+data CursorState =+    CursorState'InWindow+  | CursorState'NotInWindow+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData CursorState++-- | Allows for special forms of mouse input.+-- See <http://www.glfw.org/docs/3.3/input.html#cursor_mode Cursor Modes>+data CursorInputMode =+    CursorInputMode'Normal+  | CursorInputMode'Hidden+  | CursorInputMode'Disabled+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData CursorInputMode++-- | When sticky keys is enabled, once a key is pressed it will remain pressed+-- at least until the state is polled with 'Graphics.UI.GLFW.getKey'. After+-- that, if the key has been released it will switch back to released. This+-- helps prevent problems with low-resolution polling missing key pressed. Note+-- that use of the callbacks to avoid this problem the the recommended route,+-- and this is just for a fallback.+data StickyKeysInputMode =+    StickyKeysInputMode'Enabled+  | StickyKeysInputMode'Disabled+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData StickyKeysInputMode++-- | This is the mouse version of "StickyKeysInputMode".+data StickyMouseButtonsInputMode =+    StickyMouseButtonsInputMode'Enabled+  | StickyMouseButtonsInputMode'Disabled+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData StickyMouseButtonsInputMode++-- | Modifier keys that were pressed as part of another keypress event.+data ModifierKeys = ModifierKeys+  { modifierKeysShift    :: !Bool+  , modifierKeysControl  :: !Bool+  , modifierKeysAlt      :: !Bool+  , modifierKeysSuper    :: !Bool+  , modifierKeysCapsLock :: !Bool+  , modifierKeysNumLock  :: !Bool+  } deriving (Data, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData ModifierKeys++-- | The different types of buttons we can find on a Gamepad.+data GamepadButton+  = GamepadButton'A+  | GamepadButton'B+  | GamepadButton'X+  | GamepadButton'Y+  | GamepadButton'LeftBumper+  | GamepadButton'RightBumper+  | GamepadButton'Back+  | GamepadButton'Start+  | GamepadButton'Guide+  | GamepadButton'LeftThumb+  | GamepadButton'RightThumb+  | GamepadButton'DpadUp+  | GamepadButton'DpadRight+  | GamepadButton'DpadDown+  | GamepadButton'DpadLeft+  | GamepadButton'Cross+  | GamepadButton'Circle+  | GamepadButton'Square+  | GamepadButton'Triangle+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData GamepadButton++-- | The states in which the gamepad buttons are found+data GamepadButtonState+  = GamepadButtonState'Pressed+  | GamepadButtonState'Released+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData GamepadButtonState++-- | The different axes along which we can measure continuous input on a Gamepad+data GamepadAxis+  = GamepadAxis'LeftX+  | GamepadAxis'LeftY+  | GamepadAxis'RightX+  | GamepadAxis'RightY+  | GamepadAxis'LeftTrigger+  | GamepadAxis'RightTrigger+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData GamepadAxis++-- | This describes the input state of a gamepad+data GamepadState = GamepadState+                    { getButtonState :: GamepadButton -> GamepadButtonState+                      -- ^ Returns the current state of the given button+                    , getAxisState :: GamepadAxis -> Float+                      -- ^ Returns a value in the range [-1.0, 1.0] for the+                      -- given game axis+                    } deriving (Typeable, Generic)++instance Eq GamepadState where+  a == b =+    let compareSt f x = (&& (f a x == f b x))+     in foldr (compareSt getButtonState) True [minBound..maxBound] &&+        foldr (compareSt getAxisState) True [minBound..maxBound]++instance NFData GamepadState++deriving instance Data CUChar++-- | GLFW image data, for setting up custom mouse cursor appearnaces.+data Image = Image+  { imageWidth  :: {-# UNPACK #-} !Int+  , imageHeight :: {-# UNPACK #-} !Int+  , imagePixels :: [CUChar]+  } deriving (Data, Eq, Ord, Read, Show, Typeable, Generic)++-- | Create an image given the function to generate 8-bit RGBA values based on+-- the pixel location.+mkImage :: Int -> Int -> (Int -> Int -> (Word8, Word8, Word8, Word8)) -> Image+mkImage width height gen = Image+  { imageWidth = width+  , imageHeight = height+  , imagePixels = [ CUChar channel | y <- [0..(height - 1)]+                                   , x <- [0..(width - 1)]+                                   , let (r, g, b, a) = gen x y+                                   , channel <- [r, g, b, a]+                  ]+  }++instance NFData Image++-- | Represents a GLFW cursor.+newtype Cursor = Cursor+  { unCursor :: Ptr C'GLFWcursor+  } deriving (Data, Eq, Ord, Show, Typeable, Generic)++-- | Lets you use one of the standard cursor appearnaces that the local+-- system theme provides for.+-- See <http://www.glfw.org/docs/3.3/input.html#cursor_standard Standard Cursor Creation>.+data StandardCursorShape =+    StandardCursorShape'Arrow+  | StandardCursorShape'IBeam+  | StandardCursorShape'Crosshair+  | StandardCursorShape'Hand+  | StandardCursorShape'HResize+  | StandardCursorShape'VResize+  deriving (Bounded, Data, Enum, Eq, Ord, Read, Show, Typeable, Generic)++instance NFData StandardCursorShape++--------------------------------------------------------------------------------++{-# ANN module "HLint: ignore Use camelCase" #-}
LICENSE view
@@ -1,4 +1,4 @@-Copyright Brian Lewis <brian@lorf.org> 2009+Copyright Brian Lewis <brian@lorf.org> 2009-2013  All rights reserved.
− Makefile 
@@ -1,39 +0,0 @@-GHC	  := ghc -ignore-dot-ghci-GCCFLAGS  := $(shell $(GHC) --info | $(GHC) -e "fmap read getContents >>= \-             putStrLn . unwords . read . Data.Maybe.fromJust . lookup     \-             \"Gcc Linker flags\"")-FRAMEWORK := -framework Cocoa -framework OpenGL-GLFW_FLAG := $(GCCFLAGS) -O2 -msse2 -fno-common -Iglfw/include -Iglfw/lib    \-             -Iglfw/lib/cocoa $(CFLAGS)-SRC_DIR   := glfw/lib/cocoa-GLFW_DIR  := glfw/lib-BUILD_DIR := build--OBJ_C_SRC := $(wildcard $(SRC_DIR)/*.m)-C_SRC     := $(wildcard $(SRC_DIR)/*.c)-GLFW_SRC  := $(wildcard $(GLFW_DIR)/*.c)-OBJS      := $(addprefix $(BUILD_DIR)/, $(OBJ_C_SRC:.m=.o) $(C_SRC:.c=.o))--all: $(BUILD_DIR)/libglfw.dylib--$(BUILD_DIR)/libglfw.dylib: $(OBJS)-	$(CC) -dynamiclib -Wl,-single_module -compatibility_version 1       \-        -current_version 1                                            \-        $(GLFW_FLAG) -o $@ $(OBJS) $(GLFW_SRC) $(FRAMEWORK)--.PHONY: $(BUILD_DIR)/$(SRC_DIR)/.build-tag--$(BUILD_DIR)/$(SRC_DIR)/.build-tag:-	mkdir -p $(BUILD_DIR)/$(SRC_DIR)-	touch $@--$(OBJS): $(BUILD_DIR)/$(SRC_DIR)/.build-tag--$(BUILD_DIR)/%.o : %.c-	$(CC) -c $(GLFW_FLAG) $< -o $@-$(BUILD_DIR)/%.o : %.m-	$(CC) -c $(GLFW_FLAG) $< -o $@--.PHONY: clean-clean:-	$(RM) -rf $(BUILD_DIR)
README.md view
@@ -1,26 +1,44 @@-Differences between GLFW and GLFW-b 2011.03-===========================================+GLFW-b+======+[![Hackage](https://img.shields.io/hackage/v/GLFW-b.svg)](http://hackage.haskell.org/package/GLFW-b) -* GLFW binds to version 2.6 of the GLFW C library. GLFW-b binds to 2.7.+## Description -* Some GLFW functions return OpenGL {Gettable,Settable}StateVars. I don't like-  this because it adds an extra step to extract a value and causes GLFW to be-  dependent on OpenGL. GLFW-b doesn't depend on OpenGL.+[Haskell][1] bindings to [GLFW][2], an Open Source, multi-platform library for+creating windows with OpenGL contexts and managing input and events. -* GLFW sometimes depends on GLFW C library internally defined values. GLFW-b-  doesn't. For example, GLFW-b doesn't assume that GL\_FALSE = 0. I don't think-  this makes a difference in practice, but it makes me feel better.+GLFW-b depends on [bindings-GLFW][3], which, as of the time of this writing,+binds to GLFW 3.3, [released 2019-04-15][4]. -* GLFW sometimes assumes that certain Haskell types are equivalent to certain C-  types, e.g. Int and int. GLFW-b doesn't. GLFW-b always uses the appropriate-  type from Foreign.C.Types. I don't think this makes a difference in practice,-  but it makes me feel better.+For a demonstration of GLFW-b, see [GLFW-b-demo][5]. -* GLFW contains workarounds for a bugs in GHC &lt; 6.10 FFI. GLFW-b doesn't.+When running GLFW-b in GHCI, don't forget to -* GLFW's API is pretty faithful to the C API. GLFW-b prefers to use full words-  and self-explanatory function names.+    :set -fno-ghci-sandbox -* In GLFW-b, registering hints and opening a window are combined into one step.+since GHCI can (and might) run each line of your code in a fresh unbounded+thread. -* GLFW has support for loading textures and rendering strings. GLFW-b doesn't.+## Contributing++This package uses git-flow as development model, in short that means that:++1. New features should be added to "develop" branch.+2. "master" branch is reserved for stable releases.+3. Patches for bugs related with previous releases should always be done in+    "hotfixes" branch.+4. All merge commits to master from "hotfixes" should be done+    using the "--no-ff" flag and from "develop" should avoid merging commits.++Until we have a defined road-map we are going to leave out "release+"branches" and "feature branches". For more information about this development+model please refer to [this site.][6]++Thanks you, and happy coding.++[1]: http://www.haskell.org/+[2]: http://www.glfw.org/+[3]: https://github.com/bsl/bindings-GLFW+[4]: http://www.glfw.org/Version-3.3-released.html+[5]: https://github.com/bsl/GLFW-b-demo+[6]: http://nvie.com/posts/a-successful-git-branching-model/
Setup.hs view
@@ -1,109 +1,6 @@ module Main (main) where -import Distribution.System ( buildOS, OS(..) )-import Distribution.Simple.InstallDirs ( libdir )-import Distribution.Simple.Setup ( ConfigFlags, fromFlag, configVerbosity-                                 , InstallFlags, defaultCopyFlags-                                 , installDistPref, CleanFlags-                                 , toFlag, CopyDest(NoCopyDest)-                                 , installVerbosity, cleanVerbosity-                                 , CopyFlags(..)-                                 , configProgramArgs )-import Distribution.Simple.Utils ( rawSystemExit, installOrdinaryFile )-import Distribution.Verbosity ( verbose, Verbosity )-import Distribution.Simple ( defaultMainWithHooks-                           , simpleUserHooks-                           , buildHook, Args, confHook-                           , UserHooks(preConf, preClean,-                                       postCopy, postInst) )-import Distribution.Simple.LocalBuildInfo ( absoluteInstallDirs-                                          , LocalBuildInfo(..) )-import Distribution.PackageDescription ( emptyBuildInfo-                                       , updatePackageDescription-                                       , HookedBuildInfo-                                       , BuildInfo(..)-                                       , PackageDescription )-import System.FilePath ( (</>) )--dynamicLibDir :: FilePath-dynamicLibDir = "build"+import Distribution.Simple (defaultMain)  main :: IO ()-main = defaultMainWithHooks simpleUserHooks-  { preConf   = \a f -> makeGlfw a f >> preConf simpleUserHooks a f-  , confHook  = \a cfs -> do-      let pkgForce = [("ghc-pkg",["--force"]) | buildOS == OSX ]-          cfs' = cfs { configProgramArgs = configProgramArgs cfs ++ pkgForce }-      confHook simpleUserHooks a cfs'-  , preClean  = \a f -> makeClean a f >> preClean simpleUserHooks a f-  , buildHook = \pkgDesc lbi h f ->-      buildHook simpleUserHooks (glfwPkgDesc pkgDesc) lbi h f-  , postCopy  = postCopyGlfw-  , postInst  = postInstGlfw-  }--makeGlfw :: Args -> ConfigFlags -> IO ()-makeGlfw _ flags = do-  let verbosity = fromFlag $ configVerbosity flags-  case buildOS of-    OSX -> do-      let make = rawSystemExit verbosity "env" $-           "make" : (if verbosity >= verbose then [] else ["--quiet"])-      make-    _ -> return ()--makeClean :: Args -> CleanFlags -> IO ()-makeClean _ flags = do-  let verbosity = fromFlag $ cleanVerbosity flags-  case buildOS of-    OSX -> do-      let make = rawSystemExit verbosity "env" $-           ["make"] ++ (if verbosity >= verbose then [] else ["--quiet"])-            ++ ["clean"]-      make-    _ -> return ()--glfwPkgDesc :: PackageDescription -> PackageDescription-glfwPkgDesc pkgDesc =-  case buildOS of-    OSX -> updatePackageDescription libDirGlfw pkgDesc-    _   -> pkgDesc--libDirGlfw :: HookedBuildInfo-libDirGlfw = (Just buildinfo, [])-  where buildinfo = emptyBuildInfo-                     { extraLibDirs = [ dynamicLibDir ] }--postInstGlfw :: Args -> InstallFlags -> PackageDescription-             -> LocalBuildInfo -> IO ()-postInstGlfw _ flags pkgDesc lbi =-  case buildOS of-    OSX -> do-      let copyflags = defaultCopyFlags-                    { copyDistPref  = installDistPref flags-                    , copyDest      = toFlag NoCopyDest-                    , copyVerbosity = installVerbosity flags-                    }-      postCopyGlfw undefined copyflags pkgDesc lbi-    _ -> return ()--postCopyGlfw :: Args -> CopyFlags -> PackageDescription-             -> LocalBuildInfo -> IO ()-postCopyGlfw _ flags pkgDesc lbi =-  case buildOS of-    OSX -> do-      let installDirs = absoluteInstallDirs pkgDesc lbi-            . fromFlag . copyDest $ flags-          libPref = libdir installDirs-          verbosity = fromFlag $ copyVerbosity flags-          copyDynamic dest f = installOrdinaryFile verbosity (dynamicLibDir</>f) (dest</>f)-      maybe (return ()) (copyDynamic libPref) (Just dynamicLibName)-      install_name_tool verbosity (libPref</>dynamicLibName)-    _ -> return ()--install_name_tool :: Verbosity -> FilePath -> IO ()-install_name_tool v fp = rawSystemExit v "env" $-  ["install_name_tool"] ++ ["-id"] ++ [fp] ++ [fp]--dynamicLibName :: FilePath-dynamicLibName = "libglfw.dylib"+main = defaultMain
+ TODO view
@@ -0,0 +1,16 @@+Improve everything about testing.+Improve existing tests.+Add more tests.++Coordinate with GLFW C-library maintainer about any strange behavior.+1.) Cursor is in window. Left click.+    Events seen:+      cursor enter: CursorState'NotInWindow+      cursor enter: CursorState'InWindow+      mouse button: MouseButton'1 MouseButtonState'Pressed [mod keys: none]+      mouse button: MouseButton'1 MouseButtonState'Released [mod keys: none]+    The CursorState events seem spurious -- the cursor did not leave the+    window.++getPressedKeys?+getJoystickAxesN?
+ Test.hs view
@@ -0,0 +1,683 @@+-- base+import Control.Concurrent (threadDelay)+import Control.Monad      (forM_)+import Data.Char          (isAscii)+import Data.Bits          (xor)+import Data.List          (intercalate, isPrefixOf)+import Data.Maybe         (isNothing)++-- HUnit+import Test.HUnit ((@?=), assertBool, assertFailure)++-- test-framework+import Test.Framework (Test, defaultMain, testGroup)++-- test-framework-hunit+import Test.Framework.Providers.HUnit (testCase)++-- GLFW-b+import qualified Graphics.UI.GLFW as GLFW++--------------------------------------------------------------------------------++main :: IO ()+main = do+    GLFW.setErrorCallback $ Just $ \e s ->+        putStrLn $ unwords ["###", show e, show s]++    GLFW.initHint GLFW.InitHint'CocoaChdirResources False+    True <- GLFW.init++    Just mon <- GLFW.getPrimaryMonitor++    GLFW.windowHint $ GLFW.WindowHint'Visible False+    GLFW.windowHint $ GLFW.WindowHint'CocoaFrameName "GLFW-b test"+    mwin@(Just win) <- GLFW.createWindow 100 100 "GLFW-b test" Nothing Nothing+    GLFW.makeContextCurrent mwin++    -- Mostly check for compiling+    GLFW.setJoystickCallback $ Just $ \j c -> putStrLn $ concat+      [ show j, " changed state: ", show c ]++    defaultMain $ tests mon win++    -- TODO because of how defaultMain works, this code is not reached+    GLFW.destroyWindow win+    GLFW.terminate++--------------------------------------------------------------------------------++versionMajor, versionMinor, versionRevision :: Int+versionMajor = 3+versionMinor = 3+versionRevision = 9++giveItTime :: IO ()+giveItTime = threadDelay 500000++joysticks :: [GLFW.Joystick]+joysticks =+    [ GLFW.Joystick'1+    , GLFW.Joystick'2+    , GLFW.Joystick'3+    , GLFW.Joystick'4+    , GLFW.Joystick'5+    , GLFW.Joystick'6+    , GLFW.Joystick'7+    , GLFW.Joystick'8+    , GLFW.Joystick'9+    , GLFW.Joystick'10+    , GLFW.Joystick'11+    , GLFW.Joystick'12+    , GLFW.Joystick'13+    , GLFW.Joystick'14+    , GLFW.Joystick'15+    , GLFW.Joystick'16+    ]++between :: Ord a => a -> (a,a) -> Bool+between n (l,h) = n >= l && n <= h++videoModeLooksValid :: GLFW.VideoMode -> Bool+videoModeLooksValid vm = and+    [ GLFW.videoModeWidth       vm `between` (0,4000)+    , GLFW.videoModeHeight      vm `between` (0,3000)+    , GLFW.videoModeRedBits     vm `between` (0,  32)+    , GLFW.videoModeGreenBits   vm `between` (0,  32)+    , GLFW.videoModeBlueBits    vm `between` (0,  32)+    , GLFW.videoModeRefreshRate vm `between` (0, 120)+    ]++--------------------------------------------------------------------------------++glfwTest :: String -> IO () -> Test+glfwTest name test = testCase name $ do+  GLFW.clearError+  test+  err <- GLFW.getError+  case err of+    Nothing -> return ()+    Just e -> assertFailure $+              concat ["Test '", name, "' generated error: ", show e]++tests :: GLFW.Monitor -> GLFW.Window -> [Test]+tests mon win =+    [ testGroup "Initialization and version information"+      [ testCase "getVersion"       test_getVersion+      , testCase "getVersionString" test_getVersionString+      , testCase "getError"         test_getError+      ]+    , testGroup "Monitor handling"+      [ glfwTest "getMonitors"              test_getMonitors+      , glfwTest "getPrimaryMonitor"        test_getPrimaryMonitor+      , glfwTest "getMonitorPos"          $ test_getMonitorPos mon+      , glfwTest "getMonitorPhysicalSize" $ test_getMonitorPhysicalSize mon+      , glfwTest "getMonitorWorkarea"     $ test_getMonitorWorkarea mon+      , glfwTest "getMonitorName"         $ test_getMonitorName mon+      , glfwTest "getVideoModes"          $ test_getVideoModes mon+      , glfwTest "getVideoMode"           $ test_getVideoMode mon+      , glfwTest "getGamma"               $ test_getGammaRamp mon+      ]+    , testGroup "Window handling"+      [ glfwTest "defaultWindowHints"             test_defaultWindowHints++      -- Test window attributes+      , glfwTest "getWindowFocused"             $ test_getWindowFocused win+      , glfwTest "getWindowResizable"           $ test_getWindowResizable win+      , glfwTest "getWindowDecorated"           $ test_getWindowDecorated win+      , glfwTest "getWindowClientAPI"           $ test_getWindowClientAPI win+      , glfwTest "window context version"       $ test_window_context_version win+      , glfwTest "getWindowContextRobustness"   $ test_getWindowContextRobustness win+      , glfwTest "getWindowOpenGLForwardCompat" $ test_getWindowOpenGLForwardCompat win+      , glfwTest "getWindowOpenGLDebugContext"  $ test_getWindowOpenGLDebugContext win+      , glfwTest "getWindowOpenGLProfile"       $ test_getWindowOpenGLProfile win+      , glfwTest "window attribs"               $ test_windowAttribs win+      , glfwTest "window close flag"            $ test_window_close_flag win+      , glfwTest "setWindowOpacity"             $ test_window_opacity win+      , glfwTest "setWindowTitle"               $ test_setWindowTitle win+      , glfwTest "window pos"                   $ test_window_pos win+      , glfwTest "window size"                  $ test_window_size win+      , glfwTest "getWindowFrameSize"           $ test_getWindowFrameSize win+      , glfwTest "getFramebufferSize"           $ test_getFramebufferSize win+      , glfwTest "iconification"                $ test_iconification win+      -- , glfwTest "show/hide"                    $ test_show_hide win+      , glfwTest "getWindowMonitor"             $ test_getWindowMonitor win mon+      , glfwTest "setWindowed"                  $ test_setWindowed win+      , glfwTest "setWindowIcon"                $ test_setWindowIcon win+      , glfwTest "maximizeWindow"               $ test_maximizeWindow win+      , glfwTest "setWindowSizeLimits"          $ test_setWindowSizeLimits win+      , glfwTest "setWindowAspectRatio"         $ test_setWindowAspectRatio win+      , glfwTest "focusWindow"                  $ test_focusWindow win+      , glfwTest "cursor pos"                   $ test_cursor_pos win+      , glfwTest "pollEvents"                     test_pollEvents+      , glfwTest "waitEvents"                     test_waitEvents+      , glfwTest "waitEventsTimeout"              test_waitEventsTimeout+      ]+    , testGroup "Input handling"+      [ glfwTest "cursor input mode"               $ test_cursor_input_mode win+      , glfwTest "sticky keys input mode"          $ test_sticky_keys_input_mode win+      , glfwTest "sticky mouse buttons input mode" $ test_sticky_mouse_buttons_input_mode win+      , glfwTest "joystickPresent"                   test_joystickPresent+      , glfwTest "getJoystickAxes"                   test_getJoystickAxes+      , glfwTest "getJoystickButtons"                test_getJoystickButtons+      , glfwTest "getJoystickName"                   test_getJoystickName+      , glfwTest "getKeyName"                        test_getKeyName+      , glfwTest "getGamepadState"                   test_getGamepadState+      ]+    , testGroup "Time"+      [ glfwTest "getTime"              test_getTime+      , glfwTest "setTime"              test_setTime+      , glfwTest "getTimerValue"        test_getTimerValue+      , glfwTest "getTimerFrequency"    test_getTimerFrequency+      ]+    , testGroup "Context"+      [ glfwTest "getCurrentContext"  $ test_getCurrentContext win+      , glfwTest "swapBuffers"        $ test_swapBuffers win+      , glfwTest "swapInterval"         test_swapInterval+      , glfwTest "extensionSupported"   test_extensionSupported+      ]+    , testGroup "Clipboard"+      [ glfwTest "clipboard" $ test_clipboard win+      ]+    ]++--------------------------------------------------------------------------------++test_getVersion :: IO ()+test_getVersion = do+    v <- GLFW.getVersion+    GLFW.versionMajor v @?= versionMajor+    GLFW.versionMinor v @?= versionMinor+    GLFW.versionRevision v @?= versionRevision++test_getVersionString :: IO ()+test_getVersionString = do+    mvs <- GLFW.getVersionString+    case mvs of+      Just vs -> assertBool "" $ v `isPrefixOf` vs+      Nothing -> assertFailure ""+  where+    v = intercalate "." $ map show [versionMajor, versionMinor]++test_getError :: IO ()+test_getError = GLFW.getError >>= assertBool "Got GLFW error!" . isNothing++test_getMonitors :: IO ()+test_getMonitors = do+    r <- GLFW.getMonitors+    case r of+      Just ms -> assertBool "" $ (not . null) ms+      Nothing -> assertFailure ""++test_getPrimaryMonitor :: IO ()+test_getPrimaryMonitor = do+    r <- GLFW.getPrimaryMonitor+    case r of+      Just _  -> return ()+      Nothing -> assertFailure ""++test_getMonitorPos :: GLFW.Monitor -> IO ()+test_getMonitorPos mon = do+    (x, y) <- GLFW.getMonitorPos mon+    assertBool "" $ x >= 0+    assertBool "" $ y >= 0++test_getMonitorPhysicalSize :: GLFW.Monitor -> IO ()+test_getMonitorPhysicalSize mon = do+    (w, h) <- GLFW.getMonitorPhysicalSize mon+    assertBool "" $ w `between` (0, 1000)+    assertBool "" $ h `between` (0,  500)++test_getMonitorWorkarea :: GLFW.Monitor -> IO ()+test_getMonitorWorkarea mon = do+    (x, y, w, h) <- GLFW.getMonitorWorkarea mon+    assertBool "workarea x nonnegative" $ x >= 0+    assertBool "workarea y nonnegative" $ y >= 0+    assertBool "workarea width positive" $ w > 0+    assertBool "workarea height positive" $ h > 0++test_getMonitorName :: GLFW.Monitor -> IO ()+test_getMonitorName mon = do+    mname <- GLFW.getMonitorName mon+    case mname of+      Nothing   -> assertFailure ""+      Just name -> assertBool "" $ all isAscii name++test_getVideoModes :: GLFW.Monitor -> IO ()+test_getVideoModes mon = do+    mvms <- GLFW.getVideoModes mon+    case mvms of+      Nothing  -> assertFailure ""+      Just vms -> assertBool "" $ all videoModeLooksValid vms++test_getVideoMode :: GLFW.Monitor -> IO ()+test_getVideoMode mon = do+    mvm <- GLFW.getVideoMode mon+    case mvm of+      Just vm -> assertBool "" $ videoModeLooksValid vm+      Nothing -> assertFailure ""++test_getGammaRamp :: GLFW.Monitor -> IO ()+test_getGammaRamp mon = do+    mgr <- GLFW.getGammaRamp mon+    case mgr of+      Nothing -> assertFailure ""+      Just gr -> assertBool "" $+        let rsl = length $ GLFW.gammaRampRed   gr+            gsl = length $ GLFW.gammaRampGreen gr+            bsl = length $ GLFW.gammaRampBlue  gr+        in rsl > 0 && rsl == gsl && gsl == bsl++--------------------------------------------------------------------------------++test_defaultWindowHints :: IO ()+test_defaultWindowHints =+    GLFW.defaultWindowHints++test_windowAttribs :: GLFW.Window -> IO ()+test_windowAttribs win = do+    oldRsz <- GLFW.getWindowAttrib win GLFW.WindowAttrib'Resizable++    GLFW.setWindowAttrib win GLFW.WindowAttrib'Resizable False+    GLFW.getWindowAttrib win GLFW.WindowAttrib'Resizable >>= (@?= False)++    GLFW.setWindowAttrib win GLFW.WindowAttrib'Resizable True+    rsz <- GLFW.getWindowAttrib win GLFW.WindowAttrib'Resizable+    rsz @?= True++    GLFW.setWindowAttrib win GLFW.WindowAttrib'Resizable oldRsz++test_window_close_flag :: GLFW.Window -> IO ()+test_window_close_flag win = do+    r0 <- GLFW.windowShouldClose win+    r0 @?= False++    GLFW.setWindowShouldClose win True+    r1 <- GLFW.windowShouldClose win+    r1 @?= True++    GLFW.setWindowShouldClose win False+    r2 <- GLFW.windowShouldClose win+    r2 @?= False++test_window_opacity :: GLFW.Window -> IO ()+test_window_opacity win = do+    oldOpacity <- GLFW.getWindowOpacity win++    GLFW.setWindowOpacity win 0.27+    opacity <- GLFW.getWindowOpacity win+    assertBool "Opacity is close to what we set it to." $+      (abs (opacity - 0.27)) < 0.01++    GLFW.setWindowOpacity win oldOpacity++test_setWindowTitle :: GLFW.Window -> IO ()+test_setWindowTitle win =+    GLFW.setWindowTitle win "some new title"++-- This is a little strange. Depending on your window manager, etc, after+-- setting the window position to (x,y), the actual new window position might+-- be (x+5,y+5) due to borders. So we just check for consistency.+test_window_pos :: GLFW.Window -> IO ()+test_window_pos win = do+    let x = 17+        y = 37+        xoff = 53+        yoff = 149+    (x0, y0, dx0, dy0) <- setGet  x        y+    (x1, y1, dx1, dy1) <- setGet (x+xoff) (y+yoff)+    dx0 @?= dx1+    dy0 @?= dy1+    x1 - x0 @?= xoff+    y1 - y0 @?= yoff+  where+    setGet x0 y0 = do+        GLFW.setWindowPos win x0 y0+        giveItTime+        (x1, y1) <- GLFW.getWindowPos win+        let (dx, dy) = (x0-x1, y0-y1)+        return (x1, y1, dx, dy)++test_window_size :: GLFW.Window -> IO ()+test_window_size win = do+    let w = 170+        h = 370+    GLFW.setWindowSize win w h+    giveItTime+    (w', h') <- GLFW.getWindowSize win+    w' @?= w+    h' @?= h++test_getWindowFrameSize :: GLFW.Window -> IO ()+test_getWindowFrameSize win = do+    -- The frame size is pretty dependent on the window manager. We can only+    -- really expect that the window has a title bar, so the top frame won't be+    -- zero...+    (_, t, _, _) <- GLFW.getWindowFrameSize win+    assertBool "Window has no frame width up top!" $ t > 0++test_getFramebufferSize :: GLFW.Window -> IO ()+test_getFramebufferSize win = do+    (w, h) <- GLFW.getWindowSize win+    (fw, fh) <- GLFW.getFramebufferSize win+    -- Window size and framebuffer size are not always equal, an example are+    -- retina screens. But maybe it's safe to assume they'll always be scaled+    -- equally in both dimensions?+    let ww = ( fromIntegral fw / fromIntegral w ) :: Double+        hh = ( fromIntegral fh / fromIntegral h ) :: Double+    ww @?= hh+    assertBool "" $ fw /= 0+    assertBool "" $ fh /= 0++test_iconification :: GLFW.Window -> IO ()+test_iconification win = do+    GLFW.showWindow win+    is0 <- GLFW.getWindowIconified win+    is0 @?= False++    GLFW.iconifyWindow win+    giveItTime+    is1 <- GLFW.getWindowIconified win+    is1 @?= True++    GLFW.restoreWindow win+    GLFW.hideWindow win++-- test_show_hide :: GLFW.Window -> IO ()+-- test_show_hide win = do+--     v0 <- GLFW.getWindowVisible win+--     v0 @?= True++--     GLFW.hideWindow win+--     giveItTime+--     v1 <- GLFW.getWindowVisible win+--     v1 @?= False++--     GLFW.showWindow win+--     giveItTime+--     v2 <- GLFW.getWindowVisible win+--     v2 @?= True++test_getWindowMonitor :: GLFW.Window -> GLFW.Monitor -> IO ()+test_getWindowMonitor win _ = do+    m <- GLFW.getWindowMonitor win+    m @?= Nothing++test_setWindowed :: GLFW.Window -> IO ()+test_setWindowed win = GLFW.setWindowed win 100 100 0 0++test_setWindowIcon :: GLFW.Window -> IO ()+test_setWindowIcon win = let+  icon1 = GLFW.mkImage 32 32 $ \x y ->+    case even ((x `div` 8) `xor` (y `div` 8)) of+      True -> (255, 0, 0, 255)+      False -> (0, 255, 0, 255)++  icon2 = GLFW.mkImage 16 16 $ \x y ->+    case even ((x `div` 8) `xor` (y `div` 8)) of+      True -> (255, 255, 255, 255)+      False -> (0, 0, 0, 255)++  in GLFW.setWindowIcon win [icon1, icon2]++test_maximizeWindow :: GLFW.Window -> IO ()+test_maximizeWindow win = do+  GLFW.showWindow win+  startsMaximized <- GLFW.getWindowMaximized win+  startsMaximized @?= False++  GLFW.maximizeWindow win+  giveItTime++  isMaximized <- GLFW.getWindowMaximized win+  isMaximized @?= True+  GLFW.hideWindow win++test_setWindowSizeLimits :: GLFW.Window -> IO ()+test_setWindowSizeLimits win = do+    GLFW.setWindowSizeLimits win (Just 640) (Just 480) (Just 1024) (Just 768)++test_setWindowAspectRatio :: GLFW.Window -> IO ()+test_setWindowAspectRatio win = do+    GLFW.setWindowAspectRatio win Nothing++test_focusWindow :: GLFW.Window -> IO ()+test_focusWindow = GLFW.focusWindow++test_cursor_pos :: GLFW.Window -> IO ()+test_cursor_pos win = do+  GLFW.showWindow win+  (w, h) <- GLFW.getWindowSize win++  -- Make sure we use integral coordinates here so that we don't run into+  -- platform-dependent differences.+  let cx :: Double+      cy :: Double+      (cx, cy) = (fromIntegral $ w `div` 2, fromIntegral $ h `div` 2)++  -- !HACK! Poll events seems to be necessary on OS X,+  -- before /and/ after glfwSetCursorPos, otherwise, the+  -- windowing system likely never receives the cursor update. This is+  -- reflected in the C version of GLFW as well, we just call it here in+  -- order to have a more robust test.++  GLFW.pollEvents+  GLFW.setCursorPos win cx cy+  GLFW.pollEvents -- !HACK! see comment above++  (cx', cy') <- GLFW.getCursorPos win+  cx' @?= cx+  cy' @?= cy+  GLFW.hideWindow win++test_getWindowFocused :: GLFW.Window -> IO ()+test_getWindowFocused win = do+    fs <- GLFW.getWindowFocused win+    fs @?= False++test_getWindowResizable :: GLFW.Window -> IO ()+test_getWindowResizable win = do+    b <- GLFW.getWindowResizable win+    b @?= True++test_getWindowDecorated :: GLFW.Window -> IO ()+test_getWindowDecorated win = do+    b <- GLFW.getWindowDecorated win+    b @?= True++test_getWindowClientAPI :: GLFW.Window -> IO ()+test_getWindowClientAPI win = do+    a <- GLFW.getWindowClientAPI win+    a @?= GLFW.ClientAPI'OpenGL++test_window_context_version :: GLFW.Window -> IO ()+test_window_context_version win = do+    v0 <- GLFW.getWindowContextVersionMajor    win+    v1 <- GLFW.getWindowContextVersionMinor    win+    assertBool "" $ all (`between` (0, 20)) [v0, v1]++test_getWindowContextRobustness :: GLFW.Window -> IO ()+test_getWindowContextRobustness win = do+    _ <- GLFW.getWindowContextRobustness win+    return ()++test_getWindowOpenGLForwardCompat :: GLFW.Window -> IO ()+test_getWindowOpenGLForwardCompat win = do+    _ <- GLFW.getWindowOpenGLForwardCompat win+    return ()++test_getWindowOpenGLDebugContext :: GLFW.Window -> IO ()+test_getWindowOpenGLDebugContext win = do+    _ <- GLFW.getWindowOpenGLDebugContext win+    return ()++test_getWindowOpenGLProfile :: GLFW.Window -> IO ()+test_getWindowOpenGLProfile win = do+    _ <- GLFW.getWindowOpenGLProfile win+    return ()++test_pollEvents :: IO ()+test_pollEvents =+    GLFW.pollEvents++test_waitEvents :: IO ()+test_waitEvents = GLFW.postEmptyEvent >> GLFW.waitEvents++test_waitEventsTimeout :: IO ()+test_waitEventsTimeout =+    -- to not slow down the test too much we set the timeout to 0.001 second :+    GLFW.waitEventsTimeout 0.001++--------------------------------------------------------------------------------++test_cursor_input_mode :: GLFW.Window -> IO ()+test_cursor_input_mode win = do+    modes' <- mapM setGet modes+    modes' @?= modes+  where+    modes =+      [ GLFW.CursorInputMode'Disabled+      , GLFW.CursorInputMode'Hidden+      , GLFW.CursorInputMode'Normal+      ]+    setGet m = do+        GLFW.setCursorInputMode win m+        GLFW.getCursorInputMode win++test_sticky_keys_input_mode :: GLFW.Window -> IO ()+test_sticky_keys_input_mode win = do+    modes' <- mapM setGet modes+    modes' @?= modes+  where+    modes =+      [ GLFW.StickyKeysInputMode'Enabled+      , GLFW.StickyKeysInputMode'Disabled+      ]+    setGet m = do+        GLFW.setStickyKeysInputMode win m+        GLFW.getStickyKeysInputMode win++test_sticky_mouse_buttons_input_mode :: GLFW.Window -> IO ()+test_sticky_mouse_buttons_input_mode win = do+    modes' <- mapM setGet modes+    modes' @?= modes+  where+    modes =+      [ GLFW.StickyMouseButtonsInputMode'Enabled+      , GLFW.StickyMouseButtonsInputMode'Disabled+      ]+    setGet m = do+        GLFW.setStickyMouseButtonsInputMode win m+        GLFW.getStickyMouseButtonsInputMode win++test_joystickPresent :: IO ()+test_joystickPresent = do+    _ <- GLFW.joystickPresent GLFW.Joystick'1+    r <- GLFW.joystickPresent GLFW.Joystick'16+    assertBool "" $ not r++test_getJoystickAxes :: IO ()+test_getJoystickAxes =+    mapM_ GLFW.getJoystickAxes joysticks++test_getJoystickButtons :: IO ()+test_getJoystickButtons =+    mapM_ GLFW.getJoystickButtons joysticks++test_getJoystickName :: IO ()+test_getJoystickName =+    mapM_ GLFW.getJoystickName joysticks++test_getKeyName :: IO ()+test_getKeyName =+  forM_ (zip [GLFW.Key'Slash, GLFW.Key'Period] ["/", "."]) $ \(k, n) -> do+    name <- GLFW.getKeyName k 0+    case name of+      Nothing -> return ()+      Just s -> s @?= n++test_getGamepadState :: IO ()+test_getGamepadState =+  forM_ joysticks $ \js -> do+    mst <- GLFW.getGamepadState js+    case mst of+      (Just st) -> do+        GLFW.joystickIsGamepad js >>= assertBool "Is gamepad"+        GLFW.getGamepadName js >>= assertBool "Gamepad has name" . not . null+        forM_ [minBound..maxBound] $ assertBool "Button not pressed"+                                   . (== GLFW.GamepadButtonState'Released)+                                   . GLFW.getButtonState st+      _ -> return ()++--------------------------------------------------------------------------------++test_getTime :: IO ()+test_getTime = do+    mt <- GLFW.getTime+    case mt of+      Nothing -> assertFailure ""+      Just t  -> assertBool "" $ t `between` (0, 10)++test_setTime :: IO ()+test_setTime = do+    let t = 37+    GLFW.setTime t+    mt <- GLFW.getTime+    case mt of+      Just t' -> assertBool "" $ t' `between` (t, t+10)+      Nothing -> assertFailure ""++test_getTimerValue :: IO ()+test_getTimerValue = GLFW.getTimerValue >>= assertBool "" . (> 0)++test_getTimerFrequency :: IO ()+test_getTimerFrequency = GLFW.getTimerFrequency >>= assertBool "" . (> 0)++--------------------------------------------------------------------------------++test_getCurrentContext :: GLFW.Window -> IO ()+test_getCurrentContext win = do+    mwin <- GLFW.getCurrentContext+    case mwin of+      Nothing   -> assertFailure ""+      Just win' -> win' @?= win++test_swapBuffers :: GLFW.Window -> IO ()+test_swapBuffers =+    GLFW.swapBuffers++test_swapInterval :: IO ()+test_swapInterval =+    GLFW.swapInterval 1++test_extensionSupported :: IO ()+test_extensionSupported = do+    b0 <- GLFW.extensionSupported "GL_ARB_multisample"+    b0 @?= True+    b1 <- GLFW.extensionSupported "bogus"+    b1 @?= False++--------------------------------------------------------------------------------++test_clipboard :: GLFW.Window -> IO ()+test_clipboard win = do+    rs <- mapM setGet ss+    rs @?= map Just ss+  where+    ss =+      [ "abc 123 ???"+      , "xyz 456 !!!"+      ]+    setGet s = do+        GLFW.setClipboardString win s+        giveItTime+        result <- GLFW.getClipboardString win++        err <- GLFW.getError+        return $ case err of+          Just (GLFW.Error'FormatUnavailable, _) -> Just s+          _ -> result++--------------------------------------------------------------------------------++{-# ANN module "HLint: ignore Use camelCase" #-}
− build/glfw/lib/cocoa/.build-tag 
− glfw/include/GL/glfw.h 
@@ -1,509 +0,0 @@-/************************************************************************- * GLFW - An OpenGL framework- * API version: 2.7- * WWW:         http://www.glfw.org/- *------------------------------------------------------------------------- * Copyright (c) 2002-2006 Marcus Geelnard- * Copyright (c) 2006-2010 Camilla Berglund- *- * This software is provided 'as-is', without any express or implied- * warranty. In no event will the authors be held liable for any damages- * arising from the use of this software.- *- * Permission is granted to anyone to use this software for any purpose,- * including commercial applications, and to alter it and redistribute it- * freely, subject to the following restrictions:- *- * 1. The origin of this software must not be misrepresented; you must not- *    claim that you wrote the original software. If you use this software- *    in a product, an acknowledgment in the product documentation would- *    be appreciated but is not required.- *- * 2. Altered source versions must be plainly marked as such, and must not- *    be misrepresented as being the original software.- *- * 3. This notice may not be removed or altered from any source- *    distribution.- *- *************************************************************************/--#ifndef __glfw_h_-#define __glfw_h_--#ifdef __cplusplus-extern "C" {-#endif---/*************************************************************************- * Global definitions- *************************************************************************/--/* We need a NULL pointer from time to time */-#ifndef NULL- #ifdef __cplusplus-  #define NULL 0- #else-  #define NULL ((void *)0)- #endif-#endif /* NULL */---/* ------------------- BEGIN SYSTEM/COMPILER SPECIFIC -------------------- */--/* Please report any probles that you find with your compiler, which may- * be solved in this section! There are several compilers that I have not- * been able to test this file with yet.- *- * First: If we are we on Windows, we want a single define for it (_WIN32)- * (Note: For Cygwin the compiler flag -mwin32 should be used, but to- * make sure that things run smoothly for Cygwin users, we add __CYGWIN__- * to the list of "valid Win32 identifiers", which removes the need for- * -mwin32)- */-#if !defined(_WIN32) && (defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__))- #define _WIN32-#endif /* _WIN32 */--/* In order for extension support to be portable, we need to define an- * OpenGL function call method. We use the keyword APIENTRY, which is- * defined for Win32. (Note: Windows also needs this for <GL/gl.h>)- */-#ifndef APIENTRY- #ifdef _WIN32-  #define APIENTRY __stdcall- #else-  #define APIENTRY- #endif- #define GL_APIENTRY_DEFINED-#endif /* APIENTRY */---/* The following three defines are here solely to make some Windows-based- * <GL/gl.h> files happy. Theoretically we could include <windows.h>, but- * it has the major drawback of severely polluting our namespace.- */--/* Under Windows, we need WINGDIAPI defined */-#if !defined(WINGDIAPI) && defined(_WIN32)- #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__POCC__)-  /* Microsoft Visual C++, Borland C++ Builder and Pelles C */-  #define WINGDIAPI __declspec(dllimport)- #elif defined(__LCC__)-  /* LCC-Win32 */-  #define WINGDIAPI __stdcall- #else-  /* Others (e.g. MinGW, Cygwin) */-  #define WINGDIAPI extern- #endif- #define GL_WINGDIAPI_DEFINED-#endif /* WINGDIAPI */--/* Some <GL/glu.h> files also need CALLBACK defined */-#if !defined(CALLBACK) && defined(_WIN32)- #if defined(_MSC_VER)-  /* Microsoft Visual C++ */-  #if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS)-   #define CALLBACK __stdcall-  #else-   #define CALLBACK-  #endif- #else-  /* Other Windows compilers */-  #define CALLBACK __stdcall- #endif- #define GLU_CALLBACK_DEFINED-#endif /* CALLBACK */--/* Microsoft Visual C++, Borland C++ and Pelles C <GL*glu.h> needs wchar_t */-#if defined(_WIN32) && (defined(_MSC_VER) || defined(__BORLANDC__) || defined(__POCC__)) && !defined(_WCHAR_T_DEFINED)- typedef unsigned short wchar_t;- #define _WCHAR_T_DEFINED-#endif /* _WCHAR_T_DEFINED */---/* ---------------- GLFW related system specific defines ----------------- */--#if defined(_WIN32) && defined(GLFW_BUILD_DLL)-- /* We are building a Win32 DLL */- #define GLFWAPI      __declspec(dllexport)- #define GLFWAPIENTRY __stdcall- #define GLFWCALL     __stdcall--#elif defined(_WIN32) && defined(GLFW_DLL)-- /* We are calling a Win32 DLL */- #if defined(__LCC__)-  #define GLFWAPI      extern- #else-  #define GLFWAPI      __declspec(dllimport)- #endif- #define GLFWAPIENTRY __stdcall- #define GLFWCALL     __stdcall--#else-- /* We are either building/calling a static lib or we are non-win32 */- #define GLFWAPIENTRY- #define GLFWAPI- #define GLFWCALL--#endif--/* -------------------- END SYSTEM/COMPILER SPECIFIC --------------------- */--/* Include standard OpenGL headers: GLFW uses GL_FALSE/GL_TRUE, and it is- * convenient for the user to only have to include <GL/glfw.h>. This also- * solves the problem with Windows <GL/gl.h> and <GL/glu.h> needing some- * special defines which normally requires the user to include <windows.h>- * (which is not a nice solution for portable programs).- */-#if defined(__APPLE_CC__)- #include <OpenGL/gl.h>- #ifndef GLFW_NO_GLU-  #include <OpenGL/glu.h>- #endif-#else- #include <GL/gl.h>- #ifndef GLFW_NO_GLU-  #include <GL/glu.h>- #endif-#endif---/*************************************************************************- * GLFW version- *************************************************************************/--#define GLFW_VERSION_MAJOR    2-#define GLFW_VERSION_MINOR    7-#define GLFW_VERSION_REVISION 2---/*************************************************************************- * Input handling definitions- *************************************************************************/--/* Key and button state/action definitions */-#define GLFW_RELEASE            0-#define GLFW_PRESS              1--/* Keyboard key definitions: 8-bit ISO-8859-1 (Latin 1) encoding is used- * for printable keys (such as A-Z, 0-9 etc), and values above 256- * represent special (non-printable) keys (e.g. F1, Page Up etc).- */-#define GLFW_KEY_UNKNOWN      -1-#define GLFW_KEY_SPACE        32-#define GLFW_KEY_SPECIAL      256-#define GLFW_KEY_ESC          (GLFW_KEY_SPECIAL+1)-#define GLFW_KEY_F1           (GLFW_KEY_SPECIAL+2)-#define GLFW_KEY_F2           (GLFW_KEY_SPECIAL+3)-#define GLFW_KEY_F3           (GLFW_KEY_SPECIAL+4)-#define GLFW_KEY_F4           (GLFW_KEY_SPECIAL+5)-#define GLFW_KEY_F5           (GLFW_KEY_SPECIAL+6)-#define GLFW_KEY_F6           (GLFW_KEY_SPECIAL+7)-#define GLFW_KEY_F7           (GLFW_KEY_SPECIAL+8)-#define GLFW_KEY_F8           (GLFW_KEY_SPECIAL+9)-#define GLFW_KEY_F9           (GLFW_KEY_SPECIAL+10)-#define GLFW_KEY_F10          (GLFW_KEY_SPECIAL+11)-#define GLFW_KEY_F11          (GLFW_KEY_SPECIAL+12)-#define GLFW_KEY_F12          (GLFW_KEY_SPECIAL+13)-#define GLFW_KEY_F13          (GLFW_KEY_SPECIAL+14)-#define GLFW_KEY_F14          (GLFW_KEY_SPECIAL+15)-#define GLFW_KEY_F15          (GLFW_KEY_SPECIAL+16)-#define GLFW_KEY_F16          (GLFW_KEY_SPECIAL+17)-#define GLFW_KEY_F17          (GLFW_KEY_SPECIAL+18)-#define GLFW_KEY_F18          (GLFW_KEY_SPECIAL+19)-#define GLFW_KEY_F19          (GLFW_KEY_SPECIAL+20)-#define GLFW_KEY_F20          (GLFW_KEY_SPECIAL+21)-#define GLFW_KEY_F21          (GLFW_KEY_SPECIAL+22)-#define GLFW_KEY_F22          (GLFW_KEY_SPECIAL+23)-#define GLFW_KEY_F23          (GLFW_KEY_SPECIAL+24)-#define GLFW_KEY_F24          (GLFW_KEY_SPECIAL+25)-#define GLFW_KEY_F25          (GLFW_KEY_SPECIAL+26)-#define GLFW_KEY_UP           (GLFW_KEY_SPECIAL+27)-#define GLFW_KEY_DOWN         (GLFW_KEY_SPECIAL+28)-#define GLFW_KEY_LEFT         (GLFW_KEY_SPECIAL+29)-#define GLFW_KEY_RIGHT        (GLFW_KEY_SPECIAL+30)-#define GLFW_KEY_LSHIFT       (GLFW_KEY_SPECIAL+31)-#define GLFW_KEY_RSHIFT       (GLFW_KEY_SPECIAL+32)-#define GLFW_KEY_LCTRL        (GLFW_KEY_SPECIAL+33)-#define GLFW_KEY_RCTRL        (GLFW_KEY_SPECIAL+34)-#define GLFW_KEY_LALT         (GLFW_KEY_SPECIAL+35)-#define GLFW_KEY_RALT         (GLFW_KEY_SPECIAL+36)-#define GLFW_KEY_TAB          (GLFW_KEY_SPECIAL+37)-#define GLFW_KEY_ENTER        (GLFW_KEY_SPECIAL+38)-#define GLFW_KEY_BACKSPACE    (GLFW_KEY_SPECIAL+39)-#define GLFW_KEY_INSERT       (GLFW_KEY_SPECIAL+40)-#define GLFW_KEY_DEL          (GLFW_KEY_SPECIAL+41)-#define GLFW_KEY_PAGEUP       (GLFW_KEY_SPECIAL+42)-#define GLFW_KEY_PAGEDOWN     (GLFW_KEY_SPECIAL+43)-#define GLFW_KEY_HOME         (GLFW_KEY_SPECIAL+44)-#define GLFW_KEY_END          (GLFW_KEY_SPECIAL+45)-#define GLFW_KEY_KP_0         (GLFW_KEY_SPECIAL+46)-#define GLFW_KEY_KP_1         (GLFW_KEY_SPECIAL+47)-#define GLFW_KEY_KP_2         (GLFW_KEY_SPECIAL+48)-#define GLFW_KEY_KP_3         (GLFW_KEY_SPECIAL+49)-#define GLFW_KEY_KP_4         (GLFW_KEY_SPECIAL+50)-#define GLFW_KEY_KP_5         (GLFW_KEY_SPECIAL+51)-#define GLFW_KEY_KP_6         (GLFW_KEY_SPECIAL+52)-#define GLFW_KEY_KP_7         (GLFW_KEY_SPECIAL+53)-#define GLFW_KEY_KP_8         (GLFW_KEY_SPECIAL+54)-#define GLFW_KEY_KP_9         (GLFW_KEY_SPECIAL+55)-#define GLFW_KEY_KP_DIVIDE    (GLFW_KEY_SPECIAL+56)-#define GLFW_KEY_KP_MULTIPLY  (GLFW_KEY_SPECIAL+57)-#define GLFW_KEY_KP_SUBTRACT  (GLFW_KEY_SPECIAL+58)-#define GLFW_KEY_KP_ADD       (GLFW_KEY_SPECIAL+59)-#define GLFW_KEY_KP_DECIMAL   (GLFW_KEY_SPECIAL+60)-#define GLFW_KEY_KP_EQUAL     (GLFW_KEY_SPECIAL+61)-#define GLFW_KEY_KP_ENTER     (GLFW_KEY_SPECIAL+62)-#define GLFW_KEY_KP_NUM_LOCK  (GLFW_KEY_SPECIAL+63)-#define GLFW_KEY_CAPS_LOCK    (GLFW_KEY_SPECIAL+64)-#define GLFW_KEY_SCROLL_LOCK  (GLFW_KEY_SPECIAL+65)-#define GLFW_KEY_PAUSE        (GLFW_KEY_SPECIAL+66)-#define GLFW_KEY_LSUPER       (GLFW_KEY_SPECIAL+67)-#define GLFW_KEY_RSUPER       (GLFW_KEY_SPECIAL+68)-#define GLFW_KEY_MENU         (GLFW_KEY_SPECIAL+69)-#define GLFW_KEY_LAST         GLFW_KEY_MENU--/* Mouse button definitions */-#define GLFW_MOUSE_BUTTON_1      0-#define GLFW_MOUSE_BUTTON_2      1-#define GLFW_MOUSE_BUTTON_3      2-#define GLFW_MOUSE_BUTTON_4      3-#define GLFW_MOUSE_BUTTON_5      4-#define GLFW_MOUSE_BUTTON_6      5-#define GLFW_MOUSE_BUTTON_7      6-#define GLFW_MOUSE_BUTTON_8      7-#define GLFW_MOUSE_BUTTON_LAST   GLFW_MOUSE_BUTTON_8--/* Mouse button aliases */-#define GLFW_MOUSE_BUTTON_LEFT   GLFW_MOUSE_BUTTON_1-#define GLFW_MOUSE_BUTTON_RIGHT  GLFW_MOUSE_BUTTON_2-#define GLFW_MOUSE_BUTTON_MIDDLE GLFW_MOUSE_BUTTON_3---/* Joystick identifiers */-#define GLFW_JOYSTICK_1          0-#define GLFW_JOYSTICK_2          1-#define GLFW_JOYSTICK_3          2-#define GLFW_JOYSTICK_4          3-#define GLFW_JOYSTICK_5          4-#define GLFW_JOYSTICK_6          5-#define GLFW_JOYSTICK_7          6-#define GLFW_JOYSTICK_8          7-#define GLFW_JOYSTICK_9          8-#define GLFW_JOYSTICK_10         9-#define GLFW_JOYSTICK_11         10-#define GLFW_JOYSTICK_12         11-#define GLFW_JOYSTICK_13         12-#define GLFW_JOYSTICK_14         13-#define GLFW_JOYSTICK_15         14-#define GLFW_JOYSTICK_16         15-#define GLFW_JOYSTICK_LAST       GLFW_JOYSTICK_16---/*************************************************************************- * Other definitions- *************************************************************************/--/* glfwOpenWindow modes */-#define GLFW_WINDOW               0x00010001-#define GLFW_FULLSCREEN           0x00010002--/* glfwGetWindowParam tokens */-#define GLFW_OPENED               0x00020001-#define GLFW_ACTIVE               0x00020002-#define GLFW_ICONIFIED            0x00020003-#define GLFW_ACCELERATED          0x00020004-#define GLFW_RED_BITS             0x00020005-#define GLFW_GREEN_BITS           0x00020006-#define GLFW_BLUE_BITS            0x00020007-#define GLFW_ALPHA_BITS           0x00020008-#define GLFW_DEPTH_BITS           0x00020009-#define GLFW_STENCIL_BITS         0x0002000A--/* The following constants are used for both glfwGetWindowParam- * and glfwOpenWindowHint- */-#define GLFW_REFRESH_RATE         0x0002000B-#define GLFW_ACCUM_RED_BITS       0x0002000C-#define GLFW_ACCUM_GREEN_BITS     0x0002000D-#define GLFW_ACCUM_BLUE_BITS      0x0002000E-#define GLFW_ACCUM_ALPHA_BITS     0x0002000F-#define GLFW_AUX_BUFFERS          0x00020010-#define GLFW_STEREO               0x00020011-#define GLFW_WINDOW_NO_RESIZE     0x00020012-#define GLFW_FSAA_SAMPLES         0x00020013-#define GLFW_OPENGL_VERSION_MAJOR 0x00020014-#define GLFW_OPENGL_VERSION_MINOR 0x00020015-#define GLFW_OPENGL_FORWARD_COMPAT 0x00020016-#define GLFW_OPENGL_DEBUG_CONTEXT 0x00020017-#define GLFW_OPENGL_PROFILE       0x00020018--/* GLFW_OPENGL_PROFILE tokens */-#define GLFW_OPENGL_CORE_PROFILE  0x00050001-#define GLFW_OPENGL_COMPAT_PROFILE 0x00050002--/* glfwEnable/glfwDisable tokens */-#define GLFW_MOUSE_CURSOR         0x00030001-#define GLFW_STICKY_KEYS          0x00030002-#define GLFW_STICKY_MOUSE_BUTTONS 0x00030003-#define GLFW_SYSTEM_KEYS          0x00030004-#define GLFW_KEY_REPEAT           0x00030005-#define GLFW_AUTO_POLL_EVENTS     0x00030006--/* glfwWaitThread wait modes */-#define GLFW_WAIT                 0x00040001-#define GLFW_NOWAIT               0x00040002--/* glfwGetJoystickParam tokens */-#define GLFW_PRESENT              0x00050001-#define GLFW_AXES                 0x00050002-#define GLFW_BUTTONS              0x00050003--/* glfwReadImage/glfwLoadTexture2D flags */-#define GLFW_NO_RESCALE_BIT       0x00000001 /* Only for glfwReadImage */-#define GLFW_ORIGIN_UL_BIT        0x00000002-#define GLFW_BUILD_MIPMAPS_BIT    0x00000004 /* Only for glfwLoadTexture2D */-#define GLFW_ALPHA_MAP_BIT        0x00000008--/* Time spans longer than this (seconds) are considered to be infinity */-#define GLFW_INFINITY 100000.0---/*************************************************************************- * Typedefs- *************************************************************************/--/* The video mode structure used by glfwGetVideoModes() */-typedef struct {-    int Width, Height;-    int RedBits, BlueBits, GreenBits;-} GLFWvidmode;--/* Image/texture information */-typedef struct {-    int Width, Height;-    int Format;-    int BytesPerPixel;-    unsigned char *Data;-} GLFWimage;--/* Thread ID */-typedef int GLFWthread;--/* Mutex object */-typedef void * GLFWmutex;--/* Condition variable object */-typedef void * GLFWcond;--/* Function pointer types */-typedef void (GLFWCALL * GLFWwindowsizefun)(int,int);-typedef int  (GLFWCALL * GLFWwindowclosefun)(void);-typedef void (GLFWCALL * GLFWwindowrefreshfun)(void);-typedef void (GLFWCALL * GLFWmousebuttonfun)(int,int);-typedef void (GLFWCALL * GLFWmouseposfun)(int,int);-typedef void (GLFWCALL * GLFWmousewheelfun)(int);-typedef void (GLFWCALL * GLFWkeyfun)(int,int);-typedef void (GLFWCALL * GLFWcharfun)(int,int);-typedef void (GLFWCALL * GLFWthreadfun)(void *);---/*************************************************************************- * Prototypes- *************************************************************************/--/* GLFW initialization, termination and version querying */-GLFWAPI int  GLFWAPIENTRY glfwInit( void );-GLFWAPI void GLFWAPIENTRY glfwTerminate( void );-GLFWAPI void GLFWAPIENTRY glfwGetVersion( int *major, int *minor, int *rev );--/* Window handling */-GLFWAPI int  GLFWAPIENTRY glfwOpenWindow( int width, int height, int redbits, int greenbits, int bluebits, int alphabits, int depthbits, int stencilbits, int mode );-GLFWAPI void GLFWAPIENTRY glfwOpenWindowHint( int target, int hint );-GLFWAPI void GLFWAPIENTRY glfwCloseWindow( void );-GLFWAPI void GLFWAPIENTRY glfwSetWindowTitle( const char *title );-GLFWAPI void GLFWAPIENTRY glfwGetWindowSize( int *width, int *height );-GLFWAPI void GLFWAPIENTRY glfwSetWindowSize( int width, int height );-GLFWAPI void GLFWAPIENTRY glfwSetWindowPos( int x, int y );-GLFWAPI void GLFWAPIENTRY glfwIconifyWindow( void );-GLFWAPI void GLFWAPIENTRY glfwRestoreWindow( void );-GLFWAPI void GLFWAPIENTRY glfwSwapBuffers( void );-GLFWAPI void GLFWAPIENTRY glfwSwapInterval( int interval );-GLFWAPI int  GLFWAPIENTRY glfwGetWindowParam( int param );-GLFWAPI void GLFWAPIENTRY glfwSetWindowSizeCallback( GLFWwindowsizefun cbfun );-GLFWAPI void GLFWAPIENTRY glfwSetWindowCloseCallback( GLFWwindowclosefun cbfun );-GLFWAPI void GLFWAPIENTRY glfwSetWindowRefreshCallback( GLFWwindowrefreshfun cbfun );--/* Video mode functions */-GLFWAPI int  GLFWAPIENTRY glfwGetVideoModes( GLFWvidmode *list, int maxcount );-GLFWAPI void GLFWAPIENTRY glfwGetDesktopMode( GLFWvidmode *mode );--/* Input handling */-GLFWAPI void GLFWAPIENTRY glfwPollEvents( void );-GLFWAPI void GLFWAPIENTRY glfwWaitEvents( void );-GLFWAPI int  GLFWAPIENTRY glfwGetKey( int key );-GLFWAPI int  GLFWAPIENTRY glfwGetMouseButton( int button );-GLFWAPI void GLFWAPIENTRY glfwGetMousePos( int *xpos, int *ypos );-GLFWAPI void GLFWAPIENTRY glfwSetMousePos( int xpos, int ypos );-GLFWAPI int  GLFWAPIENTRY glfwGetMouseWheel( void );-GLFWAPI void GLFWAPIENTRY glfwSetMouseWheel( int pos );-GLFWAPI void GLFWAPIENTRY glfwSetKeyCallback( GLFWkeyfun cbfun );-GLFWAPI void GLFWAPIENTRY glfwSetCharCallback( GLFWcharfun cbfun );-GLFWAPI void GLFWAPIENTRY glfwSetMouseButtonCallback( GLFWmousebuttonfun cbfun );-GLFWAPI void GLFWAPIENTRY glfwSetMousePosCallback( GLFWmouseposfun cbfun );-GLFWAPI void GLFWAPIENTRY glfwSetMouseWheelCallback( GLFWmousewheelfun cbfun );--/* Joystick input */-GLFWAPI int GLFWAPIENTRY glfwGetJoystickParam( int joy, int param );-GLFWAPI int GLFWAPIENTRY glfwGetJoystickPos( int joy, float *pos, int numaxes );-GLFWAPI int GLFWAPIENTRY glfwGetJoystickButtons( int joy, unsigned char *buttons, int numbuttons );--/* Time */-GLFWAPI double GLFWAPIENTRY glfwGetTime( void );-GLFWAPI void   GLFWAPIENTRY glfwSetTime( double time );-GLFWAPI void   GLFWAPIENTRY glfwSleep( double time );--/* Extension support */-GLFWAPI int   GLFWAPIENTRY glfwExtensionSupported( const char *extension );-GLFWAPI void* GLFWAPIENTRY glfwGetProcAddress( const char *procname );-GLFWAPI void  GLFWAPIENTRY glfwGetGLVersion( int *major, int *minor, int *rev );--/* Threading support */-GLFWAPI GLFWthread GLFWAPIENTRY glfwCreateThread( GLFWthreadfun fun, void *arg );-GLFWAPI void GLFWAPIENTRY glfwDestroyThread( GLFWthread ID );-GLFWAPI int  GLFWAPIENTRY glfwWaitThread( GLFWthread ID, int waitmode );-GLFWAPI GLFWthread GLFWAPIENTRY glfwGetThreadID( void );-GLFWAPI GLFWmutex GLFWAPIENTRY glfwCreateMutex( void );-GLFWAPI void GLFWAPIENTRY glfwDestroyMutex( GLFWmutex mutex );-GLFWAPI void GLFWAPIENTRY glfwLockMutex( GLFWmutex mutex );-GLFWAPI void GLFWAPIENTRY glfwUnlockMutex( GLFWmutex mutex );-GLFWAPI GLFWcond GLFWAPIENTRY glfwCreateCond( void );-GLFWAPI void GLFWAPIENTRY glfwDestroyCond( GLFWcond cond );-GLFWAPI void GLFWAPIENTRY glfwWaitCond( GLFWcond cond, GLFWmutex mutex, double timeout );-GLFWAPI void GLFWAPIENTRY glfwSignalCond( GLFWcond cond );-GLFWAPI void GLFWAPIENTRY glfwBroadcastCond( GLFWcond cond );-GLFWAPI int  GLFWAPIENTRY glfwGetNumberOfProcessors( void );--/* Enable/disable functions */-GLFWAPI void GLFWAPIENTRY glfwEnable( int token );-GLFWAPI void GLFWAPIENTRY glfwDisable( int token );--/* Image/texture I/O support */-GLFWAPI int  GLFWAPIENTRY glfwReadImage( const char *name, GLFWimage *img, int flags );-GLFWAPI int  GLFWAPIENTRY glfwReadMemoryImage( const void *data, long size, GLFWimage *img, int flags );-GLFWAPI void GLFWAPIENTRY glfwFreeImage( GLFWimage *img );-GLFWAPI int  GLFWAPIENTRY glfwLoadTexture2D( const char *name, int flags );-GLFWAPI int  GLFWAPIENTRY glfwLoadMemoryTexture2D( const void *data, long size, int flags );-GLFWAPI int  GLFWAPIENTRY glfwLoadTextureImage2D( GLFWimage *img, int flags );---#ifdef __cplusplus-}-#endif--#endif /* __glfw_h_ */-
− glfw/lib/cocoa/cocoa_enable.m 
@@ -1,51 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Cocoa/NSOpenGL-// API Version: 2.7-// WWW:         http://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"--//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Enable and disable system keys-//========================================================================--void _glfwPlatformEnableSystemKeys( void )-{-    // This is checked in macosx_window.m; we take no action here-}--void _glfwPlatformDisableSystemKeys( void )-{-    // This is checked in macosx_window.m; we take no action here-    // I don't think it's really possible to disable stuff like Exposé-    // except in full-screen mode.-}-
− glfw/lib/cocoa/cocoa_fullscreen.m 
@@ -1,102 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Cocoa/NSOpenGL-// API Version: 2.7-// WWW:         http://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"--//========================================================================-// Check whether the display mode should be included in enumeration-//========================================================================--static BOOL modeIsGood( NSDictionary *mode )-{-    // This is a bit controversial, if you've got something other than an-    // LCD computer monitor as an output device you might not want these-    // checks.  You might also want to reject modes which are interlaced,-    // or TV out.  There is no one-size-fits-all policy that can work here.-    // This seems like a decent compromise, but certain applications may-    // wish to patch this...-    return [[mode objectForKey:(id)kCGDisplayBitsPerPixel] intValue] >= 15 &&-           [mode objectForKey:(id)kCGDisplayModeIsSafeForHardware] != nil &&-           [mode objectForKey:(id)kCGDisplayModeIsStretched] == nil;-}--//========================================================================-// Convert Core Graphics display mode to GLFW video mode-//========================================================================--static GLFWvidmode vidmodeFromCGDisplayMode( NSDictionary *mode )-{-    unsigned int width = [[mode objectForKey:(id)kCGDisplayWidth] unsignedIntValue];-    unsigned int height = [[mode objectForKey:(id)kCGDisplayHeight] unsignedIntValue];-    unsigned int bps = [[mode objectForKey:(id)kCGDisplayBitsPerSample] unsignedIntValue];--    GLFWvidmode result;-    result.Width = width;-    result.Height = height;-    result.RedBits = bps;-    result.GreenBits = bps;-    result.BlueBits = bps;-    return result;-}---//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Get a list of available video modes-//========================================================================--int _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount )-{-    NSArray *modes = (NSArray *)CGDisplayAvailableModes( CGMainDisplayID() );--    unsigned int i, j = 0, n = [modes count];-    for( i = 0; i < n && j < (unsigned)maxcount; i++ )-    {-        NSDictionary *mode = [modes objectAtIndex:i];-        if( modeIsGood( mode ) )-        {-            list[j++] = vidmodeFromCGDisplayMode( mode );-        }-    }--    return j;-}--//========================================================================-// Get the desktop video mode-//========================================================================--void _glfwPlatformGetDesktopMode( GLFWvidmode *mode )-{-    *mode = vidmodeFromCGDisplayMode( _glfwLibrary.DesktopMode );-}-
− glfw/lib/cocoa/cocoa_glext.m 
@@ -1,63 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Cocoa/NSOpenGL-// API Version: 2.7-// WWW:         http://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"--//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Check if an OpenGL extension is available at runtime-//========================================================================--int _glfwPlatformExtensionSupported( const char *extension )-{-    // There are no AGL, CGL or NSGL extensions.-    return GL_FALSE;-}--//========================================================================-// Get the function pointer to an OpenGL function-//========================================================================--void * _glfwPlatformGetProcAddress( const char *procname )-{-    CFStringRef symbolName = CFStringCreateWithCString( kCFAllocatorDefault,-                                                        procname,-                                                        kCFStringEncodingASCII );--    void *symbol = CFBundleGetFunctionPointerForName( _glfwLibrary.OpenGLFramework,-                                                      symbolName );--    CFRelease( symbolName );--    return symbol;-}-
− glfw/lib/cocoa/cocoa_init.m 
@@ -1,297 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Cocoa/NSOpenGL-// API Version: 2.7-// WWW:         http://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.-//-//========================================================================--// Needed for _NSGetProgname-#include <crt_externs.h>--#include "internal.h"--@interface GLFWThread : NSThread-@end--@implementation GLFWThread--- (void)main-{-}--@end--@interface GLFWApplication : NSApplication-@end--@implementation GLFWApplication--// From http://cocoadev.com/index.pl?GameKeyboardHandlingAlmost-// This works around an AppKit bug, where key up events while holding-// down the command key don't get sent to the key window.-- (void)sendEvent:(NSEvent *)event-{-    if( [event type] == NSKeyUp && ( [event modifierFlags] & NSCommandKeyMask ) )-    {-        [[self keyWindow] sendEvent:event];-    }-    else-    {-        [super sendEvent:event];-    }-}--@end--// Prior to Snow Leopard, we need to use this oddly-named semi-private API-// to get the application menu working properly.  Need to be careful in-// case it goes away in a future OS update.-@interface NSApplication (NSAppleMenu)-- (void)setAppleMenu:(NSMenu *)m;-@end--// Keys to search for as potential application names-NSString *GLFWNameKeys[] =-{-    @"CFBundleDisplayName",-    @"CFBundleName",-    @"CFBundleExecutable",-};--//========================================================================-// Try to figure out what the calling application is called-//========================================================================-static NSString *findAppName( void )-{-    NSDictionary *infoDictionary = [[NSBundle mainBundle] infoDictionary];--    unsigned int i;-    for( i = 0; i < sizeof(GLFWNameKeys) / sizeof(GLFWNameKeys[0]); i++ )-    {-        id name = [infoDictionary objectForKey:GLFWNameKeys[i]];-        if (name &&-            [name isKindOfClass:[NSString class]] &&-            ![@"" isEqualToString:name])-        {-            return name;-        }-    }--    // If we get here, we're unbundled-    if( !_glfwLibrary.Unbundled )-    {-        // Could do this only if we discover we're unbundled, but it should-        // do no harm...-        ProcessSerialNumber psn = { 0, kCurrentProcess };-        TransformProcessType( &psn, kProcessTransformToForegroundApplication );--        // Having the app in front of the terminal window is also generally-        // handy.  There is an NSApplication API to do this, but...-        SetFrontProcess( &psn );--        _glfwLibrary.Unbundled = GL_TRUE;-    }--    char **progname = _NSGetProgname();-    if( progname && *progname )-    {-        // TODO: UTF8?-        return [NSString stringWithUTF8String:*progname];-    }--    // Really shouldn't get here-    return @"GLFW Application";-}--//========================================================================-// Set up the menu bar (manually)-// This is nasty, nasty stuff -- calls to undocumented semi-private APIs that-// could go away at any moment, lots of stuff that really should be-// localize(d|able), etc.  Loading a nib would save us this horror, but that-// doesn't seem like a good thing to require of GLFW's clients.-//========================================================================-static void setUpMenuBar( void )-{-    NSString *appName = findAppName();--    NSMenu *bar = [[NSMenu alloc] init];-    [NSApp setMainMenu:bar];--    NSMenuItem *appMenuItem =-        [bar addItemWithTitle:@"" action:NULL keyEquivalent:@""];-    NSMenu *appMenu = [[NSMenu alloc] init];-    [appMenuItem setSubmenu:appMenu];--    [appMenu addItemWithTitle:[NSString stringWithFormat:@"About %@", appName]-                       action:@selector(orderFrontStandardAboutPanel:)-                keyEquivalent:@""];-    [appMenu addItem:[NSMenuItem separatorItem]];-    NSMenu *servicesMenu = [[NSMenu alloc] init];-    [NSApp setServicesMenu:servicesMenu];-    [[appMenu addItemWithTitle:@"Services"-                       action:NULL-                keyEquivalent:@""] setSubmenu:servicesMenu];-    [appMenu addItem:[NSMenuItem separatorItem]];-    [appMenu addItemWithTitle:[NSString stringWithFormat:@"Hide %@", appName]-                       action:@selector(hide:)-                keyEquivalent:@"h"];-    [[appMenu addItemWithTitle:@"Hide Others"-                       action:@selector(hideOtherApplications:)-                keyEquivalent:@"h"]-        setKeyEquivalentModifierMask:NSAlternateKeyMask | NSCommandKeyMask];-    [appMenu addItemWithTitle:@"Show All"-                       action:@selector(unhideAllApplications:)-                keyEquivalent:@""];-    [appMenu addItem:[NSMenuItem separatorItem]];-    [appMenu addItemWithTitle:[NSString stringWithFormat:@"Quit %@", appName]-                       action:@selector(terminate:)-                keyEquivalent:@"q"];--    NSMenuItem *windowMenuItem =-        [bar addItemWithTitle:@"" action:NULL keyEquivalent:@""];-    NSMenu *windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];-    [NSApp setWindowsMenu:windowMenu];-    [windowMenuItem setSubmenu:windowMenu];--    [windowMenu addItemWithTitle:@"Miniaturize"-                          action:@selector(performMiniaturize:)-                   keyEquivalent:@"m"];-    [windowMenu addItemWithTitle:@"Zoom"-                          action:@selector(performZoom:)-                   keyEquivalent:@""];-    [windowMenu addItem:[NSMenuItem separatorItem]];-    [windowMenu addItemWithTitle:@"Bring All to Front"-                          action:@selector(arrangeInFront:)-                   keyEquivalent:@""];--    // At least guard the call to private API to avoid an exception if it-    // goes away.  Hopefully that means the worst we'll break in future is to-    // look ugly...-    if( [NSApp respondsToSelector:@selector(setAppleMenu:)] )-    {-        [NSApp setAppleMenu:appMenu];-    }-}--//========================================================================-// Terminate GLFW when exiting application-//========================================================================--static void glfw_atexit( void )-{-    glfwTerminate();-}---//========================================================================-// Initialize GLFW thread package-//========================================================================--static void initThreads( void )-{-    // Initialize critical section handle-    (void) pthread_mutex_init( &_glfwThrd.CriticalSection, NULL );--    // The first thread (the main thread) has ID 0-    _glfwThrd.NextID = 0;--    // Fill out information about the main thread (this thread)-    _glfwThrd.First.ID       = _glfwThrd.NextID ++;-    _glfwThrd.First.Function = NULL;-    _glfwThrd.First.PosixID  = pthread_self();-    _glfwThrd.First.Previous = NULL;-    _glfwThrd.First.Next     = NULL;-}--//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Initialize the GLFW library-//========================================================================--int _glfwPlatformInit( void )-{-    _glfwLibrary.AutoreleasePool = [[NSAutoreleasePool alloc] init];--    // Implicitly create shared NSApplication instance-    [GLFWApplication sharedApplication];--    _glfwLibrary.OpenGLFramework =-        CFBundleGetBundleWithIdentifier( CFSTR( "com.apple.opengl" ) );-    if( _glfwLibrary.OpenGLFramework == NULL )-    {-        return GL_FALSE;-    }--    GLFWThread* thread = [[GLFWThread alloc] init];-    [thread start];-    [thread release];--    NSString* resourcePath = [[NSBundle mainBundle] resourcePath];--    if( access( [resourcePath cStringUsingEncoding:NSUTF8StringEncoding], R_OK ) == 0 )-    {-        chdir( [resourcePath cStringUsingEncoding:NSUTF8StringEncoding] );-    }--    // Setting up menu bar must go exactly here else weirdness ensues-    setUpMenuBar();--    [NSApp finishLaunching];--    // Install atexit routine-    atexit( glfw_atexit );--    initThreads();--    _glfwPlatformSetTime( 0.0 );--    _glfwLibrary.DesktopMode =-	(NSDictionary *)CGDisplayCurrentMode( CGMainDisplayID() );--    return GL_TRUE;-}--//========================================================================-// Close window, if open, and shut down GLFW-//========================================================================--int _glfwPlatformTerminate( void )-{-    // TODO: Fail unless this is the main thread--    glfwCloseWindow();--    // TODO: Kill all non-main threads?-    // TODO: Probably other cleanup--    [_glfwLibrary.AutoreleasePool release];-    _glfwLibrary.AutoreleasePool = nil;--    return GL_TRUE;-}-
− glfw/lib/cocoa/cocoa_joystick.m 
@@ -1,65 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Cocoa/NSOpenGL-// API Version: 2.7-// WWW:         http://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"--//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Determine joystick capabilities-//========================================================================--int _glfwPlatformGetJoystickParam( int joy, int param )-{-    // TODO: Implement this.-    return 0;-}--//========================================================================-// Get joystick axis positions-//========================================================================--int _glfwPlatformGetJoystickPos( int joy, float *pos, int numaxes )-{-    // TODO: Implement this.-    return 0;-}--//========================================================================-// Get joystick button states-//========================================================================--int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons, int numbuttons )-{-    // TODO: Implement this.-    return 0;-}-
− glfw/lib/cocoa/cocoa_thread.c 
@@ -1,416 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// File:        macosx_thread.c-// Platform:    Mac OS X-// API Version: 2.7-// WWW:         http://glfw.sourceforge.net-//-------------------------------------------------------------------------// Copyright (c) 2002-2006 Camilla Berglund-//-// This software is provided 'as-is', without any express or implied-// warranty. In no event will the authors be held liable for any damages-// arising from the use of this software.-//-// Permission is granted to anyone to use this software for any purpose,-// including commercial applications, and to alter it and redistribute it-// freely, subject to the following restrictions:-//-// 1. The origin of this software must not be misrepresented; you must not-//    claim that you wrote the original software. If you use this software-//    in a product, an acknowledgment in the product documentation would-//    be appreciated but is not required.-//-// 2. Altered source versions must be plainly marked as such, and must not-//    be misrepresented as being the original software.-//-// 3. This notice may not be removed or altered from any source-//    distribution.-//-//========================================================================--#include "internal.h"--#include <sys/time.h>-#include <sys/sysctl.h>---//************************************************************************-//****                  GLFW internal functions                       ****-//************************************************************************--//========================================================================-// _glfwNewThread() - This is simply a "wrapper" for calling the user-// thread function.-//========================================================================--void * _glfwNewThread( void * arg )-{-    GLFWthreadfun threadfun;-    _GLFWthread   *t;--    // Get pointer to thread information for current thread-    t = _glfwGetThreadPointer( glfwGetThreadID() );-    if( t == NULL )-    {-        return 0;-    }--    // Get user thread function pointer-    threadfun = t->Function;--    // Call the user thread function-    threadfun( arg );--    // Remove thread from thread list-    ENTER_THREAD_CRITICAL_SECTION-        _glfwRemoveThread( t );-    LEAVE_THREAD_CRITICAL_SECTION--    // When the thread function returns, the thread will die...-    return NULL;-}----//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// _glfwPlatformCreateThread() - Create a new thread-//========================================================================--GLFWthread _glfwPlatformCreateThread( GLFWthreadfun fun, void *arg )-{-    GLFWthread  ID;-    _GLFWthread *t;-    int         result;--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Create a new thread information memory area-    t = (_GLFWthread *) malloc( sizeof(_GLFWthread) );-    if( t == NULL )-    {-        // Leave critical section-        LEAVE_THREAD_CRITICAL_SECTION-        return -1;-    }--    // Get a new unique thread id-    ID = _glfwThrd.NextID ++;--    // Store thread information in the thread list-    t->Function = fun;-    t->ID       = ID;--    // Create thread-    result = pthread_create(-                            &t->PosixID,      // Thread handle-                            NULL,             // Default thread attributes-                            _glfwNewThread,   // Thread function (a wrapper function)-                            (void *)arg       // Argument to thread is user argument-                            );--    // Did the thread creation fail?-    if( result != 0 )-    {-        free( (void *) t );-        LEAVE_THREAD_CRITICAL_SECTION-        return -1;-    }--    // Append thread to thread list-    _glfwAppendThread( t );--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Return the GLFW thread ID-    return ID;-}---//========================================================================-// _glfwPlatformDestroyThread() - Kill a thread. NOTE: THIS IS A VERY-// DANGEROUS OPERATION, AND SHOULD NOT BE USED EXCEPT IN EXTREME-// SITUATIONS!-//========================================================================--void _glfwPlatformDestroyThread( GLFWthread ID )-{-    _GLFWthread *t;--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Get thread information pointer-    t = _glfwGetThreadPointer( ID );-    if( t == NULL )-    {-        LEAVE_THREAD_CRITICAL_SECTION-        return;-    }--    // Simply murder the process, no mercy!-    pthread_kill( t->PosixID, SIGKILL );--    // Remove thread from thread list-    _glfwRemoveThread( t );--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION-}---//========================================================================-// _glfwPlatformWaitThread() - Wait for a thread to die-//========================================================================--int _glfwPlatformWaitThread( GLFWthread ID, int waitmode )-{-    pthread_t   thread;-    _GLFWthread *t;--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Get thread information pointer-    t = _glfwGetThreadPointer( ID );--    // Is the thread already dead?-    if( t == NULL )-    {-        LEAVE_THREAD_CRITICAL_SECTION-        return GL_TRUE;-    }--    // If got this far, the thread is alive => polling returns FALSE-    if( waitmode == GLFW_NOWAIT )-    {-        LEAVE_THREAD_CRITICAL_SECTION-        return GL_FALSE;-    }--    // Get thread handle-    thread = t->PosixID;--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Wait for thread to die-    (void) pthread_join( thread, NULL );--    return GL_TRUE;-}---//========================================================================-// _glfwPlatformGetThreadID() - Return the thread ID for the current-// thread-//========================================================================--GLFWthread _glfwPlatformGetThreadID( void )-{-    _GLFWthread *t;-    GLFWthread  ID = -1;-    pthread_t   posixID;--    // Get current thread ID-    posixID = pthread_self();--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Loop through entire list of threads to find the matching POSIX-    // thread ID-    for( t = &_glfwThrd.First; t != NULL; t = t->Next )-    {-        if( t->PosixID == posixID )-        {-            ID = t->ID;-            break;-        }-    }--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Return the found GLFW thread identifier-    return ID;-}---//========================================================================-// _glfwPlatformCreateMutex() - Create a mutual exclusion object-//========================================================================--GLFWmutex _glfwPlatformCreateMutex( void )-{-    pthread_mutex_t *mutex;--    // Allocate memory for mutex-    mutex = (pthread_mutex_t *) malloc( sizeof( pthread_mutex_t ) );-    if( !mutex )-    {-        return NULL;-    }--    // Initialise a mutex object-    (void) pthread_mutex_init( mutex, NULL );--    // Cast to GLFWmutex and return-    return (GLFWmutex) mutex;-}---//========================================================================-// _glfwPlatformDestroyMutex() - Destroy a mutual exclusion object-//========================================================================--void _glfwPlatformDestroyMutex( GLFWmutex mutex )-{-    // Destroy the mutex object-    pthread_mutex_destroy( (pthread_mutex_t *) mutex );--    // Free memory for mutex object-    free( (void *) mutex );-}---//========================================================================-// _glfwPlatformLockMutex() - Request access to a mutex-//========================================================================--void _glfwPlatformLockMutex( GLFWmutex mutex )-{-    // Wait for mutex to be released-    (void) pthread_mutex_lock( (pthread_mutex_t *) mutex );-}---//========================================================================-// _glfwPlatformUnlockMutex() - Release a mutex-//========================================================================--void _glfwPlatformUnlockMutex( GLFWmutex mutex )-{-    // Release mutex-    pthread_mutex_unlock( (pthread_mutex_t *) mutex );-}---//========================================================================-// _glfwPlatformCreateCond() - Create a new condition variable object-//========================================================================--GLFWcond _glfwPlatformCreateCond( void )-{-    pthread_cond_t *cond;--    // Allocate memory for condition variable-    cond = (pthread_cond_t *) malloc( sizeof(pthread_cond_t) );-    if( !cond )-    {-        return NULL;-    }--    // Initialise condition variable-    (void) pthread_cond_init( cond, NULL );--    // Cast to GLFWcond and return-    return (GLFWcond) cond;-}---//========================================================================-// _glfwPlatformDestroyCond() - Destroy a condition variable object-//========================================================================--void _glfwPlatformDestroyCond( GLFWcond cond )-{-    // Destroy the condition variable object-    (void) pthread_cond_destroy( (pthread_cond_t *) cond );--    // Free memory for condition variable object-    free( (void *) cond );-}---//========================================================================-// _glfwPlatformWaitCond() - Wait for a condition to be raised-//========================================================================--void _glfwPlatformWaitCond( GLFWcond cond, GLFWmutex mutex,-                            double timeout )-{-    struct timeval  currenttime;-    struct timespec wait;-    long dt_sec, dt_usec;--    // Select infinite or timed wait-    if( timeout >= GLFW_INFINITY )-    {-        // Wait for condition (infinite wait)-        (void) pthread_cond_wait( (pthread_cond_t *) cond,-                                  (pthread_mutex_t *) mutex );-    }-    else-    {-        // Set timeout time, relatvie to current time-        gettimeofday( &currenttime, NULL );-        dt_sec  = (long) timeout;-        dt_usec = (long) ((timeout - (double)dt_sec) * 1000000.0);-        wait.tv_nsec = (currenttime.tv_usec + dt_usec) * 1000L;-        if( wait.tv_nsec > 1000000000L )-        {-            wait.tv_nsec -= 1000000000L;-            dt_sec ++;-        }-        wait.tv_sec  = currenttime.tv_sec + dt_sec;--        // Wait for condition (timed wait)-        (void) pthread_cond_timedwait( (pthread_cond_t *) cond,-                                       (pthread_mutex_t *) mutex, &wait );-    }-}---//========================================================================-// _glfwPlatformSignalCond() - Signal a condition to one waiting thread-//========================================================================--void _glfwPlatformSignalCond( GLFWcond cond )-{-    // Signal condition-    (void) pthread_cond_signal( (pthread_cond_t *) cond );-}---//========================================================================-// _glfwPlatformBroadcastCond() - Broadcast a condition to all waiting-// threads-//========================================================================--void _glfwPlatformBroadcastCond( GLFWcond cond )-{-    // Broadcast condition-    (void) pthread_cond_broadcast( (pthread_cond_t *) cond );-}---//========================================================================-// _glfwPlatformGetNumberOfProcessors() - Return the number of processors-// in the system.-//========================================================================--int _glfwPlatformGetNumberOfProcessors( void )-{-    int n;--    // Get number of processors online-    _glfw_numprocessors( n );-    return n;-}-
− glfw/lib/cocoa/cocoa_time.m 
@@ -1,105 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Cocoa/NSOpenGL-// API Version: 2.7-// WWW:         http://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/time.h>--//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Return timer value in seconds-//========================================================================--double _glfwPlatformGetTime( void )-{-    return [NSDate timeIntervalSinceReferenceDate] - _glfwLibrary.Timer.t0;-}--//========================================================================-// Set timer value in seconds-//========================================================================--void _glfwPlatformSetTime( double time )-{-    _glfwLibrary.Timer.t0 = [NSDate timeIntervalSinceReferenceDate] - time;-}--//========================================================================-// Put a thread to sleep for a specified amount of time-//========================================================================--void _glfwPlatformSleep( double time )-{-    if( time == 0.0 )-    {-	sched_yield();-	return;-    }--    struct timeval  currenttime;-    struct timespec wait;-    pthread_mutex_t mutex;-    pthread_cond_t  cond;-    long dt_sec, dt_usec;--    // Not all pthread implementations have a pthread_sleep() function. We-    // do it the portable way, using a timed wait for a condition that we-    // will never signal. NOTE: The unistd functions sleep/usleep suspends-    // the entire PROCESS, not a signle thread, which is why we can not-    // use them to implement glfwSleep.--    // Set timeout time, relatvie to current time-    gettimeofday( &currenttime, NULL );-    dt_sec  = (long) time;-    dt_usec = (long) ((time - (double)dt_sec) * 1000000.0);-    wait.tv_nsec = (currenttime.tv_usec + dt_usec) * 1000L;-    if( wait.tv_nsec > 1000000000L )-    {-        wait.tv_nsec -= 1000000000L;-        dt_sec ++;-    }-    wait.tv_sec  = currenttime.tv_sec + dt_sec;--    // Initialize condition and mutex objects-    pthread_mutex_init( &mutex, NULL );-    pthread_cond_init( &cond, NULL );--    // Do a timed wait-    pthread_mutex_lock( &mutex );-    pthread_cond_timedwait( &cond, &mutex, &wait );-    pthread_mutex_unlock( &mutex );--    // Destroy condition and mutex objects-    pthread_mutex_destroy( &mutex );-    pthread_cond_destroy( &cond );-}-
− glfw/lib/cocoa/cocoa_window.m 
@@ -1,924 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Cocoa/NSOpenGL-// API Version: 2.7-// WWW:         http://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 <AvailabilityMacros.h>--//========================================================================-// Delegate for window related notifications-// (but also used as an application delegate)-//========================================================================--@interface GLFWWindowDelegate : NSObject-@end--@implementation GLFWWindowDelegate--- (BOOL)windowShouldClose:(id)window-{-    if( _glfwWin.windowCloseCallback )-    {-        if( !_glfwWin.windowCloseCallback() )-        {-            return NO;-        }-    }--    // This is horribly ugly, but it works-    glfwCloseWindow();-    return NO;-}--- (void)windowDidResize:(NSNotification *)notification-{-    [_glfwWin.context update];--    NSRect contentRect =-        [_glfwWin.window contentRectForFrameRect:[_glfwWin.window frame]];-    _glfwWin.width = contentRect.size.width;-    _glfwWin.height = contentRect.size.height;--    if( _glfwWin.windowSizeCallback )-    {-        _glfwWin.windowSizeCallback( _glfwWin.width, _glfwWin.height );-    }-}--- (void)windowDidMiniaturize:(NSNotification *)notification-{-    _glfwWin.iconified = GL_TRUE;-}--- (void)windowDidDeminiaturize:(NSNotification *)notification-{-    _glfwWin.iconified = GL_FALSE;-}--- (void)windowDidBecomeKey:(NSNotification *)notification-{-    _glfwWin.active = GL_TRUE;-}--- (void)windowDidResignKey:(NSNotification *)notification-{-    _glfwWin.active = GL_FALSE;-    _glfwInputDeactivation();-}--- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender-{-    if( _glfwWin.windowCloseCallback )-    {-        if( !_glfwWin.windowCloseCallback() )-        {-            return NSTerminateCancel;-        }-    }--    // This is horribly ugly, but it works-    glfwCloseWindow();-    return NSTerminateCancel;-}--@end--// TODO: Need to find mappings for F13-F15, volume down/up/mute, and eject.-static const unsigned int MAC_TO_GLFW_KEYCODE_MAPPING[128] =-{-    /* 00 */ 'A',-    /* 01 */ 'S',-    /* 02 */ 'D',-    /* 03 */ 'F',-    /* 04 */ 'H',-    /* 05 */ 'G',-    /* 06 */ 'Z',-    /* 07 */ 'X',-    /* 08 */ 'C',-    /* 09 */ 'V',-    /* 0a */ -1,-    /* 0b */ 'B',-    /* 0c */ 'Q',-    /* 0d */ 'W',-    /* 0e */ 'E',-    /* 0f */ 'R',-    /* 10 */ 'Y',-    /* 11 */ 'T',-    /* 12 */ '1',-    /* 13 */ '2',-    /* 14 */ '3',-    /* 15 */ '4',-    /* 16 */ '6',-    /* 17 */ '5',-    /* 18 */ '=',-    /* 19 */ '9',-    /* 1a */ '7',-    /* 1b */ '-',-    /* 1c */ '8',-    /* 1d */ '0',-    /* 1e */ ']',-    /* 1f */ 'O',-    /* 20 */ 'U',-    /* 21 */ '[',-    /* 22 */ 'I',-    /* 23 */ 'P',-    /* 24 */ GLFW_KEY_ENTER,-    /* 25 */ 'L',-    /* 26 */ 'J',-    /* 27 */ '\'',-    /* 28 */ 'K',-    /* 29 */ ';',-    /* 2a */ '\\',-    /* 2b */ ',',-    /* 2c */ '/',-    /* 2d */ 'N',-    /* 2e */ 'M',-    /* 2f */ '.',-    /* 30 */ GLFW_KEY_TAB,-    /* 31 */ GLFW_KEY_SPACE,-    /* 32 */ '`',-    /* 33 */ GLFW_KEY_BACKSPACE,-    /* 34 */ -1,-    /* 35 */ GLFW_KEY_ESC,-    /* 36 */ GLFW_KEY_RSUPER,-    /* 37 */ GLFW_KEY_LSUPER,-    /* 38 */ GLFW_KEY_LSHIFT,-    /* 39 */ GLFW_KEY_CAPS_LOCK,-    /* 3a */ GLFW_KEY_LALT,-    /* 3b */ GLFW_KEY_LCTRL,-    /* 3c */ GLFW_KEY_RSHIFT,-    /* 3d */ GLFW_KEY_RALT,-    /* 3e */ GLFW_KEY_RCTRL,-    /* 3f */ -1, /*Function*/-    /* 40 */ GLFW_KEY_F17,-    /* 41 */ GLFW_KEY_KP_DECIMAL,-    /* 42 */ -1,-    /* 43 */ GLFW_KEY_KP_MULTIPLY,-    /* 44 */ -1,-    /* 45 */ GLFW_KEY_KP_ADD,-    /* 46 */ -1,-    /* 47 */ -1, /*KeypadClear*/-    /* 48 */ -1, /*VolumeUp*/-    /* 49 */ -1, /*VolumeDown*/-    /* 4a */ -1, /*Mute*/-    /* 4b */ GLFW_KEY_KP_DIVIDE,-    /* 4c */ GLFW_KEY_KP_ENTER,-    /* 4d */ -1,-    /* 4e */ GLFW_KEY_KP_SUBTRACT,-    /* 4f */ GLFW_KEY_F18,-    /* 50 */ GLFW_KEY_F19,-    /* 51 */ GLFW_KEY_KP_EQUAL,-    /* 52 */ GLFW_KEY_KP_0,-    /* 53 */ GLFW_KEY_KP_1,-    /* 54 */ GLFW_KEY_KP_2,-    /* 55 */ GLFW_KEY_KP_3,-    /* 56 */ GLFW_KEY_KP_4,-    /* 57 */ GLFW_KEY_KP_5,-    /* 58 */ GLFW_KEY_KP_6,-    /* 59 */ GLFW_KEY_KP_7,-    /* 5a */ GLFW_KEY_F20,-    /* 5b */ GLFW_KEY_KP_8,-    /* 5c */ GLFW_KEY_KP_9,-    /* 5d */ -1,-    /* 5e */ -1,-    /* 5f */ -1,-    /* 60 */ GLFW_KEY_F5,-    /* 61 */ GLFW_KEY_F6,-    /* 62 */ GLFW_KEY_F7,-    /* 63 */ GLFW_KEY_F3,-    /* 64 */ GLFW_KEY_F8,-    /* 65 */ GLFW_KEY_F9,-    /* 66 */ -1,-    /* 67 */ GLFW_KEY_F11,-    /* 68 */ -1,-    /* 69 */ GLFW_KEY_F13,-    /* 6a */ GLFW_KEY_F16,-    /* 6b */ GLFW_KEY_F14,-    /* 6c */ -1,-    /* 6d */ GLFW_KEY_F10,-    /* 6e */ -1,-    /* 6f */ GLFW_KEY_F12,-    /* 70 */ -1,-    /* 71 */ GLFW_KEY_F15,-    /* 72 */ GLFW_KEY_INSERT, /*Help*/-    /* 73 */ GLFW_KEY_HOME,-    /* 74 */ GLFW_KEY_PAGEUP,-    /* 75 */ GLFW_KEY_DEL,-    /* 76 */ GLFW_KEY_F4,-    /* 77 */ GLFW_KEY_END,-    /* 78 */ GLFW_KEY_F2,-    /* 79 */ GLFW_KEY_PAGEDOWN,-    /* 7a */ GLFW_KEY_F1,-    /* 7b */ GLFW_KEY_LEFT,-    /* 7c */ GLFW_KEY_RIGHT,-    /* 7d */ GLFW_KEY_DOWN,-    /* 7e */ GLFW_KEY_UP,-    /* 7f */ -1,-};--//========================================================================-// Converts a Mac OS X keycode to a GLFW keycode-//========================================================================--static int convertMacKeyCode( unsigned int macKeyCode )-{-    if( macKeyCode >= 128 )-    {-        return -1;-    }--    // This treats keycodes as *positional*; that is, we'll return 'a'-    // for the key left of 's', even on an AZERTY keyboard.  The charInput-    // function should still get 'q' though.-    return MAC_TO_GLFW_KEYCODE_MAPPING[macKeyCode];-}--//========================================================================-// Content view class for the GLFW window-//========================================================================--@interface GLFWContentView : NSView-@end--@implementation GLFWContentView--- (BOOL)isOpaque-{-    return YES;-}--- (BOOL)canBecomeKeyView-{-    return YES;-}--- (BOOL)acceptsFirstResponder-{-    return YES;-}--- (void)mouseDown:(NSEvent *)event-{-    _glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS );-}--- (void)mouseDragged:(NSEvent *)event-{-    [self mouseMoved:event];-}--- (void)mouseUp:(NSEvent *)event-{-    _glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT, GLFW_RELEASE );-}--- (void)mouseMoved:(NSEvent *)event-{-    if( _glfwWin.mouseLock )-    {-        _glfwInput.MousePosX += [event deltaX];-        _glfwInput.MousePosY += [event deltaY];-    }-    else-    {-        NSPoint p = [event locationInWindow];--        // Cocoa coordinate system has origin at lower left-        _glfwInput.MousePosX = p.x;-        _glfwInput.MousePosY = [[_glfwWin.window contentView] bounds].size.height - p.y;-    }--    if( _glfwWin.mousePosCallback )-    {-        _glfwWin.mousePosCallback( _glfwInput.MousePosX, _glfwInput.MousePosY );-    }-}--- (void)rightMouseDown:(NSEvent *)event-{-    _glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS );-}--- (void)rightMouseDragged:(NSEvent *)event-{-    [self mouseMoved:event];-}--- (void)rightMouseUp:(NSEvent *)event-{-    _glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT, GLFW_RELEASE );-}--- (void)otherMouseDown:(NSEvent *)event-{-    _glfwInputMouseClick( [event buttonNumber], GLFW_PRESS );-}--- (void)otherMouseDragged:(NSEvent *)event-{-    [self mouseMoved:event];-}--- (void)otherMouseUp:(NSEvent *)event-{-    _glfwInputMouseClick( [event buttonNumber], GLFW_RELEASE );-}--- (void)keyDown:(NSEvent *)event-{-    NSUInteger length;-    NSString* characters;-    int i, code = convertMacKeyCode( [event keyCode] );--    if( code != -1 )-    {-        _glfwInputKey( code, GLFW_PRESS );--        if( [event modifierFlags] & NSCommandKeyMask )-        {-            if( !_glfwWin.sysKeysDisabled )-            {-                [super keyDown:event];-            }-        }-        else-        {-            characters = [event characters];-            length = [characters length];--            for( i = 0;  i < length;  i++ )-            {-                _glfwInputChar( [characters characterAtIndex:i], GLFW_PRESS );-            }-        }-    }-}--- (void)flagsChanged:(NSEvent *)event-{-    unsigned int newModifierFlags = [event modifierFlags] | NSDeviceIndependentModifierFlagsMask;-    int mode;--    if( newModifierFlags > _glfwWin.modifierFlags )-    {-        mode = GLFW_PRESS;-    }-    else-    {-        mode = GLFW_RELEASE;-    }--    _glfwWin.modifierFlags = newModifierFlags;-    _glfwInputKey( MAC_TO_GLFW_KEYCODE_MAPPING[[event keyCode]], mode );-}--- (void)keyUp:(NSEvent *)event-{-    NSUInteger length;-    NSString* characters;-    int i, code = convertMacKeyCode( [event keyCode] );--    if( code != -1 )-    {-        _glfwInputKey( code, GLFW_RELEASE );--        characters = [event characters];-        length = [characters length];--        for( i = 0;  i < length;  i++ )-        {-            _glfwInputChar( [characters characterAtIndex:i], GLFW_RELEASE );-        }-    }-}--- (void)scrollWheel:(NSEvent *)event-{-    _glfwInput.WheelPosFloating += [event deltaY];-    _glfwInput.WheelPos = lrint(_glfwInput.WheelPosFloating);--    if( _glfwWin.mouseWheelCallback )-    {-        _glfwWin.mouseWheelCallback( _glfwInput.WheelPos );-    }-}--@end--//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Here is where the window is created, and the OpenGL rendering context is-// created-//========================================================================--int  _glfwPlatformOpenWindow( int width, int height,-                              const _GLFWwndconfig *wndconfig,-                              const _GLFWfbconfig *fbconfig )-{-    int colorBits;--    _glfwWin.pixelFormat = nil;-    _glfwWin.window = nil;-    _glfwWin.context = nil;-    _glfwWin.delegate = nil;--#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070-    // Fail if OpenGL 3.3 or above was requested-    if( wndconfig->glMajor > 3 || wndconfig->glMajor == 3 && wndconfig->glMinor > 2 )-    {-        return GL_FALSE;-    }--    if( wndconfig->glProfile )-    {-        // Fail if a profile other than core was explicitly selected-        if( wndconfig->glProfile != GLFW_OPENGL_CORE_PROFILE )-        {-            return GL_FALSE;-        }-    }-#else-    // Fail if OpenGL 3.0 or above was requested-    if( wndconfig->glMajor > 2 )-    {-        return GL_FALSE;-    }-#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/--    _glfwWin.delegate = [[GLFWWindowDelegate alloc] init];-    if( _glfwWin.delegate == nil )-    {-        return GL_FALSE;-    }--    [NSApp setDelegate:_glfwWin.delegate];--    // Mac OS X needs non-zero color size, so set resonable values-    colorBits = fbconfig->redBits + fbconfig->greenBits + fbconfig->blueBits;-    if( colorBits == 0 )-    {-        colorBits = 24;-    }-    else if( colorBits < 15 )-    {-        colorBits = 15;-    }--    // Ignored hints:-    // OpenGLDebug-    //     pending it meaning anything on Mac OS X--    // Don't use accumulation buffer support; it's not accelerated-    // Aux buffers probably aren't accelerated either--    CFDictionaryRef fullscreenMode = NULL;-    if( wndconfig->mode == GLFW_FULLSCREEN )-    {-        fullscreenMode =-            // I think it's safe to pass 0 to the refresh rate for this function-            // rather than conditionalizing the code to call the version which-            // doesn't specify refresh...-            CGDisplayBestModeForParametersAndRefreshRateWithProperty(-            CGMainDisplayID(),-            colorBits + fbconfig->alphaBits,-            width,-            height,-            wndconfig->refreshRate,-            // Controversial, see macosx_fullscreen.m for discussion-            kCGDisplayModeIsSafeForHardware,-            NULL);--        width = [[(id)fullscreenMode objectForKey:(id)kCGDisplayWidth] intValue];-        height = [[(id)fullscreenMode objectForKey:(id)kCGDisplayHeight] intValue];-    }--    unsigned int styleMask = 0;-    if( wndconfig->mode == GLFW_WINDOW )-    {-        styleMask = NSTitledWindowMask | NSClosableWindowMask | NSMiniaturizableWindowMask;--        if( !wndconfig->windowNoResize )-        {-            styleMask |= NSResizableWindowMask;-        }-    }-    else-    {-        styleMask = NSBorderlessWindowMask;-    }--    _glfwWin.window = [[NSWindow alloc]-        initWithContentRect:NSMakeRect(0, 0, width, height)-                  styleMask:styleMask-                    backing:NSBackingStoreBuffered-                      defer:NO];-    [_glfwWin.window setContentView:[[GLFWContentView alloc] init]];-    [_glfwWin.window setDelegate:_glfwWin.delegate];-    [_glfwWin.window setAcceptsMouseMovedEvents:YES];-    [_glfwWin.window center];--    if( wndconfig->mode == GLFW_FULLSCREEN )-    {-        CGCaptureAllDisplays();-        CGDisplaySwitchToMode( CGMainDisplayID(), fullscreenMode );-    }--    unsigned int attribute_count = 0;-#define ADD_ATTR(x) attributes[attribute_count++] = x-#define ADD_ATTR2(x, y) (void)({ ADD_ATTR(x); ADD_ATTR(y); })-#define MAX_ATTRS 64 // urrgh-    NSOpenGLPixelFormatAttribute attributes[MAX_ATTRS];--    ADD_ATTR( NSOpenGLPFADoubleBuffer );--    if( wndconfig->mode == GLFW_FULLSCREEN )-    {-        ADD_ATTR( NSOpenGLPFAFullScreen );-        ADD_ATTR( NSOpenGLPFANoRecovery );-        ADD_ATTR2( NSOpenGLPFAScreenMask,-                   CGDisplayIDToOpenGLDisplayMask( CGMainDisplayID() ) );-    }--#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 );-    }--    ADD_ATTR(0);--    _glfwWin.pixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];-    if( _glfwWin.pixelFormat == nil )-    {-        return GL_FALSE;-    }--    _glfwWin.context = [[NSOpenGLContext alloc] initWithFormat:_glfwWin.pixelFormat-                                                  shareContext:nil];-    if( _glfwWin.context == nil )-    {-        return GL_FALSE;-    }--    [_glfwWin.window makeKeyAndOrderFront:nil];-    [_glfwWin.context setView:[_glfwWin.window contentView]];--    if( wndconfig->mode == GLFW_FULLSCREEN )-    {-        // TODO: Make this work on pre-Leopard systems-        [[_glfwWin.window contentView] enterFullScreenMode:[NSScreen mainScreen]-                                               withOptions:nil];-    }--    [_glfwWin.context makeCurrentContext];--    NSPoint point = [[NSCursor currentCursor] hotSpot];-    _glfwInput.MousePosX = point.x;-    _glfwInput.MousePosY = point.y;--    return GL_TRUE;-}--//========================================================================-// Properly kill the window / video display-//========================================================================--void _glfwPlatformCloseWindow( void )-{-    [_glfwWin.window orderOut:nil];--    if( _glfwWin.fullscreen )-    {-        [[_glfwWin.window contentView] exitFullScreenModeWithOptions:nil];-        CGDisplaySwitchToMode( CGMainDisplayID(),-                               (CFDictionaryRef)_glfwLibrary.DesktopMode );-        CGReleaseAllDisplays();-    }--    [_glfwWin.pixelFormat release];-    _glfwWin.pixelFormat = nil;--    [NSOpenGLContext clearCurrentContext];-    [_glfwWin.context release];-    _glfwWin.context = nil;--    [_glfwWin.window setDelegate:nil];-    [NSApp setDelegate:nil];-    [_glfwWin.delegate release];-    _glfwWin.delegate = nil;--    [_glfwWin.window close];-    _glfwWin.window = nil;--    // TODO: Probably more cleanup-}--//========================================================================-// Set the window title-//========================================================================--void _glfwPlatformSetWindowTitle( const char *title )-{-    [_glfwWin.window setTitle:[NSString stringWithCString:title-                     encoding:NSISOLatin1StringEncoding]];-}--//========================================================================-// Set the window size-//========================================================================--void _glfwPlatformSetWindowSize( int width, int height )-{-    [_glfwWin.window setContentSize:NSMakeSize(width, height)];-}--//========================================================================-// Set the window position-//========================================================================--void _glfwPlatformSetWindowPos( int x, int y )-{-    NSRect contentRect = [_glfwWin.window contentRectForFrameRect:[_glfwWin.window frame]];--    // We assume here that the client code wants to position the window within the-    // screen the window currently occupies-    NSRect screenRect = [[_glfwWin.window screen] visibleFrame];-    contentRect.origin = NSMakePoint(screenRect.origin.x + x,-                                     screenRect.origin.y + screenRect.size.height --                                         y - contentRect.size.height);--    [_glfwWin.window setFrame:[_glfwWin.window frameRectForContentRect:contentRect]-                      display:YES];-}--//========================================================================-// Iconify the window-//========================================================================--void _glfwPlatformIconifyWindow( void )-{-    [_glfwWin.window miniaturize:nil];-}--//========================================================================-// Restore (un-iconify) the window-//========================================================================--void _glfwPlatformRestoreWindow( void )-{-    [_glfwWin.window deminiaturize:nil];-}--//========================================================================-// Swap buffers-//========================================================================--void _glfwPlatformSwapBuffers( void )-{-    // ARP appears to be unnecessary, but this is future-proof-    [_glfwWin.context flushBuffer];-}--//========================================================================-// Set double buffering swap interval-//========================================================================--void _glfwPlatformSwapInterval( int interval )-{-    GLint sync = interval;-    [_glfwWin.context setValues:&sync forParameter:NSOpenGLCPSwapInterval];-}--//========================================================================-// Write back window parameters into GLFW window structure-//========================================================================--void _glfwPlatformRefreshWindowParams( void )-{-    GLint value;--    // Since GLFW 2.x doesn't understand screens, we use virtual screen zero--    [_glfwWin.pixelFormat getValues:&value-                       forAttribute:NSOpenGLPFAAccelerated-                   forVirtualScreen:0];-    _glfwWin.accelerated = value;--    [_glfwWin.pixelFormat getValues:&value-                       forAttribute:NSOpenGLPFAAlphaSize-                   forVirtualScreen:0];-    _glfwWin.alphaBits = value;--    // It seems that the color size includes the size of the alpha channel-    [_glfwWin.pixelFormat getValues:&value-                       forAttribute:NSOpenGLPFAColorSize-                   forVirtualScreen:0];-    value -= _glfwWin.alphaBits;-    _glfwWin.redBits = value / 3;-    _glfwWin.greenBits = value / 3;-    _glfwWin.blueBits = value / 3;--    [_glfwWin.pixelFormat getValues:&value-                       forAttribute:NSOpenGLPFADepthSize-                   forVirtualScreen:0];-    _glfwWin.depthBits = value;--    [_glfwWin.pixelFormat getValues:&value-                       forAttribute:NSOpenGLPFAStencilSize-                   forVirtualScreen:0];-    _glfwWin.stencilBits = value;--    [_glfwWin.pixelFormat getValues:&value-                       forAttribute:NSOpenGLPFAAccumSize-                   forVirtualScreen:0];-    _glfwWin.accumRedBits = value / 3;-    _glfwWin.accumGreenBits = value / 3;-    _glfwWin.accumBlueBits = value / 3;--    // TODO: Figure out what to set this value to-    _glfwWin.accumAlphaBits = 0;--    [_glfwWin.pixelFormat getValues:&value-                       forAttribute:NSOpenGLPFAAuxBuffers-                   forVirtualScreen:0];-    _glfwWin.auxBuffers = value;--    [_glfwWin.pixelFormat getValues:&value-                       forAttribute:NSOpenGLPFAStereo-                   forVirtualScreen:0];-    _glfwWin.stereo = value;--    [_glfwWin.pixelFormat getValues:&value-                       forAttribute:NSOpenGLPFASamples-                   forVirtualScreen:0];-    _glfwWin.samples = value;--    _glfwWin.glDebug = GL_FALSE;-}--//========================================================================-// Poll for new window and input events-//========================================================================--void _glfwPlatformPollEvents( void )-{-    NSEvent *event;--    do-    {-        event = [NSApp nextEventMatchingMask:NSAnyEventMask-                                   untilDate:[NSDate distantPast]-                                      inMode:NSDefaultRunLoopMode-                                     dequeue:YES];--        if (event)-        {-            [NSApp sendEvent:event];-        }-    }-    while (event);--    [_glfwLibrary.AutoreleasePool drain];-    _glfwLibrary.AutoreleasePool = [[NSAutoreleasePool alloc] init];-}--//========================================================================-// Wait for new window and input events-//========================================================================--void _glfwPlatformWaitEvents( void )-{-    // I wanted to pass NO to dequeue:, and rely on PollEvents to-    // dequeue and send.  For reasons not at all clear to me, passing-    // NO to dequeue: causes this method never to return.-    NSEvent *event = [NSApp nextEventMatchingMask:NSAnyEventMask-                                        untilDate:[NSDate distantFuture]-                                           inMode:NSDefaultRunLoopMode-                                          dequeue:YES];-    [NSApp sendEvent:event];--    _glfwPlatformPollEvents();-}--//========================================================================-// Hide mouse cursor (lock it)-//========================================================================--void _glfwPlatformHideMouseCursor( void )-{-    [NSCursor hide];-    CGAssociateMouseAndMouseCursorPosition( false );-}--//========================================================================-// Show mouse cursor (unlock it)-//========================================================================--void _glfwPlatformShowMouseCursor( void )-{-    [NSCursor unhide];-    CGAssociateMouseAndMouseCursorPosition( true );-}--//========================================================================-// Set physical mouse cursor position-//========================================================================--void _glfwPlatformSetMouseCursorPos( int x, int y )-{-    // The library seems to assume that after calling this the mouse won't move,-    // but obviously it will, and escape the app's window, and activate other apps,-    // and other badness in pain.  I think the API's just silly, but maybe I'm-    // misunderstanding it...--    // Also, (x, y) are window coords...--    // Also, it doesn't seem possible to write this robustly without-    // calculating the maximum y coordinate of all screens, since Cocoa's-    // "global coordinates" are upside down from CG's...--    // Without this (once per app run, but it's convenient to do it here)-    // events will be suppressed for a default of 0.25 seconds after we-    // move the cursor.-    CGSetLocalEventsSuppressionInterval( 0.0 );--    NSPoint localPoint = NSMakePoint( x, y );-    NSPoint globalPoint = [_glfwWin.window convertBaseToScreen:localPoint];-    CGPoint mainScreenOrigin = CGDisplayBounds( CGMainDisplayID() ).origin;-    double mainScreenHeight = CGDisplayBounds( CGMainDisplayID() ).size.height;-    CGPoint targetPoint = CGPointMake( globalPoint.x - mainScreenOrigin.x,-                                       mainScreenHeight - globalPoint.y - mainScreenOrigin.y );-    CGDisplayMoveCursorToPoint( CGMainDisplayID(), targetPoint );-}-
− glfw/lib/cocoa/platform.h 
@@ -1,252 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Cocoa/NSOpenGL-// API Version: 2.7-// WWW:         http://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 _platform_h_-#define _platform_h_---// This is the Mac OS X version of GLFW-#define _GLFW_MAC_OS_X--#if defined(__OBJC__)-#import <Cocoa/Cocoa.h>-#else-typedef void *id;-#endif--#include <pthread.h>--#include "../../include/GL/glfw.h"---#ifndef GL_VERSION_3_0--typedef const GLubyte * (APIENTRY *PFNGLGETSTRINGIPROC) (GLenum, GLuint);--#endif /*GL_VERSION_3_0*/---//========================================================================-// GLFW platform specific types-//========================================================================--//-------------------------------------------------------------------------// Pointer length integer-//-------------------------------------------------------------------------typedef intptr_t GLFWintptr;--//-------------------------------------------------------------------------// Window structure-//-------------------------------------------------------------------------typedef struct _GLFWwin_struct _GLFWwin;--struct _GLFWwin_struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // User callback functions-    GLFWwindowsizefun    windowSizeCallback;-    GLFWwindowclosefun   windowCloseCallback;-    GLFWwindowrefreshfun windowRefreshCallback;-    GLFWmousebuttonfun   mouseButtonCallback;-    GLFWmouseposfun      mousePosCallback;-    GLFWmousewheelfun    mouseWheelCallback;-    GLFWkeyfun           keyCallback;-    GLFWcharfun          charCallback;--    // User selected window settings-    int       fullscreen;      // Fullscreen flag-    int       mouseLock;       // Mouse-lock flag-    int       autoPollEvents;  // Auto polling flag-    int       sysKeysDisabled; // System keys disabled flag-    int       windowNoResize;  // Resize- and maximize gadgets disabled flag-    int       refreshRate;     // Vertical monitor refresh rate--    // Window status & parameters-    int       opened;          // Flag telling if window is opened or not-    int       active;          // Application active flag-    int       iconified;       // Window iconified flag-    int       width, height;   // Window width and heigth-    int       accelerated;     // GL_TRUE if window is HW accelerated--    // Framebuffer attributes-    int       redBits;-    int       greenBits;-    int       blueBits;-    int       alphaBits;-    int       depthBits;-    int       stencilBits;-    int       accumRedBits;-    int       accumGreenBits;-    int       accumBlueBits;-    int       accumAlphaBits;-    int       auxBuffers;-    int       stereo;-    int       samples;--    // OpenGL extensions and context attributes-    int       has_GL_SGIS_generate_mipmap;-    int       has_GL_ARB_texture_non_power_of_two;-    int       glMajor, glMinor, glRevision;-    int       glForward, glDebug, glProfile;--    PFNGLGETSTRINGIPROC GetStringi;--// ========= PLATFORM SPECIFIC PART ======================================--    id        window;-    id        pixelFormat;-    id	      context;-    id	      delegate;-    unsigned int modifierFlags;-};--GLFWGLOBAL _GLFWwin _glfwWin;---//-------------------------------------------------------------------------// Library global data-//-------------------------------------------------------------------------GLFWGLOBAL struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // Window opening hints-    _GLFWhints      hints;--// ========= PLATFORM SPECIFIC PART ======================================--    // Timer data-    struct {-        double t0;-    } Timer;--    // dlopen handle for dynamically-loading extension function pointers-    void *OpenGLFramework;--    int Unbundled;--    id DesktopMode;--    id AutoreleasePool;--} _glfwLibrary;---//-------------------------------------------------------------------------// User input status (some of this should go in _GLFWwin)-//-------------------------------------------------------------------------GLFWGLOBAL struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // Mouse status-    int  MousePosX, MousePosY;-    int  WheelPos;-    char MouseButton[ GLFW_MOUSE_BUTTON_LAST+1 ];--    // Keyboard status-    char Key[ GLFW_KEY_LAST+1 ];-    int  LastChar;--    // User selected settings-    int  StickyKeys;-    int  StickyMouseButtons;-    int  KeyRepeat;---// ========= PLATFORM SPECIFIC PART ======================================--    double WheelPosFloating;--} _glfwInput;--//-------------------------------------------------------------------------// Thread information-//-------------------------------------------------------------------------typedef struct _GLFWthread_struct _GLFWthread;--// Thread record (one for each thread)-struct _GLFWthread_struct {--    // Pointer to previous and next threads in linked list-    _GLFWthread   *Previous, *Next;--    // GLFW user side thread information-    GLFWthread    ID;-    GLFWthreadfun Function;--    // System side thread information-    pthread_t     PosixID;-};--// General thread information-GLFWGLOBAL struct {--    // Critical section lock-    pthread_mutex_t  CriticalSection;--    // Next thread ID to use (increments for every created thread)-    GLFWthread       NextID;--    // First thread in linked list (always the main thread)-    _GLFWthread      First;--} _glfwThrd;---//========================================================================-// Macros for encapsulating critical code sections (i.e. making parts-// of GLFW thread safe)-//========================================================================--// Define so we can use the same thread code as X11-#define _glfw_numprocessors(n) { \-    int mib[2], ncpu; \-    size_t len = 1; \-    mib[0] = CTL_HW; \-    mib[1] = HW_NCPU; \-    n      = 1; \-    if( sysctl( mib, 2, &ncpu, &len, NULL, 0 ) != -1 ) \-    { \-        if( len > 0 ) \-        { \-            n = ncpu; \-        } \-    } \-}--// Thread list management-#define ENTER_THREAD_CRITICAL_SECTION \-pthread_mutex_lock( &_glfwThrd.CriticalSection );-#define LEAVE_THREAD_CRITICAL_SECTION \-pthread_mutex_unlock( &_glfwThrd.CriticalSection );---#endif // _platform_h_
− glfw/lib/enable.c 
@@ -1,310 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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 internal functions                       ****-//************************************************************************--//========================================================================-// Enable (show) mouse cursor-//========================================================================--static void enableMouseCursor( void )-{-    int centerPosX, centerPosY;--    if( !_glfwWin.opened || !_glfwWin.mouseLock )-    {-        return;-    }--    // Show mouse cursor-    _glfwPlatformShowMouseCursor();--    centerPosX = _glfwWin.width / 2;-    centerPosY = _glfwWin.height / 2;--    if( centerPosX != _glfwInput.MousePosX || centerPosY != _glfwInput.MousePosY )-    {-        _glfwPlatformSetMouseCursorPos( centerPosX, centerPosY );--        _glfwInput.MousePosX = centerPosX;-        _glfwInput.MousePosY = centerPosY;--        if( _glfwWin.mousePosCallback )-        {-            _glfwWin.mousePosCallback( _glfwInput.MousePosX,-                                       _glfwInput.MousePosY );-        }-    }--    // From now on the mouse is unlocked-    _glfwWin.mouseLock = GL_FALSE;-}--//========================================================================-// Disable (hide) mouse cursor-//========================================================================--static void disableMouseCursor( void )-{-    if( !_glfwWin.opened || _glfwWin.mouseLock )-    {-        return;-    }--    // Hide mouse cursor-    _glfwPlatformHideMouseCursor();--    // Move cursor to the middle of the window-    _glfwPlatformSetMouseCursorPos( _glfwWin.width >> 1,-                                    _glfwWin.height >> 1 );--    // From now on the mouse is locked-    _glfwWin.mouseLock = GL_TRUE;-}---//========================================================================-// Enable sticky keys-//========================================================================--static void enableStickyKeys( void )-{-    _glfwInput.StickyKeys = 1;-}--//========================================================================-// Disable sticky keys-//========================================================================--static void disableStickyKeys( void )-{-    int i;--    _glfwInput.StickyKeys = 0;--    // Release all sticky keys-    for( i = 0; i <= GLFW_KEY_LAST; i++ )-    {-        if( _glfwInput.Key[ i ] == 2 )-        {-            _glfwInput.Key[ i ] = 0;-        }-    }-}---//========================================================================-// Enable sticky mouse buttons-//========================================================================--static void enableStickyMouseButtons( void )-{-    _glfwInput.StickyMouseButtons = 1;-}--//========================================================================-// Disable sticky mouse buttons-//========================================================================--static void disableStickyMouseButtons( void )-{-    int i;--    _glfwInput.StickyMouseButtons = 0;--    // Release all sticky mouse buttons-    for( i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i++ )-    {-        if( _glfwInput.MouseButton[ i ] == 2 )-        {-            _glfwInput.MouseButton[ i ] = 0;-        }-    }-}---//========================================================================-// Enable system keys-//========================================================================--static void enableSystemKeys( void )-{-    if( !_glfwWin.sysKeysDisabled )-    {-        return;-    }--    _glfwPlatformEnableSystemKeys();--    // Indicate that system keys are no longer disabled-    _glfwWin.sysKeysDisabled = GL_FALSE;-}--//========================================================================-// Disable system keys-//========================================================================--static void disableSystemKeys( void )-{-    if( _glfwWin.sysKeysDisabled )-    {-        return;-    }--    _glfwPlatformDisableSystemKeys();--    // Indicate that system keys are now disabled-    _glfwWin.sysKeysDisabled = GL_TRUE;-}---//========================================================================-// Enable key repeat-//========================================================================--static void enableKeyRepeat( void )-{-    _glfwInput.KeyRepeat = 1;-}--//========================================================================-// Disable key repeat-//========================================================================--static void disableKeyRepeat( void )-{-    _glfwInput.KeyRepeat = 0;-}---//========================================================================-// Enable automatic event polling-//========================================================================--static void enableAutoPollEvents( void )-{-    _glfwWin.autoPollEvents = 1;-}--//========================================================================-// Disable automatic event polling-//========================================================================--static void disableAutoPollEvents( void )-{-    _glfwWin.autoPollEvents = 0;-}----//************************************************************************-//****                    GLFW user functions                         ****-//************************************************************************--//========================================================================-// Enable certain GLFW/window/system functions.-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwEnable( int token )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return;-    }--    switch( token )-    {-        case GLFW_MOUSE_CURSOR:-            enableMouseCursor();-            break;-        case GLFW_STICKY_KEYS:-            enableStickyKeys();-            break;-        case GLFW_STICKY_MOUSE_BUTTONS:-            enableStickyMouseButtons();-            break;-        case GLFW_SYSTEM_KEYS:-            enableSystemKeys();-            break;-        case GLFW_KEY_REPEAT:-            enableKeyRepeat();-            break;-        case GLFW_AUTO_POLL_EVENTS:-            enableAutoPollEvents();-            break;-        default:-            break;-    }-}---//========================================================================-// Disable certain GLFW/window/system functions.-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwDisable( int token )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return;-    }--    switch( token )-    {-        case GLFW_MOUSE_CURSOR:-            disableMouseCursor();-            break;-        case GLFW_STICKY_KEYS:-            disableStickyKeys();-            break;-        case GLFW_STICKY_MOUSE_BUTTONS:-            disableStickyMouseButtons();-            break;-        case GLFW_SYSTEM_KEYS:-            disableSystemKeys();-            break;-        case GLFW_KEY_REPEAT:-            disableKeyRepeat();-            break;-        case GLFW_AUTO_POLL_EVENTS:-            disableAutoPollEvents();-            break;-        default:-            break;-    }-}-
− glfw/lib/fullscreen.c 
@@ -1,94 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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 user functions                         ****-//************************************************************************--//========================================================================-// Get a list of available video modes-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwGetVideoModes( GLFWvidmode *list, int maxcount )-{-    int         count, i, swap, res1, res2, depth1, depth2;-    GLFWvidmode vm;--    if( !_glfwInitialized || maxcount <= 0 || list == (GLFWvidmode*) 0 )-    {-        return 0;-    }--    // Get list of video modes-    count = _glfwPlatformGetVideoModes( list, maxcount );--    // Sort list (bubble sort)-    do-    {-        swap = 0;-        for( i = 0; i < count-1; ++ i )-        {-            res1   = list[i].Width*list[i].Height;-            depth1 = list[i].RedBits+list[i].GreenBits+list[i].BlueBits;-            res2   = list[i+1].Width*list[i+1].Height;-            depth2 = list[i+1].RedBits+list[i+1].GreenBits+-                     list[i+1].BlueBits;-            if( (depth2<depth1) || ((depth2==depth1) && (res2<res1)) )-            {-                vm = list[i];-                list[i] = list[i+1];-                list[i+1] = vm;-                swap = 1;-            }-        }-    }-    while( swap );--    return count;-}---//========================================================================-// Get the desktop video mode-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwGetDesktopMode( GLFWvidmode *mode )-{-    if( !_glfwInitialized || mode == (GLFWvidmode*) 0 )-    {-        return;-    }--    _glfwPlatformGetDesktopMode( mode );-}-
− glfw/lib/glext.c 
@@ -1,283 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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 internal functions                       ****-//************************************************************************--#ifndef GL_VERSION_3_0-#define GL_NUM_EXTENSIONS                 0x821D-#define GL_CONTEXT_FLAGS                  0x821E-#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x0001-#endif--#ifndef GL_VERSION_3_2-#define GL_CONTEXT_CORE_PROFILE_BIT       0x00000001-#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002-#define GL_CONTEXT_PROFILE_MASK           0x9126-#endif--//========================================================================-// Parses the OpenGL version string and extracts the version number-//========================================================================--void _glfwParseGLVersion( int *major, int *minor, int *rev )-{-    GLuint _major, _minor = 0, _rev = 0;-    const GLubyte *version;-    const GLubyte *ptr;--    // Get OpenGL version string-    version = glGetString( GL_VERSION );-    if( !version )-    {-        return;-    }--    // Parse string-    ptr = version;-    for( _major = 0; *ptr >= '0' && *ptr <= '9'; ptr ++ )-    {-        _major = 10*_major + (*ptr - '0');-    }-    if( *ptr == '.' )-    {-        ptr ++;-        for( _minor = 0; *ptr >= '0' && *ptr <= '9'; ptr ++ )-        {-            _minor = 10*_minor + (*ptr - '0');-        }-        if( *ptr == '.' )-        {-            ptr ++;-            for( _rev = 0; *ptr >= '0' && *ptr <= '9'; ptr ++ )-            {-                _rev = 10*_rev + (*ptr - '0');-            }-        }-    }--    // Return parsed values-    *major = _major;-    *minor = _minor;-    *rev = _rev;-}--//========================================================================-// Check if a string can be found in an OpenGL extension string-//========================================================================--int _glfwStringInExtensionString( const char *string,-                                  const GLubyte *extensions )-{-    const GLubyte *start;-    GLubyte *where, *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;-    while( 1 )-    {-        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;-}---//========================================================================-// Reads back OpenGL context properties from the current context-//========================================================================--void _glfwRefreshContextParams( void )-{-    _glfwParseGLVersion( &_glfwWin.glMajor, &_glfwWin.glMinor,-                         &_glfwWin.glRevision );--    _glfwWin.glProfile = 0;-    _glfwWin.glForward = GL_FALSE;--    // Read back the context profile, if applicable-    if( _glfwWin.glMajor >= 3 )-    {-        GLint flags;-        glGetIntegerv( GL_CONTEXT_FLAGS, &flags );--        if( flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT )-        {-            _glfwWin.glForward = GL_TRUE;-        }-    }--    if( _glfwWin.glMajor > 3 ||-        ( _glfwWin.glMajor == 3 && _glfwWin.glMinor >= 2 ) )-    {-        GLint mask;-        glGetIntegerv( GL_CONTEXT_PROFILE_MASK, &mask );--        if( mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT )-        {-            _glfwWin.glProfile = GLFW_OPENGL_COMPAT_PROFILE;-        }-        else if( mask & GL_CONTEXT_CORE_PROFILE_BIT )-        {-            _glfwWin.glProfile = GLFW_OPENGL_CORE_PROFILE;-        }-    }-}---//************************************************************************-//****                    GLFW user functions                         ****-//************************************************************************--//========================================================================-// Check if an OpenGL extension is available at runtime-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwExtensionSupported( const char *extension )-{-    const GLubyte *extensions;-    GLubyte *where;-    GLint count;-    int i;--    // Is GLFW initialized?-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return GL_FALSE;-    }--    // Extension names should not have spaces-    where = (GLubyte *) strchr( extension, ' ' );-    if( where || *extension == '\0' )-    {-        return GL_FALSE;-    }--    if( _glfwWin.glMajor < 3 )-    {-        // Check if extension is in the old style OpenGL extensions string--        extensions = glGetString( GL_EXTENSIONS );-        if( extensions != NULL )-        {-            if( _glfwStringInExtensionString( extension, extensions ) )-            {-                return GL_TRUE;-            }-        }-    }-    else-    {-        // Check if extension is in the modern OpenGL extensions string list--        glGetIntegerv( GL_NUM_EXTENSIONS, &count );--        for( i = 0;  i < count;  i++ )-        {-             if( strcmp( (const char*) _glfwWin.GetStringi( GL_EXTENSIONS, i ),-                         extension ) == 0 )-             {-                 return GL_TRUE;-             }-        }-    }--    // Additional platform specific extension checking (e.g. WGL)-    if( _glfwPlatformExtensionSupported( extension ) )-    {-        return GL_TRUE;-    }--    return GL_FALSE;-}---//========================================================================-// Get the function pointer to an OpenGL function.  This function can be-// used to get access to extended OpenGL functions.-//========================================================================--GLFWAPI void * GLFWAPIENTRY glfwGetProcAddress( const char *procname )-{-    // Is GLFW initialized?-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return NULL;-    }--    return _glfwPlatformGetProcAddress( procname );-}---//========================================================================-// Returns the OpenGL version-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwGetGLVersion( int *major, int *minor, int *rev )-{-    // Is GLFW initialized?-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    if( major != NULL )-    {-        *major = _glfwWin.glMajor;-    }-    if( minor != NULL )-    {-        *minor = _glfwWin.glMinor;-    }-    if( rev != NULL )-    {-        *rev = _glfwWin.glRevision;-    }-}-
− glfw/lib/image.c 
@@ -1,629 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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.-//-//========================================================================--//========================================================================-// Description:-//-// This module acts as an interface for different image file formats (the-// image file format is detected automatically).-//-// By default the loaded image is rescaled (using bilinear interpolation)-// to the next higher 2^N x 2^M resolution, unless it has a valid-// 2^N x 2^M resolution. The interpolation is quite slow, even if the-// routine has been optimized for speed (a 200x200 RGB image is scaled to-// 256x256 in ~30 ms on a P3-500).-//-// Paletted images are converted to RGB/RGBA images.-//-// A convenience function is also included (glfwLoadTexture2D), which-// loads a texture image from a file directly to OpenGL texture memory,-// with an option to generate all mipmap levels. GL_SGIS_generate_mipmap-// is used whenever available, which should give an optimal mipmap-// generation speed (possibly performed in hardware). A software fallback-// method is included when GL_SGIS_generate_mipmap is not supported (it-// generates all mipmaps of a 256x256 RGB texture in ~3 ms on a P3-500).-//-//========================================================================---#include "internal.h"---// We want to support automatic mipmap generation-#ifndef GL_SGIS_generate_mipmap- #define GL_GENERATE_MIPMAP_SGIS       0x8191- #define GL_GENERATE_MIPMAP_HINT_SGIS  0x8192- #define GL_SGIS_generate_mipmap    1-#endif // GL_SGIS_generate_mipmap---//************************************************************************-//****                  GLFW internal functions                       ****-//************************************************************************--//========================================================================-// Upsample image, from size w1 x h1 to w2 x h2-//========================================================================--static void UpsampleImage( unsigned char *src, unsigned char *dst,-    int w1, int h1, int w2, int h2, int bpp )-{-    int m, n, k, x, y, col8;-    float dx, dy, xstep, ystep, col, col1, col2;-    unsigned char *src1, *src2, *src3, *src4;--    // Calculate scaling factor-    xstep = (float)(w1-1) / (float)(w2-1);-    ystep = (float)(h1-1) / (float)(h2-1);--    // Copy source data to destination data with bilinear interpolation-    // Note: The rather strange look of this routine is a direct result of-    // my attempts at optimizing it. Improvements are welcome!-    dy = 0.0f;-    y = 0;-    for( n = 0; n < h2; n ++ )-    {-        dx = 0.0f;-        src1 = &src[ y*w1*bpp ];-        src3 = y < (h1-1) ? src1 + w1*bpp : src1;-        src2 = src1 + bpp;-        src4 = src3 + bpp;-        x = 0;-        for( m = 0; m < w2; m ++ )-        {-            for( k = 0; k < bpp; k ++ )-            {-                col1 = *src1 ++;-                col2 = *src2 ++;-                col = col1 + (col2 - col1) * dx;-                col1 = *src3 ++;-                col2 = *src4 ++;-                col2 = col1 + (col2 - col1) * dx;-                col += (col2 - col) * dy;-                col8 = (int) (col + 0.5);-                if( col8 >= 256 ) col8 = 255;-                *dst++ = (unsigned char) col8;-            }-            dx += xstep;-            if( dx >= 1.0f )-            {-                x ++;-                dx -= 1.0f;-                if( x >= (w1-1) )-                {-                    src2 = src1;-                    src4 = src3;-                }-            }-            else-            {-                src1 -= bpp;-                src2 -= bpp;-                src3 -= bpp;-                src4 -= bpp;-            }-        }-        dy += ystep;-        if( dy >= 1.0f )-        {-            y ++;-            dy -= 1.0f;-        }-    }-}---//========================================================================-// Build the next mip-map level-//========================================================================--static int HalveImage( GLubyte *src, int *width, int *height,-    int components )-{-    int     halfwidth, halfheight, m, n, k, idx1, idx2;-    GLubyte *dst;--    // Last level?-    if( *width <= 1 && *height <= 1 )-    {-        return GL_FALSE;-    }--    // Calculate new width and height (handle 1D case)-    halfwidth  = *width > 1 ? *width / 2 : 1;-    halfheight = *height > 1 ? *height / 2 : 1;--    // Downsample image with a simple box-filter-    dst = src;-    if( *width == 1 || *height == 1 )-    {-        // 1D case-        for( m = 0; m < halfwidth+halfheight-1; m ++ )-        {-            for( k = 0; k < components; k ++ )-            {-                *dst ++ = (GLubyte) (((int)*src +-                                      (int)src[components] + 1) >> 1);-                src ++;-            }-            src += components;-        }-    }-    else-    {-        // 2D case-        idx1 = *width*components;-        idx2 = (*width+1)*components;-        for( m = 0; m < halfheight; m ++ )-        {-            for( n = 0; n < halfwidth; n ++ )-            {-                for( k = 0; k < components; k ++ )-                {-                    *dst ++ = (GLubyte) (((int)*src +-                                          (int)src[components] +-                                          (int)src[idx1] +-                                          (int)src[idx2] + 2) >> 2);-                    src ++;-                }-                src += components;-            }-            src += components * (*width);-        }-    }--    // Return new width and height-    *width = halfwidth;-    *height = halfheight;--    return GL_TRUE;-}---//========================================================================-// Rescales an image into power-of-two dimensions-//========================================================================--static int RescaleImage( GLFWimage* image )-{-    int     width, height, log2, newsize;-    unsigned char *data;--    // Calculate next larger 2^N width-    for( log2 = 0, width = image->Width; width > 1; width >>= 1, log2 ++ )-      ;--    width  = (int) 1 << log2;-    if( width < image->Width )-    {-        width <<= 1;-    }--    // Calculate next larger 2^M height-    for( log2 = 0, height = image->Height; height > 1; height >>= 1, log2 ++ )-      ;--    height = (int) 1 << log2;-    if( height < image->Height )-    {-        height <<= 1;-    }--    // Do we really need to rescale?-    if( width != image->Width || height != image->Height )-    {-        // Allocate memory for new (upsampled) image data-        newsize = width * height * image->BytesPerPixel;-        data = (unsigned char *) malloc( newsize );-        if( data == NULL )-        {-            free( image->Data );-            return GL_FALSE;-        }--        // Copy old image data to new image data with interpolation-        UpsampleImage( image->Data, data, image->Width, image->Height,-                       width, height, image->BytesPerPixel );--        // Free memory for old image data (not needed anymore)-        free( image->Data );--        // Set pointer to new image data, and set new image dimensions-        image->Data   = data;-        image->Width  = width;-        image->Height = height;-    }--    return GL_TRUE;-}---//************************************************************************-//****                    GLFW user functions                         ****-//************************************************************************--//========================================================================-// Read an image from a named file-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwReadImage( const char *name, GLFWimage *img,-    int flags )-{-    _GLFWstream stream;--    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return GL_FALSE;-    }--    // Start with an empty image descriptor-    img->Width         = 0;-    img->Height        = 0;-    img->BytesPerPixel = 0;-    img->Data          = NULL;--    // Open file-    if( !_glfwOpenFileStream( &stream, name, "rb" ) )-    {-        return GL_FALSE;-    }--    // We only support TGA files at the moment-    if( !_glfwReadTGA( &stream, img, flags ) )-    {-        _glfwCloseStream( &stream );-        return GL_FALSE;-    }--    // Close stream-    _glfwCloseStream( &stream );--    // Should we rescale the image to closest 2^N x 2^M resolution?-    if( !(flags & GLFW_NO_RESCALE_BIT) )-    {-        if( !RescaleImage( img ) )-        {-            return GL_FALSE;-        }-    }--    // Interpret BytesPerPixel as an OpenGL format-    switch( img->BytesPerPixel )-    {-        default:-        case 1:-            if( flags & GLFW_ALPHA_MAP_BIT )-            {-                img->Format = GL_ALPHA;-            }-            else-            {-                img->Format = GL_LUMINANCE;-            }-            break;-        case 3:-            img->Format = GL_RGB;-            break;-        case 4:-            img->Format = GL_RGBA;-            break;-    }--    return GL_TRUE;-}---//========================================================================-// Read an image file from a memory buffer-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwReadMemoryImage( const void *data, long size, GLFWimage *img, int flags )-{-    _GLFWstream stream;--    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return GL_FALSE;-    }--    // Start with an empty image descriptor-    img->Width         = 0;-    img->Height        = 0;-    img->BytesPerPixel = 0;-    img->Data          = NULL;--    // Open buffer-    if( !_glfwOpenBufferStream( &stream, (void*) data, size ) )-    {-        return GL_FALSE;-    }--    // We only support TGA files at the moment-    if( !_glfwReadTGA( &stream, img, flags ) )-    {-        _glfwCloseStream( &stream );-        return GL_FALSE;-    }--    // Close stream-    _glfwCloseStream( &stream );--    // Should we rescale the image to closest 2^N x 2^M resolution?-    if( !(flags & GLFW_NO_RESCALE_BIT) )-    {-        if( !RescaleImage( img ) )-        {-            return GL_FALSE;-        }-    }--    // Interpret BytesPerPixel as an OpenGL format-    switch( img->BytesPerPixel )-    {-        default:-        case 1:-            if( flags & GLFW_ALPHA_MAP_BIT )-            {-                img->Format = GL_ALPHA;-            }-            else-            {-                img->Format = GL_LUMINANCE;-            }-            break;-        case 3:-            img->Format = GL_RGB;-            break;-        case 4:-            img->Format = GL_RGBA;-            break;-    }--    return GL_TRUE;-}---//========================================================================-// Free allocated memory for an image-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwFreeImage( GLFWimage *img )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return;-    }--    // Free memory-    if( img->Data != NULL )-    {-        free( img->Data );-        img->Data = NULL;-    }--    // Clear all fields-    img->Width         = 0;-    img->Height        = 0;-    img->Format        = 0;-    img->BytesPerPixel = 0;-}---//========================================================================-// Read an image from a file, and upload it to texture memory-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwLoadTexture2D( const char *name, int flags )-{-    GLFWimage img;--    // Is GLFW initialized?-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return GL_FALSE;-    }--    // Force rescaling if necessary-    if( !_glfwWin.has_GL_ARB_texture_non_power_of_two )-    {-        flags &= (~GLFW_NO_RESCALE_BIT);-    }--    // Read image from file-    if( !glfwReadImage( name, &img, flags ) )-    {-        return GL_FALSE;-    }--    if( !glfwLoadTextureImage2D( &img, flags ) )-    {-        return GL_FALSE;-    }--    // Data buffer is not needed anymore-    glfwFreeImage( &img );--    return GL_TRUE;-}---//========================================================================-// Read an image from a buffer, and upload it to texture memory-//========================================================================--GLFWAPI int  GLFWAPIENTRY glfwLoadMemoryTexture2D( const void *data, long size, int flags )-{-    GLFWimage img;--    // Is GLFW initialized?-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return GL_FALSE;-    }--    // Force rescaling if necessary-    if( !_glfwWin.has_GL_ARB_texture_non_power_of_two )-    {-        flags &= (~GLFW_NO_RESCALE_BIT);-    }--    // Read image from file-    if( !glfwReadMemoryImage( data, size, &img, flags ) )-    {-        return GL_FALSE;-    }--    if( !glfwLoadTextureImage2D( &img, flags ) )-    {-        return GL_FALSE;-    }--    // Data buffer is not needed anymore-    glfwFreeImage( &img );--    return GL_TRUE;-}---//========================================================================-// Upload an image object to texture memory-//========================================================================--GLFWAPI int  GLFWAPIENTRY glfwLoadTextureImage2D( GLFWimage *img, int flags )-{-    GLint   UnpackAlignment, GenMipMap;-    int     level, format, AutoGen, newsize, n;-    unsigned char *data, *dataptr;--    // Is GLFW initialized?-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return GL_FALSE;-    }--    // TODO: Use GL_MAX_TEXTURE_SIZE or GL_PROXY_TEXTURE_2D to determine-    //       whether the image size is valid.-    // NOTE: May require box filter downsampling routine.--    // Do we need to convert the alpha map to RGBA format (OpenGL 1.0)?-    if( (_glfwWin.glMajor == 1) && (_glfwWin.glMinor == 0) &&-        (img->Format == GL_ALPHA) )-    {-        // We go to RGBA representation instead-        img->BytesPerPixel = 4;--        // Allocate memory for new RGBA image data-        newsize = img->Width * img->Height * img->BytesPerPixel;-        data = (unsigned char *) malloc( newsize );-        if( data == NULL )-        {-            free( img->Data );-            return GL_FALSE;-        }--        // Convert Alpha map to RGBA-        dataptr = data;-        for( n = 0; n < (img->Width*img->Height); ++ n )-        {-            *dataptr ++ = 255;-            *dataptr ++ = 255;-            *dataptr ++ = 255;-            *dataptr ++ = img->Data[n];-        }--        // Free memory for old image data (not needed anymore)-        free( img->Data );--        // Set pointer to new image data-        img->Data = data;-    }--    // Set unpack alignment to one byte-    glGetIntegerv( GL_UNPACK_ALIGNMENT, &UnpackAlignment );-    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );--    // Should we use automatic mipmap generation?-    AutoGen = ( flags & GLFW_BUILD_MIPMAPS_BIT ) &&-              _glfwWin.has_GL_SGIS_generate_mipmap;--    // Enable automatic mipmap generation-    if( AutoGen )-    {-        glGetTexParameteriv( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS,-            &GenMipMap );-        glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS,-            GL_TRUE );-    }--    // Format specification is different for OpenGL 1.0-    if( _glfwWin.glMajor == 1 && _glfwWin.glMinor == 0 )-    {-        format = img->BytesPerPixel;-    }-    else-    {-        format = img->Format;-    }--    // Upload to texture memeory-    level = 0;-    do-    {-        // Upload this mipmap level-        glTexImage2D( GL_TEXTURE_2D, level, format,-            img->Width, img->Height, 0, format,-            GL_UNSIGNED_BYTE, (void*) img->Data );--        // Build next mipmap level manually, if required-        if( ( flags & GLFW_BUILD_MIPMAPS_BIT ) && !AutoGen )-        {-            level = HalveImage( img->Data, &img->Width,-                        &img->Height, img->BytesPerPixel ) ?-                    level + 1 : 0;-        }-    }-    while( level != 0 );--    // Restore old automatic mipmap generation state-    if( AutoGen )-    {-        glTexParameteri( GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS,-            GenMipMap );-    }--    // Restore old unpack alignment-    glPixelStorei( GL_UNPACK_ALIGNMENT, UnpackAlignment );--    return GL_TRUE;-}-
− glfw/lib/init.c 
@@ -1,110 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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.-//-//========================================================================--#define _init_c_-#include "internal.h"---//************************************************************************-//****                    GLFW user functions                         ****-//************************************************************************--//========================================================================-// Initialize various GLFW state-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwInit( void )-{-    // Is GLFW already initialized?-    if( _glfwInitialized )-    {-        return GL_TRUE;-    }--    memset( &_glfwLibrary, 0, sizeof( _glfwLibrary ) );-    memset( &_glfwWin, 0, sizeof( _glfwWin ) );--    // Window is not yet opened-    _glfwWin.opened = GL_FALSE;--    // Default enable/disable settings-    _glfwWin.sysKeysDisabled = GL_FALSE;--    // Clear window hints-    _glfwClearWindowHints();--    // Platform specific initialization-    if( !_glfwPlatformInit() )-    {-        return GL_FALSE;-    }--    // Form now on, GLFW state is valid-    _glfwInitialized = GL_TRUE;--    return GL_TRUE;-}----//========================================================================-// Close window and kill all threads.-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwTerminate( void )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return;-    }--    // Platform specific termination-    if( !_glfwPlatformTerminate() )-    {-        return;-    }--    // GLFW is no longer initialized-    _glfwInitialized = GL_FALSE;-}---//========================================================================-// Get GLFW version-//========================================================================--GLFWAPI void GLFWAPIENTRY 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;-}-
− glfw/lib/input.c 
@@ -1,269 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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 key state-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwGetKey( int key )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return GLFW_RELEASE;-    }--    // Is it a valid key?-    if( key < 0 || key > GLFW_KEY_LAST )-    {-        return GLFW_RELEASE;-    }--    if( _glfwInput.Key[ key ] == GLFW_STICK )-    {-        // Sticky mode: release key now-        _glfwInput.Key[ key ] = GLFW_RELEASE;-        return GLFW_PRESS;-    }--    return (int) _glfwInput.Key[ key ];-}---//========================================================================-// Return mouse button state-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwGetMouseButton( int button )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return GLFW_RELEASE;-    }--    // Is it a valid mouse button?-    if( button < 0 || button > GLFW_MOUSE_BUTTON_LAST )-    {-        return GLFW_RELEASE;-    }--    if( _glfwInput.MouseButton[ button ] == GLFW_STICK )-    {-        // Sticky mode: release mouse button now-        _glfwInput.MouseButton[ button ] = GLFW_RELEASE;-        return GLFW_PRESS;-    }--    return (int) _glfwInput.MouseButton[ button ];-}---//========================================================================-// Return mouse cursor position-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwGetMousePos( int *xpos, int *ypos )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Return mouse position-    if( xpos != NULL )-    {-        *xpos = _glfwInput.MousePosX;-    }-    if( ypos != NULL )-    {-        *ypos = _glfwInput.MousePosY;-    }-}---//========================================================================-// Sets the mouse cursor position-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetMousePos( int xpos, int ypos )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Don't do anything if the mouse position did not change-    if( xpos == _glfwInput.MousePosX && ypos == _glfwInput.MousePosY )-    {-        return;-    }--    // Set GLFW mouse position-    _glfwInput.MousePosX = xpos;-    _glfwInput.MousePosY = ypos;--    // If we have a locked mouse, do not change cursor position-    if( _glfwWin.mouseLock )-    {-        return;-    }--    // Update physical cursor position-    _glfwPlatformSetMouseCursorPos( xpos, ypos );-}---//========================================================================-// Return mouse wheel position-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwGetMouseWheel( void )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return 0;-    }--    // Return mouse wheel position-    return _glfwInput.WheelPos;-}---//========================================================================-// Set mouse wheel position-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetMouseWheel( int pos )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Set mouse wheel position-    _glfwInput.WheelPos = pos;-}---//========================================================================-// Set callback function for keyboard input-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetKeyCallback( GLFWkeyfun cbfun )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Set callback function-    _glfwWin.keyCallback = cbfun;-}---//========================================================================-// Set callback function for character input-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetCharCallback( GLFWcharfun cbfun )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Set callback function-    _glfwWin.charCallback = cbfun;-}---//========================================================================-// Set callback function for mouse clicks-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetMouseButtonCallback( GLFWmousebuttonfun cbfun )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Set callback function-    _glfwWin.mouseButtonCallback = cbfun;-}---//========================================================================-// Set callback function for mouse moves-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetMousePosCallback( GLFWmouseposfun cbfun )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Set callback function-    _glfwWin.mousePosCallback = cbfun;--    // Call the callback function to let the application know the current-    // mouse position-    if( cbfun )-    {-        cbfun( _glfwInput.MousePosX, _glfwInput.MousePosY );-    }-}---//========================================================================-// Set callback function for mouse wheel-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetMouseWheelCallback( GLFWmousewheelfun cbfun )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Set callback function-    _glfwWin.mouseWheelCallback = cbfun;--    // Call the callback function to let the application know the current-    // mouse wheel position-    if( cbfun )-    {-        cbfun( _glfwInput.WheelPos );-    }-}-
− glfw/lib/internal.h 
@@ -1,265 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// File:        internal.h-// Platform:    Any-// API version: 2.7-// WWW:         http://glfw.sourceforge.net-//-------------------------------------------------------------------------// Copyright (c) 2002-2006 Camilla Berglund-//-// This software is provided 'as-is', without any express or implied-// warranty. In no event will the authors be held liable for any damages-// arising from the use of this software.-//-// Permission is granted to anyone to use this software for any purpose,-// including commercial applications, and to alter it and redistribute it-// freely, subject to the following restrictions:-//-// 1. The origin of this software must not be misrepresented; you must not-//    claim that you wrote the original software. If you use this software-//    in a product, an acknowledgment in the product documentation would-//    be appreciated but is not required.-//-// 2. Altered source versions must be plainly marked as such, and must not-//    be misrepresented as being the original software.-//-// 3. This notice may not be removed or altered from any source-//    distribution.-//-//========================================================================--#ifndef _internal_h_-#define _internal_h_--//========================================================================-// GLFWGLOBAL is a macro that places all global variables in the init.c-// module (all other modules reference global variables as 'extern')-//========================================================================--#if defined( _init_c_ )-#define GLFWGLOBAL-#else-#define GLFWGLOBAL extern-#endif---//========================================================================-// Input handling definitions-//========================================================================--// Internal key and button state/action definitions-#define GLFW_STICK 2---//========================================================================-// System independent include files-//========================================================================--#include <stdlib.h>-#include <string.h>-#include <stdio.h>---//-------------------------------------------------------------------------// Window opening hints (set by glfwOpenWindowHint)-// A bucket of semi-random stuff bunched together for historical reasons-// This is used only by the platform independent code and only to store-// parameters passed to us by glfwOpenWindowHint-//-------------------------------------------------------------------------typedef struct {-    int         refreshRate;-    int         accumRedBits;-    int         accumGreenBits;-    int         accumBlueBits;-    int         accumAlphaBits;-    int         auxBuffers;-    int         stereo;-    int         windowNoResize;-    int         samples;-    int         glMajor;-    int         glMinor;-    int         glForward;-    int         glDebug;-    int         glProfile;-} _GLFWhints;---//-------------------------------------------------------------------------// Platform specific definitions goes in platform.h (which also includes-// glfw.h)-//--------------------------------------------------------------------------#include "platform.h"---//-------------------------------------------------------------------------// Parameters relating to the creation of the context and window but not-// directly related to the properties of the framebuffer-// This is used to pass window and context creation parameters from the-// platform independent code to the platform specific code-//-------------------------------------------------------------------------typedef struct {-    int         mode;-    int         refreshRate;-    int         windowNoResize;-    int         glMajor;-    int         glMinor;-    int         glForward;-    int         glDebug;-    int         glProfile;-} _GLFWwndconfig;---//-------------------------------------------------------------------------// Framebuffer configuration descriptor, i.e. buffers and their sizes-// Also a platform specific ID used to map back to the actual backend APIs-// This is used to pass framebuffer parameters from the platform independent-// code to the platform specific code, and also to enumerate and select-// available framebuffer configurations-//-------------------------------------------------------------------------typedef struct {-    int         redBits;-    int         greenBits;-    int         blueBits;-    int         alphaBits;-    int         depthBits;-    int         stencilBits;-    int         accumRedBits;-    int         accumGreenBits;-    int         accumBlueBits;-    int         accumAlphaBits;-    int         auxBuffers;-    int         stereo;-    int         samples;-    GLFWintptr  platformID;-} _GLFWfbconfig;---//========================================================================-// System independent global variables (GLFW internals)-//========================================================================--// Flag indicating if GLFW has been initialized-#if defined( _init_c_ )-int _glfwInitialized = 0;-#else-GLFWGLOBAL int _glfwInitialized;-#endif---//-------------------------------------------------------------------------// Abstract data stream (for image I/O)-//-------------------------------------------------------------------------typedef struct {-    FILE*   file;-    void*   data;-    long    position;-    long    size;-} _GLFWstream;---//========================================================================-// Prototypes for platform specific implementation functions-//========================================================================--// Init/terminate-int _glfwPlatformInit( void );-int _glfwPlatformTerminate( void );--// Enable/Disable-void _glfwPlatformEnableSystemKeys( void );-void _glfwPlatformDisableSystemKeys( void );--// Fullscreen-int  _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount );-void _glfwPlatformGetDesktopMode( GLFWvidmode *mode );--// OpenGL extensions-int _glfwPlatformExtensionSupported( const char *extension );-void * _glfwPlatformGetProcAddress( const char *procname );--// Joystick-int _glfwPlatformGetJoystickParam( int joy, int param );-int _glfwPlatformGetJoystickPos( int joy, float *pos, int numaxes );-int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons, int numbuttons );--// Threads-GLFWthread _glfwPlatformCreateThread( GLFWthreadfun fun, void *arg );-void _glfwPlatformDestroyThread( GLFWthread ID );-int _glfwPlatformWaitThread( GLFWthread ID, int waitmode );-GLFWthread _glfwPlatformGetThreadID( void );-GLFWmutex _glfwPlatformCreateMutex( void );-void _glfwPlatformDestroyMutex( GLFWmutex mutex );-void _glfwPlatformLockMutex( GLFWmutex mutex );-void _glfwPlatformUnlockMutex( GLFWmutex mutex );-GLFWcond _glfwPlatformCreateCond( void );-void _glfwPlatformDestroyCond( GLFWcond cond );-void _glfwPlatformWaitCond( GLFWcond cond, GLFWmutex mutex, double timeout );-void _glfwPlatformSignalCond( GLFWcond cond );-void _glfwPlatformBroadcastCond( GLFWcond cond );-int _glfwPlatformGetNumberOfProcessors( void );--// Time-double _glfwPlatformGetTime( void );-void _glfwPlatformSetTime( double time );-void _glfwPlatformSleep( double time );--// Window management-int  _glfwPlatformOpenWindow( int width, int height, const _GLFWwndconfig *wndconfig, const _GLFWfbconfig *fbconfig );-void _glfwPlatformCloseWindow( void );-void _glfwPlatformSetWindowTitle( const char *title );-void _glfwPlatformSetWindowSize( int width, int height );-void _glfwPlatformSetWindowPos( int x, int y );-void _glfwPlatformIconifyWindow( void );-void _glfwPlatformRestoreWindow( void );-void _glfwPlatformSwapBuffers( void );-void _glfwPlatformSwapInterval( int interval );-void _glfwPlatformRefreshWindowParams( void );-void _glfwPlatformPollEvents( void );-void _glfwPlatformWaitEvents( void );-void _glfwPlatformHideMouseCursor( void );-void _glfwPlatformShowMouseCursor( void );-void _glfwPlatformSetMouseCursorPos( int x, int y );---//========================================================================-// Prototypes for platform independent internal functions-//========================================================================--// Window management (window.c)-void _glfwClearWindowHints( void );--// Input handling (window.c)-void _glfwClearInput( void );-void _glfwInputDeactivation( void );-void _glfwInputKey( int key, int action );-void _glfwInputChar( int character, int action );-void _glfwInputMouseClick( int button, int action );--// Threads (thread.c)-_GLFWthread * _glfwGetThreadPointer( int ID );-void _glfwAppendThread( _GLFWthread * t );-void _glfwRemoveThread( _GLFWthread * t );--// OpenGL extensions (glext.c)-void _glfwParseGLVersion( int *major, int *minor, int *rev );-int _glfwStringInExtensionString( const char *string, const GLubyte *extensions );--// Abstracted data streams (stream.c)-int _glfwOpenFileStream( _GLFWstream *stream, const char *name, const char *mode );-int _glfwOpenBufferStream( _GLFWstream *stream, void *data, long size );-long _glfwReadStream( _GLFWstream *stream, void *data, long size );-long _glfwTellStream( _GLFWstream *stream );-int _glfwSeekStream( _GLFWstream *stream, long offset, int whence );-void _glfwCloseStream( _GLFWstream *stream );--// Targa image I/O (tga.c)-int _glfwReadTGA( _GLFWstream *s, GLFWimage *img, int flags );--// Framebuffer configs-const _GLFWfbconfig *_glfwChooseFBConfig( const _GLFWfbconfig *desired,-                                          const _GLFWfbconfig *alternatives,-                                          unsigned int count );---#endif // _internal_h_
− glfw/lib/joystick.c 
@@ -1,99 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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 user functions                         ****-//************************************************************************--//========================================================================-// Determine joystick capabilities-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwGetJoystickParam( int joy, int param )-{-    if( !_glfwInitialized )-    {-        return 0;-    }--    return _glfwPlatformGetJoystickParam( joy, param );-}---//========================================================================-// Get joystick axis positions-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwGetJoystickPos( int joy, float *pos, int numaxes )-{-    int i;--    if( !_glfwInitialized )-    {-        return 0;-    }--    // Clear positions-    for( i = 0; i < numaxes; i++ )-    {-        pos[ i ] = 0.0f;-    }--    return _glfwPlatformGetJoystickPos( joy, pos, numaxes );-}---//========================================================================-// Get joystick button states-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwGetJoystickButtons( int joy,-                                                 unsigned char *buttons,-                                                 int numbuttons )-{-    int i;--    if( !_glfwInitialized )-    {-        return 0;-    }--    // Clear button states-    for( i = 0; i < numbuttons; i++ )-    {-        buttons[ i ] = GLFW_RELEASE;-    }--    return _glfwPlatformGetJoystickButtons( joy, buttons, numbuttons );-}-
− glfw/lib/stream.c 
@@ -1,195 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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.-//-//========================================================================--#define _CRT_SECURE_NO_WARNINGS--#include "internal.h"---//========================================================================-// Opens a GLFW stream with a file-//========================================================================--int _glfwOpenFileStream( _GLFWstream *stream, const char* name, const char* mode )-{-    memset( stream, 0, sizeof(_GLFWstream) );--    stream->file = fopen( name, mode );-    if( stream->file == NULL )-    {-        return GL_FALSE;-    }--    return GL_TRUE;-}---//========================================================================-// Opens a GLFW stream with a memory block-//========================================================================--int _glfwOpenBufferStream( _GLFWstream *stream, void *data, long size )-{-    memset( stream, 0, sizeof(_GLFWstream) );--    stream->data = data;-    stream->size = size;-    return GL_TRUE;-}---//========================================================================-// Reads data from a GLFW stream-//========================================================================--long _glfwReadStream( _GLFWstream *stream, void *data, long size )-{-    if( stream->file != NULL )-    {-        return (long) fread( data, 1, size, stream->file );-    }--    if( stream->data != NULL )-    {-        // Check for EOF-        if( stream->position == stream->size )-        {-            return 0;-        }--        // Clamp read size to available data-        if( stream->position + size > stream->size )-        {-            size = stream->size - stream->position;-        }--        // Perform data read-        memcpy( data, (unsigned char*) stream->data + stream->position, size );-        stream->position += size;-        return size;-    }--    return 0;-}---//========================================================================-// Returns the current position of a GLFW stream-//========================================================================--long _glfwTellStream( _GLFWstream *stream )-{-    if( stream->file != NULL )-    {-        return ftell( stream->file );-    }--    if( stream->data != NULL )-    {-        return stream->position;-    }--    return 0;-}---//========================================================================-// Sets the current position of a GLFW stream-//========================================================================--int _glfwSeekStream( _GLFWstream *stream, long offset, int whence )-{-    long position;--    if( stream->file != NULL )-    {-        if( fseek( stream->file, offset, whence ) != 0 )-        {-            return GL_FALSE;-        }--        return GL_TRUE;-    }--    if( stream->data != NULL )-    {-        position = offset;--        // Handle whence parameter-        if( whence == SEEK_CUR )-        {-            position += stream->position;-        }-        else if( whence == SEEK_END )-        {-            position += stream->size;-        }-        else if( whence != SEEK_SET )-        {-            return GL_FALSE;-        }--        // Clamp offset to buffer bounds and apply it-        if( position > stream->size )-        {-            stream->position = stream->size;-        }-        else if( position < 0 )-        {-            stream->position = 0;-        }-        else-        {-            stream->position = position;-        }--        return GL_TRUE;-    }--    return GL_FALSE;-}---//========================================================================-// Closes a GLFW stream-//========================================================================--void _glfwCloseStream( _GLFWstream *stream )-{-    if( stream->file != NULL )-    {-        fclose( stream->file );-    }--    // Nothing to be done about (user allocated) memory blocks--    memset( stream, 0, sizeof(_GLFWstream) );-}-
− glfw/lib/tga.c 
@@ -1,404 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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.-//-//========================================================================--//========================================================================-// Description:-//-// TGA format image file loader. This module supports version 1 Targa-// images, with these restrictions:-//  - Pixel format may only be 8, 24 or 32 bits-//  - Colormaps must be no longer than 256 entries-//-//========================================================================---#include "internal.h"---//************************************************************************-//****            GLFW internal functions & declarations              ****-//************************************************************************--//========================================================================-// TGA file header information-//========================================================================--typedef struct {-    int idlen;                 // 1 byte-    int cmaptype;              // 1 byte-    int imagetype;             // 1 byte-    int cmapfirstidx;          // 2 bytes-    int cmaplen;               // 2 bytes-    int cmapentrysize;         // 1 byte-    int xorigin;               // 2 bytes-    int yorigin;               // 2 bytes-    int width;                 // 2 bytes-    int height;                // 2 bytes-    int bitsperpixel;          // 1 byte-    int imageinfo;             // 1 byte-    int _alphabits;            // (derived from imageinfo)-    int _origin;               // (derived from imageinfo)-} _tga_header_t;--#define _TGA_CMAPTYPE_NONE      0-#define _TGA_CMAPTYPE_PRESENT   1--#define _TGA_IMAGETYPE_NONE     0-#define _TGA_IMAGETYPE_CMAP     1-#define _TGA_IMAGETYPE_TC       2-#define _TGA_IMAGETYPE_GRAY     3-#define _TGA_IMAGETYPE_CMAP_RLE 9-#define _TGA_IMAGETYPE_TC_RLE   10-#define _TGA_IMAGETYPE_GRAY_RLE 11--#define _TGA_IMAGEINFO_ALPHA_MASK   0x0f-#define _TGA_IMAGEINFO_ALPHA_SHIFT  0-#define _TGA_IMAGEINFO_ORIGIN_MASK  0x30-#define _TGA_IMAGEINFO_ORIGIN_SHIFT 4--#define _TGA_ORIGIN_BL 0-#define _TGA_ORIGIN_BR 1-#define _TGA_ORIGIN_UL 2-#define _TGA_ORIGIN_UR 3---//========================================================================-// Read TGA file header (and check that it is valid)-//========================================================================--static int ReadTGAHeader( _GLFWstream *s, _tga_header_t *h )-{-    unsigned char buf[ 18 ];-    int pos;--    // Read TGA file header from file-    pos = _glfwTellStream( s );-    _glfwReadStream( s, buf, 18 );--    // Interpret header (endian independent parsing)-    h->idlen         = (int) buf[0];-    h->cmaptype      = (int) buf[1];-    h->imagetype     = (int) buf[2];-    h->cmapfirstidx  = (int) buf[3] | (((int) buf[4]) << 8);-    h->cmaplen       = (int) buf[5] | (((int) buf[6]) << 8);-    h->cmapentrysize = (int) buf[7];-    h->xorigin       = (int) buf[8] | (((int) buf[9]) << 8);-    h->yorigin       = (int) buf[10] | (((int) buf[11]) << 8);-    h->width         = (int) buf[12] | (((int) buf[13]) << 8);-    h->height        = (int) buf[14] | (((int) buf[15]) << 8);-    h->bitsperpixel  = (int) buf[16];-    h->imageinfo     = (int) buf[17];--    // Extract alphabits and origin information-    h->_alphabits = (int) (h->imageinfo & _TGA_IMAGEINFO_ALPHA_MASK) >>-                     _TGA_IMAGEINFO_ALPHA_SHIFT;-    h->_origin    = (int) (h->imageinfo & _TGA_IMAGEINFO_ORIGIN_MASK) >>-                     _TGA_IMAGEINFO_ORIGIN_SHIFT;--    // Validate TGA header (is this a TGA file?)-    if( (h->cmaptype == 0 || h->cmaptype == 1) &&-        ((h->imagetype >= 1 && h->imagetype <= 3) ||-         (h->imagetype >= 9 && h->imagetype <= 11)) &&-         (h->bitsperpixel == 8 || h->bitsperpixel == 24 ||-          h->bitsperpixel == 32) )-    {-        // Skip the ID field-        _glfwSeekStream( s, h->idlen, SEEK_CUR );--        // Indicate that the TGA header was valid-        return GL_TRUE;-    }-    else-    {-        // Restore file position-        _glfwSeekStream( s, pos, SEEK_SET );--        // Indicate that the TGA header was invalid-        return GL_FALSE;-    }-}--//========================================================================-// Read Run-Length Encoded data-//========================================================================--static void ReadTGA_RLE( unsigned char *buf, int size, int bpp,-                         _GLFWstream *s )-{-    int repcount, bytes, k, n;-    unsigned char pixel[ 4 ];-    char c;--    // Dummy check-    if( bpp > 4 )-    {-        return;-    }--    while( size > 0 )-    {-        // Get repetition count-	_glfwReadStream( s, &c, 1 );-        repcount = (unsigned int) c;-        bytes = ((repcount & 127) + 1) * bpp;-        if( size < bytes )-        {-            bytes = size;-        }--        // Run-Length packet?-        if( repcount & 128 )-        {-            _glfwReadStream( s, pixel, bpp );-            for( n = 0; n < (repcount & 127) + 1; n ++ )-            {-                for( k = 0; k < bpp; k ++ )-                {-                    *buf ++ = pixel[ k ];-                }-            }-        }-        else-        {-            // It's a Raw packet-            _glfwReadStream( s, buf, bytes );-            buf += bytes;-        }--        size -= bytes;-    }-}---//========================================================================-// Read a TGA image from a file-//========================================================================--int _glfwReadTGA( _GLFWstream *s, GLFWimage *img, int flags )-{-    _tga_header_t h;-    unsigned char *cmap, *pix, tmp, *src, *dst;-    int cmapsize, pixsize, pixsize2;-    int bpp, bpp2, k, m, n, swapx, swapy;--    // Read TGA header-    if( !ReadTGAHeader( s, &h ) )-    {-        return 0;-    }--    // Is there a colormap?-    cmapsize = (h.cmaptype == _TGA_CMAPTYPE_PRESENT ? 1 : 0) * h.cmaplen *-               ((h.cmapentrysize+7) / 8);-    if( cmapsize > 0 )-    {-        // Is it a colormap that we can handle?-        if( (h.cmapentrysize != 24 && h.cmapentrysize != 32) ||-            h.cmaplen == 0 || h.cmaplen > 256 )-        {-            return 0;-        }--        // Allocate memory for colormap-        cmap = (unsigned char *) malloc( cmapsize );-        if( cmap == NULL )-        {-            return 0;-        }--        // Read colormap from file-        _glfwReadStream( s, cmap, cmapsize );-    }-    else-    {-        cmap = NULL;-    }--    // Size of pixel data-    pixsize = h.width * h.height * ((h.bitsperpixel + 7) / 8);--    // Bytes per pixel (pixel data - unexpanded)-    bpp = (h.bitsperpixel + 7) / 8;--    // Bytes per pixel (expanded pixels - not colormap indeces)-    if( cmap )-    {-        bpp2 = (h.cmapentrysize + 7) / 8;-    }-    else-    {-        bpp2 = bpp;-    }--    // For colormaped images, the RGB/RGBA image data may use more memory-    // than the stored pixel data-    pixsize2 = h.width * h.height * bpp2;--    // Allocate memory for pixel data-    pix = (unsigned char *) malloc( pixsize2 );-    if( pix == NULL )-    {-        if( cmap )-        {-            free( cmap );-        }-        return 0;-    }--    // Read pixel data from file-    if( h.imagetype >= _TGA_IMAGETYPE_CMAP_RLE )-    {-        ReadTGA_RLE( pix, pixsize, bpp, s );-    }-    else-    {-        _glfwReadStream( s, pix, pixsize );-    }--    // If the image origin is not what we want, re-arrange the pixels-    switch( h._origin )-    {-    default:-    case _TGA_ORIGIN_UL:-        swapx = 0;-        swapy = 1;-        break;--    case _TGA_ORIGIN_BL:-        swapx = 0;-        swapy = 0;-        break;--    case _TGA_ORIGIN_UR:-        swapx = 1;-        swapy = 1;-        break;--    case _TGA_ORIGIN_BR:-        swapx = 1;-        swapy = 0;-        break;-    }-    if( (swapy && !(flags & GLFW_ORIGIN_UL_BIT)) ||-        (!swapy && (flags & GLFW_ORIGIN_UL_BIT)) )-    {-        src = pix;-        dst = &pix[ (h.height-1)*h.width*bpp ];-        for( n = 0; n < h.height/2; n ++ )-        {-            for( m = 0; m < h.width ; m ++ )-            {-                for( k = 0; k < bpp; k ++ )-                {-                    tmp     = *src;-                    *src ++ = *dst;-                    *dst ++ = tmp;-                }-            }-            dst -= 2*h.width*bpp;-        }-    }-    if( swapx )-    {-        src = pix;-        dst = &pix[ (h.width-1)*bpp ];-        for( n = 0; n < h.height; n ++ )-        {-            for( m = 0; m < h.width/2 ; m ++ )-            {-                for( k = 0; k < bpp; k ++ )-                {-                    tmp     = *src;-                    *src ++ = *dst;-                    *dst ++ = tmp;-                }-                dst -= 2*bpp;-            }-            src += ((h.width+1)/2)*bpp;-            dst += ((3*h.width+1)/2)*bpp;-        }-    }--    // Convert BGR/BGRA to RGB/RGBA, and optionally colormap indeces to-    // RGB/RGBA values-    if( cmap )-    {-        // Convert colormap pixel format (BGR -> RGB or BGRA -> RGBA)-        if( bpp2 == 3 || bpp2 == 4 )-        {-            for( n = 0; n < h.cmaplen; n ++ )-            {-                tmp                = cmap[ n*bpp2 ];-                cmap[ n*bpp2 ]     = cmap[ n*bpp2 + 2 ];-                cmap[ n*bpp2 + 2 ] = tmp;-            }-        }--        // Convert pixel data to RGB/RGBA data-        for( m = h.width * h.height - 1; m >= 0; m -- )-        {-            n = pix[ m ];-            for( k = 0; k < bpp2; k ++ )-            {-                pix[ m*bpp2 + k ] = cmap[ n*bpp2 + k ];-            }-        }--        // Free memory for colormap (it's not needed anymore)-        free( cmap );-    }-    else-    {-        // Convert image pixel format (BGR -> RGB or BGRA -> RGBA)-        if( bpp2 == 3 || bpp2 == 4 )-        {-            src = pix;-            dst = &pix[ 2 ];-            for( n = 0; n < h.height * h.width; n ++ )-            {-                tmp  = *src;-                *src = *dst;-                *dst = tmp;-                src += bpp2;-                dst += bpp2;-            }-        }-    }--    // Fill out GLFWimage struct (the Format field will be set by-    // glfwReadImage)-    img->Width         = h.width;-    img->Height        = h.height;-    img->BytesPerPixel = bpp2;-    img->Data          = pix;--    return 1;-}-
− glfw/lib/thread.c 
@@ -1,341 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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 internal functions                       ****-//************************************************************************--//========================================================================-// Find pointer to thread with a matching ID-//========================================================================--_GLFWthread * _glfwGetThreadPointer( int ID )-{-    _GLFWthread *t;--    for( t = &_glfwThrd.First; t != NULL; t = t->Next )-    {-        if( t->ID == ID )-        {-            break;-        }-    }--    return t;-}---//========================================================================-// Append thread to thread list-//========================================================================--void _glfwAppendThread( _GLFWthread * t )-{-    _GLFWthread *t_tmp;--    t_tmp = &_glfwThrd.First;-    while( t_tmp->Next != NULL )-    {-        t_tmp = t_tmp->Next;-    }-    t_tmp->Next = t;-    t->Previous = t_tmp;-    t->Next     = NULL;-}---//========================================================================-// Remove thread from thread list-//========================================================================--void _glfwRemoveThread( _GLFWthread * t )-{-    if( t->Previous != NULL )-    {-        t->Previous->Next = t->Next;-    }-    if( t->Next != NULL )-    {-        t->Next->Previous = t->Previous;-    }-    free( (void *) t );-}----//************************************************************************-//****                     GLFW user functions                        ****-//************************************************************************--//========================================================================-// Create a new thread-//========================================================================--GLFWAPI GLFWthread GLFWAPIENTRY glfwCreateThread( GLFWthreadfun fun,-                                                  void *arg )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return -1;-    }--    // Return the GLFW thread ID-    return _glfwPlatformCreateThread( fun, arg );-}---//========================================================================-// Kill a thread. NOTE: THIS IS A VERY DANGEROUS OPERATION, AND SHOULD NOT-// BE USED EXCEPT IN EXTREME SITUATIONS!-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwDestroyThread( GLFWthread ID )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return;-    }--    // Is it a valid thread? (killing the main thread is not allowed)-    if( ID < 1 )-    {-        return;-    }--    _glfwPlatformDestroyThread( ID );-}---//========================================================================-// Wait for a thread to die-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwWaitThread( GLFWthread ID, int waitmode )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return GL_TRUE;-    }--    // Is it a valid thread? (waiting for the main thread is not allowed)-    if( ID < 1 )-    {-        return GL_TRUE;-    }--    return _glfwPlatformWaitThread( ID, waitmode );-}---//========================================================================-// Return the thread ID for the current thread-//========================================================================--GLFWAPI GLFWthread GLFWAPIENTRY glfwGetThreadID( void )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return 0;-    }--    return _glfwPlatformGetThreadID();-}---//========================================================================-// Create a mutual exclusion object-//========================================================================--GLFWAPI GLFWmutex GLFWAPIENTRY glfwCreateMutex( void )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return (GLFWmutex) 0;-    }--    return _glfwPlatformCreateMutex();-}---//========================================================================-// Destroy a mutual exclusion object-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwDestroyMutex( GLFWmutex mutex )-{-    // Initialized & valid mutex (no real way of assuring this)?-    if( !_glfwInitialized || !mutex )-    {-        return;-    }--    _glfwPlatformDestroyMutex( mutex );-}---//========================================================================-// Request access to a mutex-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwLockMutex( GLFWmutex mutex )-{-    // Initialized & valid mutex (no real way of assuring this)?-    if( !_glfwInitialized && !mutex )-    {-        return;-    }--    _glfwPlatformLockMutex( mutex );-}---//========================================================================-// Release a mutex-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwUnlockMutex( GLFWmutex mutex )-{-    // Initialized & valid mutex (no real way of assuring this)?-    if( !_glfwInitialized && !mutex )-    {-        return;-    }--    _glfwPlatformUnlockMutex( mutex );-}---//========================================================================-// Create a new condition variable object-//========================================================================--GLFWAPI GLFWcond GLFWAPIENTRY glfwCreateCond( void )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return (GLFWcond) 0;-    }--    return _glfwPlatformCreateCond();-}---//========================================================================-// Destroy a condition variable object-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwDestroyCond( GLFWcond cond )-{-    // Initialized & valid condition variable?-    if( !_glfwInitialized || !cond )-    {-        return;-    }--    _glfwPlatformDestroyCond( cond );-}---//========================================================================-// Wait for a condition to be raised-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwWaitCond( GLFWcond cond, GLFWmutex mutex,-                                        double timeout )-{-    // Initialized & valid condition variable and mutex?-    if( !_glfwInitialized || !cond || !mutex )-    {-        return;-    }--    _glfwPlatformWaitCond( cond, mutex, timeout );-}---//========================================================================-// Signal a condition to one waiting thread-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSignalCond( GLFWcond cond )-{-    // Initialized & valid condition variable?-    if( !_glfwInitialized || !cond )-    {-        return;-    }--    _glfwPlatformSignalCond( cond );-}---//========================================================================-// Broadcast a condition to all waiting threads-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwBroadcastCond( GLFWcond cond )-{-    // Initialized & valid condition variable?-    if( !_glfwInitialized || !cond )-    {-        return;-    }--    _glfwPlatformBroadcastCond( cond );-}---//========================================================================-// Return the number of processors in the system. This information can be-// useful for determining the optimal number of threads to use for-// performing a certain task.-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwGetNumberOfProcessors( void )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return 0;-    }--    return _glfwPlatformGetNumberOfProcessors();-}-
− glfw/lib/time.c 
@@ -1,84 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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 user functions                         ****-//************************************************************************--//========================================================================-// Return timer value in seconds-//========================================================================--GLFWAPI double GLFWAPIENTRY glfwGetTime( void )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return 0.0;-    }--    return _glfwPlatformGetTime();-}---//========================================================================-// Set timer value in seconds-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetTime( double time )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return;-    }--    _glfwPlatformSetTime( time );-}---//========================================================================-// Put a thread to sleep for a specified amount of time-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSleep( double time )-{-    // Is GLFW initialized?-    if( !_glfwInitialized )-    {-        return;-    }--    _glfwPlatformSleep( time );-}-
− glfw/lib/win32/platform.h 
@@ -1,555 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Win32/WGL-// API version: 2.7-// WWW:         http://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 _platform_h_-#define _platform_h_---// This is the Windows version of GLFW-#define _GLFW_WIN32--// We don't need all the fancy stuff-#define NOMINMAX-#define WIN32_LEAN_AND_MEAN-#define VC_EXTRALEAN--// Include files-#include <windows.h>-#include <mmsystem.h>-#include "../../include/GL/glfw.h"---//========================================================================-// Hack: Define things that some <windows.h>'s do not define-//========================================================================--// Some old versions of w32api (used by MinGW and Cygwin) define-// WH_KEYBOARD_LL without typedef:ing KBDLLHOOKSTRUCT (!)-#if defined(__MINGW32__) || defined(__CYGWIN__)-#include <w32api.h>-#if defined(WH_KEYBOARD_LL) && (__W32API_MAJOR_VERSION == 1) && (__W32API_MINOR_VERSION <= 2)-#undef WH_KEYBOARD_LL-#endif-#endif--//-------------------------------------------------------------------------// ** NOTE **  If this gives you compiler errors and you are using MinGW-// (or Dev-C++), update to w32api version 1.3 or later:-// http://sourceforge.net/project/showfiles.php?group_id=2435-//-------------------------------------------------------------------------#ifndef WH_KEYBOARD_LL-#define WH_KEYBOARD_LL 13-typedef struct tagKBDLLHOOKSTRUCT {-  DWORD   vkCode;-  DWORD   scanCode;-  DWORD   flags;-  DWORD   time;-  DWORD   dwExtraInfo;-} KBDLLHOOKSTRUCT, FAR *LPKBDLLHOOKSTRUCT, *PKBDLLHOOKSTRUCT;-#endif // WH_KEYBOARD_LL--#ifndef LLKHF_ALTDOWN-#define LLKHF_ALTDOWN  0x00000020-#endif--#ifndef SPI_SETSCREENSAVERRUNNING-#define SPI_SETSCREENSAVERRUNNING 97-#endif-#ifndef SPI_GETANIMATION-#define SPI_GETANIMATION 72-#endif-#ifndef SPI_SETANIMATION-#define SPI_SETANIMATION 73-#endif-#ifndef SPI_GETFOREGROUNDLOCKTIMEOUT-#define SPI_GETFOREGROUNDLOCKTIMEOUT 0x2000-#endif-#ifndef SPI_SETFOREGROUNDLOCKTIMEOUT-#define SPI_SETFOREGROUNDLOCKTIMEOUT 0x2001-#endif--#ifndef CDS_FULLSCREEN-#define CDS_FULLSCREEN 4-#endif--#ifndef PFD_GENERIC_ACCELERATED-#define PFD_GENERIC_ACCELERATED 0x00001000-#endif-#ifndef PFD_DEPTH_DONTCARE-#define PFD_DEPTH_DONTCARE 0x20000000-#endif--#ifndef ENUM_CURRENT_SETTINGS-#define ENUM_CURRENT_SETTINGS -1-#endif-#ifndef ENUM_REGISTRY_SETTINGS-#define ENUM_REGISTRY_SETTINGS -2-#endif--#ifndef WM_MOUSEWHEEL-#define WM_MOUSEWHEEL 0x020A-#endif-#ifndef WHEEL_DELTA-#define WHEEL_DELTA 120-#endif--#ifndef WM_XBUTTONDOWN-#define WM_XBUTTONDOWN 0x020B-#endif-#ifndef WM_XBUTTONUP-#define WM_XBUTTONUP 0x020C-#endif-#ifndef XBUTTON1-#define XBUTTON1 1-#endif-#ifndef XBUTTON2-#define XBUTTON2 2-#endif--#ifndef WGL_EXT_swap_control--/* Entry points */-typedef int (APIENTRY * PFNWGLSWAPINTERVALEXTPROC) (int);--#endif /*WGL_EXT_swap_control*/--#ifndef WGL_ARB_extensions_string--/* Entry points */-typedef const char *(APIENTRY * PFNWGLGETEXTENSIONSSTRINGARBPROC)( HDC );--#endif /*WGL_ARB_extensions_string*/--#ifndef WGL_EXT_extension_string--/* Entry points */-typedef const char *(APIENTRY * PFNWGLGETEXTENSIONSSTRINGEXTPROC)( void );--#endif /*WGL_EXT_extension_string*/--#ifndef WGL_ARB_pixel_format--/* Entry points */-typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC, int, int, UINT, const int *, int *);--/* Constants for wglGetPixelFormatAttribivARB */-#define WGL_NUMBER_PIXEL_FORMATS_ARB    0x2000-#define WGL_DRAW_TO_WINDOW_ARB          0x2001-#define WGL_SUPPORT_OPENGL_ARB          0x2010-#define WGL_ACCELERATION_ARB            0x2003-#define WGL_DOUBLE_BUFFER_ARB           0x2011-#define WGL_STEREO_ARB                  0x2012-#define WGL_PIXEL_TYPE_ARB              0x2013-#define WGL_COLOR_BITS_ARB              0x2014-#define WGL_RED_BITS_ARB                0x2015-#define WGL_GREEN_BITS_ARB              0x2017-#define WGL_BLUE_BITS_ARB               0x2019-#define WGL_ALPHA_BITS_ARB              0x201B-#define WGL_ACCUM_BITS_ARB              0x201D-#define WGL_ACCUM_RED_BITS_ARB          0x201E-#define WGL_ACCUM_GREEN_BITS_ARB        0x201F-#define WGL_ACCUM_BLUE_BITS_ARB         0x2020-#define WGL_ACCUM_ALPHA_BITS_ARB        0x2021-#define WGL_DEPTH_BITS_ARB              0x2022-#define WGL_STENCIL_BITS_ARB            0x2023-#define WGL_AUX_BUFFERS_ARB             0x2024-#define WGL_SAMPLE_BUFFERS_ARB          0x2041-#define WGL_SAMPLES_ARB                 0x2042--/* Constants for WGL_ACCELERATION_ARB */-#define WGL_NO_ACCELERATION_ARB         0x2025-#define WGL_GENERIC_ACCELERATION_ARB    0x2026-#define WGL_FULL_ACCELERATION_ARB       0x2027--/* Constants for WGL_PIXEL_TYPE_ARB */-#define WGL_TYPE_RGBA_ARB               0x202B-#define WGL_TYPE_COLORINDEX_ARB         0x202C--#endif /*WGL_ARB_pixel_format*/---#ifndef WGL_ARB_create_context--/* Entry points */-typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC, HGLRC, const int *);--/* Tokens for wglCreateContextAttribsARB attributes */-#define WGL_CONTEXT_MAJOR_VERSION_ARB          0x2091-#define WGL_CONTEXT_MINOR_VERSION_ARB          0x2092-#define WGL_CONTEXT_LAYER_PLANE_ARB            0x2093-#define WGL_CONTEXT_FLAGS_ARB                  0x2094-#define WGL_CONTEXT_PROFILE_MASK_ARB           0x9126--/* Bits for WGL_CONTEXT_FLAGS_ARB */-#define WGL_CONTEXT_DEBUG_BIT_ARB              0x0001-#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002--/* Bits for WGL_CONTEXT_PROFILE_MASK_ARB */-#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB          0x00000001-#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002--#endif /*WGL_ARB_create_context*/---#ifndef GL_VERSION_3_0--typedef const GLubyte * (APIENTRY *PFNGLGETSTRINGIPROC) (GLenum, GLuint);--#endif /*GL_VERSION_3_0*/---//========================================================================-// DLLs that are loaded at glfwInit()-//========================================================================--// gdi32.dll function pointer typedefs-#ifndef _GLFW_NO_DLOAD_GDI32-typedef int  (WINAPI * CHOOSEPIXELFORMAT_T) (HDC,CONST PIXELFORMATDESCRIPTOR*);-typedef int  (WINAPI * DESCRIBEPIXELFORMAT_T) (HDC,int,UINT,LPPIXELFORMATDESCRIPTOR);-typedef int  (WINAPI * GETPIXELFORMAT_T) (HDC);-typedef BOOL (WINAPI * SETPIXELFORMAT_T) (HDC,int,const PIXELFORMATDESCRIPTOR*);-typedef BOOL (WINAPI * SWAPBUFFERS_T) (HDC);-#endif // _GLFW_NO_DLOAD_GDI32--// winmm.dll function pointer typedefs-#ifndef _GLFW_NO_DLOAD_WINMM-typedef MMRESULT (WINAPI * JOYGETDEVCAPSA_T) (UINT,LPJOYCAPSA,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---// gdi32.dll shortcuts-#ifndef _GLFW_NO_DLOAD_GDI32-#define _glfw_ChoosePixelFormat   _glfwLibrary.Libs.ChoosePixelFormat-#define _glfw_DescribePixelFormat _glfwLibrary.Libs.DescribePixelFormat-#define _glfw_GetPixelFormat      _glfwLibrary.Libs.GetPixelFormat-#define _glfw_SetPixelFormat      _glfwLibrary.Libs.SetPixelFormat-#define _glfw_SwapBuffers         _glfwLibrary.Libs.SwapBuffers-#else-#define _glfw_ChoosePixelFormat   ChoosePixelFormat-#define _glfw_DescribePixelFormat DescribePixelFormat-#define _glfw_GetPixelFormat      GetPixelFormat-#define _glfw_SetPixelFormat      SetPixelFormat-#define _glfw_SwapBuffers         SwapBuffers-#endif // _GLFW_NO_DLOAD_GDI32--// winmm.dll shortcuts-#ifndef _GLFW_NO_DLOAD_WINMM-#define _glfw_joyGetDevCaps _glfwLibrary.Libs.joyGetDevCapsA-#define _glfw_joyGetPos     _glfwLibrary.Libs.joyGetPos-#define _glfw_joyGetPosEx   _glfwLibrary.Libs.joyGetPosEx-#define _glfw_timeGetTime   _glfwLibrary.Libs.timeGetTime-#else-#define _glfw_joyGetDevCaps joyGetDevCapsA-#define _glfw_joyGetPos     joyGetPos-#define _glfw_joyGetPosEx   joyGetPosEx-#define _glfw_timeGetTime   timeGetTime-#endif // _GLFW_NO_DLOAD_WINMM---//========================================================================-// GLFW platform specific types-//========================================================================--//-------------------------------------------------------------------------// Pointer length integer-//-------------------------------------------------------------------------typedef INT_PTR GLFWintptr;---//-------------------------------------------------------------------------// Window structure-//-------------------------------------------------------------------------typedef struct _GLFWwin_struct _GLFWwin;--struct _GLFWwin_struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // User callback functions-    GLFWwindowsizefun    windowSizeCallback;-    GLFWwindowclosefun   windowCloseCallback;-    GLFWwindowrefreshfun windowRefreshCallback;-    GLFWmousebuttonfun   mouseButtonCallback;-    GLFWmouseposfun      mousePosCallback;-    GLFWmousewheelfun    mouseWheelCallback;-    GLFWkeyfun           keyCallback;-    GLFWcharfun          charCallback;--    // User selected window settings-    int       fullscreen;      // Fullscreen flag-    int       mouseLock;       // Mouse-lock flag-    int       autoPollEvents;  // Auto polling flag-    int       sysKeysDisabled; // System keys disabled flag-    int       windowNoResize;  // Resize- and maximize gadgets disabled flag-    int       refreshRate;     // Vertical monitor refresh rate--    // Window status & parameters-    int       opened;          // Flag telling if window is opened or not-    int       active;          // Application active flag-    int       iconified;       // Window iconified flag-    int       width, height;   // Window width and heigth-    int       accelerated;     // GL_TRUE if window is HW accelerated--    // Framebuffer attributes-    int       redBits;-    int       greenBits;-    int       blueBits;-    int       alphaBits;-    int       depthBits;-    int       stencilBits;-    int       accumRedBits;-    int       accumGreenBits;-    int       accumBlueBits;-    int       accumAlphaBits;-    int       auxBuffers;-    int       stereo;-    int       samples;--    // OpenGL extensions and context attributes-    int       has_GL_SGIS_generate_mipmap;-    int       has_GL_ARB_texture_non_power_of_two;-    int       glMajor, glMinor, glRevision;-    int       glForward, glDebug, glProfile;--    PFNGLGETSTRINGIPROC GetStringi;---// ========= PLATFORM SPECIFIC PART ======================================--    // Platform specific window resources-    HDC       DC;              // Private GDI device context-    HGLRC     context;         // Permanent rendering context-    HWND      window;          // Window handle-    ATOM      classAtom;       // Window class atom-    int       modeID;          // Mode ID for fullscreen mode-    HHOOK     keyboardHook;    // Keyboard hook handle-    DWORD     dwStyle;         // Window styles used for window creation-    DWORD     dwExStyle;       // --"----    // Platform specific extensions (context specific)-    PFNWGLSWAPINTERVALEXTPROC      SwapIntervalEXT;-    PFNWGLGETPIXELFORMATATTRIBIVARBPROC GetPixelFormatAttribivARB;-    PFNWGLGETEXTENSIONSSTRINGEXTPROC GetExtensionsStringEXT;-    PFNWGLGETEXTENSIONSSTRINGARBPROC GetExtensionsStringARB;-    PFNWGLCREATECONTEXTATTRIBSARBPROC CreateContextAttribsARB;-    GLboolean                      has_WGL_EXT_swap_control;-    GLboolean                      has_WGL_ARB_multisample;-    GLboolean                      has_WGL_ARB_pixel_format;-    GLboolean                      has_WGL_ARB_create_context;-    GLboolean                      has_WGL_ARB_create_context_profile;--    // Various platform specific internal variables-    int       oldMouseLock;    // Old mouse-lock flag (used for remembering-                               // mouse-lock state when iconifying)-    int       oldMouseLockValid;-    int       desiredRefreshRate; // Desired vertical monitor refresh rate--};--GLFWGLOBAL _GLFWwin _glfwWin;---//-------------------------------------------------------------------------// User input status (most of this should go in _GLFWwin)-//-------------------------------------------------------------------------GLFWGLOBAL struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // Mouse status-    int  MousePosX, MousePosY;-    int  WheelPos;-    char MouseButton[ GLFW_MOUSE_BUTTON_LAST+1 ];--    // Keyboard status-    char Key[ GLFW_KEY_LAST+1 ];-    int  LastChar;--    // User selected settings-    int  StickyKeys;-    int  StickyMouseButtons;-    int  KeyRepeat;---// ========= PLATFORM SPECIFIC PART ======================================--    // Platform specific internal variables-    int  MouseMoved, OldMouseX, OldMouseY;--} _glfwInput;---//-------------------------------------------------------------------------// Library global data-//-------------------------------------------------------------------------GLFWGLOBAL struct {--    // Window opening hints-    _GLFWhints      hints;--// ========= PLATFORM SPECIFIC PART ======================================--  HINSTANCE instance;        // Instance of the application--  // Timer data-  struct {-      int          HasPerformanceCounter;-      double       Resolution;-      unsigned int t0_32;-      __int64      t0_64;-  } Timer;--  // System information-  struct {-      int     winVer;-      int     hasUnicode;-      DWORD   foregroundLockTimeout;-  } Sys;--#if !defined(_GLFW_NO_DLOAD_WINMM) || !defined(_GLFW_NO_DLOAD_GDI32)-  // Library handles and function pointers-  struct {-#ifndef _GLFW_NO_DLOAD_GDI32-      // gdi32.dll-      HINSTANCE             gdi32;-      CHOOSEPIXELFORMAT_T   ChoosePixelFormat;-      DESCRIBEPIXELFORMAT_T DescribePixelFormat;-      GETPIXELFORMAT_T      GetPixelFormat;-      SETPIXELFORMAT_T      SetPixelFormat;-      SWAPBUFFERS_T         SwapBuffers;-#endif // _GLFW_NO_DLOAD_GDI32--      // winmm.dll-#ifndef _GLFW_NO_DLOAD_WINMM-      HINSTANCE             winmm;-      JOYGETDEVCAPSA_T      joyGetDevCapsA;-      JOYGETPOS_T           joyGetPos;-      JOYGETPOSEX_T         joyGetPosEx;-      TIMEGETTIME_T         timeGetTime;-#endif // _GLFW_NO_DLOAD_WINMM-  } Libs;-#endif--} _glfwLibrary;---//-------------------------------------------------------------------------// Thread record (one for each thread)-//-------------------------------------------------------------------------typedef struct _GLFWthread_struct _GLFWthread;--struct _GLFWthread_struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // Pointer to previous and next threads in linked list-    _GLFWthread   *Previous, *Next;--    // GLFW user side thread information-    GLFWthread    ID;-    GLFWthreadfun Function;--// ========= PLATFORM SPECIFIC PART ======================================--    // System side thread information-    HANDLE        Handle;-    DWORD         WinID;--};---//-------------------------------------------------------------------------// General thread information-//-------------------------------------------------------------------------GLFWGLOBAL struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // Next thread ID to use (increments for every created thread)-    GLFWthread       NextID;--    // First thread in linked list (always the main thread)-    _GLFWthread      First;--// ========= PLATFORM SPECIFIC PART ======================================--    // Critical section lock-    CRITICAL_SECTION CriticalSection;--} _glfwThrd;----//========================================================================-// Macros for encapsulating critical code sections (i.e. making parts-// of GLFW thread safe)-//========================================================================--// Thread list management-#define ENTER_THREAD_CRITICAL_SECTION \-        EnterCriticalSection( &_glfwThrd.CriticalSection );-#define LEAVE_THREAD_CRITICAL_SECTION \-        LeaveCriticalSection( &_glfwThrd.CriticalSection );---//========================================================================-// Various Windows version constants-//========================================================================--#define _GLFW_WIN_UNKNOWN    0x0000  // Earlier than 95 or NT4-#define _GLFW_WIN_95         0x0001-#define _GLFW_WIN_98         0x0002-#define _GLFW_WIN_ME         0x0003-#define _GLFW_WIN_UNKNOWN_9x 0x0004  // Later than ME-#define _GLFW_WIN_NT4        0x0101-#define _GLFW_WIN_2K         0x0102-#define _GLFW_WIN_XP         0x0103-#define _GLFW_WIN_NET_SERVER 0x0104-#define _GLFW_WIN_UNKNOWN_NT 0x0105  // Later than .NET Server---//========================================================================-// Prototypes for platform specific internal functions-//========================================================================--// Time-void _glfwInitTimer( void );--// Fullscreen support-int _glfwGetClosestVideoModeBPP( int *w, int *h, int *bpp, int *refresh );-int _glfwGetClosestVideoMode( int *w, int *h, int *r, int *g, int *b, int *refresh );-void _glfwSetVideoModeMODE( int mode );-void _glfwSetVideoMode( int *w, int *h, int r, int g, int b, int refresh );---#endif // _platform_h_
− glfw/lib/win32/win32_dllmain.c 
@@ -1,49 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Win32/WGL-// API version: 2.7-// WWW:         http://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"---#if defined(GLFW_BUILD_DLL)--//========================================================================-// GLFW DLL entry point-//========================================================================--BOOL WINAPI DllMain( HINSTANCE instance, DWORD reason, LPVOID reserved )-{-    // NOTE: Some compilers complains about instance and x never being used --    // never mind that (we don't want to use them)!--    return TRUE;-}--#endif // GLFW_BUILD_DLL-
− glfw/lib/win32/win32_enable.c 
@@ -1,155 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Win32/WGL-// API version: 2.7-// WWW:         http://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 internal functions                       ****-//************************************************************************--//========================================================================-// Low level keyboard hook (system callback) function-// Used to disable system keys under Windows NT-//========================================================================--static LRESULT CALLBACK keyboardHook( int nCode, WPARAM wParam, LPARAM lParam )-{-    BOOL syskeys = FALSE;-    PKBDLLHOOKSTRUCT p;--    // We are only looking for keyboard events - interpret lParam as a-    // pointer to a KBDLLHOOKSTRUCT-    p = (PKBDLLHOOKSTRUCT) lParam;--    if( nCode == HC_ACTION )-    {-        // We have a keyboard event--        switch( wParam )-        {-            case WM_KEYDOWN:-            case WM_SYSKEYDOWN:-            case WM_KEYUP:-            case WM_SYSKEYUP:-                // Detect: ALT+TAB, ALT+ESC, ALT+F4, CTRL+ESC,-                // LWIN, RWIN, APPS (mysterious menu key)-                syskeys = ( p->vkCode == VK_TAB &&-                            p->flags & LLKHF_ALTDOWN ) ||-                          ( p->vkCode == VK_ESCAPE &&-                            p->flags & LLKHF_ALTDOWN ) ||-                          ( p->vkCode == VK_F4 &&-                            p->flags & LLKHF_ALTDOWN ) ||-                          ( p->vkCode == VK_ESCAPE &&-                            (GetKeyState(VK_CONTROL) & 0x8000)) ||-                          p->vkCode == VK_LWIN ||-                          p->vkCode == VK_RWIN ||-                          p->vkCode == VK_APPS;-                break;--            default:-                break;-        }-    }--    // Was it a system key combination (e.g. ALT+TAB)?-    if( syskeys )-    {-        // Pass the key event to our window message loop-        if( _glfwWin.opened )-        {-            PostMessage( _glfwWin.window, (UINT) wParam, p->vkCode, 0 );-        }--        // We've taken care of it - don't let the system know about this-        // key event-        return 1;-    }-    else-    {-        // It's a harmless key press, let the system deal with it-        return CallNextHookEx( _glfwWin.keyboardHook, nCode, wParam, lParam );-    }-}----//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Enable system keys-//========================================================================--void _glfwPlatformEnableSystemKeys( void )-{-    BOOL dummy;--    // Use different methods depending on operating system version-    if( _glfwLibrary.Sys.winVer >= _GLFW_WIN_NT4 )-    {-        if( _glfwWin.keyboardHook != NULL )-        {-            UnhookWindowsHookEx( _glfwWin.keyboardHook );-            _glfwWin.keyboardHook = NULL;-        }-    }-    else-    {-        (void) SystemParametersInfo( SPI_SETSCREENSAVERRUNNING, FALSE, &dummy, 0 );-    }-}--//========================================================================-// Disable system keys-//========================================================================--void _glfwPlatformDisableSystemKeys( void )-{-    BOOL dummy;--    // Use different methods depending on operating system version-    if( _glfwLibrary.Sys.winVer >= _GLFW_WIN_NT4 )-    {-        // Under Windows NT, install a low level keyboard hook-        _glfwWin.keyboardHook = SetWindowsHookEx( WH_KEYBOARD_LL,-                                                  keyboardHook,-                                                  _glfwLibrary.instance,-                                                  0 );-    }-    else-    {-        // Under Windows 95/98/ME, fool Windows that a screensaver-        // is running => prevents ALT+TAB, CTRL+ESC and CTRL+ALT+DEL-        (void) SystemParametersInfo( SPI_SETSCREENSAVERRUNNING, TRUE, &dummy, 0 );-    }-}-
− glfw/lib/win32/win32_fullscreen.c 
@@ -1,320 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Win32/WGL-// API version: 2.7-// WWW:         http://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 internal functions                       ****-//************************************************************************--//========================================================================-// Convert BPP to RGB bits based on "best guess"-//========================================================================--static void bpp2rgb( int bpp, int *r, int *g, int *b )-{-    int delta;--    // We assume that by 32 they really meant 24-    if( bpp == 32 )-    {-        bpp = 24;-    }--    // Convert "bits per pixel" to red, green & blue sizes--    *r = *g = *b = bpp / 3;-    delta = bpp - (*r * 3);-    if( delta >= 1 )-    {-        *g = *g + 1;-    }-    if( delta == 2 )-    {-        *r = *r + 1;-    }-}---//========================================================================-// Return closest video mode by dimensions, refresh rate and bits per pixel-//========================================================================--int _glfwGetClosestVideoModeBPP( int *w, int *h, int *bpp, int *refresh )-{-    int     mode, bestmode, match, bestmatch, rr, bestrr, success;-    DEVMODE dm;--    // Find best match-    bestmatch = 0x7fffffff;-    bestrr    = 0x7fffffff;-    mode = bestmode = 0;-    do-    {-        dm.dmSize = sizeof( DEVMODE );-        success = EnumDisplaySettings( NULL, mode, &dm );-        if( success )-        {-            match = dm.dmBitsPerPel - *bpp;-            if( match < 0 ) match = -match;-            match = ( match << 25 ) |-                    ( (dm.dmPelsWidth - *w) *-                      (dm.dmPelsWidth - *w) +-                      (dm.dmPelsHeight - *h) *-                      (dm.dmPelsHeight - *h) );-            if( match < bestmatch )-            {-                bestmatch = match;-                bestmode  = mode;-                bestrr = (dm.dmDisplayFrequency - *refresh) *-                         (dm.dmDisplayFrequency - *refresh);-            }-            else if( match == bestmatch && *refresh > 0 )-            {-                rr = (dm.dmDisplayFrequency - *refresh) *-                     (dm.dmDisplayFrequency - *refresh);-                if( rr < bestrr )-                {-                    bestmatch = match;-                    bestmode  = mode;-                    bestrr    = rr;-                }-            }-        }-        mode ++;-    }-    while( success );--    // Get the parameters for the best matching display mode-    dm.dmSize = sizeof( DEVMODE );-    (void) EnumDisplaySettings( NULL, bestmode, &dm );--    // Fill out actual width and height-    *w = dm.dmPelsWidth;-    *h = dm.dmPelsHeight;--    // Return bits per pixel-    *bpp = dm.dmBitsPerPel;--    // Return vertical refresh rate-    *refresh = dm.dmDisplayFrequency;--    return bestmode;-}---//========================================================================-// Return closest video mode by dimensions, refresh rate and channel sizes-//========================================================================--static int getClosestVideoMode( int *w, int *h,-                                int *r, int *g, int *b,-                                int *refresh )-{-    int bpp, bestmode;--    // Colorbits = sum of red/green/blue bits-    bpp = *r + *g + *b;--    // If colorbits < 15 (e.g. 0) or >= 24, default to 32 bpp-    if( bpp < 15 || bpp >= 24 )-    {-        bpp = 32;-    }--    // Find best match-    bestmode = _glfwGetClosestVideoModeBPP( w, h, &bpp, refresh );--    // Convert "bits per pixel" to red, green & blue sizes-    bpp2rgb( bpp, r, g, b );--    return bestmode;-}---//========================================================================-// Change the current video mode-//========================================================================--void _glfwSetVideoModeMODE( int mode )-{-    DEVMODE dm;-    int success;--    // Get the parameters for the best matching display mode-    dm.dmSize = sizeof( DEVMODE );-    (void) EnumDisplaySettings( NULL, mode, &dm );--    // Set which fields we want to specify-    dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;--    // Do we have a prefered refresh rate?-    if( _glfwWin.desiredRefreshRate > 0 )-    {-        dm.dmFields = dm.dmFields | DM_DISPLAYFREQUENCY;-        dm.dmDisplayFrequency = _glfwWin.desiredRefreshRate;-    }--    // Change display setting-    dm.dmSize = sizeof( DEVMODE );-    success = ChangeDisplaySettings( &dm, CDS_FULLSCREEN );--    // If the mode change was not possible, query the current display-    // settings (we'll use the desktop resolution for fullscreen mode)-    if( success == DISP_CHANGE_SUCCESSFUL )-    {-        _glfwWin.modeID = mode;-    }-    else-    {-        _glfwWin.modeID = ENUM_REGISTRY_SETTINGS;-        EnumDisplaySettings( NULL, ENUM_REGISTRY_SETTINGS, &dm );-    }--    // Set the window size to that of the display mode-    _glfwWin.width  = dm.dmPelsWidth;-    _glfwWin.height = dm.dmPelsHeight;-}---//========================================================================-// Change the current video mode-//========================================================================--void _glfwSetVideoMode( int *w, int *h, int r, int g, int b, int refresh )-{-    int     bestmode;--    // Find a best match mode-    bestmode = getClosestVideoMode( w, h, &r, &g, &b, &refresh );--    // Change mode-    _glfwSetVideoModeMODE( bestmode );-}---//************************************************************************-//****                    GLFW user functions                         ****-//************************************************************************--//========================================================================-// Get a list of available video modes-//========================================================================--int _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount )-{-    int count, success, mode, i, j;-    int m1, m2, bpp, r, g, b;-    DEVMODE dm;--    // Loop through all video modes and extract all the UNIQUE modes-    count = 0;-    mode  = 0;-    do-    {-        // Get video mode properties-        dm.dmSize = sizeof( DEVMODE );-        success = EnumDisplaySettings( NULL, mode, &dm );--        // Is it a valid mode? (only list depths >= 15 bpp)-        if( success && dm.dmBitsPerPel >= 15 )-        {-            // Convert to RGB, and back to bpp ("mask out" alpha bits etc)-            bpp2rgb( dm.dmBitsPerPel, &r, &g, &b );-            bpp = r + g + b;--            // Mode "code" for this mode-            m1 = (bpp << 25) | (dm.dmPelsWidth * dm.dmPelsHeight);--            // Insert mode in list (sorted), and avoid duplicates-            for( i = 0; i < count; i ++ )-            {-                // Mode "code" for already listed mode-                bpp = list[i].RedBits + list[i].GreenBits +-                      list[i].BlueBits;-                m2 = (bpp << 25) | (list[i].Width * list[i].Height);-                if( m1 <= m2 )-                {-                    break;-                }-            }--            // New entry at the end of the list?-            if( i >= count )-            {-                list[count].Width     = dm.dmPelsWidth;-                list[count].Height    = dm.dmPelsHeight;-                list[count].RedBits   = r;-                list[count].GreenBits = g;-                list[count].BlueBits  = b;-                count ++;-            }-            // Insert new entry in the list?-            else if( m1 < m2 )-            {-                for( j = count; j > i; j -- )-                {-                    list[j] = list[j-1];-                }-                list[i].Width     = dm.dmPelsWidth;-                list[i].Height    = dm.dmPelsHeight;-                list[i].RedBits   = r;-                list[i].GreenBits = g;-                list[i].BlueBits  = b;-                count ++;-            }-        }-        mode ++;-    }-    while( success && (count < maxcount) );--    return count;-}---//========================================================================-// Get the desktop video mode-//========================================================================--void _glfwPlatformGetDesktopMode( GLFWvidmode *mode )-{-    DEVMODE dm;--    // Get desktop display mode-    dm.dmSize = sizeof( DEVMODE );-    (void) EnumDisplaySettings( NULL, ENUM_REGISTRY_SETTINGS, &dm );--    // Return desktop mode parameters-    mode->Width  = dm.dmPelsWidth;-    mode->Height = dm.dmPelsHeight;-    bpp2rgb( dm.dmBitsPerPel, &mode->RedBits, &mode->GreenBits, &mode->BlueBits );-}-
− glfw/lib/win32/win32_glext.c 
@@ -1,82 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Win32/WGL-// API version: 2.7-// WWW:         http://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"---//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Check if the current context supports the specified WGL extension-//========================================================================--int _glfwPlatformExtensionSupported( const char *extension )-{-    const GLubyte *extensions;--    if( _glfwWin.GetExtensionsStringEXT != NULL )-    {-        extensions = (GLubyte *) _glfwWin.GetExtensionsStringEXT();-        if( extensions != NULL )-        {-            if( _glfwStringInExtensionString( extension, extensions ) )-            {-                return GL_TRUE;-            }-        }-    }--    if( _glfwWin.GetExtensionsStringARB != NULL )-    {-        extensions = (GLubyte *) _glfwWin.GetExtensionsStringARB( _glfwWin.DC );-        if( extensions != NULL )-        {-            if( _glfwStringInExtensionString( extension, extensions ) )-            {-                return GL_TRUE;-            }-        }-    }--    return GL_FALSE;-}---//========================================================================-// Get the function pointer to an OpenGL function-//========================================================================--void *_glfwPlatformGetProcAddress( const char *procname )-{-    return (void *) wglGetProcAddress( procname );-}-
− glfw/lib/win32/win32_init.c 
@@ -1,356 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Win32/WGL-// API version: 2.7-// WWW:         http://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"--// With the Borland C++ compiler, we want to disable FPU exceptions-#ifdef __BORLANDC__-#include <float.h>-#endif // __BORLANDC__----//************************************************************************-//****                  GLFW internal functions                       ****-//************************************************************************--//========================================================================-// Load necessary libraries (DLLs)-//========================================================================--static int _glfwInitLibraries( void )-{-    // gdi32.dll (OpenGL pixel format functions & SwapBuffers)-#ifndef _GLFW_NO_DLOAD_GDI32-    _glfwLibrary.Libs.gdi32 = LoadLibrary( "gdi32.dll" );-    if( _glfwLibrary.Libs.gdi32 != NULL )-    {-        _glfwLibrary.Libs.ChoosePixelFormat   = (CHOOSEPIXELFORMAT_T)-            GetProcAddress( _glfwLibrary.Libs.gdi32, "ChoosePixelFormat" );-        _glfwLibrary.Libs.DescribePixelFormat = (DESCRIBEPIXELFORMAT_T)-            GetProcAddress( _glfwLibrary.Libs.gdi32, "DescribePixelFormat" );-        _glfwLibrary.Libs.GetPixelFormat      = (GETPIXELFORMAT_T)-            GetProcAddress( _glfwLibrary.Libs.gdi32, "GetPixelFormat" );-        _glfwLibrary.Libs.SetPixelFormat      = (SETPIXELFORMAT_T)-            GetProcAddress( _glfwLibrary.Libs.gdi32, "SetPixelFormat" );-        _glfwLibrary.Libs.SwapBuffers         = (SWAPBUFFERS_T)-            GetProcAddress( _glfwLibrary.Libs.gdi32, "SwapBuffers" );-        if( _glfwLibrary.Libs.ChoosePixelFormat   == NULL ||-            _glfwLibrary.Libs.DescribePixelFormat == NULL ||-            _glfwLibrary.Libs.GetPixelFormat      == NULL ||-            _glfwLibrary.Libs.SetPixelFormat      == NULL ||-            _glfwLibrary.Libs.SwapBuffers         == NULL )-        {-            FreeLibrary( _glfwLibrary.Libs.gdi32 );-            _glfwLibrary.Libs.gdi32 = NULL;-            return GL_FALSE;-        }-    }-    else-    {-        return GL_FALSE;-    }-#endif // _GLFW_NO_DLOAD_GDI32--    // winmm.dll (for joystick and timer support)-#ifndef _GLFW_NO_DLOAD_WINMM-    _glfwLibrary.Libs.winmm = LoadLibrary( "winmm.dll" );-    if( _glfwLibrary.Libs.winmm != NULL )-    {-        _glfwLibrary.Libs.joyGetDevCapsA = (JOYGETDEVCAPSA_T)-            GetProcAddress( _glfwLibrary.Libs.winmm, "joyGetDevCapsA" );-        _glfwLibrary.Libs.joyGetPos      = (JOYGETPOS_T)-            GetProcAddress( _glfwLibrary.Libs.winmm, "joyGetPos" );-        _glfwLibrary.Libs.joyGetPosEx    = (JOYGETPOSEX_T)-            GetProcAddress( _glfwLibrary.Libs.winmm, "joyGetPosEx" );-        _glfwLibrary.Libs.timeGetTime    = (TIMEGETTIME_T)-            GetProcAddress( _glfwLibrary.Libs.winmm, "timeGetTime" );-        if( _glfwLibrary.Libs.joyGetDevCapsA == NULL ||-            _glfwLibrary.Libs.joyGetPos      == NULL ||-            _glfwLibrary.Libs.joyGetPosEx    == NULL ||-            _glfwLibrary.Libs.timeGetTime    == NULL )-        {-            FreeLibrary( _glfwLibrary.Libs.winmm );-            _glfwLibrary.Libs.winmm = NULL;-            return GL_FALSE;-        }-    }-    else-    {-        return GL_FALSE;-    }-#endif // _GLFW_NO_DLOAD_WINMM--    return GL_TRUE;-}---//========================================================================-// Unload used libraries (DLLs)-//========================================================================--static void _glfwFreeLibraries( void )-{-    // gdi32.dll-#ifndef _GLFW_NO_DLOAD_GDI32-    if( _glfwLibrary.Libs.gdi32 != NULL )-    {-        FreeLibrary( _glfwLibrary.Libs.gdi32 );-        _glfwLibrary.Libs.gdi32 = NULL;-    }-#endif // _GLFW_NO_DLOAD_GDI32--    // winmm.dll-#ifndef _GLFW_NO_DLOAD_WINMM-    if( _glfwLibrary.Libs.winmm != NULL )-    {-        FreeLibrary( _glfwLibrary.Libs.winmm );-        _glfwLibrary.Libs.winmm = NULL;-    }-#endif // _GLFW_NO_DLOAD_WINMM-}---//========================================================================-// Initialize GLFW thread package-//========================================================================--static void _glfwInitThreads( void )-{-    // Initialize critical section handle-    InitializeCriticalSection( &_glfwThrd.CriticalSection );--    // The first thread (the main thread) has ID 0-    _glfwThrd.NextID = 0;--    // Fill out information about the main thread (this thread)-    _glfwThrd.First.ID       = _glfwThrd.NextID ++;-    _glfwThrd.First.Function = NULL;-    _glfwThrd.First.Handle   = GetCurrentThread();-    _glfwThrd.First.WinID    = GetCurrentThreadId();-    _glfwThrd.First.Previous = NULL;-    _glfwThrd.First.Next     = NULL;-}---//========================================================================-// Terminate GLFW thread package-//========================================================================--static void _glfwTerminateThreads( void )-{-    _GLFWthread *t, *t_next;--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Kill all threads (NOTE: THE USER SHOULD WAIT FOR ALL THREADS TO-    // DIE, _BEFORE_ CALLING glfwTerminate()!!!)-    t = _glfwThrd.First.Next;-    while( t != NULL )-    {-        // Get pointer to next thread-        t_next = t->Next;--        // Simply murder the process, no mercy!-        if( TerminateThread( t->Handle, 0 ) )-        {-            // Close thread handle-            CloseHandle( t->Handle );--            // Free memory allocated for this thread-            free( (void *) t );-        }--        // Select next thread in list-        t = t_next;-    }--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Delete critical section handle-    DeleteCriticalSection( &_glfwThrd.CriticalSection );-}---//========================================================================-// Terminate GLFW when exiting application-//========================================================================--void _glfwTerminate_atexit( void )-{-    glfwTerminate();-}----//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Initialize various GLFW state-//========================================================================--int _glfwPlatformInit( void )-{-    OSVERSIONINFO osi;--    // 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,-                          &_glfwLibrary.Sys.foregroundLockTimeout, 0 );-    SystemParametersInfo( SPI_SETFOREGROUNDLOCKTIMEOUT, 0, (LPVOID)0,-                          SPIF_SENDCHANGE );--    // Check which OS version we are running-    osi.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );-    GetVersionEx( &osi );-    _glfwLibrary.Sys.winVer = _GLFW_WIN_UNKNOWN;-    if( osi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )-    {-        if( osi.dwMajorVersion == 4 && osi.dwMinorVersion < 10 )-        {-            _glfwLibrary.Sys.winVer = _GLFW_WIN_95;-        }-        else if( osi.dwMajorVersion == 4 && osi.dwMinorVersion < 90 )-        {-            _glfwLibrary.Sys.winVer = _GLFW_WIN_98;-        }-        else if( osi.dwMajorVersion == 4 && osi.dwMinorVersion == 90 )-        {-            _glfwLibrary.Sys.winVer = _GLFW_WIN_ME;-        }-        else if( osi.dwMajorVersion >= 4 )-        {-            _glfwLibrary.Sys.winVer = _GLFW_WIN_UNKNOWN_9x;-        }-    }-    else if( osi.dwPlatformId == VER_PLATFORM_WIN32_NT )-    {-        if( osi.dwMajorVersion == 4 && osi.dwMinorVersion == 0 )-        {-            _glfwLibrary.Sys.winVer = _GLFW_WIN_NT4;-        }-        else if( osi.dwMajorVersion == 5 && osi.dwMinorVersion == 0 )-        {-            _glfwLibrary.Sys.winVer = _GLFW_WIN_2K;-        }-        else if( osi.dwMajorVersion == 5 && osi.dwMinorVersion == 1 )-        {-            _glfwLibrary.Sys.winVer = _GLFW_WIN_XP;-        }-        else if( osi.dwMajorVersion == 5 && osi.dwMinorVersion == 2 )-        {-            _glfwLibrary.Sys.winVer = _GLFW_WIN_NET_SERVER;-        }-        else if( osi.dwMajorVersion >= 5 )-        {-            _glfwLibrary.Sys.winVer = _GLFW_WIN_UNKNOWN_NT;-        }-    }--    // Do we have Unicode support?-    if( _glfwLibrary.Sys.winVer >= _GLFW_WIN_NT4 )-    {-        // Windows NT/2000/XP/.NET has Unicode support-        _glfwLibrary.Sys.hasUnicode = GL_TRUE;-    }-    else-    {-        // Windows 9x/ME does not have Unicode support-        _glfwLibrary.Sys.hasUnicode = GL_FALSE;-    }--    // Load libraries (DLLs)-    if( !_glfwInitLibraries() )-    {-        return GL_FALSE;-    }--    // With the Borland C++ compiler, we want to disable FPU exceptions-    // (this is recommended for OpenGL applications under Windows)-#ifdef __BORLANDC__-    _control87( MCW_EM, MCW_EM );-#endif--    // Retrieve GLFW instance handle-    _glfwLibrary.instance = GetModuleHandle( NULL );--    // System keys are not disabled-    _glfwWin.keyboardHook = NULL;--    // Initialise thread package-    _glfwInitThreads();--    // Install atexit() routine-    atexit( _glfwTerminate_atexit );--    // Start the timer-    _glfwInitTimer();--    return GL_TRUE;-}---//========================================================================-// Close window and kill all threads-//========================================================================--int _glfwPlatformTerminate( void )-{-    // Only the main thread is allowed to do this...-    if( GetCurrentThreadId() != _glfwThrd.First.WinID )-    {-        return GL_FALSE;-    }--    // Close OpenGL window-    glfwCloseWindow();--    // Kill thread package-    _glfwTerminateThreads();--    // Enable system keys again (if they were disabled)-    glfwEnable( GLFW_SYSTEM_KEYS );--    // Unload libraries (DLLs)-    _glfwFreeLibraries();--    // Restore FOREGROUNDLOCKTIMEOUT system setting-    SystemParametersInfo( SPI_SETFOREGROUNDLOCKTIMEOUT, 0,-                          (LPVOID) _glfwLibrary.Sys.foregroundLockTimeout,-                          SPIF_SENDCHANGE );--    return GL_TRUE;-}-
− glfw/lib/win32/win32_joystick.c 
@@ -1,233 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Win32/WGL-// API version: 2.7-// WWW:         http://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 internal functions                       ****-//************************************************************************--//========================================================================-// Return GL_TRUE if joystick is present, else return GL_FALSE.-//========================================================================--static int _glfwJoystickPresent( int joy )-{-    JOYINFO ji;--    // Windows NT 4.0 MMSYSTEM only supports 2 sticks (other Windows-    // versions support 16 sticks)-    if( _glfwLibrary.Sys.winVer == _GLFW_WIN_NT4 && joy > GLFW_JOYSTICK_2 )-    {-        return GL_FALSE;-    }--    // Is it a valid stick ID (Windows don't support more than 16 sticks)?-    if( joy < GLFW_JOYSTICK_1 || joy > GLFW_JOYSTICK_16 )-    {-        return GL_FALSE;-    }--    // Is the joystick present?-    if( _glfw_joyGetPos( joy - GLFW_JOYSTICK_1, &ji ) != JOYERR_NOERROR )-    {-        return GL_FALSE;-    }--    return GL_TRUE;-}---//========================================================================-// Calculate joystick position-//========================================================================--static float _glfwCalcJoystickPos( DWORD pos, DWORD min, DWORD max )-{-    float fpos = (float) pos;-    float fmin = (float) min;-    float fmax = (float) max;-    return (2.0f*(fpos - fmin) / (fmax - fmin)) - 1.0f;-}----//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Determine joystick capabilities-//========================================================================--int _glfwPlatformGetJoystickParam( int joy, int param )-{-    JOYCAPS jc;--//  return 0;--    // Is joystick present?-    if( !_glfwJoystickPresent( joy ) )-    {-        return 0;-    }--    // We got this far, the joystick is present-    if( param == GLFW_PRESENT )-    {-        return GL_TRUE;-    }--    // Get joystick capabilities-    _glfw_joyGetDevCaps( joy - GLFW_JOYSTICK_1, &jc, sizeof(JOYCAPS) );--    switch( param )-    {-    case GLFW_AXES:-        // Return number of joystick axes-        return jc.wNumAxes;--    case GLFW_BUTTONS:-        // Return number of joystick axes-        return jc.wNumButtons;--    default:-        break;-    }--    return 0;-}---//========================================================================-// Get joystick axis positions-//========================================================================--int _glfwPlatformGetJoystickPos( int joy, float *pos, int numaxes )-{-    JOYCAPS   jc;-    JOYINFOEX ji;-    int       axis;--//  return 0;--    // Is joystick present?-    if( !_glfwJoystickPresent( joy ) )-    {-        return 0;-    }--    // Get joystick capabilities-    _glfw_joyGetDevCaps( joy - GLFW_JOYSTICK_1, &jc, sizeof(JOYCAPS) );--    // Get joystick state-    ji.dwSize = sizeof( JOYINFOEX );-    ji.dwFlags = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ |-                 JOY_RETURNR | JOY_RETURNU | JOY_RETURNV;-    _glfw_joyGetPosEx( joy - GLFW_JOYSTICK_1, &ji );--    // Get position values for all axes-    axis = 0;-    if( axis < numaxes )-    {-        pos[ axis++ ] = _glfwCalcJoystickPos( ji.dwXpos, jc.wXmin,-                                              jc.wXmax );-    }-    if( axis < numaxes )-    {-        pos[ axis++ ] = -_glfwCalcJoystickPos( ji.dwYpos, jc.wYmin,-                                               jc.wYmax );-    }-    if( axis < numaxes && jc.wCaps & JOYCAPS_HASZ )-    {-        pos[ axis++ ] = _glfwCalcJoystickPos( ji.dwZpos, jc.wZmin,-                                              jc.wZmax );-    }-    if( axis < numaxes && jc.wCaps & JOYCAPS_HASR )-    {-        pos[ axis++ ] = _glfwCalcJoystickPos( ji.dwRpos, jc.wRmin,-                                              jc.wRmax );-    }-    if( axis < numaxes && jc.wCaps & JOYCAPS_HASU )-    {-        pos[ axis++ ] = _glfwCalcJoystickPos( ji.dwUpos, jc.wUmin,-                                              jc.wUmax );-    }-    if( axis < numaxes && jc.wCaps & JOYCAPS_HASV )-    {-        pos[ axis++ ] = -_glfwCalcJoystickPos( ji.dwVpos, jc.wVmin,-                                               jc.wVmax );-    }--    // Return number of returned axes-    return axis;-}---//========================================================================-// Get joystick button states-//========================================================================--int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons,-    int numbuttons )-{-    JOYCAPS   jc;-    JOYINFOEX ji;-    int       button;--//  return 0;--    // Is joystick present?-    if( !_glfwJoystickPresent( joy ) )-    {-        return 0;-    }--    // Get joystick capabilities-    _glfw_joyGetDevCaps( joy - GLFW_JOYSTICK_1, &jc, sizeof(JOYCAPS) );--    // Get joystick state-    ji.dwSize = sizeof( JOYINFOEX );-    ji.dwFlags = JOY_RETURNBUTTONS;-    _glfw_joyGetPosEx( joy - GLFW_JOYSTICK_1, &ji );--    // Get states of all requested buttons-    button = 0;-    while( button < numbuttons && button < (int) jc.wNumButtons )-    {-        buttons[ button ] = (unsigned char)-            (ji.dwButtons & (1UL << button) ? GLFW_PRESS : GLFW_RELEASE);-        button ++;-    }--    return button;-}-
− glfw/lib/win32/win32_thread.c 
@@ -1,506 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Win32/WGL-// API version: 2.7-// WWW:         http://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"---//************************************************************************-// This is an implementation of POSIX "compatible" condition variables for-// Win32, as described by Douglas C. Schmidt and Irfan Pyarali:-// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html-//************************************************************************--enum {-    _GLFW_COND_SIGNAL     = 0,-    _GLFW_COND_BROADCAST  = 1-};--typedef struct {-    // Signal and broadcast event HANDLEs-    HANDLE events[ 2 ];--    // Count of the number of waiters-    unsigned int waiters_count;--    // Serialize access to <waiters_count>-    CRITICAL_SECTION waiters_count_lock;-} _GLFWcond;----//************************************************************************-//****                  GLFW internal functions                       ****-//************************************************************************--//========================================================================-// This is simply a "wrapper" for calling the user thread function.-//========================================================================--DWORD WINAPI _glfwNewThread( LPVOID lpParam )-{-    GLFWthreadfun threadfun;-    _GLFWthread   *t;--    // Get pointer to thread information for current thread-    t = _glfwGetThreadPointer( _glfwPlatformGetThreadID() );-    if( t == NULL )-    {-        return 0;-    }--    // Get user thread function pointer-    threadfun = t->Function;--    // Call the user thread function-    threadfun( (void *) lpParam );--    // Remove thread from thread list-    ENTER_THREAD_CRITICAL_SECTION-    _glfwRemoveThread( t );-    LEAVE_THREAD_CRITICAL_SECTION--    // When the thread function returns, the thread will die...-    return 0;-}----//************************************************************************-//****                     GLFW user functions                        ****-//************************************************************************--//========================================================================-// Create a new thread-//========================================================================--GLFWthread _glfwPlatformCreateThread( GLFWthreadfun fun, void *arg )-{-    GLFWthread  ID;-    _GLFWthread *t, *t_tmp;-    HANDLE      hThread;-    DWORD       dwThreadId;--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Create a new thread information memory area-    t = (_GLFWthread *) malloc( sizeof(_GLFWthread) );-    if( t == NULL )-    {-        // Leave critical section-        LEAVE_THREAD_CRITICAL_SECTION-        return -1;-    }--    // Get a new unique thread id-    ID = _glfwThrd.NextID ++;--    // Store thread information in the thread list-    t->Function = fun;-    t->ID       = ID;--    // Create thread-    hThread = CreateThread(-        NULL,              // Default security attributes-        0,                 // Default stack size (1 MB)-        _glfwNewThread,    // Thread function (a wrapper function)-        (LPVOID)arg,       // Argument to thread is the user argument-        0,                 // Default creation flags-        &dwThreadId        // Returned thread identifier-    );--    // Did the thread creation fail?-    if( hThread == NULL )-    {-        free( (void *) t );-        LEAVE_THREAD_CRITICAL_SECTION-        return -1;-    }--    // Store more thread information in the thread list-    t->Handle = hThread;-    t->WinID  = dwThreadId;--    // Append thread to thread list-    t_tmp = &_glfwThrd.First;-    while( t_tmp->Next != NULL )-    {-        t_tmp = t_tmp->Next;-    }-    t_tmp->Next = t;-    t->Previous = t_tmp;-    t->Next     = NULL;--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Return the GLFW thread ID-    return ID;-}---//========================================================================-// Kill a thread. NOTE: THIS IS A VERY DANGEROUS OPERATION, AND SHOULD NOT-// BE USED EXCEPT IN EXTREME SITUATIONS!-//========================================================================--void _glfwPlatformDestroyThread( GLFWthread ID )-{-    _GLFWthread *t;--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Get thread information pointer-    t = _glfwGetThreadPointer( ID );-    if( t == NULL )-    {-        LEAVE_THREAD_CRITICAL_SECTION-        return;-    }--    // Simply murder the process, no mercy!-    if( TerminateThread( t->Handle, 0 ) )-    {-        // Close thread handle-        CloseHandle( t->Handle );--        // Remove thread from thread list-        _glfwRemoveThread( t );-    }--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION-}---//========================================================================-// Wait for a thread to die-//========================================================================--int _glfwPlatformWaitThread( GLFWthread ID, int waitmode )-{-    DWORD       result;-    HANDLE      hThread;-    _GLFWthread *t;--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Get thread information pointer-    t = _glfwGetThreadPointer( ID );--    // Is the thread already dead?-    if( t == NULL )-    {-        LEAVE_THREAD_CRITICAL_SECTION-        return GL_TRUE;-    }--    // Get thread handle-    hThread = t->Handle;--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Wait for thread to die-    if( waitmode == GLFW_WAIT )-    {-        result = WaitForSingleObject( hThread, INFINITE );-    }-    else if( waitmode == GLFW_NOWAIT )-    {-        result = WaitForSingleObject( hThread, 0 );-    }-    else-    {-        return GL_FALSE;-    }--    // Did we have a time-out?-    if( result == WAIT_TIMEOUT )-    {-        return GL_FALSE;-    }-    return GL_TRUE;-}---//========================================================================-// Return the thread ID for the current thread-//========================================================================--GLFWthread _glfwPlatformGetThreadID( void )-{-    _GLFWthread *t;-    GLFWthread  ID = -1;-    DWORD       WinID;--    // Get Windows thread ID-    WinID = GetCurrentThreadId();--    // Enter critical section (to avoid an inconsistent thread list)-    ENTER_THREAD_CRITICAL_SECTION--    // Loop through entire list of threads to find the matching Windows-    // thread ID-    for( t = &_glfwThrd.First; t != NULL; t = t->Next )-    {-        if( t->WinID == WinID )-        {-            ID = t->ID;-            break;-        }-    }--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Return the found GLFW thread identifier-    return ID;-}---//========================================================================-// Create a mutual exclusion object-//========================================================================--GLFWmutex _glfwPlatformCreateMutex( void )-{-    CRITICAL_SECTION *mutex;--    // Allocate memory for mutex-    mutex = (CRITICAL_SECTION *) malloc( sizeof(CRITICAL_SECTION) );-    if( !mutex )-    {-        return NULL;-    }--    // Initialize mutex-    InitializeCriticalSection( mutex );--    // Cast to GLFWmutex and return-    return (GLFWmutex) mutex;-}---//========================================================================-// Destroy a mutual exclusion object-//========================================================================--void _glfwPlatformDestroyMutex( GLFWmutex mutex )-{-    // Destroy mutex-    DeleteCriticalSection( (CRITICAL_SECTION *) mutex );-    free( mutex );-}---//========================================================================-// Request access to a mutex-//========================================================================--void _glfwPlatformLockMutex( GLFWmutex mutex )-{-    // Wait for mutex to be released-    EnterCriticalSection( (CRITICAL_SECTION *) mutex );-}---//========================================================================-// Release a mutex-//========================================================================--void _glfwPlatformUnlockMutex( GLFWmutex mutex )-{-    // Release mutex-    LeaveCriticalSection( (CRITICAL_SECTION *) mutex );-}---//========================================================================-// Create a new condition variable object-//========================================================================--GLFWcond _glfwPlatformCreateCond( void )-{-    _GLFWcond   *cond;--    // Allocate memory for condition variable-    cond = (_GLFWcond *) malloc( sizeof(_GLFWcond) );-    if( !cond )-    {-        return NULL;-    }--    // Initialize condition variable-    cond->waiters_count = 0;-    cond->events[ _GLFW_COND_SIGNAL ]    = CreateEvent( NULL, FALSE,-                                                        FALSE, NULL );-    cond->events[ _GLFW_COND_BROADCAST ] = CreateEvent( NULL, TRUE,-                                                        FALSE, NULL );-    InitializeCriticalSection( &cond->waiters_count_lock );--    // Cast to GLFWcond and return-    return (GLFWcond) cond;-}---//========================================================================-// Destroy a condition variable object-//========================================================================--void _glfwPlatformDestroyCond( GLFWcond cond )-{-    // Close the condition variable handles-    CloseHandle( ((_GLFWcond *)cond)->events[ _GLFW_COND_SIGNAL ] );-    CloseHandle( ((_GLFWcond *)cond)->events[ _GLFW_COND_BROADCAST ] );--    // Delete critical section-    DeleteCriticalSection( &((_GLFWcond *)cond)->waiters_count_lock );--    // Free memory for condition variable-    free( (void *) cond );-}---//========================================================================-// Wait for a condition to be raised-//========================================================================--void _glfwPlatformWaitCond( GLFWcond cond, GLFWmutex mutex, double timeout )-{-    _GLFWcond *cv = (_GLFWcond *) cond;-    int       result, last_waiter;-    DWORD     timeout_ms;--    // Avoid race conditions-    EnterCriticalSection( &cv->waiters_count_lock );-    cv->waiters_count ++;-    LeaveCriticalSection( &cv->waiters_count_lock );--    // It's ok to release the mutex here since Win32 manual-reset events-    // maintain state when used with SetEvent()-    LeaveCriticalSection( (CRITICAL_SECTION *) mutex );--    // Translate timeout into milliseconds-    if( timeout >= GLFW_INFINITY )-    {-        timeout_ms = INFINITE;-    }-    else-    {-        timeout_ms = (DWORD) (1000.0 * timeout + 0.5);-        if( timeout_ms <= 0 )-        {-            timeout_ms = 1;-        }-    }--    // Wait for either event to become signaled due to glfwSignalCond or-    // glfwBroadcastCond being called-    result = WaitForMultipleObjects( 2, cv->events, FALSE, timeout_ms );--    // Check if we are the last waiter-    EnterCriticalSection( &cv->waiters_count_lock );-    cv->waiters_count --;-    last_waiter = (result == WAIT_OBJECT_0 + _GLFW_COND_BROADCAST) &&-                  (cv->waiters_count == 0);-    LeaveCriticalSection( &cv->waiters_count_lock );--    // Some thread called glfwBroadcastCond-    if( last_waiter )-    {-        // We're the last waiter to be notified or to stop waiting, so-        // reset the manual event-        ResetEvent( cv->events[ _GLFW_COND_BROADCAST ] );-    }--    // Reacquire the mutex-    EnterCriticalSection( (CRITICAL_SECTION *) mutex );-}---//========================================================================-// Signal a condition to one waiting thread-//========================================================================--void _glfwPlatformSignalCond( GLFWcond cond )-{-    _GLFWcond *cv = (_GLFWcond *) cond;-    int       have_waiters;--    // Avoid race conditions-    EnterCriticalSection( &cv->waiters_count_lock );-    have_waiters = cv->waiters_count > 0;-    LeaveCriticalSection( &cv->waiters_count_lock );--    if( have_waiters )-    {-        SetEvent( cv->events[ _GLFW_COND_SIGNAL ] );-    }-}---//========================================================================-// Broadcast a condition to all waiting threads-//========================================================================--void _glfwPlatformBroadcastCond( GLFWcond cond )-{-    _GLFWcond *cv = (_GLFWcond *) cond;-    int       have_waiters;--    // Avoid race conditions-    EnterCriticalSection( &cv->waiters_count_lock );-    have_waiters = cv->waiters_count > 0;-    LeaveCriticalSection( &cv->waiters_count_lock );--    if( have_waiters )-    {-        SetEvent( cv->events[ _GLFW_COND_BROADCAST ] );-    }-}---//========================================================================-// Return the number of processors in the system.-//========================================================================--int _glfwPlatformGetNumberOfProcessors( void )-{-    SYSTEM_INFO si;--    // Get hardware system information-    GetSystemInfo( &si );--    return (int) si.dwNumberOfProcessors;-}-
− glfw/lib/win32/win32_time.c 
@@ -1,146 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Win32/WGL-// API version: 2.7-// WWW:         http://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 internal functions                       ****-//************************************************************************--//========================================================================-// Initialise timer-//========================================================================--void _glfwInitTimer( void )-{-    __int64 freq;--    // Check if we have a performance counter-    if( QueryPerformanceFrequency( (LARGE_INTEGER *)&freq ) )-    {-        // Performance counter is available => use it!-        _glfwLibrary.Timer.HasPerformanceCounter = GL_TRUE;--        // Counter resolution is 1 / counter frequency-        _glfwLibrary.Timer.Resolution = 1.0 / (double)freq;--        // Set start time for timer-        QueryPerformanceCounter( (LARGE_INTEGER *)&_glfwLibrary.Timer.t0_64 );-    }-    else-    {-        // No performace counter available => use the tick counter-        _glfwLibrary.Timer.HasPerformanceCounter = GL_FALSE;--        // Counter resolution is 1 ms-        _glfwLibrary.Timer.Resolution = 0.001;--        // Set start time for timer-        _glfwLibrary.Timer.t0_32 = _glfw_timeGetTime();-    }-}---//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Return timer value in seconds-//========================================================================--double _glfwPlatformGetTime( void )-{-    double  t;-    __int64 t_64;--    if( _glfwLibrary.Timer.HasPerformanceCounter )-    {-        QueryPerformanceCounter( (LARGE_INTEGER *)&t_64 );-        t =  (double)(t_64 - _glfwLibrary.Timer.t0_64);-    }-    else-    {-        t = (double)(_glfw_timeGetTime() - _glfwLibrary.Timer.t0_32);-    }--    // Calculate the current time in seconds-    return t * _glfwLibrary.Timer.Resolution;-}---//========================================================================-// Set timer value in seconds-//========================================================================--void _glfwPlatformSetTime( double t )-{-    __int64 t_64;--    if( _glfwLibrary.Timer.HasPerformanceCounter )-    {-        QueryPerformanceCounter( (LARGE_INTEGER *)&t_64 );-        _glfwLibrary.Timer.t0_64 = t_64 - (__int64)(t/_glfwLibrary.Timer.Resolution);-    }-    else-    {-        _glfwLibrary.Timer.t0_32 = _glfw_timeGetTime() - (int)(t*1000.0);-    }-}---//========================================================================-// Put a thread to sleep for a specified amount of time-//========================================================================--void _glfwPlatformSleep( double time )-{-    DWORD t;--    if( time == 0.0 )-    {-	t = 0;-    }-    else if( time < 0.001 )-    {-        t = 1;-    }-    else if( time > 2147483647.0 )-    {-        t = 2147483647;-    }-    else-    {-        t = (DWORD)(time*1000.0 + 0.5);-    }-    Sleep( t );-}-
− glfw/lib/win32/win32_window.c 
@@ -1,1875 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Win32/WGL-// API version: 2.7-// WWW:         http://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 internal functions                       ****-//************************************************************************--// We use versioned window class names in order not to cause conflicts-// between applications using different versions of GLFW-#define _GLFW_WNDCLASSNAME "GLFW27"---//========================================================================-// Enable/disable minimize/restore animations-//========================================================================--static int setMinMaxAnimations( int enable )-{-    ANIMATIONINFO AI;-    int old_enable;--    // Get old animation setting-    AI.cbSize = sizeof( ANIMATIONINFO );-    SystemParametersInfo( SPI_GETANIMATION, AI.cbSize, &AI, 0 );-    old_enable = AI.iMinAnimate;--    // If requested, change setting-    if( old_enable != enable )-    {-        AI.iMinAnimate = enable;-        SystemParametersInfo( SPI_SETANIMATION, AI.cbSize, &AI,-                              SPIF_SENDCHANGE );-    }--    return old_enable;-}---//========================================================================-// Focus the window and bring it to the top of the stack-// Due to some nastiness with how Win98/ME/2k/XP handles SetForegroundWindow,-// we have to go through some really bizarre measures to achieve this-//========================================================================--static void setForegroundWindow( HWND hWnd )-{-    int try_count = 0;-    int old_animate;--    // Try the standard approach first...-    BringWindowToTop( hWnd );-    SetForegroundWindow( hWnd );--    // If it worked, return now-    if( hWnd == GetForegroundWindow() )-    {-        // Try to modify the system settings (since this is the foreground-        // process, we are allowed to do this)-        SystemParametersInfo( SPI_SETFOREGROUNDLOCKTIMEOUT, 0, (LPVOID)0,-                              SPIF_SENDCHANGE );-        return;-    }--    // For other Windows versions than 95 & NT4.0, the standard approach-    // may not work, so if we failed we have to "trick" Windows into-    // making our window the foureground window: Iconify and restore-    // again. It is ugly, but it seems to work (we turn off those annoying-    // zoom animations to make it look a bit better at least).--    // Turn off minimize/restore animations-    old_animate = setMinMaxAnimations( 0 );--    // We try this a few times, just to be on the safe side of things...-    do-    {-        // Iconify & restore-        ShowWindow( hWnd, SW_HIDE );-        ShowWindow( hWnd, SW_SHOWMINIMIZED );-        ShowWindow( hWnd, SW_SHOWNORMAL );--        // Try to get focus-        BringWindowToTop( hWnd );-        SetForegroundWindow( hWnd );--        // We do not want to keep going on forever, so we keep track of-        // how many times we tried-        try_count ++;-    }-    while( hWnd != GetForegroundWindow() && try_count <= 3 );--    // Restore the system minimize/restore animation setting-    (void) setMinMaxAnimations( old_animate );--    // Try to modify the system settings (since this is now hopefully the-    // foreground process, we are probably allowed to do this)-    SystemParametersInfo( SPI_SETFOREGROUNDLOCKTIMEOUT, 0, (LPVOID)0,-                          SPIF_SENDCHANGE );-}---//========================================================================-// 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(int pixelFormat, int attrib)-{-    int value = 0;--    if( !_glfwWin.GetPixelFormatAttribivARB( _glfwWin.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 _GLFWfbconfig *getFBConfigs( unsigned int *found )-{-    _GLFWfbconfig *result;-    PIXELFORMATDESCRIPTOR pfd;-    int i, count;--    *found = 0;--    if( _glfwWin.has_WGL_ARB_pixel_format )-    {-        count = getPixelFormatAttrib( 1, WGL_NUMBER_PIXEL_FORMATS_ARB );-    }-    else-    {-        count = _glfw_DescribePixelFormat( _glfwWin.DC, 1, sizeof( PIXELFORMATDESCRIPTOR ), NULL );-    }--    if( !count )-    {-        fprintf( stderr, "No Win32 pixel formats available\n" );-        return NULL;-    }--    result = (_GLFWfbconfig*) malloc( sizeof( _GLFWfbconfig ) * count );-    if( !result )-    {-        fprintf(stderr, "Out of memory");-        return NULL;-    }--    for( i = 1;  i <= count;  i++ )-    {-        if( _glfwWin.has_WGL_ARB_pixel_format )-        {-            // Get pixel format attributes through WGL_ARB_pixel_format--            if( !getPixelFormatAttrib( i, WGL_SUPPORT_OPENGL_ARB ) ||-                !getPixelFormatAttrib( i, WGL_DRAW_TO_WINDOW_ARB ) ||-                !getPixelFormatAttrib( i, WGL_DOUBLE_BUFFER_ARB ) )-            {-                // Only consider doublebuffered OpenGL pixel formats for windows-                continue;-            }--            if( getPixelFormatAttrib( i, WGL_PIXEL_TYPE_ARB ) != WGL_TYPE_RGBA_ARB )-            {-                // Only consider RGBA pixel formats-                continue;-            }--            // Only consider "hardware-accelerated" pixel formats-            if( getPixelFormatAttrib( i, WGL_ACCELERATION_ARB ) ==-                WGL_NO_ACCELERATION_ARB )-            {-                continue;-            }--            result[*found].redBits = getPixelFormatAttrib( i, WGL_RED_BITS_ARB );-            result[*found].greenBits = getPixelFormatAttrib( i, WGL_GREEN_BITS_ARB );-            result[*found].blueBits = getPixelFormatAttrib( i, WGL_BLUE_BITS_ARB );-            result[*found].alphaBits = getPixelFormatAttrib( i, WGL_ALPHA_BITS_ARB );--            result[*found].depthBits = getPixelFormatAttrib( i, WGL_DEPTH_BITS_ARB );-            result[*found].stencilBits = getPixelFormatAttrib( i, WGL_STENCIL_BITS_ARB );--            result[*found].accumRedBits = getPixelFormatAttrib( i, WGL_ACCUM_RED_BITS_ARB );-            result[*found].accumGreenBits = getPixelFormatAttrib( i, WGL_ACCUM_GREEN_BITS_ARB );-            result[*found].accumBlueBits = getPixelFormatAttrib( i, WGL_ACCUM_BLUE_BITS_ARB );-            result[*found].accumAlphaBits = getPixelFormatAttrib( i, WGL_ACCUM_ALPHA_BITS_ARB );--            result[*found].auxBuffers = getPixelFormatAttrib( i, WGL_AUX_BUFFERS_ARB );-            result[*found].stereo = getPixelFormatAttrib( i, WGL_STEREO_ARB );--            if( _glfwWin.has_WGL_ARB_multisample )-            {-                result[*found].samples = getPixelFormatAttrib( i, WGL_SAMPLES_ARB );-            }-            else-            {-                result[*found].samples = 0;-            }-        }-        else-        {-            // Get pixel format attributes through old-fashioned PFDs--            if( !_glfw_DescribePixelFormat( _glfwWin.DC, i, sizeof( PIXELFORMATDESCRIPTOR ), &pfd ) )-            {-                continue;-            }--            if( !( pfd.dwFlags & PFD_DRAW_TO_WINDOW ) ||-                !( pfd.dwFlags & PFD_SUPPORT_OPENGL ) ||-                !( pfd.dwFlags & PFD_DOUBLEBUFFER ) )-            {-                // Only consider doublebuffered OpenGL pixel formats for windows-                continue;-            }--            if( !( pfd.dwFlags & PFD_GENERIC_ACCELERATED ) &&-                ( pfd.dwFlags & PFD_GENERIC_FORMAT ) )-            {-                continue;-            }--            if( pfd.iPixelType != PFD_TYPE_RGBA )-            {-                // Only RGBA pixel formats considered-                continue;-            }--            result[*found].redBits = pfd.cRedBits;-            result[*found].greenBits = pfd.cGreenBits;-            result[*found].blueBits = pfd.cBlueBits;-            result[*found].alphaBits = pfd.cAlphaBits;--            result[*found].depthBits = pfd.cDepthBits;-            result[*found].stencilBits = pfd.cStencilBits;--            result[*found].accumRedBits = pfd.cAccumRedBits;-            result[*found].accumGreenBits = pfd.cAccumGreenBits;-            result[*found].accumBlueBits = pfd.cAccumBlueBits;-            result[*found].accumAlphaBits = pfd.cAccumAlphaBits;--            result[*found].auxBuffers = pfd.cAuxBuffers;-            result[*found].stereo = ( pfd.dwFlags & PFD_STEREO ) ? GL_TRUE : GL_FALSE;--            // PFD pixel formats do not support FSAA-            result[*found].samples = 0;-        }--        result[*found].platformID = i;--        (*found)++;-    }--    return result;-}---//========================================================================-// Creates an OpenGL context on the specified device context-//========================================================================--static GLboolean createContext( HDC dc, const _GLFWwndconfig* wndconfig, int pixelFormat )-{-    PIXELFORMATDESCRIPTOR pfd;-    int flags, i = 0, attribs[40];--    if( !_glfw_DescribePixelFormat( dc, pixelFormat, sizeof(pfd), &pfd ) )-    {-        return GL_FALSE;-    }--    if( !_glfw_SetPixelFormat( dc, pixelFormat, &pfd ) )-    {-        return GL_FALSE;-    }--    if( _glfwWin.has_WGL_ARB_create_context )-    {-        // Use the newer wglCreateContextAttribsARB--        if( wndconfig->glMajor != 1 || wndconfig->glMinor != 0 )-        {-            // Request an explicitly versioned context--            attribs[i++] = WGL_CONTEXT_MAJOR_VERSION_ARB;-            attribs[i++] = wndconfig->glMajor;-            attribs[i++] = WGL_CONTEXT_MINOR_VERSION_ARB;-            attribs[i++] = wndconfig->glMinor;-        }--        if( wndconfig->glForward || wndconfig->glDebug )-        {-            flags = 0;--            if( wndconfig->glForward )-            {-                flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;-            }--            if( wndconfig->glDebug )-            {-                flags |= WGL_CONTEXT_DEBUG_BIT_ARB;-            }--            attribs[i++] = WGL_CONTEXT_FLAGS_ARB;-            attribs[i++] = flags;-        }--        if( wndconfig->glProfile )-        {-            if( !_glfwWin.has_WGL_ARB_create_context_profile )-            {-                return GL_FALSE;-            }--            if( wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE )-            {-                flags = WGL_CONTEXT_CORE_PROFILE_BIT_ARB;-            }-            else-            {-                flags = WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;-            }--            attribs[i++] = WGL_CONTEXT_PROFILE_MASK_ARB;-            attribs[i++] = flags;-        }--        attribs[i++] = 0;--        _glfwWin.context = _glfwWin.CreateContextAttribsARB( dc, NULL, attribs );-        if( !_glfwWin.context )-        {-            return GL_FALSE;-        }-    }-    else-    {-        _glfwWin.context = wglCreateContext( dc );-        if( !_glfwWin.context )-        {-            return GL_FALSE;-        }-    }--    return GL_TRUE;-}---//========================================================================-// Translates a Windows key to the corresponding GLFW key-//========================================================================--static int translateKey( WPARAM wParam, LPARAM lParam )-{-    MSG next_msg;-    DWORD msg_time;-    DWORD scan_code;--    // Check for numeric keypad keys-    // Note: This way we always force "NumLock = ON", which at least-    // enables GLFW users to detect numeric keypad keys-    int hiFlags = HIWORD( lParam );--    if ( !( hiFlags & 0x100 ) )-    {-        switch( MapVirtualKey( hiFlags & 0xFF, 1 ) )-        {-            case VK_INSERT:   return GLFW_KEY_KP_0;-            case VK_END:      return GLFW_KEY_KP_1;-            case VK_DOWN:     return GLFW_KEY_KP_2;-            case VK_NEXT:     return GLFW_KEY_KP_3;-            case VK_LEFT:     return GLFW_KEY_KP_4;-            case VK_CLEAR:    return GLFW_KEY_KP_5;-            case VK_RIGHT:    return GLFW_KEY_KP_6;-            case VK_HOME:     return GLFW_KEY_KP_7;-            case VK_UP:       return GLFW_KEY_KP_8;-            case VK_PRIOR:    return GLFW_KEY_KP_9;-            case VK_DIVIDE:   return GLFW_KEY_KP_DIVIDE;-            case VK_MULTIPLY: return GLFW_KEY_KP_MULTIPLY;-            case VK_SUBTRACT: return GLFW_KEY_KP_SUBTRACT;-            case VK_ADD:      return GLFW_KEY_KP_ADD;-            case VK_DELETE:   return GLFW_KEY_KP_DECIMAL;-        }-    }--    // Check which key was pressed or released-    switch( wParam )-    {-        // The SHIFT keys require special handling-        case VK_SHIFT:-        {-            // Compare scan code for this key with that of VK_RSHIFT in-            // order to determine which shift key was pressed (left or-            // right)-            scan_code = MapVirtualKey( VK_RSHIFT, 0 );-            if( ((lParam & 0x01ff0000) >> 16) == scan_code )-            {-                return GLFW_KEY_RSHIFT;-            }--            return GLFW_KEY_LSHIFT;-        }--        // The CTRL keys require special handling-        case VK_CONTROL:-        {-            // Is this an extended key (i.e. right key)?-            if( lParam & 0x01000000 )-            {-                return GLFW_KEY_RCTRL;-            }--            // Here is a trick: "Alt Gr" sends LCTRL, then RALT. We only-            // want the RALT message, so we try to see if the next message-            // is a RALT message. In that case, this is a false LCTRL!-            msg_time = GetMessageTime();-            if( PeekMessage( &next_msg, NULL, 0, 0, PM_NOREMOVE ) )-            {-                if( next_msg.message == WM_KEYDOWN ||-                    next_msg.message == WM_SYSKEYDOWN )-                {-                    if( next_msg.wParam == VK_MENU &&-                        (next_msg.lParam & 0x01000000) &&-                        next_msg.time == msg_time )-                    {-                        // Next message is a RALT down message, which-                        // means that this is NOT a proper LCTRL message!-                        return GLFW_KEY_UNKNOWN;-                    }-                }-            }--            return GLFW_KEY_LCTRL;-        }--        // The ALT keys require special handling-        case VK_MENU:-        {-            // Is this an extended key (i.e. right key)?-            if( lParam & 0x01000000 )-            {-                return GLFW_KEY_RALT;-            }--            return GLFW_KEY_LALT;-        }--        // The ENTER keys require special handling-        case VK_RETURN:-        {-            // Is this an extended key (i.e. right key)?-            if( lParam & 0x01000000 )-            {-                return GLFW_KEY_KP_ENTER;-            }--            return GLFW_KEY_ENTER;-        }--        // Special keys (non character keys)-        case VK_ESCAPE:        return GLFW_KEY_ESC;-        case VK_TAB:           return GLFW_KEY_TAB;-        case VK_BACK:          return GLFW_KEY_BACKSPACE;-        case VK_HOME:          return GLFW_KEY_HOME;-        case VK_END:           return GLFW_KEY_END;-        case VK_PRIOR:         return GLFW_KEY_PAGEUP;-        case VK_NEXT:          return GLFW_KEY_PAGEDOWN;-        case VK_INSERT:        return GLFW_KEY_INSERT;-        case VK_DELETE:        return GLFW_KEY_DEL;-        case VK_LEFT:          return GLFW_KEY_LEFT;-        case VK_UP:            return GLFW_KEY_UP;-        case VK_RIGHT:         return GLFW_KEY_RIGHT;-        case VK_DOWN:          return GLFW_KEY_DOWN;-        case VK_F1:            return GLFW_KEY_F1;-        case VK_F2:            return GLFW_KEY_F2;-        case VK_F3:            return GLFW_KEY_F3;-        case VK_F4:            return GLFW_KEY_F4;-        case VK_F5:            return GLFW_KEY_F5;-        case VK_F6:            return GLFW_KEY_F6;-        case VK_F7:            return GLFW_KEY_F7;-        case VK_F8:            return GLFW_KEY_F8;-        case VK_F9:            return GLFW_KEY_F9;-        case VK_F10:           return GLFW_KEY_F10;-        case VK_F11:           return GLFW_KEY_F11;-        case VK_F12:           return GLFW_KEY_F12;-        case VK_F13:           return GLFW_KEY_F13;-        case VK_F14:           return GLFW_KEY_F14;-        case VK_F15:           return GLFW_KEY_F15;-        case VK_F16:           return GLFW_KEY_F16;-        case VK_F17:           return GLFW_KEY_F17;-        case VK_F18:           return GLFW_KEY_F18;-        case VK_F19:           return GLFW_KEY_F19;-        case VK_F20:           return GLFW_KEY_F20;-        case VK_F21:           return GLFW_KEY_F21;-        case VK_F22:           return GLFW_KEY_F22;-        case VK_F23:           return GLFW_KEY_F23;-        case VK_F24:           return GLFW_KEY_F24;-        case VK_SPACE:         return GLFW_KEY_SPACE;--        // Numeric keypad-        case VK_NUMPAD0:       return GLFW_KEY_KP_0;-        case VK_NUMPAD1:       return GLFW_KEY_KP_1;-        case VK_NUMPAD2:       return GLFW_KEY_KP_2;-        case VK_NUMPAD3:       return GLFW_KEY_KP_3;-        case VK_NUMPAD4:       return GLFW_KEY_KP_4;-        case VK_NUMPAD5:       return GLFW_KEY_KP_5;-        case VK_NUMPAD6:       return GLFW_KEY_KP_6;-        case VK_NUMPAD7:       return GLFW_KEY_KP_7;-        case VK_NUMPAD8:       return GLFW_KEY_KP_8;-        case VK_NUMPAD9:       return GLFW_KEY_KP_9;-        case VK_DIVIDE:        return GLFW_KEY_KP_DIVIDE;-        case VK_MULTIPLY:      return GLFW_KEY_KP_MULTIPLY;-        case VK_SUBTRACT:      return GLFW_KEY_KP_SUBTRACT;-        case VK_ADD:           return GLFW_KEY_KP_ADD;-        case VK_DECIMAL:       return GLFW_KEY_KP_DECIMAL;-        case VK_NUMLOCK:       return GLFW_KEY_KP_NUM_LOCK;--        case VK_CAPITAL:       return GLFW_KEY_CAPS_LOCK;-        case VK_SCROLL:        return GLFW_KEY_SCROLL_LOCK;-        case VK_PAUSE:         return GLFW_KEY_PAUSE;--        case VK_LWIN:          return GLFW_KEY_LSUPER;-        case VK_RWIN:          return GLFW_KEY_RSUPER;-        case VK_APPS:          return GLFW_KEY_MENU;--        // The rest (should be printable keys)-        default:-        {-            // Convert to printable character (ISO-8859-1 or Unicode)-            wParam = MapVirtualKey( (UINT) wParam, 2 ) & 0x0000FFFF;--            // Make sure that the character is uppercase-            if( _glfwLibrary.Sys.hasUnicode )-            {-                wParam = (WPARAM) CharUpperW( (LPWSTR) wParam );-            }-            else-            {-                wParam = (WPARAM) CharUpperA( (LPSTR) wParam );-            }--            // Valid ISO-8859-1 character?-            if( (wParam >=  32 && wParam <= 126) ||-                (wParam >= 160 && wParam <= 255) )-            {-                return (int) wParam;-            }--            return GLFW_KEY_UNKNOWN;-        }-    }-}---//========================================================================-// Translates a Windows key to Unicode-//========================================================================--static void translateChar( DWORD wParam, DWORD lParam, int action )-{-    BYTE  keyboard_state[ 256 ];-    UCHAR char_buf[ 10 ];-    WCHAR unicode_buf[ 10 ];-    UINT  scan_code;-    int   i, num_chars, unicode;--    GetKeyboardState( keyboard_state );--    // Derive scan code from lParam and action-    scan_code = (lParam & 0x01ff0000) >> 16;-    if( action == GLFW_RELEASE )-    {-        scan_code |= 0x8000000;-    }--    if( _glfwLibrary.Sys.hasUnicode )-    {-        num_chars = ToUnicode(-            wParam,          // virtual-key code-            scan_code,       // scan code-            keyboard_state,  // key-state array-            unicode_buf,     // buffer for translated key-            10,              // size of translated key buffer-            0                // active-menu flag-        );-        unicode = 1;-    }-    else-    {-        // Convert to ISO-8859-1-        num_chars = ToAscii(-            wParam,            // virtual-key code-            scan_code,         // scan code-            keyboard_state,    // key-state array-            (LPWORD) char_buf, // buffer for translated key-            0                  // active-menu flag-        );-        unicode = 0;-    }--    // Report characters-    for( i = 0;  i < num_chars;  i++ )-    {-        // Get next character from buffer-        if( unicode )-        {-            _glfwInputChar( (int) unicode_buf[ i ], action );-        }-        else-        {-            _glfwInputChar( (int) char_buf[ i ], action );-        }-    }-}---//========================================================================-// Window callback function (handles window events)-//========================================================================--static LRESULT CALLBACK windowProc( HWND hWnd, UINT uMsg,-                                    WPARAM wParam, LPARAM lParam )-{-    int wheelDelta, iconified;--    switch( uMsg )-    {-        // Window activate message? (iconification?)-        case WM_ACTIVATE:-        {-            _glfwWin.active = LOWORD(wParam) != WA_INACTIVE ? GL_TRUE : GL_FALSE;--            iconified = HIWORD(wParam) ? GL_TRUE : GL_FALSE;--            // Were we deactivated/iconified?-            if( (!_glfwWin.active || iconified) && !_glfwWin.iconified )-            {-                _glfwInputDeactivation();--                // If we are in fullscreen mode we need to iconify-                if( _glfwWin.opened && _glfwWin.fullscreen )-                {-                    // Do we need to manually iconify?-                    if( !iconified )-                    {-                        // Minimize window-                        ShowWindow( _glfwWin.window, SW_MINIMIZE );-                        iconified = GL_TRUE;-                    }--                    // Restore the original desktop resolution-                    ChangeDisplaySettings( NULL, CDS_FULLSCREEN );-                }--                // Unlock mouse if locked-                if( !_glfwWin.oldMouseLockValid )-                {-                    _glfwWin.oldMouseLock = _glfwWin.mouseLock;-                    _glfwWin.oldMouseLockValid = GL_TRUE;-                    glfwEnable( GLFW_MOUSE_CURSOR );-                }-            }-            else if( _glfwWin.active || !iconified )-            {-                // If we are in fullscreen mode we need to maximize-                if( _glfwWin.opened && _glfwWin.fullscreen && _glfwWin.iconified )-                {-                    // Change display settings to the user selected mode-                    _glfwSetVideoModeMODE( _glfwWin.modeID );--                    // Do we need to manually restore window?-                    if( iconified )-                    {-                        // Restore window-                        ShowWindow( _glfwWin.window, SW_RESTORE );-                        iconified = GL_FALSE;--                        // Activate window-                        ShowWindow( hWnd, SW_SHOW );-                        setForegroundWindow( _glfwWin.window );-                        SetFocus( _glfwWin.window );-                    }-                }--                // Lock mouse, if necessary-                if( _glfwWin.oldMouseLockValid && _glfwWin.oldMouseLock )-                {-                    glfwDisable( GLFW_MOUSE_CURSOR );-                }-                _glfwWin.oldMouseLockValid = GL_FALSE;-            }--            _glfwWin.iconified = iconified;-            return 0;-        }--        case WM_SYSCOMMAND:-        {-            switch( wParam & 0xfff0 )-            {-                case SC_SCREENSAVE:-                case SC_MONITORPOWER:-                {-                    if( _glfwWin.fullscreen )-                    {-                        // Disallow screen saver and screen blanking if we are-                        // running in fullscreen mode-                        return 0;-                    }-                    else-                    {-                        break;-                    }-                }--                // User trying to access application menu using ALT?-                case SC_KEYMENU:-                    return 0;-            }-            break;-        }--        case WM_CLOSE:-        {-            // Translate this to WM_QUIT so that we can handle all cases in the-            // same place-            PostQuitMessage( 0 );-            return 0;-        }--        case WM_KEYDOWN:-        case WM_SYSKEYDOWN:-        {-            _glfwInputKey( translateKey( wParam, lParam ), GLFW_PRESS );--            if( _glfwWin.charCallback )-            {-                translateChar( (DWORD) wParam, (DWORD) lParam, GLFW_PRESS );-            }-            return 0;-          }--        case WM_KEYUP:-        case WM_SYSKEYUP:-        {-            // Special trick: release both shift keys on SHIFT up event-            if( wParam == VK_SHIFT )-            {-                _glfwInputKey( GLFW_KEY_LSHIFT, GLFW_RELEASE );-                _glfwInputKey( GLFW_KEY_RSHIFT, GLFW_RELEASE );-            }-            else-            {-                _glfwInputKey( translateKey( wParam, lParam ), GLFW_RELEASE );-            }--            if( _glfwWin.charCallback )-            {-                translateChar( (DWORD) wParam, (DWORD) lParam, GLFW_RELEASE );-            }--            return 0;-        }--        case WM_LBUTTONDOWN:-            SetCapture(hWnd);-            _glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS );-            return 0;-        case WM_RBUTTONDOWN:-            SetCapture(hWnd);-            _glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS );-            return 0;-        case WM_MBUTTONDOWN:-            SetCapture(hWnd);-            _glfwInputMouseClick( GLFW_MOUSE_BUTTON_MIDDLE, GLFW_PRESS );-            return 0;-        case WM_XBUTTONDOWN:-        {-            if( HIWORD(wParam) == XBUTTON1 )-            {-                SetCapture(hWnd);-                _glfwInputMouseClick( GLFW_MOUSE_BUTTON_4, GLFW_PRESS );-            }-            else if( HIWORD(wParam) == XBUTTON2 )-            {-                SetCapture(hWnd);-                _glfwInputMouseClick( GLFW_MOUSE_BUTTON_5, GLFW_PRESS );-            }-            return 1;-        }--        case WM_LBUTTONUP:-            ReleaseCapture();-            _glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT, GLFW_RELEASE );-            return 0;-        case WM_RBUTTONUP:-            ReleaseCapture();-            _glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT, GLFW_RELEASE );-            return 0;-        case WM_MBUTTONUP:-            ReleaseCapture();-            _glfwInputMouseClick( GLFW_MOUSE_BUTTON_MIDDLE, GLFW_RELEASE );-            return 0;-        case WM_XBUTTONUP:-        {-            if( HIWORD(wParam) == XBUTTON1 )-            {-                ReleaseCapture();-                _glfwInputMouseClick( GLFW_MOUSE_BUTTON_4, GLFW_RELEASE );-            }-            else if( HIWORD(wParam) == XBUTTON2 )-            {-                ReleaseCapture();-                _glfwInputMouseClick( GLFW_MOUSE_BUTTON_5, GLFW_RELEASE );-            }-            return 1;-        }--        case WM_MOUSEMOVE:-        {-            int NewMouseX, NewMouseY;--            // Get signed (!) mouse position-            NewMouseX = (int)((short)LOWORD(lParam));-            NewMouseY = (int)((short)HIWORD(lParam));--            if( NewMouseX != _glfwInput.OldMouseX ||-                NewMouseY != _glfwInput.OldMouseY )-            {-                if( _glfwWin.mouseLock )-                {-                    _glfwInput.MousePosX += NewMouseX --                                            _glfwInput.OldMouseX;-                    _glfwInput.MousePosY += NewMouseY --                                            _glfwInput.OldMouseY;-                }-                else-                {-                    _glfwInput.MousePosX = NewMouseX;-                    _glfwInput.MousePosY = NewMouseY;-                }-                _glfwInput.OldMouseX = NewMouseX;-                _glfwInput.OldMouseY = NewMouseY;-                _glfwInput.MouseMoved = GL_TRUE;--                if( _glfwWin.mousePosCallback )-                {-                    _glfwWin.mousePosCallback( _glfwInput.MousePosX,-                                               _glfwInput.MousePosY );-                }-            }-            return 0;-        }--        case WM_MOUSEWHEEL:-        {-            // WM_MOUSEWHEEL is not supported under Windows 95-            if( _glfwLibrary.Sys.winVer != _GLFW_WIN_95 )-            {-                wheelDelta = (((int)wParam) >> 16) / WHEEL_DELTA;-                _glfwInput.WheelPos += wheelDelta;-                if( _glfwWin.mouseWheelCallback )-                {-                    _glfwWin.mouseWheelCallback( _glfwInput.WheelPos );-                }-                return 0;-            }-            break;-        }--        case WM_SIZE:-        {-            _glfwWin.width  = LOWORD(lParam);-            _glfwWin.height = HIWORD(lParam);--            // If the mouse is locked, update the clipping rect-            if( _glfwWin.mouseLock )-            {-                RECT ClipWindowRect;-                if( GetWindowRect( _glfwWin.window, &ClipWindowRect ) )-                {-                    ClipCursor( &ClipWindowRect );-                }-            }--            if( _glfwWin.windowSizeCallback )-            {-                _glfwWin.windowSizeCallback( LOWORD(lParam), HIWORD(lParam) );-            }-            return 0;-        }--        case WM_MOVE:-        {-            // If the mouse is locked, update the clipping rect-            if( _glfwWin.mouseLock )-            {-                RECT ClipWindowRect;-                if( GetWindowRect( _glfwWin.window, &ClipWindowRect ) )-                {-                    ClipCursor( &ClipWindowRect );-                }-            }-            return 0;-        }--        // Was the window contents damaged?-        case WM_PAINT:-        {-            if( _glfwWin.windowRefreshCallback )-            {-                _glfwWin.windowRefreshCallback();-            }-            break;-        }--        case WM_DISPLAYCHANGE:-        {-            // TODO: Do stuff here.--            break;-        }-    }--    // Pass all unhandled messages to DefWindowProc-    return DefWindowProc( hWnd, uMsg, wParam, lParam );-}---//========================================================================-// Translate client window size to full window size (including window borders)-//========================================================================--static void getFullWindowSize( int clientWidth, int clientHeight,-                               int *fullWidth, int *fullHeight )-{-    RECT rect;--    // Create a window rectangle-    rect.left   = (long)0;-    rect.right  = (long)clientWidth - 1;-    rect.top    = (long)0;-    rect.bottom = (long)clientHeight - 1;--    // Adjust according to window styles-    AdjustWindowRectEx( &rect, _glfwWin.dwStyle, FALSE, _glfwWin.dwExStyle );--    // Calculate width and height of full window-    *fullWidth = rect.right - rect.left + 1;-    *fullHeight = rect.bottom - rect.top + 1;-}---//========================================================================-// 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( void )-{-    // This needs to include every function pointer loaded below-    _glfwWin.SwapIntervalEXT = NULL;-    _glfwWin.GetPixelFormatAttribivARB = NULL;-    _glfwWin.GetExtensionsStringARB = NULL;-    _glfwWin.GetExtensionsStringEXT = NULL;-    _glfwWin.CreateContextAttribsARB = NULL;--    // This needs to include every extension used below except for-    // WGL_ARB_extensions_string and WGL_EXT_extensions_string-    _glfwWin.has_WGL_EXT_swap_control = GL_FALSE;-    _glfwWin.has_WGL_ARB_pixel_format = GL_FALSE;-    _glfwWin.has_WGL_ARB_multisample = GL_FALSE;-    _glfwWin.has_WGL_ARB_create_context = GL_FALSE;-    _glfwWin.has_WGL_ARB_create_context_profile = GL_FALSE;--    _glfwWin.GetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)-        wglGetProcAddress( "wglGetExtensionsStringEXT" );-    if( !_glfwWin.GetExtensionsStringEXT )-    {-        _glfwWin.GetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)-            wglGetProcAddress( "wglGetExtensionsStringARB" );-        if( !_glfwWin.GetExtensionsStringARB )-        {-            return;-        }-    }--    if( _glfwPlatformExtensionSupported( "WGL_ARB_multisample" ) )-    {-        _glfwWin.has_WGL_ARB_multisample = GL_TRUE;-    }--    if( _glfwPlatformExtensionSupported( "WGL_ARB_create_context" ) )-    {-        _glfwWin.has_WGL_ARB_create_context = GL_TRUE;-        _glfwWin.CreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)-            wglGetProcAddress( "wglCreateContextAttribsARB" );-    }--    if( _glfwWin.has_WGL_ARB_create_context )-    {-        if( _glfwPlatformExtensionSupported( "WGL_ARB_create_context_profile" ) )-        {-            _glfwWin.has_WGL_ARB_create_context_profile = GL_TRUE;-        }-    }--    if( _glfwPlatformExtensionSupported( "WGL_EXT_swap_control" ) )-    {-        _glfwWin.has_WGL_EXT_swap_control = GL_TRUE;-        _glfwWin.SwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)-            wglGetProcAddress( "wglSwapIntervalEXT" );-    }--    if( _glfwPlatformExtensionSupported( "WGL_ARB_pixel_format" ) )-    {-        _glfwWin.has_WGL_ARB_pixel_format = GL_TRUE;-        _glfwWin.GetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)-            wglGetProcAddress( "wglGetPixelFormatAttribivARB" );-    }-}---//========================================================================-// Registers the GLFW window class-//========================================================================--static ATOM registerWindowClass( void )-{-    WNDCLASS wc;--    // Set window class parameters-    wc.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw on...-    wc.lpfnWndProc   = (WNDPROC)windowProc;           // Message handler-    wc.cbClsExtra    = 0;                             // No extra class data-    wc.cbWndExtra    = 0;                             // No extra window data-    wc.hInstance     = _glfwLibrary.instance;         // Set instance-    wc.hCursor       = LoadCursor( NULL, IDC_ARROW ); // Load arrow pointer-    wc.hbrBackground = NULL;                          // No background-    wc.lpszMenuName  = NULL;                          // No menu-    wc.lpszClassName = _GLFW_WNDCLASSNAME;            // Set class name--    // Load user-provided icon if available-    wc.hIcon = LoadIcon( _glfwLibrary.instance, "GLFW_ICON" );-    if( !wc.hIcon )-    {-        // Load default icon-        wc.hIcon = LoadIcon( NULL, IDI_WINLOGO );-    }--    return RegisterClass( &wc );-}---//========================================================================-// Returns the closest matching pixel format, or zero on error-//========================================================================--static int choosePixelFormat( const _GLFWfbconfig *fbconfig )-{-    unsigned int fbcount;-    int pixelFormat;-    _GLFWfbconfig *fbconfigs;-    const _GLFWfbconfig *closest;--    fbconfigs = getFBConfigs( &fbcount );-    if( !fbconfigs )-    {-        fprintf( stderr, "Failed to find any usable GLFWFBConfigs\n" );-        return 0;-    }--    closest = _glfwChooseFBConfig( fbconfig, fbconfigs, fbcount );-    if( !closest )-    {-        fprintf( stderr, "Failed to select a GLFWFBConfig from the alternatives\n" );-        free( fbconfigs );-        return 0;-    }--    pixelFormat = (int) closest->platformID;--    free( fbconfigs );-    fbconfigs = NULL;-    closest = NULL;--    return pixelFormat;-}---//========================================================================-// Creates the GLFW window and rendering context-//========================================================================--static int createWindow( const _GLFWwndconfig *wndconfig,-                         const _GLFWfbconfig *fbconfig )-{-    DWORD dwStyle, dwExStyle;-    int pixelFormat, fullWidth, fullHeight;-    RECT wa;-    POINT pos;--    _glfwWin.DC  = NULL;-    _glfwWin.context = NULL;-    _glfwWin.window = NULL;--    // Set common window styles-    dwStyle   = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;-    dwExStyle = WS_EX_APPWINDOW;--    // Set window style, depending on fullscreen mode-    if( _glfwWin.fullscreen )-    {-        dwStyle |= WS_POPUP;--        // Here's a trick for helping us getting window focus-        // (SetForegroundWindow doesn't work properly under-        // Win98/ME/2K/.NET/+)-        /*-        if( _glfwLibrary.Sys.WinVer != _GLFW_WIN_95 &&-            _glfwLibrary.Sys.WinVer != _GLFW_WIN_NT4 &&-            _glfwLibrary.Sys.WinVer != _GLFW_WIN_XP )-        {-            dwStyle |= WS_MINIMIZE;-        }-        */-    }-    else-    {-        dwStyle |= WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;--        if( !wndconfig->windowNoResize )-        {-            dwStyle |= ( WS_MAXIMIZEBOX | WS_SIZEBOX );-            dwExStyle |= WS_EX_WINDOWEDGE;-        }-    }--    // Remember window styles (used by getFullWindowSize)-    _glfwWin.dwStyle   = dwStyle;-    _glfwWin.dwExStyle = dwExStyle;--    // Adjust window size for frame and title bar-    getFullWindowSize( _glfwWin.width, _glfwWin.height, &fullWidth, &fullHeight );--    // Adjust window position to working area (e.g. if the task bar is at-    // the top of the display). Fullscreen windows are always opened in-    // the upper left corner regardless of the desktop working area.-    if( _glfwWin.fullscreen )-    {-        wa.left = wa.top = 0;-    }-    else-    {-        SystemParametersInfo( SPI_GETWORKAREA, 0, &wa, 0 );-    }--    _glfwWin.window = CreateWindowEx( _glfwWin.dwExStyle,    // Extended style-                                      _GLFW_WNDCLASSNAME,    // Class name-                                      "GLFW Window",         // Window title-                                      _glfwWin.dwStyle,      // Defined window style-                                      wa.left, wa.top,       // Window position-                                      fullWidth,             // Decorated window width-                                      fullHeight,            // Decorated window height-                                      NULL,                  // No parent window-                                      NULL,                  // No menu-                                      _glfwLibrary.instance, // Instance-                                      NULL );                // Nothing to WM_CREATE--    if( !_glfwWin.window )-    {-        fprintf( stderr, "Unable to create Win32 window\n" );-        return GL_FALSE;-    }--    _glfwWin.DC = GetDC( _glfwWin.window );-    if( !_glfwWin.DC )-    {-        fprintf( stderr, "Unable to retrieve GLFW window DC\n" );-        return GL_FALSE;-    }--    pixelFormat = choosePixelFormat( fbconfig );-    if( !pixelFormat )-    {-        fprintf( stderr, "Unable to find a usable pixel format\n" );-        return GL_FALSE;-    }--    if( !createContext( _glfwWin.DC, wndconfig, pixelFormat ) )-    {-        fprintf( stderr, "Unable to create OpenGL context\n" );-        return GL_FALSE;-    }--    if( !wglMakeCurrent( _glfwWin.DC, _glfwWin.context ) )-    {-        fprintf( stderr, "Unable to make OpenGL context current\n" );-        return GL_FALSE;-    }--    initWGLExtensions();--    // Initialize mouse position data-    GetCursorPos( &pos );-    ScreenToClient( _glfwWin.window, &pos );-    _glfwInput.OldMouseX = _glfwInput.MousePosX = pos.x;-    _glfwInput.OldMouseY = _glfwInput.MousePosY = pos.y;--    return GL_TRUE;-}---//========================================================================-// Destroys the GLFW window and rendering context-//========================================================================--static void destroyWindow( void )-{-    if( _glfwWin.context )-    {-        wglMakeCurrent( NULL, NULL );-        wglDeleteContext( _glfwWin.context );-        _glfwWin.context = NULL;-    }--    if( _glfwWin.DC )-    {-        ReleaseDC( _glfwWin.window, _glfwWin.DC );-        _glfwWin.DC = NULL;-    }--    if( _glfwWin.window )-    {-        if( _glfwLibrary.Sys.winVer <= _GLFW_WIN_NT4 )-        {-            // Note: Hiding the window first fixes an annoying W98/NT4-            // remaining icon bug for fullscreen displays-            ShowWindow( _glfwWin.window, SW_HIDE );-        }--        DestroyWindow( _glfwWin.window );-        _glfwWin.window = NULL;-    }-}----//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Here is where the window is created, and the OpenGL rendering context is-// created-//========================================================================--int _glfwPlatformOpenWindow( int width, int height,-                             const _GLFWwndconfig *wndconfig,-                             const _GLFWfbconfig *fbconfig )-{-    GLboolean recreateContext = GL_FALSE;--    // Clear platform specific GLFW window state-    _glfwWin.classAtom         = 0;-    _glfwWin.oldMouseLockValid = GL_FALSE;--    _glfwWin.desiredRefreshRate = wndconfig->refreshRate;--    _glfwWin.classAtom = registerWindowClass();-    if( !_glfwWin.classAtom )-    {-        fprintf( stderr, "Failed to register GLFW window class\n" );-        return GL_FALSE;-    }--    if( _glfwWin.fullscreen )-    {-        _glfwSetVideoMode( &_glfwWin.width, &_glfwWin.height,-                           fbconfig->redBits, fbconfig->greenBits, fbconfig->blueBits,-                           wndconfig->refreshRate );-    }--    initWGLExtensions();--    if( !createWindow( wndconfig, fbconfig ) )-    {-        fprintf( stderr, "Failed to create GLFW window\n" );-        return GL_FALSE;-    }--    _glfwRefreshContextParams();--    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( _glfwWin.has_WGL_ARB_multisample && _glfwWin.has_WGL_ARB_pixel_format )-        {-            // We appear to have both the FSAA extension and the means to ask for it-            recreateContext = GL_TRUE;-        }-    }--    if( wndconfig->glMajor > 2 )-    {-        if ( wndconfig->glMajor != _glfwWin.glMajor ||-             wndconfig->glMinor != _glfwWin.glMinor )-        {-            // We want a different OpenGL version, but can we get it?-            // Otherwise, if we got a version greater than required, that's fine,-            // whereas if we got a version lesser than required, it will be dealt-            // with in glfwOpenWindow--            if( _glfwWin.has_WGL_ARB_create_context )-            {-                recreateContext = GL_TRUE;-            }-        }--        if( wndconfig->glForward )-        {-            if( !_glfwWin.has_WGL_ARB_create_context )-            {-                // Forward-compatibility is a hard constraint-                return GL_FALSE;-            }--            recreateContext = GL_TRUE;-        }--        if( wndconfig->glProfile )-        {-            if( !_glfwWin.has_WGL_ARB_create_context_profile )-            {-                // Context profile is a hard constraint-                return GL_FALSE;-            }--            recreateContext = GL_TRUE;-        }-    }--    if( recreateContext )-    {-        // Some window hints require us to re-create the context using WGL-        // extensions retrieved through the current context, as we cannot check-        // for WGL extensions or retrieve WGL entry points before we have a-        // current context (actually until we have implicitly loaded the ICD)--        // Yes, this is strange, and yes, this is the proper way on Win32--        // As Windows only allows you to set the pixel format once for a-        // window, we need to destroy the current window and create a new one-        // to be able to use the new pixel format--        // Technically, it may be possible to keep the old window around if-        // we're just creating an OpenGL 3.0+ context with the same pixel-        // format, but it's not worth the potential compatibility problems--        destroyWindow();--        if( !createWindow( wndconfig, fbconfig ) )-        {-            fprintf( stderr, "Unable to re-create GLFW window\n" );-            return GL_FALSE;-        }-    }--    if( _glfwWin.fullscreen )-    {-        // Place the window above all topmost windows-        SetWindowPos( _glfwWin.window, HWND_TOPMOST, 0,0,0,0,-                      SWP_NOMOVE | SWP_NOSIZE );-    }--    setForegroundWindow( _glfwWin.window );-    SetFocus( _glfwWin.window );--    return GL_TRUE;-}---//========================================================================-// Properly kill the window / video display-//========================================================================--void _glfwPlatformCloseWindow( void )-{-    destroyWindow();--    if( _glfwWin.classAtom )-    {-        UnregisterClass( _GLFW_WNDCLASSNAME, _glfwLibrary.instance );-        _glfwWin.classAtom = 0;-    }--    if( _glfwWin.fullscreen )-    {-        // Restore original desktop resolution-        ChangeDisplaySettings( NULL, CDS_FULLSCREEN );-    }-}---//========================================================================-// Set the window title-//========================================================================--void _glfwPlatformSetWindowTitle( const char *title )-{-    (void) SetWindowText( _glfwWin.window, title );-}---//========================================================================-// Set the window size.-//========================================================================--void _glfwPlatformSetWindowSize( int width, int height )-{-    int     bpp, mode = 0, refresh;-    int     sizechanged = GL_FALSE;-    GLint   drawbuffer;-    GLfloat clearcolor[4];--    if( _glfwWin.fullscreen )-    {-        // Get some info about the current mode--        DEVMODE dm;--        // Get current BPP settings-        dm.dmSize = sizeof( DEVMODE );-        if( EnumDisplaySettings( NULL, _glfwWin.modeID, &dm ) )-        {-            // Get bpp-            bpp = dm.dmBitsPerPel;--            // Get closest match for target video mode-            refresh = _glfwWin.desiredRefreshRate;-            mode = _glfwGetClosestVideoModeBPP( &width, &height, &bpp,-                                                &refresh );-        }-        else-        {-            mode = _glfwWin.modeID;-        }-    }-    else-    {-        // If we are in windowed mode, adjust the window size to-        // compensate for window decorations-        getFullWindowSize( width, height, &width, &height );-    }--    // Change window size before changing fullscreen mode?-    if( _glfwWin.fullscreen && (width > _glfwWin.width) )-    {-        SetWindowPos( _glfwWin.window, HWND_TOP, 0, 0, width, height,-                      SWP_NOOWNERZORDER | SWP_NOMOVE | SWP_NOZORDER );-        sizechanged = GL_TRUE;-    }--    // Change fullscreen video mode?-    if( _glfwWin.fullscreen && mode != _glfwWin.modeID )-    {-        _glfwSetVideoModeMODE( mode );--        // Clear the front buffer to black (avoid ugly desktop remains in-        // our OpenGL window)-        glGetIntegerv( GL_DRAW_BUFFER, &drawbuffer );-        glGetFloatv( GL_COLOR_CLEAR_VALUE, clearcolor );-        glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );-        glClear( GL_COLOR_BUFFER_BIT );-        if( drawbuffer == GL_BACK )-        {-            _glfw_SwapBuffers( _glfwWin.DC );-        }-        glClearColor( clearcolor[0], clearcolor[1], clearcolor[2],-                      clearcolor[3] );-    }--    // Set window size (if not already changed)-    if( !sizechanged )-    {-        SetWindowPos( _glfwWin.window, HWND_TOP, 0, 0, width, height,-                      SWP_NOOWNERZORDER | SWP_NOMOVE | SWP_NOZORDER );-    }-}---//========================================================================-// Set the window position-//========================================================================--void _glfwPlatformSetWindowPos( int x, int y )-{-    (void) SetWindowPos( _glfwWin.window, HWND_TOP, x, y, 0, 0,-                         SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER );-}---//========================================================================-// Window iconification-//========================================================================--void _glfwPlatformIconifyWindow( void )-{-    // Iconify window-    ShowWindow( _glfwWin.window, SW_MINIMIZE );-    _glfwWin.iconified = GL_TRUE;--    // If we are in fullscreen mode we need to change video modes-    if( _glfwWin.fullscreen )-    {-        // Change display settings to the desktop resolution-        ChangeDisplaySettings( NULL, CDS_FULLSCREEN );-    }--    // Unlock mouse-    if( !_glfwWin.oldMouseLockValid )-    {-        _glfwWin.oldMouseLock = _glfwWin.mouseLock;-        _glfwWin.oldMouseLockValid = GL_TRUE;-        glfwEnable( GLFW_MOUSE_CURSOR );-    }-}---//========================================================================-// Window un-iconification-//========================================================================--void _glfwPlatformRestoreWindow( void )-{-    // If we are in fullscreen mode we need to change video modes-    if( _glfwWin.fullscreen )-    {-        // Change display settings to the user selected mode-        _glfwSetVideoModeMODE( _glfwWin.modeID );-    }--    // Un-iconify window-    ShowWindow( _glfwWin.window, SW_RESTORE );--    // Make sure that our window ends up on top of things-    ShowWindow( _glfwWin.window, SW_SHOW );-    setForegroundWindow( _glfwWin.window );-    SetFocus( _glfwWin.window );--    // Window is no longer iconified-    _glfwWin.iconified = GL_FALSE;--    // Lock mouse, if necessary-    if( _glfwWin.oldMouseLockValid && _glfwWin.oldMouseLock )-    {-        glfwDisable( GLFW_MOUSE_CURSOR );-    }-    _glfwWin.oldMouseLockValid = GL_FALSE;-}---//========================================================================-// Swap buffers (double-buffering)-//========================================================================--void _glfwPlatformSwapBuffers( void )-{-    _glfw_SwapBuffers( _glfwWin.DC );-}---//========================================================================-// Set double buffering swap interval-//========================================================================--void _glfwPlatformSwapInterval( int interval )-{-    if( _glfwWin.has_WGL_EXT_swap_control )-    {-        _glfwWin.SwapIntervalEXT( interval );-    }-}---//========================================================================-// Write back window parameters into GLFW window structure-//========================================================================--void _glfwPlatformRefreshWindowParams( void )-{-    PIXELFORMATDESCRIPTOR pfd;-    DEVMODE dm;-    int pixelFormat, mode;--    // Obtain a detailed description of current pixel format-    pixelFormat = _glfw_GetPixelFormat( _glfwWin.DC );--    if( _glfwWin.has_WGL_ARB_pixel_format )-    {-        if( getPixelFormatAttrib( pixelFormat, WGL_ACCELERATION_ARB ) !=-            WGL_NO_ACCELERATION_ARB )-        {-            _glfwWin.accelerated = GL_TRUE;-        }-        else-        {-            _glfwWin.accelerated = GL_FALSE;-        }--        _glfwWin.redBits = getPixelFormatAttrib( pixelFormat, WGL_RED_BITS_ARB );-        _glfwWin.greenBits = getPixelFormatAttrib( pixelFormat, WGL_GREEN_BITS_ARB );-        _glfwWin.blueBits = getPixelFormatAttrib( pixelFormat, WGL_BLUE_BITS_ARB );--        _glfwWin.alphaBits = getPixelFormatAttrib( pixelFormat, WGL_ALPHA_BITS_ARB );-        _glfwWin.depthBits = getPixelFormatAttrib( pixelFormat, WGL_DEPTH_BITS_ARB );-        _glfwWin.stencilBits = getPixelFormatAttrib( pixelFormat, WGL_STENCIL_BITS_ARB );--        _glfwWin.accumRedBits = getPixelFormatAttrib( pixelFormat, WGL_ACCUM_RED_BITS_ARB );-        _glfwWin.accumGreenBits = getPixelFormatAttrib( pixelFormat, WGL_ACCUM_GREEN_BITS_ARB );-        _glfwWin.accumBlueBits = getPixelFormatAttrib( pixelFormat, WGL_ACCUM_BLUE_BITS_ARB );-        _glfwWin.accumAlphaBits = getPixelFormatAttrib( pixelFormat, WGL_ACCUM_ALPHA_BITS_ARB );--        _glfwWin.auxBuffers = getPixelFormatAttrib( pixelFormat, WGL_AUX_BUFFERS_ARB );-        _glfwWin.stereo = getPixelFormatAttrib( pixelFormat, WGL_STEREO_ARB ) ? GL_TRUE : GL_FALSE;--        if( _glfwWin.has_WGL_ARB_multisample )-        {-            _glfwWin.samples = getPixelFormatAttrib( pixelFormat, WGL_SAMPLES_ARB );-            // Should we force 1 to 0 here for consistency, or keep 1 for transparency?-        }-        else-        {-            _glfwWin.samples = 0;-        }-    }-    else-    {-        _glfw_DescribePixelFormat( _glfwWin.DC, pixelFormat,-                                   sizeof(PIXELFORMATDESCRIPTOR), &pfd );--        // Is current OpenGL context accelerated?-        _glfwWin.accelerated = (pfd.dwFlags & PFD_GENERIC_ACCELERATED) ||-                               !(pfd.dwFlags & PFD_GENERIC_FORMAT) ? 1 : 0;--        // "Standard" window parameters-        _glfwWin.redBits        = pfd.cRedBits;-        _glfwWin.greenBits      = pfd.cGreenBits;-        _glfwWin.blueBits       = pfd.cBlueBits;-        _glfwWin.alphaBits      = pfd.cAlphaBits;-        _glfwWin.depthBits      = pfd.cDepthBits;-        _glfwWin.stencilBits    = pfd.cStencilBits;-        _glfwWin.accumRedBits   = pfd.cAccumRedBits;-        _glfwWin.accumGreenBits = pfd.cAccumGreenBits;-        _glfwWin.accumBlueBits  = pfd.cAccumBlueBits;-        _glfwWin.accumAlphaBits = pfd.cAccumAlphaBits;-        _glfwWin.auxBuffers     = pfd.cAuxBuffers;-        _glfwWin.stereo         = (pfd.dwFlags & PFD_STEREO) ? GL_TRUE : GL_FALSE;--        // If we don't have WGL_ARB_pixel_format then we can't have created a-        // multisampling context, so it's safe to hardcode zero here-        _glfwWin.samples = 0;-    }--    // Get refresh rate-    mode = _glfwWin.fullscreen ? _glfwWin.modeID : ENUM_CURRENT_SETTINGS;-    dm.dmSize = sizeof( DEVMODE );--    if( EnumDisplaySettings( NULL, mode, &dm ) )-    {-        _glfwWin.refreshRate = dm.dmDisplayFrequency;-        if( _glfwWin.refreshRate <= 1 )-        {-            _glfwWin.refreshRate = 0;-        }-    }-    else-    {-        _glfwWin.refreshRate = 0;-    }-}---//========================================================================-// Poll for new window and input events-//========================================================================--void _glfwPlatformPollEvents( void )-{-    MSG msg;-    int winclosed = GL_FALSE;--    // Flag: mouse was not moved (will be changed by _glfwGetNextEvent if-    // there was a mouse move event)-    _glfwInput.MouseMoved = GL_FALSE;-    if( _glfwWin.mouseLock )-    {-        _glfwInput.OldMouseX = _glfwWin.width/2;-        _glfwInput.OldMouseY = _glfwWin.height/2;-    }-    else-    {-        _glfwInput.OldMouseX = _glfwInput.MousePosX;-        _glfwInput.OldMouseY = _glfwInput.MousePosY;-    }--    // Check for new window messages-    while( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )-    {-        switch( msg.message )-        {-            // QUIT-message (from close window)?-            case WM_QUIT:-                winclosed = GL_TRUE;-                break;--            // Ok, send it to the window message handler-            default:-                DispatchMessage( &msg );-                break;-        }-    }--    // LSHIFT/RSHIFT fixup (keys tend to "stick" without this fix)-    // This is the only async event handling in GLFW, but it solves some-    // nasty problems.-    // Caveat: Does not work under Win 9x/ME.-    if( _glfwLibrary.Sys.winVer >= _GLFW_WIN_NT4 )-    {-        int lshift_down, rshift_down;--        // Get current state of left and right shift keys-        lshift_down = (GetAsyncKeyState( VK_LSHIFT ) >> 15) & 1;-        rshift_down = (GetAsyncKeyState( VK_RSHIFT ) >> 15) & 1;--        // See if this differs from our belief of what has happened-        // (we only have to check for lost key up events)-        if( !lshift_down && _glfwInput.Key[ GLFW_KEY_LSHIFT ] == 1 )-        {-            _glfwInputKey( GLFW_KEY_LSHIFT, GLFW_RELEASE );-        }-        if( !rshift_down && _glfwInput.Key[ GLFW_KEY_RSHIFT ] == 1 )-        {-            _glfwInputKey( GLFW_KEY_RSHIFT, GLFW_RELEASE );-        }-    }--    // Did we have mouse movement in locked cursor mode?-    if( _glfwInput.MouseMoved && _glfwWin.mouseLock )-    {-        _glfwPlatformSetMouseCursorPos( _glfwWin.width / 2,-                                        _glfwWin.height / 2 );-    }--    // Was there a window close request?-    if( winclosed && _glfwWin.windowCloseCallback )-    {-        // Check if the program wants us to close the window-        winclosed = _glfwWin.windowCloseCallback();-    }-    if( winclosed )-    {-        glfwCloseWindow();-    }-}---//========================================================================-// Wait for new window and input events-//========================================================================--void _glfwPlatformWaitEvents( void )-{-    WaitMessage();--    _glfwPlatformPollEvents();-}---//========================================================================-// Hide mouse cursor (lock it)-//========================================================================--void _glfwPlatformHideMouseCursor( void )-{-    RECT ClipWindowRect;--    ShowCursor( FALSE );--    // Clip cursor to the window-    if( GetWindowRect( _glfwWin.window, &ClipWindowRect ) )-    {-        ClipCursor( &ClipWindowRect );-    }--    // Capture cursor to user window-    SetCapture( _glfwWin.window );-}---//========================================================================-// Show mouse cursor (unlock it)-//========================================================================--void _glfwPlatformShowMouseCursor( void )-{-    // Un-capture cursor-    ReleaseCapture();--    // Release the cursor from the window-    ClipCursor( NULL );--    ShowCursor( TRUE );-}---//========================================================================-// Set physical mouse cursor position-//========================================================================--void _glfwPlatformSetMouseCursorPos( int x, int y )-{-    POINT pos;--    // Convert client coordinates to screen coordinates-    pos.x = x;-    pos.y = y;-    ClientToScreen( _glfwWin.window, &pos );--    SetCursorPos( pos.x, pos.y );-}-
− glfw/lib/window.c 
@@ -1,1005 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    Any-// API version: 2.7-// WWW:         http://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>---#ifndef GL_VERSION_3_2--#define GL_CONTEXT_CORE_PROFILE_BIT       0x00000001-#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002-#define GL_CONTEXT_PROFILE_MASK           0x9126--#endif /*GL_VERSION_3_2*/----//************************************************************************-//****                  GLFW internal functions                       ****-//************************************************************************--static int Max(int a, int b)-{-    return (a > b) ? a : b;-}--//========================================================================-// Clear all open window hints-//========================================================================--void _glfwClearWindowHints( void )-{-    memset( &_glfwLibrary.hints, 0, sizeof( _glfwLibrary.hints ) );-    _glfwLibrary.hints.glMajor = 1;-}---//========================================================================-// Handle the input tracking part of window deactivation-//========================================================================--void _glfwInputDeactivation( void )-{-    int i;--    // Release all keyboard keys-    for( i = 0; i <= GLFW_KEY_LAST; i ++ )-    {-        if( _glfwInput.Key[ i ] == GLFW_PRESS )-        {-            _glfwInputKey( i, GLFW_RELEASE );-        }-    }--    // Release all mouse buttons-    for( i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i ++ )-    {-        if( _glfwInput.MouseButton[ i ] == GLFW_PRESS )-        {-            _glfwInputMouseClick( i, GLFW_RELEASE );-        }-    }-}---//========================================================================-// Clear all input state-//========================================================================--void _glfwClearInput( void )-{-    int i;--    // Release all keyboard keys-    for( i = 0; i <= GLFW_KEY_LAST; i ++ )-    {-        _glfwInput.Key[ i ] = GLFW_RELEASE;-    }--    // Clear last character-    _glfwInput.LastChar = 0;--    // Release all mouse buttons-    for( i = 0; i <= GLFW_MOUSE_BUTTON_LAST; i ++ )-    {-        _glfwInput.MouseButton[ i ] = GLFW_RELEASE;-    }--    // Set mouse position to (0,0)-    _glfwInput.MousePosX = 0;-    _glfwInput.MousePosY = 0;--    // Set mouse wheel position to 0-    _glfwInput.WheelPos = 0;--    // The default is to use non sticky keys and mouse buttons-    _glfwInput.StickyKeys = GL_FALSE;-    _glfwInput.StickyMouseButtons = GL_FALSE;--    // The default is to disable key repeat-    _glfwInput.KeyRepeat = GL_FALSE;-}---//========================================================================-// Register keyboard activity-//========================================================================--void _glfwInputKey( int key, int action )-{-    int keyrepeat = 0;--    if( key < 0 || key > GLFW_KEY_LAST )-    {-        return;-    }--    // Are we trying to release an already released key?-    if( action == GLFW_RELEASE && _glfwInput.Key[ key ] != GLFW_PRESS )-    {-        return;-    }--    // Register key action-    if( action == GLFW_RELEASE && _glfwInput.StickyKeys )-    {-        _glfwInput.Key[ key ] = GLFW_STICK;-    }-    else-    {-        keyrepeat = (_glfwInput.Key[ key ] == GLFW_PRESS) &&-                    (action == GLFW_PRESS);-        _glfwInput.Key[ key ] = (char) action;-    }--    // Call user callback function-    if( _glfwWin.keyCallback && (_glfwInput.KeyRepeat || !keyrepeat) )-    {-        _glfwWin.keyCallback( key, action );-    }-}---//========================================================================-// Register (keyboard) character activity-//========================================================================--void _glfwInputChar( int character, int action )-{-    int keyrepeat = 0;--    // Valid Unicode (ISO 10646) character?-    if( !( (character >= 32 && character <= 126) || character >= 160 ) )-    {-        return;-    }--    // Is this a key repeat?-    if( action == GLFW_PRESS && _glfwInput.LastChar == character )-    {-        keyrepeat = 1;-    }--    // Store this character as last character (or clear it, if released)-    if( action == GLFW_PRESS )-    {-        _glfwInput.LastChar = character;-    }-    else-    {-        _glfwInput.LastChar = 0;-    }--    if( action != GLFW_PRESS )-    {-        // This intentionally breaks release notifications for Unicode-        // characters, partly to see if anyone cares but mostly because it's-        // a nonsensical concept to begin with-        //-        // It will remain broken either until its removal in the 3.0 API or-        // until someone explains, in a way that makes sense to people outside-        // the US and Scandinavia, what "Unicode character up" actually means-        //-        // If what you want is "physical key up" then you should be using the-        // key functions and/or the key callback, NOT the Unicode input-        //-        // However, if your particular application uses this misfeature for...-        // something, you can re-enable it by removing this if-statement-        return;-    }--    if( _glfwWin.charCallback && (_glfwInput.KeyRepeat || !keyrepeat) )-    {-        _glfwWin.charCallback( character, action );-    }-}---//========================================================================-// Register mouse button clicks-//========================================================================--void _glfwInputMouseClick( int button, int action )-{-    if( button >= 0 && button <= GLFW_MOUSE_BUTTON_LAST )-    {-        // Register mouse button action-        if( action == GLFW_RELEASE && _glfwInput.StickyMouseButtons )-        {-            _glfwInput.MouseButton[ button ] = GLFW_STICK;-        }-        else-        {-            _glfwInput.MouseButton[ button ] = (char) action;-        }--        // Call user callback function-        if( _glfwWin.mouseButtonCallback )-        {-            _glfwWin.mouseButtonCallback( button, action );-        }-    }-}---//========================================================================-// Return the available framebuffer config closest to the desired values-// This is based on the manual GLX Visual selection from 2.6-//========================================================================--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 );-            }-        }--        // Figure out if the current one is better than the best one found so far--        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;-}---//************************************************************************-//****                    GLFW user functions                         ****-//************************************************************************--//========================================================================-// Create the GLFW window and its associated context-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwOpenWindow( int width, int height,-    int redbits, int greenbits, int bluebits, int alphabits,-    int depthbits, int stencilbits, int mode )-{-    _GLFWfbconfig fbconfig;-    _GLFWwndconfig wndconfig;--    if( !_glfwInitialized || _glfwWin.opened )-    {-        return GL_FALSE;-    }--    // Set up desired framebuffer config-    fbconfig.redBits        = Max( redbits, 0 );-    fbconfig.greenBits      = Max( greenbits, 0 );-    fbconfig.blueBits       = Max( bluebits, 0 );-    fbconfig.alphaBits      = Max( alphabits, 0 );-    fbconfig.depthBits      = Max( depthbits, 0 );-    fbconfig.stencilBits    = Max( stencilbits, 0 );-    fbconfig.accumRedBits   = Max( _glfwLibrary.hints.accumRedBits, 0 );-    fbconfig.accumGreenBits = Max( _glfwLibrary.hints.accumGreenBits, 0 );-    fbconfig.accumBlueBits  = Max( _glfwLibrary.hints.accumBlueBits, 0 );-    fbconfig.accumAlphaBits = Max( _glfwLibrary.hints.accumAlphaBits, 0 );-    fbconfig.auxBuffers     = Max( _glfwLibrary.hints.auxBuffers, 0 );-    fbconfig.stereo         = _glfwLibrary.hints.stereo ? GL_TRUE : GL_FALSE;-    fbconfig.samples        = Max( _glfwLibrary.hints.samples, 0 );--    // Set up desired window config-    wndconfig.mode           = mode;-    wndconfig.refreshRate    = Max( _glfwLibrary.hints.refreshRate, 0 );-    wndconfig.windowNoResize = _glfwLibrary.hints.windowNoResize ? GL_TRUE : GL_FALSE;-    wndconfig.glMajor        = Max( _glfwLibrary.hints.glMajor, 1 );-    wndconfig.glMinor        = Max( _glfwLibrary.hints.glMinor, 0 );-    wndconfig.glForward      = _glfwLibrary.hints.glForward ? GL_TRUE : GL_FALSE;-    wndconfig.glDebug        = _glfwLibrary.hints.glDebug ? GL_TRUE : GL_FALSE;-    wndconfig.glProfile      = _glfwLibrary.hints.glProfile;--    if( wndconfig.glMajor == 1 && wndconfig.glMinor > 5 )-    {-        // OpenGL 1.x series ended with version 1.5-        return GL_FALSE;-    }-    else if( wndconfig.glMajor == 2 && wndconfig.glMinor > 1 )-    {-        // OpenGL 2.x series ended with version 2.1-        return GL_FALSE;-    }-    else if( wndconfig.glMajor == 3 && wndconfig.glMinor > 3 )-    {-        // OpenGL 3.x series ended with version 3.3-        return GL_FALSE;-    }-    else-    {-        // For now, let everything else through-    }--    if( wndconfig.glProfile &&-        ( wndconfig.glMajor < 3 || ( wndconfig.glMajor == 3 && wndconfig.glMinor < 2 ) ) )-    {-        // Context profiles are only defined 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-        return GL_FALSE;-    }--    // Clear for next open call-    _glfwClearWindowHints();--    // Check input arguments-    if( mode != GLFW_WINDOW && mode != GLFW_FULLSCREEN )-    {-        return GL_FALSE;-    }--    // Clear GLFW window state-    _glfwWin.active         = GL_TRUE;-    _glfwWin.iconified      = GL_FALSE;-    _glfwWin.mouseLock      = GL_FALSE;-    _glfwWin.autoPollEvents = GL_TRUE;-    _glfwClearInput();--    // Unregister all callback functions-    _glfwWin.windowSizeCallback    = NULL;-    _glfwWin.windowCloseCallback   = NULL;-    _glfwWin.windowRefreshCallback = NULL;-    _glfwWin.keyCallback           = NULL;-    _glfwWin.charCallback          = NULL;-    _glfwWin.mousePosCallback      = NULL;-    _glfwWin.mouseButtonCallback   = NULL;-    _glfwWin.mouseWheelCallback    = NULL;--    // Check width & height-    if( width > 0 && height <= 0 )-    {-        // Set the window aspect ratio to 4:3-        height = (width * 3) / 4;-    }-    else if( width <= 0 && height > 0 )-    {-        // Set the window aspect ratio to 4:3-        width = (height * 4) / 3;-    }-    else if( width <= 0 && height <= 0 )-    {-        // Default window size-        width  = 640;-        height = 480;-    }--    // Remember window settings-    _glfwWin.width      = width;-    _glfwWin.height     = height;-    _glfwWin.fullscreen = (mode == GLFW_FULLSCREEN ? GL_TRUE : GL_FALSE);--    // Platform specific window opening routine-    if( !_glfwPlatformOpenWindow( width, height, &wndconfig, &fbconfig ) )-    {-        glfwCloseWindow();-        return GL_FALSE;-    }--    // Flag that window is now opened-    _glfwWin.opened = GL_TRUE;--    // Read back window and context parameters-    _glfwPlatformRefreshWindowParams();-    _glfwRefreshContextParams();--    if( _glfwWin.glMajor < wndconfig.glMajor ||-        ( _glfwWin.glMajor == wndconfig.glMajor &&-          _glfwWin.glMinor < wndconfig.glMinor ) )-    {-        glfwCloseWindow();-        return GL_FALSE;-    }--    // Do we have non-power-of-two textures (added to core in version 2.0)?-    _glfwWin.has_GL_ARB_texture_non_power_of_two =-        ( _glfwWin.glMajor >= 2 ) ||-        glfwExtensionSupported( "GL_ARB_texture_non_power_of_two" );--    // Do we have automatic mipmap generation (added to core in version 1.4)?-    _glfwWin.has_GL_SGIS_generate_mipmap =-        ( _glfwWin.glMajor >= 2 ) || ( _glfwWin.glMinor >= 4 ) ||-        glfwExtensionSupported( "GL_SGIS_generate_mipmap" );--    if( _glfwWin.glMajor > 2 )-    {-        _glfwWin.GetStringi = (PFNGLGETSTRINGIPROC) glfwGetProcAddress( "glGetStringi" );-        if( !_glfwWin.GetStringi )-        {-            // This is a very common problem among people who compile GLFW-            // on X11/GLX using custom build systems, as it needs explicit-            // configuration in order to work-            //-            // See readme.html section 2.2 for details--            glfwCloseWindow();-            return GL_FALSE;-        }-    }--    // If full-screen mode was requested, disable mouse cursor-    if( mode == GLFW_FULLSCREEN )-    {-        glfwDisable( GLFW_MOUSE_CURSOR );-    }--    // Start by clearing the front buffer to black (avoid ugly desktop-    // remains in our OpenGL window)-    glClear( GL_COLOR_BUFFER_BIT );-    _glfwPlatformSwapBuffers();--    return GL_TRUE;-}---//========================================================================-// Set hints for opening the window-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwOpenWindowHint( int target, int hint )-{-    if( !_glfwInitialized )-    {-        return;-    }--    switch( target )-    {-        case GLFW_REFRESH_RATE:-            _glfwLibrary.hints.refreshRate = hint;-            break;-        case GLFW_ACCUM_RED_BITS:-            _glfwLibrary.hints.accumRedBits = hint;-            break;-        case GLFW_ACCUM_GREEN_BITS:-            _glfwLibrary.hints.accumGreenBits = hint;-            break;-        case GLFW_ACCUM_BLUE_BITS:-            _glfwLibrary.hints.accumBlueBits = hint;-            break;-        case GLFW_ACCUM_ALPHA_BITS:-            _glfwLibrary.hints.accumAlphaBits = hint;-            break;-        case GLFW_AUX_BUFFERS:-            _glfwLibrary.hints.auxBuffers = hint;-            break;-        case GLFW_STEREO:-            _glfwLibrary.hints.stereo = hint;-            break;-        case GLFW_WINDOW_NO_RESIZE:-            _glfwLibrary.hints.windowNoResize = hint;-            break;-        case GLFW_FSAA_SAMPLES:-            _glfwLibrary.hints.samples = hint;-            break;-        case GLFW_OPENGL_VERSION_MAJOR:-            _glfwLibrary.hints.glMajor = hint;-            break;-        case GLFW_OPENGL_VERSION_MINOR:-            _glfwLibrary.hints.glMinor = hint;-            break;-        case GLFW_OPENGL_FORWARD_COMPAT:-            _glfwLibrary.hints.glForward = hint;-            break;-        case GLFW_OPENGL_DEBUG_CONTEXT:-            _glfwLibrary.hints.glDebug = hint;-            break;-        case GLFW_OPENGL_PROFILE:-            _glfwLibrary.hints.glProfile = hint;-            break;-        default:-            break;-    }-}---//========================================================================-// Properly kill the window / video display-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwCloseWindow( void )-{-    if( !_glfwInitialized )-    {-        return;-    }--    // Show mouse pointer again (if hidden)-    glfwEnable( GLFW_MOUSE_CURSOR );--    _glfwPlatformCloseWindow();--    memset( &_glfwWin, 0, sizeof(_glfwWin) );-}---//========================================================================-// Set the window title-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetWindowTitle( const char *title )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Set window title-    _glfwPlatformSetWindowTitle( title );-}---//========================================================================-// Get the window size-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwGetWindowSize( int *width, int *height )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    if( width != NULL )-    {-        *width = _glfwWin.width;-    }-    if( height != NULL )-    {-        *height = _glfwWin.height;-    }-}---//========================================================================-// Set the window size-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetWindowSize( int width, int height )-{-    if( !_glfwInitialized || !_glfwWin.opened || _glfwWin.iconified )-    {-        return;-    }--    // Don't do anything if the window size did not change-    if( width == _glfwWin.width && height == _glfwWin.height )-    {-        return;-    }--    // Change window size-    _glfwPlatformSetWindowSize( width, height );--    // Refresh window parameters (may have changed due to changed video-    // modes)-    _glfwPlatformRefreshWindowParams();-}---//========================================================================-// Set the window position-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetWindowPos( int x, int y )-{-    if( !_glfwInitialized || !_glfwWin.opened || _glfwWin.fullscreen ||-        _glfwWin.iconified )-    {-        return;-    }--    // Set window position-    _glfwPlatformSetWindowPos( x, y );-}---//========================================================================-// Window iconification-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwIconifyWindow( void )-{-    if( !_glfwInitialized || !_glfwWin.opened || _glfwWin.iconified )-    {-        return;-    }--    // Iconify window-    _glfwPlatformIconifyWindow();-}---//========================================================================-// Window un-iconification-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwRestoreWindow( void )-{-    if( !_glfwInitialized || !_glfwWin.opened || !_glfwWin.iconified )-    {-        return;-    }--    // Restore iconified window-    _glfwPlatformRestoreWindow();--    // Refresh window parameters-    _glfwPlatformRefreshWindowParams();-}---//========================================================================-// Swap buffers (double-buffering) and poll any new events-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSwapBuffers( void )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    _glfwPlatformSwapBuffers();--    // Check for window messages-    if( _glfwWin.autoPollEvents )-    {-        glfwPollEvents();-    }-}---//========================================================================-// Set double buffering swap interval (0 = vsync off)-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSwapInterval( int interval )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Set double buffering swap interval-    _glfwPlatformSwapInterval( interval );-}---//========================================================================-// Get window parameter-//========================================================================--GLFWAPI int GLFWAPIENTRY glfwGetWindowParam( int param )-{-    if( !_glfwInitialized )-    {-        return 0;-    }--    // Is the window opened?-    if( !_glfwWin.opened )-    {-        if( param == GLFW_OPENED )-        {-            return GL_FALSE;-        }-        return 0;-    }--    // Window parameters-    switch( param )-    {-        case GLFW_OPENED:-            return GL_TRUE;-        case GLFW_ACTIVE:-            return _glfwWin.active;-        case GLFW_ICONIFIED:-            return _glfwWin.iconified;-        case GLFW_ACCELERATED:-            return _glfwWin.accelerated;-        case GLFW_RED_BITS:-            return _glfwWin.redBits;-        case GLFW_GREEN_BITS:-            return _glfwWin.greenBits;-        case GLFW_BLUE_BITS:-            return _glfwWin.blueBits;-        case GLFW_ALPHA_BITS:-            return _glfwWin.alphaBits;-        case GLFW_DEPTH_BITS:-            return _glfwWin.depthBits;-        case GLFW_STENCIL_BITS:-            return _glfwWin.stencilBits;-        case GLFW_ACCUM_RED_BITS:-            return _glfwWin.accumRedBits;-        case GLFW_ACCUM_GREEN_BITS:-            return _glfwWin.accumGreenBits;-        case GLFW_ACCUM_BLUE_BITS:-            return _glfwWin.accumBlueBits;-        case GLFW_ACCUM_ALPHA_BITS:-            return _glfwWin.accumAlphaBits;-        case GLFW_AUX_BUFFERS:-            return _glfwWin.auxBuffers;-        case GLFW_STEREO:-            return _glfwWin.stereo;-        case GLFW_REFRESH_RATE:-            return _glfwWin.refreshRate;-        case GLFW_WINDOW_NO_RESIZE:-            return _glfwWin.windowNoResize;-        case GLFW_FSAA_SAMPLES:-            return _glfwWin.samples;-        case GLFW_OPENGL_VERSION_MAJOR:-            return _glfwWin.glMajor;-        case GLFW_OPENGL_VERSION_MINOR:-            return _glfwWin.glMinor;-        case GLFW_OPENGL_FORWARD_COMPAT:-            return _glfwWin.glForward;-        case GLFW_OPENGL_DEBUG_CONTEXT:-            return _glfwWin.glDebug;-        case GLFW_OPENGL_PROFILE:-            return _glfwWin.glProfile;-        default:-            return 0;-    }-}---//========================================================================-// Set callback function for window size changes-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetWindowSizeCallback( GLFWwindowsizefun cbfun )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Set callback function-    _glfwWin.windowSizeCallback = cbfun;--    // Call the callback function to let the application know the current-    // window size-    if( cbfun )-    {-        cbfun( _glfwWin.width, _glfwWin.height );-    }-}--//========================================================================-// Set callback function for window close events-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetWindowCloseCallback( GLFWwindowclosefun cbfun )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Set callback function-    _glfwWin.windowCloseCallback = cbfun;-}---//========================================================================-// Set callback function for window refresh events-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwSetWindowRefreshCallback( GLFWwindowrefreshfun cbfun )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Set callback function-    _glfwWin.windowRefreshCallback = cbfun;-}---//========================================================================-// Poll for new window and input events-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwPollEvents( void )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Poll for new events-    _glfwPlatformPollEvents();-}---//========================================================================-// Wait for new window and input events-//========================================================================--GLFWAPI void GLFWAPIENTRY glfwWaitEvents( void )-{-    if( !_glfwInitialized || !_glfwWin.opened )-    {-        return;-    }--    // Poll for new events-    _glfwPlatformWaitEvents();-}-
− glfw/lib/x11/platform.h 
@@ -1,503 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    X11/GLX-// API version: 2.7-// WWW:         http://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 _platform_h_-#define _platform_h_---// This is the X11 version of GLFW-#define _GLFW_X11---// Include files-#include <sys/time.h>-#include <unistd.h>-#include <signal.h>-#include <X11/Xlib.h>-#include <X11/keysym.h>-#include <X11/Xatom.h>-#include <GL/glx.h>-#include "../../include/GL/glfw.h"--// Do we have pthread support?-#ifdef _GLFW_HAS_PTHREAD- #include <pthread.h>- #include <sched.h>-#endif--// We need declarations for GLX version 1.3 or above even if the server doesn't-// support version 1.3-#ifndef GLX_VERSION_1_3- #error "GLX header version 1.3 or above is required"-#endif--#if defined( _GLFW_HAS_XF86VIDMODE ) && defined( _GLFW_HAS_XRANDR )- #error "Xf86VidMode and RandR extensions cannot both be enabled"-#endif--// With XFree86, we can use the XF86VidMode extension-#if defined( _GLFW_HAS_XF86VIDMODE )- #include <X11/extensions/xf86vmode.h>-#endif--#if defined( _GLFW_HAS_XRANDR )- #include <X11/extensions/Xrandr.h>-#endif--// Do we have support for dlopen/dlsym?-#if defined( _GLFW_HAS_DLOPEN )- #include <dlfcn.h>-#endif--// We support two different ways for getting the number of processors in-// the system: sysconf (POSIX) and sysctl (BSD?)-#if defined( _GLFW_HAS_SYSCONF )-- // Use a single constant for querying number of online processors using- // the sysconf function (e.g. SGI defines _SC_NPROC_ONLN instead of- // _SC_NPROCESSORS_ONLN)- #ifndef _SC_NPROCESSORS_ONLN-  #ifdef  _SC_NPROC_ONLN-   #define _SC_NPROCESSORS_ONLN _SC_NPROC_ONLN-  #else-   #error POSIX constant _SC_NPROCESSORS_ONLN not defined!-  #endif- #endif-- // Macro for querying the number of processors- #define _glfw_numprocessors(n) n=(int)sysconf(_SC_NPROCESSORS_ONLN)--#elif defined( _GLFW_HAS_SYSCTL )-- #include <sys/types.h>- #include <sys/sysctl.h>-- // Macro for querying the number of processors- #define _glfw_numprocessors(n) { \-    int mib[2], ncpu; \-    size_t len = 1; \-    mib[0] = CTL_HW; \-    mib[1] = HW_NCPU; \-    n      = 1; \-    if( sysctl( mib, 2, &ncpu, &len, NULL, 0 ) != -1 ) \-    { \-        if( len > 0 ) \-        { \-            n = ncpu; \-        } \-    } \- }--#else-- // If neither sysconf nor sysctl is supported, assume single processor- // system- #define _glfw_numprocessors(n) n=1--#endif--// Pointer length integer-// One day, this will most likely move into glfw.h-typedef intptr_t GLFWintptr;---#ifndef GLX_SGI_swap_control--// Function signature for GLX_SGI_swap_control-typedef int ( * PFNGLXSWAPINTERVALSGIPROC) (int interval);--#endif /*GLX_SGI_swap_control*/---#ifndef GLX_SGIX_fbconfig--/* Type definitions for GLX_SGIX_fbconfig */-typedef XID GLXFBConfigIDSGIX;-typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;--/* Function signatures for GLX_SGIX_fbconfig */-typedef int ( * PFNGLXGETFBCONFIGATTRIBSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int attribute, int *value);-typedef GLXFBConfigSGIX * ( * PFNGLXCHOOSEFBCONFIGSGIXPROC) (Display *dpy, int screen, int *attrib_list, int *nelements);-typedef GLXContext ( * PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) (Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct);-typedef XVisualInfo * ( * PFNGLXGETVISUALFROMFBCONFIGSGIXPROC) (Display *dpy, GLXFBConfigSGIX config);--/* Tokens for GLX_SGIX_fbconfig */-#define GLX_WINDOW_BIT_SGIX                0x00000001-#define GLX_PIXMAP_BIT_SGIX                0x00000002-#define GLX_RGBA_BIT_SGIX                  0x00000001-#define GLX_COLOR_INDEX_BIT_SGIX           0x00000002-#define GLX_DRAWABLE_TYPE_SGIX             0x8010-#define GLX_RENDER_TYPE_SGIX               0x8011-#define GLX_X_RENDERABLE_SGIX              0x8012-#define GLX_FBCONFIG_ID_SGIX               0x8013-#define GLX_RGBA_TYPE_SGIX                 0x8014-#define GLX_COLOR_INDEX_TYPE_SGIX          0x8015-#define GLX_SCREEN_EXT                     0x800C--#endif /*GLX_SGIX_fbconfig*/---#ifndef GLX_ARB_create_context--/* Tokens for glXCreateContextAttribsARB attributes */-#define GLX_CONTEXT_MAJOR_VERSION_ARB           0x2091-#define GLX_CONTEXT_MINOR_VERSION_ARB           0x2092-#define GLX_CONTEXT_FLAGS_ARB                   0x2094--/* Bits for WGL_CONTEXT_FLAGS_ARB */-#define GLX_CONTEXT_DEBUG_BIT_ARB               0x0001-#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB  0x0002--/* Prototype for glXCreateContextAttribs */-typedef GLXContext (*PFNGLXCREATECONTEXTATTRIBSARBPROC)( Display *display, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list);--#endif /*GLX_ARB_create_context*/---#ifndef GLX_ARB_create_context_profile--/* Tokens for glXCreateContextAttribsARB attributes */-#define GLX_CONTEXT_PROFILE_MASK_ARB            0x9126--/* BIts for GLX_CONTEXT_PROFILE_MASK_ARB */-#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB        0x00000001-#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002--#endif /*GLX_ARB_create_context_profile*/---#ifndef GL_VERSION_3_0--typedef const GLubyte * (APIENTRY *PFNGLGETSTRINGIPROC) (GLenum, GLuint);--#endif /*GL_VERSION_3_0*/----//========================================================================-// Global variables (GLFW internals)-//========================================================================--//-------------------------------------------------------------------------// Window structure-//-------------------------------------------------------------------------typedef struct _GLFWwin_struct _GLFWwin;--struct _GLFWwin_struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // User callback functions-    GLFWwindowsizefun    windowSizeCallback;-    GLFWwindowclosefun   windowCloseCallback;-    GLFWwindowrefreshfun windowRefreshCallback;-    GLFWmousebuttonfun   mouseButtonCallback;-    GLFWmouseposfun      mousePosCallback;-    GLFWmousewheelfun    mouseWheelCallback;-    GLFWkeyfun           keyCallback;-    GLFWcharfun          charCallback;--    // User selected window settings-    int       fullscreen;      // Fullscreen flag-    int       mouseLock;       // Mouse-lock flag-    int       autoPollEvents;  // Auto polling flag-    int       sysKeysDisabled; // System keys disabled flag-    int       windowNoResize;  // Resize- and maximize gadgets disabled flag-    int       refreshRate;     // Vertical monitor refresh rate--    // Window status & parameters-    int       opened;          // Flag telling if window is opened or not-    int       active;          // Application active flag-    int       iconified;       // Window iconified flag-    int       width, height;   // Window width and heigth-    int       accelerated;     // GL_TRUE if window is HW accelerated--    // Framebuffer attributes-    int       redBits;-    int       greenBits;-    int       blueBits;-    int       alphaBits;-    int       depthBits;-    int       stencilBits;-    int       accumRedBits;-    int       accumGreenBits;-    int       accumBlueBits;-    int       accumAlphaBits;-    int       auxBuffers;-    int       stereo;-    int       samples;--    // OpenGL extensions and context attributes-    int       has_GL_SGIS_generate_mipmap;-    int       has_GL_ARB_texture_non_power_of_two;-    int       glMajor, glMinor, glRevision;-    int       glForward, glDebug, glProfile;--    PFNGLGETSTRINGIPROC GetStringi;---// ========= PLATFORM SPECIFIC PART ======================================--    // Platform specific window resources-    Colormap      colormap;          // Window colormap-    Window        window;            // Window-    Window        root;              // Root window for screen-    int           screen;            // Screen ID-    XVisualInfo  *visual;            // Visual for selected GLXFBConfig-    GLXFBConfigID fbconfigID;        // ID of selected GLXFBConfig-    GLXContext    context;           // OpenGL rendering context-    Atom          wmDeleteWindow;    // WM_DELETE_WINDOW atom-    Atom          wmPing;            // _NET_WM_PING atom-    Atom          wmState;           // _NET_WM_STATE atom-    Atom          wmStateFullscreen; // _NET_WM_STATE_FULLSCREEN atom-    Atom          wmActiveWindow;    // _NET_ACTIVE_WINDOW atom-    Cursor        cursor;            // Invisible cursor for hidden cursor--    // GLX extensions-    PFNGLXSWAPINTERVALSGIPROC             SwapIntervalSGI;-    PFNGLXGETFBCONFIGATTRIBSGIXPROC       GetFBConfigAttribSGIX;-    PFNGLXCHOOSEFBCONFIGSGIXPROC          ChooseFBConfigSGIX;-    PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC CreateContextWithConfigSGIX;-    PFNGLXGETVISUALFROMFBCONFIGSGIXPROC   GetVisualFromFBConfigSGIX;-    PFNGLXCREATECONTEXTATTRIBSARBPROC     CreateContextAttribsARB;-    GLboolean   has_GLX_SGIX_fbconfig;-    GLboolean   has_GLX_SGI_swap_control;-    GLboolean   has_GLX_ARB_multisample;-    GLboolean   has_GLX_ARB_create_context;-    GLboolean   has_GLX_ARB_create_context_profile;--    // Various platform specific internal variables-    GLboolean   hasEWMH;          // True if window manager supports EWMH-    GLboolean   overrideRedirect; // True if window is OverrideRedirect-    GLboolean   keyboardGrabbed;  // True if keyboard is currently grabbed-    GLboolean   pointerGrabbed;   // True if pointer is currently grabbed-    GLboolean   pointerHidden;    // True if pointer is currently hidden--    // Screensaver data-    struct {-        int     changed;-        int     timeout;-        int     interval;-        int     blanking;-        int     exposure;-    } Saver;--    // Fullscreen data-    struct {-        int     modeChanged;-#if defined( _GLFW_HAS_XF86VIDMODE )-        XF86VidModeModeInfo oldMode;-#endif-#if defined( _GLFW_HAS_XRANDR )-        SizeID   oldSizeID;-        int      oldWidth;-        int      oldHeight;-        Rotation oldRotation;-#endif-    } FS;-};--GLFWGLOBAL _GLFWwin _glfwWin;---//-------------------------------------------------------------------------// User input status (most of this should go in _GLFWwin)-//-------------------------------------------------------------------------GLFWGLOBAL struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // Mouse status-    int  MousePosX, MousePosY;-    int  WheelPos;-    char MouseButton[ GLFW_MOUSE_BUTTON_LAST+1 ];--    // Keyboard status-    char Key[ GLFW_KEY_LAST+1 ];-    int  LastChar;--    // User selected settings-    int  StickyKeys;-    int  StickyMouseButtons;-    int  KeyRepeat;---// ========= PLATFORM SPECIFIC PART ======================================--    // Platform specific internal variables-    int  MouseMoved, CursorPosX, CursorPosY;--} _glfwInput;---//-------------------------------------------------------------------------// Library global data-//-------------------------------------------------------------------------GLFWGLOBAL struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // Window opening hints-    _GLFWhints      hints;--// ========= PLATFORM SPECIFIC PART ======================================--    Display        *display;--    // Server-side GLX version-    int             glxMajor, glxMinor;--    struct {-        int         available;-        int         eventBase;-        int         errorBase;-    } XF86VidMode;--    struct {-        int         available;-        int         eventBase;-        int         errorBase;-    } XRandR;--    // Timer data-    struct {-        double      resolution;-        long long   t0;-    } Timer;--#if defined(_GLFW_HAS_DLOPEN)-    struct {-        void       *libGL;  // dlopen handle for libGL.so-    } Libs;-#endif-} _glfwLibrary;---//-------------------------------------------------------------------------// Thread record (one for each thread)-//-------------------------------------------------------------------------typedef struct _GLFWthread_struct _GLFWthread;--struct _GLFWthread_struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // Pointer to previous and next threads in linked list-    _GLFWthread   *Previous, *Next;--    // GLFW user side thread information-    GLFWthread    ID;-    GLFWthreadfun Function;--// ========= PLATFORM SPECIFIC PART ======================================--    // System side thread information-#ifdef _GLFW_HAS_PTHREAD-    pthread_t     PosixID;-#endif--};---//-------------------------------------------------------------------------// General thread information-//-------------------------------------------------------------------------GLFWGLOBAL struct {--// ========= PLATFORM INDEPENDENT MANDATORY PART =========================--    // Next thread ID to use (increments for every created thread)-    GLFWthread       NextID;--    // First thread in linked list (always the main thread)-    _GLFWthread      First;--// ========= PLATFORM SPECIFIC PART ======================================--    // Critical section lock-#ifdef _GLFW_HAS_PTHREAD-    pthread_mutex_t  CriticalSection;-#endif--} _glfwThrd;---//-------------------------------------------------------------------------// Joystick information & state-//-------------------------------------------------------------------------GLFWGLOBAL struct {-    int           Present;-    int           fd;-    int           NumAxes;-    int           NumButtons;-    float         *Axis;-    unsigned char *Button;-} _glfwJoy[ GLFW_JOYSTICK_LAST + 1 ];---//========================================================================-// Macros for encapsulating critical code sections (i.e. making parts-// of GLFW thread safe)-//========================================================================--// Thread list management-#ifdef _GLFW_HAS_PTHREAD- #define ENTER_THREAD_CRITICAL_SECTION \-         pthread_mutex_lock( &_glfwThrd.CriticalSection );- #define LEAVE_THREAD_CRITICAL_SECTION \-         pthread_mutex_unlock( &_glfwThrd.CriticalSection );-#else- #define ENTER_THREAD_CRITICAL_SECTION- #define LEAVE_THREAD_CRITICAL_SECTION-#endif---//========================================================================-// Prototypes for platform specific internal functions-//========================================================================--// Time-void _glfwInitTimer( void );--// Fullscreen support-int  _glfwGetClosestVideoMode( int screen, int *width, int *height, int *rate );-void _glfwSetVideoModeMODE( int screen, int mode, int rate );-void _glfwSetVideoMode( int screen, int *width, int *height, int *rate );-void _glfwRestoreVideoMode( void );--// Joystick input-void _glfwInitJoysticks( void );-void _glfwTerminateJoysticks( void );--// Unicode support-long _glfwKeySym2Unicode( KeySym keysym );---#endif // _platform_h_
− glfw/lib/x11/x11_enable.c 
@@ -1,64 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    X11 (Unix)-// API version: 2.7-// WWW:         http://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"---//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Enable system keys-//========================================================================--void _glfwPlatformEnableSystemKeys( void )-{-    if( _glfwWin.keyboardGrabbed )-    {-        XUngrabKeyboard( _glfwLibrary.display, CurrentTime );-        _glfwWin.keyboardGrabbed = GL_FALSE;-    }-}--//========================================================================-// Disable system keys-//========================================================================--void _glfwPlatformDisableSystemKeys( void )-{-    if( XGrabKeyboard( _glfwLibrary.display, _glfwWin.window, True,-                        GrabModeAsync, GrabModeAsync, CurrentTime ) ==-        GrabSuccess )-    {-        _glfwWin.keyboardGrabbed = GL_TRUE;-    }-}-
− glfw/lib/x11/x11_fullscreen.c 
@@ -1,569 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    X11/GLX-// API version: 2.7-// WWW:         http://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>---//************************************************************************-//****                  GLFW internal functions                       ****-//************************************************************************--//========================================================================-// Convert BPP to RGB bits (based on "best guess")-//========================================================================--static void BPP2RGB( int bpp, int *r, int *g, int *b )-{-    int delta;--    // Special case: BPP = 32 (I don't think this is necessary for X11??)-    if( bpp == 32 )-        bpp = 24;--    // Convert "bits per pixel" to red, green & blue sizes-    *r = *g = *b = bpp / 3;-    delta = bpp - (*r * 3);-    if( delta >= 1 )-    {-        *g = *g + 1;-    }-    if( delta == 2 )-    {-        *r = *r + 1;-    }-}---//========================================================================-// Finds the video mode closest in size to the specified desired size-//========================================================================--int _glfwGetClosestVideoMode( int screen, int *width, int *height, int *rate )-{-#if defined( _GLFW_HAS_XRANDR )-    int i, match, bestmatch;-    int sizecount, bestsize;-    int ratecount, bestrate;-    short *ratelist;-    XRRScreenConfiguration *sc;-    XRRScreenSize *sizelist;--    if( _glfwLibrary.XRandR.available )-    {-        sc = XRRGetScreenInfo( _glfwLibrary.display,-                               RootWindow( _glfwLibrary.display, screen ) );--        sizelist = XRRConfigSizes( sc, &sizecount );--        // Find the best matching mode-        bestsize  = -1;-        bestmatch = INT_MAX;-        for( i = 0; i < sizecount; i++ )-        {-            match = (*width - sizelist[i].width) *-                    (*width - sizelist[i].width) +-                    (*height - sizelist[i].height) *-                    (*height - sizelist[i].height);-            if( match < bestmatch )-            {-                bestmatch = match;-                bestsize  = i;-            }-        }--        if( bestsize != -1 )-        {-            // Report width & height of best matching mode-            *width = sizelist[bestsize].width;-            *height = sizelist[bestsize].height;--            if( *rate > 0 )-            {-                ratelist = XRRConfigRates( sc, bestsize, &ratecount );--                bestrate = -1;-                bestmatch = INT_MAX;-                for( i = 0; i < ratecount; i++ )-                {-                    match = abs( ratelist[i] - *rate );-                    if( match < bestmatch )-                    {-                        bestmatch = match;-                        bestrate = ratelist[i];-                    }-                }--                if( bestrate != -1 )-                {-                    *rate = bestrate;-                }-            }-        }--            // Free modelist-        XRRFreeScreenConfigInfo( sc );--        if( bestsize != -1 )-        {-            return bestsize;-        }-    }-#elif defined( _GLFW_HAS_XF86VIDMODE )-    XF86VidModeModeInfo **modelist;-    int modecount, i, bestmode, bestmatch, match;--    // Use the XF86VidMode extension to control video resolution-    if( _glfwLibrary.XF86VidMode.available )-    {-        // Get a list of all available display modes-        XF86VidModeGetAllModeLines( _glfwLibrary.display, screen,-                                    &modecount, &modelist );--        // Find the best matching mode-        bestmode  = -1;-        bestmatch = INT_MAX;-        for( i = 0; i < modecount; i++ )-        {-            match = (*width - modelist[i]->hdisplay) *-                    (*width - modelist[i]->hdisplay) +-                    (*height - modelist[i]->vdisplay) *-                    (*height - modelist[i]->vdisplay);-            if( match < bestmatch )-            {-                bestmatch = match;-                bestmode  = i;-            }-        }--        if( bestmode != -1 )-        {-            // Report width & height of best matching mode-            *width = modelist[ bestmode ]->hdisplay;-            *height = modelist[ bestmode ]->vdisplay;-        }--        // Free modelist-        XFree( modelist );--        if( bestmode != -1 )-        {-            return bestmode;-        }-    }-#endif--    // Default: Simply use the screen resolution-    *width = DisplayWidth( _glfwLibrary.display, screen );-    *height = DisplayHeight( _glfwLibrary.display, screen );--    return 0;-}---//========================================================================-// Change the current video mode-//========================================================================--void _glfwSetVideoModeMODE( int screen, int mode, int rate )-{-#if defined( _GLFW_HAS_XRANDR )-    XRRScreenConfiguration *sc;-    Window root;--    if( _glfwLibrary.XRandR.available )-    {-        root = RootWindow( _glfwLibrary.display, screen );-        sc   = XRRGetScreenInfo( _glfwLibrary.display, root );--        // Remember old size and flag that we have changed the mode-        if( !_glfwWin.FS.modeChanged )-        {-            _glfwWin.FS.oldSizeID = XRRConfigCurrentConfiguration( sc, &_glfwWin.FS.oldRotation );-            _glfwWin.FS.oldWidth  = DisplayWidth( _glfwLibrary.display, screen );-            _glfwWin.FS.oldHeight = DisplayHeight( _glfwLibrary.display, screen );--            _glfwWin.FS.modeChanged = GL_TRUE;-        }--        if( rate > 0 )-        {-            // Set desired configuration-            XRRSetScreenConfigAndRate( _glfwLibrary.display,-                                       sc,-                                       root,-                                       mode,-                                       RR_Rotate_0,-                                       (short) rate,-                                       CurrentTime );-        }-        else-        {-            // Set desired configuration-            XRRSetScreenConfig( _glfwLibrary.display,-                                sc,-                                root,-                                mode,-                                RR_Rotate_0,-                                CurrentTime );-        }--        XRRFreeScreenConfigInfo( sc );-    }-#elif defined( _GLFW_HAS_XF86VIDMODE )-    XF86VidModeModeInfo **modelist;-    int modecount;--    // Use the XF86VidMode extension to control video resolution-    if( _glfwLibrary.XF86VidMode.available )-    {-        // Get a list of all available display modes-        XF86VidModeGetAllModeLines( _glfwLibrary.display, screen,-                                    &modecount, &modelist );--        // Unlock mode switch if necessary-        if( _glfwWin.FS.modeChanged )-        {-            XF86VidModeLockModeSwitch( _glfwLibrary.display, screen, 0 );-        }--        // Change the video mode to the desired mode-        XF86VidModeSwitchToMode(  _glfwLibrary.display, screen,-                                  modelist[ mode ] );--        // Set viewport to upper left corner (where our window will be)-        XF86VidModeSetViewPort( _glfwLibrary.display, screen, 0, 0 );--        // Lock mode switch-        XF86VidModeLockModeSwitch( _glfwLibrary.display, screen, 1 );--        // Remember old mode and flag that we have changed the mode-        if( !_glfwWin.FS.modeChanged )-        {-            _glfwWin.FS.oldMode = *modelist[ 0 ];-            _glfwWin.FS.modeChanged = GL_TRUE;-        }--        // Free mode list-        XFree( modelist );-    }-#endif-}---//========================================================================-// Change the current video mode-//========================================================================--void _glfwSetVideoMode( int screen, int *width, int *height, int *rate )-{-    int     bestmode;--    // Find a best match mode-    bestmode = _glfwGetClosestVideoMode( screen, width, height, rate );--    // Change mode-    _glfwSetVideoModeMODE( screen, bestmode, *rate );-}---//========================================================================-// Restore the previously saved (original) video mode-//========================================================================--void _glfwRestoreVideoMode( void )-{-    if( _glfwWin.FS.modeChanged )-    {-#if defined( _GLFW_HAS_XRANDR )-        if( _glfwLibrary.XRandR.available )-        {-            XRRScreenConfiguration *sc;--            sc = XRRGetScreenInfo( _glfwLibrary.display, _glfwWin.root );--            XRRSetScreenConfig( _glfwLibrary.display,-                                sc,-                                _glfwWin.root,-                                _glfwWin.FS.oldSizeID,-                                _glfwWin.FS.oldRotation,-                                CurrentTime );--            XRRFreeScreenConfigInfo( sc );-        }-#elif defined( _GLFW_HAS_XF86VIDMODE )-        if( _glfwLibrary.XF86VidMode.available )-        {-            // Unlock mode switch-            XF86VidModeLockModeSwitch( _glfwLibrary.display, _glfwWin.screen, 0 );--            // Change the video mode back to the old mode-            XF86VidModeSwitchToMode( _glfwLibrary.display,-                                    _glfwWin.screen,-                                    &_glfwWin.FS.oldMode );-        }-#endif-        _glfwWin.FS.modeChanged = GL_FALSE;-    }-}----//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--struct _glfwResolution-{-    int width;-    int height;-};--//========================================================================-// List available video modes-//========================================================================--int _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount )-{-    int count, k, l, r, g, b, rgba, gl;-    int depth, screen;-    Display *dpy;-    XVisualInfo *vislist, dummy;-    int viscount, rgbcount, rescount;-    int *rgbarray;-    struct _glfwResolution *resarray;-#if defined( _GLFW_HAS_XRANDR )-    XRRScreenConfiguration *sc;-    XRRScreenSize *sizelist;-    int sizecount;-#elif defined( _GLFW_HAS_XF86VIDMODE )-    XF86VidModeModeInfo **modelist;-    int modecount, width, height;-#endif--    // Get display and screen-    dpy = _glfwLibrary.display;-    screen = DefaultScreen( dpy );--    // Get list of visuals-    vislist = XGetVisualInfo( dpy, 0, &dummy, &viscount );-    if( vislist == NULL )-    {-        return 0;-    }--    rgbarray = (int*) malloc( sizeof(int) * viscount );-    rgbcount = 0;--    // Build RGB array-    for( k = 0; k < viscount; k++ )-    {-        // Does the visual support OpenGL & true color?-        glXGetConfig( dpy, &vislist[k], GLX_USE_GL, &gl );-        glXGetConfig( dpy, &vislist[k], GLX_RGBA, &rgba );-        if( gl && rgba )-        {-            // Get color depth for this visual-            depth = vislist[k].depth;--            // Convert to RGB-            BPP2RGB( depth, &r, &g, &b );-            depth = (r<<16) | (g<<8) | b;--            // Is this mode unique?-            for( l = 0; l < rgbcount; l++ )-            {-                if( depth == rgbarray[ l ] )-                {-                    break;-                }-            }-            if( l >= rgbcount )-            {-                rgbarray[ rgbcount ] = depth;-                rgbcount++;-            }-        }-    }--    rescount = 0;-    resarray = NULL;--    // Build resolution array-#if defined( _GLFW_HAS_XRANDR )-    if( _glfwLibrary.XRandR.available )-    {-        sc = XRRGetScreenInfo( dpy, RootWindow( dpy, screen ) );-        sizelist = XRRConfigSizes( sc, &sizecount );--        resarray = (struct _glfwResolution*) malloc( sizeof(struct _glfwResolution) * sizecount );--        for( k = 0; k < sizecount; k++ )-        {-            resarray[ rescount ].width = sizelist[ k ].width;-            resarray[ rescount ].height = sizelist[ k ].height;-            rescount++;-        }--        XRRFreeScreenConfigInfo( sc );-    }-#elif defined( _GLFW_HAS_XF86VIDMODE )-    if( _glfwLibrary.XF86VidMode.available )-    {-        XF86VidModeGetAllModeLines( dpy, screen, &modecount, &modelist );--        resarray = (struct _glfwResolution*) malloc( sizeof(struct _glfwResolution) * modecount );--        for( k = 0; k < modecount; k++ )-        {-            width  = modelist[ k ]->hdisplay;-            height = modelist[ k ]->vdisplay;--            // Is this mode unique?-            for( l = 0; l < rescount; l++ )-            {-                if( width == resarray[ l ].width && height == resarray[ l ].height )-                {-                    break;-                }-            }--            if( l >= rescount )-            {-                resarray[ rescount ].width = width;-                resarray[ rescount ].height = height;-                rescount++;-            }-        }--        XFree( modelist );-    }-#endif--    if( !resarray )-    {-        rescount = 1;-        resarray = (struct _glfwResolution*) malloc( sizeof(struct _glfwResolution) * rescount );--        resarray[ 0 ].width = DisplayWidth( dpy, screen );-        resarray[ 0 ].height = DisplayHeight( dpy, screen );-    }--    // Build permutations of colors and resolutions-    count = 0;-    for( k = 0; k < rgbcount && count < maxcount; k++ )-    {-        for( l = 0; l < rescount && count < maxcount; l++ )-        {-            list[count].Width     = resarray[ l ].width;-            list[count].Height    = resarray[ l ].height;-            list[count].RedBits   = (rgbarray[ k ] >> 16) & 255;-            list[count].GreenBits = (rgbarray[ k ] >> 8) & 255;-            list[count].BlueBits  = rgbarray[ k ] & 255;-            count++;-        }-    }--    // Free visuals list-    XFree( vislist );--    free( resarray );-    free( rgbarray );--    return count;-}---//========================================================================-// Get the desktop video mode-//========================================================================--void _glfwPlatformGetDesktopMode( GLFWvidmode *mode )-{-    Display *dpy;-    int     bpp, screen;-#if defined( _GLFW_HAS_XF86VIDMODE )-    XF86VidModeModeInfo **modelist;-    int     modecount;-#endif--    // Get display and screen-    dpy = _glfwLibrary.display;-    screen = DefaultScreen( dpy );--    // Get display depth-    bpp = DefaultDepth( dpy, screen );--    // Convert BPP to RGB bits-    BPP2RGB( bpp, &mode->RedBits, &mode->GreenBits, &mode->BlueBits );--#if defined( _GLFW_HAS_XRANDR )-    if( _glfwLibrary.XRandR.available )-    {-        if( _glfwWin.FS.modeChanged )-        {-            mode->Width  = _glfwWin.FS.oldWidth;-            mode->Height = _glfwWin.FS.oldHeight;-            return;-        }-    }-#elif defined( _GLFW_HAS_XF86VIDMODE )-    if( _glfwLibrary.XF86VidMode.available )-    {-        if( _glfwWin.FS.modeChanged )-        {-            // The old (desktop) mode is stored in _glfwWin.FS.oldMode-            mode->Width  = _glfwWin.FS.oldMode.hdisplay;-            mode->Height = _glfwWin.FS.oldMode.vdisplay;-        }-        else-        {-            // Use the XF86VidMode extension to get list of video modes-            XF86VidModeGetAllModeLines( dpy, screen, &modecount,-                                        &modelist );--            // The first mode in the list is the current (desktio) mode-            mode->Width  = modelist[ 0 ]->hdisplay;-            mode->Height = modelist[ 0 ]->vdisplay;--            // Free list-            XFree( modelist );-        }--        return;-    }-#endif--    // Get current display width and height-    mode->Width  = DisplayWidth( dpy, screen );-    mode->Height = DisplayHeight( dpy, screen );-}-
− glfw/lib/x11/x11_glext.c 
@@ -1,89 +0,0 @@-//==================-// GLFW - An OpenGL framework-// Platform:    X11/GLX-// API version: 2.7-// WWW:         http://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"---void (*glXGetProcAddress(const GLubyte *procName))();-void (*glXGetProcAddressARB(const GLubyte *procName))();-void (*glXGetProcAddressEXT(const GLubyte *procName))();--// 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(_glfwLibrary.Libs.libGL,x)-#else-#define _glfw_glXGetProcAddress(x) NULL-#endif---//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Check if an OpenGL extension is available at runtime-//========================================================================--int _glfwPlatformExtensionSupported( const char *extension )-{-    const GLubyte *extensions;--    // Get list of GLX extensions-    extensions = (const GLubyte*) glXQueryExtensionsString( _glfwLibrary.display,-                                                            _glfwWin.screen );-    if( extensions != NULL )-    {-        if( _glfwStringInExtensionString( extension, extensions ) )-        {-            return GL_TRUE;-        }-    }--    return GL_FALSE;-}---//========================================================================-// Get the function pointer to an OpenGL function-//========================================================================--void * _glfwPlatformGetProcAddress( const char *procname )-{-    return (void *) _glfw_glXGetProcAddress( (const GLubyte *) procname );-}-
− glfw/lib/x11/x11_init.c 
@@ -1,286 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    X11/GLX-// API version: 2.7-// WWW:         http://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 internal functions                       ****-//************************************************************************--//========================================================================-// Initialize GLFW thread package-//========================================================================--static void initThreads( void )-{-    // Initialize critical section handle-#ifdef _GLFW_HAS_PTHREAD-    (void) pthread_mutex_init( &_glfwThrd.CriticalSection, NULL );-#endif--    // The first thread (the main thread) has ID 0-    _glfwThrd.NextID = 0;--    // Fill out information about the main thread (this thread)-    _glfwThrd.First.ID       = _glfwThrd.NextID++;-    _glfwThrd.First.Function = NULL;-    _glfwThrd.First.Previous = NULL;-    _glfwThrd.First.Next     = NULL;-#ifdef _GLFW_HAS_PTHREAD-    _glfwThrd.First.PosixID  = pthread_self();-#endif-}---//========================================================================-// Terminate GLFW thread package-//========================================================================--static void terminateThreads( void )-{-#ifdef _GLFW_HAS_PTHREAD--    _GLFWthread *t, *t_next;--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Kill all threads (NOTE: THE USER SHOULD WAIT FOR ALL THREADS TO-    // DIE, _BEFORE_ CALLING glfwTerminate()!!!)-    t = _glfwThrd.First.Next;-    while( t != NULL )-    {-        // Get pointer to next thread-        t_next = t->Next;--        // Simply murder the process, no mercy!-        pthread_kill( t->PosixID, SIGKILL );--        // Free memory allocated for this thread-        free( (void *) t );--        // Select next thread in list-        t = t_next;-    }--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Delete critical section handle-    pthread_mutex_destroy( &_glfwThrd.CriticalSection );--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Dynamically load libraries-//========================================================================--static void initLibraries( 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-    };--    _glfwLibrary.Libs.libGL = NULL;-    for( i = 0; !libGL_names[ i ] != NULL; i ++ )-    {-        _glfwLibrary.Libs.libGL = dlopen( libGL_names[ i ],-                                          RTLD_LAZY | RTLD_GLOBAL );-        if( _glfwLibrary.Libs.libGL )-            break;-    }-#endif-}---//========================================================================-// Terminate GLFW when exiting application-//========================================================================--static void glfw_atexit( void )-{-    glfwTerminate();-}---//========================================================================-// Initialize X11 display-//========================================================================--static int initDisplay( void )-{-    // Open display-    _glfwLibrary.display = XOpenDisplay( 0 );-    if( !_glfwLibrary.display )-    {-        fprintf(stderr, "Failed to open X display\n");-        return GL_FALSE;-    }--    // Check for XF86VidMode extension-#ifdef _GLFW_HAS_XF86VIDMODE-    _glfwLibrary.XF86VidMode.available =-        XF86VidModeQueryExtension( _glfwLibrary.display,-                                   &_glfwLibrary.XF86VidMode.eventBase,-                                   &_glfwLibrary.XF86VidMode.errorBase);-#else-    _glfwLibrary.XF86VidMode.available = 0;-#endif--    // Check for XRandR extension-#ifdef _GLFW_HAS_XRANDR-    _glfwLibrary.XRandR.available =-        XRRQueryExtension( _glfwLibrary.display,-                           &_glfwLibrary.XRandR.eventBase,-                           &_glfwLibrary.XRandR.errorBase );-#else-    _glfwLibrary.XRandR.available = 0;-#endif--    // Fullscreen & screen saver settings-    // Check if GLX is supported on this display-    if( !glXQueryExtension( _glfwLibrary.display, NULL, NULL ) )-    {-        fprintf(stderr, "GLX not supported\n");-        return GL_FALSE;-    }--    // Retrieve GLX version-    if( !glXQueryVersion( _glfwLibrary.display,-                          &_glfwLibrary.glxMajor,-                          &_glfwLibrary.glxMinor ) )-    {-        fprintf(stderr, "Unable to query GLX version\n");-        return GL_FALSE;-    }--    return GL_TRUE;-}---//========================================================================-// Terminate X11 display-//========================================================================--static void terminateDisplay( void )-{-    // Open display-    if( _glfwLibrary.display )-    {-        XCloseDisplay( _glfwLibrary.display );-        _glfwLibrary.display = NULL;-    }-}---//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Initialize various GLFW state-//========================================================================--int _glfwPlatformInit( void )-{-    // Initialize display-    if( !initDisplay() )-    {-        return GL_FALSE;-    }--    // Initialize thread package-    initThreads();--    // Try to load libGL.so if necessary-    initLibraries();--    // Install atexit() routine-    atexit( glfw_atexit );--    // Initialize joysticks-    _glfwInitJoysticks();--    // Start the timer-    _glfwInitTimer();--    return GL_TRUE;-}---//========================================================================-// Close window and kill all threads-//========================================================================--int _glfwPlatformTerminate( void )-{-#ifdef _GLFW_HAS_PTHREAD-    // Only the main thread is allowed to do this...-    if( pthread_self() != _glfwThrd.First.PosixID )-    {-        return GL_FALSE;-    }-#endif // _GLFW_HAS_PTHREAD--    // Close OpenGL window-    glfwCloseWindow();--    // Kill thread package-    terminateThreads();--    // Terminate display-    terminateDisplay();--    // Terminate joysticks-    _glfwTerminateJoysticks();--    // Unload libGL.so if necessary-#ifdef _GLFW_DLOPEN_LIBGL-    if( _glfwLibrary.Libs.libGL != NULL )-    {-        dlclose( _glfwLibrary.Libs.libGL );-        _glfwLibrary.Libs.libGL = NULL;-    }-#endif--    return GL_TRUE;-}-
− glfw/lib/x11/x11_joystick.c 
@@ -1,367 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    X11/GLX-// API version: 2.7-// WWW:         http://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"---//========================================================================-// Note: Only Linux joystick input is supported at the moment. Other-// systems will behave as if there are no joysticks connected.-//========================================================================---//************************************************************************-//****                  GLFW internal functions                       ****-//************************************************************************--#ifdef _GLFW_USE_LINUX_JOYSTICKS--//-------------------------------------------------------------------------// Here are the Linux joystick driver v1.x interface definitions that we-// use (we do not want to rely on <linux/joystick.h>):-//--------------------------------------------------------------------------#include <sys/ioctl.h>-#include <fcntl.h>-#include <errno.h>--// Joystick event types-#define JS_EVENT_BUTTON     0x01    /* button pressed/released */-#define JS_EVENT_AXIS       0x02    /* joystick moved */-#define JS_EVENT_INIT       0x80    /* initial state of device */--// Joystick event structure-struct js_event {-    unsigned int  time;    /* (u32) event timestamp in milliseconds */-    signed short  value;   /* (s16) value */-    unsigned char type;    /* (u8)  event type */-    unsigned char number;  /* (u8)  axis/button number */-};--// Joystick IOCTL commands-#define JSIOCGVERSION  _IOR('j', 0x01, int)   /* get driver version (u32) */-#define JSIOCGAXES     _IOR('j', 0x11, char)  /* get number of axes (u8) */-#define JSIOCGBUTTONS  _IOR('j', 0x12, char)  /* get number of buttons (u8) */--#endif // _GLFW_USE_LINUX_JOYSTICKS---//========================================================================-// Initialize joystick interface-//========================================================================--void _glfwInitJoysticks( void )-{-#ifdef _GLFW_USE_LINUX_JOYSTICKS-    int  k, n, fd, joy_count;-    char *joy_base_name, joy_dev_name[ 20 ];-    int  driver_version = 0x000800;-    char ret_data;-#endif // _GLFW_USE_LINUX_JOYSTICKS-    int  i;--    // Start by saying that there are no sticks-    for( i = 0; i <= GLFW_JOYSTICK_LAST; ++ i )-    {-        _glfwJoy[ i ].Present = GL_FALSE;-    }--#ifdef _GLFW_USE_LINUX_JOYSTICKS--    // Try to open joysticks (nonblocking)-    joy_count = 0;-    for( k = 0; k <= 1 && joy_count <= GLFW_JOYSTICK_LAST; ++ k )-    {-        // Pick joystick base name-        switch( k )-        {-        case 0:-            joy_base_name = "/dev/input/js";  // USB sticks-            break;-        case 1:-            joy_base_name = "/dev/js";        // "Legacy" sticks-            break;-        default:-            continue;                         // (should never happen)-        }--        // Try to open a few of these sticks-        for( i = 0; i <= 50 && joy_count <= GLFW_JOYSTICK_LAST; ++ i )-        {-            sprintf( joy_dev_name, "%s%d", joy_base_name, i );-            fd = open( joy_dev_name, O_NONBLOCK );-            if( fd != -1 )-            {-                // Remember fd-                _glfwJoy[ joy_count ].fd = fd;--                // Check that the joystick driver version is 1.0+-                ioctl( fd, JSIOCGVERSION, &driver_version );-                if( driver_version < 0x010000 )-                {-                    // It's an old 0.x interface (we don't support it)-                    close( fd );-                    continue;-                }--                // Get number of joystick axes-                ioctl( fd, JSIOCGAXES, &ret_data );-                _glfwJoy[ joy_count ].NumAxes = (int) ret_data;--                // Get number of joystick buttons-                ioctl( fd, JSIOCGBUTTONS, &ret_data );-                _glfwJoy[ joy_count ].NumButtons = (int) ret_data;--                // Allocate memory for joystick state-                _glfwJoy[ joy_count ].Axis =-                    (float *) malloc( sizeof(float) *-                                      _glfwJoy[ joy_count ].NumAxes );-                if( _glfwJoy[ joy_count ].Axis == NULL )-                {-                    close( fd );-                    continue;-                }-                _glfwJoy[ joy_count ].Button =-                    (unsigned char *) malloc( sizeof(char) *-                                     _glfwJoy[ joy_count ].NumButtons );-                if( _glfwJoy[ joy_count ].Button == NULL )-                {-                    free( _glfwJoy[ joy_count ].Axis );-                    close( fd );-                    continue;-                }--                // Clear joystick state-                for( n = 0; n < _glfwJoy[ joy_count ].NumAxes; ++ n )-                {-                    _glfwJoy[ joy_count ].Axis[ n ] = 0.0f;-                }-                for( n = 0; n < _glfwJoy[ joy_count ].NumButtons; ++ n )-                {-                    _glfwJoy[ joy_count ].Button[ n ] = GLFW_RELEASE;-                }--                // The joystick is supported and connected-                _glfwJoy[ joy_count ].Present = GL_TRUE;-                joy_count ++;-            }-        }-    }--#endif // _GLFW_USE_LINUX_JOYSTICKS--}---//========================================================================-// Close all opened joystick handles-//========================================================================--void _glfwTerminateJoysticks( void )-{--#ifdef _GLFW_USE_LINUX_JOYSTICKS--    int i;--    // Close any opened joysticks-    for( i = 0; i <= GLFW_JOYSTICK_LAST; ++ i )-    {-        if( _glfwJoy[ i ].Present )-        {-            close( _glfwJoy[ i ].fd );-            free( _glfwJoy[ i ].Axis );-            free( _glfwJoy[ i ].Button );-            _glfwJoy[ i ].Present = GL_FALSE;-        }-    }--#endif // _GLFW_USE_LINUX_JOYSTICKS--}---//========================================================================-// Empty joystick event queue-//========================================================================--static void pollJoystickEvents( void )-{--#ifdef _GLFW_USE_LINUX_JOYSTICKS--    struct js_event e;-    int i;--    // Get joystick events for all GLFW joysticks-    for( i = 0; i <= GLFW_JOYSTICK_LAST; ++ i )-    {-        // Is the stick present?-        if( _glfwJoy[ i ].Present )-        {-            // Read all queued events (non-blocking)-            while( read(_glfwJoy[i].fd, &e, sizeof(struct js_event)) > 0 )-            {-                // We don't care if it's an init event or not-                e.type &= ~JS_EVENT_INIT;--                // Check event type-                switch( e.type )-                {-                case JS_EVENT_AXIS:-                    _glfwJoy[ i ].Axis[ e.number ] = (float) e.value /-                                                             32767.0f;-                    // We need to change the sign for the Y axes, so that-                    // positive = up/forward, according to the GLFW spec.-                    if( e.number & 1 )-                    {-                        _glfwJoy[ i ].Axis[ e.number ] =-                            -_glfwJoy[ i ].Axis[ e.number ];-                    }-                    break;--                case JS_EVENT_BUTTON:-                    _glfwJoy[ i ].Button[ e.number ] =-                        e.value ? GLFW_PRESS : GLFW_RELEASE;-                    break;--                default:-                    break;-                }-            }-        }-    }--#endif // _GLFW_USE_LINUX_JOYSTICKS--}---//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Determine joystick capabilities-//========================================================================--int _glfwPlatformGetJoystickParam( int joy, int param )-{-    // Is joystick present?-    if( !_glfwJoy[ joy ].Present )-    {-        return 0;-    }--    switch( param )-    {-    case GLFW_PRESENT:-        return GL_TRUE;--    case GLFW_AXES:-        return _glfwJoy[ joy ].NumAxes;--    case GLFW_BUTTONS:-        return _glfwJoy[ joy ].NumButtons;--    default:-        break;-    }--    return 0;-}---//========================================================================-// Get joystick axis positions-//========================================================================--int _glfwPlatformGetJoystickPos( int joy, float *pos, int numaxes )-{-    int i;--    // Is joystick present?-    if( !_glfwJoy[ joy ].Present )-    {-        return 0;-    }--    // Update joystick state-    pollJoystickEvents();--    // Does the joystick support less axes than requested?-    if( _glfwJoy[ joy ].NumAxes < numaxes )-    {-        numaxes = _glfwJoy[ joy ].NumAxes;-    }--    // Copy axis positions from internal state-    for( i = 0; i < numaxes; ++ i )-    {-        pos[ i ] = _glfwJoy[ joy ].Axis[ i ];-    }--    return numaxes;-}---//========================================================================-// Get joystick button states-//========================================================================--int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons,-    int numbuttons )-{-    int i;--    // Is joystick present?-    if( !_glfwJoy[ joy ].Present )-    {-        return 0;-    }--    // Update joystick state-    pollJoystickEvents();--    // Does the joystick support less buttons than requested?-    if( _glfwJoy[ joy ].NumButtons < numbuttons )-    {-        numbuttons = _glfwJoy[ joy ].NumButtons;-    }--    // Copy button states from internal state-    for( i = 0; i < numbuttons; ++ i )-    {-        buttons[ i ] = _glfwJoy[ joy ].Button[ i ];-    }--    return numbuttons;-}-
− glfw/lib/x11/x11_keysym2unicode.c 
@@ -1,901 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    X11/GLX-// API version: 2.7-// WWW:         http://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 functions                       ****-//************************************************************************--//========================================================================-// 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;-}
− glfw/lib/x11/x11_thread.c 
@@ -1,503 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    X11/GLX-// API version: 2.7-// WWW:         http://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 internal functions                       ****-//************************************************************************--#ifdef _GLFW_HAS_PTHREAD--//========================================================================-// This is simply a "wrapper" for calling the user thread function.-//========================================================================--void * _glfwNewThread( void * arg )-{-    GLFWthreadfun threadfun;-    _GLFWthread   *t;-    pthread_t   posixID;--    // Get current thread ID-    posixID = pthread_self();--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Loop through entire list of threads to find the matching POSIX-    // thread ID-    for( t = &_glfwThrd.First; t != NULL; t = t->Next )-    {-        if( t->PosixID == posixID )-        {-            break;-        }-    }-    if( t == NULL )-    {-        LEAVE_THREAD_CRITICAL_SECTION-        return NULL;-    }--    // Get user thread function pointer-    threadfun = t->Function;--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Call the user thread function-    threadfun( arg );--    // Remove thread from thread list-    ENTER_THREAD_CRITICAL_SECTION-    _glfwRemoveThread( t );-    LEAVE_THREAD_CRITICAL_SECTION--    // When the thread function returns, the thread will die...-    return NULL;-}--#endif // _GLFW_HAS_PTHREAD----//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Create a new thread-//========================================================================--GLFWthread _glfwPlatformCreateThread( GLFWthreadfun fun, void *arg )-{-#ifdef _GLFW_HAS_PTHREAD--    GLFWthread  ID;-    _GLFWthread *t;-    int         result;--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Create a new thread information memory area-    t = (_GLFWthread *) malloc( sizeof(_GLFWthread) );-    if( t == NULL )-    {-        // Leave critical section-        LEAVE_THREAD_CRITICAL_SECTION-        return -1;-    }--    // Get a new unique thread id-    ID = _glfwThrd.NextID ++;--    // Store thread information in the thread list-    t->Function = fun;-    t->ID       = ID;--    // Create thread-    result = pthread_create(-        &t->PosixID,      // Thread handle-        NULL,             // Default thread attributes-        _glfwNewThread,   // Thread function (a wrapper function)-        (void *)arg       // Argument to thread is user argument-    );--    // Did the thread creation fail?-    if( result != 0 )-    {-        free( (void *) t );-        LEAVE_THREAD_CRITICAL_SECTION-        return -1;-    }--    // Append thread to thread list-    _glfwAppendThread( t );--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Return the GLFW thread ID-    return ID;--#else--    return -1;--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Kill a thread. NOTE: THIS IS A VERY DANGEROUS OPERATION, AND SHOULD NOT-// BE USED EXCEPT IN EXTREME SITUATIONS!-//========================================================================--void _glfwPlatformDestroyThread( GLFWthread ID )-{-#ifdef _GLFW_HAS_PTHREAD--    _GLFWthread *t;--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Get thread information pointer-    t = _glfwGetThreadPointer( ID );-    if( t == NULL )-    {-        LEAVE_THREAD_CRITICAL_SECTION-        return;-    }--    // Simply murder the process, no mercy!-    pthread_kill( t->PosixID, SIGKILL );--    // Remove thread from thread list-    _glfwRemoveThread( t );--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Wait for a thread to die-//========================================================================--int _glfwPlatformWaitThread( GLFWthread ID, int waitmode )-{-#ifdef _GLFW_HAS_PTHREAD--    pthread_t   thread;-    _GLFWthread *t;--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Get thread information pointer-    t = _glfwGetThreadPointer( ID );--    // Is the thread already dead?-    if( t == NULL )-    {-        LEAVE_THREAD_CRITICAL_SECTION-        return GL_TRUE;-    }--    // If got this far, the thread is alive => polling returns FALSE-    if( waitmode == GLFW_NOWAIT )-    {-        LEAVE_THREAD_CRITICAL_SECTION-        return GL_FALSE;-    }--    // Get thread handle-    thread = t->PosixID;--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Wait for thread to die-    (void) pthread_join( thread, NULL );--    return GL_TRUE;--#else--    return GL_TRUE;--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Return the thread ID for the current thread-//========================================================================--GLFWthread _glfwPlatformGetThreadID( void )-{-#ifdef _GLFW_HAS_PTHREAD--    _GLFWthread *t;-    GLFWthread  ID = -1;-    pthread_t   posixID;--    // Get current thread ID-    posixID = pthread_self();--    // Enter critical section-    ENTER_THREAD_CRITICAL_SECTION--    // Loop through entire list of threads to find the matching POSIX-    // thread ID-    for( t = &_glfwThrd.First; t != NULL; t = t->Next )-    {-        if( t->PosixID == posixID )-        {-            ID = t->ID;-            break;-        }-    }--    // Leave critical section-    LEAVE_THREAD_CRITICAL_SECTION--    // Return the found GLFW thread identifier-    return ID;--#else--    return 0;--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Create a mutual exclusion object-//========================================================================--GLFWmutex _glfwPlatformCreateMutex( void )-{-#ifdef _GLFW_HAS_PTHREAD--    pthread_mutex_t *mutex;--    // Allocate memory for mutex-    mutex = (pthread_mutex_t *) malloc( sizeof( pthread_mutex_t ) );-    if( !mutex )-    {-        return NULL;-    }--    // Initialise a mutex object-    (void) pthread_mutex_init( mutex, NULL );--    // Cast to GLFWmutex and return-    return (GLFWmutex) mutex;--#else--    return (GLFWmutex) 0;--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Destroy a mutual exclusion object-//========================================================================--void _glfwPlatformDestroyMutex( GLFWmutex mutex )-{-#ifdef _GLFW_HAS_PTHREAD--    // Destroy the mutex object-    pthread_mutex_destroy( (pthread_mutex_t *) mutex );--    // Free memory for mutex object-    free( (void *) mutex );--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Request access to a mutex-//========================================================================--void _glfwPlatformLockMutex( GLFWmutex mutex )-{-#ifdef _GLFW_HAS_PTHREAD--    // Wait for mutex to be released-    (void) pthread_mutex_lock( (pthread_mutex_t *) mutex );--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Release a mutex-//========================================================================--void _glfwPlatformUnlockMutex( GLFWmutex mutex )-{-#ifdef _GLFW_HAS_PTHREAD--    // Release mutex-    pthread_mutex_unlock( (pthread_mutex_t *) mutex );--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Create a new condition variable object-//========================================================================--GLFWcond _glfwPlatformCreateCond( void )-{-#ifdef _GLFW_HAS_PTHREAD--    pthread_cond_t *cond;--    // Allocate memory for condition variable-    cond = (pthread_cond_t *) malloc( sizeof(pthread_cond_t) );-    if( !cond )-    {-        return NULL;-    }--    // Initialise condition variable-    (void) pthread_cond_init( cond, NULL );--    // Cast to GLFWcond and return-    return (GLFWcond) cond;--#else--    return (GLFWcond) 0;--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Destroy a condition variable object-//========================================================================--void _glfwPlatformDestroyCond( GLFWcond cond )-{-#ifdef _GLFW_HAS_PTHREAD--    // Destroy the condition variable object-    (void) pthread_cond_destroy( (pthread_cond_t *) cond );--    // Free memory for condition variable object-    free( (void *) cond );--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Wait for a condition to be raised-//========================================================================--void _glfwPlatformWaitCond( GLFWcond cond, GLFWmutex mutex,-    double timeout )-{-#ifdef _GLFW_HAS_PTHREAD--    struct timeval  currenttime;-    struct timespec wait;-    long dt_sec, dt_usec;--    // Select infinite or timed wait-    if( timeout >= GLFW_INFINITY )-    {-        // Wait for condition (infinite wait)-        (void) pthread_cond_wait( (pthread_cond_t *) cond,-                  (pthread_mutex_t *) mutex );-    }-    else-    {-        // Set timeout time, relatvie to current time-        gettimeofday( &currenttime, NULL );-        dt_sec  = (long) timeout;-        dt_usec = (long) ((timeout - (double)dt_sec) * 1000000.0);-        wait.tv_nsec = (currenttime.tv_usec + dt_usec) * 1000L;-        if( wait.tv_nsec > 1000000000L )-        {-            wait.tv_nsec -= 1000000000L;-            dt_sec ++;-        }-        wait.tv_sec  = currenttime.tv_sec + dt_sec;--        // Wait for condition (timed wait)-        (void) pthread_cond_timedwait( (pthread_cond_t *) cond,-                   (pthread_mutex_t *) mutex, &wait );-    }--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Signal a condition to one waiting thread-//========================================================================--void _glfwPlatformSignalCond( GLFWcond cond )-{-#ifdef _GLFW_HAS_PTHREAD--    // Signal condition-    (void) pthread_cond_signal( (pthread_cond_t *) cond );--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Broadcast a condition to all waiting threads-//========================================================================--void _glfwPlatformBroadcastCond( GLFWcond cond )-{-#ifdef _GLFW_HAS_PTHREAD--    // Broadcast condition-    (void) pthread_cond_broadcast( (pthread_cond_t *) cond );--#endif // _GLFW_HAS_PTHREAD-}---//========================================================================-// Return the number of processors in the system.-//========================================================================--int _glfwPlatformGetNumberOfProcessors( void )-{-    int n;--    // Get number of processors online-    _glfw_numprocessors( n );-    return n;-}-
− glfw/lib/x11/x11_time.c 
@@ -1,154 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    X11/GLX-// API version: 2.7-// WWW:         http://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"---//========================================================================-// Initialise timer-//========================================================================--void _glfwInitTimer( void )-{-    struct timeval  tv;--    // "Resolution" is 1 us-    _glfwLibrary.Timer.resolution = 1e-6;--    // Set start-time for timer-    gettimeofday( &tv, NULL );-    _glfwLibrary.Timer.t0 = (long long) tv.tv_sec * (long long) 1000000 +-		            (long long) tv.tv_usec;-}---//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Return timer value in seconds-//========================================================================--double _glfwPlatformGetTime( void )-{-    long long t;-    struct timeval  tv;--    gettimeofday( &tv, NULL );-    t = (long long) tv.tv_sec * (long long) 1000000 +-	(long long) tv.tv_usec;--    return (double)(t - _glfwLibrary.Timer.t0) * _glfwLibrary.Timer.resolution;-}---//========================================================================-// Set timer value in seconds-//========================================================================--void _glfwPlatformSetTime( double t )-{-    long long t0;-    struct timeval  tv;--    gettimeofday( &tv, NULL );-    t0 = (long long) tv.tv_sec * (long long) 1000000 +-	 (long long) tv.tv_usec;--    // Calulate new starting time-    _glfwLibrary.Timer.t0 = t0 - (long long)(t/_glfwLibrary.Timer.resolution);-}---//========================================================================-// Put a thread to sleep for a specified amount of time-//========================================================================--void _glfwPlatformSleep( double time )-{-#ifdef _GLFW_HAS_PTHREAD--    if( time == 0.0 )-    {-#ifdef _GLFW_HAS_SCHED_YIELD-	sched_yield();-#endif-	return;-    }--    struct timeval  currenttime;-    struct timespec wait;-    pthread_mutex_t mutex;-    pthread_cond_t  cond;-    long dt_sec, dt_usec;--    // Not all pthread implementations have a pthread_sleep() function. We-    // do it the portable way, using a timed wait for a condition that we-    // will never signal. NOTE: The unistd functions sleep/usleep suspends-    // the entire PROCESS, not a signle thread, which is why we can not-    // use them to implement glfwSleep.--    // Set timeout time, relatvie to current time-    gettimeofday( &currenttime, NULL );-    dt_sec  = (long) time;-    dt_usec = (long) ((time - (double)dt_sec) * 1000000.0);-    wait.tv_nsec = (currenttime.tv_usec + dt_usec) * 1000L;-    if( wait.tv_nsec > 1000000000L )-    {-        wait.tv_nsec -= 1000000000L;-        dt_sec++;-    }-    wait.tv_sec  = currenttime.tv_sec + dt_sec;--    // Initialize condition and mutex objects-    pthread_mutex_init( &mutex, NULL );-    pthread_cond_init( &cond, NULL );--    // Do a timed wait-    pthread_mutex_lock( &mutex );-    pthread_cond_timedwait( &cond, &mutex, &wait );-    pthread_mutex_unlock( &mutex );--    // Destroy condition and mutex objects-    pthread_mutex_destroy( &mutex );-    pthread_cond_destroy( &cond );--#else--    // For systems without PTHREAD, use unistd usleep-    if( time > 0 )-    {-        usleep( (unsigned int) (time*1000000) );-    }--#endif // _GLFW_HAS_PTHREAD-}-
− glfw/lib/x11/x11_window.c 
@@ -1,1891 +0,0 @@-//========================================================================-// GLFW - An OpenGL framework-// Platform:    X11/GLX-// API version: 2.7-// WWW:         http://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>---/* Define GLX 1.4 FSAA tokens if not already defined */-#ifndef GLX_VERSION_1_4--#define GLX_SAMPLE_BUFFERS  100000-#define GLX_SAMPLES         100001--#endif /*GLX_VERSION_1_4*/--// Action for EWMH client messages-#define _NET_WM_STATE_REMOVE        0-#define _NET_WM_STATE_ADD           1-#define _NET_WM_STATE_TOGGLE        2---//************************************************************************-//****                  GLFW internal functions                       ****-//************************************************************************--//========================================================================-// Error handler for BadMatch errors when requesting context with-// unavailable OpenGL versions using the GLX_ARB_create_context extension-//========================================================================--static int errorHandler( Display *display, XErrorEvent *event )-{-    return 0;-}---//========================================================================-// Checks whether the event is a MapNotify for the specified window-//========================================================================--static Bool isMapNotify( Display *d, XEvent *e, char *arg )-{-    return (e->type == MapNotify) && (e->xmap.window == (Window)arg);-}---//========================================================================-// Retrieve a single window property of the specified type-// Inspired by fghGetWindowProperty from freeglut-//========================================================================--static unsigned long getWindowProperty( Window window,-                                        Atom property,-                                        Atom type,-                                        unsigned char** value )-{-    Atom actualType;-    int actualFormat;-    unsigned long itemCount, bytesAfter;--    XGetWindowProperty( _glfwLibrary.display,-                        window,-                        property,-                        0,-                        LONG_MAX,-                        False,-                        type,-                        &actualType,-                        &actualFormat,-                        &itemCount,-                        &bytesAfter,-                        value );--    if( actualType != type )-    {-        return 0;-    }--    return itemCount;-}---//========================================================================-// Check whether the specified atom is supported-//========================================================================--static Atom getSupportedAtom( Atom* supportedAtoms,-                              unsigned long atomCount,-                              const char* atomName )-{-    Atom atom = XInternAtom( _glfwLibrary.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 GLboolean checkForEWMH( void )-{-    Window *windowFromRoot = NULL;-    Window *windowFromChild = NULL;--    // Hey kids; let's see if the window manager supports EWMH!--    // First we need a couple of atoms, which should already be there-    Atom supportingWmCheck = XInternAtom( _glfwLibrary.display,-                                          "_NET_SUPPORTING_WM_CHECK",-                                          True );-    Atom wmSupported = XInternAtom( _glfwLibrary.display,-                                    "_NET_SUPPORTED",-                                    True );-    if( supportingWmCheck == None || wmSupported == None )-    {-        return GL_FALSE;-    }--    // Then we look for the _NET_SUPPORTING_WM_CHECK property of the root window-    if( getWindowProperty( _glfwWin.root,-                           supportingWmCheck,-                           XA_WINDOW,-                           (unsigned char**) &windowFromRoot ) != 1 )-    {-        XFree( windowFromRoot );-        return GL_FALSE;-    }--    // It should be the ID of a child window (of the root)-    // Then we look for the same property on the child window-    if( getWindowProperty( *windowFromRoot,-                           supportingWmCheck,-                           XA_WINDOW,-                           (unsigned char**) &windowFromChild ) != 1 )-    {-        XFree( windowFromRoot );-        XFree( windowFromChild );-        return GL_FALSE;-    }--    // It should be the ID of that same child window-    if( *windowFromRoot != *windowFromChild )-    {-        XFree( windowFromRoot );-        XFree( windowFromChild );-        return GL_FALSE;-    }--    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-    atomCount = getWindowProperty( _glfwWin.root,-                                   wmSupported,-                                   XA_ATOM,-                                   (unsigned char**) &supportedAtoms );--    // See which of the atoms we support that are supported by the WM--    _glfwWin.wmState = getSupportedAtom( supportedAtoms,-                                         atomCount,-                                         "_NET_WM_STATE" );--    _glfwWin.wmStateFullscreen = getSupportedAtom( supportedAtoms,-                                                   atomCount,-                                                   "_NET_WM_STATE_FULLSCREEN" );--    _glfwWin.wmPing = getSupportedAtom( supportedAtoms,-                                        atomCount,-                                        "_NET_WM_PING" );--    _glfwWin.wmActiveWindow = getSupportedAtom( supportedAtoms,-                                                atomCount,-                                                "_NET_ACTIVE_WINDOW" );--    XFree( supportedAtoms );--    return GL_TRUE;-}--//========================================================================-// Translates an X Window key to internal coding-//========================================================================--static int translateKey( int keycode )-{-    KeySym key, key_lc, key_uc;--    // Try secondary keysym, for numeric keypad keys-    // Note: This way we always force "NumLock = ON", which at least-    // enables GLFW users to detect numeric keypad keys-    key = XKeycodeToKeysym( _glfwLibrary.display, keycode, 1 );-    switch( key )-    {-        // Numeric keypad-        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-    key = XKeycodeToKeysym( _glfwLibrary.display, keycode, 0 );-    switch( key )-    {-        // Special keys (non character keys)-        case XK_Escape:       return GLFW_KEY_ESC;-        case XK_Tab:          return GLFW_KEY_TAB;-        case XK_Shift_L:      return GLFW_KEY_LSHIFT;-        case XK_Shift_R:      return GLFW_KEY_RSHIFT;-        case XK_Control_L:    return GLFW_KEY_LCTRL;-        case XK_Control_R:    return GLFW_KEY_RCTRL;-        case XK_Meta_L:-        case XK_Alt_L:        return GLFW_KEY_LALT;-        case XK_Mode_switch:  // Mapped to Alt_R on many keyboards-        case XK_Meta_R:-        case XK_ISO_Level3_Shift: // AltGr on at least some machines-        case XK_Alt_R:        return GLFW_KEY_RALT;-        case XK_Super_L:      return GLFW_KEY_LSUPER;-        case XK_Super_R:      return GLFW_KEY_RSUPER;-        case XK_Menu:         return GLFW_KEY_MENU;-        case XK_Num_Lock:     return GLFW_KEY_KP_NUM_LOCK;-        case XK_Caps_Lock:    return GLFW_KEY_CAPS_LOCK;-        case XK_Scroll_Lock:  return GLFW_KEY_SCROLL_LOCK;-        case XK_Pause:        return GLFW_KEY_PAUSE;-        case XK_KP_Delete:-        case XK_Delete:       return GLFW_KEY_DEL;-        case XK_BackSpace:    return GLFW_KEY_BACKSPACE;-        case XK_Return:       return GLFW_KEY_ENTER;-        case XK_KP_Home:-        case XK_Home:         return GLFW_KEY_HOME;-        case XK_KP_End:-        case XK_End:          return GLFW_KEY_END;-        case XK_KP_Page_Up:-        case XK_Page_Up:      return GLFW_KEY_PAGEUP;-        case XK_KP_Page_Down:-        case XK_Page_Down:    return GLFW_KEY_PAGEDOWN;-        case XK_KP_Insert:-        case XK_Insert:       return GLFW_KEY_INSERT;-        case XK_KP_Left:-        case XK_Left:         return GLFW_KEY_LEFT;-        case XK_KP_Right:-        case XK_Right:        return GLFW_KEY_RIGHT;-        case XK_KP_Down:-        case XK_Down:         return GLFW_KEY_DOWN;-        case XK_KP_Up:-        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 (should have been detected in secondary keysym!)-        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;-        case XK_KP_Equal:     return GLFW_KEY_KP_EQUAL;-        case XK_KP_Enter:     return GLFW_KEY_KP_ENTER;--        // The rest (should be printable keys)-        default:-            // Make uppercase-            XConvertCase( key, &key_lc, &key_uc );-            key = key_uc;--            // Valid ISO 8859-1 character?-            if( (key >=  32 && key <= 126) ||-                (key >= 160 && key <= 255) )-            {-                return (int) key;-            }-            return GLFW_KEY_UNKNOWN;-    }-}---//========================================================================-// Translates an X Window event to Unicode-//========================================================================--static int translateChar( XKeyEvent *event )-{-    KeySym keysym;--    // Get X11 keysym-    XLookupString( event, NULL, 0, &keysym, NULL );--    // Convert to Unicode (see x11_keysym2unicode.c)-    return (int) _glfwKeySym2Unicode( keysym );-}---//========================================================================-// Create a blank cursor (for locked mouse mode)-//========================================================================--static Cursor createNULLCursor( Display *display, Window root )-{-    Pixmap    cursormask;-    XGCValues xgc;-    GC        gc;-    XColor    col;-    Cursor    cursor;--    cursormask = XCreatePixmap( display, root, 1, 1, 1 );-    xgc.function = GXclear;-    gc = XCreateGC( display, cursormask, GCFunction, &xgc );-    XFillRectangle( display, cursormask, gc, 0, 0, 1, 1 );-    col.pixel = 0;-    col.red = 0;-    col.flags = 4;-    cursor = XCreatePixmapCursor( display, cursormask, cursormask,-                                  &col,&col, 0,0 );-    XFreePixmap( display, cursormask );-    XFreeGC( display, gc );--    return cursor;-}---//========================================================================-// 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( _glfwWin.has_GLX_SGIX_fbconfig )-    {-        _glfwWin.GetFBConfigAttribSGIX( _glfwLibrary.display, fbconfig, attrib, &value );-    }-    else-    {-        glXGetFBConfigAttrib( _glfwLibrary.display, fbconfig, attrib, &value );-    }--    return value;-}---//========================================================================-// Return a list of available and usable framebuffer configs-//========================================================================--static _GLFWfbconfig *getFBConfigs( unsigned int *found )-{-    GLXFBConfig *fbconfigs;-    _GLFWfbconfig *result;-    int i, count = 0;--    *found = 0;--    if( _glfwLibrary.glxMajor == 1 && _glfwLibrary.glxMinor < 3 )-    {-        if( !_glfwWin.has_GLX_SGIX_fbconfig )-        {-            fprintf( stderr, "GLXFBConfigs are not supported by the X server\n" );-            return NULL;-        }-    }--    if( _glfwWin.has_GLX_SGIX_fbconfig )-    {-        fbconfigs = _glfwWin.ChooseFBConfigSGIX( _glfwLibrary.display,-                                                 _glfwWin.screen,-                                                 NULL,-                                                 &count );-        if( !count )-        {-            fprintf( stderr, "No GLXFBConfigs returned\n" );-            return NULL;-        }-    }-    else-    {-        fbconfigs = glXGetFBConfigs( _glfwLibrary.display, _glfwWin.screen, &count );-        if( !count )-        {-            fprintf( stderr, "No GLXFBConfigs returned\n" );-            return NULL;-        }-    }--    result = (_GLFWfbconfig*) malloc( sizeof(_GLFWfbconfig) * count );-    if( !result )-    {-        fprintf( stderr, "Out of memory\n" );-        return NULL;-    }--    for( i = 0;  i < count;  i++ )-    {-        if( !getFBConfigAttrib( fbconfigs[i], GLX_DOUBLEBUFFER ) ||-            !getFBConfigAttrib( fbconfigs[i], GLX_VISUAL_ID ) )-        {-            // Only consider double-buffered GLXFBConfigs with associated visuals-            continue;-        }--        if( !( getFBConfigAttrib( fbconfigs[i], GLX_RENDER_TYPE ) & GLX_RGBA_BIT ) )-        {-            // Only consider RGBA GLXFBConfigs-            continue;-        }--        if( !( getFBConfigAttrib( fbconfigs[i], GLX_DRAWABLE_TYPE ) & GLX_WINDOW_BIT ) )-        {-            // Only consider window GLXFBConfigs-            continue;-        }--        result[*found].redBits = getFBConfigAttrib( fbconfigs[i], GLX_RED_SIZE );-        result[*found].greenBits = getFBConfigAttrib( fbconfigs[i], GLX_GREEN_SIZE );-        result[*found].blueBits = getFBConfigAttrib( fbconfigs[i], GLX_BLUE_SIZE );--        result[*found].alphaBits = getFBConfigAttrib( fbconfigs[i], GLX_ALPHA_SIZE );-        result[*found].depthBits = getFBConfigAttrib( fbconfigs[i], GLX_DEPTH_SIZE );-        result[*found].stencilBits = getFBConfigAttrib( fbconfigs[i], GLX_STENCIL_SIZE );--        result[*found].accumRedBits = getFBConfigAttrib( fbconfigs[i], GLX_ACCUM_RED_SIZE );-        result[*found].accumGreenBits = getFBConfigAttrib( fbconfigs[i], GLX_ACCUM_GREEN_SIZE );-        result[*found].accumBlueBits = getFBConfigAttrib( fbconfigs[i], GLX_ACCUM_BLUE_SIZE );-        result[*found].accumAlphaBits = getFBConfigAttrib( fbconfigs[i], GLX_ACCUM_ALPHA_SIZE );--        result[*found].auxBuffers = getFBConfigAttrib( fbconfigs[i], GLX_AUX_BUFFERS );-        result[*found].stereo = getFBConfigAttrib( fbconfigs[i], GLX_STEREO );--        if( _glfwWin.has_GLX_ARB_multisample )-        {-            result[*found].samples = getFBConfigAttrib( fbconfigs[i], GLX_SAMPLES );-        }-        else-        {-            result[*found].samples = 0;-        }--        result[*found].platformID = (GLFWintptr) getFBConfigAttrib( fbconfigs[i], GLX_FBCONFIG_ID );--        (*found)++;-    }--    XFree( fbconfigs );--    return result;-}---//========================================================================-// Create the OpenGL context-//========================================================================--#define setGLXattrib( attribs, index, attribName, attribValue ) \-    attribs[index++] = attribName; \-    attribs[index++] = attribValue;--static int createContext( const _GLFWwndconfig *wndconfig, GLXFBConfigID fbconfigID )-{-    int attribs[40];-    int flags, dummy, index;-    GLXFBConfig *fbconfig;--    // Retrieve the previously selected GLXFBConfig-    {-        index = 0;--        setGLXattrib( attribs, index, GLX_FBCONFIG_ID, (int) fbconfigID );-        setGLXattrib( attribs, index, None, None );--        if( _glfwWin.has_GLX_SGIX_fbconfig )-        {-            fbconfig = _glfwWin.ChooseFBConfigSGIX( _glfwLibrary.display,-                                                    _glfwWin.screen,-                                                    attribs,-                                                    &dummy );-        }-        else-        {-            fbconfig = glXChooseFBConfig( _glfwLibrary.display,-                                          _glfwWin.screen,-                                          attribs,-                                          &dummy );-        }--        if( fbconfig == NULL )-        {-            fprintf(stderr, "Unable to retrieve the selected GLXFBConfig\n");-            return GL_FALSE;-        }-    }--    // Retrieve the corresponding visual-    if( _glfwWin.has_GLX_SGIX_fbconfig )-    {-        _glfwWin.visual = _glfwWin.GetVisualFromFBConfigSGIX( _glfwLibrary.display,-                                                              *fbconfig );-    }-    else-    {-        _glfwWin.visual = glXGetVisualFromFBConfig( _glfwLibrary.display, *fbconfig );-    }--    if( _glfwWin.visual == NULL )-    {-        XFree( fbconfig );--        fprintf(stderr, "Unable to retrieve visual for GLXFBconfig\n");-        return GL_FALSE;-    }--    if( _glfwWin.has_GLX_ARB_create_context )-    {-        index = 0;--        if( wndconfig->glMajor != 1 || wndconfig->glMinor != 0 )-        {-            // Request an explicitly versioned context--            setGLXattrib( attribs, index, GLX_CONTEXT_MAJOR_VERSION_ARB, wndconfig->glMajor );-            setGLXattrib( attribs, index, GLX_CONTEXT_MINOR_VERSION_ARB, wndconfig->glMinor );-        }--        if( wndconfig->glForward || wndconfig->glDebug )-        {-            flags = 0;--            if( wndconfig->glForward )-            {-                flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;-            }--            if( wndconfig->glDebug )-            {-                flags |= GLX_CONTEXT_DEBUG_BIT_ARB;-            }--            setGLXattrib( attribs, index, GLX_CONTEXT_FLAGS_ARB, flags );-        }--        if( wndconfig->glProfile )-        {-            if( !_glfwWin.has_GLX_ARB_create_context_profile )-            {-                fprintf( stderr, "OpenGL profile requested but GLX_ARB_create_context_profile "-                                 "is unavailable\n" );-                return GL_FALSE;-            }--            if( wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE )-            {-                flags = GLX_CONTEXT_CORE_PROFILE_BIT_ARB;-            }-            else-            {-                flags = GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;-            }--            setGLXattrib( attribs, index, GLX_CONTEXT_PROFILE_MASK_ARB, flags );-        }--        setGLXattrib( attribs, index, None, None );--        // This is the only place we set an Xlib error handler, and we only do-        // it because glXCreateContextAttribsARB generates a BadMatch error if-        // the requested OpenGL version is unavailable (instead of a civilized-        // response like returning NULL)-        XSetErrorHandler( errorHandler );--        _glfwWin.context = _glfwWin.CreateContextAttribsARB( _glfwLibrary.display,-                                                             *fbconfig,-                                                             NULL,-                                                             True,-                                                             attribs );--        // We are done, so unset the error handler again (see above)-        XSetErrorHandler( NULL );-    }-    else-    {-        if( _glfwWin.has_GLX_SGIX_fbconfig )-        {-            _glfwWin.context = _glfwWin.CreateContextWithConfigSGIX( _glfwLibrary.display,-                                                                     *fbconfig,-                                                                     GLX_RGBA_TYPE,-                                                                     NULL,-                                                                     True );-        }-        else-        {-            _glfwWin.context = glXCreateNewContext( _glfwLibrary.display,-                                                    *fbconfig,-                                                    GLX_RGBA_TYPE,-                                                    NULL,-                                                    True );-        }-    }--    XFree( fbconfig );--    if( _glfwWin.context == NULL )-    {-        fprintf(stderr, "Unable to create OpenGL context\n");-        return GL_FALSE;-    }--    _glfwWin.fbconfigID = fbconfigID;--    return GL_TRUE;-}--#undef setGLXattrib---//========================================================================-// Initialize GLX-specific extensions-//========================================================================--static void initGLXExtensions( void )-{-    // This needs to include every function pointer loaded below-    _glfwWin.SwapIntervalSGI             = NULL;-    _glfwWin.GetFBConfigAttribSGIX       = NULL;-    _glfwWin.ChooseFBConfigSGIX          = NULL;-    _glfwWin.CreateContextWithConfigSGIX = NULL;-    _glfwWin.GetVisualFromFBConfigSGIX   = NULL;-    _glfwWin.CreateContextAttribsARB     = NULL;--    // This needs to include every extension used below-    _glfwWin.has_GLX_SGIX_fbconfig              = GL_FALSE;-    _glfwWin.has_GLX_SGI_swap_control           = GL_FALSE;-    _glfwWin.has_GLX_ARB_multisample            = GL_FALSE;-    _glfwWin.has_GLX_ARB_create_context         = GL_FALSE;-    _glfwWin.has_GLX_ARB_create_context_profile = GL_FALSE;--    if( _glfwPlatformExtensionSupported( "GLX_SGI_swap_control" ) )-    {-        _glfwWin.SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)-            _glfwPlatformGetProcAddress( "glXSwapIntervalSGI" );--        if( _glfwWin.SwapIntervalSGI )-        {-            _glfwWin.has_GLX_SGI_swap_control = GL_TRUE;-        }-    }--    if( _glfwPlatformExtensionSupported( "GLX_SGIX_fbconfig" ) )-    {-        _glfwWin.GetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)-            _glfwPlatformGetProcAddress( "glXGetFBConfigAttribSGIX" );-        _glfwWin.ChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)-            _glfwPlatformGetProcAddress( "glXChooseFBConfigSGIX" );-        _glfwWin.CreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)-            _glfwPlatformGetProcAddress( "glXCreateContextWithConfigSGIX" );-        _glfwWin.GetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)-            _glfwPlatformGetProcAddress( "glXGetVisualFromFBConfigSGIX" );--        if( _glfwWin.GetFBConfigAttribSGIX &&-            _glfwWin.ChooseFBConfigSGIX &&-            _glfwWin.CreateContextWithConfigSGIX &&-            _glfwWin.GetVisualFromFBConfigSGIX )-        {-            _glfwWin.has_GLX_SGIX_fbconfig = GL_TRUE;-        }-    }--    if( _glfwPlatformExtensionSupported( "GLX_ARB_multisample" ) )-    {-        _glfwWin.has_GLX_ARB_multisample = GL_TRUE;-    }--    if( _glfwPlatformExtensionSupported( "GLX_ARB_create_context" ) )-    {-        _glfwWin.CreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)-            _glfwPlatformGetProcAddress( "glXCreateContextAttribsARB" );--        if( _glfwWin.CreateContextAttribsARB )-        {-            _glfwWin.has_GLX_ARB_create_context = GL_TRUE;-        }-    }--    if( _glfwPlatformExtensionSupported( "GLX_ARB_create_context_profile" ) )-    {-        _glfwWin.has_GLX_ARB_create_context_profile = GL_TRUE;-    }-}---//========================================================================-// Create the X11 window (and its colormap)-//========================================================================--static GLboolean createWindow( int width, int height,-                               const _GLFWwndconfig *wndconfig )-{-    XEvent event;-    unsigned long wamask;-    XSetWindowAttributes wa;--    // Every window needs a colormap-    // Create one based on the visual used by the current context--    _glfwWin.colormap = XCreateColormap( _glfwLibrary.display,-                                         _glfwWin.root,-                                         _glfwWin.visual->visual,-                                         AllocNone );--    // Create the actual window-    {-        wamask = CWBorderPixel | CWColormap | CWEventMask;--        wa.colormap = _glfwWin.colormap;-        wa.border_pixel = 0;-        wa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask |-            PointerMotionMask | ButtonPressMask | ButtonReleaseMask |-            ExposureMask | FocusChangeMask | VisibilityChangeMask;--        if( wndconfig->mode == GLFW_WINDOW )-        {-            // The /only/ reason we are setting the background pixel here is-            // that otherwise our window wont get any decorations on systems-            // using Compiz on Intel hardware-            wa.background_pixel = BlackPixel( _glfwLibrary.display, _glfwWin.screen );-            wamask |= CWBackPixel;-        }--        _glfwWin.window = XCreateWindow(-            _glfwLibrary.display,-            _glfwWin.root,-            0, 0,                            // Upper left corner of this window on root-            _glfwWin.width, _glfwWin.height,-            0,                               // Border width-            _glfwWin.visual->depth,          // Color depth-            InputOutput,-            _glfwWin.visual->visual,-            wamask,-            &wa-        );-        if( !_glfwWin.window )-        {-            _glfwPlatformCloseWindow();-            return GL_FALSE;-        }-    }--    // Check whether an EWMH-compliant window manager is running-    _glfwWin.hasEWMH = checkForEWMH();--    if( _glfwWin.fullscreen && !_glfwWin.hasEWMH )-    {-        // This is the butcher's way of removing window decorations-        // Setting the override-redirect attribute on a window makes the window-        // manager ignore the window completely (ICCCM, section 4)-        // The good thing is that this makes undecorated fullscreen windows-        // easy to do; the bad thing is that we have to do everything manually-        // and some things (like iconify/restore) won't work at all, as they're-        // usually performed by the window manager--        XSetWindowAttributes attributes;-        attributes.override_redirect = True;-        XChangeWindowAttributes( _glfwLibrary.display,-                                 _glfwWin.window,-                                 CWOverrideRedirect,-                                 &attributes );--        _glfwWin.overrideRedirect = GL_TRUE;-    }--    // Find or create the protocol atom for window close notifications-    _glfwWin.wmDeleteWindow = XInternAtom( _glfwLibrary.display,-                                            "WM_DELETE_WINDOW",-                                            False );--    // Declare the WM protocols we support-    {-        int count = 0;-        Atom protocols[2];--        // The WM_DELETE_WINDOW ICCCM protocol-        // Basic window close notification protocol-        if( _glfwWin.wmDeleteWindow != None )-        {-            protocols[count++] = _glfwWin.wmDeleteWindow;-        }--        // The _NET_WM_PING EWMH protocol-        // Tells the WM to ping our window and flag us as unresponsive if we-        // don't reply within a few seconds-        if( _glfwWin.wmPing != None )-        {-            protocols[count++] = _glfwWin.wmPing;-        }--        if( count > 0 )-        {-            XSetWMProtocols( _glfwLibrary.display, _glfwWin.window,-                             protocols, count );-        }-    }--    // Set ICCCM WM_HINTS property-    {-        XWMHints *hints = XAllocWMHints();-        if( !hints )-        {-            _glfwPlatformCloseWindow();-            return GL_FALSE;-        }--        hints->flags = StateHint;-        hints->initial_state = NormalState;--        XSetWMHints( _glfwLibrary.display, _glfwWin.window, hints );-        XFree( hints );-    }--    // Set ICCCM WM_NORMAL_HINTS property (even if no parts are set)-    {-        XSizeHints *hints = XAllocSizeHints();-        if( !hints )-        {-            _glfwPlatformCloseWindow();-            return GL_FALSE;-        }--        hints->flags = 0;--        if( wndconfig->windowNoResize && !_glfwWin.fullscreen )-        {-            hints->flags |= (PMinSize | PMaxSize);-            hints->min_width  = hints->max_width  = _glfwWin.width;-            hints->min_height = hints->max_height = _glfwWin.height;-        }--        XSetWMNormalHints( _glfwLibrary.display, _glfwWin.window, hints );-        XFree( hints );-    }--    _glfwPlatformSetWindowTitle( "GLFW Window" );--    // Make sure the window is mapped before proceeding-    XMapWindow( _glfwLibrary.display, _glfwWin.window );-    XPeekIfEvent( _glfwLibrary.display, &event, isMapNotify,-                  (char*)_glfwWin.window );--    return GL_TRUE;-}---//========================================================================-// Enter fullscreen mode-//========================================================================--static void enterFullscreenMode( void )-{-    if( !_glfwWin.Saver.changed )-    {-        // Remember old screen saver settings-        XGetScreenSaver( _glfwLibrary.display,-                         &_glfwWin.Saver.timeout, &_glfwWin.Saver.interval,-                         &_glfwWin.Saver.blanking, &_glfwWin.Saver.exposure );--        // Disable screen saver-        XSetScreenSaver( _glfwLibrary.display, 0, 0, DontPreferBlanking,-                        DefaultExposures );--        _glfwWin.Saver.changed = GL_TRUE;-    }--    _glfwSetVideoMode( _glfwWin.screen,-                       &_glfwWin.width, &_glfwWin.height,-                       &_glfwWin.refreshRate );--    if( _glfwWin.hasEWMH &&-        _glfwWin.wmState != None &&-        _glfwWin.wmStateFullscreen != None )-    {-        if( _glfwWin.wmActiveWindow != None )-        {-            // Ask the window manager to raise and focus the GLFW window-            // Only focused windows with the _NET_WM_STATE_FULLSCREEN state end-            // up on top of all other windows ("Stacking order" in EWMH spec)--            XEvent event;-            memset( &event, 0, sizeof(event) );--            event.type = ClientMessage;-            event.xclient.window = _glfwWin.window;-            event.xclient.format = 32; // Data is 32-bit longs-            event.xclient.message_type = _glfwWin.wmActiveWindow;-            event.xclient.data.l[0] = 1; // Sender is a normal application-            event.xclient.data.l[1] = 0; // We don't really know the timestamp--            XSendEvent( _glfwLibrary.display,-                        _glfwWin.root,-                        False,-                        SubstructureNotifyMask | SubstructureRedirectMask,-                        &event );-        }--        // Ask the window manager to make the GLFW window a fullscreen window-        // Fullscreen windows are undecorated and, when focused, are kept-        // on top of all other windows--        XEvent event;-        memset( &event, 0, sizeof(event) );--        event.type = ClientMessage;-        event.xclient.window = _glfwWin.window;-        event.xclient.format = 32; // Data is 32-bit longs-        event.xclient.message_type = _glfwWin.wmState;-        event.xclient.data.l[0] = _NET_WM_STATE_ADD;-        event.xclient.data.l[1] = _glfwWin.wmStateFullscreen;-        event.xclient.data.l[2] = 0; // No secondary property-        event.xclient.data.l[3] = 1; // Sender is a normal application--        XSendEvent( _glfwLibrary.display,-                    _glfwWin.root,-                    False,-                    SubstructureNotifyMask | SubstructureRedirectMask,-                    &event );-    }-    else if( _glfwWin.overrideRedirect )-    {-        // In override-redirect mode, we have divorced ourselves from the-        // window manager, so we need to do everything manually--        XRaiseWindow( _glfwLibrary.display, _glfwWin.window );-        XSetInputFocus( _glfwLibrary.display, _glfwWin.window,-                        RevertToParent, CurrentTime );-        XMoveWindow( _glfwLibrary.display, _glfwWin.window, 0, 0 );-        XResizeWindow( _glfwLibrary.display, _glfwWin.window,-                       _glfwWin.width, _glfwWin.height );-    }--    if( _glfwWin.mouseLock )-    {-        _glfwPlatformHideMouseCursor();-    }--    // HACK: Try to get window inside viewport (for virtual displays) by moving-    // the mouse cursor to the upper left corner (and then to the center)-    // This hack should be harmless on saner systems as well-    XWarpPointer( _glfwLibrary.display, None, _glfwWin.window, 0,0,0,0, 0,0 );-    XWarpPointer( _glfwLibrary.display, None, _glfwWin.window, 0,0,0,0,-                  _glfwWin.width / 2, _glfwWin.height / 2 );-}--//========================================================================-// Leave fullscreen mode-//========================================================================--static void leaveFullscreenMode( void )-{-    _glfwRestoreVideoMode();--    // Did we change the screen saver setting?-    if( _glfwWin.Saver.changed )-    {-        // Restore old screen saver settings-        XSetScreenSaver( _glfwLibrary.display,-                         _glfwWin.Saver.timeout,-                         _glfwWin.Saver.interval,-                         _glfwWin.Saver.blanking,-                         _glfwWin.Saver.exposure );--        _glfwWin.Saver.changed = GL_FALSE;-    }--    if( _glfwWin.hasEWMH &&-        _glfwWin.wmState != None &&-        _glfwWin.wmStateFullscreen != None )-    {-        // Ask the window manager to make the GLFW window a normal window-        // Normal windows usually have frames and other decorations--        XEvent event;-        memset( &event, 0, sizeof(event) );--        event.type = ClientMessage;-        event.xclient.window = _glfwWin.window;-        event.xclient.format = 32; // Data is 32-bit longs-        event.xclient.message_type = _glfwWin.wmState;-        event.xclient.data.l[0] = _NET_WM_STATE_REMOVE;-        event.xclient.data.l[1] = _glfwWin.wmStateFullscreen;-        event.xclient.data.l[2] = 0; // No secondary property-        event.xclient.data.l[3] = 1; // Sender is a normal application--        XSendEvent( _glfwLibrary.display,-                    _glfwWin.root,-                    False,-                    SubstructureNotifyMask | SubstructureRedirectMask,-                    &event );-    }--    if( _glfwWin.mouseLock )-    {-        _glfwPlatformShowMouseCursor();-    }-}--//========================================================================-// Get and process next X event (called by _glfwPlatformPollEvents)-// Returns GL_TRUE if a window close request was received-//========================================================================--static GLboolean processSingleEvent( void )-{-    XEvent event;-    XNextEvent( _glfwLibrary.display, &event );--    switch( event.type )-    {-        case KeyPress:-        {-            // A keyboard key was pressed--            // Translate and report key press-            _glfwInputKey( translateKey( event.xkey.keycode ), GLFW_PRESS );--            // Translate and report character input-            if( _glfwWin.charCallback )-            {-                _glfwInputChar( translateChar( &event.xkey ), GLFW_PRESS );-            }-            break;-        }--        case KeyRelease:-        {-            // A keyboard key was released--            // Do not report key releases for key repeats. For key repeats we-            // will get KeyRelease/KeyPress pairs with similar or identical-            // time stamps. User selected key repeat filtering is handled in-            // _glfwInputKey()/_glfwInputChar().-            if( XEventsQueued( _glfwLibrary.display, QueuedAfterReading ) )-            {-                XEvent nextEvent;-                XPeekEvent( _glfwLibrary.display, &nextEvent );--                if( nextEvent.type == KeyPress &&-                    nextEvent.xkey.window == event.xkey.window &&-                    nextEvent.xkey.keycode == event.xkey.keycode )-                {-                    // This last check is a hack to work around key repeats-                    // leaking through due to some sort of time drift-                    // Toshiyuki Takahashi can press a button 16 times per-                    // second so it's fairly safe to assume that no human is-                    // pressing the key 50 times per second (value is ms)-                    if( ( nextEvent.xkey.time - event.xkey.time ) < 20 )-                    {-                        // Do not report anything for this event-                        break;-                    }-                }-            }--            // Translate and report key release-            _glfwInputKey( translateKey( event.xkey.keycode ), GLFW_RELEASE );--            // Translate and report character input-            if( _glfwWin.charCallback )-            {-                _glfwInputChar( translateChar( &event.xkey ), GLFW_RELEASE );-            }-            break;-        }--        case ButtonPress:-        {-            // A mouse button was pressed or a scrolling event occurred--            if( event.xbutton.button == Button1 )-            {-                _glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS );-            }-            else if( event.xbutton.button == Button2 )-            {-                _glfwInputMouseClick( GLFW_MOUSE_BUTTON_MIDDLE, GLFW_PRESS );-            }-            else if( event.xbutton.button == Button3 )-            {-                _glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS );-            }--            // XFree86 3.3.2 and later translates mouse wheel up/down into-            // mouse button 4 & 5 presses-            else if( event.xbutton.button == Button4 )-            {-                _glfwInput.WheelPos++;  // To verify: is this up or down?-                if( _glfwWin.mouseWheelCallback )-                {-                    _glfwWin.mouseWheelCallback( _glfwInput.WheelPos );-                }-            }-            else if( event.xbutton.button == Button5 )-            {-                _glfwInput.WheelPos--;-                if( _glfwWin.mouseWheelCallback )-                {-                    _glfwWin.mouseWheelCallback( _glfwInput.WheelPos );-                }-            }-            break;-        }--        case ButtonRelease:-        {-            // A mouse button was released--            if( event.xbutton.button == Button1 )-            {-                _glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT,-                                      GLFW_RELEASE );-            }-            else if( event.xbutton.button == Button2 )-            {-                _glfwInputMouseClick( GLFW_MOUSE_BUTTON_MIDDLE,-                                      GLFW_RELEASE );-            }-            else if( event.xbutton.button == Button3 )-            {-                _glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT,-                                      GLFW_RELEASE );-            }-            break;-        }--        case MotionNotify:-        {-            // The mouse cursor was moved--            if( event.xmotion.x != _glfwInput.CursorPosX ||-                event.xmotion.y != _glfwInput.CursorPosY )-            {-                // The mouse cursor was moved and we didn't do it--                if( _glfwWin.mouseLock )-                {-                    if( _glfwWin.pointerHidden )-                    {-                        _glfwInput.MousePosX += event.xmotion.x --                                                _glfwInput.CursorPosX;-                        _glfwInput.MousePosY += event.xmotion.y --                                                _glfwInput.CursorPosY;-                    }-                }-                else-                {-                    _glfwInput.MousePosX = event.xmotion.x;-                    _glfwInput.MousePosY = event.xmotion.y;-                }--                _glfwInput.CursorPosX = event.xmotion.x;-                _glfwInput.CursorPosY = event.xmotion.y;-                _glfwInput.MouseMoved = GL_TRUE;--                if( _glfwWin.mousePosCallback )-                {-                    _glfwWin.mousePosCallback( _glfwInput.MousePosX,-                                               _glfwInput.MousePosY );-                }-            }-            break;-        }--        case ConfigureNotify:-        {-            if( event.xconfigure.width != _glfwWin.width ||-                event.xconfigure.height != _glfwWin.height )-            {-                // The window was resized--                _glfwWin.width = event.xconfigure.width;-                _glfwWin.height = event.xconfigure.height;-                if( _glfwWin.windowSizeCallback )-                {-                    _glfwWin.windowSizeCallback( _glfwWin.width,-                                                 _glfwWin.height );-                }-            }-            break;-        }--        case ClientMessage:-        {-            if( (Atom) event.xclient.data.l[ 0 ] == _glfwWin.wmDeleteWindow )-            {-                // The window manager was asked to close the window, for example by-                // the user pressing a 'close' window decoration button--                return GL_TRUE;-            }-            else if( _glfwWin.wmPing != None &&-                     (Atom) event.xclient.data.l[ 0 ] == _glfwWin.wmPing )-            {-                // The window manager is pinging us to make sure we are still-                // responding to events--                event.xclient.window = _glfwWin.root;-                XSendEvent( _glfwLibrary.display,-                            event.xclient.window,-                            False,-                            SubstructureNotifyMask | SubstructureRedirectMask,-                            &event );-            }--            break;-        }--        case MapNotify:-        {-            // The window was mapped--            _glfwWin.iconified = GL_FALSE;-            break;-        }--        case UnmapNotify:-        {-            // The window was unmapped--            _glfwWin.iconified = GL_TRUE;-            break;-        }--        case FocusIn:-        {-            // The window gained focus--            _glfwWin.active = GL_TRUE;--            if( _glfwWin.mouseLock )-            {-                _glfwPlatformHideMouseCursor();-            }--            break;-        }--        case FocusOut:-        {-            // The window lost focus--            _glfwWin.active = GL_FALSE;-            _glfwInputDeactivation();--            if( _glfwWin.mouseLock )-            {-                _glfwPlatformShowMouseCursor();-            }--            break;-        }--        case Expose:-        {-            // The window's contents was damaged--            if( _glfwWin.windowRefreshCallback )-            {-                _glfwWin.windowRefreshCallback();-            }-            break;-        }--        // Was the window destroyed?-        case DestroyNotify:-            return GL_FALSE;--        default:-        {-#if defined( _GLFW_HAS_XRANDR )-            switch( event.type - _glfwLibrary.XRandR.eventBase )-            {-                case RRScreenChangeNotify:-                {-                    // Show XRandR that we really care-                    XRRUpdateConfiguration( &event );-                    break;-                }-            }-#endif-            break;-        }-    }--    // The window was not destroyed-    return GL_FALSE;-}----//************************************************************************-//****               Platform implementation functions                ****-//************************************************************************--//========================================================================-// Here is where the window is created, and-// the OpenGL rendering context is created-//========================================================================--int _glfwPlatformOpenWindow( int width, int height,-                             const _GLFWwndconfig* wndconfig,-                             const _GLFWfbconfig* fbconfig )-{-    _GLFWfbconfig closest;--    // Clear platform specific GLFW window state-    _glfwWin.visual           = (XVisualInfo*)NULL;-    _glfwWin.colormap         = (Colormap)0;-    _glfwWin.context          = (GLXContext)NULL;-    _glfwWin.window           = (Window)0;-    _glfwWin.pointerGrabbed   = GL_FALSE;-    _glfwWin.pointerHidden    = GL_FALSE;-    _glfwWin.keyboardGrabbed  = GL_FALSE;-    _glfwWin.overrideRedirect = GL_FALSE;-    _glfwWin.FS.modeChanged   = GL_FALSE;-    _glfwWin.Saver.changed    = GL_FALSE;-    _glfwWin.refreshRate      = wndconfig->refreshRate;-    _glfwWin.windowNoResize   = wndconfig->windowNoResize;--    _glfwWin.wmDeleteWindow    = None;-    _glfwWin.wmPing            = None;-    _glfwWin.wmState           = None;-    _glfwWin.wmStateFullscreen = None;-    _glfwWin.wmActiveWindow    = None;--    // As the 2.x API doesn't understand multiple display devices, we hardcode-    // this choice and hope for the best-    _glfwWin.screen = DefaultScreen( _glfwLibrary.display );-    _glfwWin.root = RootWindow( _glfwLibrary.display, _glfwWin.screen );--    // Create the invisible cursor for hidden cursor mode-    _glfwWin.cursor = createNULLCursor( _glfwLibrary.display, _glfwWin.root );--    initGLXExtensions();--    // Choose the best available fbconfig-    {-        unsigned int fbcount;-        _GLFWfbconfig *fbconfigs;-        const _GLFWfbconfig *result;--        fbconfigs = getFBConfigs( &fbcount );-        if( !fbconfigs )-        {-            return GL_FALSE;-        }--        result = _glfwChooseFBConfig( fbconfig, fbconfigs, fbcount );-        if( !result )-        {-            free( fbconfigs );-            return GL_FALSE;-        }--        closest = *result;-        free( fbconfigs );-    }--    if( !createContext( wndconfig, (GLXFBConfigID) closest.platformID ) )-    {-        return GL_FALSE;-    }--    if( !createWindow( width, height, wndconfig ) )-    {-        return GL_FALSE;-    }--    if( wndconfig->mode == GLFW_FULLSCREEN )-    {-#if defined( _GLFW_HAS_XRANDR )-        // Request screen change notifications-        if( _glfwLibrary.XRandR.available )-        {-            XRRSelectInput( _glfwLibrary.display,-                            _glfwWin.window,-                            RRScreenChangeNotifyMask );-        }-#endif-        enterFullscreenMode();-    }--    // Process the window map event and any other that may have arrived-    _glfwPlatformPollEvents();--    // Retrieve and set initial cursor position-    {-        Window window, root;-        int windowX, windowY, rootX, rootY;-        unsigned int mask;--        XQueryPointer( _glfwLibrary.display,-                       _glfwWin.window,-                       &root,-                       &window,-                       &rootX, &rootY,-                       &windowX, &windowY,-                       &mask );--        // TODO: Probably check for some corner cases here.--        _glfwInput.MousePosX = windowX;-        _glfwInput.MousePosY = windowY;-    }--    // Connect the context to the window-    glXMakeCurrent( _glfwLibrary.display, _glfwWin.window, _glfwWin.context );--    return GL_TRUE;-}---//========================================================================-// Properly kill the window/video display-//========================================================================--void _glfwPlatformCloseWindow( void )-{-    if( _glfwWin.fullscreen )-    {-        leaveFullscreenMode();-    }--    if( _glfwWin.context )-    {-        // Release and destroy the context-        glXMakeCurrent( _glfwLibrary.display, None, NULL );-        glXDestroyContext( _glfwLibrary.display, _glfwWin.context );-        _glfwWin.context = NULL;-    }--    if( _glfwWin.visual )-    {-        XFree( _glfwWin.visual );-        _glfwWin.visual = NULL;-    }--    if( _glfwWin.window )-    {-        XUnmapWindow( _glfwLibrary.display, _glfwWin.window );-        XDestroyWindow( _glfwLibrary.display, _glfwWin.window );-        _glfwWin.window = (Window) 0;-    }--    if( _glfwWin.colormap )-    {-        XFreeColormap( _glfwLibrary.display, _glfwWin.colormap );-        _glfwWin.colormap = (Colormap) 0;-    }--    if( _glfwWin.cursor )-    {-        XFreeCursor( _glfwLibrary.display, _glfwWin.cursor );-        _glfwWin.cursor = (Cursor) 0;-    }-}---//========================================================================-// Set the window title-//========================================================================--void _glfwPlatformSetWindowTitle( const char *title )-{-    // Set window & icon title-    XStoreName( _glfwLibrary.display, _glfwWin.window, title );-    XSetIconName( _glfwLibrary.display, _glfwWin.window, title );-}---//========================================================================-// Set the window size-//========================================================================--void _glfwPlatformSetWindowSize( int width, int height )-{-    int     mode = 0, rate, sizeChanged = GL_FALSE;-    XSizeHints *sizehints;--    rate = _glfwWin.refreshRate;--    if( _glfwWin.fullscreen )-    {-        // Get the closest matching video mode for the specified window size-        mode = _glfwGetClosestVideoMode( _glfwWin.screen, &width, &height, &rate );-    }--    if( _glfwWin.windowNoResize )-    {-        // Update window size restrictions to match new window size--        sizehints = XAllocSizeHints();-        sizehints->flags = 0;--        sizehints->min_width  = sizehints->max_width  = width;-        sizehints->min_height = sizehints->max_height = height;--        XSetWMNormalHints( _glfwLibrary.display, _glfwWin.window, sizehints );-        XFree( sizehints );-    }--    // Change window size before changing fullscreen mode?-    if( _glfwWin.fullscreen && (width > _glfwWin.width) )-    {-        XResizeWindow( _glfwLibrary.display, _glfwWin.window, width, height );-        sizeChanged = GL_TRUE;-    }--    if( _glfwWin.fullscreen )-    {-        // Change video mode, keeping current refresh rate-        _glfwSetVideoModeMODE( _glfwWin.screen, mode, _glfwWin.refreshRate );-    }--    // Set window size (if not already changed)-    if( !sizeChanged )-    {-        XResizeWindow( _glfwLibrary.display, _glfwWin.window, width, height );-    }-}---//========================================================================-// Set the window position.-//========================================================================--void _glfwPlatformSetWindowPos( int x, int y )-{-    XMoveWindow( _glfwLibrary.display, _glfwWin.window, x, y );-}---//========================================================================-// Window iconification-//========================================================================--void _glfwPlatformIconifyWindow( void )-{-    if( _glfwWin.overrideRedirect )-    {-        // We can't iconify/restore override-redirect windows, as that's-        // performed by the window manager-        return;-    }--    XIconifyWindow( _glfwLibrary.display, _glfwWin.window, _glfwWin.screen );-}---//========================================================================-// Window un-iconification-//========================================================================--void _glfwPlatformRestoreWindow( void )-{-    if( _glfwWin.overrideRedirect )-    {-        // We can't iconify/restore override-redirect windows, as that's-        // performed by the window manager-        return;-    }--    XMapWindow( _glfwLibrary.display, _glfwWin.window );-}---//========================================================================-// Swap OpenGL buffers and poll any new events-//========================================================================--void _glfwPlatformSwapBuffers( void )-{-    // Update display-buffer-    glXSwapBuffers( _glfwLibrary.display, _glfwWin.window );-}---//========================================================================-// Set double buffering swap interval-//========================================================================--void _glfwPlatformSwapInterval( int interval )-{-    if( _glfwWin.has_GLX_SGI_swap_control )-    {-        _glfwWin.SwapIntervalSGI( interval );-    }-}---//========================================================================-// Read back framebuffer parameters from the context-//========================================================================--void _glfwPlatformRefreshWindowParams( void )-{-    int dummy;-    GLXFBConfig *fbconfig;-#if defined( _GLFW_HAS_XRANDR )-    XRRScreenConfiguration *sc;-#elif defined( _GLFW_HAS_XF86VIDMODE )-    XF86VidModeModeLine modeline;-    int dotclock;-    float pixels_per_second, pixels_per_frame;-#endif-    int attribs[] = { GLX_FBCONFIG_ID, _glfwWin.fbconfigID, None };--    if( _glfwWin.has_GLX_SGIX_fbconfig )-    {-        fbconfig = _glfwWin.ChooseFBConfigSGIX( _glfwLibrary.display,-                                                _glfwWin.screen,-                                                attribs,-                                                &dummy );-    }-    else-    {-        fbconfig = glXChooseFBConfig( _glfwLibrary.display,-                                    _glfwWin.screen,-                                    attribs,-                                    &dummy );-    }--    if( fbconfig == NULL )-    {-        // This should never ever happen-        // TODO: Figure out what to do when this happens-        fprintf( stderr, "Cannot find known GLXFBConfig by ID. "-                         "This cannot happen. Have a nice day.\n");-        abort();-    }--    // There is no clear definition of an "accelerated" context on X11/GLX, and-    // true sounds better than false, so we hardcode true here-    _glfwWin.accelerated = GL_TRUE;--    _glfwWin.redBits = getFBConfigAttrib( *fbconfig, GLX_RED_SIZE );-    _glfwWin.greenBits = getFBConfigAttrib( *fbconfig, GLX_GREEN_SIZE );-    _glfwWin.blueBits = getFBConfigAttrib( *fbconfig, GLX_BLUE_SIZE );--    _glfwWin.alphaBits = getFBConfigAttrib( *fbconfig, GLX_ALPHA_SIZE );-    _glfwWin.depthBits = getFBConfigAttrib( *fbconfig, GLX_DEPTH_SIZE );-    _glfwWin.stencilBits = getFBConfigAttrib( *fbconfig, GLX_STENCIL_SIZE );--    _glfwWin.accumRedBits = getFBConfigAttrib( *fbconfig, GLX_ACCUM_RED_SIZE );-    _glfwWin.accumGreenBits = getFBConfigAttrib( *fbconfig, GLX_ACCUM_GREEN_SIZE );-    _glfwWin.accumBlueBits = getFBConfigAttrib( *fbconfig, GLX_ACCUM_BLUE_SIZE );-    _glfwWin.accumAlphaBits = getFBConfigAttrib( *fbconfig, GLX_ACCUM_ALPHA_SIZE );--    _glfwWin.auxBuffers = getFBConfigAttrib( *fbconfig, GLX_AUX_BUFFERS );-    _glfwWin.stereo = getFBConfigAttrib( *fbconfig, GLX_STEREO ) ? 1 : 0;--    // Get FSAA buffer sample count-    if( _glfwWin.has_GLX_ARB_multisample )-    {-        _glfwWin.samples = getFBConfigAttrib( *fbconfig, GLX_SAMPLES );-    }-    else-    {-        _glfwWin.samples = 0;-    }--    // Default to refresh rate unknown (=0 according to GLFW spec)-    _glfwWin.refreshRate = 0;--    // Retrieve refresh rate if possible-#if defined( _GLFW_HAS_XRANDR )-    if( _glfwLibrary.XRandR.available )-    {-        sc = XRRGetScreenInfo( _glfwLibrary.display, _glfwWin.root );-        _glfwWin.refreshRate = XRRConfigCurrentRate( sc );-        XRRFreeScreenConfigInfo( sc );-    }-#elif defined( _GLFW_HAS_XF86VIDMODE )-    if( _glfwLibrary.XF86VidMode.available )-    {-        // Use the XF86VidMode extension to get current video mode-        XF86VidModeGetModeLine( _glfwLibrary.display, _glfwWin.screen,-                                &dotclock, &modeline );-        pixels_per_second = 1000.0f * (float) dotclock;-        pixels_per_frame  = (float) modeline.htotal * modeline.vtotal;-        _glfwWin.refreshRate = (int)(pixels_per_second/pixels_per_frame+0.5);-    }-#endif--    XFree( fbconfig );-}---//========================================================================-// Poll for new window and input events-//========================================================================--void _glfwPlatformPollEvents( void )-{-    GLboolean closeRequested = GL_FALSE;--    // Flag that the cursor has not moved-    _glfwInput.MouseMoved = GL_FALSE;--    // Process all pending events-    while( XPending( _glfwLibrary.display ) )-    {-        if( processSingleEvent() )-        {-            closeRequested = GL_TRUE;-        }-    }--    // Did we get mouse movement in fully enabled hidden cursor mode?-    if( _glfwInput.MouseMoved && _glfwWin.pointerHidden )-    {-        _glfwPlatformSetMouseCursorPos( _glfwWin.width/2,-                                        _glfwWin.height/2 );-    }--    if( closeRequested && _glfwWin.windowCloseCallback )-    {-        closeRequested = _glfwWin.windowCloseCallback();-    }-    if( closeRequested )-    {-        glfwCloseWindow();-    }-}---//========================================================================-// Wait for new window and input events-//========================================================================--void _glfwPlatformWaitEvents( void )-{-    XEvent event;--    // Block waiting for an event to arrive-    XNextEvent( _glfwLibrary.display, &event );-    XPutBackEvent( _glfwLibrary.display, &event );--    _glfwPlatformPollEvents();-}---//========================================================================-// Hide mouse cursor (lock it)-//========================================================================--void _glfwPlatformHideMouseCursor( void )-{-    // Hide cursor-    if( !_glfwWin.pointerHidden )-    {-        XDefineCursor( _glfwLibrary.display, _glfwWin.window, _glfwWin.cursor );-        _glfwWin.pointerHidden = GL_TRUE;-    }--    // Grab cursor to user window-    if( !_glfwWin.pointerGrabbed )-    {-        if( XGrabPointer( _glfwLibrary.display, _glfwWin.window, True,-                          ButtonPressMask | ButtonReleaseMask |-                          PointerMotionMask, GrabModeAsync, GrabModeAsync,-                          _glfwWin.window, None, CurrentTime ) ==-            GrabSuccess )-        {-            _glfwWin.pointerGrabbed = GL_TRUE;-        }-    }-}---//========================================================================-// Show mouse cursor (unlock it)-//========================================================================--void _glfwPlatformShowMouseCursor( void )-{-    // Un-grab cursor (only in windowed mode: in fullscreen mode we still-    // want the mouse grabbed in order to confine the cursor to the window-    // area)-    if( _glfwWin.pointerGrabbed )-    {-        XUngrabPointer( _glfwLibrary.display, CurrentTime );-        _glfwWin.pointerGrabbed = GL_FALSE;-    }--    // Show cursor-    if( _glfwWin.pointerHidden )-    {-        XUndefineCursor( _glfwLibrary.display, _glfwWin.window );-        _glfwWin.pointerHidden = GL_FALSE;-    }-}---//========================================================================-// Set physical mouse cursor position-//========================================================================--void _glfwPlatformSetMouseCursorPos( int x, int y )-{-    // Store the new position so we can recognise it later-    _glfwInput.CursorPosX = x;-    _glfwInput.CursorPosY = y;--    XWarpPointer( _glfwLibrary.display, None, _glfwWin.window, 0,0,0,0, x, y );-}-
− src/Graphics/UI/GLFW.hsc 
@@ -1,1087 +0,0 @@-{-# LANGUAGE ForeignFunctionInterface #-}-{-# LANGUAGE MultiParamTypeClasses    #-}--module Graphics.UI.GLFW-  ( -- *   Initialization and termination-    initialize-  , terminate--    -- *   Video mode information-  , getVideoMode-  , getVideoModes-    ---  , VideoMode(..)--    -- *   OpenGL context-  , OpenGLProfile(..)-    -- **  Information-  , openGLContextIsForwardCompatible-  , openGLContextIsDebugContext-  , openGLProfile--    -- *   Windows-    -- **  Management-  , openWindow-  , closeWindow-  , setWindowTitle-  , setWindowDimensions-  , setWindowPosition-  , iconifyWindow-  , restoreWindow-  , swapBuffers-  , setWindowBufferSwapInterval-    ---  , DisplayMode(..)-  , DisplayOptions(..)-  , defaultDisplayOptions-    -- **  Information-  , windowIsOpen-  , windowIsActive-  , windowIsIconified-  , windowIsResizable-  , windowIsHardwareAccelerated-  , windowSupportsStereoRendering-  , getWindowRefreshRate-  , getWindowDimensions-  , getWindowValue-  , setWindowCloseCallback-  , setWindowSizeCallback-  , setWindowRefreshCallback-    ---  , WindowValue(..)-  , WindowCloseCallback-  , WindowSizeCallback-  , WindowRefreshCallback--    -- *   Input-  , pollEvents-  , waitEvents-  , enableAutoPoll-  , enableKeyRepeat-  , disableKeyRepeat-  , disableAutoPoll-    -- **  Keyboard-  , keyIsPressed-  , setCharCallback-  , setKeyCallback-    ---  , Key(..)-  , CharCallback-  , KeyCallback-    -- **  Mouse-  , mouseButtonIsPressed-  , getMousePosition-  , getMouseWheel-  , setMousePosition-  , setMouseWheel-  , setMouseButtonCallback-  , setMousePositionCallback-  , setMouseWheelCallback-  , enableMouseCursor-  , disableMouseCursor-    ---  , MouseButton(..)-  , MouseButtonCallback-  , MousePositionCallback-  , MouseWheelCallback-    -- **  Joystick-  , joystickIsPresent-  , getJoystickPosition-  , getNumJoystickAxes-  , getNumJoystickButtons-  , joystickButtonsArePressed-    ---  , Joystick(..)--    -- *   Time-  , getTime-  , setTime-  , resetTime-  , sleep--    -- *   Version information-  , getGlfwVersion-  , getGlVersion-  ) where---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----import Control.Monad         (when)-import Data.Char             (chr, ord)-import Data.IORef            (IORef, atomicModifyIORef, newIORef)-import Data.Maybe            (fromJust, isJust)-import Data.Version          (Version(..))-import Foreign.C.String      (CString, withCString)-import Foreign.C.Types       (CDouble(..), CFloat(..), CInt(..), CUChar(..))-import Foreign.Marshal.Alloc (alloca)-import Foreign.Marshal.Array (allocaArray, peekArray)-import Foreign.Ptr           (FunPtr, Ptr, freeHaskellFunPtr)-import Foreign.Storable      (Storable(..))-import System.IO.Unsafe      (unsafePerformIO)---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----#include <GL/glfw.h>--foreign import ccall glfwInit                     :: IO CInt-foreign import ccall glfwTerminate                :: IO ()-foreign import ccall glfwGetVersion               :: Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()--foreign import ccall glfwOpenWindow               :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt-foreign import ccall glfwOpenWindowHint           :: CInt -> CInt -> IO ()-foreign import ccall glfwCloseWindow              :: IO ()-foreign import ccall glfwSetWindowCloseCallback   :: FunPtr GlfwWindowCloseCallback -> IO ()-foreign import ccall glfwSetWindowTitle           :: CString -> IO ()-foreign import ccall glfwSetWindowSize            :: CInt -> CInt -> IO ()-foreign import ccall glfwSetWindowPos             :: CInt -> CInt -> IO ()-foreign import ccall glfwGetWindowSize            :: Ptr CInt -> Ptr CInt -> IO ()-foreign import ccall glfwSetWindowSizeCallback    :: FunPtr GlfwWindowSizeCallback -> IO ()-foreign import ccall glfwIconifyWindow            :: IO ()-foreign import ccall glfwRestoreWindow            :: IO ()-foreign import ccall glfwGetWindowParam           :: CInt -> IO CInt-foreign import ccall glfwSwapBuffers              :: IO ()-foreign import ccall glfwSwapInterval             :: CInt -> IO ()-foreign import ccall glfwSetWindowRefreshCallback :: FunPtr GlfwWindowRefreshCallback -> IO ()--foreign import ccall glfwGetVideoModes            :: Ptr VideoMode -> CInt -> IO CInt-foreign import ccall glfwGetDesktopMode           :: Ptr VideoMode -> IO ()--foreign import ccall glfwPollEvents               :: IO ()-foreign import ccall glfwWaitEvents               :: IO ()-foreign import ccall glfwGetKey                   :: CInt -> IO CInt-foreign import ccall glfwGetMouseButton           :: CInt -> IO CInt-foreign import ccall glfwGetMousePos              :: Ptr CInt -> Ptr CInt -> IO ()-foreign import ccall glfwSetMousePos              :: CInt -> CInt -> IO ()-foreign import ccall glfwGetMouseWheel            :: IO CInt-foreign import ccall glfwSetMouseWheel            :: CInt -> IO ()-foreign import ccall glfwSetKeyCallback           :: FunPtr GlfwKeyCallback -> IO ()-foreign import ccall glfwSetCharCallback          :: FunPtr GlfwCharCallback -> IO ()-foreign import ccall glfwSetMouseButtonCallback   :: FunPtr GlfwMouseButtonCallback -> IO ()-foreign import ccall glfwSetMousePosCallback      :: FunPtr GlfwMousePositionCallback -> IO ()-foreign import ccall glfwSetMouseWheelCallback    :: FunPtr GlfwMouseWheelCallback -> IO ()-foreign import ccall glfwGetJoystickParam         :: CInt -> CInt -> IO CInt-foreign import ccall glfwGetJoystickPos           :: CInt -> Ptr CFloat -> CInt -> IO CInt-foreign import ccall glfwGetJoystickButtons       :: CInt -> Ptr CUChar -> CInt -> IO CInt--foreign import ccall glfwGetTime                  :: IO CDouble-foreign import ccall glfwSetTime                  :: CDouble -> IO ()-foreign import ccall glfwSleep                    :: CDouble -> IO ()--foreign import ccall glfwGetGLVersion             :: Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()--foreign import ccall glfwEnable                   :: CInt -> IO ()-foreign import ccall glfwDisable                  :: CInt -> IO ()--type GlfwCharCallback          = CInt -> CInt -> IO ()-type GlfwKeyCallback           = CInt -> CInt -> IO ()-type GlfwMouseButtonCallback   = CInt -> CInt -> IO ()-type GlfwMousePositionCallback = CInt -> CInt -> IO ()-type GlfwMouseWheelCallback    = CInt         -> IO ()-type GlfwWindowCloseCallback   =                 IO CInt-type GlfwWindowRefreshCallback =                 IO ()-type GlfwWindowSizeCallback    = CInt -> CInt -> IO ()--type CharCallback          = Char -> Bool        -> IO ()-type KeyCallback           = Key -> Bool         -> IO ()-type MouseButtonCallback   = MouseButton -> Bool -> IO ()-type MousePositionCallback = Int -> Int          -> IO ()-type MouseWheelCallback    = Int                 -> IO ()-type WindowCloseCallback   =                        IO Bool-type WindowRefreshCallback =                        IO ()-type WindowSizeCallback    = Int -> Int          -> IO ()--foreign import ccall "wrapper" wrapCharCallback          :: GlfwCharCallback          -> IO (FunPtr GlfwCharCallback)-foreign import ccall "wrapper" wrapKeyCallback           :: GlfwKeyCallback           -> IO (FunPtr GlfwKeyCallback)-foreign import ccall "wrapper" wrapMouseButtonCallback   :: GlfwMouseButtonCallback   -> IO (FunPtr GlfwMouseButtonCallback)-foreign import ccall "wrapper" wrapMousePositionCallback :: GlfwMousePositionCallback -> IO (FunPtr GlfwMousePositionCallback)-foreign import ccall "wrapper" wrapMouseWheelCallback    :: GlfwMouseWheelCallback    -> IO (FunPtr GlfwMouseWheelCallback)-foreign import ccall "wrapper" wrapWindowCloseCallback   :: GlfwWindowCloseCallback   -> IO (FunPtr GlfwWindowCloseCallback)-foreign import ccall "wrapper" wrapWindowRefreshCallback :: GlfwWindowRefreshCallback -> IO (FunPtr GlfwWindowRefreshCallback)-foreign import ccall "wrapper" wrapWindowSizeCallback    :: GlfwWindowSizeCallback    -> IO (FunPtr GlfwWindowSizeCallback)---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- Initialization and termination--initialize :: IO Bool-initialize =-    fromC `fmap` glfwInit--terminate :: IO ()-terminate =-    glfwTerminate---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- Video mode information--getVideoMode :: IO VideoMode-getVideoMode =-    alloca $ \ptr -> do-        glfwGetDesktopMode ptr-        peek ptr--getVideoModes :: IO [VideoMode]-getVideoModes =-    allocaArray m $ \ptr -> do-        n <- glfwGetVideoModes ptr (toC m)-        peekArray (fromC n) ptr-  where-    m = 256---- -- -- -- -- -- -- -- -- ----data VideoMode = VideoMode-  { videoMode_width        :: Int-  , videoMode_height       :: Int-  , videoMode_numRedBits   :: Int-  , videoMode_numGreenBits :: Int-  , videoMode_numBlueBits  :: Int-  } deriving (Eq, Ord, Read, Show)--instance Storable VideoMode where-  sizeOf    _ = (#const sizeof(GLFWvidmode))-  alignment _ = alignment (undefined :: CInt)--  peek ptr = do-      w <- (#peek GLFWvidmode, Width)     ptr :: IO CInt-      h <- (#peek GLFWvidmode, Height)    ptr :: IO CInt-      r <- (#peek GLFWvidmode, RedBits)   ptr :: IO CInt-      g <- (#peek GLFWvidmode, GreenBits) ptr :: IO CInt-      b <- (#peek GLFWvidmode, BlueBits)  ptr :: IO CInt-      return VideoMode-        { videoMode_width        = fromC w-        , videoMode_height       = fromC h-        , videoMode_numRedBits   = fromC r-        , videoMode_numGreenBits = fromC g-        , videoMode_numBlueBits  = fromC b-        }---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- OpenGL context--data OpenGLProfile-  = DefaultProfile-  | CoreProfile-  | CompatibilityProfile-  deriving (Eq, Ord, Bounded, Enum, Read, Show)--instance C OpenGLProfile CInt where-  toC op = case op of-      DefaultProfile       -> 0-      CoreProfile          -> #const GLFW_OPENGL_CORE_PROFILE-      CompatibilityProfile -> #const GLFW_OPENGL_COMPAT_PROFILE-  fromC i = case i of-      (#const GLFW_OPENGL_CORE_PROFILE)   -> CoreProfile-      (#const GLFW_OPENGL_COMPAT_PROFILE) -> CompatibilityProfile-      (0)                                 -> DefaultProfile-      _                                   -> makeFromCError "OpenGLProfile" i---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- OpenGL information--openGLContextIsForwardCompatible :: IO Bool-openGLContextIsForwardCompatible =-    fromC `fmap` glfwGetWindowParam (#const GLFW_OPENGL_FORWARD_COMPAT)--openGLContextIsDebugContext :: IO Bool-openGLContextIsDebugContext =-    fromC `fmap` glfwGetWindowParam (#const GLFW_OPENGL_DEBUG_CONTEXT)--openGLProfile :: IO OpenGLProfile-openGLProfile =-    fromC `fmap` glfwGetWindowParam (#const GLFW_OPENGL_PROFILE)---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- Window management--openWindow :: DisplayOptions -> IO Bool-openWindow displayOptions = do-    let DisplayOptions-          { displayOptions_width                   = _displayOptions_width-          , displayOptions_height                  = _displayOptions_height-          , displayOptions_numRedBits              = _displayOptions_numRedBits-          , displayOptions_numGreenBits            = _displayOptions_numGreenBits-          , displayOptions_numBlueBits             = _displayOptions_numBlueBits-          , displayOptions_numAlphaBits            = _displayOptions_numAlphaBits-          , displayOptions_numDepthBits            = _displayOptions_numDepthBits-          , displayOptions_numStencilBits          = _displayOptions_numStencilBits-          , displayOptions_displayMode             = _displayOptions_displayMode-          , displayOptions_refreshRate             = _displayOptions_refreshRate-          , displayOptions_accumNumRedBits         = _displayOptions_accumNumRedBits-          , displayOptions_accumNumGreenBits       = _displayOptions_accumNumGreenBits-          , displayOptions_accumNumBlueBits        = _displayOptions_accumNumBlueBits-          , displayOptions_accumNumAlphaBits       = _displayOptions_accumNumAlphaBits-          , displayOptions_numAuxiliaryBuffers     = _displayOptions_numAuxiliaryBuffers-          , displayOptions_numFsaaSamples          = _displayOptions_numFsaaSamples-          , displayOptions_windowIsResizable       = _displayOptions_windowIsResizable-          , displayOptions_stereoRendering         = _displayOptions_stereoRendering-          , displayOptions_openGLVersion           = _displayOptions_openGLVersion-          , displayOptions_openGLForwardCompatible = _displayOptions_openGLForwardCompatible-          , displayOptions_openGLDebugContext      = _displayOptions_openGLDebugContext-          , displayOptions_openGLProfile           = _displayOptions_openGLProfile-          } = displayOptions--    -- Add hints.-    when (isJust _displayOptions_refreshRate)              $ glfwOpenWindowHint (#const GLFW_REFRESH_RATE)     (toC (fromJust _displayOptions_refreshRate))-    when (isJust _displayOptions_accumNumRedBits)          $ glfwOpenWindowHint (#const GLFW_ACCUM_RED_BITS)   (toC (fromJust _displayOptions_accumNumRedBits))-    when (isJust _displayOptions_accumNumGreenBits)        $ glfwOpenWindowHint (#const GLFW_ACCUM_GREEN_BITS) (toC (fromJust _displayOptions_accumNumGreenBits))-    when (isJust _displayOptions_accumNumBlueBits)         $ glfwOpenWindowHint (#const GLFW_ACCUM_BLUE_BITS)  (toC (fromJust _displayOptions_accumNumBlueBits))-    when (isJust _displayOptions_accumNumAlphaBits)        $ glfwOpenWindowHint (#const GLFW_ACCUM_ALPHA_BITS) (toC (fromJust _displayOptions_accumNumAlphaBits))-    when (isJust _displayOptions_numAuxiliaryBuffers)      $ glfwOpenWindowHint (#const GLFW_AUX_BUFFERS)      (toC (fromJust _displayOptions_numAuxiliaryBuffers))-    when (isJust _displayOptions_numFsaaSamples)           $ glfwOpenWindowHint (#const GLFW_FSAA_SAMPLES)     (toC (fromJust _displayOptions_numFsaaSamples))--    glfwOpenWindowHint (#const GLFW_WINDOW_NO_RESIZE)      (toC (not _displayOptions_windowIsResizable))-    glfwOpenWindowHint (#const GLFW_STEREO)                (toC      _displayOptions_stereoRendering)-    glfwOpenWindowHint (#const GLFW_OPENGL_VERSION_MAJOR)  (toC (fst _displayOptions_openGLVersion))-    glfwOpenWindowHint (#const GLFW_OPENGL_VERSION_MINOR)  (toC (snd _displayOptions_openGLVersion))-    glfwOpenWindowHint (#const GLFW_OPENGL_FORWARD_COMPAT) (toC _displayOptions_openGLForwardCompatible)-    glfwOpenWindowHint (#const GLFW_OPENGL_DEBUG_CONTEXT)  (toC _displayOptions_openGLDebugContext)-    glfwOpenWindowHint (#const GLFW_OPENGL_PROFILE)        (toC _displayOptions_openGLProfile)--    -- Open the window.-    fromC `fmap` glfwOpenWindow-      (toC _displayOptions_width)-      (toC _displayOptions_height)-      (toC _displayOptions_numRedBits)-      (toC _displayOptions_numGreenBits)-      (toC _displayOptions_numBlueBits)-      (toC _displayOptions_numAlphaBits)-      (toC _displayOptions_numDepthBits)-      (toC _displayOptions_numStencilBits)-      (toC _displayOptions_displayMode)--closeWindow :: IO ()-closeWindow =-    glfwCloseWindow--setWindowTitle :: String -> IO ()-setWindowTitle t =-    withCString t glfwSetWindowTitle--setWindowDimensions :: Int -> Int -> IO ()-setWindowDimensions w h =-    glfwSetWindowSize (toC w) (toC h)--setWindowPosition :: Int -> Int -> IO ()-setWindowPosition w h =-    glfwSetWindowPos (toC w) (toC h)--iconifyWindow :: IO ()-iconifyWindow =-    glfwIconifyWindow--restoreWindow :: IO ()-restoreWindow =-    glfwRestoreWindow--swapBuffers :: IO ()-swapBuffers =-    glfwSwapBuffers--setWindowBufferSwapInterval :: Int -> IO ()-setWindowBufferSwapInterval =-    glfwSwapInterval . toC---- -- -- -- -- -- -- -- -- ----data DisplayMode-  = Window-  | Fullscreen-  deriving (Eq, Ord, Bounded, Enum, Read, Show)--instance C DisplayMode CInt where-  toC dm = case dm of-      Window     -> #const GLFW_WINDOW-      Fullscreen -> #const GLFW_FULLSCREEN--  fromC i = case i of-      (#const GLFW_WINDOW    ) -> Window-      (#const GLFW_FULLSCREEN) -> Fullscreen-      _                        -> makeFromCError "DisplayMode" i---- -- -- -- -- -- -- -- -- ----data DisplayOptions = DisplayOptions-  { displayOptions_width                   :: Int-  , displayOptions_height                  :: Int-  , displayOptions_numRedBits              :: Int-  , displayOptions_numGreenBits            :: Int-  , displayOptions_numBlueBits             :: Int-  , displayOptions_numAlphaBits            :: Int-  , displayOptions_numDepthBits            :: Int-  , displayOptions_numStencilBits          :: Int-  , displayOptions_displayMode             :: DisplayMode-  , displayOptions_refreshRate             :: Maybe Int-  , displayOptions_accumNumRedBits         :: Maybe Int-  , displayOptions_accumNumGreenBits       :: Maybe Int-  , displayOptions_accumNumBlueBits        :: Maybe Int-  , displayOptions_accumNumAlphaBits       :: Maybe Int-  , displayOptions_numAuxiliaryBuffers     :: Maybe Int-  , displayOptions_numFsaaSamples          :: Maybe Int-  , displayOptions_windowIsResizable       :: Bool-  , displayOptions_stereoRendering         :: Bool-  , displayOptions_openGLVersion           :: (Int, Int)-  , displayOptions_openGLForwardCompatible :: Bool-  , displayOptions_openGLDebugContext      :: Bool-  , displayOptions_openGLProfile           :: OpenGLProfile--  } deriving (Eq, Ord, Read, Show)--defaultDisplayOptions :: DisplayOptions-defaultDisplayOptions =-    DisplayOptions-      { displayOptions_width                   = 0-      , displayOptions_height                  = 0-      , displayOptions_numRedBits              = 0-      , displayOptions_numGreenBits            = 0-      , displayOptions_numBlueBits             = 0-      , displayOptions_numAlphaBits            = 0-      , displayOptions_numDepthBits            = 0-      , displayOptions_numStencilBits          = 0-      , displayOptions_displayMode             = Window-      , displayOptions_refreshRate             = Nothing-      , displayOptions_accumNumRedBits         = Nothing-      , displayOptions_accumNumGreenBits       = Nothing-      , displayOptions_accumNumBlueBits        = Nothing-      , displayOptions_accumNumAlphaBits       = Nothing-      , displayOptions_numAuxiliaryBuffers     = Nothing-      , displayOptions_numFsaaSamples          = Nothing-      , displayOptions_windowIsResizable       = True-      , displayOptions_stereoRendering         = False-      , displayOptions_openGLVersion           = (1,1)-      , displayOptions_openGLForwardCompatible = False-      , displayOptions_openGLDebugContext      = False-      , displayOptions_openGLProfile           = DefaultProfile-      }---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- Window information--windowIsOpen :: IO Bool-windowIsOpen =-    fromC `fmap` glfwGetWindowParam (#const GLFW_OPENED)--windowIsActive :: IO Bool-windowIsActive =-    fromC `fmap` glfwGetWindowParam (#const GLFW_ACTIVE)--windowIsIconified :: IO Bool-windowIsIconified =-    fromC `fmap` glfwGetWindowParam (#const GLFW_ICONIFIED)--windowIsResizable :: IO Bool-windowIsResizable =-    (not . fromC) `fmap` glfwGetWindowParam (#const GLFW_WINDOW_NO_RESIZE)--windowIsHardwareAccelerated :: IO Bool-windowIsHardwareAccelerated =-    fromC `fmap` glfwGetWindowParam (#const GLFW_ACCELERATED)--windowSupportsStereoRendering :: IO Bool-windowSupportsStereoRendering =-    fromC `fmap` glfwGetWindowParam (#const GLFW_STEREO)--getWindowRefreshRate :: IO Int-getWindowRefreshRate =-    fromC `fmap` glfwGetWindowParam (#const GLFW_REFRESH_RATE)--getWindowDimensions :: IO (Int, Int)-getWindowDimensions =-    alloca $ \wp ->-    alloca $ \hp -> do-        glfwGetWindowSize wp hp-        w <- peek wp-        h <- peek hp-        return (fromC w, fromC h)--getWindowValue :: WindowValue -> IO Int-getWindowValue wn =-    fromC `fmap` glfwGetWindowParam (toC wn)--setWindowCloseCallback :: WindowCloseCallback -> IO ()-setWindowCloseCallback cb = do-    ccb <- wrapWindowCloseCallback (toC `fmap` cb)-    glfwSetWindowCloseCallback ccb-    storeCallback windowCloseCallback ccb--setWindowSizeCallback :: WindowSizeCallback -> IO ()-setWindowSizeCallback cb = do-    ccb <- wrapWindowSizeCallback (\w h -> cb (fromC w) (fromC h))-    glfwSetWindowSizeCallback ccb-    storeCallback windowSizeCallback ccb--setWindowRefreshCallback :: WindowRefreshCallback -> IO ()-setWindowRefreshCallback cb = do-    ccb <- wrapWindowRefreshCallback cb-    glfwSetWindowRefreshCallback ccb-    storeCallback windowRefreshCallback ccb---- -- -- -- -- -- -- -- -- ----data WindowValue-  = NumRedBits-  | NumGreenBits-  | NumBlueBits-  | NumAlphaBits-  | NumDepthBits-  | NumStencilBits-  | NumAccumRedBits-  | NumAccumGreenBits-  | NumAccumBlueBits-  | NumAccumAlphaBits-  | NumAuxBuffers-  | NumFsaaSamples-  deriving (Eq, Ord, Bounded, Enum, Read, Show)--instance C WindowValue CInt where-  toC wn = case wn of-      NumRedBits        -> #const GLFW_RED_BITS-      NumGreenBits      -> #const GLFW_GREEN_BITS-      NumBlueBits       -> #const GLFW_BLUE_BITS-      NumAlphaBits      -> #const GLFW_ALPHA_BITS-      NumDepthBits      -> #const GLFW_DEPTH_BITS-      NumStencilBits    -> #const GLFW_STENCIL_BITS-      NumAccumRedBits   -> #const GLFW_ACCUM_RED_BITS-      NumAccumGreenBits -> #const GLFW_ACCUM_GREEN_BITS-      NumAccumBlueBits  -> #const GLFW_ACCUM_BLUE_BITS-      NumAccumAlphaBits -> #const GLFW_ACCUM_ALPHA_BITS-      NumAuxBuffers     -> #const GLFW_AUX_BUFFERS-      NumFsaaSamples    -> #const GLFW_FSAA_SAMPLES---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- Input--pollEvents :: IO ()-pollEvents =-    glfwPollEvents--waitEvents :: IO ()-waitEvents =-    glfwWaitEvents---- Make 'swapBuffers' implicitly call 'pollEvents' (Default)-enableAutoPoll :: IO ()-enableAutoPoll = glfwEnable (#const GLFW_AUTO_POLL_EVENTS)---- Disable 'swapBuffers' implicitly calling 'pollEvents'-disableAutoPoll :: IO ()-disableAutoPoll = glfwDisable (#const GLFW_AUTO_POLL_EVENTS)--enableKeyRepeat :: IO ()-enableKeyRepeat = glfwEnable (#const GLFW_KEY_REPEAT)--disableKeyRepeat :: IO ()-disableKeyRepeat = glfwDisable (#const GLFW_KEY_REPEAT)---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- Keyboard--keyIsPressed :: Key -> IO Bool-keyIsPressed k =-    fromC `fmap` glfwGetKey (toC k)--setCharCallback :: CharCallback -> IO ()-setCharCallback cb = do-    ccb <- wrapCharCallback (\c b -> cb (fromC c) (fromC b))-    glfwSetCharCallback ccb-    storeCallback charCallback ccb--setKeyCallback :: KeyCallback -> IO ()-setKeyCallback cb = do-    ccb <- wrapKeyCallback (\k b -> cb (fromC k) (fromC b))-    glfwSetKeyCallback ccb-    storeCallback keyCallback ccb---- -- -- -- -- -- -- -- -- ----data Key-  = CharKey Char-  | KeyUnknown-  | KeySpace-  | KeySpecial-  | KeyEsc-  | KeyF1-  | KeyF2-  | KeyF3-  | KeyF4-  | KeyF5-  | KeyF6-  | KeyF7-  | KeyF8-  | KeyF9-  | KeyF10-  | KeyF11-  | KeyF12-  | KeyF13-  | KeyF14-  | KeyF15-  | KeyF16-  | KeyF17-  | KeyF18-  | KeyF19-  | KeyF20-  | KeyF21-  | KeyF22-  | KeyF23-  | KeyF24-  | KeyF25-  | KeyUp-  | KeyDown-  | KeyLeft-  | KeyRight-  | KeyLeftShift-  | KeyRightShift-  | KeyLeftCtrl-  | KeyRightCtrl-  | KeyLeftAlt-  | KeyRightAlt-  | KeyTab-  | KeyEnter-  | KeyBackspace-  | KeyInsert-  | KeyDel-  | KeyPageup-  | KeyPagedown-  | KeyHome-  | KeyEnd-  | KeyPad0-  | KeyPad1-  | KeyPad2-  | KeyPad3-  | KeyPad4-  | KeyPad5-  | KeyPad6-  | KeyPad7-  | KeyPad8-  | KeyPad9-  | KeyPadDivide-  | KeyPadMultiply-  | KeyPadSubtract-  | KeyPadAdd-  | KeyPadDecimal-  | KeyPadEqual-  | KeyPadEnter-  deriving (Eq, Ord, Read, Show)--instance C Key CInt where-  toC k = case k of-      CharKey c      -> fromIntegral (ord c)-      KeyUnknown     -> #const GLFW_KEY_UNKNOWN-      KeySpace       -> #const GLFW_KEY_SPACE-      KeySpecial     -> #const GLFW_KEY_SPECIAL-      KeyEsc         -> #const GLFW_KEY_ESC-      KeyF1          -> #const GLFW_KEY_F1-      KeyF2          -> #const GLFW_KEY_F2-      KeyF3          -> #const GLFW_KEY_F3-      KeyF4          -> #const GLFW_KEY_F4-      KeyF5          -> #const GLFW_KEY_F5-      KeyF6          -> #const GLFW_KEY_F6-      KeyF7          -> #const GLFW_KEY_F7-      KeyF8          -> #const GLFW_KEY_F8-      KeyF9          -> #const GLFW_KEY_F9-      KeyF10         -> #const GLFW_KEY_F10-      KeyF11         -> #const GLFW_KEY_F11-      KeyF12         -> #const GLFW_KEY_F12-      KeyF13         -> #const GLFW_KEY_F13-      KeyF14         -> #const GLFW_KEY_F14-      KeyF15         -> #const GLFW_KEY_F15-      KeyF16         -> #const GLFW_KEY_F16-      KeyF17         -> #const GLFW_KEY_F17-      KeyF18         -> #const GLFW_KEY_F18-      KeyF19         -> #const GLFW_KEY_F19-      KeyF20         -> #const GLFW_KEY_F20-      KeyF21         -> #const GLFW_KEY_F21-      KeyF22         -> #const GLFW_KEY_F22-      KeyF23         -> #const GLFW_KEY_F23-      KeyF24         -> #const GLFW_KEY_F24-      KeyF25         -> #const GLFW_KEY_F25-      KeyUp          -> #const GLFW_KEY_UP-      KeyDown        -> #const GLFW_KEY_DOWN-      KeyLeft        -> #const GLFW_KEY_LEFT-      KeyRight       -> #const GLFW_KEY_RIGHT-      KeyLeftShift   -> #const GLFW_KEY_LSHIFT-      KeyRightShift  -> #const GLFW_KEY_RSHIFT-      KeyLeftCtrl    -> #const GLFW_KEY_LCTRL-      KeyRightCtrl   -> #const GLFW_KEY_RCTRL-      KeyLeftAlt     -> #const GLFW_KEY_LALT-      KeyRightAlt    -> #const GLFW_KEY_RALT-      KeyTab         -> #const GLFW_KEY_TAB-      KeyEnter       -> #const GLFW_KEY_ENTER-      KeyBackspace   -> #const GLFW_KEY_BACKSPACE-      KeyInsert      -> #const GLFW_KEY_INSERT-      KeyDel         -> #const GLFW_KEY_DEL-      KeyPageup      -> #const GLFW_KEY_PAGEUP-      KeyPagedown    -> #const GLFW_KEY_PAGEDOWN-      KeyHome        -> #const GLFW_KEY_HOME-      KeyEnd         -> #const GLFW_KEY_END-      KeyPad0        -> #const GLFW_KEY_KP_0-      KeyPad1        -> #const GLFW_KEY_KP_1-      KeyPad2        -> #const GLFW_KEY_KP_2-      KeyPad3        -> #const GLFW_KEY_KP_3-      KeyPad4        -> #const GLFW_KEY_KP_4-      KeyPad5        -> #const GLFW_KEY_KP_5-      KeyPad6        -> #const GLFW_KEY_KP_6-      KeyPad7        -> #const GLFW_KEY_KP_7-      KeyPad8        -> #const GLFW_KEY_KP_8-      KeyPad9        -> #const GLFW_KEY_KP_9-      KeyPadDivide   -> #const GLFW_KEY_KP_DIVIDE-      KeyPadMultiply -> #const GLFW_KEY_KP_MULTIPLY-      KeyPadSubtract -> #const GLFW_KEY_KP_SUBTRACT-      KeyPadAdd      -> #const GLFW_KEY_KP_ADD-      KeyPadDecimal  -> #const GLFW_KEY_KP_DECIMAL-      KeyPadEqual    -> #const GLFW_KEY_KP_EQUAL-      KeyPadEnter    -> #const GLFW_KEY_KP_ENTER--  fromC i =-      if i < #const GLFW_KEY_SPECIAL-        then CharKey (chr (fromIntegral i))-        else case i of-               (#const GLFW_KEY_UNKNOWN    ) -> KeyUnknown-               (#const GLFW_KEY_SPACE      ) -> KeySpace-               (#const GLFW_KEY_SPECIAL    ) -> KeySpecial-               (#const GLFW_KEY_ESC        ) -> KeyEsc-               (#const GLFW_KEY_F1         ) -> KeyF1-               (#const GLFW_KEY_F2         ) -> KeyF2-               (#const GLFW_KEY_F3         ) -> KeyF3-               (#const GLFW_KEY_F4         ) -> KeyF4-               (#const GLFW_KEY_F5         ) -> KeyF5-               (#const GLFW_KEY_F6         ) -> KeyF6-               (#const GLFW_KEY_F7         ) -> KeyF7-               (#const GLFW_KEY_F8         ) -> KeyF8-               (#const GLFW_KEY_F9         ) -> KeyF9-               (#const GLFW_KEY_F10        ) -> KeyF10-               (#const GLFW_KEY_F11        ) -> KeyF11-               (#const GLFW_KEY_F12        ) -> KeyF12-               (#const GLFW_KEY_F13        ) -> KeyF13-               (#const GLFW_KEY_F14        ) -> KeyF14-               (#const GLFW_KEY_F15        ) -> KeyF15-               (#const GLFW_KEY_F16        ) -> KeyF16-               (#const GLFW_KEY_F17        ) -> KeyF17-               (#const GLFW_KEY_F18        ) -> KeyF18-               (#const GLFW_KEY_F19        ) -> KeyF19-               (#const GLFW_KEY_F20        ) -> KeyF20-               (#const GLFW_KEY_F21        ) -> KeyF21-               (#const GLFW_KEY_F22        ) -> KeyF22-               (#const GLFW_KEY_F23        ) -> KeyF23-               (#const GLFW_KEY_F24        ) -> KeyF24-               (#const GLFW_KEY_F25        ) -> KeyF25-               (#const GLFW_KEY_UP         ) -> KeyUp-               (#const GLFW_KEY_DOWN       ) -> KeyDown-               (#const GLFW_KEY_LEFT       ) -> KeyLeft-               (#const GLFW_KEY_RIGHT      ) -> KeyRight-               (#const GLFW_KEY_LSHIFT     ) -> KeyLeftShift-               (#const GLFW_KEY_RSHIFT     ) -> KeyRightShift-               (#const GLFW_KEY_LCTRL      ) -> KeyLeftCtrl-               (#const GLFW_KEY_RCTRL      ) -> KeyRightCtrl-               (#const GLFW_KEY_LALT       ) -> KeyLeftAlt-               (#const GLFW_KEY_RALT       ) -> KeyRightAlt-               (#const GLFW_KEY_TAB        ) -> KeyTab-               (#const GLFW_KEY_ENTER      ) -> KeyEnter-               (#const GLFW_KEY_BACKSPACE  ) -> KeyBackspace-               (#const GLFW_KEY_INSERT     ) -> KeyInsert-               (#const GLFW_KEY_DEL        ) -> KeyDel-               (#const GLFW_KEY_PAGEUP     ) -> KeyPageup-               (#const GLFW_KEY_PAGEDOWN   ) -> KeyPagedown-               (#const GLFW_KEY_HOME       ) -> KeyHome-               (#const GLFW_KEY_END        ) -> KeyEnd-               (#const GLFW_KEY_KP_0       ) -> KeyPad0-               (#const GLFW_KEY_KP_1       ) -> KeyPad1-               (#const GLFW_KEY_KP_2       ) -> KeyPad2-               (#const GLFW_KEY_KP_3       ) -> KeyPad3-               (#const GLFW_KEY_KP_4       ) -> KeyPad4-               (#const GLFW_KEY_KP_5       ) -> KeyPad5-               (#const GLFW_KEY_KP_6       ) -> KeyPad6-               (#const GLFW_KEY_KP_7       ) -> KeyPad7-               (#const GLFW_KEY_KP_8       ) -> KeyPad8-               (#const GLFW_KEY_KP_9       ) -> KeyPad9-               (#const GLFW_KEY_KP_DIVIDE  ) -> KeyPadDivide-               (#const GLFW_KEY_KP_MULTIPLY) -> KeyPadMultiply-               (#const GLFW_KEY_KP_SUBTRACT) -> KeyPadSubtract-               (#const GLFW_KEY_KP_ADD     ) -> KeyPadAdd-               (#const GLFW_KEY_KP_DECIMAL ) -> KeyPadDecimal-               (#const GLFW_KEY_KP_EQUAL   ) -> KeyPadEqual-               (#const GLFW_KEY_KP_ENTER   ) -> KeyPadEnter-               _                             -> KeyUnknown---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- Mouse--mouseButtonIsPressed :: MouseButton -> IO Bool-mouseButtonIsPressed mb =-    fromC `fmap` glfwGetMouseButton (toC mb)--getMousePosition :: IO (Int, Int)-getMousePosition =-    alloca $ \px ->-    alloca $ \py -> do-        glfwGetMousePos px py-        x <- peek px-        y <- peek py-        return (fromC x, fromC y)--getMouseWheel :: IO Int-getMouseWheel =-    fromC `fmap` glfwGetMouseWheel--setMousePosition :: Int -> Int -> IO ()-setMousePosition x y =-    glfwSetMousePos (toC x) (toC y)--setMouseWheel :: Int -> IO ()-setMouseWheel =-    glfwSetMouseWheel . toC--setMouseButtonCallback :: MouseButtonCallback -> IO ()-setMouseButtonCallback cb = do-    ccb <- wrapMouseButtonCallback (\b p -> cb (fromC b) (fromC p))-    glfwSetMouseButtonCallback ccb-    storeCallback mouseButtonCallback ccb--setMousePositionCallback :: MousePositionCallback -> IO ()-setMousePositionCallback cb = do-    ccb <- wrapMousePositionCallback (\x y -> cb (fromC x) (fromC y))-    glfwSetMousePosCallback ccb-    storeCallback mousePositionCallback ccb--setMouseWheelCallback :: MouseWheelCallback -> IO ()-setMouseWheelCallback cb = do-    ccb <- wrapMouseWheelCallback (cb . fromC)-    glfwSetMouseWheelCallback ccb-    storeCallback mouseWheelCallback ccb---- |Make the mouse cursor visible.-enableMouseCursor :: IO ()-enableMouseCursor = glfwEnable (#const GLFW_MOUSE_CURSOR)---- |Make the mouse cursor invisible.-disableMouseCursor :: IO ()-disableMouseCursor = glfwDisable (#const GLFW_MOUSE_CURSOR)---- -- -- -- -- -- -- -- -- ----data MouseButton-  = MouseButton0 | MouseButton1 | MouseButton2 | MouseButton3-  | MouseButton4 | MouseButton5 | MouseButton6 | MouseButton7-  deriving (Bounded, Enum, Eq, Ord, Read, Show)--instance C MouseButton CInt where-  toC mb = case mb of-      MouseButton0 -> #const GLFW_MOUSE_BUTTON_1-      MouseButton1 -> #const GLFW_MOUSE_BUTTON_2-      MouseButton2 -> #const GLFW_MOUSE_BUTTON_3-      MouseButton3 -> #const GLFW_MOUSE_BUTTON_4-      MouseButton4 -> #const GLFW_MOUSE_BUTTON_5-      MouseButton5 -> #const GLFW_MOUSE_BUTTON_6-      MouseButton6 -> #const GLFW_MOUSE_BUTTON_7-      MouseButton7 -> #const GLFW_MOUSE_BUTTON_8--  fromC i = case i of-      (#const GLFW_MOUSE_BUTTON_1) -> MouseButton0-      (#const GLFW_MOUSE_BUTTON_2) -> MouseButton1-      (#const GLFW_MOUSE_BUTTON_3) -> MouseButton2-      (#const GLFW_MOUSE_BUTTON_4) -> MouseButton3-      (#const GLFW_MOUSE_BUTTON_5) -> MouseButton4-      (#const GLFW_MOUSE_BUTTON_6) -> MouseButton5-      (#const GLFW_MOUSE_BUTTON_7) -> MouseButton6-      (#const GLFW_MOUSE_BUTTON_8) -> MouseButton7-      _                            -> makeFromCError "MouseButton" i---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- Joystick--joystickIsPresent :: Joystick -> IO Bool-joystickIsPresent j =-    fromC `fmap` glfwGetJoystickParam (toC j) (#const GLFW_PRESENT)--getNumJoystickAxes :: Joystick -> IO Int-getNumJoystickAxes j =-    fromC `fmap` glfwGetJoystickParam (toC j) (#const GLFW_AXES)--getNumJoystickButtons :: Joystick -> IO Int-getNumJoystickButtons j =-    fromC `fmap` glfwGetJoystickParam (toC j) (#const GLFW_BUTTONS)--getJoystickPosition :: Joystick -> Int -> IO [Float]-getJoystickPosition j m =-    if m < 1-      then return []-      else allocaArray m $ \ptr -> do-               n <- fromC `fmap` glfwGetJoystickPos (toC j) ptr (toC m)-               a <- peekArray n ptr-               return $ map fromC a--joystickButtonsArePressed :: Joystick -> Int -> IO [Bool]-joystickButtonsArePressed j m =-    if m < 1-      then return []-      else allocaArray m $ \ptr -> do-               n <- fromC `fmap` glfwGetJoystickButtons (toC j) ptr (toC m)-               a <- peekArray n ptr :: IO [CUChar]-               return $ map ((glfwPress ==) . fromIntegral) a---- -- -- -- -- -- -- -- -- ----data Joystick-  = Joystick0  | Joystick1  | Joystick2  | Joystick3-  | Joystick4  | Joystick5  | Joystick6  | Joystick7-  | Joystick8  | Joystick9  | Joystick10 | Joystick11-  | Joystick12 | Joystick13 | Joystick14 | Joystick15-  deriving (Bounded, Enum, Eq, Ord, Read, Show)--instance C Joystick CInt where-  toC j = case j of-      Joystick0  -> #const GLFW_JOYSTICK_1-      Joystick1  -> #const GLFW_JOYSTICK_2-      Joystick2  -> #const GLFW_JOYSTICK_3-      Joystick3  -> #const GLFW_JOYSTICK_4-      Joystick4  -> #const GLFW_JOYSTICK_5-      Joystick5  -> #const GLFW_JOYSTICK_6-      Joystick6  -> #const GLFW_JOYSTICK_7-      Joystick7  -> #const GLFW_JOYSTICK_8-      Joystick8  -> #const GLFW_JOYSTICK_9-      Joystick9  -> #const GLFW_JOYSTICK_10-      Joystick10 -> #const GLFW_JOYSTICK_11-      Joystick11 -> #const GLFW_JOYSTICK_12-      Joystick12 -> #const GLFW_JOYSTICK_13-      Joystick13 -> #const GLFW_JOYSTICK_14-      Joystick14 -> #const GLFW_JOYSTICK_15-      Joystick15 -> #const GLFW_JOYSTICK_16--  fromC i = case i of-      (#const GLFW_JOYSTICK_1 ) -> Joystick0-      (#const GLFW_JOYSTICK_2 ) -> Joystick1-      (#const GLFW_JOYSTICK_3 ) -> Joystick2-      (#const GLFW_JOYSTICK_4 ) -> Joystick3-      (#const GLFW_JOYSTICK_5 ) -> Joystick4-      (#const GLFW_JOYSTICK_6 ) -> Joystick5-      (#const GLFW_JOYSTICK_7 ) -> Joystick6-      (#const GLFW_JOYSTICK_8 ) -> Joystick7-      (#const GLFW_JOYSTICK_9 ) -> Joystick8-      (#const GLFW_JOYSTICK_10) -> Joystick9-      (#const GLFW_JOYSTICK_11) -> Joystick10-      (#const GLFW_JOYSTICK_12) -> Joystick11-      (#const GLFW_JOYSTICK_13) -> Joystick12-      (#const GLFW_JOYSTICK_14) -> Joystick13-      (#const GLFW_JOYSTICK_15) -> Joystick14-      (#const GLFW_JOYSTICK_16) -> Joystick15-      _                         -> makeFromCError "Joystick" i---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- Time--getTime :: IO Double-getTime =-    realToFrac `fmap` glfwGetTime--setTime :: Double -> IO ()-setTime =-    glfwSetTime . realToFrac--resetTime :: IO ()-resetTime =-    setTime (0 :: Double)--sleep :: Double -> IO ()-sleep =-    glfwSleep . realToFrac---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----- Version information--getGlfwVersion :: IO Version-getGlfwVersion =-    alloca $ \p0 ->-    alloca $ \p1 ->-    alloca $ \p2 -> do-        glfwGetVersion p0 p1 p2-        v0 <- fromC `fmap` peek p0-        v1 <- fromC `fmap` peek p1-        v2 <- fromC `fmap` peek p2-        return $ Version [v0, v1, v2] []--getGlVersion :: IO Version-getGlVersion =-    alloca $ \p0 ->-    alloca $ \p1 ->-    alloca $ \p2 -> do-        glfwGetGLVersion p0 p1 p2-        v0 <- fromC `fmap` peek p0-        v1 <- fromC `fmap` peek p1-        v2 <- fromC `fmap` peek p2-        return $ Version [v0, v1, v2] []---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----glfwPress :: CInt-glfwPress = #const GLFW_PRESS---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----class C h c where-  toC   :: h -> c-  fromC :: c -> h--  toC   = undefined-  fromC = undefined--makeFromCError :: (Show c) => String -> c -> a-makeFromCError s c = error (s ++ " fromC: no match for " ++ show c)---- -- -- -- -- -- -- -- -- ----instance C Bool CInt where-  toC False = #const GL_FALSE-  toC True  = #const GL_TRUE--  fromC (#const GL_FALSE) = False-  fromC (#const GL_TRUE)  = True-  fromC i                 = makeFromCError "Bool" i---- -- -- -- -- -- -- -- -- ----instance C Char CInt where-  toC   = fromIntegral . ord-  fromC = chr . fromIntegral---- -- -- -- -- -- -- -- -- ----instance C Float CFloat where-  toC   = realToFrac-  fromC = realToFrac---- -- -- -- -- -- -- -- -- ----instance C Int CInt where-  toC   = fromIntegral-  fromC = fromIntegral---- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- ----charCallback          :: IORef (Maybe (FunPtr GlfwCharCallback))-keyCallback           :: IORef (Maybe (FunPtr GlfwKeyCallback))-mouseButtonCallback   :: IORef (Maybe (FunPtr GlfwMouseButtonCallback))-mousePositionCallback :: IORef (Maybe (FunPtr GlfwMousePositionCallback))-mouseWheelCallback    :: IORef (Maybe (FunPtr GlfwMouseWheelCallback))-windowCloseCallback   :: IORef (Maybe (FunPtr GlfwWindowCloseCallback))-windowRefreshCallback :: IORef (Maybe (FunPtr GlfwWindowRefreshCallback))-windowSizeCallback    :: IORef (Maybe (FunPtr GlfwWindowSizeCallback))--charCallback          = unsafePerformIO (newIORef Nothing)-{-# NOINLINE charCallback #-}-keyCallback           = unsafePerformIO (newIORef Nothing)-{-# NOINLINE keyCallback #-}-mouseButtonCallback   = unsafePerformIO (newIORef Nothing)-{-# NOINLINE mouseButtonCallback #-}-mousePositionCallback = unsafePerformIO (newIORef Nothing)-{-# NOINLINE mousePositionCallback #-}-mouseWheelCallback    = unsafePerformIO (newIORef Nothing)-{-# NOINLINE mouseWheelCallback #-}-windowCloseCallback   = unsafePerformIO (newIORef Nothing)-{-# NOINLINE windowCloseCallback #-}-windowRefreshCallback = unsafePerformIO (newIORef Nothing)-{-# NOINLINE windowRefreshCallback #-}-windowSizeCallback    = unsafePerformIO (newIORef Nothing)-{-# NOINLINE windowSizeCallback #-}--storeCallback :: IORef (Maybe (FunPtr a)) -> FunPtr a -> IO ()-storeCallback ior cb =-    atomicModifyIORef ior (\mcb -> (Just cb, mcb)) >>= maybe (return ()) freeHaskellFunPtr