GLFW-b 0.1.0.5 → 1.0.0

raw patch · 60 files changed

+2318/−17841 lines, 60 filesdep +GLFW-bdep +HUnitdep +bindings-GLFWdep ~basesetup-changedPVP ok

version bump matches the API change (PVP)

Dependencies added: GLFW-b, HUnit, bindings-GLFW, template-haskell, test-framework, test-framework-hunit, th-lift

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• GLFW-b.cabal +57/−110
• Graphics/UI/GLFW.hs +849/−0
• Graphics/UI/GLFW/Internal/C.hs +9/−0
• Graphics/UI/GLFW/Internal/C/TH.hs +76/−0
• Graphics/UI/GLFW/Internal/Instances/C.hs +98/−0
• Graphics/UI/GLFW/Internal/Instances/Data.hs +18/−0
• Graphics/UI/GLFW/Internal/Instances/Lift.hs +43/−0
• Graphics/UI/GLFW/Internal/Tables.hs +282/−0
• Graphics/UI/GLFW/Types.hs +343/−0
• LICENSE +1/−1
• Makefile +0/−39
• README.md +10/−23
• Setup.hs +2/−105
• TODO +19/−0
• Test.hs +511/−0
• build/glfw/lib/cocoa/.build-tag +0/−0
• glfw/include/GL/glfw.h +0/−509
• glfw/lib/cocoa/cocoa_enable.m +0/−51
• glfw/lib/cocoa/cocoa_fullscreen.m +0/−102
• glfw/lib/cocoa/cocoa_glext.m +0/−63
• glfw/lib/cocoa/cocoa_init.m +0/−297
• glfw/lib/cocoa/cocoa_joystick.m +0/−65
• glfw/lib/cocoa/cocoa_thread.c +0/−416
• glfw/lib/cocoa/cocoa_time.m +0/−105
• glfw/lib/cocoa/cocoa_window.m +0/−924
• glfw/lib/cocoa/platform.h +0/−252
• glfw/lib/enable.c +0/−310
• glfw/lib/fullscreen.c +0/−94
• glfw/lib/glext.c +0/−283
• glfw/lib/image.c +0/−629
• glfw/lib/init.c +0/−110
• glfw/lib/input.c +0/−269
• glfw/lib/internal.h +0/−265
• glfw/lib/joystick.c +0/−99
• glfw/lib/stream.c +0/−195
• glfw/lib/tga.c +0/−404
• glfw/lib/thread.c +0/−341
• glfw/lib/time.c +0/−84
• glfw/lib/win32/platform.h +0/−555
• glfw/lib/win32/win32_dllmain.c +0/−49
• glfw/lib/win32/win32_enable.c +0/−155
• glfw/lib/win32/win32_fullscreen.c +0/−320
• glfw/lib/win32/win32_glext.c +0/−82
• glfw/lib/win32/win32_init.c +0/−356
• glfw/lib/win32/win32_joystick.c +0/−233
• glfw/lib/win32/win32_thread.c +0/−506
• glfw/lib/win32/win32_time.c +0/−146
• glfw/lib/win32/win32_window.c +0/−1875
• glfw/lib/window.c +0/−1005
• glfw/lib/x11/platform.h +0/−503
• glfw/lib/x11/x11_enable.c +0/−64
• glfw/lib/x11/x11_fullscreen.c +0/−569
• glfw/lib/x11/x11_glext.c +0/−89
• glfw/lib/x11/x11_init.c +0/−286
• glfw/lib/x11/x11_joystick.c +0/−367
• glfw/lib/x11/x11_keysym2unicode.c +0/−901
• glfw/lib/x11/x11_thread.c +0/−503
• glfw/lib/x11/x11_time.c +0/−154
• glfw/lib/x11/x11_window.c +0/−1891
• src/Graphics/UI/GLFW.hsc +0/−1087

@@ -1,140 +1,87 @@ name:         GLFW-b-version:      0.1.0.5-+version:      1.0.0 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>  license:      BSD3 license-file: LICENSE --- -- -- -- -- -- -- -- -- --+synopsis:     Bindings to GLFW OpenGL library+description:+  Bindings to <http://www.glfw.org/ GLFW>, an open source, multi-platform+  library for creating windows with OpenGL contexts and managing input and+  events.+  .+  GLFW-b depends on+  <http://hackage.haskell.org/package/bindings-GLFW bindings-GLFW>, which, as+  of the time of this writing, binds to+  <http://www.glfw.org/Version-3.0.1-released.html GLFW 3.0.1, released 2013-06-17>.+  .+  If you've used GLFW before, you were probably using 2.7.x. There are some+  significant differences in 3.0.x. Please see the+  <http://www.glfw.org/docs/3.0/moving.html transition guide>. -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 -O2+  if impl(ghc >= 6.8)+    ghc-options: -fwarn-tabs+   exposed-modules:     Graphics.UI.GLFW -  build-depends:-    base == 4.*+  other-modules:+    Graphics.UI.GLFW.Internal.C+    Graphics.UI.GLFW.Internal.C.TH+    Graphics.UI.GLFW.Internal.Instances.C+    Graphics.UI.GLFW.Internal.Instances.Data+    Graphics.UI.GLFW.Internal.Instances.Lift+    Graphics.UI.GLFW.Internal.Tables+    Graphics.UI.GLFW.Types -  hs-source-dirs:-    src+  build-depends:+    base              < 5,+    bindings-GLFW    == 0.0.*,+    template-haskell == 2.8.*,+    th-lift          == 0.5.* -  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   if impl(ghc >= 6.8)     ghc-options: -fwarn-tabs --- -- -- -- -- -- -- -- -- --+  type: exitcode-stdio-1.0++  main-is: Test.hs+  build-depends:+    GLFW-b               == 1.0.*,+    HUnit                == 1.2.*,+    base                  < 5,+    bindings-GLFW        == 0.0.*,+    template-haskell     == 2.8.*,+    test-framework       == 0.8.*,+    test-framework-hunit == 0.3.*,+    th-lift              == 0.5.*++--------------------------------------------------------------------------------  source-repository head   type:     git

