    {-# LINE 1 "Graphics/UI/SDL/Video.hsc" #-}
    -----------------------------------------------------------------------------
    {-# LINE 2 "Graphics/UI/SDL/Video.hsc" #-}
    -- |
    -- Module      :  Graphics.UI.SDL.Video
    -- Copyright   :  (c) David Himmelstrup 2005
    -- License     :  BSD-like
    --
    -- Maintainer  :  lemmih@gmail.com
    -- Stability   :  provisional
    -- Portability :  portable
    --
    -----------------------------------------------------------------------------
    module Graphics.UI.SDL.Video
        ( Palette
        , Toggle (..)
        , fromToggle
        , toToggle
        , tryGetVideoSurface
        , getVideoSurface
        , tryVideoDriverName
        , videoDriverName
        , getVideoInfo
        , ListModes(..)
        , listModes
        , videoModeOK
        , trySetVideoMode
        , setVideoMode
        , updateRect
        , updateRects
        , tryFlip
        , flip
        , setColors
        , setPalette
        , setGamma
        , tryGetGammaRamp
        , getGammaRamp
        , trySetGammaRamp
        , setGammaRamp
        , mapRGB
        , mapRGBA
        , getRGB
        , getRGBA
        , tryCreateRGBSurface
        , createRGBSurface
        , tryCreateRGBSurfaceEndian
        , createRGBSurfaceEndian
        , tryCreateRGBSurfaceFrom
        , createRGBSurfaceFrom
        , freeSurface
        , lockSurface
        , unlockSurface
        , loadBMP
        , saveBMP
        , setColorKey
        , setAlpha
        , setClipRect
        , getClipRect
        , withClipRect
        , tryConvertSurface
        , convertSurface
        , blitSurface
        , fillRect
        , tryDisplayFormat
        , displayFormat
        , tryDisplayFormatAlpha
        , displayFormatAlpha
        , warpMouse
        , showCursor
        , queryCursorState
        , GLAttr, GLValue
        , glRedSize, glGreenSize, glBlueSize, glAlphaSize, glBufferSize, glDoubleBuffer
        , glDepthSize, glStencilSize, glAccumRedSize, glAccumGreenSize, glAccumBlueSize
        , glAccumAlphaSize, glStereo, glMultiSampleBuffers, glMultiSampleSamples
        , tryGLGetAttribute, glGetAttribute
        , tryGLSetAttribute, glSetAttribute
        , glSwapBuffers
        , mkFinalizedSurface
        ) where

    {-# LINE 80 "Graphics/UI/SDL/Video.hsc" #-}

    {-# LINE 83 "Graphics/UI/SDL/Video.hsc" #-}

    import Foreign (Ptr, FunPtr, Storable(peek), castPtr, plusPtr, nullPtr, newForeignPtr_,
                   finalizeForeignPtr, alloca, withForeignPtr, newForeignPtr)
    import Foreign.C (peekCString, CString, CInt(..))
    import Foreign.Marshal.Array (withArrayLen, peekArray0, peekArray, allocaArray)
    import Foreign.Marshal.Utils (with, toBool, maybeWith, maybePeek, fromBool)
    import Control.Exception (bracket)
    import Data.Word (Word8, Word16, Word32)
    import Data.Int (Int32)

    import Graphics.UI.SDL.Utilities (Enum(..), intToBool, toBitmask, fromCInt, toCInt)
    import Graphics.UI.SDL.General (unwrapMaybe, unwrapBool)
    import Graphics.UI.SDL.Rect (Rect(rectY, rectX, rectW, rectH))
    import Graphics.UI.SDL.Color (Pixel(..), Color)
    import Graphics.UI.SDL.Types (SurfaceFlag, PixelFormat, PixelFormatStruct, RWops,
                                  RWopsStruct, VideoInfo, VideoInfoStruct, Surface, SurfaceStruct)
    import qualified Graphics.UI.SDL.RWOps as RW

    import Prelude hiding (flip,Enum(..))

    --import Foreign.HacanonLight.Generate
    --import Foreign.HacanonLight.DIS (foreignPtr,mkOut,word8)

    data Palette
        = Logical
        | Physical
          deriving (Show,Eq,Ord)

    instance Bounded Palette where
        minBound = Logical
        maxBound = Physical

    instance Enum Palette Int where
        fromEnum Logical = 1
    {-# LINE 117 "Graphics/UI/SDL/Video.hsc" #-}
        fromEnum Physical = 2
    {-# LINE 118 "Graphics/UI/SDL/Video.hsc" #-}
        toEnum 1 = Logical
    {-# LINE 119 "Graphics/UI/SDL/Video.hsc" #-}
        toEnum 2 = Physical
    {-# LINE 120 "Graphics/UI/SDL/Video.hsc" #-}
        toEnum _ = error "Graphics.UI.SDL.Video.toEnum: bad argument"
        succ Logical = Physical
        succ _ = error "Graphics.UI.SDL.Video.succ: bad argument"
        pred Physical = Logical
        pred _ = error "Graphics.UI.SDL.Video.pred: bad argument"
        enumFromTo x y | x > y = []
                       | x == y = [y]
                       | True = x : enumFromTo (succ x) y

    data Toggle = Disable | Enable | Query
        deriving (Eq, Ord, Show)

    toToggle :: (Eq a, Num a) => a -> Toggle
    toToggle (0) = Disable
    {-# LINE 135 "Graphics/UI/SDL/Video.hsc" #-}
    toToggle (1) = Enable
    {-# LINE 136 "Graphics/UI/SDL/Video.hsc" #-}
    toToggle (-1) = Query
    {-# LINE 137 "Graphics/UI/SDL/Video.hsc" #-}
    toToggle _ = error "Graphics.UI.SDL.Video.toToggle: bad argument"

    fromToggle :: (Num a) => Toggle -> a
    fromToggle Disable = 0
    fromToggle Enable = 1
    fromToggle Query = (-1)

    foreign import ccall unsafe "SDL_GetVideoSurface" sdlGetVideoSurface :: IO (Ptr SurfaceStruct)

    -- | Returns the video surface or @Nothing@ on error.
    tryGetVideoSurface :: IO (Maybe Surface)
    tryGetVideoSurface =
        sdlGetVideoSurface >>= maybePeek newForeignPtr_

    -- | Returns the video surface, throwing an exception on error.
    getVideoSurface :: IO Surface
    getVideoSurface = unwrapMaybe "SDL_GetVideoSurface" tryGetVideoSurface

    foreign import ccall unsafe "SDL_VideoDriverName" sdlVideoDriverName :: CString -> CInt -> IO CString

    -- | Returns the video driver name or @Nothing@ on error. Notice, the driver name is limited to 256 chars.
    tryVideoDriverName :: IO (Maybe String)
    tryVideoDriverName
        = allocaArray size (\ptr -> sdlVideoDriverName ptr (toCInt size) >>= maybePeek peekCString)
        where size = 256

    -- | Returns the video driver name, throwing an exception on error. See also 'tryVideoDriverName'.
    videoDriverName :: IO String
    videoDriverName = unwrapMaybe "SDL_VideoDriverName" tryVideoDriverName

    foreign import ccall unsafe "SDL_GetVideoInfo" sdlGetVideoInfo :: IO (Ptr VideoInfoStruct)
    getVideoInfo :: IO VideoInfo
    getVideoInfo = sdlGetVideoInfo >>= newForeignPtr_

    data ListModes
        = Modes [Rect] -- ^ List of available resolutions.
        | NonAvailable -- ^ No modes available!
        | AnyOK -- ^ All resolutions available.
          deriving (Show,Eq,Ord)

    foreign import ccall unsafe "SDL_ListModes" sdlListModes :: Ptr PixelFormatStruct -> Word32 -> IO (Ptr (Ptr Rect))

    -- | Returns the available screen resolutions for the given format and video flags.
    listModes :: Maybe PixelFormat -- ^ Will use SDL_GetVideoInfo()->vfmt when @Nothing@.
              -> [SurfaceFlag]
              -> IO ListModes
    listModes mbFormat flags
        = do ret <- getFormat (\ptr -> sdlListModes ptr (toBitmask flags))
             if ret == nullPtr `plusPtr` (-1)
                then return AnyOK
                else if ret == nullPtr
                        then return NonAvailable
                        else do array <- peekArray0 nullPtr ret
                                fmap Modes (mapM peek array)
        where getFormat = maybe (\action -> action nullPtr) withForeignPtr mbFormat

    -- int SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags);
    foreign import ccall unsafe "SDL_VideoModeOK" sdlVideoModeOK :: CInt -> CInt -> CInt -> Word32 -> IO CInt

    -- | Check to see if a particular video mode is supported.
    --   Returns the bits-per-pixel of the closest available mode with the given width,
    --   height and requested surface flags, or @Nothing@ on error.
    videoModeOK :: Int -- ^ Width.
                -> Int -- ^ Height.
                -> Int -- ^ Bits-per-pixel.
                -> [SurfaceFlag] -- ^ Flags.
                -> IO (Maybe Int)
    videoModeOK width height bpp flags
        = do ret <- sdlVideoModeOK (toCInt width) (toCInt height) (toCInt bpp) (toBitmask flags)
             case ret of
               0 -> return Nothing
               x -> return (Just $ fromCInt x)

    -- SDL_Surface *SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags);
    foreign import ccall unsafe "SDL_SetVideoMode" sdlSetVideoMode :: CInt -> CInt -> CInt -> Word32 -> IO (Ptr SurfaceStruct)

    -- | Set up a video mode with the specified width, height and bits-per-pixel.
    --   Returns @Nothing@ on error.
    trySetVideoMode :: Int -- ^ Width.
                    -> Int -- ^ Height.
                    -> Int -- ^ Bits-per-pixel.
                    -> [SurfaceFlag] -- ^ Flags.
                    -> IO (Maybe Surface)
    trySetVideoMode width height bpp flags
        = sdlSetVideoMode (toCInt width) (toCInt height) (toCInt bpp) (toBitmask flags) >>= maybePeek newForeignPtr_

    -- | Same as 'trySetVideoMode' except it throws an exception on error.
    setVideoMode :: Int -> Int -> Int -> [SurfaceFlag] -> IO Surface
    setVideoMode width height bpp flags
        = unwrapMaybe "SDL_SetVideoMode" (trySetVideoMode width height bpp flags)

    -- void SDL_UpdateRect(SDL_Surface *screen, Sint32 x, Sint32 y, Sint32 w, Sint32 h);
    foreign import ccall unsafe "SDL_UpdateRect" sdlUpdateRect :: Ptr SurfaceStruct
                                                               -> Int32 -> Int32 -> Word32 -> Word32 -> IO ()

    -- | Makes sure the given area is updated on the given screen.
    updateRect :: Surface -> Rect -> IO ()
    updateRect surface rect
        = withForeignPtr surface (\ptr -> sdlUpdateRect ptr x y w h)
        where x = fromIntegral (rectX rect)
              y = fromIntegral (rectY rect)
              w = fromIntegral (rectW rect)
              h = fromIntegral (rectH rect)

    -- void SDL_UpdateRects(SDL_Surface *screen, int numrects, SDL_Rect *rects);
    foreign import ccall unsafe "SDL_UpdateRects" sdlUpdateRects :: Ptr SurfaceStruct -> CInt -> Ptr Rect -> IO ()

    -- | Makes sure the given list of rectangles is updated on the given screen.
    --   The rectangles are not automatically merged or checked for overlap.
    --   In general, the programmer can use his knowledge about his particular
    --   rectangles to merge them in an efficient way, to avoid overdraw.
    updateRects :: Surface -> [Rect] -> IO ()
    updateRects surface rects
        = withForeignPtr surface $ \ptr ->
          withArrayLen rects $ \len array ->
          sdlUpdateRects ptr (toCInt len) array

    -- int SDL_Flip(SDL_Surface *screen);
    foreign import ccall unsafe "SDL_Flip" sdlFlip :: Ptr SurfaceStruct -> IO CInt

    -- | Swaps screen buffers.
    tryFlip :: Surface -> IO Bool
    tryFlip surface
        = withForeignPtr surface $ \ptr ->
          do ret <- sdlFlip ptr
             case ret of
               (-1) -> return False
               _    -> return True

    -- | Same as 'tryFlip' but throws an exception on error.
    flip :: Surface -> IO ()
    flip = unwrapBool "SDL_Flip" . tryFlip

    -- int SDL_SetColors(SDL_Surface *surface, SDL_Color *colors, int firstcolor, int ncolors);
    foreign import ccall unsafe "SDL_SetColors" sdlSetColors :: Ptr SurfaceStruct -> Ptr Color -> CInt -> CInt -> IO CInt

    -- | Sets a portion of the colormap for the given 8-bit surface.
    setColors :: Surface -> [Color] -> Int -> IO Bool
    setColors surface colors start
        = withForeignPtr surface $ \ptr ->
          withArrayLen colors $ \len array ->
          fmap toBool (sdlSetColors ptr array (toCInt start) (toCInt len))

    -- int SDL_SetPalette(SDL_Surface *surface, int flags, SDL_Color *colors, int firstcolor, int ncolors);
    foreign import ccall unsafe "SDL_SetPalette" sdlSetPalette
        :: Ptr SurfaceStruct -> CInt -> Ptr Color -> CInt -> CInt -> IO CInt

    -- | Sets the colors in the palette of an 8-bit surface.
    setPalette :: Surface -> [Palette] -> [Color] -> Int -> IO Bool
    setPalette surface flags colors start
        = withForeignPtr surface $ \ptr ->
          withArrayLen colors $ \len array ->
          fmap toBool (sdlSetPalette ptr (toCInt $ toBitmask flags) array (toCInt start) (toCInt len))

    --int SDL_SetGamma(float redgamma, float greengamma, float bluegamma);
    foreign import ccall unsafe "SDL_SetGamma" sdlSetGamma :: Float -> Float -> Float -> IO CInt
    setGamma :: Float -> Float -> Float -> IO Bool
    setGamma red green blue
        = intToBool (-1) (fmap fromCInt $ sdlSetGamma red green blue)

    -- int SDL_GetGammaRamp(Uint16 *redtable, Uint16 *greentable, Uint16 *bluetable);
    foreign import ccall unsafe "SDL_GetGammaRamp" sdlGetGammaRamp :: Ptr Word16 -> Ptr Word16 -> Ptr Word16 -> IO CInt
    tryGetGammaRamp :: IO (Maybe ([Word16],[Word16],[Word16]))
    tryGetGammaRamp
        = allocaArray size $ \red ->
          allocaArray size $ \green ->
          allocaArray size $ \blue ->
          do ret <- sdlGetGammaRamp red green blue
             case ret of
               (-1) -> return Nothing
               _ -> do [r,g,b] <- mapM (peekArray size) [red,green,blue]
                       return (Just (r,g,b))
        where size = 256

    getGammaRamp :: IO ([Word16],[Word16],[Word16])
    getGammaRamp = unwrapMaybe "SDL_GetGammaRamp" tryGetGammaRamp

    -- int SDL_SetGammaRamp(Uint16 *redtable, Uint16 *greentable, Uint16 *bluetable);
    foreign import ccall unsafe "SDL_SetGammaRamp" sdlSetGammaRamp :: Ptr Word16 -> Ptr Word16 -> Ptr Word16 -> IO CInt
    trySetGammaRamp :: [Word16] -> [Word16] -> [Word16] -> IO Bool
    trySetGammaRamp red green blue
        = withArrayLen red $ check $ \ptrRed ->
          withArrayLen green $ check $ \ptrGreen ->
          withArrayLen blue $ check $ \ptrBlue ->
          intToBool (-1) (fmap fromCInt $ sdlSetGammaRamp ptrRed ptrGreen ptrBlue)
        where check action 256 ptr = action ptr
              check _ _ _ = return False

    setGammaRamp :: [Word16] -> [Word16] -> [Word16] -> IO ()
    setGammaRamp red green blue = unwrapBool "setGammaRamp_" (trySetGammaRamp red green blue)

    -- Uint32 SDL_MapRGB(SDL_PixelFormat *fmt, Uint8 r, Uint8 g, Uint8 b);
    foreign import ccall unsafe "SDL_MapRGB" sdlMapRGB :: Ptr PixelFormatStruct -> Word8 -> Word8 -> Word8 -> IO Word32

    -- | Map a RGB color value to a pixel format.
    mapRGB :: PixelFormat
           -> Word8 -- ^ Red value.
           -> Word8 -- ^ Green value.
           -> Word8 -- ^ Blue value.
           -> IO Pixel
    mapRGB format r g b
        = withForeignPtr format $ \ptr ->
          fmap Pixel (sdlMapRGB ptr r g b)

    -- Uint32 SDL_MapRGBA(SDL_PixelFormat *fmt, Uint8 r, Uint8 g, Uint8 b, Uint8 a);

    foreign import ccall unsafe "SDL_MapRGBA" sdlMapRGBA
        :: Ptr PixelFormatStruct -> Word8 -> Word8 -> Word8 -> Word8 -> IO Word32

    -- | Map a RGBA color value to a pixel format.
    mapRGBA :: PixelFormat
            -> Word8 -- ^ Red value.
            -> Word8 -- ^ Green value.
            -> Word8 -- ^ Blue value.
            -> Word8 -- ^ Alpha value.
            -> IO Pixel
    mapRGBA format r g b a
        = withForeignPtr format $ \ptr ->
          fmap Pixel (sdlMapRGBA ptr r g b a)

    -- void SDL_GetRGB(Uint32 pixel, SDL_PixelFormat *fmt, Uint8 *r, Uint8 *g, Uint8 *b);
    foreign import ccall unsafe "SDL_GetRGB" sdlGetRGB
        :: Word32 -> Ptr PixelFormatStruct -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO ()

    -- | Get RGB values from a pixel in the specified pixel format.
    getRGB :: Pixel -> PixelFormat -> IO (Word8,Word8,Word8)
    getRGB (Pixel p) format
        = alloca $ \red ->
          alloca $ \green ->
          alloca $ \blue ->
          withForeignPtr format $ \ptr ->
          do sdlGetRGB p ptr red green blue
             [r,g,b] <- mapM peek [red,green,blue]
             return (r,g,b)

    -- void SDL_GetRGBA(Uint32 pixel, SDL_PixelFormat *fmt, Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a);
    foreign import ccall unsafe "SDL_GetRGBA" sdlGetRGBA
        :: Word32 -> Ptr PixelFormatStruct -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> Ptr Word8 -> IO ()

    -- | Gets RGBA values from a pixel in the specified pixel format.
    getRGBA :: Pixel -> PixelFormat -> IO (Word8,Word8,Word8,Word8)
    getRGBA (Pixel p) format
        = alloca $ \red ->
          alloca $ \green ->
          alloca $ \blue ->
          alloca $ \alpha ->
          withForeignPtr format $ \ptr ->
          do sdlGetRGBA p ptr red green blue alpha
             [r,g,b,a] <- mapM peek [red,green,blue,alpha]
             return (r,g,b,a)

    -- SDL_Surface *SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
    foreign import ccall unsafe "SDL_CreateRGBSurface" sdlCreateRGBSurface
        :: Word32 -> CInt -> CInt -> CInt -> Word32 -> Word32 -> Word32 -> Word32 -> IO (Ptr SurfaceStruct)

    -- | Creates an empty @Surface@. Returns @Nothing@ on error.
    tryCreateRGBSurface :: [SurfaceFlag] -> Int -> Int -> Int
                      -> Word32 -> Word32 -> Word32 -> Word32 -> IO (Maybe Surface)
    tryCreateRGBSurface flags width height bpp rmask gmask bmask amask
        = sdlCreateRGBSurface (toBitmask flags) (toCInt width) (toCInt height) (toCInt bpp) rmask gmask bmask amask >>=
          maybePeek mkFinalizedSurface

    -- | Creates an empty @Surface@. Throws an exception on error.
    createRGBSurface :: [SurfaceFlag] -> Int -> Int -> Int
                     -> Word32 -> Word32 -> Word32 -> Word32 -> IO Surface
    createRGBSurface flags width height bpp rmask gmask bmask amask
        = unwrapMaybe "SDL_CreateRGBSurface" (tryCreateRGBSurface flags width height bpp rmask gmask bmask amask)

    -- | Creates an empty @Surface@ with (r\/g\/b\/a)mask determined from the local endian.
    --   Returns @Nothing@ on error.
    tryCreateRGBSurfaceEndian :: [SurfaceFlag] -> Int -> Int -> Int -> IO (Maybe Surface)
    tryCreateRGBSurfaceEndian flags width height bpp
        = tryCreateRGBSurface flags width height bpp

    {-# LINE 412 "Graphics/UI/SDL/Video.hsc" #-}
            0x000000FF 0x0000FF00 0x00FF0000 0xFF000000

    {-# LINE 416 "Graphics/UI/SDL/Video.hsc" #-}

    -- | Creates an empty @Surface@ with (r\/g\/b\/a)mask determined from the local endian.
    --   Throws an exception on error.
    createRGBSurfaceEndian :: [SurfaceFlag] -> Int -> Int -> Int -> IO Surface
    createRGBSurfaceEndian flags width height bpp
        = unwrapMaybe "SDL_CreateRGBSurface" (tryCreateRGBSurfaceEndian flags width height bpp)

    -- SDL_Surface *SDL_CreateRGBSurfaceFrom(void *pixels, int width, int height, int depth, int pitch, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
    foreign import ccall unsafe "SDL_CreateRGBSurfaceFrom" sdlCreateRGBSurfaceFrom
        :: Ptr Word8 -> CInt -> CInt -> CInt -> CInt -> Word32 -> Word32 -> Word32 -> Word32 -> IO (Ptr SurfaceStruct)
    tryCreateRGBSurfaceFrom :: Ptr a -> Int -> Int -> Int -> Int
                            -> Word32 -> Word32 -> Word32 -> Word32 -> IO (Maybe Surface)
    tryCreateRGBSurfaceFrom pixels width height depth pitch rmask gmask bmask amask
        = sdlCreateRGBSurfaceFrom (castPtr pixels) (toCInt width) (toCInt height) (toCInt depth) (toCInt pitch) rmask gmask bmask amask >>=
          maybePeek mkFinalizedSurface

    createRGBSurfaceFrom :: Ptr a -> Int -> Int -> Int -> Int
                         -> Word32 -> Word32 -> Word32 -> Word32 -> IO Surface
    createRGBSurfaceFrom pixels width height depth pitch rmask gmask bmask amask
        = unwrapMaybe "SDL_CreateRGBSurfaceFrom"
                      (tryCreateRGBSurfaceFrom pixels width height depth pitch rmask gmask bmask amask)

    {-
    -- void SDL_FreeSurface(SDL_Surface *surface);
    foreign import ccall unsafe "SDL_FreeSurface" sdlFreeSurface :: Ptr SurfaceStruct -> IO ()
    -- | Frees (deletes) a @Surface@. Don\'t use it unless you really know what you're doing. All surfaces
    --   are automatically deleted when they're out of scope or forced with @finalizeForeignPtr@.
    freeSurface :: Surface -> IO ()
    freeSurface surface
        = withForeignPtr surface sdlFreeSurface
    -}

    -- | Forces the finalization of a @Surface@. Only supported with GHC.
    freeSurface :: Surface -> IO ()
    freeSurface =

    {-# LINE 452 "Graphics/UI/SDL/Video.hsc" #-}
      finalizeForeignPtr

    {-# LINE 456 "Graphics/UI/SDL/Video.hsc" #-}

    -- int SDL_LockSurface(SDL_Surface *surface);
    foreign import ccall unsafe "SDL_LockSurface" sdlLockSurface :: Ptr SurfaceStruct -> IO CInt

    -- | Locks a surface for direct access.
    lockSurface :: Surface -> IO Bool
    lockSurface surface
        = withForeignPtr surface $ \ptr ->
          intToBool (-1) (fmap fromCInt $ sdlLockSurface ptr)

    -- void SDL_UnlockSurface(SDL_Surface *surface);
    foreign import ccall unsafe "SDL_UnlockSurface" sdlUnlockSurface :: Ptr SurfaceStruct -> IO ()

    -- | Unlocks a previously locked surface.
    unlockSurface :: Surface -> IO ()
    unlockSurface surface = withForeignPtr surface sdlUnlockSurface

    -- extern DECLSPEC SDL_Surface * SDLCALL SDL_LoadBMP_RW(SDL_RWops *src, int freesrc);
    -- define SDL_LoadBMP(file)       SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
    foreign import ccall unsafe "SDL_LoadBMP_RW" sdlLoadBMP_RW :: Ptr RWopsStruct -> CInt -> IO (Ptr SurfaceStruct)

    tryLoadBMPRW :: RWops -> Bool -> IO (Maybe Surface)
    tryLoadBMPRW rw freesrc
        = withForeignPtr rw $ \rwPtr ->
          sdlLoadBMP_RW rwPtr (fromBool freesrc) >>= maybePeek mkFinalizedSurface

    loadBMPRW :: RWops -> Bool -> IO Surface
    loadBMPRW rw freesrc = unwrapMaybe "SDL_LoadBMP_RW" (tryLoadBMPRW rw freesrc)

    loadBMP :: FilePath -> IO Surface
    loadBMP filepath
        = RW.with filepath "rb" $ \rw ->
          loadBMPRW rw False

    -- extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
    --                (SDL_Surface *surface, SDL_RWops *dst, int freedst);
    foreign import ccall unsafe "SDL_SaveBMP_RW" sdlSaveBMP_RW :: Ptr SurfaceStruct -> Ptr RWopsStruct -> CInt -> IO CInt

    saveBMPRW :: Surface -> RWops -> Bool -> IO Bool
    saveBMPRW surface rw freedst
        = withForeignPtr surface $ \ptr ->
          withForeignPtr rw $ \rwPtr ->
          intToBool (-1) (fmap fromCInt $ sdlSaveBMP_RW ptr rwPtr (fromBool freedst))

    saveBMP :: Surface -> FilePath -> IO Bool
    saveBMP surface filepath
        = RW.with filepath "wb" $ \rw ->
          saveBMPRW surface rw False

    -- int SDL_SetColorKey(SDL_Surface *surface, Uint32 flag, Uint32 key);
    foreign import ccall unsafe "SDL_SetColorKey" sdlSetColorKey :: Ptr SurfaceStruct -> Word32 -> Word32 -> IO CInt
    setColorKey :: Surface -> [SurfaceFlag] -> Pixel -> IO Bool
    setColorKey surface flags (Pixel w)
        = withForeignPtr surface $ \ptr ->
          intToBool (-1) (fmap fromCInt $ sdlSetColorKey ptr (toBitmask flags) w)

    -- int SDL_SetAlpha(SDL_Surface *surface, Uint32 flag, Uint8 alpha);
    foreign import ccall unsafe "SDL_SetAlpha" sdlSetAlpha :: Ptr SurfaceStruct -> Word32 -> Word8 -> IO CInt

    -- | Adjusts the alpha properties of a surface.
    setAlpha :: Surface -> [SurfaceFlag] -> Word8 -> IO Bool
    setAlpha surface flags alpha
        = withForeignPtr surface $ \ptr ->
          intToBool (-1) (fmap fromCInt $ sdlSetAlpha ptr (toBitmask flags) alpha)

    -- void SDL_SetClipRect(SDL_Surface *surface, SDL_Rect *rect);
    foreign import ccall unsafe "SDL_SetClipRect" sdlSetClipRect :: Ptr SurfaceStruct -> Ptr Rect -> IO ()

    -- | Sets the clipping rectangle for a surface.
    setClipRect :: Surface -> Maybe Rect -> IO ()
    setClipRect surface mbRect
        = withForeignPtr surface $ \ptr ->
          maybeWith with mbRect $ \rect ->
          sdlSetClipRect ptr rect

    -- void SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect);
    foreign import ccall unsafe "SDL_GetClipRect" sdlGetClipRect :: Ptr SurfaceStruct -> Ptr Rect -> IO ()

    -- | Gets the clipping rectangle for a surface.
    getClipRect :: Surface -> IO Rect
    getClipRect surface
        = withForeignPtr surface $ \ptr ->
          alloca $ \rectPtr ->
          do sdlGetClipRect ptr rectPtr
             peek rectPtr

    -- | Run an action with a given clipping rect applied.
    --   If an exception is raised, then withClipRect will re-raise the exception (after resetting the original clipping rect).
    withClipRect :: Surface -> Maybe Rect -> IO a -> IO a
    withClipRect surface rect action
        = bracket (getClipRect surface) -- Get the current cliprect
                  (setClipRect surface . Just) -- Reset to old cliprect when done.
                  (const (setClipRect surface rect >> action)) -- Set new cliprect.

    -- SDL_Surface *SDL_ConvertSurface(SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags);
    foreign import ccall unsafe "SDL_ConvertSurface" sdlConvertSurface
        :: Ptr SurfaceStruct -> Ptr PixelFormatStruct -> Word32 -> IO (Ptr SurfaceStruct)

    -- | Converts a surface to the same format as another surface. Returns @Nothing@ on error.
    tryConvertSurface :: Surface -> PixelFormat -> [SurfaceFlag] -> IO (Maybe Surface)
    tryConvertSurface surface format flags
        = withForeignPtr surface $ \ptr ->
          withForeignPtr format $ \formatPtr ->
          sdlConvertSurface ptr formatPtr (toBitmask flags) >>= maybePeek mkFinalizedSurface

    -- | Converts a surface to the same format as another surface. Throws an exception on error.
    convertSurface :: Surface -> PixelFormat -> [SurfaceFlag] -> IO Surface
    convertSurface surface format flags
        = unwrapMaybe "SDL_ConvertSurface"
                      (tryConvertSurface surface format flags)

    -- int SDL_UpperBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect);
    foreign import ccall unsafe "SDL_UpperBlit" sdlBlitSurface
        :: Ptr SurfaceStruct -> Ptr Rect -> Ptr SurfaceStruct -> Ptr Rect -> IO CInt

    -- | This function performs a fast blit from the source surface to the destination surface.
    blitSurface :: Surface -> Maybe Rect -> Surface -> Maybe Rect -> IO Bool
    blitSurface src srcRect dst dstRect
        = withForeignPtr src $ \srcPtr ->
          withForeignPtr dst $ \dstPtr ->
          maybeWith with srcRect $ \srcRectPtr ->
          maybeWith with dstRect $ \dstRectPtr ->
          intToBool (-1) (fmap fromCInt $ sdlBlitSurface srcPtr srcRectPtr dstPtr dstRectPtr)

    -- int SDL_FillRect(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color);
    foreign import ccall unsafe "SDL_FillRect" sdlFillRect :: Ptr SurfaceStruct -> Ptr Rect -> Word32 -> IO CInt

    -- | This function performs a fast fill of the given rectangle with some color.
    fillRect :: Surface -> Maybe Rect -> Pixel -> IO Bool
    fillRect surface mbRect (Pixel w)
        = withForeignPtr surface $ \ptr ->
          maybeWith with mbRect $ \rect ->
          intToBool (-1) (fmap fromCInt $ sdlFillRect ptr rect w)

    -- SDL_Surface *SDL_DisplayFormat(SDL_Surface *surface);
    foreign import ccall unsafe "SDL_DisplayFormat" sdlDisplayFormat :: Ptr SurfaceStruct -> IO (Ptr SurfaceStruct)

    -- | Converts a surface to the display format. Returns @Nothing@ on error.
    tryDisplayFormat :: Surface -> IO (Maybe Surface)
    tryDisplayFormat surface
        = withForeignPtr surface $ \ptr ->
          sdlDisplayFormat ptr >>= maybePeek mkFinalizedSurface

    -- | Converts a surface to the display format. Throws an exception on error.
    displayFormat :: Surface -> IO Surface
    displayFormat = unwrapMaybe "SDL_DisplayFormat" . tryDisplayFormat

    -- SDL_Surface *SDL_DisplayFormatAlpha(SDL_Surface *surface);
    foreign import ccall unsafe "SDL_DisplayFormatAlpha" sdlDisplayFormatAlpha :: Ptr SurfaceStruct -> IO (Ptr SurfaceStruct)

    -- | Converts a surface to the display format. Returns @Nothing@ on error.
    tryDisplayFormatAlpha :: Surface -> IO (Maybe Surface)
    tryDisplayFormatAlpha surface
        = withForeignPtr surface $ \ptr ->
          sdlDisplayFormatAlpha ptr >>= maybePeek mkFinalizedSurface

    -- | Converts a surface to the display format. Throws an exception on error.
    displayFormatAlpha :: Surface -> IO Surface
    displayFormatAlpha = unwrapMaybe "SDL_DisplayFormatAlpha" . tryDisplayFormatAlpha

    -- void SDL_WarpMouse(Uint16 x, Uint16 y);
    foreign import ccall unsafe "SDL_WarpMouse" sdlWarpMouse :: Word16 -> Word16 -> IO ()

    -- | Sets the position of the mouse cursor.
    warpMouse :: Word16 -- ^ Mouse X position.
              -> Word16 -- ^ Mouse Y position.
              -> IO ()
    warpMouse = sdlWarpMouse

    -- int SDL_ShowCursor(int toggle);
    foreign import ccall unsafe "SDL_ShowCursor" sdlShowCursor :: CInt -> IO CInt

    -- | Toggle whether or not the cursor is shown on the screen.
    showCursor :: Bool -> IO ()
    showCursor enable
        = sdlShowCursor (fromToggle toggle) >>
          return ()
        where toggle = case enable of
                         True -> Enable
                         False -> Disable

    -- | Returns @True@ when the cursor is set to visible. See also 'showCursor'.
    queryCursorState :: IO Bool
    queryCursorState = fmap toBool (sdlShowCursor (fromToggle Query))

    type GLAttr = CInt
    type GLValue = CInt

    glRedSize, glGreenSize, glBlueSize, glAlphaSize, glBufferSize, glDoubleBuffer :: GLAttr
    glDepthSize, glStencilSize, glAccumRedSize, glAccumGreenSize, glAccumBlueSize :: GLAttr
    glAccumAlphaSize, glStereo, glMultiSampleBuffers, glMultiSampleSamples :: GLAttr

    glRedSize = 0
    {-# LINE 653 "Graphics/UI/SDL/Video.hsc" #-}
    glGreenSize = 1
    {-# LINE 654 "Graphics/UI/SDL/Video.hsc" #-}
    glBlueSize = 2
    {-# LINE 655 "Graphics/UI/SDL/Video.hsc" #-}
    glAlphaSize = 3
    {-# LINE 656 "Graphics/UI/SDL/Video.hsc" #-}
    glBufferSize = 4
    {-# LINE 657 "Graphics/UI/SDL/Video.hsc" #-}
    glDoubleBuffer = 5
    {-# LINE 658 "Graphics/UI/SDL/Video.hsc" #-}
    glDepthSize  = 6
    {-# LINE 659 "Graphics/UI/SDL/Video.hsc" #-}
    glStencilSize = 7
    {-# LINE 660 "Graphics/UI/SDL/Video.hsc" #-}
    glAccumRedSize = 8
    {-# LINE 661 "Graphics/UI/SDL/Video.hsc" #-}
    glAccumGreenSize = 9
    {-# LINE 662 "Graphics/UI/SDL/Video.hsc" #-}
    glAccumBlueSize = 10
    {-# LINE 663 "Graphics/UI/SDL/Video.hsc" #-}
    glAccumAlphaSize = 11
    {-# LINE 664 "Graphics/UI/SDL/Video.hsc" #-}
    glStereo = 12
    {-# LINE 665 "Graphics/UI/SDL/Video.hsc" #-}
    glMultiSampleBuffers = 13
    {-# LINE 666 "Graphics/UI/SDL/Video.hsc" #-}
    glMultiSampleSamples = 14
    {-# LINE 667 "Graphics/UI/SDL/Video.hsc" #-}

    --int SDL_GL_SetAttribute(SDL_GLattr attr, int value);
    foreign import ccall unsafe "SDL_GL_SetAttribute" sdlGLSetAttribute :: CInt -> CInt -> IO CInt
    -- | Sets a special SDL\/OpenGL attribute. Returns @False@ on error.
    tryGLSetAttribute :: GLAttr -> GLValue -> IO Bool
    tryGLSetAttribute attr value = fmap (==0) (sdlGLSetAttribute attr value)

    -- | Sets a special SDL\/OpenGL attribute. Throws an exception on error.
    glSetAttribute :: GLAttr -> GLValue -> IO ()
    glSetAttribute attr value = unwrapBool "SDL_GL_SetAttribute" (tryGLSetAttribute attr value)

    -- int SDL_GL_GetAttribute(SDLGLattr attr, int *value);
    foreign import ccall unsafe "SDL_GL_GetAttribute" sdlGLGetAttribute :: CInt -> Ptr CInt -> IO CInt

    -- | Gets the value of a special SDL\/OpenGL attribute. Returns @Nothing@ on error.
    tryGLGetAttribute :: GLAttr -> IO (Maybe GLValue)
    tryGLGetAttribute attr
        = alloca $ \valuePtr ->
          do ret <- sdlGLGetAttribute attr valuePtr
             case ret of
               0 -> fmap Just (peek valuePtr)
               _ -> return Nothing

    -- | Gets the value of a special SDL\/OpenGL attribute. Throws an exception on error.
    glGetAttribute :: GLAttr -> IO GLValue
    glGetAttribute = unwrapMaybe "SDL_GL_GetAttribute" . tryGLGetAttribute

    --void SDLCALL SDL_GL_SwapBuffers(void);
    -- | Swaps OpenGL framebuffers\/Update Display.
    foreign import ccall unsafe "SDL_GL_SwapBuffers" glSwapBuffers :: IO ()

    foreign import ccall unsafe "&SDL_FreeSurface" sdlFreeSurfaceFinal :: FunPtr (Ptr SurfaceStruct -> IO ())

    mkFinalizedSurface :: Ptr SurfaceStruct -> IO Surface
    mkFinalizedSurface = newForeignPtr sdlFreeSurfaceFinal