    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE PatternSynonyms #-}
    module SDL.Video
      ( module SDL.Video.OpenGL
      , module SDL.Video.Renderer

      -- * Window Management
      , Window
      , createWindow
      , defaultWindow
      , WindowConfig(..)
      , WindowGraphicsContext(..)
      , WindowMode(..)
      , WindowPosition(..)
      , destroyWindow

      -- * Window Actions
      , hideWindow
      , raiseWindow
      , showWindow

      -- * Window Attributes
      , windowMinimumSize
      , windowMaximumSize
      , windowSize
      , windowBordered
      , windowBrightness
      , windowGammaRamp
      , windowGrab
      , setWindowMode
      , getWindowAbsolutePosition
      , setWindowPosition
      , windowTitle
      , windowData
      , getWindowConfig
      , getWindowPixelFormat
      , PixelFormat(..)

      -- * Renderer Management
      , createRenderer
      , createSoftwareRenderer
      , destroyRenderer

      -- * Clipboard Handling
      , getClipboardText
      , hasClipboardText
      , setClipboardText

      -- * Display
      , getDisplays
      , Display(..)
      , DisplayMode(..)
      , VideoDriver(..)

      -- * Screen Savers
      -- | Screen savers should be disabled when the sudden enablement of the
      -- monitor's power saving features would be inconvenient for when the user
      -- hasn't provided any input for some period of time, such as during video
      -- playback.
      --
      -- Screen savers are disabled by default upon the initialization of the
      -- video subsystem.
      , screenSaverEnabled

      -- * Message Box
      , showSimpleMessageBox
      , MessageKind(..)
      ) where

    import Prelude hiding (all, foldl, foldr, mapM_)

    import Data.StateVar
    import Control.Applicative
    import Control.Exception
    import Control.Monad (forM, unless, void)
    import Control.Monad.IO.Class (MonadIO, liftIO)
    import Data.Bits
    import Data.Data (Data)
    import Data.Foldable
    import Data.Maybe (isJust, fromMaybe)
    import Data.Monoid (First(..))
    import Data.Text (Text)
    import Data.Typeable
    import Foreign hiding (void, throwIfNull, throwIfNeg, throwIfNeg_)
    import Foreign.C
    import GHC.Generics (Generic)
    import SDL.Vect
    import SDL.Internal.Exception
    import SDL.Internal.Numbered
    import SDL.Internal.Types
    import SDL.Video.OpenGL
    import SDL.Video.Renderer

    import qualified Data.ByteString as BS
    import qualified Data.Text.Encoding as Text
    import qualified Data.Vector.Storable as SV
    import qualified SDL.Raw as Raw

    -- | Create a window with the given title and configuration.
    --
    -- Throws 'SDLException' on failure.
    createWindow :: MonadIO m => Text -> WindowConfig -> m Window
    createWindow :: Text -> WindowConfig -> m Window
    createWindow title :: Text
    title config :: WindowConfig
    config = IO Window -> m Window
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Window -> m Window) -> IO Window -> m Window
    forall a b. (a -> b) -> a -> b
    $ do
      case WindowConfig -> WindowGraphicsContext
    windowGraphicsContext WindowConfig
    config of
        OpenGLContext glcfg :: OpenGLConfig
    glcfg -> OpenGLConfig -> IO ()
    forall (m :: * -> *). MonadIO m => OpenGLConfig -> m ()
    setGLAttributes OpenGLConfig
    glcfg
        _                   -> () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

      ByteString -> (CString -> IO Window) -> IO Window
    forall a. ByteString -> (CString -> IO a) -> IO a
    BS.useAsCString (Text -> ByteString
    Text.encodeUtf8 Text
    title) ((CString -> IO Window) -> IO Window)
    -> (CString -> IO Window) -> IO Window
    forall a b. (a -> b) -> a -> b
    $ \title' :: CString
    title' -> do
        let create :: CInt -> CInt -> CInt -> CInt -> Word32 -> IO Window
    create = CString -> CInt -> CInt -> CInt -> CInt -> Word32 -> IO Window
    forall (m :: * -> *).
    MonadIO m =>
    CString -> CInt -> CInt -> CInt -> CInt -> Word32 -> m Window
    Raw.createWindow CString
    title'
        let create' :: V2 CInt -> Word32 -> IO Window
    create' (V2 w :: CInt
    w h :: CInt
    h) = case WindowConfig -> WindowPosition
    windowPosition WindowConfig
    config of
              Centered -> let u :: CInt
    u = CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOWPOS_CENTERED in CInt -> CInt -> CInt -> CInt -> Word32 -> IO Window
    create CInt
    u CInt
    u CInt
    w CInt
    h
              Wherever -> let u :: CInt
    u = CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOWPOS_UNDEFINED in CInt -> CInt -> CInt -> CInt -> Word32 -> IO Window
    create CInt
    u CInt
    u CInt
    w CInt
    h
              Absolute (P (V2 x :: CInt
    x y :: CInt
    y)) -> CInt -> CInt -> CInt -> CInt -> Word32 -> IO Window
    create CInt
    x CInt
    y CInt
    w CInt
    h
        V2 CInt -> Word32 -> IO Window
    create' (WindowConfig -> V2 CInt
    windowInitialSize WindowConfig
    config) Word32
    flags IO Window -> (Window -> IO Window) -> IO Window
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= Window -> IO Window
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Window -> IO Window) -> (Window -> Window) -> Window -> IO Window
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Window -> Window
    Window
      where
        flags :: Word32
    flags = (Word32 -> Word32 -> Word32) -> Word32 -> [Word32] -> Word32
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    (.|.) 0
          [ if WindowConfig -> Bool
    windowBorder WindowConfig
    config then 0 else Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_BORDERLESS
          , if WindowConfig -> Bool
    windowHighDPI WindowConfig
    config then Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_ALLOW_HIGHDPI else 0
          , if WindowConfig -> Bool
    windowInputGrabbed WindowConfig
    config then Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_INPUT_GRABBED else 0
          , WindowMode -> Word32
    forall a b. ToNumber a b => a -> b
    toNumber (WindowMode -> Word32) -> WindowMode -> Word32
    forall a b. (a -> b) -> a -> b
    $ WindowConfig -> WindowMode
    windowMode WindowConfig
    config
          , if WindowGraphicsContext -> Bool
    ctxIsOpenGL (WindowConfig -> WindowGraphicsContext
    windowGraphicsContext WindowConfig
    config) then Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_OPENGL else 0
          , if WindowConfig -> Bool
    windowResizable WindowConfig
    config then Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_RESIZABLE else 0
          , if WindowConfig -> Bool
    windowVisible WindowConfig
    config then 0 else Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_HIDDEN
          , if WindowConfig -> WindowGraphicsContext
    windowGraphicsContext WindowConfig
    config WindowGraphicsContext -> WindowGraphicsContext -> Bool
    forall a. Eq a => a -> a -> Bool
    == WindowGraphicsContext
    VulkanContext then Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_VULKAN else 0
          ]
        setGLAttributes :: OpenGLConfig -> m ()
    setGLAttributes (OpenGLConfig (V4 r :: CInt
    r g :: CInt
    g b :: CInt
    b a :: CInt
    a) d :: CInt
    d s :: CInt
    s ms :: CInt
    ms p :: Profile
    p) = do
          let (msk :: CInt
    msk, v0 :: CInt
    v0, v1 :: CInt
    v1, flg :: CInt
    flg) = case Profile
    p of
                Core Debug v0' :: CInt
    v0' v1' :: CInt
    v1' -> (CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_GL_CONTEXT_PROFILE_CORE, CInt
    v0', CInt
    v1', CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_GL_CONTEXT_DEBUG_FLAG)
                Core Normal v0' :: CInt
    v0' v1' :: CInt
    v1' -> (CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_GL_CONTEXT_PROFILE_CORE, CInt
    v0', CInt
    v1', 0)
                Compatibility Debug v0' :: CInt
    v0' v1' :: CInt
    v1' -> (CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_GL_CONTEXT_PROFILE_COMPATIBILITY, CInt
    v0', CInt
    v1', CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_GL_CONTEXT_DEBUG_FLAG)
                Compatibility Normal v0' :: CInt
    v0' v1' :: CInt
    v1' -> (CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_GL_CONTEXT_PROFILE_COMPATIBILITY, CInt
    v0', CInt
    v1', 0)
                ES Debug v0' :: CInt
    v0' v1' :: CInt
    v1' -> (CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_GL_CONTEXT_PROFILE_ES, CInt
    v0', CInt
    v1', CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_GL_CONTEXT_DEBUG_FLAG)
                ES Normal v0' :: CInt
    v0' v1' :: CInt
    v1' -> (CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_GL_CONTEXT_PROFILE_ES, CInt
    v0', CInt
    v1', 0)
          ((Word32, CInt) -> m ()) -> [(Word32, CInt)] -> m ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (Text -> Text -> m CInt -> m ()
    forall (m :: * -> *) a.
    (MonadIO m, Num a, Ord a) =>
    Text -> Text -> m a -> m ()
    throwIfNeg_ "SDL.Video.createWindow" "SDL_GL_SetAttribute" (m CInt -> m ())
    -> ((Word32, CInt) -> m CInt) -> (Word32, CInt) -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Word32 -> CInt -> m CInt) -> (Word32, CInt) -> m CInt
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Word32 -> CInt -> m CInt
    forall (m :: * -> *). MonadIO m => Word32 -> CInt -> m CInt
    Raw.glSetAttribute) ([(Word32, CInt)] -> m ()) -> [(Word32, CInt)] -> m ()
    forall a b. (a -> b) -> a -> b
    $
            [ (Word32
    Raw.SDL_GL_RED_SIZE, CInt
    r)
            , (Word32
    Raw.SDL_GL_GREEN_SIZE, CInt
    g)
            , (Word32
    Raw.SDL_GL_BLUE_SIZE, CInt
    b)
            , (Word32
    Raw.SDL_GL_ALPHA_SIZE, CInt
    a)
            , (Word32
    Raw.SDL_GL_DEPTH_SIZE, CInt
    d)
            , (Word32
    Raw.SDL_GL_STENCIL_SIZE, CInt
    s)
            , (Word32
    Raw.SDL_GL_MULTISAMPLEBUFFERS, if CInt
    ms CInt -> CInt -> Bool
    forall a. Ord a => a -> a -> Bool
    > 1 then 1 else 0)
            , (Word32
    Raw.SDL_GL_MULTISAMPLESAMPLES, if CInt
    ms CInt -> CInt -> Bool
    forall a. Ord a => a -> a -> Bool
    > 1 then CInt
    ms else 0)
            , (Word32
    Raw.SDL_GL_CONTEXT_PROFILE_MASK, CInt
    msk)
            , (Word32
    Raw.SDL_GL_CONTEXT_MAJOR_VERSION, CInt
    v0)
            , (Word32
    Raw.SDL_GL_CONTEXT_MINOR_VERSION, CInt
    v1)
            , (Word32
    Raw.SDL_GL_CONTEXT_FLAGS, CInt
    flg)
            ]

    -- | Default configuration for windows. Use the record update syntax to
    -- override any of the defaults.
    --
    -- @
    -- 'defaultWindow' = 'WindowConfig'
    --   { 'windowBorder'          = True
    --   , 'windowHighDPI'         = False
    --   , 'windowInputGrabbed'    = False
    --   , 'windowMode'            = 'Windowed'
    --   , 'windowGraphicsContext' = NoGraphicsContext
    --   , 'windowPosition'        = 'Wherever'
    --   , 'windowResizable'       = False
    --   , 'windowInitialSize'     = V2 800 600
    --   , 'windowVisible'         = True
    --   }
    -- @
    defaultWindow :: WindowConfig
    defaultWindow :: WindowConfig
    defaultWindow = WindowConfig :: Bool
    -> Bool
    -> Bool
    -> WindowMode
    -> WindowGraphicsContext
    -> WindowPosition
    -> Bool
    -> V2 CInt
    -> Bool
    -> WindowConfig
    WindowConfig
      { windowBorder :: Bool
    windowBorder          = Bool
    True
      , windowHighDPI :: Bool
    windowHighDPI         = Bool
    False
      , windowInputGrabbed :: Bool
    windowInputGrabbed    = Bool
    False
      , windowMode :: WindowMode
    windowMode            = WindowMode
    Windowed
      , windowGraphicsContext :: WindowGraphicsContext
    windowGraphicsContext = WindowGraphicsContext
    NoGraphicsContext
      , windowPosition :: WindowPosition
    windowPosition        = WindowPosition
    Wherever
      , windowResizable :: Bool
    windowResizable       = Bool
    False
      , windowInitialSize :: V2 CInt
    windowInitialSize     = CInt -> CInt -> V2 CInt
    forall a. a -> a -> V2 a
    V2 800 600
         , windowVisible :: Bool
    windowVisible      = Bool
    True
      }

    data WindowConfig = WindowConfig
      { WindowConfig -> Bool
    windowBorder          :: Bool                  -- ^ Defaults to 'True'.
      , WindowConfig -> Bool
    windowHighDPI         :: Bool                  -- ^ Defaults to 'False'. Can not be changed after window creation.
      , WindowConfig -> Bool
    windowInputGrabbed    :: Bool                  -- ^ Defaults to 'False'. Whether the mouse shall be confined to the window.
      , WindowConfig -> WindowMode
    windowMode            :: WindowMode            -- ^ Defaults to 'Windowed'.
      , WindowConfig -> WindowGraphicsContext
    windowGraphicsContext :: WindowGraphicsContext -- ^ Defaults to 'NoGraphicsContext'. Can not be changed after window creation.
      , WindowConfig -> WindowPosition
    windowPosition        :: WindowPosition        -- ^ Defaults to 'Wherever'.
      , WindowConfig -> Bool
    windowResizable       :: Bool                  -- ^ Defaults to 'False'. Whether the window can be resized by the user. It is still possible to programatically change the size by changing 'windowSize'.
      , WindowConfig -> V2 CInt
    windowInitialSize     :: V2 CInt               -- ^ Defaults to @(800, 600)@. If you set 'windowHighDPI' flag, window size in screen coordinates may differ from the size in pixels. Use 'glGetDrawableSize' or 'SDL.Video.Vulkan.vkGetDrawableSize' to get size in pixels.
      , WindowConfig -> Bool
    windowVisible         :: Bool                  -- ^ Defaults to 'True'.
      } deriving (WindowConfig -> WindowConfig -> Bool
    (WindowConfig -> WindowConfig -> Bool)
    -> (WindowConfig -> WindowConfig -> Bool) -> Eq WindowConfig
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: WindowConfig -> WindowConfig -> Bool
    $c/= :: WindowConfig -> WindowConfig -> Bool
    == :: WindowConfig -> WindowConfig -> Bool
    $c== :: WindowConfig -> WindowConfig -> Bool
    Eq, (forall x. WindowConfig -> Rep WindowConfig x)
    -> (forall x. Rep WindowConfig x -> WindowConfig)
    -> Generic WindowConfig
    forall x. Rep WindowConfig x -> WindowConfig
    forall x. WindowConfig -> Rep WindowConfig x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep WindowConfig x -> WindowConfig
    $cfrom :: forall x. WindowConfig -> Rep WindowConfig x
    Generic, Eq WindowConfig
    Eq WindowConfig =>
    (WindowConfig -> WindowConfig -> Ordering)
    -> (WindowConfig -> WindowConfig -> Bool)
    -> (WindowConfig -> WindowConfig -> Bool)
    -> (WindowConfig -> WindowConfig -> Bool)
    -> (WindowConfig -> WindowConfig -> Bool)
    -> (WindowConfig -> WindowConfig -> WindowConfig)
    -> (WindowConfig -> WindowConfig -> WindowConfig)
    -> Ord WindowConfig
    WindowConfig -> WindowConfig -> Bool
    WindowConfig -> WindowConfig -> Ordering
    WindowConfig -> WindowConfig -> WindowConfig
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: WindowConfig -> WindowConfig -> WindowConfig
    $cmin :: WindowConfig -> WindowConfig -> WindowConfig
    max :: WindowConfig -> WindowConfig -> WindowConfig
    $cmax :: WindowConfig -> WindowConfig -> WindowConfig
    >= :: WindowConfig -> WindowConfig -> Bool
    $c>= :: WindowConfig -> WindowConfig -> Bool
    > :: WindowConfig -> WindowConfig -> Bool
    $c> :: WindowConfig -> WindowConfig -> Bool
    <= :: WindowConfig -> WindowConfig -> Bool
    $c<= :: WindowConfig -> WindowConfig -> Bool
    < :: WindowConfig -> WindowConfig -> Bool
    $c< :: WindowConfig -> WindowConfig -> Bool
    compare :: WindowConfig -> WindowConfig -> Ordering
    $ccompare :: WindowConfig -> WindowConfig -> Ordering
    $cp1Ord :: Eq WindowConfig
    Ord, ReadPrec [WindowConfig]
    ReadPrec WindowConfig
    Int -> ReadS WindowConfig
    ReadS [WindowConfig]
    (Int -> ReadS WindowConfig)
    -> ReadS [WindowConfig]
    -> ReadPrec WindowConfig
    -> ReadPrec [WindowConfig]
    -> Read WindowConfig
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [WindowConfig]
    $creadListPrec :: ReadPrec [WindowConfig]
    readPrec :: ReadPrec WindowConfig
    $creadPrec :: ReadPrec WindowConfig
    readList :: ReadS [WindowConfig]
    $creadList :: ReadS [WindowConfig]
    readsPrec :: Int -> ReadS WindowConfig
    $creadsPrec :: Int -> ReadS WindowConfig
    Read, Int -> WindowConfig -> ShowS
    [WindowConfig] -> ShowS
    WindowConfig -> String
    (Int -> WindowConfig -> ShowS)
    -> (WindowConfig -> String)
    -> ([WindowConfig] -> ShowS)
    -> Show WindowConfig
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [WindowConfig] -> ShowS
    $cshowList :: [WindowConfig] -> ShowS
    show :: WindowConfig -> String
    $cshow :: WindowConfig -> String
    showsPrec :: Int -> WindowConfig -> ShowS
    $cshowsPrec :: Int -> WindowConfig -> ShowS
    Show, Typeable)

    -- | Configuration of additional graphics context that will be created for window.
    --
    --   Can not be changed after window creation.
    data WindowGraphicsContext
      = NoGraphicsContext          -- ^ Window will be created without any additional graphics context.
      | OpenGLContext OpenGLConfig -- ^ Window will be created with OpenGL support with parameters from 'OpenGLConfig'.
      | VulkanContext              -- ^ Window will be created with Vulkan support.
                                   --   The following functions will be implicitly called by SDL C library:
                                   --
                                   --     1. analogue of 'SDL.Video.Vulkan.vkLoadLibrary' 'Nothing' will be called automatically before first window creation;
                                   --     2. analogue of 'SDL.Video.Vulkan.vkUnloadLibrary' will be called after last window destruction.
      deriving (WindowGraphicsContext -> WindowGraphicsContext -> Bool
    (WindowGraphicsContext -> WindowGraphicsContext -> Bool)
    -> (WindowGraphicsContext -> WindowGraphicsContext -> Bool)
    -> Eq WindowGraphicsContext
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    $c/= :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    == :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    $c== :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    Eq, (forall x. WindowGraphicsContext -> Rep WindowGraphicsContext x)
    -> (forall x. Rep WindowGraphicsContext x -> WindowGraphicsContext)
    -> Generic WindowGraphicsContext
    forall x. Rep WindowGraphicsContext x -> WindowGraphicsContext
    forall x. WindowGraphicsContext -> Rep WindowGraphicsContext x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep WindowGraphicsContext x -> WindowGraphicsContext
    $cfrom :: forall x. WindowGraphicsContext -> Rep WindowGraphicsContext x
    Generic, Eq WindowGraphicsContext
    Eq WindowGraphicsContext =>
    (WindowGraphicsContext -> WindowGraphicsContext -> Ordering)
    -> (WindowGraphicsContext -> WindowGraphicsContext -> Bool)
    -> (WindowGraphicsContext -> WindowGraphicsContext -> Bool)
    -> (WindowGraphicsContext -> WindowGraphicsContext -> Bool)
    -> (WindowGraphicsContext -> WindowGraphicsContext -> Bool)
    -> (WindowGraphicsContext
        -> WindowGraphicsContext -> WindowGraphicsContext)
    -> (WindowGraphicsContext
        -> WindowGraphicsContext -> WindowGraphicsContext)
    -> Ord WindowGraphicsContext
    WindowGraphicsContext -> WindowGraphicsContext -> Bool
    WindowGraphicsContext -> WindowGraphicsContext -> Ordering
    WindowGraphicsContext
    -> WindowGraphicsContext -> WindowGraphicsContext
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: WindowGraphicsContext
    -> WindowGraphicsContext -> WindowGraphicsContext
    $cmin :: WindowGraphicsContext
    -> WindowGraphicsContext -> WindowGraphicsContext
    max :: WindowGraphicsContext
    -> WindowGraphicsContext -> WindowGraphicsContext
    $cmax :: WindowGraphicsContext
    -> WindowGraphicsContext -> WindowGraphicsContext
    >= :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    $c>= :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    > :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    $c> :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    <= :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    $c<= :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    < :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    $c< :: WindowGraphicsContext -> WindowGraphicsContext -> Bool
    compare :: WindowGraphicsContext -> WindowGraphicsContext -> Ordering
    $ccompare :: WindowGraphicsContext -> WindowGraphicsContext -> Ordering
    $cp1Ord :: Eq WindowGraphicsContext
    Ord, ReadPrec [WindowGraphicsContext]
    ReadPrec WindowGraphicsContext
    Int -> ReadS WindowGraphicsContext
    ReadS [WindowGraphicsContext]
    (Int -> ReadS WindowGraphicsContext)
    -> ReadS [WindowGraphicsContext]
    -> ReadPrec WindowGraphicsContext
    -> ReadPrec [WindowGraphicsContext]
    -> Read WindowGraphicsContext
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [WindowGraphicsContext]
    $creadListPrec :: ReadPrec [WindowGraphicsContext]
    readPrec :: ReadPrec WindowGraphicsContext
    $creadPrec :: ReadPrec WindowGraphicsContext
    readList :: ReadS [WindowGraphicsContext]
    $creadList :: ReadS [WindowGraphicsContext]
    readsPrec :: Int -> ReadS WindowGraphicsContext
    $creadsPrec :: Int -> ReadS WindowGraphicsContext
    Read, Int -> WindowGraphicsContext -> ShowS
    [WindowGraphicsContext] -> ShowS
    WindowGraphicsContext -> String
    (Int -> WindowGraphicsContext -> ShowS)
    -> (WindowGraphicsContext -> String)
    -> ([WindowGraphicsContext] -> ShowS)
    -> Show WindowGraphicsContext
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [WindowGraphicsContext] -> ShowS
    $cshowList :: [WindowGraphicsContext] -> ShowS
    show :: WindowGraphicsContext -> String
    $cshow :: WindowGraphicsContext -> String
    showsPrec :: Int -> WindowGraphicsContext -> ShowS
    $cshowsPrec :: Int -> WindowGraphicsContext -> ShowS
    Show, Typeable)

    ctxIsOpenGL :: WindowGraphicsContext -> Bool
    ctxIsOpenGL :: WindowGraphicsContext -> Bool
    ctxIsOpenGL (OpenGLContext _) = Bool
    True
    ctxIsOpenGL _                 = Bool
    False

    data WindowMode
      = Fullscreen        -- ^ Real fullscreen with a video mode change
      | FullscreenDesktop -- ^ Fake fullscreen that takes the size of the desktop
      | Maximized
      | Minimized
      | Windowed
      deriving (WindowMode
    WindowMode -> WindowMode -> Bounded WindowMode
    forall a. a -> a -> Bounded a
    maxBound :: WindowMode
    $cmaxBound :: WindowMode
    minBound :: WindowMode
    $cminBound :: WindowMode
    Bounded, Typeable WindowMode
    Constr
    DataType
    Typeable WindowMode =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> WindowMode -> c WindowMode)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c WindowMode)
    -> (WindowMode -> Constr)
    -> (WindowMode -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c WindowMode))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c WindowMode))
    -> ((forall b. Data b => b -> b) -> WindowMode -> WindowMode)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> WindowMode -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> WindowMode -> r)
    -> (forall u. (forall d. Data d => d -> u) -> WindowMode -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> WindowMode -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> WindowMode -> m WindowMode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> WindowMode -> m WindowMode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> WindowMode -> m WindowMode)
    -> Data WindowMode
    WindowMode -> Constr
    WindowMode -> DataType
    (forall b. Data b => b -> b) -> WindowMode -> WindowMode
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WindowMode -> c WindowMode
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WindowMode
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> WindowMode -> u
    forall u. (forall d. Data d => d -> u) -> WindowMode -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WindowMode -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WindowMode -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WindowMode -> m WindowMode
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WindowMode -> m WindowMode
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WindowMode
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WindowMode -> c WindowMode
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WindowMode)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WindowMode)
    $cWindowed :: Constr
    $cMinimized :: Constr
    $cMaximized :: Constr
    $cFullscreenDesktop :: Constr
    $cFullscreen :: Constr
    $tWindowMode :: DataType
    gmapMo :: (forall d. Data d => d -> m d) -> WindowMode -> m WindowMode
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WindowMode -> m WindowMode
    gmapMp :: (forall d. Data d => d -> m d) -> WindowMode -> m WindowMode
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WindowMode -> m WindowMode
    gmapM :: (forall d. Data d => d -> m d) -> WindowMode -> m WindowMode
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WindowMode -> m WindowMode
    gmapQi :: Int -> (forall d. Data d => d -> u) -> WindowMode -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WindowMode -> u
    gmapQ :: (forall d. Data d => d -> u) -> WindowMode -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> WindowMode -> [u]
    gmapQr :: (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WindowMode -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WindowMode -> r
    gmapQl :: (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WindowMode -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WindowMode -> r
    gmapT :: (forall b. Data b => b -> b) -> WindowMode -> WindowMode
    $cgmapT :: (forall b. Data b => b -> b) -> WindowMode -> WindowMode
    dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WindowMode)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WindowMode)
    dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c WindowMode)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WindowMode)
    dataTypeOf :: WindowMode -> DataType
    $cdataTypeOf :: WindowMode -> DataType
    toConstr :: WindowMode -> Constr
    $ctoConstr :: WindowMode -> Constr
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WindowMode
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WindowMode
    gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WindowMode -> c WindowMode
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WindowMode -> c WindowMode
    $cp1Data :: Typeable WindowMode
    Data, Int -> WindowMode
    WindowMode -> Int
    WindowMode -> [WindowMode]
    WindowMode -> WindowMode
    WindowMode -> WindowMode -> [WindowMode]
    WindowMode -> WindowMode -> WindowMode -> [WindowMode]
    (WindowMode -> WindowMode)
    -> (WindowMode -> WindowMode)
    -> (Int -> WindowMode)
    -> (WindowMode -> Int)
    -> (WindowMode -> [WindowMode])
    -> (WindowMode -> WindowMode -> [WindowMode])
    -> (WindowMode -> WindowMode -> [WindowMode])
    -> (WindowMode -> WindowMode -> WindowMode -> [WindowMode])
    -> Enum WindowMode
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    enumFromThenTo :: WindowMode -> WindowMode -> WindowMode -> [WindowMode]
    $cenumFromThenTo :: WindowMode -> WindowMode -> WindowMode -> [WindowMode]
    enumFromTo :: WindowMode -> WindowMode -> [WindowMode]
    $cenumFromTo :: WindowMode -> WindowMode -> [WindowMode]
    enumFromThen :: WindowMode -> WindowMode -> [WindowMode]
    $cenumFromThen :: WindowMode -> WindowMode -> [WindowMode]
    enumFrom :: WindowMode -> [WindowMode]
    $cenumFrom :: WindowMode -> [WindowMode]
    fromEnum :: WindowMode -> Int
    $cfromEnum :: WindowMode -> Int
    toEnum :: Int -> WindowMode
    $ctoEnum :: Int -> WindowMode
    pred :: WindowMode -> WindowMode
    $cpred :: WindowMode -> WindowMode
    succ :: WindowMode -> WindowMode
    $csucc :: WindowMode -> WindowMode
    Enum, WindowMode -> WindowMode -> Bool
    (WindowMode -> WindowMode -> Bool)
    -> (WindowMode -> WindowMode -> Bool) -> Eq WindowMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: WindowMode -> WindowMode -> Bool
    $c/= :: WindowMode -> WindowMode -> Bool
    == :: WindowMode -> WindowMode -> Bool
    $c== :: WindowMode -> WindowMode -> Bool
    Eq, (forall x. WindowMode -> Rep WindowMode x)
    -> (forall x. Rep WindowMode x -> WindowMode) -> Generic WindowMode
    forall x. Rep WindowMode x -> WindowMode
    forall x. WindowMode -> Rep WindowMode x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep WindowMode x -> WindowMode
    $cfrom :: forall x. WindowMode -> Rep WindowMode x
    Generic, Eq WindowMode
    Eq WindowMode =>
    (WindowMode -> WindowMode -> Ordering)
    -> (WindowMode -> WindowMode -> Bool)
    -> (WindowMode -> WindowMode -> Bool)
    -> (WindowMode -> WindowMode -> Bool)
    -> (WindowMode -> WindowMode -> Bool)
    -> (WindowMode -> WindowMode -> WindowMode)
    -> (WindowMode -> WindowMode -> WindowMode)
    -> Ord WindowMode
    WindowMode -> WindowMode -> Bool
    WindowMode -> WindowMode -> Ordering
    WindowMode -> WindowMode -> WindowMode
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: WindowMode -> WindowMode -> WindowMode
    $cmin :: WindowMode -> WindowMode -> WindowMode
    max :: WindowMode -> WindowMode -> WindowMode
    $cmax :: WindowMode -> WindowMode -> WindowMode
    >= :: WindowMode -> WindowMode -> Bool
    $c>= :: WindowMode -> WindowMode -> Bool
    > :: WindowMode -> WindowMode -> Bool
    $c> :: WindowMode -> WindowMode -> Bool
    <= :: WindowMode -> WindowMode -> Bool
    $c<= :: WindowMode -> WindowMode -> Bool
    < :: WindowMode -> WindowMode -> Bool
    $c< :: WindowMode -> WindowMode -> Bool
    compare :: WindowMode -> WindowMode -> Ordering
    $ccompare :: WindowMode -> WindowMode -> Ordering
    $cp1Ord :: Eq WindowMode
    Ord, ReadPrec [WindowMode]
    ReadPrec WindowMode
    Int -> ReadS WindowMode
    ReadS [WindowMode]
    (Int -> ReadS WindowMode)
    -> ReadS [WindowMode]
    -> ReadPrec WindowMode
    -> ReadPrec [WindowMode]
    -> Read WindowMode
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [WindowMode]
    $creadListPrec :: ReadPrec [WindowMode]
    readPrec :: ReadPrec WindowMode
    $creadPrec :: ReadPrec WindowMode
    readList :: ReadS [WindowMode]
    $creadList :: ReadS [WindowMode]
    readsPrec :: Int -> ReadS WindowMode
    $creadsPrec :: Int -> ReadS WindowMode
    Read, Int -> WindowMode -> ShowS
    [WindowMode] -> ShowS
    WindowMode -> String
    (Int -> WindowMode -> ShowS)
    -> (WindowMode -> String)
    -> ([WindowMode] -> ShowS)
    -> Show WindowMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [WindowMode] -> ShowS
    $cshowList :: [WindowMode] -> ShowS
    show :: WindowMode -> String
    $cshow :: WindowMode -> String
    showsPrec :: Int -> WindowMode -> ShowS
    $cshowsPrec :: Int -> WindowMode -> ShowS
    Show, Typeable)

    instance ToNumber WindowMode Word32 where
      toNumber :: WindowMode -> Word32
    toNumber Fullscreen = Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_FULLSCREEN
      toNumber FullscreenDesktop = Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_FULLSCREEN_DESKTOP
      toNumber Maximized = Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_MAXIMIZED
      toNumber Minimized = Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_MINIMIZED
      toNumber Windowed = 0

    instance FromNumber WindowMode Word32 where
      fromNumber :: Word32 -> WindowMode
    fromNumber n :: Word32
    n = WindowMode -> Maybe WindowMode -> WindowMode
    forall a. a -> Maybe a -> a
    fromMaybe WindowMode
    Windowed (Maybe WindowMode -> WindowMode)
    -> (First WindowMode -> Maybe WindowMode)
    -> First WindowMode
    -> WindowMode
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . First WindowMode -> Maybe WindowMode
    forall a. First a -> Maybe a
    getFirst (First WindowMode -> WindowMode) -> First WindowMode -> WindowMode
    forall a b. (a -> b) -> a -> b
    $
        (Maybe WindowMode -> First WindowMode)
    -> [Maybe WindowMode] -> First WindowMode
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    foldMap Maybe WindowMode -> First WindowMode
    forall a. Maybe a -> First a
    First [
            Maybe WindowMode
    sdlWindowFullscreen
          , Maybe WindowMode
    sdlWindowFullscreenDesktop
          , Maybe WindowMode
    sdlWindowMaximized
          , Maybe WindowMode
    sdlWindowMinimized
          ]
        where
          maybeBit :: a -> Word32 -> Maybe a
    maybeBit val :: a
    val msk :: Word32
    msk = if Word32
    n Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    msk Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    > 0 then a -> Maybe a
    forall a. a -> Maybe a
    Just a
    val else Maybe a
    forall a. Maybe a
    Nothing
          sdlWindowFullscreen :: Maybe WindowMode
    sdlWindowFullscreen        = WindowMode -> Word32 -> Maybe WindowMode
    forall a. a -> Word32 -> Maybe a
    maybeBit WindowMode
    Fullscreen Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_FULLSCREEN
          sdlWindowFullscreenDesktop :: Maybe WindowMode
    sdlWindowFullscreenDesktop = WindowMode -> Word32 -> Maybe WindowMode
    forall a. a -> Word32 -> Maybe a
    maybeBit WindowMode
    FullscreenDesktop Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_FULLSCREEN_DESKTOP
          sdlWindowMaximized :: Maybe WindowMode
    sdlWindowMaximized         = WindowMode -> Word32 -> Maybe WindowMode
    forall a. a -> Word32 -> Maybe a
    maybeBit WindowMode
    Maximized Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_MAXIMIZED
          sdlWindowMinimized :: Maybe WindowMode
    sdlWindowMinimized         = WindowMode -> Word32 -> Maybe WindowMode
    forall a. a -> Word32 -> Maybe a
    maybeBit WindowMode
    Minimized Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_MINIMIZED

    data WindowPosition
      = Centered
      | Wherever -- ^ Let the window mananger decide where it's best to place the window.
      | Absolute (Point V2 CInt)
      deriving (WindowPosition -> WindowPosition -> Bool
    (WindowPosition -> WindowPosition -> Bool)
    -> (WindowPosition -> WindowPosition -> Bool) -> Eq WindowPosition
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: WindowPosition -> WindowPosition -> Bool
    $c/= :: WindowPosition -> WindowPosition -> Bool
    == :: WindowPosition -> WindowPosition -> Bool
    $c== :: WindowPosition -> WindowPosition -> Bool
    Eq, (forall x. WindowPosition -> Rep WindowPosition x)
    -> (forall x. Rep WindowPosition x -> WindowPosition)
    -> Generic WindowPosition
    forall x. Rep WindowPosition x -> WindowPosition
    forall x. WindowPosition -> Rep WindowPosition x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep WindowPosition x -> WindowPosition
    $cfrom :: forall x. WindowPosition -> Rep WindowPosition x
    Generic, Eq WindowPosition
    Eq WindowPosition =>
    (WindowPosition -> WindowPosition -> Ordering)
    -> (WindowPosition -> WindowPosition -> Bool)
    -> (WindowPosition -> WindowPosition -> Bool)
    -> (WindowPosition -> WindowPosition -> Bool)
    -> (WindowPosition -> WindowPosition -> Bool)
    -> (WindowPosition -> WindowPosition -> WindowPosition)
    -> (WindowPosition -> WindowPosition -> WindowPosition)
    -> Ord WindowPosition
    WindowPosition -> WindowPosition -> Bool
    WindowPosition -> WindowPosition -> Ordering
    WindowPosition -> WindowPosition -> WindowPosition
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: WindowPosition -> WindowPosition -> WindowPosition
    $cmin :: WindowPosition -> WindowPosition -> WindowPosition
    max :: WindowPosition -> WindowPosition -> WindowPosition
    $cmax :: WindowPosition -> WindowPosition -> WindowPosition
    >= :: WindowPosition -> WindowPosition -> Bool
    $c>= :: WindowPosition -> WindowPosition -> Bool
    > :: WindowPosition -> WindowPosition -> Bool
    $c> :: WindowPosition -> WindowPosition -> Bool
    <= :: WindowPosition -> WindowPosition -> Bool
    $c<= :: WindowPosition -> WindowPosition -> Bool
    < :: WindowPosition -> WindowPosition -> Bool
    $c< :: WindowPosition -> WindowPosition -> Bool
    compare :: WindowPosition -> WindowPosition -> Ordering
    $ccompare :: WindowPosition -> WindowPosition -> Ordering
    $cp1Ord :: Eq WindowPosition
    Ord, ReadPrec [WindowPosition]
    ReadPrec WindowPosition
    Int -> ReadS WindowPosition
    ReadS [WindowPosition]
    (Int -> ReadS WindowPosition)
    -> ReadS [WindowPosition]
    -> ReadPrec WindowPosition
    -> ReadPrec [WindowPosition]
    -> Read WindowPosition
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [WindowPosition]
    $creadListPrec :: ReadPrec [WindowPosition]
    readPrec :: ReadPrec WindowPosition
    $creadPrec :: ReadPrec WindowPosition
    readList :: ReadS [WindowPosition]
    $creadList :: ReadS [WindowPosition]
    readsPrec :: Int -> ReadS WindowPosition
    $creadsPrec :: Int -> ReadS WindowPosition
    Read, Int -> WindowPosition -> ShowS
    [WindowPosition] -> ShowS
    WindowPosition -> String
    (Int -> WindowPosition -> ShowS)
    -> (WindowPosition -> String)
    -> ([WindowPosition] -> ShowS)
    -> Show WindowPosition
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [WindowPosition] -> ShowS
    $cshowList :: [WindowPosition] -> ShowS
    show :: WindowPosition -> String
    $cshow :: WindowPosition -> String
    showsPrec :: Int -> WindowPosition -> ShowS
    $cshowsPrec :: Int -> WindowPosition -> ShowS
    Show, Typeable)

    -- | Destroy the given window. The 'Window' handler may not be used
    -- afterwards.
    destroyWindow :: MonadIO m => Window -> m ()
    destroyWindow :: Window -> m ()
    destroyWindow (Window w :: Window
    w) = Window -> m ()
    forall (m :: * -> *). MonadIO m => Window -> m ()
    Raw.destroyWindow Window
    w

    -- | Get or set if the window should have a border.
    --
    -- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
    windowBordered :: Window -> StateVar Bool
    windowBordered :: Window -> StateVar Bool
    windowBordered (Window w :: Window
    w) = IO Bool -> (Bool -> IO ()) -> StateVar Bool
    forall a. IO a -> (a -> IO ()) -> StateVar a
    makeStateVar IO Bool
    getWindowBordered Bool -> IO ()
    setWindowBordered
      where
      getWindowBordered :: IO Bool
    getWindowBordered = (Word32 -> Bool) -> IO Word32 -> IO Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((Word32 -> Word32 -> Bool
    forall a. Eq a => a -> a -> Bool
    == 0) (Word32 -> Bool) -> (Word32 -> Word32) -> Word32 -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_BORDERLESS)) (Window -> IO Word32
    forall (m :: * -> *). MonadIO m => Window -> m Word32
    Raw.getWindowFlags Window
    w)
      setWindowBordered :: Bool -> IO ()
    setWindowBordered = Window -> Bool -> IO ()
    forall (m :: * -> *). MonadIO m => Window -> Bool -> m ()
    Raw.setWindowBordered Window
    w

    -- | Get or set the window's brightness, where 0.0 is completely dark and 1.0 is normal brightness.
    --
    -- Throws 'SDLException' if the hardware does not support gamma
    -- correction, or if the system has run out of memory.
    --
    -- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
    windowBrightness :: Window -> StateVar Float
    windowBrightness :: Window -> StateVar Float
    windowBrightness (Window w :: Window
    w) = IO Float -> (Float -> IO ()) -> StateVar Float
    forall a. IO a -> (a -> IO ()) -> StateVar a
    makeStateVar IO Float
    getWindowBrightness Float -> IO ()
    forall (m :: * -> *) a. (MonadIO m, Real a) => a -> m ()
    setWindowBrightness
      where
      setWindowBrightness :: a -> m ()
    setWindowBrightness brightness :: a
    brightness = do
        Text -> Text -> m CInt -> m ()
    forall a (m :: * -> *).
    (Eq a, MonadIO m, Num a) =>
    Text -> Text -> m a -> m ()
    throwIfNot0_ "SDL.Video.setWindowBrightness" "SDL_SetWindowBrightness" (m CInt -> m ()) -> m CInt -> m ()
    forall a b. (a -> b) -> a -> b
    $
          Window -> CFloat -> m CInt
    forall (m :: * -> *). MonadIO m => Window -> CFloat -> m CInt
    Raw.setWindowBrightness Window
    w (CFloat -> m CInt) -> CFloat -> m CInt
    forall a b. (a -> b) -> a -> b
    $ a -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac a
    brightness

      getWindowBrightness :: IO Float
    getWindowBrightness =
          Float -> IO Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> IO Float) -> (CFloat -> Float) -> CFloat -> IO Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac (CFloat -> IO Float) -> IO CFloat -> IO Float
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Window -> IO CFloat
    forall (m :: * -> *). MonadIO m => Window -> m CFloat
    Raw.getWindowBrightness Window
    w

    -- | Get or set whether the mouse shall be confined to the window.
    --
    -- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
    windowGrab :: Window -> StateVar Bool
    windowGrab :: Window -> StateVar Bool
    windowGrab (Window w :: Window
    w) = IO Bool -> (Bool -> IO ()) -> StateVar Bool
    forall a. IO a -> (a -> IO ()) -> StateVar a
    makeStateVar IO Bool
    getWindowGrab Bool -> IO ()
    setWindowGrab
      where
      setWindowGrab :: Bool -> IO ()
    setWindowGrab = Window -> Bool -> IO ()
    forall (m :: * -> *). MonadIO m => Window -> Bool -> m ()
    Raw.setWindowGrab Window
    w
      getWindowGrab :: IO Bool
    getWindowGrab = Window -> IO Bool
    forall (m :: * -> *). MonadIO m => Window -> m Bool
    Raw.getWindowGrab Window
    w

    -- | Change between window modes.
    --
    -- Throws 'SDLException' on failure.
    setWindowMode :: MonadIO m => Window -> WindowMode -> m ()
    setWindowMode :: Window -> WindowMode -> m ()
    setWindowMode (Window w :: Window
    w) mode :: WindowMode
    mode =
      IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> (IO CInt -> IO ()) -> IO CInt -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Text -> IO CInt -> IO ()
    forall a (m :: * -> *).
    (Eq a, MonadIO m, Num a) =>
    Text -> Text -> m a -> m ()
    throwIfNot0_ "SDL.Video.setWindowMode" "SDL_SetWindowFullscreen" (IO CInt -> m ()) -> IO CInt -> m ()
    forall a b. (a -> b) -> a -> b
    $
        case WindowMode
    mode of
          Fullscreen -> Window -> Word32 -> IO CInt
    forall (m :: * -> *). MonadIO m => Window -> Word32 -> m CInt
    Raw.setWindowFullscreen Window
    w Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_FULLSCREEN IO CInt -> IO () -> IO CInt
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Window -> IO ()
    forall (m :: * -> *). MonadIO m => Window -> m ()
    Raw.raiseWindow Window
    w
          FullscreenDesktop -> Window -> Word32 -> IO CInt
    forall (m :: * -> *). MonadIO m => Window -> Word32 -> m CInt
    Raw.setWindowFullscreen Window
    w Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_FULLSCREEN_DESKTOP IO CInt -> IO () -> IO CInt
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Window -> IO ()
    forall (m :: * -> *). MonadIO m => Window -> m ()
    Raw.raiseWindow Window
    w
          Maximized -> Window -> Word32 -> IO CInt
    forall (m :: * -> *). MonadIO m => Window -> Word32 -> m CInt
    Raw.setWindowFullscreen Window
    w 0 IO CInt -> IO () -> IO CInt
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Window -> IO ()
    forall (m :: * -> *). MonadIO m => Window -> m ()
    Raw.maximizeWindow Window
    w
          Minimized -> Window -> IO ()
    forall (m :: * -> *). MonadIO m => Window -> m ()
    Raw.minimizeWindow Window
    w IO () -> IO CInt -> IO CInt
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> CInt -> IO CInt
    forall (m :: * -> *) a. Monad m => a -> m a
    return 0
          Windowed -> Window -> Word32 -> IO CInt
    forall (m :: * -> *). MonadIO m => Window -> Word32 -> m CInt
    Raw.setWindowFullscreen Window
    w 0 IO CInt -> IO () -> IO CInt
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Window -> IO ()
    forall (m :: * -> *). MonadIO m => Window -> m ()
    Raw.restoreWindow Window
    w

    -- | Set the position of the window.
    setWindowPosition :: MonadIO m => Window -> WindowPosition -> m ()
    setWindowPosition :: Window -> WindowPosition -> m ()
    setWindowPosition (Window w :: Window
    w) pos :: WindowPosition
    pos = case WindowPosition
    pos of
      Centered -> let u :: CInt
    u = CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOWPOS_CENTERED in Window -> CInt -> CInt -> m ()
    forall (m :: * -> *). MonadIO m => Window -> CInt -> CInt -> m ()
    Raw.setWindowPosition Window
    w CInt
    u CInt
    u
      Wherever -> let u :: CInt
    u = CInt
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOWPOS_UNDEFINED in Window -> CInt -> CInt -> m ()
    forall (m :: * -> *). MonadIO m => Window -> CInt -> CInt -> m ()
    Raw.setWindowPosition Window
    w CInt
    u CInt
    u
      Absolute (P (V2 x :: CInt
    x y :: CInt
    y)) -> Window -> CInt -> CInt -> m ()
    forall (m :: * -> *). MonadIO m => Window -> CInt -> CInt -> m ()
    Raw.setWindowPosition Window
    w CInt
    x CInt
    y

    -- | Get the position of the window.
    getWindowAbsolutePosition :: MonadIO m => Window -> m (V2 CInt)
    getWindowAbsolutePosition :: Window -> m (V2 CInt)
    getWindowAbsolutePosition (Window w :: Window
    w) =
        IO (V2 CInt) -> m (V2 CInt)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (V2 CInt) -> m (V2 CInt)) -> IO (V2 CInt) -> m (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $
        (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt))
    -> (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $ \wPtr :: Ptr CInt
    wPtr ->
        (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt))
    -> (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $ \hPtr :: Ptr CInt
    hPtr -> do
            Window -> Ptr CInt -> Ptr CInt -> IO ()
    forall (m :: * -> *).
    MonadIO m =>
    Window -> Ptr CInt -> Ptr CInt -> m ()
    Raw.getWindowPosition Window
    w Ptr CInt
    wPtr Ptr CInt
    hPtr
            CInt -> CInt -> V2 CInt
    forall a. a -> a -> V2 a
    V2 (CInt -> CInt -> V2 CInt) -> IO CInt -> IO (CInt -> V2 CInt)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Ptr CInt -> IO CInt
    forall a. Storable a => Ptr a -> IO a
    peek Ptr CInt
    wPtr IO (CInt -> V2 CInt) -> IO CInt -> IO (V2 CInt)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Ptr CInt -> IO CInt
    forall a. Storable a => Ptr a -> IO a
    peek Ptr CInt
    hPtr

    -- | Get or set the size of a window's client area. Values beyond the maximum supported size are clamped.
    --
    -- If window was created with 'windowHighDPI' flag, this size may differ from the size in pixels.
    -- Use 'glGetDrawableSize' or 'SDL.Video.Vulkan.vkGetDrawableSize' to get size in pixels.
    --
    -- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
    --
    -- See @<https://wiki.libsdl.org/SDL_SetWindowSize SDL_SetWindowSize>@ and @<https://wiki.libsdl.org/SDL_GetWindowSize SDL_GetWindowSize>@ for C documentation.
    windowSize :: Window -> StateVar (V2 CInt)
    windowSize :: Window -> StateVar (V2 CInt)
    windowSize (Window win :: Window
    win) = IO (V2 CInt) -> (V2 CInt -> IO ()) -> StateVar (V2 CInt)
    forall a. IO a -> (a -> IO ()) -> StateVar a
    makeStateVar IO (V2 CInt)
    getWindowSize V2 CInt -> IO ()
    forall (m :: * -> *). MonadIO m => V2 CInt -> m ()
    setWindowSize
      where
      setWindowSize :: V2 CInt -> m ()
    setWindowSize (V2 w :: CInt
    w h :: CInt
    h) = Window -> CInt -> CInt -> m ()
    forall (m :: * -> *). MonadIO m => Window -> CInt -> CInt -> m ()
    Raw.setWindowSize Window
    win CInt
    w CInt
    h

      getWindowSize :: IO (V2 CInt)
    getWindowSize =
        IO (V2 CInt) -> IO (V2 CInt)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (V2 CInt) -> IO (V2 CInt)) -> IO (V2 CInt) -> IO (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $
        (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt))
    -> (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $ \wptr :: Ptr CInt
    wptr ->
        (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt))
    -> (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $ \hptr :: Ptr CInt
    hptr -> do
          Window -> Ptr CInt -> Ptr CInt -> IO ()
    forall (m :: * -> *).
    MonadIO m =>
    Window -> Ptr CInt -> Ptr CInt -> m ()
    Raw.getWindowSize Window
    win Ptr CInt
    wptr Ptr CInt
    hptr
          CInt -> CInt -> V2 CInt
    forall a. a -> a -> V2 a
    V2 (CInt -> CInt -> V2 CInt) -> IO CInt -> IO (CInt -> V2 CInt)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Ptr CInt -> IO CInt
    forall a. Storable a => Ptr a -> IO a
    peek Ptr CInt
    wptr IO (CInt -> V2 CInt) -> IO CInt -> IO (V2 CInt)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Ptr CInt -> IO CInt
    forall a. Storable a => Ptr a -> IO a
    peek Ptr CInt
    hptr

    -- | Get or set the title of the window. If the window has no title, then an empty string is returned.
    --
    -- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
    --
    -- See @<https://wiki.libsdl.org/SDL_SetWindowTitle SDL_SetWindowTitle>@ and @<https://wiki.libsdl.org/SDL_GetWindowTitle SDL_GetWindowTitle>@ for C documentation.
    windowTitle :: Window -> StateVar Text
    windowTitle :: Window -> StateVar Text
    windowTitle (Window w :: Window
    w) = IO Text -> (Text -> IO ()) -> StateVar Text
    forall a. IO a -> (a -> IO ()) -> StateVar a
    makeStateVar IO Text
    getWindowTitle Text -> IO ()
    forall (m :: * -> *). MonadIO m => Text -> m ()
    setWindowTitle
      where
      setWindowTitle :: Text -> m ()
    setWindowTitle title :: Text
    title =
        IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ())
    -> ((CString -> IO ()) -> IO ()) -> (CString -> IO ()) -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> (CString -> IO ()) -> IO ()
    forall a. ByteString -> (CString -> IO a) -> IO a
    BS.useAsCString (Text -> ByteString
    Text.encodeUtf8 Text
    title) ((CString -> IO ()) -> m ()) -> (CString -> IO ()) -> m ()
    forall a b. (a -> b) -> a -> b
    $
          Window -> CString -> IO ()
    forall (m :: * -> *). MonadIO m => Window -> CString -> m ()
    Raw.setWindowTitle Window
    w

      getWindowTitle :: IO Text
    getWindowTitle = IO Text -> IO Text
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> IO Text) -> IO Text -> IO Text
    forall a b. (a -> b) -> a -> b
    $ do
          CString
    cstr <- Window -> IO CString
    forall (m :: * -> *). MonadIO m => Window -> m CString
    Raw.getWindowTitle Window
    w
          ByteString -> Text
    Text.decodeUtf8 (ByteString -> Text) -> IO ByteString -> IO Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> CString -> IO ByteString
    BS.packCString CString
    cstr

    -- | Get or set the pointer to arbitrary user data associated with the given
    -- window and name.
    --
    -- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
    windowData :: Window -> CString -> StateVar (Ptr ())
    windowData :: Window -> CString -> StateVar Window
    windowData (Window w :: Window
    w) key :: CString
    key = IO Window -> (Window -> IO ()) -> StateVar Window
    forall a. IO a -> (a -> IO ()) -> StateVar a
    makeStateVar IO Window
    getWindowData Window -> IO ()
    setWindowData
      where
      setWindowData :: Window -> IO ()
    setWindowData = IO Window -> IO ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (IO Window -> IO ()) -> (Window -> IO Window) -> Window -> IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Window -> CString -> Window -> IO Window
    forall (m :: * -> *).
    MonadIO m =>
    Window -> CString -> Window -> m Window
    Raw.setWindowData Window
    w CString
    key
      getWindowData :: IO Window
    getWindowData = Window -> CString -> IO Window
    forall (m :: * -> *). MonadIO m => Window -> CString -> m Window
    Raw.getWindowData Window
    w CString
    key

    -- | Retrieve the configuration of the given window.
    --
    -- Note that 'NoGraphicsContext' will be returned instead of potential OpenGL parameters
    -- used during the creation of the window.
    getWindowConfig :: MonadIO m => Window -> m WindowConfig
    getWindowConfig :: Window -> m WindowConfig
    getWindowConfig (Window w :: Window
    w) = do
        Word32
    wFlags <- Window -> m Word32
    forall (m :: * -> *). MonadIO m => Window -> m Word32
    Raw.getWindowFlags Window
    w

        V2 CInt
    wSize <- StateVar (V2 CInt) -> m (V2 CInt)
    forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
    get (Window -> StateVar (V2 CInt)
    windowSize (Window -> Window
    Window Window
    w))
        V2 CInt
    wPos  <- Window -> m (V2 CInt)
    forall (m :: * -> *). MonadIO m => Window -> m (V2 CInt)
    getWindowAbsolutePosition (Window -> Window
    Window Window
    w)

        WindowConfig -> m WindowConfig
    forall (m :: * -> *) a. Monad m => a -> m a
    return WindowConfig :: Bool
    -> Bool
    -> Bool
    -> WindowMode
    -> WindowGraphicsContext
    -> WindowPosition
    -> Bool
    -> V2 CInt
    -> Bool
    -> WindowConfig
    WindowConfig {
            windowBorder :: Bool
    windowBorder          = Word32
    wFlags Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_BORDERLESS Word32 -> Word32 -> Bool
    forall a. Eq a => a -> a -> Bool
    == 0
          , windowHighDPI :: Bool
    windowHighDPI         = Word32
    wFlags Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_ALLOW_HIGHDPI Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    > 0
          , windowInputGrabbed :: Bool
    windowInputGrabbed    = Word32
    wFlags Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_INPUT_GRABBED Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    > 0
          , windowMode :: WindowMode
    windowMode            = Word32 -> WindowMode
    forall a b. FromNumber a b => b -> a
    fromNumber Word32
    wFlags
            -- Should we store the OpenGL config that was used to create the window?
          , windowGraphicsContext :: WindowGraphicsContext
    windowGraphicsContext = if Word32
    wFlags Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_VULKAN Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    > 0
                                      then WindowGraphicsContext
    VulkanContext else WindowGraphicsContext
    NoGraphicsContext
          , windowPosition :: WindowPosition
    windowPosition        = Point V2 CInt -> WindowPosition
    Absolute (V2 CInt -> Point V2 CInt
    forall (f :: * -> *) a. f a -> Point f a
    P V2 CInt
    wPos)
          , windowResizable :: Bool
    windowResizable       = Word32
    wFlags Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_RESIZABLE Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    > 0
          , windowInitialSize :: V2 CInt
    windowInitialSize     = V2 CInt
    wSize
          , windowVisible :: Bool
    windowVisible         = Word32
    wFlags Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_WINDOW_SHOWN Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    > 0
        }

    -- | Get the pixel format that is used for the given window.
    getWindowPixelFormat :: MonadIO m => Window -> m PixelFormat
    getWindowPixelFormat :: Window -> m PixelFormat
    getWindowPixelFormat (Window w :: Window
    w) = PixelFormat -> m PixelFormat
    forall (m :: * -> *) a. Monad m => a -> m a
    return (PixelFormat -> m PixelFormat)
    -> (Word32 -> PixelFormat) -> Word32 -> m PixelFormat
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> PixelFormat
    forall a b. FromNumber a b => b -> a
    fromNumber (Word32 -> m PixelFormat) -> m Word32 -> m PixelFormat
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Window -> m Word32
    forall (m :: * -> *). MonadIO m => Window -> m Word32
    Raw.getWindowPixelFormat Window
    w

    -- | Get the text from the clipboard.
    --
    -- Throws 'SDLException' on failure.
    getClipboardText :: MonadIO m => m Text
    getClipboardText :: m Text
    getClipboardText = IO Text -> m Text
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> (IO Text -> IO Text) -> IO Text -> m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . IO Text -> IO Text
    forall a. IO a -> IO a
    mask_ (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
      CString
    cstr <- Text -> Text -> IO CString -> IO CString
    forall (m :: * -> *) a.
    MonadIO m =>
    Text -> Text -> m (Ptr a) -> m (Ptr a)
    throwIfNull "SDL.Video.getClipboardText" "SDL_GetClipboardText"
        IO CString
    forall (m :: * -> *). MonadIO m => m CString
    Raw.getClipboardText
      IO Text -> IO () -> IO Text
    forall a b. IO a -> IO b -> IO a
    finally (ByteString -> Text
    Text.decodeUtf8 (ByteString -> Text) -> IO ByteString -> IO Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> CString -> IO ByteString
    BS.packCString CString
    cstr) (CString -> IO ()
    forall a. Ptr a -> IO ()
    free CString
    cstr)

    -- | Checks if the clipboard exists, and has some text in it.
    hasClipboardText :: MonadIO m => m Bool
    hasClipboardText :: m Bool
    hasClipboardText = m Bool
    forall (m :: * -> *). MonadIO m => m Bool
    Raw.hasClipboardText

    -- | Replace the contents of the clipboard with the given text.
    --
    -- Throws 'SDLException' on failure.
    setClipboardText :: MonadIO m => Text -> m ()
    setClipboardText :: Text -> m ()
    setClipboardText str :: Text
    str = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
      Text -> Text -> IO CInt -> IO ()
    forall a (m :: * -> *).
    (Eq a, MonadIO m, Num a) =>
    Text -> Text -> m a -> m ()
    throwIfNot0_ "SDL.Video.setClipboardText" "SDL_SetClipboardText" (IO CInt -> IO ()) -> IO CInt -> IO ()
    forall a b. (a -> b) -> a -> b
    $
        ByteString -> (CString -> IO CInt) -> IO CInt
    forall a. ByteString -> (CString -> IO a) -> IO a
    BS.useAsCString (Text -> ByteString
    Text.encodeUtf8 Text
    str) CString -> IO CInt
    forall (m :: * -> *). MonadIO m => CString -> m CInt
    Raw.setClipboardText

    -- | Hide a window.
    --
    -- See @<https://wiki.libsdl.org/SDL_HideWindow SDL_HideWindow>@ for C documentation.
    hideWindow :: MonadIO m => Window -> m ()
    hideWindow :: Window -> m ()
    hideWindow (Window w :: Window
    w) = Window -> m ()
    forall (m :: * -> *). MonadIO m => Window -> m ()
    Raw.hideWindow Window
    w

    -- | Raise the window above other windows and set the input focus.
    --
    -- See @<https://wiki.libsdl.org/SDL_RaiseWindow SDL_RaiseWindow>@ for C documentation.
    raiseWindow :: MonadIO m => Window -> m ()
    raiseWindow :: Window -> m ()
    raiseWindow (Window w :: Window
    w) = Window -> m ()
    forall (m :: * -> *). MonadIO m => Window -> m ()
    Raw.raiseWindow Window
    w

    -- | Get or set whether to allow the screen to be blanked by a screen saver.
    --
    -- Screen savers are re-enabled, if needed, when SDL quits.
    screenSaverEnabled :: StateVar Bool
    screenSaverEnabled :: StateVar Bool
    screenSaverEnabled = IO Bool -> (Bool -> IO ()) -> StateVar Bool
    forall a. IO a -> (a -> IO ()) -> StateVar a
    makeStateVar (IO Bool
    isScreenSaverEnabled) (Bool -> IO ()
    forall (m :: * -> *). MonadIO m => Bool -> m ()
    setScreenSaverEnabled)
      where
      isScreenSaverEnabled :: IO Bool
    isScreenSaverEnabled = IO Bool
    forall (m :: * -> *). MonadIO m => m Bool
    Raw.isScreenSaverEnabled

      setScreenSaverEnabled :: Bool -> m ()
    setScreenSaverEnabled True = m ()
    forall (m :: * -> *). MonadIO m => m ()
    Raw.enableScreenSaver
      setScreenSaverEnabled False = m ()
    forall (m :: * -> *). MonadIO m => m ()
    Raw.disableScreenSaver

    -- | Show a window.
    --
    -- See @<https://wiki.libsdl.org/SDL_ShowWindow SDL_ShowWindow>@ for C documentation.
    showWindow :: MonadIO m => Window -> m ()
    showWindow :: Window -> m ()
    showWindow (Window w :: Window
    w) = Window -> m ()
    forall (m :: * -> *). MonadIO m => Window -> m ()
    Raw.showWindow Window
    w

    -- | Gets or sets the gamma ramp for the display that owns a given window.
    --
    -- Note that the data for the gamma ramp - the 'V3' ('SV.Vector' 'Word16') - must contain 256 element arrays. This triple is a set of translation vectors for each of the 16-bit red, green and blue channels.
    --
    -- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
    --
    -- Despite the name and signature, this method retrieves the gamma ramp of the entire display, not an individual window. A window is considered to be owned by the display that contains the window's center pixel.
    windowGammaRamp :: Window -> StateVar (V3 (SV.Vector Word16))
    windowGammaRamp :: Window -> StateVar (V3 (Vector Word16))
    windowGammaRamp (Window w :: Window
    w) = IO (V3 (Vector Word16))
    -> (V3 (Vector Word16) -> IO ()) -> StateVar (V3 (Vector Word16))
    forall a. IO a -> (a -> IO ()) -> StateVar a
    makeStateVar IO (V3 (Vector Word16))
    getWindowGammaRamp V3 (Vector Word16) -> IO ()
    forall (m :: * -> *). MonadIO m => V3 (Vector Word16) -> m ()
    setWindowGammaRamp
      where
      getWindowGammaRamp :: IO (V3 (Vector Word16))
    getWindowGammaRamp =
        Int
    -> (Ptr Word16 -> IO (V3 (Vector Word16)))
    -> IO (V3 (Vector Word16))
    forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
    allocaArray 256 ((Ptr Word16 -> IO (V3 (Vector Word16)))
     -> IO (V3 (Vector Word16)))
    -> (Ptr Word16 -> IO (V3 (Vector Word16)))
    -> IO (V3 (Vector Word16))
    forall a b. (a -> b) -> a -> b
    $ \rPtr :: Ptr Word16
    rPtr ->
        Int
    -> (Ptr Word16 -> IO (V3 (Vector Word16)))
    -> IO (V3 (Vector Word16))
    forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
    allocaArray 256 ((Ptr Word16 -> IO (V3 (Vector Word16)))
     -> IO (V3 (Vector Word16)))
    -> (Ptr Word16 -> IO (V3 (Vector Word16)))
    -> IO (V3 (Vector Word16))
    forall a b. (a -> b) -> a -> b
    $ \gPtr :: Ptr Word16
    gPtr ->
        Int
    -> (Ptr Word16 -> IO (V3 (Vector Word16)))
    -> IO (V3 (Vector Word16))
    forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
    allocaArray 256 ((Ptr Word16 -> IO (V3 (Vector Word16)))
     -> IO (V3 (Vector Word16)))
    -> (Ptr Word16 -> IO (V3 (Vector Word16)))
    -> IO (V3 (Vector Word16))
    forall a b. (a -> b) -> a -> b
    $ \bPtr :: Ptr Word16
    bPtr -> do
          Text -> Text -> IO CInt -> IO ()
    forall (m :: * -> *) a.
    (MonadIO m, Num a, Ord a) =>
    Text -> Text -> m a -> m ()
    throwIfNeg_ "SDL.Video.getWindowGammaRamp" "SDL_GetWindowGammaRamp"
            (Window -> Ptr Word16 -> Ptr Word16 -> Ptr Word16 -> IO CInt
    forall (m :: * -> *).
    MonadIO m =>
    Window -> Ptr Word16 -> Ptr Word16 -> Ptr Word16 -> m CInt
    Raw.getWindowGammaRamp Window
    w Ptr Word16
    rPtr Ptr Word16
    gPtr Ptr Word16
    bPtr)
          (Vector Word16
     -> Vector Word16 -> Vector Word16 -> V3 (Vector Word16))
    -> IO (Vector Word16)
    -> IO (Vector Word16)
    -> IO (Vector Word16)
    -> IO (V3 (Vector Word16))
    forall (f :: * -> *) a b c d.
    Applicative f =>
    (a -> b -> c -> d) -> f a -> f b -> f c -> f d
    liftA3 Vector Word16
    -> Vector Word16 -> Vector Word16 -> V3 (Vector Word16)
    forall a. a -> a -> a -> V3 a
    V3 (([Word16] -> Vector Word16) -> IO [Word16] -> IO (Vector Word16)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [Word16] -> Vector Word16
    forall a. Storable a => [a] -> Vector a
    SV.fromList (Int -> Ptr Word16 -> IO [Word16]
    forall a. Storable a => Int -> Ptr a -> IO [a]
    peekArray 256 Ptr Word16
    rPtr))
                    (([Word16] -> Vector Word16) -> IO [Word16] -> IO (Vector Word16)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [Word16] -> Vector Word16
    forall a. Storable a => [a] -> Vector a
    SV.fromList (Int -> Ptr Word16 -> IO [Word16]
    forall a. Storable a => Int -> Ptr a -> IO [a]
    peekArray 256 Ptr Word16
    gPtr))
                    (([Word16] -> Vector Word16) -> IO [Word16] -> IO (Vector Word16)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [Word16] -> Vector Word16
    forall a. Storable a => [a] -> Vector a
    SV.fromList (Int -> Ptr Word16 -> IO [Word16]
    forall a. Storable a => Int -> Ptr a -> IO [a]
    peekArray 256 Ptr Word16
    bPtr))

      setWindowGammaRamp :: V3 (Vector Word16) -> m ()
    setWindowGammaRamp (V3 r :: Vector Word16
    r g :: Vector Word16
    g b :: Vector Word16
    b) = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Bool -> IO () -> IO ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless ((Vector Word16 -> Bool) -> [Vector Word16] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all ((Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == 256) (Int -> Bool) -> (Vector Word16 -> Int) -> Vector Word16 -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Vector Word16 -> Int
    forall a. Storable a => Vector a -> Int
    SV.length) [Vector Word16
    r,Vector Word16
    g,Vector Word16
    b]) (IO () -> IO ()) -> IO () -> IO ()
    forall a b. (a -> b) -> a -> b
    $
          String -> IO ()
    forall a. HasCallStack => String -> a
    error "setWindowGammaRamp requires 256 element in each colour channel"

        Vector Word16 -> (Ptr Word16 -> IO ()) -> IO ()
    forall a b. Storable a => Vector a -> (Ptr a -> IO b) -> IO b
    SV.unsafeWith Vector Word16
    r ((Ptr Word16 -> IO ()) -> IO ()) -> (Ptr Word16 -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \rPtr :: Ptr Word16
    rPtr ->
          Vector Word16 -> (Ptr Word16 -> IO ()) -> IO ()
    forall a b. Storable a => Vector a -> (Ptr a -> IO b) -> IO b
    SV.unsafeWith Vector Word16
    b ((Ptr Word16 -> IO ()) -> IO ()) -> (Ptr Word16 -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \bPtr :: Ptr Word16
    bPtr ->
            Vector Word16 -> (Ptr Word16 -> IO ()) -> IO ()
    forall a b. Storable a => Vector a -> (Ptr a -> IO b) -> IO b
    SV.unsafeWith Vector Word16
    g ((Ptr Word16 -> IO ()) -> IO ()) -> (Ptr Word16 -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \gPtr :: Ptr Word16
    gPtr ->
              Text -> Text -> IO CInt -> IO ()
    forall (m :: * -> *) a.
    (MonadIO m, Num a, Ord a) =>
    Text -> Text -> m a -> m ()
    throwIfNeg_ "SDL.Video.setWindowGammaRamp" "SDL_SetWindowGammaRamp" (IO CInt -> IO ()) -> IO CInt -> IO ()
    forall a b. (a -> b) -> a -> b
    $
                Window -> Ptr Word16 -> Ptr Word16 -> Ptr Word16 -> IO CInt
    forall (m :: * -> *).
    MonadIO m =>
    Window -> Ptr Word16 -> Ptr Word16 -> Ptr Word16 -> m CInt
    Raw.setWindowGammaRamp Window
    w Ptr Word16
    rPtr Ptr Word16
    gPtr Ptr Word16
    bPtr

    data Display = Display {
                   Display -> String
    displayName           :: String
                 , Display -> Point V2 CInt
    displayBoundsPosition :: Point V2 CInt
                     -- ^ Position of the desktop area represented by the display,
                     -- with the primary display located at @(0, 0)@.
                 , Display -> V2 CInt
    displayBoundsSize     :: V2 CInt
                     -- ^ Size of the desktop area represented by the display.
                 , Display -> [DisplayMode]
    displayModes          :: [DisplayMode]
                 }
                 deriving (Display -> Display -> Bool
    (Display -> Display -> Bool)
    -> (Display -> Display -> Bool) -> Eq Display
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Display -> Display -> Bool
    $c/= :: Display -> Display -> Bool
    == :: Display -> Display -> Bool
    $c== :: Display -> Display -> Bool
    Eq, (forall x. Display -> Rep Display x)
    -> (forall x. Rep Display x -> Display) -> Generic Display
    forall x. Rep Display x -> Display
    forall x. Display -> Rep Display x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Display x -> Display
    $cfrom :: forall x. Display -> Rep Display x
    Generic, Eq Display
    Eq Display =>
    (Display -> Display -> Ordering)
    -> (Display -> Display -> Bool)
    -> (Display -> Display -> Bool)
    -> (Display -> Display -> Bool)
    -> (Display -> Display -> Bool)
    -> (Display -> Display -> Display)
    -> (Display -> Display -> Display)
    -> Ord Display
    Display -> Display -> Bool
    Display -> Display -> Ordering
    Display -> Display -> Display
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: Display -> Display -> Display
    $cmin :: Display -> Display -> Display
    max :: Display -> Display -> Display
    $cmax :: Display -> Display -> Display
    >= :: Display -> Display -> Bool
    $c>= :: Display -> Display -> Bool
    > :: Display -> Display -> Bool
    $c> :: Display -> Display -> Bool
    <= :: Display -> Display -> Bool
    $c<= :: Display -> Display -> Bool
    < :: Display -> Display -> Bool
    $c< :: Display -> Display -> Bool
    compare :: Display -> Display -> Ordering
    $ccompare :: Display -> Display -> Ordering
    $cp1Ord :: Eq Display
    Ord, ReadPrec [Display]
    ReadPrec Display
    Int -> ReadS Display
    ReadS [Display]
    (Int -> ReadS Display)
    -> ReadS [Display]
    -> ReadPrec Display
    -> ReadPrec [Display]
    -> Read Display
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [Display]
    $creadListPrec :: ReadPrec [Display]
    readPrec :: ReadPrec Display
    $creadPrec :: ReadPrec Display
    readList :: ReadS [Display]
    $creadList :: ReadS [Display]
    readsPrec :: Int -> ReadS Display
    $creadsPrec :: Int -> ReadS Display
    Read, Int -> Display -> ShowS
    [Display] -> ShowS
    Display -> String
    (Int -> Display -> ShowS)
    -> (Display -> String) -> ([Display] -> ShowS) -> Show Display
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Display] -> ShowS
    $cshowList :: [Display] -> ShowS
    show :: Display -> String
    $cshow :: Display -> String
    showsPrec :: Int -> Display -> ShowS
    $cshowsPrec :: Int -> Display -> ShowS
    Show, Typeable)

    data DisplayMode = DisplayMode {
                       DisplayMode -> PixelFormat
    displayModeFormat      :: PixelFormat
                     , DisplayMode -> V2 CInt
    displayModeSize        :: V2 CInt
                     , DisplayMode -> CInt
    displayModeRefreshRate :: CInt -- ^ Display's refresh rate in hertz, or @0@ if unspecified.
                     }
                     deriving (DisplayMode -> DisplayMode -> Bool
    (DisplayMode -> DisplayMode -> Bool)
    -> (DisplayMode -> DisplayMode -> Bool) -> Eq DisplayMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: DisplayMode -> DisplayMode -> Bool
    $c/= :: DisplayMode -> DisplayMode -> Bool
    == :: DisplayMode -> DisplayMode -> Bool
    $c== :: DisplayMode -> DisplayMode -> Bool
    Eq, (forall x. DisplayMode -> Rep DisplayMode x)
    -> (forall x. Rep DisplayMode x -> DisplayMode)
    -> Generic DisplayMode
    forall x. Rep DisplayMode x -> DisplayMode
    forall x. DisplayMode -> Rep DisplayMode x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep DisplayMode x -> DisplayMode
    $cfrom :: forall x. DisplayMode -> Rep DisplayMode x
    Generic, Eq DisplayMode
    Eq DisplayMode =>
    (DisplayMode -> DisplayMode -> Ordering)
    -> (DisplayMode -> DisplayMode -> Bool)
    -> (DisplayMode -> DisplayMode -> Bool)
    -> (DisplayMode -> DisplayMode -> Bool)
    -> (DisplayMode -> DisplayMode -> Bool)
    -> (DisplayMode -> DisplayMode -> DisplayMode)
    -> (DisplayMode -> DisplayMode -> DisplayMode)
    -> Ord DisplayMode
    DisplayMode -> DisplayMode -> Bool
    DisplayMode -> DisplayMode -> Ordering
    DisplayMode -> DisplayMode -> DisplayMode
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: DisplayMode -> DisplayMode -> DisplayMode
    $cmin :: DisplayMode -> DisplayMode -> DisplayMode
    max :: DisplayMode -> DisplayMode -> DisplayMode
    $cmax :: DisplayMode -> DisplayMode -> DisplayMode
    >= :: DisplayMode -> DisplayMode -> Bool
    $c>= :: DisplayMode -> DisplayMode -> Bool
    > :: DisplayMode -> DisplayMode -> Bool
    $c> :: DisplayMode -> DisplayMode -> Bool
    <= :: DisplayMode -> DisplayMode -> Bool
    $c<= :: DisplayMode -> DisplayMode -> Bool
    < :: DisplayMode -> DisplayMode -> Bool
    $c< :: DisplayMode -> DisplayMode -> Bool
    compare :: DisplayMode -> DisplayMode -> Ordering
    $ccompare :: DisplayMode -> DisplayMode -> Ordering
    $cp1Ord :: Eq DisplayMode
    Ord, ReadPrec [DisplayMode]
    ReadPrec DisplayMode
    Int -> ReadS DisplayMode
    ReadS [DisplayMode]
    (Int -> ReadS DisplayMode)
    -> ReadS [DisplayMode]
    -> ReadPrec DisplayMode
    -> ReadPrec [DisplayMode]
    -> Read DisplayMode
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [DisplayMode]
    $creadListPrec :: ReadPrec [DisplayMode]
    readPrec :: ReadPrec DisplayMode
    $creadPrec :: ReadPrec DisplayMode
    readList :: ReadS [DisplayMode]
    $creadList :: ReadS [DisplayMode]
    readsPrec :: Int -> ReadS DisplayMode
    $creadsPrec :: Int -> ReadS DisplayMode
    Read, Int -> DisplayMode -> ShowS
    [DisplayMode] -> ShowS
    DisplayMode -> String
    (Int -> DisplayMode -> ShowS)
    -> (DisplayMode -> String)
    -> ([DisplayMode] -> ShowS)
    -> Show DisplayMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [DisplayMode] -> ShowS
    $cshowList :: [DisplayMode] -> ShowS
    show :: DisplayMode -> String
    $cshow :: DisplayMode -> String
    showsPrec :: Int -> DisplayMode -> ShowS
    $cshowsPrec :: Int -> DisplayMode -> ShowS
    Show, Typeable)

    data VideoDriver = VideoDriver {
                       VideoDriver -> String
    videoDriverName :: String
                     }
                     deriving (Typeable VideoDriver
    Constr
    DataType
    Typeable VideoDriver =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> VideoDriver -> c VideoDriver)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c VideoDriver)
    -> (VideoDriver -> Constr)
    -> (VideoDriver -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c VideoDriver))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c VideoDriver))
    -> ((forall b. Data b => b -> b) -> VideoDriver -> VideoDriver)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> VideoDriver -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> VideoDriver -> r)
    -> (forall u. (forall d. Data d => d -> u) -> VideoDriver -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> VideoDriver -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> VideoDriver -> m VideoDriver)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> VideoDriver -> m VideoDriver)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> VideoDriver -> m VideoDriver)
    -> Data VideoDriver
    VideoDriver -> Constr
    VideoDriver -> DataType
    (forall b. Data b => b -> b) -> VideoDriver -> VideoDriver
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VideoDriver -> c VideoDriver
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VideoDriver
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> VideoDriver -> u
    forall u. (forall d. Data d => d -> u) -> VideoDriver -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VideoDriver -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VideoDriver -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VideoDriver -> m VideoDriver
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VideoDriver -> m VideoDriver
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VideoDriver
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VideoDriver -> c VideoDriver
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c VideoDriver)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c VideoDriver)
    $cVideoDriver :: Constr
    $tVideoDriver :: DataType
    gmapMo :: (forall d. Data d => d -> m d) -> VideoDriver -> m VideoDriver
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VideoDriver -> m VideoDriver
    gmapMp :: (forall d. Data d => d -> m d) -> VideoDriver -> m VideoDriver
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VideoDriver -> m VideoDriver
    gmapM :: (forall d. Data d => d -> m d) -> VideoDriver -> m VideoDriver
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VideoDriver -> m VideoDriver
    gmapQi :: Int -> (forall d. Data d => d -> u) -> VideoDriver -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VideoDriver -> u
    gmapQ :: (forall d. Data d => d -> u) -> VideoDriver -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> VideoDriver -> [u]
    gmapQr :: (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VideoDriver -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VideoDriver -> r
    gmapQl :: (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VideoDriver -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VideoDriver -> r
    gmapT :: (forall b. Data b => b -> b) -> VideoDriver -> VideoDriver
    $cgmapT :: (forall b. Data b => b -> b) -> VideoDriver -> VideoDriver
    dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c VideoDriver)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c VideoDriver)
    dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c VideoDriver)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c VideoDriver)
    dataTypeOf :: VideoDriver -> DataType
    $cdataTypeOf :: VideoDriver -> DataType
    toConstr :: VideoDriver -> Constr
    $ctoConstr :: VideoDriver -> Constr
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VideoDriver
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VideoDriver
    gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VideoDriver -> c VideoDriver
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VideoDriver -> c VideoDriver
    $cp1Data :: Typeable VideoDriver
    Data, VideoDriver -> VideoDriver -> Bool
    (VideoDriver -> VideoDriver -> Bool)
    -> (VideoDriver -> VideoDriver -> Bool) -> Eq VideoDriver
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: VideoDriver -> VideoDriver -> Bool
    $c/= :: VideoDriver -> VideoDriver -> Bool
    == :: VideoDriver -> VideoDriver -> Bool
    $c== :: VideoDriver -> VideoDriver -> Bool
    Eq, (forall x. VideoDriver -> Rep VideoDriver x)
    -> (forall x. Rep VideoDriver x -> VideoDriver)
    -> Generic VideoDriver
    forall x. Rep VideoDriver x -> VideoDriver
    forall x. VideoDriver -> Rep VideoDriver x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep VideoDriver x -> VideoDriver
    $cfrom :: forall x. VideoDriver -> Rep VideoDriver x
    Generic, Eq VideoDriver
    Eq VideoDriver =>
    (VideoDriver -> VideoDriver -> Ordering)
    -> (VideoDriver -> VideoDriver -> Bool)
    -> (VideoDriver -> VideoDriver -> Bool)
    -> (VideoDriver -> VideoDriver -> Bool)
    -> (VideoDriver -> VideoDriver -> Bool)
    -> (VideoDriver -> VideoDriver -> VideoDriver)
    -> (VideoDriver -> VideoDriver -> VideoDriver)
    -> Ord VideoDriver
    VideoDriver -> VideoDriver -> Bool
    VideoDriver -> VideoDriver -> Ordering
    VideoDriver -> VideoDriver -> VideoDriver
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: VideoDriver -> VideoDriver -> VideoDriver
    $cmin :: VideoDriver -> VideoDriver -> VideoDriver
    max :: VideoDriver -> VideoDriver -> VideoDriver
    $cmax :: VideoDriver -> VideoDriver -> VideoDriver
    >= :: VideoDriver -> VideoDriver -> Bool
    $c>= :: VideoDriver -> VideoDriver -> Bool
    > :: VideoDriver -> VideoDriver -> Bool
    $c> :: VideoDriver -> VideoDriver -> Bool
    <= :: VideoDriver -> VideoDriver -> Bool
    $c<= :: VideoDriver -> VideoDriver -> Bool
    < :: VideoDriver -> VideoDriver -> Bool
    $c< :: VideoDriver -> VideoDriver -> Bool
    compare :: VideoDriver -> VideoDriver -> Ordering
    $ccompare :: VideoDriver -> VideoDriver -> Ordering
    $cp1Ord :: Eq VideoDriver
    Ord, ReadPrec [VideoDriver]
    ReadPrec VideoDriver
    Int -> ReadS VideoDriver
    ReadS [VideoDriver]
    (Int -> ReadS VideoDriver)
    -> ReadS [VideoDriver]
    -> ReadPrec VideoDriver
    -> ReadPrec [VideoDriver]
    -> Read VideoDriver
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [VideoDriver]
    $creadListPrec :: ReadPrec [VideoDriver]
    readPrec :: ReadPrec VideoDriver
    $creadPrec :: ReadPrec VideoDriver
    readList :: ReadS [VideoDriver]
    $creadList :: ReadS [VideoDriver]
    readsPrec :: Int -> ReadS VideoDriver
    $creadsPrec :: Int -> ReadS VideoDriver
    Read, Int -> VideoDriver -> ShowS
    [VideoDriver] -> ShowS
    VideoDriver -> String
    (Int -> VideoDriver -> ShowS)
    -> (VideoDriver -> String)
    -> ([VideoDriver] -> ShowS)
    -> Show VideoDriver
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [VideoDriver] -> ShowS
    $cshowList :: [VideoDriver] -> ShowS
    show :: VideoDriver -> String
    $cshow :: VideoDriver -> String
    showsPrec :: Int -> VideoDriver -> ShowS
    $cshowsPrec :: Int -> VideoDriver -> ShowS
    Show, Typeable)

    -- | Throws 'SDLException' on failure.
    getDisplays :: MonadIO m => m [Display]
    getDisplays :: m [Display]
    getDisplays = IO [Display] -> m [Display]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Display] -> m [Display]) -> IO [Display] -> m [Display]
    forall a b. (a -> b) -> a -> b
    $ do
      CInt
    numDisplays <- Text -> Text -> IO CInt -> IO CInt
    forall (m :: * -> *) a.
    (MonadIO m, Num a, Ord a) =>
    Text -> Text -> m a -> m a
    throwIfNeg "SDL.Video.getDisplays" "SDL_GetNumVideoDisplays"
        IO CInt
    forall (m :: * -> *). MonadIO m => m CInt
    Raw.getNumVideoDisplays

      [CInt] -> (CInt -> IO Display) -> IO [Display]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    t a -> (a -> m b) -> m (t b)
    forM [0..CInt
    numDisplays CInt -> CInt -> CInt
    forall a. Num a => a -> a -> a
    - 1] ((CInt -> IO Display) -> IO [Display])
    -> (CInt -> IO Display) -> IO [Display]
    forall a b. (a -> b) -> a -> b
    $ \displayId :: CInt
    displayId -> do
        CString
    name <- Text -> Text -> IO CString -> IO CString
    forall (m :: * -> *) a.
    MonadIO m =>
    Text -> Text -> m (Ptr a) -> m (Ptr a)
    throwIfNull "SDL.Video.getDisplays" "SDL_GetDisplayName" (IO CString -> IO CString) -> IO CString -> IO CString
    forall a b. (a -> b) -> a -> b
    $
            CInt -> IO CString
    forall (m :: * -> *). MonadIO m => CInt -> m CString
    Raw.getDisplayName CInt
    displayId

        String
    name' <- CString -> IO String
    peekCString CString
    name

        Raw.Rect x :: CInt
    x y :: CInt
    y w :: CInt
    w h :: CInt
    h <- (Ptr Rect -> IO Rect) -> IO Rect
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr Rect -> IO Rect) -> IO Rect)
    -> (Ptr Rect -> IO Rect) -> IO Rect
    forall a b. (a -> b) -> a -> b
    $ \rect :: Ptr Rect
    rect -> do
          Text -> Text -> IO CInt -> IO ()
    forall a (m :: * -> *).
    (Eq a, MonadIO m, Num a) =>
    Text -> Text -> m a -> m ()
    throwIfNot0_ "SDL.Video.getDisplays" "SDL_GetDisplayBounds" (IO CInt -> IO ()) -> IO CInt -> IO ()
    forall a b. (a -> b) -> a -> b
    $
            CInt -> Ptr Rect -> IO CInt
    forall (m :: * -> *). MonadIO m => CInt -> Ptr Rect -> m CInt
    Raw.getDisplayBounds CInt
    displayId Ptr Rect
    rect
          Ptr Rect -> IO Rect
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Rect
    rect

        CInt
    numModes <- Text -> Text -> IO CInt -> IO CInt
    forall (m :: * -> *) a.
    (MonadIO m, Num a, Ord a) =>
    Text -> Text -> m a -> m a
    throwIfNeg "SDL.Video.getDisplays" "SDL_GetNumDisplayModes" (IO CInt -> IO CInt) -> IO CInt -> IO CInt
    forall a b. (a -> b) -> a -> b
    $
          CInt -> IO CInt
    forall (m :: * -> *). MonadIO m => CInt -> m CInt
    Raw.getNumDisplayModes CInt
    displayId

        [DisplayMode]
    modes <- [CInt] -> (CInt -> IO DisplayMode) -> IO [DisplayMode]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    t a -> (a -> m b) -> m (t b)
    forM [0..CInt
    numModes CInt -> CInt -> CInt
    forall a. Num a => a -> a -> a
    - 1] ((CInt -> IO DisplayMode) -> IO [DisplayMode])
    -> (CInt -> IO DisplayMode) -> IO [DisplayMode]
    forall a b. (a -> b) -> a -> b
    $ \modeId :: CInt
    modeId -> do
          Raw.DisplayMode format :: Word32
    format w' :: CInt
    w' h' :: CInt
    h' refreshRate :: CInt
    refreshRate _ <- (Ptr DisplayMode -> IO DisplayMode) -> IO DisplayMode
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr DisplayMode -> IO DisplayMode) -> IO DisplayMode)
    -> (Ptr DisplayMode -> IO DisplayMode) -> IO DisplayMode
    forall a b. (a -> b) -> a -> b
    $ \mode :: Ptr DisplayMode
    mode -> do
            Text -> Text -> IO CInt -> IO ()
    forall a (m :: * -> *).
    (Eq a, MonadIO m, Num a) =>
    Text -> Text -> m a -> m ()
    throwIfNot0_ "SDL.Video.getDisplays" "SDL_GetDisplayMode" (IO CInt -> IO ()) -> IO CInt -> IO ()
    forall a b. (a -> b) -> a -> b
    $
              CInt -> CInt -> Ptr DisplayMode -> IO CInt
    forall (m :: * -> *).
    MonadIO m =>
    CInt -> CInt -> Ptr DisplayMode -> m CInt
    Raw.getDisplayMode CInt
    displayId CInt
    modeId Ptr DisplayMode
    mode
            Ptr DisplayMode -> IO DisplayMode
    forall a. Storable a => Ptr a -> IO a
    peek Ptr DisplayMode
    mode

          DisplayMode -> IO DisplayMode
    forall (m :: * -> *) a. Monad m => a -> m a
    return (DisplayMode -> IO DisplayMode) -> DisplayMode -> IO DisplayMode
    forall a b. (a -> b) -> a -> b
    $ DisplayMode :: PixelFormat -> V2 CInt -> CInt -> DisplayMode
    DisplayMode {
              displayModeFormat :: PixelFormat
    displayModeFormat = Word32 -> PixelFormat
    forall a b. FromNumber a b => b -> a
    fromNumber Word32
    format
            , displayModeSize :: V2 CInt
    displayModeSize = CInt -> CInt -> V2 CInt
    forall a. a -> a -> V2 a
    V2 CInt
    w' CInt
    h'
            , displayModeRefreshRate :: CInt
    displayModeRefreshRate = CInt
    refreshRate
          }

        Display -> IO Display
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Display -> IO Display) -> Display -> IO Display
    forall a b. (a -> b) -> a -> b
    $ Display :: String -> Point V2 CInt -> V2 CInt -> [DisplayMode] -> Display
    Display {
            displayName :: String
    displayName = String
    name'
          , displayBoundsPosition :: Point V2 CInt
    displayBoundsPosition = V2 CInt -> Point V2 CInt
    forall (f :: * -> *) a. f a -> Point f a
    P (CInt -> CInt -> V2 CInt
    forall a. a -> a -> V2 a
    V2 CInt
    x CInt
    y)
          , displayBoundsSize :: V2 CInt
    displayBoundsSize = CInt -> CInt -> V2 CInt
    forall a. a -> a -> V2 a
    V2 CInt
    w CInt
    h
          , displayModes :: [DisplayMode]
    displayModes = [DisplayMode]
    modes
        }

    -- | Show a simple message box with the given title and a message. Consider
    -- writing your messages to @stderr@ too.
    --
    -- Throws 'SDLException' if there are no available video targets.
    showSimpleMessageBox :: MonadIO m => Maybe Window -> MessageKind -> Text -> Text -> m ()
    showSimpleMessageBox :: Maybe Window -> MessageKind -> Text -> Text -> m ()
    showSimpleMessageBox window :: Maybe Window
    window kind :: MessageKind
    kind title :: Text
    title message :: Text
    message =
      IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> (IO CInt -> IO ()) -> IO CInt -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Text -> IO CInt -> IO ()
    forall a (m :: * -> *).
    (Eq a, MonadIO m, Num a) =>
    Text -> Text -> m a -> m ()
    throwIfNot0_ "SDL.Video.showSimpleMessageBox" "SDL_ShowSimpleMessageBox" (IO CInt -> m ()) -> IO CInt -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        ByteString -> (CString -> IO CInt) -> IO CInt
    forall a. ByteString -> (CString -> IO a) -> IO a
    BS.useAsCString (Text -> ByteString
    Text.encodeUtf8 Text
    title) ((CString -> IO CInt) -> IO CInt)
    -> (CString -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \title' :: CString
    title' ->
          ByteString -> (CString -> IO CInt) -> IO CInt
    forall a. ByteString -> (CString -> IO a) -> IO a
    BS.useAsCString (Text -> ByteString
    Text.encodeUtf8 Text
    message) ((CString -> IO CInt) -> IO CInt)
    -> (CString -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \message' :: CString
    message' ->
            Word32 -> CString -> CString -> Window -> IO CInt
    forall (m :: * -> *).
    MonadIO m =>
    Word32 -> CString -> CString -> Window -> m CInt
    Raw.showSimpleMessageBox (MessageKind -> Word32
    forall a b. ToNumber a b => a -> b
    toNumber MessageKind
    kind) CString
    title' CString
    message' (Window -> IO CInt) -> Window -> IO CInt
    forall a b. (a -> b) -> a -> b
    $
              Maybe Window -> Window
    windowId Maybe Window
    window
      where
        windowId :: Maybe Window -> Window
    windowId (Just (Window w :: Window
    w)) = Window
    w
        windowId Nothing = Window
    forall a. Ptr a
    nullPtr

    data MessageKind
      = Error
      | Warning
      | Information
      deriving (MessageKind
    MessageKind -> MessageKind -> Bounded MessageKind
    forall a. a -> a -> Bounded a
    maxBound :: MessageKind
    $cmaxBound :: MessageKind
    minBound :: MessageKind
    $cminBound :: MessageKind
    Bounded, Typeable MessageKind
    Constr
    DataType
    Typeable MessageKind =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> MessageKind -> c MessageKind)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c MessageKind)
    -> (MessageKind -> Constr)
    -> (MessageKind -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c MessageKind))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c MessageKind))
    -> ((forall b. Data b => b -> b) -> MessageKind -> MessageKind)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> MessageKind -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> MessageKind -> r)
    -> (forall u. (forall d. Data d => d -> u) -> MessageKind -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> MessageKind -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> MessageKind -> m MessageKind)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MessageKind -> m MessageKind)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> MessageKind -> m MessageKind)
    -> Data MessageKind
    MessageKind -> Constr
    MessageKind -> DataType
    (forall b. Data b => b -> b) -> MessageKind -> MessageKind
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MessageKind -> c MessageKind
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MessageKind
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> MessageKind -> u
    forall u. (forall d. Data d => d -> u) -> MessageKind -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MessageKind -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MessageKind -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MessageKind -> m MessageKind
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MessageKind -> m MessageKind
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MessageKind
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MessageKind -> c MessageKind
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MessageKind)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MessageKind)
    $cInformation :: Constr
    $cWarning :: Constr
    $cError :: Constr
    $tMessageKind :: DataType
    gmapMo :: (forall d. Data d => d -> m d) -> MessageKind -> m MessageKind
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MessageKind -> m MessageKind
    gmapMp :: (forall d. Data d => d -> m d) -> MessageKind -> m MessageKind
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MessageKind -> m MessageKind
    gmapM :: (forall d. Data d => d -> m d) -> MessageKind -> m MessageKind
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MessageKind -> m MessageKind
    gmapQi :: Int -> (forall d. Data d => d -> u) -> MessageKind -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MessageKind -> u
    gmapQ :: (forall d. Data d => d -> u) -> MessageKind -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> MessageKind -> [u]
    gmapQr :: (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MessageKind -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MessageKind -> r
    gmapQl :: (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MessageKind -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MessageKind -> r
    gmapT :: (forall b. Data b => b -> b) -> MessageKind -> MessageKind
    $cgmapT :: (forall b. Data b => b -> b) -> MessageKind -> MessageKind
    dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MessageKind)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MessageKind)
    dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c MessageKind)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MessageKind)
    dataTypeOf :: MessageKind -> DataType
    $cdataTypeOf :: MessageKind -> DataType
    toConstr :: MessageKind -> Constr
    $ctoConstr :: MessageKind -> Constr
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MessageKind
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MessageKind
    gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MessageKind -> c MessageKind
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MessageKind -> c MessageKind
    $cp1Data :: Typeable MessageKind
    Data, Int -> MessageKind
    MessageKind -> Int
    MessageKind -> [MessageKind]
    MessageKind -> MessageKind
    MessageKind -> MessageKind -> [MessageKind]
    MessageKind -> MessageKind -> MessageKind -> [MessageKind]
    (MessageKind -> MessageKind)
    -> (MessageKind -> MessageKind)
    -> (Int -> MessageKind)
    -> (MessageKind -> Int)
    -> (MessageKind -> [MessageKind])
    -> (MessageKind -> MessageKind -> [MessageKind])
    -> (MessageKind -> MessageKind -> [MessageKind])
    -> (MessageKind -> MessageKind -> MessageKind -> [MessageKind])
    -> Enum MessageKind
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    enumFromThenTo :: MessageKind -> MessageKind -> MessageKind -> [MessageKind]
    $cenumFromThenTo :: MessageKind -> MessageKind -> MessageKind -> [MessageKind]
    enumFromTo :: MessageKind -> MessageKind -> [MessageKind]
    $cenumFromTo :: MessageKind -> MessageKind -> [MessageKind]
    enumFromThen :: MessageKind -> MessageKind -> [MessageKind]
    $cenumFromThen :: MessageKind -> MessageKind -> [MessageKind]
    enumFrom :: MessageKind -> [MessageKind]
    $cenumFrom :: MessageKind -> [MessageKind]
    fromEnum :: MessageKind -> Int
    $cfromEnum :: MessageKind -> Int
    toEnum :: Int -> MessageKind
    $ctoEnum :: Int -> MessageKind
    pred :: MessageKind -> MessageKind
    $cpred :: MessageKind -> MessageKind
    succ :: MessageKind -> MessageKind
    $csucc :: MessageKind -> MessageKind
    Enum, MessageKind -> MessageKind -> Bool
    (MessageKind -> MessageKind -> Bool)
    -> (MessageKind -> MessageKind -> Bool) -> Eq MessageKind
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: MessageKind -> MessageKind -> Bool
    $c/= :: MessageKind -> MessageKind -> Bool
    == :: MessageKind -> MessageKind -> Bool
    $c== :: MessageKind -> MessageKind -> Bool
    Eq, (forall x. MessageKind -> Rep MessageKind x)
    -> (forall x. Rep MessageKind x -> MessageKind)
    -> Generic MessageKind
    forall x. Rep MessageKind x -> MessageKind
    forall x. MessageKind -> Rep MessageKind x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep MessageKind x -> MessageKind
    $cfrom :: forall x. MessageKind -> Rep MessageKind x
    Generic, Eq MessageKind
    Eq MessageKind =>
    (MessageKind -> MessageKind -> Ordering)
    -> (MessageKind -> MessageKind -> Bool)
    -> (MessageKind -> MessageKind -> Bool)
    -> (MessageKind -> MessageKind -> Bool)
    -> (MessageKind -> MessageKind -> Bool)
    -> (MessageKind -> MessageKind -> MessageKind)
    -> (MessageKind -> MessageKind -> MessageKind)
    -> Ord MessageKind
    MessageKind -> MessageKind -> Bool
    MessageKind -> MessageKind -> Ordering
    MessageKind -> MessageKind -> MessageKind
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: MessageKind -> MessageKind -> MessageKind
    $cmin :: MessageKind -> MessageKind -> MessageKind
    max :: MessageKind -> MessageKind -> MessageKind
    $cmax :: MessageKind -> MessageKind -> MessageKind
    >= :: MessageKind -> MessageKind -> Bool
    $c>= :: MessageKind -> MessageKind -> Bool
    > :: MessageKind -> MessageKind -> Bool
    $c> :: MessageKind -> MessageKind -> Bool
    <= :: MessageKind -> MessageKind -> Bool
    $c<= :: MessageKind -> MessageKind -> Bool
    < :: MessageKind -> MessageKind -> Bool
    $c< :: MessageKind -> MessageKind -> Bool
    compare :: MessageKind -> MessageKind -> Ordering
    $ccompare :: MessageKind -> MessageKind -> Ordering
    $cp1Ord :: Eq MessageKind
    Ord, ReadPrec [MessageKind]
    ReadPrec MessageKind
    Int -> ReadS MessageKind
    ReadS [MessageKind]
    (Int -> ReadS MessageKind)
    -> ReadS [MessageKind]
    -> ReadPrec MessageKind
    -> ReadPrec [MessageKind]
    -> Read MessageKind
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [MessageKind]
    $creadListPrec :: ReadPrec [MessageKind]
    readPrec :: ReadPrec MessageKind
    $creadPrec :: ReadPrec MessageKind
    readList :: ReadS [MessageKind]
    $creadList :: ReadS [MessageKind]
    readsPrec :: Int -> ReadS MessageKind
    $creadsPrec :: Int -> ReadS MessageKind
    Read, Int -> MessageKind -> ShowS
    [MessageKind] -> ShowS
    MessageKind -> String
    (Int -> MessageKind -> ShowS)
    -> (MessageKind -> String)
    -> ([MessageKind] -> ShowS)
    -> Show MessageKind
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [MessageKind] -> ShowS
    $cshowList :: [MessageKind] -> ShowS
    show :: MessageKind -> String
    $cshow :: MessageKind -> String
    showsPrec :: Int -> MessageKind -> ShowS
    $cshowsPrec :: Int -> MessageKind -> ShowS
    Show, Typeable)

    instance ToNumber MessageKind Word32 where
      toNumber :: MessageKind -> Word32
    toNumber Error = Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_MESSAGEBOX_ERROR
      toNumber Warning = Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_MESSAGEBOX_WARNING
      toNumber Information = Word32
    forall a. (Eq a, Num a) => a
    Raw.SDL_MESSAGEBOX_INFORMATION

    -- | Get or set the maximum size of a window's client area.
    --
    -- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
    --
    -- See @<https://wiki.libsdl.org/SDL_SetWindowMaximumSize SDL_SetWindowMaximumSize>@ and @<https://wiki.libsdl.org/SDL_GetWindowMaximumSize SDL_GetWindowMaximumSize>@ for C documentation.
    windowMaximumSize :: Window -> StateVar (V2 CInt)
    windowMaximumSize :: Window -> StateVar (V2 CInt)
    windowMaximumSize (Window win :: Window
    win) = IO (V2 CInt) -> (V2 CInt -> IO ()) -> StateVar (V2 CInt)
    forall a. IO a -> (a -> IO ()) -> StateVar a
    makeStateVar IO (V2 CInt)
    getWindowMaximumSize V2 CInt -> IO ()
    forall (m :: * -> *). MonadIO m => V2 CInt -> m ()
    setWindowMaximumSize
      where
      setWindowMaximumSize :: V2 CInt -> m ()
    setWindowMaximumSize (V2 w :: CInt
    w h :: CInt
    h) = Window -> CInt -> CInt -> m ()
    forall (m :: * -> *). MonadIO m => Window -> CInt -> CInt -> m ()
    Raw.setWindowMaximumSize Window
    win CInt
    w CInt
    h

      getWindowMaximumSize :: IO (V2 CInt)
    getWindowMaximumSize =
        IO (V2 CInt) -> IO (V2 CInt)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (V2 CInt) -> IO (V2 CInt)) -> IO (V2 CInt) -> IO (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $
        (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt))
    -> (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $ \wptr :: Ptr CInt
    wptr ->
        (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt))
    -> (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $ \hptr :: Ptr CInt
    hptr -> do
          Window -> Ptr CInt -> Ptr CInt -> IO ()
    forall (m :: * -> *).
    MonadIO m =>
    Window -> Ptr CInt -> Ptr CInt -> m ()
    Raw.getWindowMaximumSize Window
    win Ptr CInt
    wptr Ptr CInt
    hptr
          CInt -> CInt -> V2 CInt
    forall a. a -> a -> V2 a
    V2 (CInt -> CInt -> V2 CInt) -> IO CInt -> IO (CInt -> V2 CInt)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Ptr CInt -> IO CInt
    forall a. Storable a => Ptr a -> IO a
    peek Ptr CInt
    wptr IO (CInt -> V2 CInt) -> IO CInt -> IO (V2 CInt)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Ptr CInt -> IO CInt
    forall a. Storable a => Ptr a -> IO a
    peek Ptr CInt
    hptr

    -- | Get or set the minimum size of a window's client area.
    --
    -- This 'StateVar' can be modified using '$=' and the current value retrieved with 'get'.
    --
    -- See @<https://wiki.libsdl.org/SDL_SetWindowMinimumSize SDL_SetWindowMinimumSize>@ and @<https://wiki.libsdl.org/SDL_GetWindowMinimumSize SDL_GetWindowMinimumSize>@ for C documentation.
    windowMinimumSize :: Window -> StateVar (V2 CInt)
    windowMinimumSize :: Window -> StateVar (V2 CInt)
    windowMinimumSize (Window win :: Window
    win) = IO (V2 CInt) -> (V2 CInt -> IO ()) -> StateVar (V2 CInt)
    forall a. IO a -> (a -> IO ()) -> StateVar a
    makeStateVar IO (V2 CInt)
    getWindowMinimumSize V2 CInt -> IO ()
    forall (m :: * -> *). MonadIO m => V2 CInt -> m ()
    setWindowMinimumSize
      where
      setWindowMinimumSize :: V2 CInt -> m ()
    setWindowMinimumSize (V2 w :: CInt
    w h :: CInt
    h) = Window -> CInt -> CInt -> m ()
    forall (m :: * -> *). MonadIO m => Window -> CInt -> CInt -> m ()
    Raw.setWindowMinimumSize Window
    win CInt
    w CInt
    h

      getWindowMinimumSize :: IO (V2 CInt)
    getWindowMinimumSize =
        IO (V2 CInt) -> IO (V2 CInt)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (V2 CInt) -> IO (V2 CInt)) -> IO (V2 CInt) -> IO (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $
        (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt))
    -> (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $ \wptr :: Ptr CInt
    wptr ->
        (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. Storable a => (Ptr a -> IO b) -> IO b
    alloca ((Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt))
    -> (Ptr CInt -> IO (V2 CInt)) -> IO (V2 CInt)
    forall a b. (a -> b) -> a -> b
    $ \hptr :: Ptr CInt
    hptr -> do
          Window -> Ptr CInt -> Ptr CInt -> IO ()
    forall (m :: * -> *).
    MonadIO m =>
    Window -> Ptr CInt -> Ptr CInt -> m ()
    Raw.getWindowMinimumSize Window
    win Ptr CInt
    wptr Ptr CInt
    hptr
          CInt -> CInt -> V2 CInt
    forall a. a -> a -> V2 a
    V2 (CInt -> CInt -> V2 CInt) -> IO CInt -> IO (CInt -> V2 CInt)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Ptr CInt -> IO CInt
    forall a. Storable a => Ptr a -> IO a
    peek Ptr CInt
    wptr IO (CInt -> V2 CInt) -> IO CInt -> IO (V2 CInt)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Ptr CInt -> IO CInt
    forall a. Storable a => Ptr a -> IO a
    peek Ptr CInt
    hptr

    createRenderer :: MonadIO m => Window -> CInt -> RendererConfig -> m Renderer
    createRenderer :: Window -> CInt -> RendererConfig -> m Renderer
    createRenderer (Window w :: Window
    w) driver :: CInt
    driver config :: RendererConfig
    config =
      IO Renderer -> m Renderer
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Renderer -> m Renderer)
    -> (IO Window -> IO Renderer) -> IO Window -> m Renderer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Window -> Renderer) -> IO Window -> IO Renderer
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Window -> Renderer
    Renderer (IO Window -> m Renderer) -> IO Window -> m Renderer
    forall a b. (a -> b) -> a -> b
    $
        Text -> Text -> IO Window -> IO Window
    forall (m :: * -> *) a.
    MonadIO m =>
    Text -> Text -> m (Ptr a) -> m (Ptr a)
    throwIfNull "SDL.Video.createRenderer" "SDL_CreateRenderer" (IO Window -> IO Window) -> IO Window -> IO Window
    forall a b. (a -> b) -> a -> b
    $
        Window -> CInt -> Word32 -> IO Window
    forall (m :: * -> *).
    MonadIO m =>
    Window -> CInt -> Word32 -> m Window
    Raw.createRenderer Window
    w CInt
    driver (RendererConfig -> Word32
    forall a b. ToNumber a b => a -> b
    toNumber RendererConfig
    config)

    -- | Create a 2D software rendering context for the given surface.
    --
    -- See @<https://wiki.libsdl.org/SDL_CreateSoftwareRenderer>@
    createSoftwareRenderer :: MonadIO m => Surface -> m Renderer
    createSoftwareRenderer :: Surface -> m Renderer
    createSoftwareRenderer (Surface ptr :: Ptr Surface
    ptr _) =
      IO Renderer -> m Renderer
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Renderer -> m Renderer)
    -> (IO Window -> IO Renderer) -> IO Window -> m Renderer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Window -> Renderer) -> IO Window -> IO Renderer
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Window -> Renderer
    Renderer (IO Window -> m Renderer) -> IO Window -> m Renderer
    forall a b. (a -> b) -> a -> b
    $
        Text -> Text -> IO Window -> IO Window
    forall (m :: * -> *) a.
    MonadIO m =>
    Text -> Text -> m (Ptr a) -> m (Ptr a)
    throwIfNull "SDL.Video.createSoftwareRenderer" "SDL_CreateSoftwareRenderer" (IO Window -> IO Window) -> IO Window -> IO Window
    forall a b. (a -> b) -> a -> b
    $
        Ptr Surface -> IO Window
    forall (m :: * -> *). MonadIO m => Ptr Surface -> m Window
    Raw.createSoftwareRenderer Ptr Surface
    ptr

    destroyRenderer :: MonadIO m => Renderer -> m ()
    destroyRenderer :: Renderer -> m ()
    destroyRenderer (Renderer r :: Window
    r) = Window -> m ()
    forall (m :: * -> *). MonadIO m => Window -> m ()
    Raw.destroyRenderer Window
    r