    --------------------------------------------------------------------------------
    -- |
    -- Module      :  Graphics.UI.GLUT.Initialization
    -- Copyright   :  (c) Sven Panne 2002-2013
    -- License     :  BSD3
    --
    -- Maintainer  :  Sven Panne <svenpanne@gmail.com>
    -- Stability   :  stable
    -- Portability :  portable
    --
    -- Actions and state variables in this module are used to initialize GLUT state.
    -- The primary initialization routine is 'initialize', which should only be
    -- called exactly once in a GLUT program. No other GLUT or OpenGL actions should
    -- be called before 'initialize', apart from getting or setting the state
    -- variables in this module.
    --
    -- The reason is that these state variables can be used to set default window
    -- initialization state that might be modified by the command processing done in
    -- 'initialize'. For example, 'initialWindowSize' can be set to @('Size'
    -- 400 400)@ before 'initialize' is called to indicate 400 by 400 is the
    -- program\'s default window size. Setting the initial window size or position
    -- before 'initialize' allows the GLUT program user to specify the initial size
    -- or position using command line arguments.
    --
    --------------------------------------------------------------------------------

    module Graphics.UI.GLUT.Initialization (
       -- * Primary initialization
       initialize, getArgsAndInitialize, exit,

       -- * Initial window geometry
       initialWindowPosition, initialWindowSize,

       -- * Setting the initial display mode (I)
       DisplayMode(..), initialDisplayMode, displayModePossible,

       -- * Setting the initial display mode (II)
       DisplayCapability(..), Relation(..), DisplayCapabilityDescription(..),
       initialDisplayCapabilities,

       -- * Controlling the creation of rendering contexts
       RenderingContext(..), renderingContext,

       -- * Direct\/indirect rendering
       DirectRendering(..), directRendering,

       -- * OpenGL 3.x context support
       initialContextVersion, ContextFlag(..), initialContextFlags,
       ContextProfile(..), initialContextProfile
    ) where

    import Control.Monad ( when )
    import Control.Monad.IO.Class ( MonadIO(..) )
    import Data.Bits ( Bits(..) )
    import Data.List ( genericLength, intersperse, mapAccumR )
    import Data.StateVar ( get, ($=), GettableStateVar, makeGettableStateVar
                         , SettableStateVar, makeSettableStateVar, StateVar, makeStateVar )
    import Foreign.C.String ( peekCString, withCString )
    import Foreign.C.Types ( CInt, CUInt )
    import Foreign.Marshal.Array ( peekArray, withArray0 )
    import Foreign.Marshal.Utils ( with, withMany )
    import Foreign.Ptr ( nullPtr )
    import Foreign.Storable ( peek )
    import Graphics.Rendering.OpenGL ( Position(..), Size(..) )
    import System.Environment ( getArgs, getProgName )

    import Graphics.UI.GLUT.QueryUtils
    import Graphics.UI.GLUT.Raw
    import Graphics.UI.GLUT.Types

    --------------------------------------------------------------------------------

    -- | Given the program name and command line arguments, initialize the GLUT
    -- library and negotiate a session with the window system. During this
    -- process, 'initialize' may cause the termination of the GLUT program with an
    -- error message to the user if GLUT cannot be properly initialized.
    -- Examples of this situation include the failure to connect to the window
    -- system, the lack of window system support for OpenGL, and invalid command
    -- line options.
    --
    -- 'initialize' also processes command line options, but the specific options
    -- parsed are window system dependent. Any command line arguments which are
    -- not GLUT-specific are returned.
    --
    -- /X Implementation Notes:/ The X Window System specific options parsed by
    -- 'initialize' are as follows:
    --
    -- * @-display /DISPLAY/@: Specify the X server to connect to. If not specified,
    --   the value of the @DISPLAY@ environment variable is used.
    --
    -- * @-geometry /WxH+X+Y/@: Determines where windows should be created on the
    --   screen. The parameter following @-geometry@ should be formatted as a
    --   standard X geometry specification. The effect of using this option is to
    --   change the GLUT initial size and initial position the same as if
    --   'initialWindowSize' or 'initialWindowPosition' were modified directly.
    --
    -- * @-iconic@: Requests all top-level windows be created in an iconic state.
    --
    -- * @-indirect@: Force the use of indirect OpenGL rendering contexts.
    --
    -- * @-direct@: Force the use of direct OpenGL rendering contexts (not all GLX
    --   implementations support direct rendering contexts). A fatal error is
    --   generated if direct rendering is not supported by the OpenGL
    --   implementation. If neither @-indirect@ or @-direct@ are used to force a
    --   particular behavior, GLUT will attempt to use direct rendering if
    --   possible and otherwise fallback to indirect rendering.
    --
    -- * @-gldebug@: After processing callbacks and\/or events, call
    --   'Graphics.UI.GLUT.Debugging.reportErrors' to check if there are any pending
    --   OpenGL errors. Using this option is helpful in detecting OpenGL run-time
    --   errors.
    --
    -- * @-sync@: Enable synchronous X protocol transactions. This option makes
    --   it easier to track down potential X protocol errors.

    initialize :: MonadIO m
               => String      -- ^ The program name.
               -> [String]    -- ^ The command line arguments
               -> m [String] -- ^ Non-GLUT command line arguments
    initialize prog args = liftIO $
       with (1 + genericLength args) $ \argcBuf ->
       withMany withCString (prog : args) $ \argvPtrs ->
       withArray0 nullPtr argvPtrs $ \argvBuf -> do
       glutInit argcBuf argvBuf
       newArgc <- peek argcBuf
       newArgvPtrs <- peekArray (fromIntegral newArgc) argvBuf
       newArgv <- mapM peekCString newArgvPtrs
       return $ tail newArgv

    -- | Convenience action: Initialize GLUT, returning the program name and any
    -- non-GLUT command line arguments.

    getArgsAndInitialize :: MonadIO m => m (String, [String])
    getArgsAndInitialize = liftIO $ do
       prog <- getProgName
       args <- getArgs
       nonGLUTArgs <- initialize prog args
       return (prog, nonGLUTArgs)

    -----------------------------------------------------------------------------

    -- | (/freeglut only/) De-initialize GLUT. After this, one has to use
    -- 'initialize' or 'getArgsAndInitialize' to initialize GLUT again.

    exit :: MonadIO m => m ()
    exit = glutExit

    --------------------------------------------------------------------------------

    -- | Controls the /initial window position/.  Windows created by
    -- 'Graphics.UI.GLUT.Window.createWindow' will be requested to be created with
    -- the current /initial window position/. The initial value of the /initial
    -- window position/ GLUT state is @'Position' (-1) (-1)@. If either the X or Y
    -- component of the /initial window position/ is negative, the actual window
    -- position is left to the window system to determine.
    --
    -- The intent of the /initial window position/ is to provide a suggestion to
    -- the window system for a window\'s initial position. The window system is
    -- not obligated to use this information. Therefore, GLUT programs should not
    -- assume the window was created at the specified position.

    initialWindowPosition :: StateVar Position
    initialWindowPosition =
       makeStateVar getInitialWindowPosition setInitialWindowPosition

    getInitialWindowPosition :: IO Position
    getInitialWindowPosition = do
       x <- simpleGet fromIntegral glut_INIT_WINDOW_X
       y <- simpleGet fromIntegral glut_INIT_WINDOW_Y
       return $ Position x y

    setInitialWindowPosition :: Position -> IO ()
    setInitialWindowPosition (Position x y) =
        glutInitWindowPosition (fromIntegral x) (fromIntegral y)

    --------------------------------------------------------------------------------

    -- | Controls the /initial window size/.  Windows created by
    -- 'Graphics.UI.GLUT.Window.createWindow' will be requested to be created with
    -- the current /initial window size/. The initial value of the /initial window
    -- size/ GLUT state is @'Size' 300 300@. If either the width or the height
    -- component of the /initial window size/ is non-positive, the actual window
    -- size is left to the window system to determine.
    --
    -- The intent of the /initial window size/ is to provide a suggestion to the
    -- window system for a window\'s initial size. The window system is not
    -- obligated to use this information. Therefore, GLUT programs should not
    -- assume the window was created at the specified size. A GLUT program should
    -- use the window\'s reshape callback to determine the true size of the
    -- window.

    initialWindowSize :: StateVar Size
    initialWindowSize = makeStateVar getInitialWindowSize setInitialWindowSize

    getInitialWindowSize :: IO Size
    getInitialWindowSize = do
       w <- simpleGet fromIntegral glut_INIT_WINDOW_WIDTH
       h <- simpleGet fromIntegral glut_INIT_WINDOW_HEIGHT
       return $ Size w h

    setInitialWindowSize :: Size -> IO ()
    setInitialWindowSize (Size w h) =
       glutInitWindowSize (fromIntegral w) (fromIntegral h)

    --------------------------------------------------------------------------------

    -- | A single aspect of a window which is to be created, used in conjunction
    -- with 'initialDisplayMode'.

    data DisplayMode
       = RGBAMode
         -- ^ Select an RGBA mode window. This is the default if neither 'RGBAMode'
         -- nor 'IndexMode' are specified.
       | RGBMode
         -- ^ An alias for 'RGBAMode'.
       | IndexMode
         -- ^ Select a color index mode window. This overrides 'RGBAMode' if it is
         -- also specified.
       | LuminanceMode
         -- ^ Select a window with a \"luminance\" color model. This model provides
         -- the functionality of OpenGL\'s RGBA color model, but the green and blue
         -- components are not maintained in the frame buffer. Instead each pixel\'s
         -- red component is converted to an index between zero and
         --  'Graphics.UI.GLUT.Colormap.numColorMapEntries' and looked up in a
         -- per-window color map to determine the color of pixels within the window.
         -- The initial colormap of 'LuminanceMode' windows is initialized to be a
         -- linear gray ramp, but can be modified with GLUT\'s colormap actions.
         -- /Implementation Notes:/ 'LuminanceMode' is not supported on most OpenGL
         -- platforms.
       | WithAlphaComponent
         -- ^ Select a window with an alpha component to the color buffer(s).
       | WithAccumBuffer
         -- ^ Select a window with an accumulation buffer.
       | WithDepthBuffer
         -- ^ Select a window with a depth buffer.
       | WithStencilBuffer
         -- ^ Select a window with a stencil buffer.
       | WithAuxBuffers Int
         -- ^ (/freeglut only/) Select a window with /n/ (1 .. 4) auxiliary buffers.
         -- Any /n/ outside the range 1 .. 4 is a fatal error.
       | SingleBuffered
         -- ^ Select a single buffered window. This is the default if neither
         -- 'DoubleBuffered' nor 'SingleBuffered' are specified.
       | DoubleBuffered
         -- ^ Select a double buffered window. This overrides 'SingleBuffered' if it
         -- is also specified.
       | Multisampling
         -- ^ Select a window with multisampling support. If multisampling is not
         -- available, a non-multisampling window will automatically be chosen.
         -- Note: both the OpenGL client-side and server-side implementations must
         -- support the @GLX_SAMPLE_SGIS@ extension for multisampling to be
         -- available. Deprecated, use 'WithSamplesPerPixel'.
       | WithSamplesPerPixel Int
         -- ^ Select a window with multisampling, using the given samples per pixel.
       | Stereoscopic
         -- ^ Select a stereo window.
       | Captionless
         -- ^ Select a window without a caption (/freeglut only/).
       | Borderless
         -- ^ Select a window without any borders (/freeglut only/).
       | SRGBMode
         -- ^ Select an sRGB mode window (/freeglut only/).
       deriving ( Eq, Ord, Show )

    marshalDisplayMode :: DisplayMode -> CUInt
    marshalDisplayMode m = case m of
       RGBAMode -> glut_RGBA
       RGBMode -> glut_RGB
       IndexMode -> glut_INDEX
       LuminanceMode -> glut_LUMINANCE
       WithAlphaComponent -> glut_ALPHA
       WithAccumBuffer -> glut_ACCUM
       WithDepthBuffer -> glut_DEPTH
       WithStencilBuffer -> glut_STENCIL
       WithAuxBuffers 1 -> glut_AUX1
       WithAuxBuffers 2 -> glut_AUX2
       WithAuxBuffers 3 -> glut_AUX3
       WithAuxBuffers 4 -> glut_AUX4
       WithAuxBuffers n ->
          error ("marshalDisplayMode: illegal number of auxiliary buffers: " ++ show n)
       SingleBuffered -> glut_SINGLE
       DoubleBuffered -> glut_DOUBLE
       Multisampling -> glut_MULTISAMPLE
       WithSamplesPerPixel _ -> error ("marshalDisplayMode: this should not happen")
       Stereoscopic -> glut_STEREO
       Captionless -> glut_CAPTIONLESS
       Borderless -> glut_BORDERLESS
       SRGBMode -> glut_SRGB

    --------------------------------------------------------------------------------

    -- | Controls the /initial display mode/ used when creating top-level windows,
    -- subwindows, and overlays to determine the OpenGL display mode for the
    -- to-be-created window or overlay.
    --
    -- Note that 'RGBAMode' selects the RGBA color model, but it does not request any
    -- bits of alpha (sometimes called an /alpha buffer/ or /destination alpha/)
    -- be allocated. To request alpha, specify 'WithAlphaComponent'. The same
    -- applies to 'LuminanceMode'.

    initialDisplayMode :: StateVar [DisplayMode]
    initialDisplayMode = makeStateVar getInitialDisplayMode setInitialDisplayMode

    getInitialDisplayMode :: IO [DisplayMode]
    getInitialDisplayMode = do
       mode <- simpleGet fromIntegral glut_INIT_DISPLAY_MODE
       let displayModes = i2dms (mode .&. complement glut_MULTISAMPLE)
       if mode .&. glut_MULTISAMPLE == 0
          then return displayModes
          else do
             n <- get samplesPerPixel
             return $ WithSamplesPerPixel n : displayModes

    i2dms :: CUInt -> [DisplayMode]
    i2dms bitfield | IndexMode `elem` modes || LuminanceMode `elem` modes = modes
                   | otherwise = RGBAMode : modes
       where modes = i2dmsWithoutRGBA bitfield

    i2dmsWithoutRGBA :: CUInt -> [DisplayMode]
    i2dmsWithoutRGBA bitfield =
       [ c | c <- [ IndexMode, LuminanceMode, WithAlphaComponent,
                    WithAccumBuffer, WithDepthBuffer, WithStencilBuffer,
                    WithAuxBuffers 1, WithAuxBuffers 2, WithAuxBuffers 3,
                    WithAuxBuffers 4, SingleBuffered, DoubleBuffered, Multisampling,
                    Stereoscopic, Captionless, Borderless, SRGBMode ]
           , (bitfield .&. marshalDisplayMode c) /= 0 ]

    setInitialDisplayMode :: [DisplayMode] -> IO ()
    setInitialDisplayMode modes = do
       let (spps, transformedModes) = mapAccumR handleMultisampling [] modes
       mapM_ (samplesPerPixel $=) spps
       glutInitDisplayMode (toBitfield marshalDisplayMode transformedModes)

    handleMultisampling :: [Int] -> DisplayMode -> ([Int], DisplayMode)
    handleMultisampling spps (WithSamplesPerPixel spp) = (spp : spps, Multisampling)
    handleMultisampling spps mode                      = (spps, mode)

    toBitfield :: (Num b, Bits b) => (a -> b) -> [a] -> b
    toBitfield marshal = foldl (.|.) 0 . map marshal

    -- | Contains 'True' if the /current display mode/ is supported, 'False'
    -- otherwise.

    displayModePossible :: GettableStateVar Bool
    displayModePossible =
       makeGettableStateVar $ simpleGet (/= 0) glut_DISPLAY_MODE_POSSIBLE

    --------------------------------------------------------------------------------

    samplesPerPixel :: StateVar Int
    samplesPerPixel = makeStateVar getSamplesPerPixel setSamplesPerPixel

    getSamplesPerPixel :: IO Int
    getSamplesPerPixel = do
       m <- multisamplingSupported
       if m
          then simpleGet fromIntegral (fromIntegral glut_MULTISAMPLE)
          else return defaultSamplesPerPixels

    defaultSamplesPerPixels :: Int
    defaultSamplesPerPixels = 4

    setSamplesPerPixel :: Int -> IO ()
    setSamplesPerPixel spp = do
       m <- multisamplingSupported
       when m $
          glutSetOption (fromIntegral glut_MULTISAMPLE) (fromIntegral spp)

    multisamplingSupported :: IO Bool
    multisamplingSupported = isKnown "glutGetModeValues"

    --------------------------------------------------------------------------------

    -- | Capabilities for 'initialDisplayCapabilities', most of them are extensions
    -- of the constructors of 'DisplayMode'.

    data DisplayCapability
       = DisplayRGBA  -- ^ Number of bits of red, green, blue, and alpha in the RGBA
                      --   color buffer. Default is \"'IsAtLeast' @1@\" for red,
                      --   green, blue, and alpha capabilities, and \"'IsEqualTo'
                      --   @1@\" for the RGBA color model capability.
       | DisplayRGB   -- ^ Number of bits of red, green, and blue in the RGBA color
                      --   buffer and zero bits of alpha color buffer precision.
                      --   Default is \"'IsAtLeast' @1@\" for the red, green, and
                      --   blue capabilities, and \"'IsNotLessThan' @0@\" for alpha
                      --   capability, and \"'IsEqualTo' @1@\" for the RGBA color
                      --   model capability.
       | DisplayRed   -- ^ Red color buffer precision in bits. Default is
                      --   \"'IsAtLeast' @1@\".
       | DisplayGreen -- ^ Green color buffer precision in bits. Default is
                      --   \"'IsAtLeast' @1@\".
       | DisplayBlue  -- ^ Blue color buffer precision in bits. Default is
                      --   \"'IsAtLeast' @1@\".
       | DisplayIndex -- ^ Boolean if the color model is color index or not. True is
                      --   color index. Default is \"'IsAtLeast' @1@\".
       | DisplayBuffer -- ^ Number of bits in the color index color buffer. Default
                      --   is \"'IsAtLeast' @1@\".
       | DisplaySingle -- ^ Boolean indicate the color buffer is single buffered.
                      --   Default is \"'IsEqualTo' @1@\".
       | DisplayDouble -- ^ Boolean indicating if the color buffer is double
                      --   buffered. Default is \"'IsEqualTo' @1@\".
       | DisplayAccA  -- ^ Red, green, blue, and alpha accumulation buffer precision
                      --   in  bits. Default is \"'IsAtLeast' @1@\" for red, green,
                      --   blue, and alpha capabilities.
       | DisplayAcc   -- ^ Red, green, and green accumulation buffer precision in
                      --   bits and zero bits of alpha accumulation buffer precision.
                      --   Default is \"'IsAtLeast' @1@\" for red, green, and blue
                      --   capabilities, and \"'IsNotLessThan' @0@\" for the alpha
                      --   capability.
       | DisplayAlpha -- ^ Alpha color buffer precision in bits. Default is
                      --   \"'IsAtLeast' @1@\".
       | DisplayDepth -- ^ Number of bits of precsion in the depth buffer. Default
                      --   is \"'IsAtLeast' @12@\".
       | DisplayStencil -- ^ Number of bits in the stencil buffer. Default is
                      --   \"'IsNotLessThan' @1@\".
       | DisplaySamples -- ^ Indicates the number of multisamples to use based on
                      --   GLX\'s @SGIS_multisample@ extension (for antialiasing).
                      --   Default is \"'IsNotGreaterThan' @4@\". This default means
                      --   that a GLUT application can request multisampling if
                      --   available by simply specifying \"'With' 'DisplaySamples'\".
       | DisplayStereo -- ^ Boolean indicating the color buffer is supports
                      --   OpenGL-style stereo. Default is \"'IsEqualTo' @1@\".
       | DisplayLuminance -- ^ Number of bits of red in the RGBA and zero bits of green,
                      --   blue (alpha not specified) of color buffer precision.
                      --   Default is \"'IsAtLeast' @1@\" for the red capabilitis,
                      --   and \"'IsEqualTo' @0@\" for the green and blue
                      --   capabilities, and \"'IsEqualTo' @1@\" for the RGBA color
                      --   model capability, and, for X11, \"'IsEqualTo' @1@\" for
                      --   the 'DisplayXStaticGray' capability. SGI InfiniteReality (and
                      --   other future machines) support a 16-bit luminance (single
                      --   channel) display mode (an additional 16-bit alpha channel
                      --   can also be requested). The red channel maps to gray
                      --   scale and green and blue channels are not available. A
                      --   16-bit precision luminance display mode is often
                      --   appropriate for medical imaging applications. Do not
                      --   expect many machines to support extended precision
                      --   luminance display modes.
       | DisplayAux   -- ^ (/freeglut only/) Number of auxiliary buffers. Default is
                      --   \"'IsEqualTo' @1@\".
       | DisplayNum   -- ^ A special capability name indicating where the value
                      --   represents the Nth frame buffer configuration matching
                      --   the description string. When not specified,
                      --   'initialDisplayCapabilities' also uses the first
                      --   (best matching) configuration. 'Num' requires a relation
                      --   and numeric value.
       | DisplayConformant -- ^ Boolean indicating if the frame buffer configuration is
                      --   conformant or not. Conformance information is based on
                      --   GLX\'s @EXT_visual_rating@ extension if supported. If the
                      --   extension is not supported, all visuals are assumed
                      --   conformant. Default is \"'IsEqualTo' @1@\".
       | DisplaySlow  -- ^ Boolean indicating if the frame buffer configuration is
                      --   slow or not. Slowness information is based on GLX\'s
                      --   @EXT_visual_rating@ extension if supported. If the
                      --   extension is not supported, all visuals are assumed fast.
                      --   Note that slowness is a relative designation relative to
                      --   other frame buffer configurations available. The intent
                      --   of the slow capability is to help programs avoid frame
                      --   buffer configurations that are slower (but perhaps higher
                      --   precision) for the current machine. Default is
                      --   \"'IsAtLeast' @0@\". This default means that slow visuals
                      --   are used in preference to fast visuals, but fast visuals
                      --   will still be allowed.
       | DisplayWin32PFD -- ^ Only recognized on GLUT implementations for Win32, this
                      --   capability name matches the Win32 Pixel Format Descriptor
                      --   by number. 'DisplayWin32PFD' can only be used with 'Where'.
       | DisplayXVisual -- ^ Only recongized on GLUT implementations for the X Window
                      --   System, this capability name matches the X visual ID by
                      --   number. 'DisplayXVisual' requires a relation and numeric value.
       | DisplayXStaticGray -- ^ Only recongized on GLUT implementations for the X Window
                      --   System, boolean indicating if the frame buffer
                      --   configuration\'s X visual is of type @StaticGray@.
                      --   Default is \"'IsEqualTo' @1@\".
       | DisplayXGrayScale -- ^ Only recongized on GLUT implementations for the X Window
                      --   System, boolean indicating if the frame buffer
                      --   configuration\'s X visual is of type @GrayScale@. Default
                      --   is \"'IsEqualTo' @1@\".
       | DisplayXStaticColor -- ^ Only recongized on GLUT implementations for the X Window
                      --   System, boolean indicating if the frame buffer
                      --   configuration\'s X visual is of type @StaticColor@.
                      --   Default is \"'IsEqualTo' @1@\".
       | DisplayXPseudoColor -- ^ Only recongized on GLUT implementations for the X Window
                      --   System, boolean indicating if the frame buffer
                      --   configuration\'s X visual is of type @PsuedoColor@.
                      --   Default is \"'IsEqualTo' @1@\".
       | DisplayXTrueColor -- ^ Only recongized on GLUT implementations for the X Window
                      --   System, boolean indicating if the frame buffer
                      --   configuration\'s X visual is of type @TrueColor@. Default
                      --   is \"'IsEqualTo' @1@\".
       | DisplayXDirectColor -- ^ Only recongized on GLUT implementations for the X Window
                      --   System, boolean indicating if the frame buffer
                      --   configuration\'s X visual is of type @DirectColor@.
                      --   Default is \"'IsEqualTo' @1@\".
       deriving ( Eq, Ord, Show )

    displayCapabilityToString :: DisplayCapability -> String
    displayCapabilityToString x = case x of
       DisplayRGBA         -> "rgba"
       DisplayRGB          -> "rgb"
       DisplayRed          -> "red"
       DisplayGreen        -> "green"
       DisplayBlue         -> "blue"
       DisplayIndex        -> "index"
       DisplayBuffer       -> "buffer"
       DisplaySingle       -> "single"
       DisplayDouble       -> "double"
       DisplayAccA         -> "acca"
       DisplayAcc          -> "acc"
       DisplayAlpha        -> "alpha"
       DisplayDepth        -> "depth"
       DisplayStencil      -> "stencil"
       DisplaySamples      -> "samples"
       DisplayStereo       -> "stereo"
       DisplayLuminance    -> "luminance"
       DisplayAux          -> "aux"
       DisplayNum          -> "num"
       DisplayConformant   -> "conformant"
       DisplaySlow         -> "slow"
       DisplayWin32PFD     -> "win32pfd"
       DisplayXVisual      -> "xvisual"
       DisplayXStaticGray  -> "xstaticgray"
       DisplayXGrayScale   -> "xgrayscale"
       DisplayXStaticColor -> "xstaticcolor"
       DisplayXPseudoColor -> "xpseudocolor"
       DisplayXTrueColor   -> "xtruecolor"
       DisplayXDirectColor -> "xdirectcolor"

    -- | A single capability description for 'initialDisplayCapabilities'.

    data DisplayCapabilityDescription
       = Where DisplayCapability Relation Int
         -- ^ A description of a capability with a specific relation to a numeric
         --   value.
       | With  DisplayCapability
         -- ^ When the relation and numeric value are not specified, each capability
         --   has a different default, see the different constructors of
         --   'DisplayCapability'.
       deriving ( Eq, Ord, Show )

    displayCapabilityDescriptionToString ::  DisplayCapabilityDescription -> String
    displayCapabilityDescriptionToString (Where c r i) =
       displayCapabilityToString c ++ relationToString r ++ show i
    displayCapabilityDescriptionToString (With c) = displayCapabilityToString c

    -- | Controls the /initial display mode/ used when creating top-level windows,
    -- subwindows, and overlays to determine the OpenGL display mode for the
    -- to-be-created window or overlay. It is described by a list of zero or more
    -- capability descriptions, which are translated into a set of criteria used to
    -- select the appropriate frame buffer configuration. The criteria are matched
    -- in strict left to right order of precdence. That is, the first specified
    -- criterion (leftmost) takes precedence over the later criteria for non-exact
    -- criteria ('IsGreaterThan', 'IsLessThan', etc.). Exact criteria ('IsEqualTo',
    -- 'IsNotEqualTo') must match exactly so precedence is not relevant.
    --
    -- Unspecified capability descriptions will result in unspecified criteria being
    -- generated. These unspecified criteria help 'initialDisplayCapabilities'
    -- behave sensibly with terse display mode descriptions.
    --
    -- Here is an example using 'initialDisplayCapabilities':
    --
    -- @
    --    initialDisplayCapabilities $= [ With  DisplayRGB,
    --                                    Where DisplayDepth IsAtLeast 16,
    --                                    With  DisplaySamples,
    --                                    Where DisplayStencil IsNotLessThan 2,
    --                                    With  DisplayDouble ]
    -- @
    --
    -- The above call requests a window with an RGBA color model (but requesting
    -- no bits of alpha), a depth buffer with at least 16 bits of precision but
    -- preferring more, multisampling if available, at least 2 bits of stencil
    -- (favoring less stencil to more as long as 2 bits are available), and double
    -- buffering.

    initialDisplayCapabilities :: SettableStateVar [DisplayCapabilityDescription]
    initialDisplayCapabilities =
       makeSettableStateVar $ \caps ->
          withCString
             (concat . intersperse " " . map displayCapabilityDescriptionToString $
              caps)
             glutInitDisplayString

    -----------------------------------------------------------------------------

    -- | How rendering context for new windows are created.

    data RenderingContext
       = -- | Create a new context via @glXCreateContext@ or @wglCreateContext@
         --   (default).
         CreateNewContext
       | -- | Re-use the current rendering context.
         UseCurrentContext
       deriving ( Eq, Ord, Show )

    marshalRenderingContext :: RenderingContext -> CInt
    marshalRenderingContext CreateNewContext  = glut_CREATE_NEW_CONTEXT
    marshalRenderingContext UseCurrentContext = glut_USE_CURRENT_CONTEXT

    unmarshalRenderingContext :: CInt -> RenderingContext
    unmarshalRenderingContext r
       | r == glut_CREATE_NEW_CONTEXT  = CreateNewContext
       | r == glut_USE_CURRENT_CONTEXT = UseCurrentContext
       | otherwise = error "unmarshalRenderingContext"

    -----------------------------------------------------------------------------

    -- | (/freeglut only/) Controls the creation of rendering contexts for new
    -- windows.

    renderingContext :: StateVar RenderingContext
    renderingContext =
       makeStateVar
          (simpleGet unmarshalRenderingContext glut_RENDERING_CONTEXT)
          (glutSetOption glut_RENDERING_CONTEXT . marshalRenderingContext)

    -----------------------------------------------------------------------------

    -- | The kind of GLX rendering context used. Direct rendering provides a
    -- performance advantage in some implementations. However, direct rendering
    -- contexts cannot be shared outside a single process, and they may be unable
    -- to render to GLX pixmaps.

    data DirectRendering
       = -- | Rendering is always done through the X server. This corresponds to
         -- the command line argument @-indirect@, see 'initialize'.
         ForceIndirectContext
       | -- | Try to use direct rendering, silently using indirect rendering if this
         -- is not possible.
         AllowDirectContext
       | -- | Try to use direct rendering, issue a warning and use indirect
         -- rendering if this is not possible.
         TryDirectContext
       | -- | Try to use direct rendering, issue an error and terminate the program
         -- if this is not possible.This corresponds to the command line argument
         -- @-direct@, see 'initialize'.
         ForceDirectContext
       deriving ( Eq, Ord, Show )

    marshalDirectRendering :: DirectRendering -> CInt
    marshalDirectRendering x = case x of
       ForceIndirectContext -> glut_FORCE_INDIRECT_CONTEXT
       AllowDirectContext -> glut_ALLOW_DIRECT_CONTEXT
       TryDirectContext -> glut_TRY_DIRECT_CONTEXT
       ForceDirectContext -> glut_FORCE_DIRECT_CONTEXT

    unmarshalDirectRendering :: CInt -> DirectRendering
    unmarshalDirectRendering x
       | x == glut_FORCE_INDIRECT_CONTEXT = ForceIndirectContext
       | x == glut_ALLOW_DIRECT_CONTEXT = AllowDirectContext
       | x == glut_TRY_DIRECT_CONTEXT = TryDirectContext
       | x == glut_FORCE_DIRECT_CONTEXT = ForceDirectContext
       | otherwise = error ("unmarshalDirectRendering: illegal value " ++ show x)

    -----------------------------------------------------------------------------

    -- | (/freeglut on X11 only/) Controls which kind of rendering context is
    -- created when a new one is required.

    directRendering :: StateVar DirectRendering
    directRendering =
       makeStateVar
          (simpleGet unmarshalDirectRendering glut_DIRECT_RENDERING)
          (glutSetOption glut_DIRECT_RENDERING . marshalDirectRendering)

    -----------------------------------------------------------------------------

    -- | (/freeglut only/) Controls the API major\/minor version of the OpenGL
    -- context. If a version less than or equal to 2.1 is requested, the context
    -- returned may implement any version no less than that requested and no
    -- greater than 2.1. If version 3.0 is requested, the context returned must
    -- implement exactly version 3.0. Versioning behavior once GL versions beyond
    -- 3.0 are defined will be defined by an amendment to the OpenGL specification
    -- to define dependencies on such GL versions.
    --
    -- 'Graphics.Rendering.OpenGL.GL.StringQueries.glVersion' and
    -- 'Graphics.Rendering.OpenGL.GL.StringQueries.majorMinor' will return the
    -- actual version supported by a context.
    --
    -- The default context version is (1, 0), which will typically return an
    -- OpenGL 2.1 context, if one is available.

    initialContextVersion :: StateVar (Int, Int)
    initialContextVersion = makeStateVar getContextVersion setContextVersion

    getContextVersion :: IO (Int, Int)
    getContextVersion = do
       major <- simpleGet fromIntegral glut_INIT_MAJOR_VERSION
       minor <- simpleGet fromIntegral glut_INIT_MINOR_VERSION
       return (major, minor)

    setContextVersion :: (Int, Int) -> IO ()
    setContextVersion (major, minor) =
       glutInitContextVersion (fromIntegral major) (fromIntegral minor)

    -----------------------------------------------------------------------------

    -- | A flag affecting the rendering context to create, used in conjunction
    -- with 'initialContextFlags'.

    data ContextFlag
       = -- | Debug contexts are intended for use during application development,
         -- and provide additional runtime checking, validation, and logging
         -- functionality while possibly incurring performance penalties. The
         -- additional functionality provided by debug contexts may vary according
         -- to the implementation. In some cases a debug context may be identical
         -- to a non-debug context.
         DebugContext
       | -- | Forward-compatible contexts are defined only for OpenGL versions 3.0
         -- and later. They must not support functionality marked as /deprecated/
         -- by that version of the API, while a non-forward-compatible context must
         -- support all functionality in that version, deprecated or not.
         ForwardCompatibleContext
       deriving ( Eq, Ord, Show )

    marshalContextFlag :: ContextFlag -> CInt
    marshalContextFlag x = case x of
       DebugContext -> glut_DEBUG
       ForwardCompatibleContext -> glut_FORWARD_COMPATIBLE

    -----------------------------------------------------------------------------

    -- | (/freeglut only/) Controls the set of flags for the rendering context.

    initialContextFlags :: StateVar [ContextFlag]
    initialContextFlags = makeStateVar getContextFlags setContextFlags

    getContextFlags :: IO [ContextFlag]
    getContextFlags = simpleGet i2cfs glut_INIT_FLAGS

    i2cfs :: CInt -> [ContextFlag]
    i2cfs bitfield =
       [ c | c <- [ DebugContext, ForwardCompatibleContext ]
           , (fromIntegral bitfield .&. marshalContextFlag c) /= 0 ]

    setContextFlags :: [ContextFlag] -> IO ()
    setContextFlags = glutInitContextFlags . toBitfield marshalContextFlag

    -----------------------------------------------------------------------------

    -- | An OpenGL API profile, affecting the rendering context to create, used
    -- in conjunction with 'initialContextProfile'.

    data ContextProfile
       = -- | The OpenGL /core/ profile, which all OpenGL 3.2 implementations
         -- are required to support.
          CoreProfile
       | -- | The OpenGL /compatibility/ profile, which is optional for OpenGL
         -- 3.2 implementations.
         CompatibilityProfile
       deriving ( Eq, Ord, Show )

    marshalContextProfile :: ContextProfile -> CInt
    marshalContextProfile x = case x of
       CoreProfile -> glut_CORE_PROFILE
       CompatibilityProfile -> glut_COMPATIBILITY_PROFILE

    -----------------------------------------------------------------------------

    -- | (/freeglut only/) Controls the set of profiles for the rendering context.

    initialContextProfile :: StateVar [ContextProfile]
    initialContextProfile = makeStateVar getContextProfiles setContextProfiles

    getContextProfiles :: IO [ContextProfile]
    getContextProfiles = simpleGet i2cps glut_INIT_PROFILE

    i2cps :: CInt -> [ContextProfile]
    i2cps bitfield =
       [ c | c <- [ CoreProfile, CompatibilityProfile ]
           , (fromIntegral bitfield .&. marshalContextProfile c) /= 0 ]

    setContextProfiles :: [ContextProfile] -> IO ()
    setContextProfiles = glutInitContextProfile . toBitfield marshalContextProfile