@@ -0,0 +1,849 @@+module Graphics.UI.GLFW+  ( -- * Error handling+    Error (..)+    --+  , setErrorCallback, ErrorCallback++    -- * Initialization and version information+  , Version (..)+    --+  , init+  , terminate+  , getVersion+  , getVersionString++    -- * Monitor handling+  , Monitor+  , MonitorState (..)+  , VideoMode    (..)+  , GammaRamp    (gammaRampRed, gammaRampGreen, gammaRampBlue)+  , makeGammaRamp+    --+  , getMonitors+  , getPrimaryMonitor+  , getMonitorPos+  , getMonitorPhysicalSize+  , getMonitorName+  , setMonitorCallback, MonitorCallback+  , getVideoModes+  , getVideoMode+  , setGamma+  , getGammaRamp+  , setGammaRamp++    -- * Window handling+  , Window+  , WindowHint        (..)+  , FocusState        (..)+  , IconifyState      (..)+  , ContextRobustness (..)+  , OpenGLProfile     (..)+  , ClientAPI         (..)+    --+  , defaultWindowHints+  , windowHint+  , createWindow+  , destroyWindow+  , windowShouldClose+  , setWindowShouldClose+  , setWindowTitle+  , getWindowPos+  , setWindowPos+  , getWindowSize+  , setWindowSize+  , getFramebufferSize+  , iconifyWindow+  , restoreWindow+  , showWindow+  , hideWindow+  , getWindowMonitor+  , setCursorPos+    -- related to c'glfwGetWindowAttrib --.+  , getWindowFocused                   -- |+  , getWindowIconified                 -- |+  , getWindowResizable                 -- |+  , getWindowDecorated                 -- |+  , getWindowVisible                   -- |+  , getWindowClientAPI                 -- |+  , getWindowContextVersionMajor       -- |+  , getWindowContextVersionMinor       -- |+  , getWindowContextVersionRevision    -- |+  , getWindowContextRobustness         -- |+  , getWindowOpenGLForwardCompat       -- |+  , getWindowOpenGLDebugContext        -- |+  , getWindowOpenGLProfile  --------------'+  , setWindowPosCallback,       WindowPosCallback+  , setWindowSizeCallback,      WindowSizeCallback+  , setWindowCloseCallback,     WindowCloseCallback+  , setWindowRefreshCallback,   WindowRefreshCallback+  , setWindowFocusCallback,     WindowFocusCallback+  , setWindowIconifyCallback,   WindowIconifyCallback+  , setFramebufferSizeCallback, FramebufferSizeCallback+  , pollEvents+  , waitEvents++    -- * Input handling+  , Key                         (..)+  , KeyState                    (..)+  , Joystick                    (..)+  , JoystickButtonState         (..)+  , MouseButton                 (..)+  , MouseButtonState            (..)+  , CursorState                 (..)+  , CursorInputMode             (..)+  , StickyKeysInputMode         (..)+  , StickyMouseButtonsInputMode (..)+  , ModifierKeys                (..)+    --+    -- related to c'glfwSetInputMode ----.+  , getCursorInputMode                -- |+  , setCursorInputMode                -- |+  , getStickyKeysInputMode            -- |+  , setStickyKeysInputMode            -- |+  , getStickyMouseButtonsInputMode    -- |+  , setStickyMouseButtonsInputMode  -----'+  , getKey+  , getMouseButton+  , getCursorPos+  , setKeyCallback,         KeyCallback+  , setCharCallback,        CharCallback+  , setMouseButtonCallback, MouseButtonCallback+  , setCursorPosCallback,   CursorPosCallback+  , setCursorEnterCallback, CursorEnterCallback+  , setScrollCallback,      ScrollCallback+  , joystickPresent+  , getJoystickAxes+  , getJoystickButtons+  , getJoystickName++    -- * Time+  , getTime+  , setTime++    -- * Context+  , makeContextCurrent+  , getCurrentContext+  , swapBuffers+  , swapInterval+  , extensionSupported++    -- * Clipboard+  , getClipboardString+  , setClipboardString+  ) where++--------------------------------------------------------------------------------++import Prelude hiding (init)++import Control.Monad         (when)+import Data.IORef            (IORef, atomicModifyIORef', newIORef)+import Foreign.C.String      (peekCString, withCString)+import Foreign.C.Types       (CUInt, CUShort)+import Foreign.Marshal.Alloc (alloca)+import Foreign.Marshal.Array (advancePtr, allocaArray, peekArray, withArray)+import Foreign.Ptr           (FunPtr, freeHaskellFunPtr, nullFunPtr, nullPtr)+import Foreign.Storable      (Storable(..))+import System.IO.Unsafe      (unsafePerformIO)++import Graphics.UI.GLFW.Internal.C           (C(..))+import Graphics.UI.GLFW.Internal.Instances.C ()+import Graphics.UI.GLFW.Types++import Bindings.GLFW++--------------------------------------------------------------------------------++-- We store FunPtrs from mk'GLFW*fun in these stored*Fun IORefs. Initialized+-- with unsafePerformIO, they are basically mutable global variables.++storedCharFun            :: IORef C'GLFWcharfun+storedCursorEnterFun     :: IORef C'GLFWcursorenterfun+storedCursorPosFun       :: IORef C'GLFWcursorposfun+storedErrorFun           :: IORef C'GLFWerrorfun+storedFramebufferSizeFun :: IORef C'GLFWframebuffersizefun+storedKeyFun             :: IORef C'GLFWkeyfun+storedMonitorFun         :: IORef C'GLFWmonitorfun+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++storedCharFun            = unsafePerformIO $ newIORef nullFunPtr+storedCursorEnterFun     = unsafePerformIO $ newIORef nullFunPtr+storedCursorPosFun       = unsafePerformIO $ newIORef nullFunPtr+storedErrorFun           = unsafePerformIO $ newIORef nullFunPtr+storedFramebufferSizeFun = unsafePerformIO $ newIORef nullFunPtr+storedKeyFun             = unsafePerformIO $ newIORef nullFunPtr+storedMonitorFun         = unsafePerformIO $ newIORef nullFunPtr+storedMouseButtonFun     = unsafePerformIO $ newIORef nullFunPtr+storedScrollFun          = unsafePerformIO $ newIORef nullFunPtr+storedWindowCloseFun     = unsafePerformIO $ newIORef nullFunPtr+storedWindowFocusFun     = unsafePerformIO $ newIORef nullFunPtr+storedWindowIconifyFun   = unsafePerformIO $ newIORef nullFunPtr+storedWindowPosFun       = unsafePerformIO $ newIORef nullFunPtr+storedWindowRefreshFun   = unsafePerformIO $ newIORef nullFunPtr+storedWindowSizeFun      = 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 storedCharFun            #-}+{-# NOINLINE storedCursorEnterFun     #-}+{-# NOINLINE storedCursorPosFun       #-}+{-# NOINLINE storedErrorFun           #-}+{-# NOINLINE storedFramebufferSizeFun #-}+{-# NOINLINE storedKeyFun             #-}+{-# NOINLINE storedMonitorFun         #-}+{-# NOINLINE storedMouseButtonFun     #-}+{-# NOINLINE storedScrollFun          #-}+{-# NOINLINE storedWindowCloseFun     #-}+{-# NOINLINE storedWindowFocusFun     #-}+{-# NOINLINE storedWindowIconifyFun   #-}+{-# NOINLINE storedWindowPosFun       #-}+{-# NOINLINE storedWindowRefreshFun   #-}+{-# NOINLINE storedWindowSizeFun      #-}++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++--------------------------------------------------------------------------------++type ErrorCallback           = Error -> String                                           -> IO ()+type WindowPosCallback       = Window -> Int -> Int                                      -> IO ()+type WindowSizeCallback      = Window -> Int -> Int                                      -> IO ()+type WindowCloseCallback     = Window                                                    -> IO ()+type WindowRefreshCallback   = Window                                                    -> IO ()+type WindowFocusCallback     = Window -> FocusState                                      -> IO ()+type WindowIconifyCallback   = Window -> IconifyState                                    -> IO ()+type FramebufferSizeCallback = Window -> Int -> Int                                      -> IO ()+type MouseButtonCallback     = Window -> MouseButton -> MouseButtonState -> ModifierKeys -> IO ()+type CursorPosCallback       = Window -> Double -> Double                                -> IO ()+type CursorEnterCallback     = Window -> CursorState                                     -> IO ()+type ScrollCallback          = Window -> Double -> Double                                -> IO ()+type KeyCallback             = Window -> Key -> Int -> KeyState -> ModifierKeys          -> IO ()+type CharCallback            = Window -> Char                                            -> IO ()+type MonitorCallback         = Monitor -> MonitorState                                   -> IO ()++--------------------------------------------------------------------------------+-- Error handling++setErrorCallback :: Maybe ErrorCallback -> IO ()+setErrorCallback = setCallback+    mk'GLFWerrorfun+    (\cb a0 a1 -> do+        s <- peekCString a1+        cb (fromC a0) s)+    c'glfwSetErrorCallback+    storedErrorFun++--------------------------------------------------------------------------------+-- Initialization and version information++init :: IO Bool+init =+    fromC `fmap` c'glfwInit++terminate :: IO ()+terminate = do+    c'glfwTerminate+    -- Free all stored FunPtrs.+    storeCallback storedCharFun            nullFunPtr+    storeCallback storedCursorEnterFun     nullFunPtr+    storeCallback storedCursorPosFun       nullFunPtr+    storeCallback storedErrorFun           nullFunPtr+    storeCallback storedFramebufferSizeFun nullFunPtr+    storeCallback storedKeyFun             nullFunPtr+    storeCallback storedMonitorFun         nullFunPtr+    storeCallback storedMouseButtonFun     nullFunPtr+    storeCallback storedScrollFun          nullFunPtr+    storeCallback storedWindowCloseFun     nullFunPtr+    storeCallback storedWindowFocusFun     nullFunPtr+    storeCallback storedWindowIconifyFun   nullFunPtr+    storeCallback storedWindowPosFun       nullFunPtr+    storeCallback storedWindowRefreshFun   nullFunPtr+    storeCallback storedWindowSizeFun      nullFunPtr++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++getVersionString :: IO (Maybe String)+getVersionString = do+    p'vs <- c'glfwGetVersionString+    if p'vs /= nullPtr+      then Just `fmap` peekCString p'vs+      else return Nothing++--------------------------------------------------------------------------------+-- Monitor handling++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++getPrimaryMonitor :: IO (Maybe Monitor)+getPrimaryMonitor = do+    p'mon <- c'glfwGetPrimaryMonitor+    return $+      if p'mon == nullPtr+        then Nothing+        else Just $ fromC p'mon++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)++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)++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++setMonitorCallback :: Maybe MonitorCallback -> IO ()+setMonitorCallback = setCallback+    mk'GLFWmonitorfun+    (\cb a0 a1 -> cb (fromC a0) (fromC a1))+    c'glfwSetMonitorCallback+    storedMonitorFun++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++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++setGamma :: Monitor -> Double -> IO ()+setGamma mon e =+    c'glfwSetGamma (toC mon) (toC e)++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+                  }++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++--------------------------------------------------------------------------------+-- Window handling++defaultWindowHints :: IO ()+defaultWindowHints =+    c'glfwDefaultWindowHints++windowHint :: WindowHint -> IO ()+windowHint wh =+    let (t, v) = unpack+    in c'glfwWindowHint t v+  where+    unpack = case wh of+      (WindowHint'Resizable           x) -> (c'GLFW_RESIZABLE,             toC x)+      (WindowHint'Visible             x) -> (c'GLFW_VISIBLE,               toC x)+      (WindowHint'Decorated           x) -> (c'GLFW_DECORATED,             toC x)+      (WindowHint'RedBits             x) -> (c'GLFW_RED_BITS,              toC x)+      (WindowHint'GreenBits           x) -> (c'GLFW_GREEN_BITS,            toC x)+      (WindowHint'BlueBits            x) -> (c'GLFW_BLUE_BITS,             toC x)+      (WindowHint'AlphaBits           x) -> (c'GLFW_ALPHA_BITS,            toC x)+      (WindowHint'DepthBits           x) -> (c'GLFW_DEPTH_BITS,            toC x)+      (WindowHint'StencilBits         x) -> (c'GLFW_STENCIL_BITS,          toC x)+      (WindowHint'AccumRedBits        x) -> (c'GLFW_ACCUM_RED_BITS,        toC x)+      (WindowHint'AccumGreenBits      x) -> (c'GLFW_ACCUM_GREEN_BITS,      toC x)+      (WindowHint'AccumBlueBits       x) -> (c'GLFW_ACCUM_BLUE_BITS,       toC x)+      (WindowHint'AccumAlphaBits      x) -> (c'GLFW_ACCUM_ALPHA_BITS,      toC x)+      (WindowHint'AuxBuffers          x) -> (c'GLFW_AUX_BUFFERS,           toC x)+      (WindowHint'Samples             x) -> (c'GLFW_SAMPLES,               toC x)+      (WindowHint'RefreshRate         x) -> (c'GLFW_REFRESH_RATE,          toC x)+      (WindowHint'Stereo              x) -> (c'GLFW_STEREO,                toC x)+      (WindowHint'sRGBCapable         x) -> (c'GLFW_SRGB_CAPABLE,          toC x)+      (WindowHint'ClientAPI           x) -> (c'GLFW_CLIENT_API,            toC x)+      (WindowHint'ContextVersionMajor x) -> (c'GLFW_CONTEXT_VERSION_MAJOR, toC x)+      (WindowHint'ContextVersionMinor x) -> (c'GLFW_CONTEXT_VERSION_MINOR, toC x)+      (WindowHint'ContextRobustness   x) -> (c'GLFW_CONTEXT_ROBUSTNESS,    toC x)+      (WindowHint'OpenGLForwardCompat x) -> (c'GLFW_OPENGL_FORWARD_COMPAT, toC x)+      (WindowHint'OpenGLDebugContext  x) -> (c'GLFW_OPENGL_DEBUG_CONTEXT,  toC x)+      (WindowHint'OpenGLProfile       x) -> (c'GLFW_OPENGL_PROFILE,        toC x)++createWindow :: Int -> Int -> String -> Maybe Monitor -> Maybe Window -> IO (Maybe Window)+createWindow w h title mmon mwin =+    withCString title $ \ptitle -> do+        p'win <- c'glfwCreateWindow+          (toC w)+          (toC h)+          ptitle+          (maybe nullPtr toC mmon)+          (maybe nullPtr toC mwin)+        return $ if p'win == nullPtr+          then Nothing+          else Just $ fromC p'win++destroyWindow :: Window -> IO ()+destroyWindow =+    c'glfwDestroyWindow . toC++windowShouldClose :: Window -> IO Bool+windowShouldClose win =+    fromC `fmap` c'glfwWindowShouldClose (toC win)++setWindowShouldClose :: Window -> Bool -> IO ()+setWindowShouldClose win b =+    c'glfwSetWindowShouldClose (toC win) (toC b)++setWindowTitle :: Window -> String -> IO ()+setWindowTitle win title =+    withCString title $ c'glfwSetWindowTitle (toC win)++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)++setWindowPos :: Window -> Int -> Int -> IO ()+setWindowPos win x y =+    c'glfwSetWindowPos (toC win) (toC x) (toC y)++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)++setWindowSize :: Window -> Int -> Int -> IO ()+setWindowSize win w h =+    c'glfwSetWindowSize (toC win) (toC w) (toC h)++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)++iconifyWindow :: Window -> IO ()+iconifyWindow =+    c'glfwIconifyWindow . toC++restoreWindow :: Window -> IO ()+restoreWindow =+    c'glfwRestoreWindow . toC++showWindow :: Window -> IO ()+showWindow =+    c'glfwShowWindow . toC++hideWindow :: Window -> IO ()+hideWindow =+    c'glfwHideWindow . toC++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++setCursorPos :: Window -> Double -> Double -> IO ()+setCursorPos win x y =+    c'glfwSetCursorPos (toC win) (toC x) (toC y)++-- start of functions related to c'glfwGetWindowAttrib++getWindowFocused :: Window -> IO FocusState+getWindowFocused win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_FOCUSED++getWindowIconified :: Window -> IO IconifyState+getWindowIconified win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_ICONIFIED++getWindowResizable :: Window -> IO Bool+getWindowResizable win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_RESIZABLE++getWindowDecorated :: Window -> IO Bool+getWindowDecorated win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_DECORATED++getWindowVisible :: Window -> IO Bool+getWindowVisible win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_VISIBLE++getWindowClientAPI :: Window -> IO ClientAPI+getWindowClientAPI win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CLIENT_API++getWindowContextVersionMajor :: Window -> IO Int+getWindowContextVersionMajor win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CONTEXT_VERSION_MAJOR++getWindowContextVersionMinor :: Window -> IO Int+getWindowContextVersionMinor win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CONTEXT_VERSION_MINOR++getWindowContextVersionRevision :: Window -> IO Int+getWindowContextVersionRevision win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CONTEXT_REVISION++getWindowContextRobustness :: Window -> IO ContextRobustness+getWindowContextRobustness win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_CONTEXT_ROBUSTNESS++getWindowOpenGLForwardCompat :: Window -> IO Bool+getWindowOpenGLForwardCompat win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_OPENGL_FORWARD_COMPAT++getWindowOpenGLDebugContext :: Window -> IO Bool+getWindowOpenGLDebugContext win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_OPENGL_DEBUG_CONTEXT++getWindowOpenGLProfile :: Window -> IO OpenGLProfile+getWindowOpenGLProfile win =+    fromC `fmap` c'glfwGetWindowAttrib (toC win) c'GLFW_OPENGL_PROFILE++-- end of functions related to c'glfwGetWindowAttrib++setWindowPosCallback :: Window -> Maybe WindowPosCallback -> IO ()+setWindowPosCallback win = setCallback+    mk'GLFWwindowposfun+    (\cb a0 a1 a2 ->+      cb (fromC a0) (fromC a1) (fromC a2))+    (c'glfwSetWindowPosCallback (toC win))+    storedWindowPosFun++setWindowSizeCallback :: Window -> Maybe WindowSizeCallback -> IO ()+setWindowSizeCallback win = setCallback+    mk'GLFWwindowsizefun+    (\cb a0 a1 a2 ->+      cb (fromC a0) (fromC a1) (fromC a2))+    (c'glfwSetWindowSizeCallback (toC win))+    storedWindowSizeFun++setWindowCloseCallback :: Window -> Maybe WindowCloseCallback -> IO ()+setWindowCloseCallback win = setCallback+    mk'GLFWwindowclosefun+    (. fromC)+    (c'glfwSetWindowCloseCallback (toC win))+    storedWindowCloseFun++setWindowRefreshCallback :: Window -> Maybe WindowRefreshCallback -> IO ()+setWindowRefreshCallback win = setCallback+    mk'GLFWwindowrefreshfun+    (. fromC)+    (c'glfwSetWindowRefreshCallback (toC win))+    storedWindowRefreshFun++setWindowFocusCallback :: Window -> Maybe WindowFocusCallback -> IO ()+setWindowFocusCallback win = setCallback+    mk'GLFWwindowfocusfun+    (\cb a0 a1 -> cb (fromC a0) (fromC a1))+    (c'glfwSetWindowFocusCallback (toC win))+    storedWindowFocusFun++setWindowIconifyCallback :: Window -> Maybe WindowIconifyCallback -> IO ()+setWindowIconifyCallback win = setCallback+    mk'GLFWwindowiconifyfun+    (\cb a0 a1 -> cb (fromC a0) (fromC a1))+    (c'glfwSetWindowIconifyCallback (toC win))+    storedWindowIconifyFun++setFramebufferSizeCallback :: Window -> Maybe FramebufferSizeCallback -> IO ()+setFramebufferSizeCallback win = setCallback+    mk'GLFWframebuffersizefun+    (\cb a0 a1 a2 -> cb (fromC a0) (fromC a1) (fromC a2))+    (c'glfwSetFramebufferSizeCallback (toC win))+    storedFramebufferSizeFun++pollEvents :: IO ()+pollEvents = c'glfwPollEvents++waitEvents :: IO ()+waitEvents = c'glfwWaitEvents++--------------------------------------------------------------------------------+-- Input handling++-- start of glfw{GS}etInputMode-related functions++getCursorInputMode :: Window -> IO CursorInputMode+getCursorInputMode win =+    fromC `fmap` c'glfwGetInputMode (toC win) c'GLFW_CURSOR++setCursorInputMode :: Window -> CursorInputMode -> IO ()+setCursorInputMode win c =+    c'glfwSetInputMode (toC win) c'GLFW_CURSOR (toC c)++getStickyKeysInputMode :: Window -> IO StickyKeysInputMode+getStickyKeysInputMode win =+    fromC `fmap` c'glfwGetInputMode (toC win) c'GLFW_STICKY_KEYS++setStickyKeysInputMode :: Window -> StickyKeysInputMode -> IO ()+setStickyKeysInputMode win sk =+    c'glfwSetInputMode (toC win) c'GLFW_STICKY_KEYS (toC sk)++getStickyMouseButtonsInputMode :: Window -> IO StickyMouseButtonsInputMode+getStickyMouseButtonsInputMode win =+    fromC `fmap` c'glfwGetInputMode (toC win) c'GLFW_STICKY_MOUSE_BUTTONS++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++getKey :: Window -> Key -> IO KeyState+getKey win k =+    fromC `fmap` c'glfwGetKey (toC win) (toC k)++getMouseButton :: Window -> MouseButton -> IO MouseButtonState+getMouseButton win b =+    fromC `fmap` c'glfwGetMouseButton (toC win) (toC b)++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)++setKeyCallback :: Window -> Maybe KeyCallback -> IO ()+setKeyCallback win = setCallback+    mk'GLFWkeyfun+    (\cb a0 a1 a2 a3 a4 ->+      cb (fromC a0) (fromC a1) (fromC a2) (fromC a3) (fromC a4))+    (c'glfwSetKeyCallback (toC win))+    storedKeyFun++setCharCallback :: Window -> Maybe CharCallback -> IO ()+setCharCallback win = setCallback+    mk'GLFWcharfun+    (\cb a0 a1 -> cb (fromC a0) (fromC a1))+    (c'glfwSetCharCallback (toC win))+    storedCharFun++setMouseButtonCallback :: Window -> Maybe MouseButtonCallback -> IO ()+setMouseButtonCallback win = setCallback+    mk'GLFWmousebuttonfun+    (\cb a0 a1 a2 a3 -> cb (fromC a0) (fromC a1) (fromC a2) (fromC a3))+    (c'glfwSetMouseButtonCallback (toC win))+    storedMouseButtonFun++setCursorPosCallback :: Window -> Maybe CursorPosCallback -> IO ()+setCursorPosCallback win = setCallback+    mk'GLFWcursorposfun+    (\cb a0 a1 a2 -> cb (fromC a0) (fromC a1) (fromC a2))+    (c'glfwSetCursorPosCallback (toC win))+    storedCursorPosFun++setCursorEnterCallback :: Window -> Maybe CursorEnterCallback -> IO ()+setCursorEnterCallback win = setCallback+    mk'GLFWcursorenterfun+    (\cb a0 a1 -> cb (fromC a0) (fromC a1))+    (c'glfwSetCursorEnterCallback (toC win))+    storedCursorEnterFun++setScrollCallback :: Window -> Maybe ScrollCallback -> IO ()+setScrollCallback win = setCallback+    mk'GLFWscrollfun+    (\cb a0 a1 a2 -> cb (fromC a0) (fromC a1) (fromC a2))+    (c'glfwSetScrollCallback (toC win))+    storedScrollFun++joystickPresent :: Joystick -> IO Bool+joystickPresent js =+    fromC `fmap` c'glfwJoystickPresent (toC js)++getJoystickAxes :: Joystick -> IO (Maybe [Double])+getJoystickAxes js =+    alloca $ \p'n -> do+        p'axes <- c'glfwGetJoystickAxes (toC js) p'n+        n <- fromC `fmap` peek p'n+        if p'axes == nullPtr || n <= 0+          then return Nothing+          else (Just . map fromC) `fmap` peekArray n p'axes++getJoystickButtons :: Joystick -> IO (Maybe [JoystickButtonState])+getJoystickButtons js =+    alloca $ \p'n -> do+        p'buttons <- c'glfwGetJoystickButtons (toC js) p'n+        n <- fromC `fmap` peek p'n+        if p'buttons == nullPtr || n <= 0+          then return Nothing+          else (Just . map fromC) `fmap` peekArray n p'buttons++getJoystickName :: Joystick -> IO (Maybe String)+getJoystickName js = do+    p'name <- c'glfwGetJoystickName (toC js)+    if p'name == nullPtr+      then return Nothing+      else Just `fmap` peekCString p'name++--------------------------------------------------------------------------------+-- Time++getTime :: IO (Maybe Double)+getTime = do+    t <- fromC `fmap` c'glfwGetTime+    return $ if t == 0+      then Nothing+      else Just t++setTime :: Double -> IO ()+setTime =+    c'glfwSetTime . toC++--------------------------------------------------------------------------------+-- Context++makeContextCurrent :: Maybe Window -> IO ()+makeContextCurrent =+    c'glfwMakeContextCurrent . maybe nullPtr toC++getCurrentContext :: IO (Maybe Window)+getCurrentContext = do+    p'win <- c'glfwGetCurrentContext+    return $ if p'win == nullPtr+      then Nothing+      else Just $ fromC p'win++swapBuffers :: Window -> IO ()+swapBuffers =+    c'glfwSwapBuffers . toC++swapInterval :: Int -> IO ()+swapInterval =+    c'glfwSwapInterval . toC++extensionSupported :: String -> IO Bool+extensionSupported ext =+    withCString ext $ \p'ext ->+      fromC `fmap` c'glfwExtensionSupported p'ext++--------------------------------------------------------------------------------+-- Clipboard++setClipboardString :: Window -> String -> IO ()+setClipboardString win s =+    withCString s (c'glfwSetClipboardString (toC win))++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

@@ -0,0 +1,9 @@+{-# LANGUAGE MultiParamTypeClasses #-}++module Graphics.UI.GLFW.Internal.C where++-- A class for converting between C-type c and Haskell-type h. For example,+-- suppose you have a Haskell Joystick, but need the CInt, or vice versa.+class C c h where+  fromC :: c -> h+  toC   :: h -> c

@@ -0,0 +1,76 @@+{-# LANGUAGE TemplateHaskell #-}++-- deriveC creates an instance of C c h from [(c, h)].+--+-- Example:+--+-- > pairs :: [(CInt, Bool)]+-- > pairs = [(0, False), (1, True)]+-- >+-- > deriveC ''CInt ''Bool pairs+--+-- would derive+--+-- > instance C CInt Bool where+-- >   fromC 0 = False+-- >   fromC 1 = True+-- >   fromC _ = error ...+-- >+-- >   toC False = 0+-- >   toC True  = 1++module Graphics.UI.GLFW.Internal.C.TH+  ( deriveC+  ) where++--------------------------------------------------------------------------------++import Data.Data                  (Data)+import Data.Tuple                 (swap)+import Language.Haskell.TH        (Dec, Name, Q, appT, clause, conT, cxt, funD, global, instanceD, mkName, nameBase, normalB, varP)+import Language.Haskell.TH.Quote  (dataToPatQ)+import Language.Haskell.TH.Syntax (Lift(..))++--------------------------------------------------------------------------------++deriveC :: (Data c, Data h, Lift c, Lift h) => Name -> Name -> [(c, h)] -> Q [Dec]+deriveC ctype htype pairs =+    (:[]) `fmap` deriveC1 ctype htype pairs++--------------------------------------------------------------------------------++deriveC1 :: (Data c, Data h, Lift c, Lift h) => Name -> Name -> [(c, h)] -> Q Dec+deriveC1 _ _ [] =+    error "deriveC: no pairs!"+deriveC1 ctype htype pairs =+    instanceD+      (cxt [])+      (appT+          (appT (conT cname) (conT ctype))+          (conT htype)+      )+      [ funD frname frClauses+      , funD toname toClauses+      ]+  where+    cname  = mkName "C"+    frname = mkName "fromC"+    toname = mkName "toC"+    vname  = mkName "v"++    frClauses = map  genPairClause         pairs ++ [genErrorClause]+    toClauses = map (genPairClause . swap) pairs++    genPairClause (v0, v1) =+        clause [pat] body []+      where+        pat  = dataToPatQ (const Nothing) v0+        body = normalB [|v1|]++    genErrorClause =+        clause [pat] body []+      where+        pat   = varP vname+        body  = normalB [| error $ msg ++ show $(global vname) |]+        -- e.g., "C CInt Bool fromC: "+        msg = unwords (map nameBase [cname, ctype, htype, frname]) ++ ": "

@@ -0,0 +1,98 @@+{-# LANGUAGE    FlexibleInstances     #-}+{-# LANGUAGE    MultiParamTypeClasses #-}+{-# LANGUAGE    TemplateHaskell       #-}+{-# OPTIONS_GHC -fno-warn-orphans     #-}++module Graphics.UI.GLFW.Internal.Instances.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.Internal.C              (C(..))+import Graphics.UI.GLFW.Internal.C.TH           (deriveC)+import Graphics.UI.GLFW.Internal.Instances.Data ()+import Graphics.UI.GLFW.Internal.Instances.Lift ()+import Graphics.UI.GLFW.Internal.Tables+import Graphics.UI.GLFW.Types++--------------------------------------------------------------------------------++deriveC ''CInt   ''Bool                        table_C_CInt_Bool+deriveC ''CInt   ''ClientAPI                   table_C_CInt_ClientAPI+deriveC ''CInt   ''ContextRobustness           table_C_CInt_ContextRobustness+deriveC ''CInt   ''CursorInputMode             table_C_CInt_CursorInputMode+deriveC ''CInt   ''CursorState                 table_C_CInt_CursorState+deriveC ''CInt   ''Error                       table_C_CInt_Error+deriveC ''CInt   ''FocusState                  table_C_CInt_FocusState+deriveC ''CInt   ''IconifyState                table_C_CInt_IconifyState+deriveC ''CInt   ''Joystick                    table_C_CInt_Joystick+deriveC ''CInt   ''Key                         table_C_CInt_Key+deriveC ''CInt   ''KeyState                    table_C_CInt_KeyState+deriveC ''CInt   ''MonitorState                table_C_CInt_MonitorState+deriveC ''CInt   ''MouseButton                 table_C_CInt_MouseButton+deriveC ''CInt   ''MouseButtonState            table_C_CInt_MouseButtonState+deriveC ''CInt   ''OpenGLProfile               table_C_CInt_OpenGLProfile+deriveC ''CInt   ''StickyKeysInputMode         table_C_CInt_StickyKeysInputMode+deriveC ''CInt   ''StickyMouseButtonsInputMode table_C_CInt_StickyMouseButtonsInputMode+deriveC ''CUChar ''JoystickButtonState         table_C_CUChar_JoystickButtonState++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+    }+  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

@@ -0,0 +1,18 @@+{-# LANGUAGE    DeriveDataTypeable #-}+{-# LANGUAGE    StandaloneDeriving #-}+{-# OPTIONS_GHC -fno-warn-orphans  #-}++-- To derive instances of C c h with deriveC, c and h must be instances of+-- Data.++module Graphics.UI.GLFW.Internal.Instances.Data where++--------------------------------------------------------------------------------++import Data.Data       (Data)+import Foreign.C.Types (CInt(..), CUChar(..))++--------------------------------------------------------------------------------++deriving instance Data CInt+deriving instance Data CUChar

@@ -0,0 +1,43 @@+{-# LANGUAGE    TemplateHaskell   #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}++-- To derive instances of C c h with deriveC, c and h must be instances of+-- Lift.++module Graphics.UI.GLFW.Internal.Instances.Lift where++--------------------------------------------------------------------------------++import Foreign.C.Types            (CInt, CUChar)+import Language.Haskell.TH.Lift   (deriveLiftMany)+import Language.Haskell.TH.Syntax (Exp(LitE), Lift(..), Lit(IntegerL))++import Graphics.UI.GLFW.Types++--------------------------------------------------------------------------------++instance Lift CInt where+  lift x = return (LitE (IntegerL (fromIntegral x)))++instance Lift CUChar where+  lift x = return (LitE (IntegerL (fromIntegral x)))++deriveLiftMany+  [ ''ClientAPI+  , ''ContextRobustness+  , ''CursorInputMode+  , ''CursorState+  , ''Error+  , ''FocusState+  , ''IconifyState+  , ''Joystick+  , ''JoystickButtonState+  , ''Key+  , ''KeyState+  , ''MonitorState+  , ''MouseButton+  , ''MouseButtonState+  , ''OpenGLProfile+  , ''StickyKeysInputMode+  , ''StickyMouseButtonsInputMode+  ]

@@ -0,0 +1,282 @@+-- Lists of pairs for use with deriveC.++module Graphics.UI.GLFW.Internal.Tables where++--------------------------------------------------------------------------------++import Foreign.C.Types (CInt, CUChar)++import Bindings.GLFW+import Graphics.UI.GLFW.Types++--------------------------------------------------------------------------------++table_C_CInt_Bool :: [(CInt, Bool)]+table_C_CInt_Bool =+    [ ( c'GL_FALSE, False )+    , ( c'GL_TRUE,  True  )+    ]++--------------------------------------------------------------------------------++table_C_CInt_Error :: [(CInt, Error)]+table_C_CInt_Error =+    [ ( c'GLFW_NOT_INITIALIZED,     Error'NotInitialized     )+    , ( c'GLFW_NO_CURRENT_CONTEXT,  Error'NoCurrentContext   )+    , ( c'GLFW_INVALID_ENUM,        Error'InvalidEnum        )+    , ( c'GLFW_INVALID_VALUE,       Error'InvalidValue       )+    , ( c'GLFW_OUT_OF_MEMORY,       Error'OutOfMemory        )+    , ( c'GLFW_API_UNAVAILABLE,     Error'ApiUnavailable     )+    , ( c'GLFW_VERSION_UNAVAILABLE, Error'VersionUnavailable )+    , ( c'GLFW_PLATFORM_ERROR,      Error'PlatformError      )+    , ( c'GLFW_FORMAT_UNAVAILABLE,  Error'FormatUnavailable  )+    ]++--------------------------------------------------------------------------------++table_C_CInt_MonitorState :: [(CInt, MonitorState)]+table_C_CInt_MonitorState =+    [ ( c'GL_TRUE,  MonitorState'Connected    )+    , ( c'GL_FALSE, MonitorState'Disconnected )+    ]++--------------------------------------------------------------------------------++table_C_CInt_FocusState :: [(CInt, FocusState)]+table_C_CInt_FocusState =+    [ ( c'GL_TRUE,  FocusState'Focused   )+    , ( c'GL_FALSE, FocusState'Defocused )+    ]++table_C_CInt_IconifyState :: [(CInt, IconifyState)]+table_C_CInt_IconifyState =+    [ ( c'GL_TRUE,  IconifyState'Iconified    )+    , ( c'GL_FALSE, IconifyState'NotIconified )+    ]++table_C_CInt_ContextRobustness :: [(CInt, ContextRobustness)]+table_C_CInt_ContextRobustness =+    [ ( c'GLFW_NO_ROBUSTNESS,         ContextRobustness'NoRobustness        )+    , ( c'GLFW_NO_RESET_NOTIFICATION, ContextRobustness'NoResetNotification )+    , ( c'GLFW_LOSE_CONTEXT_ON_RESET, ContextRobustness'LoseContextOnReset  )+    ]++table_C_CInt_OpenGLProfile :: [(CInt, OpenGLProfile)]+table_C_CInt_OpenGLProfile =+    [ ( c'GLFW_OPENGL_ANY_PROFILE,    OpenGLProfile'Any    )+    , ( c'GLFW_OPENGL_COMPAT_PROFILE, OpenGLProfile'Compat )+    , ( c'GLFW_OPENGL_CORE_PROFILE,   OpenGLProfile'Core   )+    ]++table_C_CInt_ClientAPI :: [(CInt, ClientAPI)]+table_C_CInt_ClientAPI =+    [ ( c'GLFW_OPENGL_API,    ClientAPI'OpenGL   )+    , ( c'GLFW_OPENGL_ES_API, ClientAPI'OpenGLES )+    ]++--------------------------------------------------------------------------------++table_C_CInt_Key :: [(CInt, Key)]+table_C_CInt_Key =+   [ ( c'GLFW_KEY_UNKNOWN,       Key'Unknown      )+   , ( c'GLFW_KEY_SPACE,         Key'Space        )+   , ( c'GLFW_KEY_APOSTROPHE,    Key'Apostrophe   )+   , ( c'GLFW_KEY_COMMA,         Key'Comma        )+   , ( c'GLFW_KEY_MINUS,         Key'Minus        )+   , ( c'GLFW_KEY_PERIOD,        Key'Period       )+   , ( c'GLFW_KEY_SLASH,         Key'Slash        )+   , ( c'GLFW_KEY_0,             Key'0            )+   , ( c'GLFW_KEY_1,             Key'1            )+   , ( c'GLFW_KEY_2,             Key'2            )+   , ( c'GLFW_KEY_3,             Key'3            )+   , ( c'GLFW_KEY_4,             Key'4            )+   , ( c'GLFW_KEY_5,             Key'5            )+   , ( c'GLFW_KEY_6,             Key'6            )+   , ( c'GLFW_KEY_7,             Key'7            )+   , ( c'GLFW_KEY_8,             Key'8            )+   , ( c'GLFW_KEY_9,             Key'9            )+   , ( c'GLFW_KEY_SEMICOLON,     Key'Semicolon    )+   , ( c'GLFW_KEY_EQUAL,         Key'Equal        )+   , ( c'GLFW_KEY_A,             Key'A            )+   , ( c'GLFW_KEY_B,             Key'B            )+   , ( c'GLFW_KEY_C,             Key'C            )+   , ( c'GLFW_KEY_D,             Key'D            )+   , ( c'GLFW_KEY_E,             Key'E            )+   , ( c'GLFW_KEY_F,             Key'F            )+   , ( c'GLFW_KEY_G,             Key'G            )+   , ( c'GLFW_KEY_H,             Key'H            )+   , ( c'GLFW_KEY_I,             Key'I            )+   , ( c'GLFW_KEY_J,             Key'J            )+   , ( c'GLFW_KEY_K,             Key'K            )+   , ( c'GLFW_KEY_L,             Key'L            )+   , ( c'GLFW_KEY_M,             Key'M            )+   , ( c'GLFW_KEY_N,             Key'N            )+   , ( c'GLFW_KEY_O,             Key'O            )+   , ( c'GLFW_KEY_P,             Key'P            )+   , ( c'GLFW_KEY_Q,             Key'Q            )+   , ( c'GLFW_KEY_R,             Key'R            )+   , ( c'GLFW_KEY_S,             Key'S            )+   , ( c'GLFW_KEY_T,             Key'T            )+   , ( c'GLFW_KEY_U,             Key'U            )+   , ( c'GLFW_KEY_V,             Key'V            )+   , ( c'GLFW_KEY_W,             Key'W            )+   , ( c'GLFW_KEY_X,             Key'X            )+   , ( c'GLFW_KEY_Y,             Key'Y            )+   , ( c'GLFW_KEY_Z,             Key'Z            )+   , ( c'GLFW_KEY_LEFT_BRACKET,  Key'LeftBracket  )+   , ( c'GLFW_KEY_BACKSLASH,     Key'Backslash    )+   , ( c'GLFW_KEY_RIGHT_BRACKET, Key'RightBracket )+   , ( c'GLFW_KEY_GRAVE_ACCENT,  Key'GraveAccent  )+   , ( c'GLFW_KEY_WORLD_1,       Key'World1       )+   , ( c'GLFW_KEY_WORLD_2,       Key'World2       )+   , ( c'GLFW_KEY_ESCAPE,        Key'Escape       )+   , ( c'GLFW_KEY_ENTER,         Key'Enter        )+   , ( c'GLFW_KEY_TAB,           Key'Tab          )+   , ( c'GLFW_KEY_BACKSPACE,     Key'Backspace    )+   , ( c'GLFW_KEY_INSERT,        Key'Insert       )+   , ( c'GLFW_KEY_DELETE,        Key'Delete       )+   , ( c'GLFW_KEY_RIGHT,         Key'Right        )+   , ( c'GLFW_KEY_LEFT,          Key'Left         )+   , ( c'GLFW_KEY_DOWN,          Key'Down         )+   , ( c'GLFW_KEY_UP,            Key'Up           )+   , ( c'GLFW_KEY_PAGE_UP,       Key'PageUp       )+   , ( c'GLFW_KEY_PAGE_DOWN,     Key'PageDown     )+   , ( c'GLFW_KEY_HOME,          Key'Home         )+   , ( c'GLFW_KEY_END,           Key'End          )+   , ( c'GLFW_KEY_CAPS_LOCK,     Key'CapsLock     )+   , ( c'GLFW_KEY_SCROLL_LOCK,   Key'ScrollLock   )+   , ( c'GLFW_KEY_NUM_LOCK,      Key'NumLock      )+   , ( c'GLFW_KEY_PRINT_SCREEN,  Key'PrintScreen  )+   , ( c'GLFW_KEY_PAUSE,         Key'Pause        )+   , ( c'GLFW_KEY_F1,            Key'F1           )+   , ( c'GLFW_KEY_F2,            Key'F2           )+   , ( c'GLFW_KEY_F3,            Key'F3           )+   , ( c'GLFW_KEY_F4,            Key'F4           )+   , ( c'GLFW_KEY_F5,            Key'F5           )+   , ( c'GLFW_KEY_F6,            Key'F6           )+   , ( c'GLFW_KEY_F7,            Key'F7           )+   , ( c'GLFW_KEY_F8,            Key'F8           )+   , ( c'GLFW_KEY_F9,            Key'F9           )+   , ( c'GLFW_KEY_F10,           Key'F10          )+   , ( c'GLFW_KEY_F11,           Key'F11          )+   , ( c'GLFW_KEY_F12,           Key'F12          )+   , ( c'GLFW_KEY_F13,           Key'F13          )+   , ( c'GLFW_KEY_F14,           Key'F14          )+   , ( c'GLFW_KEY_F15,           Key'F15          )+   , ( c'GLFW_KEY_F16,           Key'F16          )+   , ( c'GLFW_KEY_F17,           Key'F17          )+   , ( c'GLFW_KEY_F18,           Key'F18          )+   , ( c'GLFW_KEY_F19,           Key'F19          )+   , ( c'GLFW_KEY_F20,           Key'F20          )+   , ( c'GLFW_KEY_F21,           Key'F21          )+   , ( c'GLFW_KEY_F22,           Key'F22          )+   , ( c'GLFW_KEY_F23,           Key'F23          )+   , ( c'GLFW_KEY_F24,           Key'F24          )+   , ( c'GLFW_KEY_F25,           Key'F25          )+   , ( c'GLFW_KEY_KP_0,          Key'Pad0         )+   , ( c'GLFW_KEY_KP_1,          Key'Pad1         )+   , ( c'GLFW_KEY_KP_2,          Key'Pad2         )+   , ( c'GLFW_KEY_KP_3,          Key'Pad3         )+   , ( c'GLFW_KEY_KP_4,          Key'Pad4         )+   , ( c'GLFW_KEY_KP_5,          Key'Pad5         )+   , ( c'GLFW_KEY_KP_6,          Key'Pad6         )+   , ( c'GLFW_KEY_KP_7,          Key'Pad7         )+   , ( c'GLFW_KEY_KP_8,          Key'Pad8         )+   , ( c'GLFW_KEY_KP_9,          Key'Pad9         )+   , ( c'GLFW_KEY_KP_DECIMAL,    Key'PadDecimal   )+   , ( c'GLFW_KEY_KP_DIVIDE,     Key'PadDivide    )+   , ( c'GLFW_KEY_KP_MULTIPLY,   Key'PadMultiply  )+   , ( c'GLFW_KEY_KP_SUBTRACT,   Key'PadSubtract  )+   , ( c'GLFW_KEY_KP_ADD,        Key'PadAdd       )+   , ( c'GLFW_KEY_KP_ENTER,      Key'PadEnter     )+   , ( c'GLFW_KEY_KP_EQUAL,      Key'PadEqual     )+   , ( c'GLFW_KEY_LEFT_SHIFT,    Key'LeftShift    )+   , ( c'GLFW_KEY_LEFT_CONTROL,  Key'LeftControl  )+   , ( c'GLFW_KEY_LEFT_ALT,      Key'LeftAlt      )+   , ( c'GLFW_KEY_LEFT_SUPER,    Key'LeftSuper    )+   , ( c'GLFW_KEY_RIGHT_SHIFT,   Key'RightShift   )+   , ( c'GLFW_KEY_RIGHT_CONTROL, Key'RightControl )+   , ( c'GLFW_KEY_RIGHT_ALT,     Key'RightAlt     )+   , ( c'GLFW_KEY_RIGHT_SUPER,   Key'RightSuper   )+   , ( c'GLFW_KEY_MENU,          Key'Menu         )+   ]++table_C_CInt_KeyState :: [(CInt, KeyState)]+table_C_CInt_KeyState =+    [ ( c'GLFW_PRESS,   KeyState'Pressed   )+    , ( c'GLFW_RELEASE, KeyState'Released  )+    , ( c'GLFW_REPEAT,  KeyState'Repeating )+    ]++table_C_CInt_Joystick :: [(CInt, Joystick)]+table_C_CInt_Joystick =+    [ ( c'GLFW_JOYSTICK_1,  Joystick'1  )+    , ( c'GLFW_JOYSTICK_2,  Joystick'2  )+    , ( c'GLFW_JOYSTICK_3,  Joystick'3  )+    , ( c'GLFW_JOYSTICK_4,  Joystick'4  )+    , ( c'GLFW_JOYSTICK_5,  Joystick'5  )+    , ( c'GLFW_JOYSTICK_6,  Joystick'6  )+    , ( c'GLFW_JOYSTICK_7,  Joystick'7  )+    , ( c'GLFW_JOYSTICK_8,  Joystick'8  )+    , ( c'GLFW_JOYSTICK_9,  Joystick'9  )+    , ( c'GLFW_JOYSTICK_10, Joystick'10 )+    , ( c'GLFW_JOYSTICK_11, Joystick'11 )+    , ( c'GLFW_JOYSTICK_12, Joystick'12 )+    , ( c'GLFW_JOYSTICK_13, Joystick'13 )+    , ( c'GLFW_JOYSTICK_14, Joystick'14 )+    , ( c'GLFW_JOYSTICK_15, Joystick'15 )+    , ( c'GLFW_JOYSTICK_16, Joystick'16 )+    ]++table_C_CUChar_JoystickButtonState :: [(CUChar, JoystickButtonState)]+table_C_CUChar_JoystickButtonState =+    [ ( c'GLFW_PRESS,   JoystickButtonState'Pressed  )+    , ( c'GLFW_RELEASE, JoystickButtonState'Released )+    ]++table_C_CInt_MouseButton :: [(CInt, MouseButton)]+table_C_CInt_MouseButton =+    [ ( c'GLFW_MOUSE_BUTTON_1, MouseButton'1 )+    , ( c'GLFW_MOUSE_BUTTON_2, MouseButton'2 )+    , ( c'GLFW_MOUSE_BUTTON_3, MouseButton'3 )+    , ( c'GLFW_MOUSE_BUTTON_4, MouseButton'4 )+    , ( c'GLFW_MOUSE_BUTTON_5, MouseButton'5 )+    , ( c'GLFW_MOUSE_BUTTON_6, MouseButton'6 )+    , ( c'GLFW_MOUSE_BUTTON_7, MouseButton'7 )+    , ( c'GLFW_MOUSE_BUTTON_8, MouseButton'8 )+    ]++table_C_CInt_MouseButtonState :: [(CInt, MouseButtonState)]+table_C_CInt_MouseButtonState =+    [ ( c'GLFW_PRESS,   MouseButtonState'Pressed  )+    , ( c'GLFW_RELEASE, MouseButtonState'Released )+    ]++table_C_CInt_CursorState :: [(CInt, CursorState)]+table_C_CInt_CursorState =+    [ ( c'GL_TRUE,  CursorState'InWindow    )+    , ( c'GL_FALSE, CursorState'NotInWindow )+    ]++table_C_CInt_CursorInputMode :: [(CInt, CursorInputMode)]+table_C_CInt_CursorInputMode =+    [ ( c'GLFW_CURSOR_NORMAL,   CursorInputMode'Normal   )+    , ( c'GLFW_CURSOR_HIDDEN,   CursorInputMode'Hidden   )+    , ( c'GLFW_CURSOR_DISABLED, CursorInputMode'Disabled )+    ]++table_C_CInt_StickyKeysInputMode :: [(CInt, StickyKeysInputMode)]+table_C_CInt_StickyKeysInputMode =+    [ ( c'GL_TRUE,  StickyKeysInputMode'Enabled )+    , ( c'GL_FALSE, StickyKeysInputMode'Disabled )+    ]++table_C_CInt_StickyMouseButtonsInputMode :: [(CInt, StickyMouseButtonsInputMode)]+table_C_CInt_StickyMouseButtonsInputMode =+    [ ( c'GL_TRUE,  StickyMouseButtonsInputMode'Enabled )+    , ( c'GL_FALSE, StickyMouseButtonsInputMode'Disabled )+    ]++--------------------------------------------------------------------------------++{-# ANN module "HLint: ignore Use camelCase" #-}

@@ -0,0 +1,343 @@+{-# LANGUAGE DeriveDataTypeable #-}++module Graphics.UI.GLFW.Types where++--------------------------------------------------------------------------------++import Data.Data     (Data)+import Data.Typeable (Typeable)+import Foreign.Ptr   (Ptr)++import Bindings.GLFW++--------------------------------------------------------------------------------+-- Error handling++data Error =+    Error'NotInitialized+  | Error'NoCurrentContext+  | Error'InvalidEnum+  | Error'InvalidValue+  | Error'OutOfMemory+  | Error'ApiUnavailable+  | Error'VersionUnavailable+  | Error'PlatformError+  | Error'FormatUnavailable+  deriving (Data, Eq, Show, Typeable)++--------------------------------------------------------------------------------+-- Initialization and version information++data Version = Version+  { versionMajor    :: Int+  , versionMinor    :: Int+  , versionRevision :: Int+  } deriving (Data, Eq, Show, Typeable)++--------------------------------------------------------------------------------+-- Monitor handling++newtype Monitor = Monitor+  { unMonitor :: Ptr C'GLFWmonitor+  } deriving (Data, Eq, Show, Typeable)++data MonitorState =+    MonitorState'Connected+  | MonitorState'Disconnected+  deriving (Data, Eq, Show, Typeable)++data VideoMode = VideoMode+  { videoModeWidth       :: Int+  , videoModeHeight      :: Int+  , videoModeRedBits     :: Int+  , videoModeGreenBits   :: Int+  , videoModeBlueBits    :: Int+  , videoModeRefreshRate :: Int+  } deriving (Data, Eq, Show, Typeable)++-- 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.+data GammaRamp = GammaRamp+  { gammaRampRed   :: [Int]+  , gammaRampGreen :: [Int]+  , gammaRampBlue  :: [Int]+  } deriving (Data, Eq, Show, Typeable)++-- Smart constructor for 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++newtype Window = Window+  { unWindow :: Ptr C'GLFWwindow+  } deriving (Data, Eq, Show, Typeable)++data WindowHint =+    WindowHint'Resizable           Bool+  | WindowHint'Visible             Bool+  | WindowHint'Decorated           Bool+  | WindowHint'RedBits             Int+  | WindowHint'GreenBits           Int+  | WindowHint'BlueBits            Int+  | WindowHint'AlphaBits           Int+  | WindowHint'DepthBits           Int+  | WindowHint'StencilBits         Int+  | WindowHint'AccumRedBits        Int+  | WindowHint'AccumGreenBits      Int+  | WindowHint'AccumBlueBits       Int+  | WindowHint'AccumAlphaBits      Int+  | WindowHint'AuxBuffers          Int+  | WindowHint'Samples             Int+  | WindowHint'RefreshRate         Int+  | WindowHint'Stereo              Bool+  | WindowHint'sRGBCapable         Bool+  | WindowHint'ClientAPI           ClientAPI+  | WindowHint'ContextVersionMajor Int+  | WindowHint'ContextVersionMinor Int+  | WindowHint'ContextRobustness   ContextRobustness+  | WindowHint'OpenGLForwardCompat Bool+  | WindowHint'OpenGLDebugContext  Bool+  | WindowHint'OpenGLProfile       OpenGLProfile+  deriving (Data, Eq, Show, Typeable)++data FocusState =+    FocusState'Focused+  | FocusState'Defocused+  deriving (Data, Eq, Show, Typeable)++data IconifyState =+    IconifyState'Iconified+  | IconifyState'NotIconified+  deriving (Data, Eq, Show, Typeable)++data ContextRobustness =+    ContextRobustness'NoRobustness+  | ContextRobustness'NoResetNotification+  | ContextRobustness'LoseContextOnReset+  deriving (Data, Eq, Show, Typeable)++data OpenGLProfile =+    OpenGLProfile'Any+  | OpenGLProfile'Compat+  | OpenGLProfile'Core+  deriving (Data, Eq, Show, Typeable)++data ClientAPI =+    ClientAPI'OpenGL+  | ClientAPI'OpenGLES+  deriving (Data, Eq, Show, Typeable)++--------------------------------------------------------------------------------+-- Input handling++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 (Data, Eq, Show, Typeable)++data KeyState =+    KeyState'Pressed+  | KeyState'Released+  | KeyState'Repeating+  deriving (Data, Eq, Show, Typeable)++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 (Data, Eq, Ord, Show, Typeable)++data JoystickButtonState =+    JoystickButtonState'Pressed+  | JoystickButtonState'Released+  deriving (Data, Eq, Show, Typeable)++data MouseButton =+    MouseButton'1+  | MouseButton'2+  | MouseButton'3+  | MouseButton'4+  | MouseButton'5+  | MouseButton'6+  | MouseButton'7+  | MouseButton'8+  deriving (Data, Eq, Show, Typeable)++data MouseButtonState =+    MouseButtonState'Pressed+  | MouseButtonState'Released+  deriving (Data, Eq, Show, Typeable)++data CursorState =+    CursorState'InWindow+  | CursorState'NotInWindow+  deriving (Data, Eq, Show, Typeable)++data CursorInputMode =+    CursorInputMode'Normal+  | CursorInputMode'Hidden+  | CursorInputMode'Disabled+  deriving (Data, Eq, Show, Typeable)++data StickyKeysInputMode =+    StickyKeysInputMode'Enabled+  | StickyKeysInputMode'Disabled+  deriving (Data, Eq, Show, Typeable)++data StickyMouseButtonsInputMode =+    StickyMouseButtonsInputMode'Enabled+  | StickyMouseButtonsInputMode'Disabled+  deriving (Data, Eq, Show, Typeable)++data ModifierKeys = ModifierKeys+  { modifierKeysShift   :: Bool+  , modifierKeysControl :: Bool+  , modifierKeysAlt     :: Bool+  , modifierKeysSuper   :: Bool+  } deriving (Data, Eq, Show, Typeable)++--------------------------------------------------------------------------------++{-# ANN module "HLint: ignore Use camelCase" #-}

@@ -1,4 +1,4 @@-Copyright Brian Lewis <brian@lorf.org> 2009+Copyright Brian Lewis <brian@lorf.org> 2009-2013  All rights reserved. 

@@ -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)

@@ -1,26 +1,13 @@-Differences between GLFW and GLFW-b 2011.03-===========================================--* GLFW binds to version 2.6 of the GLFW C library. GLFW-b binds to 2.7.--* 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.--* 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 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.--* GLFW contains workarounds for a bugs in GHC < 6.10 FFI. GLFW-b doesn't.+[Haskell][1] bindings to [GLFW][2], an Open Source, multi-platform library for+creating windows with OpenGL contexts and managing input and events. -* GLFW's API is pretty faithful to the C API. GLFW-b prefers to use full words-  and self-explanatory function names.+GLFW-b depends on [bindings-GLFW][3], which, as of the time of this writing,+binds to GLFW 3.0.1, [released 2013-06-17][4]. -* In GLFW-b, registering hints and opening a window are combined into one step.+For a demonstration of GLFW-b, see [GLFW-b-demo][5]. -* GLFW has support for loading textures and rendering strings. GLFW-b doesn't.+[1]: http://www.haskell.org/+[2]: http://www.glfw.org/+[3]: https://github.com/bsl/bindings-GLFW+[4]: http://www.glfw.org/Version-3.0.1-released.html+[5]: https://github.com/bsl/GLFW-b-demo

@@ -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

@@ -0,0 +1,19 @@+Improve everything about testing.+Improve existing tests.+Add more tests.++Is there a better way to accomplish the translation done by the 'C' class that+doesn't require TH?++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.++Coordinate with GLFW C-library maintainer about new functionality.+1.) waitEvents with timeout?

@@ -0,0 +1,511 @@+-- base+import Control.Concurrent (threadDelay)+import Data.Char          (isAscii)+import Data.List          (intercalate, isPrefixOf)++-- 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]++    True <- GLFW.init++    Just mon <- GLFW.getPrimaryMonitor++    GLFW.windowHint $ GLFW.WindowHint'Visible False+    mwin@(Just win) <- GLFW.createWindow 100 100 "GLFW-b test" Nothing Nothing+    GLFW.makeContextCurrent mwin++    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    = 0+versionRevision = 1++version :: GLFW.Version+version = GLFW.Version versionMajor versionMinor versionRevision++giveItTime :: IO ()+giveItTime = threadDelay 250000++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,2000)+    , GLFW.videoModeRedBits     vm `between` (0,  32)+    , GLFW.videoModeGreenBits   vm `between` (0,  32)+    , GLFW.videoModeBlueBits    vm `between` (0,  32)+    , GLFW.videoModeRefreshRate vm `between` (0, 120)+    ]++--------------------------------------------------------------------------------++tests :: GLFW.Monitor -> GLFW.Window -> [Test]+tests mon win =+    [ testGroup "Initialization and version information"+      [ testCase "getVersion"       test_getVersion+      , testCase "getVersionString" test_getVersionString+      ]+    , testGroup "Monitor handling"+      [ testCase "getMonitors"              test_getMonitors+      , testCase "getPrimaryMonitor"        test_getPrimaryMonitor+      , testCase "getMonitorPos"          $ test_getMonitorPos mon+      , testCase "getMonitorPhysicalSize" $ test_getMonitorPhysicalSize mon+      , testCase "getMonitorName"         $ test_getMonitorName mon+      , testCase "getVideoModes"          $ test_getVideoModes mon+      , testCase "getVideoMode"           $ test_getVideoMode mon+      , testCase "getGamma"               $ test_getGammaRamp mon+      -- , testCase "setGamma"               $ test_setGamma mon+      -- , testCase "gamma ramp"             $ test_gamma_ramp mon+      ]+    , testGroup "Window handling"+      [ testCase "defaultWindowHints"             test_defaultWindowHints+      , testCase "window close flag"            $ test_window_close_flag win+      , testCase "setWindowTitle"               $ test_setWindowTitle win+      , testCase "window pos"                   $ test_window_pos win+      , testCase "window size"                  $ test_window_size win+      , testCase "getFramebufferSize"           $ test_getFramebufferSize win+      , testCase "iconification"                $ test_iconification win+      -- , testCase "show/hide"                    $ test_show_hide win+      , testCase "getWindowMonitor"             $ test_getWindowMonitor win mon+      , testCase "cursor pos"                   $ test_cursor_pos win+      , testCase "getWindowFocused"             $ test_getWindowFocused win+      , testCase "getWindowResizable"           $ test_getWindowResizable win+      , testCase "getWindowDecorated"           $ test_getWindowDecorated win+      , testCase "getWindowClientAPI"           $ test_getWindowClientAPI win+      , testCase "window context version"       $ test_window_context_version win+      , testCase "getWindowContextRobustness"   $ test_getWindowContextRobustness win+      , testCase "getWindowOpenGLForwardCompat" $ test_getWindowOpenGLForwardCompat win+      , testCase "getWindowOpenGLDebugContext"  $ test_getWindowOpenGLDebugContext win+      , testCase "getWindowOpenGLProfile"       $ test_getWindowOpenGLProfile win+      , testCase "pollEvents"                     test_pollEvents+      , testCase "waitEvents"                     test_waitEvents+      ]+    , testGroup "Input handling"+      [ testCase "cursor input mode"               $ test_cursor_input_mode win+      , testCase "sticky keys input mode"          $ test_sticky_keys_input_mode win+      , testCase "sticky mouse buttons input mode" $ test_sticky_mouse_buttons_input_mode win+      , testCase "joystickPresent"                   test_joystickPresent+      , testCase "getJoystickAxes"                   test_getJoystickAxes+      , testCase "getJoystickButtons"                test_getJoystickButtons+      , testCase "getJoystickName"                   test_getJoystickName+      ]+    , testGroup "Time"+      [ testCase "getTime" test_getTime+      , testCase "setTime" test_setTime+      ]+    , testGroup "Context"+      [ testCase "getCurrentContext"  $ test_getCurrentContext win+      , testCase "swapBuffers"        $ test_swapBuffers win+      , testCase "swapInterval"         test_swapInterval+      , testCase "extensionSupported"   test_extensionSupported+      ]+    , testGroup "Clipboard"+      [ testCase "clipboard" $ test_clipboard win+      ]+    ]++--------------------------------------------------------------------------------++test_getVersion :: IO ()+test_getVersion = do+    v <- GLFW.getVersion+    v                      @?= version+    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, versionRevision]++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_getMonitorName :: GLFW.Monitor -> IO ()+test_getMonitorName mon = do+    mname <- GLFW.getMonitorName mon+    case mname of+      Nothing   -> assertFailure ""+      Just name -> do+          assertBool "" $ length name `between` (0, 20)+          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_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_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 = 17+        h = 37+    GLFW.setWindowSize win w h+    giveItTime+    (w', h') <- GLFW.getWindowSize win+    w' @?= w+    h' @?= h++test_getFramebufferSize :: GLFW.Window -> IO ()+test_getFramebufferSize win = do+    (w, h) <- GLFW.getWindowSize win+    (fw, fh) <- GLFW.getFramebufferSize win+    fw @?= w+    fh @?= h++test_iconification :: GLFW.Window -> IO ()+test_iconification win = do+    is0 <- GLFW.getWindowIconified win+    is0 @?= GLFW.IconifyState'NotIconified++    GLFW.iconifyWindow win+    giveItTime+    is1 <- GLFW.getWindowIconified win+    is1 @?= GLFW.IconifyState'Iconified++    GLFW.restoreWindow 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_cursor_pos :: GLFW.Window -> IO ()+test_cursor_pos win = do+    (w, h) <- GLFW.getWindowSize win+    let cx = fromIntegral w / 2+        cy = fromIntegral h / 2+    GLFW.setCursorPos win cx cy+    giveItTime+    (cx', cy') <- GLFW.getCursorPos win+    cx' @?= cx+    cy' @?= cy++test_getWindowFocused :: GLFW.Window -> IO ()+test_getWindowFocused win = do+    fs <- GLFW.getWindowFocused win+    fs @?= GLFW.FocusState'Defocused++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+    v2 <- GLFW.getWindowContextVersionRevision win+    assertBool "" $ all (`between` (0, 20)) [v0, v1, v2]++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.waitEvents++--------------------------------------------------------------------------------++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_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_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+        GLFW.getClipboardString win++--------------------------------------------------------------------------------++{-# ANN module "HLint: ignore Use camelCase" #-}

@@ -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_ */-

@@ -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.-}-

@@ -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 );-}-

@@ -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;-}-

@@ -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;-}-

@@ -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;-}-

@@ -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;-}-

@@ -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 );-}-

@@ -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 );-}-

@@ -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_

@@ -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;-    }-}-

@@ -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 );-}-

@@ -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;-    }-}-

@@ -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;-}-

@@ -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;-}-

@@ -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 );-    }-}-