{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}

-- | The types of the package. This module is considered "internal", and the
-- types are re-exported from Graphics.UI.GLFW as necessary.
module Graphics.UI.GLFW.Types where

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

import Control.DeepSeq  (NFData)
import Data.Data        (Data)
import Data.IORef       (IORef)
import Data.Typeable    (Typeable)
import Data.Word        (Word8)
import Foreign.Ptr      (Ptr)
import Foreign.C.Types  (CUChar(..))
import GHC.Generics

import Bindings.GLFW

--------------------------------------------------------------------------------
-- Error handling

-- | An enum for one of the <http://www.glfw.org/docs/3.3/group__errors.html#ga196e125ef261d94184e2b55c05762f14 GLFW error codes>.
data Error =
    Error'NotInitialized -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#ga2374ee02c177f12e1fa76ff3ed15e14a doc>
  | Error'NoCurrentContext -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#gaa8290386e9528ccb9e42a3a4e16fc0d0 doc>
  | Error'InvalidEnum -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#ga76f6bb9c4eea73db675f096b404593ce doc>
  | Error'InvalidValue -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#gaaf2ef9aa8202c2b82ac2d921e554c687 doc>
  | Error'OutOfMemory -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#ga9023953a2bcb98c2906afd071d21ee7f doc>
  | Error'ApiUnavailable -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#ga56882b290db23261cc6c053c40c2d08e doc>
  | Error'VersionUnavailable -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#gad16c5565b4a69f9c2a9ac2c0dbc89462 doc>
  | Error'PlatformError -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#gad44162d78100ea5e87cdd38426b8c7a1 doc>
  | Error'FormatUnavailable -- ^ <http://www.glfw.org/docs/3.3/group__errors.html#ga196e125ef261d94184e2b55c05762f14 doc>
  deriving (Error
Error -> Error -> Bounded Error
forall a. a -> a -> Bounded a
$cminBound :: Error
minBound :: Error
$cmaxBound :: Error
maxBound :: Error
Bounded, Typeable Error
Typeable Error =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Error -> c Error)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Error)
-> (Error -> Constr)
-> (Error -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Error))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Error))
-> ((forall b. Data b => b -> b) -> Error -> Error)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Error -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Error -> r)
-> (forall u. (forall d. Data d => d -> u) -> Error -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Error -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Error -> m Error)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Error -> m Error)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Error -> m Error)
-> Data Error
Error -> Constr
Error -> DataType
(forall b. Data b => b -> b) -> Error -> Error
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) -> Error -> u
forall u. (forall d. Data d => d -> u) -> Error -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Error -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Error -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Error -> m Error
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Error -> m Error
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Error
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Error -> c Error
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Error)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Error)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Error -> c Error
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Error -> c Error
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Error
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Error
$ctoConstr :: Error -> Constr
toConstr :: Error -> Constr
$cdataTypeOf :: Error -> DataType
dataTypeOf :: Error -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Error)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Error)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Error)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Error)
$cgmapT :: (forall b. Data b => b -> b) -> Error -> Error
gmapT :: (forall b. Data b => b -> b) -> Error -> Error
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Error -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Error -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Error -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Error -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Error -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Error -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Error -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Error -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Error -> m Error
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Error -> m Error
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Error -> m Error
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Error -> m Error
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Error -> m Error
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Error -> m Error
Data, Int -> Error
Error -> Int
Error -> [Error]
Error -> Error
Error -> Error -> [Error]
Error -> Error -> Error -> [Error]
(Error -> Error)
-> (Error -> Error)
-> (Int -> Error)
-> (Error -> Int)
-> (Error -> [Error])
-> (Error -> Error -> [Error])
-> (Error -> Error -> [Error])
-> (Error -> Error -> Error -> [Error])
-> Enum Error
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Error -> Error
succ :: Error -> Error
$cpred :: Error -> Error
pred :: Error -> Error
$ctoEnum :: Int -> Error
toEnum :: Int -> Error
$cfromEnum :: Error -> Int
fromEnum :: Error -> Int
$cenumFrom :: Error -> [Error]
enumFrom :: Error -> [Error]
$cenumFromThen :: Error -> Error -> [Error]
enumFromThen :: Error -> Error -> [Error]
$cenumFromTo :: Error -> Error -> [Error]
enumFromTo :: Error -> Error -> [Error]
$cenumFromThenTo :: Error -> Error -> Error -> [Error]
enumFromThenTo :: Error -> Error -> Error -> [Error]
Enum, Error -> Error -> Bool
(Error -> Error -> Bool) -> (Error -> Error -> Bool) -> Eq Error
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Error -> Error -> Bool
== :: Error -> Error -> Bool
$c/= :: Error -> Error -> Bool
/= :: Error -> Error -> Bool
Eq, Eq Error
Eq Error =>
(Error -> Error -> Ordering)
-> (Error -> Error -> Bool)
-> (Error -> Error -> Bool)
-> (Error -> Error -> Bool)
-> (Error -> Error -> Bool)
-> (Error -> Error -> Error)
-> (Error -> Error -> Error)
-> Ord Error
Error -> Error -> Bool
Error -> Error -> Ordering
Error -> Error -> Error
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
$ccompare :: Error -> Error -> Ordering
compare :: Error -> Error -> Ordering
$c< :: Error -> Error -> Bool
< :: Error -> Error -> Bool
$c<= :: Error -> Error -> Bool
<= :: Error -> Error -> Bool
$c> :: Error -> Error -> Bool
> :: Error -> Error -> Bool
$c>= :: Error -> Error -> Bool
>= :: Error -> Error -> Bool
$cmax :: Error -> Error -> Error
max :: Error -> Error -> Error
$cmin :: Error -> Error -> Error
min :: Error -> Error -> Error
Ord, ReadPrec [Error]
ReadPrec Error
Int -> ReadS Error
ReadS [Error]
(Int -> ReadS Error)
-> ReadS [Error]
-> ReadPrec Error
-> ReadPrec [Error]
-> Read Error
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Error
readsPrec :: Int -> ReadS Error
$creadList :: ReadS [Error]
readList :: ReadS [Error]
$creadPrec :: ReadPrec Error
readPrec :: ReadPrec Error
$creadListPrec :: ReadPrec [Error]
readListPrec :: ReadPrec [Error]
Read, Int -> Error -> ShowS
[Error] -> ShowS
Error -> String
(Int -> Error -> ShowS)
-> (Error -> String) -> ([Error] -> ShowS) -> Show Error
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Error -> ShowS
showsPrec :: Int -> Error -> ShowS
$cshow :: Error -> String
show :: Error -> String
$cshowList :: [Error] -> ShowS
showList :: [Error] -> ShowS
Show, Typeable, (forall x. Error -> Rep Error x)
-> (forall x. Rep Error x -> Error) -> Generic Error
forall x. Rep Error x -> Error
forall x. Error -> Rep Error x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Error -> Rep Error x
from :: forall x. Error -> Rep Error x
$cto :: forall x. Rep Error x -> Error
to :: forall x. Rep Error x -> Error
Generic)

instance NFData Error

--------------------------------------------------------------------------------
-- Initialization and version information

-- | Initialization hints are set before glfwInit and affect how the library
-- behaves until termination. Hints are set with glfwInitHint. See
-- <https://www.glfw.org/docs/3.3/intro_guide.html#init_hints Init Hints>
data InitHint
  = InitHint'JoystickHatButtons
  | InitHint'CocoaChdirResources
  | InitHint'CocoaMenubar
  deriving (InitHint
InitHint -> InitHint -> Bounded InitHint
forall a. a -> a -> Bounded a
$cminBound :: InitHint
minBound :: InitHint
$cmaxBound :: InitHint
maxBound :: InitHint
Bounded, Typeable InitHint
Typeable InitHint =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> InitHint -> c InitHint)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InitHint)
-> (InitHint -> Constr)
-> (InitHint -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InitHint))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InitHint))
-> ((forall b. Data b => b -> b) -> InitHint -> InitHint)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InitHint -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InitHint -> r)
-> (forall u. (forall d. Data d => d -> u) -> InitHint -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> InitHint -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InitHint -> m InitHint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InitHint -> m InitHint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InitHint -> m InitHint)
-> Data InitHint
InitHint -> Constr
InitHint -> DataType
(forall b. Data b => b -> b) -> InitHint -> InitHint
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) -> InitHint -> u
forall u. (forall d. Data d => d -> u) -> InitHint -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InitHint -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InitHint -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InitHint -> m InitHint
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InitHint -> m InitHint
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InitHint
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InitHint -> c InitHint
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InitHint)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InitHint)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InitHint -> c InitHint
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InitHint -> c InitHint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InitHint
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InitHint
$ctoConstr :: InitHint -> Constr
toConstr :: InitHint -> Constr
$cdataTypeOf :: InitHint -> DataType
dataTypeOf :: InitHint -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InitHint)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InitHint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InitHint)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InitHint)
$cgmapT :: (forall b. Data b => b -> b) -> InitHint -> InitHint
gmapT :: (forall b. Data b => b -> b) -> InitHint -> InitHint
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InitHint -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InitHint -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InitHint -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InitHint -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InitHint -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InitHint -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InitHint -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InitHint -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InitHint -> m InitHint
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InitHint -> m InitHint
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InitHint -> m InitHint
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InitHint -> m InitHint
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InitHint -> m InitHint
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InitHint -> m InitHint
Data, Int -> InitHint
InitHint -> Int
InitHint -> [InitHint]
InitHint -> InitHint
InitHint -> InitHint -> [InitHint]
InitHint -> InitHint -> InitHint -> [InitHint]
(InitHint -> InitHint)
-> (InitHint -> InitHint)
-> (Int -> InitHint)
-> (InitHint -> Int)
-> (InitHint -> [InitHint])
-> (InitHint -> InitHint -> [InitHint])
-> (InitHint -> InitHint -> [InitHint])
-> (InitHint -> InitHint -> InitHint -> [InitHint])
-> Enum InitHint
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: InitHint -> InitHint
succ :: InitHint -> InitHint
$cpred :: InitHint -> InitHint
pred :: InitHint -> InitHint
$ctoEnum :: Int -> InitHint
toEnum :: Int -> InitHint
$cfromEnum :: InitHint -> Int
fromEnum :: InitHint -> Int
$cenumFrom :: InitHint -> [InitHint]
enumFrom :: InitHint -> [InitHint]
$cenumFromThen :: InitHint -> InitHint -> [InitHint]
enumFromThen :: InitHint -> InitHint -> [InitHint]
$cenumFromTo :: InitHint -> InitHint -> [InitHint]
enumFromTo :: InitHint -> InitHint -> [InitHint]
$cenumFromThenTo :: InitHint -> InitHint -> InitHint -> [InitHint]
enumFromThenTo :: InitHint -> InitHint -> InitHint -> [InitHint]
Enum, InitHint -> InitHint -> Bool
(InitHint -> InitHint -> Bool)
-> (InitHint -> InitHint -> Bool) -> Eq InitHint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InitHint -> InitHint -> Bool
== :: InitHint -> InitHint -> Bool
$c/= :: InitHint -> InitHint -> Bool
/= :: InitHint -> InitHint -> Bool
Eq, Eq InitHint
Eq InitHint =>
(InitHint -> InitHint -> Ordering)
-> (InitHint -> InitHint -> Bool)
-> (InitHint -> InitHint -> Bool)
-> (InitHint -> InitHint -> Bool)
-> (InitHint -> InitHint -> Bool)
-> (InitHint -> InitHint -> InitHint)
-> (InitHint -> InitHint -> InitHint)
-> Ord InitHint
InitHint -> InitHint -> Bool
InitHint -> InitHint -> Ordering
InitHint -> InitHint -> InitHint
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
$ccompare :: InitHint -> InitHint -> Ordering
compare :: InitHint -> InitHint -> Ordering
$c< :: InitHint -> InitHint -> Bool
< :: InitHint -> InitHint -> Bool
$c<= :: InitHint -> InitHint -> Bool
<= :: InitHint -> InitHint -> Bool
$c> :: InitHint -> InitHint -> Bool
> :: InitHint -> InitHint -> Bool
$c>= :: InitHint -> InitHint -> Bool
>= :: InitHint -> InitHint -> Bool
$cmax :: InitHint -> InitHint -> InitHint
max :: InitHint -> InitHint -> InitHint
$cmin :: InitHint -> InitHint -> InitHint
min :: InitHint -> InitHint -> InitHint
Ord, ReadPrec [InitHint]
ReadPrec InitHint
Int -> ReadS InitHint
ReadS [InitHint]
(Int -> ReadS InitHint)
-> ReadS [InitHint]
-> ReadPrec InitHint
-> ReadPrec [InitHint]
-> Read InitHint
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InitHint
readsPrec :: Int -> ReadS InitHint
$creadList :: ReadS [InitHint]
readList :: ReadS [InitHint]
$creadPrec :: ReadPrec InitHint
readPrec :: ReadPrec InitHint
$creadListPrec :: ReadPrec [InitHint]
readListPrec :: ReadPrec [InitHint]
Read, Int -> InitHint -> ShowS
[InitHint] -> ShowS
InitHint -> String
(Int -> InitHint -> ShowS)
-> (InitHint -> String) -> ([InitHint] -> ShowS) -> Show InitHint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InitHint -> ShowS
showsPrec :: Int -> InitHint -> ShowS
$cshow :: InitHint -> String
show :: InitHint -> String
$cshowList :: [InitHint] -> ShowS
showList :: [InitHint] -> ShowS
Show, Typeable, (forall x. InitHint -> Rep InitHint x)
-> (forall x. Rep InitHint x -> InitHint) -> Generic InitHint
forall x. Rep InitHint x -> InitHint
forall x. InitHint -> Rep InitHint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InitHint -> Rep InitHint x
from :: forall x. InitHint -> Rep InitHint x
$cto :: forall x. Rep InitHint x -> InitHint
to :: forall x. Rep InitHint x -> InitHint
Generic)

instance NFData InitHint

-- | The library version of the GLFW implementation in use.
-- See <http://www.glfw.org/docs/3.3/intro.html#intro_version Version Management>
data Version = Version
  { Version -> Int
versionMajor    :: {-# UNPACK #-} !Int
  , Version -> Int
versionMinor    :: {-# UNPACK #-} !Int
  , Version -> Int
versionRevision :: {-# UNPACK #-} !Int
  } deriving (Typeable Version
Typeable Version =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Version -> c Version)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Version)
-> (Version -> Constr)
-> (Version -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Version))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version))
-> ((forall b. Data b => b -> b) -> Version -> Version)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Version -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Version -> r)
-> (forall u. (forall d. Data d => d -> u) -> Version -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Version -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Version -> m Version)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Version -> m Version)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Version -> m Version)
-> Data Version
Version -> Constr
Version -> DataType
(forall b. Data b => b -> b) -> Version -> Version
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) -> Version -> u
forall u. (forall d. Data d => d -> u) -> Version -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Version -> m Version
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Version -> m Version
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Version
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Version -> c Version
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Version)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Version -> c Version
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Version -> c Version
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Version
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Version
$ctoConstr :: Version -> Constr
toConstr :: Version -> Constr
$cdataTypeOf :: Version -> DataType
dataTypeOf :: Version -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Version)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Version)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version)
$cgmapT :: (forall b. Data b => b -> b) -> Version -> Version
gmapT :: (forall b. Data b => b -> b) -> Version -> Version
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Version -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Version -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Version -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Version -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Version -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Version -> m Version
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Version -> m Version
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Version -> m Version
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Version -> m Version
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Version -> m Version
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Version -> m Version
Data, Version -> Version -> Bool
(Version -> Version -> Bool)
-> (Version -> Version -> Bool) -> Eq Version
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Version -> Version -> Bool
== :: Version -> Version -> Bool
$c/= :: Version -> Version -> Bool
/= :: Version -> Version -> Bool
Eq, Eq Version
Eq Version =>
(Version -> Version -> Ordering)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Version)
-> (Version -> Version -> Version)
-> Ord Version
Version -> Version -> Bool
Version -> Version -> Ordering
Version -> Version -> Version
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
$ccompare :: Version -> Version -> Ordering
compare :: Version -> Version -> Ordering
$c< :: Version -> Version -> Bool
< :: Version -> Version -> Bool
$c<= :: Version -> Version -> Bool
<= :: Version -> Version -> Bool
$c> :: Version -> Version -> Bool
> :: Version -> Version -> Bool
$c>= :: Version -> Version -> Bool
>= :: Version -> Version -> Bool
$cmax :: Version -> Version -> Version
max :: Version -> Version -> Version
$cmin :: Version -> Version -> Version
min :: Version -> Version -> Version
Ord, ReadPrec [Version]
ReadPrec Version
Int -> ReadS Version
ReadS [Version]
(Int -> ReadS Version)
-> ReadS [Version]
-> ReadPrec Version
-> ReadPrec [Version]
-> Read Version
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Version
readsPrec :: Int -> ReadS Version
$creadList :: ReadS [Version]
readList :: ReadS [Version]
$creadPrec :: ReadPrec Version
readPrec :: ReadPrec Version
$creadListPrec :: ReadPrec [Version]
readListPrec :: ReadPrec [Version]
Read, Int -> Version -> ShowS
[Version] -> ShowS
Version -> String
(Int -> Version -> ShowS)
-> (Version -> String) -> ([Version] -> ShowS) -> Show Version
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Version -> ShowS
showsPrec :: Int -> Version -> ShowS
$cshow :: Version -> String
show :: Version -> String
$cshowList :: [Version] -> ShowS
showList :: [Version] -> ShowS
Show, Typeable, (forall x. Version -> Rep Version x)
-> (forall x. Rep Version x -> Version) -> Generic Version
forall x. Rep Version x -> Version
forall x. Version -> Rep Version x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Version -> Rep Version x
from :: forall x. Version -> Rep Version x
$cto :: forall x. Rep Version x -> Version
to :: forall x. Rep Version x -> Version
Generic)

instance NFData Version

--------------------------------------------------------------------------------
-- Monitor handling

-- | Represents a physical monitor that's currently connected.
-- See the <http://www.glfw.org/docs/3.3/monitor.html Monitor Guide>
newtype Monitor = Monitor
  { Monitor -> Ptr C'GLFWmonitor
unMonitor :: Ptr C'GLFWmonitor
  } deriving (Typeable Monitor
Typeable Monitor =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Monitor -> c Monitor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Monitor)
-> (Monitor -> Constr)
-> (Monitor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Monitor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Monitor))
-> ((forall b. Data b => b -> b) -> Monitor -> Monitor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Monitor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Monitor -> r)
-> (forall u. (forall d. Data d => d -> u) -> Monitor -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Monitor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Monitor -> m Monitor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Monitor -> m Monitor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Monitor -> m Monitor)
-> Data Monitor
Monitor -> Constr
Monitor -> DataType
(forall b. Data b => b -> b) -> Monitor -> Monitor
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) -> Monitor -> u
forall u. (forall d. Data d => d -> u) -> Monitor -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Monitor -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Monitor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Monitor -> m Monitor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Monitor -> m Monitor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Monitor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Monitor -> c Monitor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Monitor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Monitor)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Monitor -> c Monitor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Monitor -> c Monitor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Monitor
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Monitor
$ctoConstr :: Monitor -> Constr
toConstr :: Monitor -> Constr
$cdataTypeOf :: Monitor -> DataType
dataTypeOf :: Monitor -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Monitor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Monitor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Monitor)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Monitor)
$cgmapT :: (forall b. Data b => b -> b) -> Monitor -> Monitor
gmapT :: (forall b. Data b => b -> b) -> Monitor -> Monitor
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Monitor -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Monitor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Monitor -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Monitor -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Monitor -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Monitor -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Monitor -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Monitor -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Monitor -> m Monitor
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Monitor -> m Monitor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Monitor -> m Monitor
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Monitor -> m Monitor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Monitor -> m Monitor
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Monitor -> m Monitor
Data, Monitor -> Monitor -> Bool
(Monitor -> Monitor -> Bool)
-> (Monitor -> Monitor -> Bool) -> Eq Monitor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Monitor -> Monitor -> Bool
== :: Monitor -> Monitor -> Bool
$c/= :: Monitor -> Monitor -> Bool
/= :: Monitor -> Monitor -> Bool
Eq, Eq Monitor
Eq Monitor =>
(Monitor -> Monitor -> Ordering)
-> (Monitor -> Monitor -> Bool)
-> (Monitor -> Monitor -> Bool)
-> (Monitor -> Monitor -> Bool)
-> (Monitor -> Monitor -> Bool)
-> (Monitor -> Monitor -> Monitor)
-> (Monitor -> Monitor -> Monitor)
-> Ord Monitor
Monitor -> Monitor -> Bool
Monitor -> Monitor -> Ordering
Monitor -> Monitor -> Monitor
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
$ccompare :: Monitor -> Monitor -> Ordering
compare :: Monitor -> Monitor -> Ordering
$c< :: Monitor -> Monitor -> Bool
< :: Monitor -> Monitor -> Bool
$c<= :: Monitor -> Monitor -> Bool
<= :: Monitor -> Monitor -> Bool
$c> :: Monitor -> Monitor -> Bool
> :: Monitor -> Monitor -> Bool
$c>= :: Monitor -> Monitor -> Bool
>= :: Monitor -> Monitor -> Bool
$cmax :: Monitor -> Monitor -> Monitor
max :: Monitor -> Monitor -> Monitor
$cmin :: Monitor -> Monitor -> Monitor
min :: Monitor -> Monitor -> Monitor
Ord, Int -> Monitor -> ShowS
[Monitor] -> ShowS
Monitor -> String
(Int -> Monitor -> ShowS)
-> (Monitor -> String) -> ([Monitor] -> ShowS) -> Show Monitor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Monitor -> ShowS
showsPrec :: Int -> Monitor -> ShowS
$cshow :: Monitor -> String
show :: Monitor -> String
$cshowList :: [Monitor] -> ShowS
showList :: [Monitor] -> ShowS
Show, Typeable, (forall x. Monitor -> Rep Monitor x)
-> (forall x. Rep Monitor x -> Monitor) -> Generic Monitor
forall x. Rep Monitor x -> Monitor
forall x. Monitor -> Rep Monitor x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Monitor -> Rep Monitor x
from :: forall x. Monitor -> Rep Monitor x
$cto :: forall x. Rep Monitor x -> Monitor
to :: forall x. Rep Monitor x -> Monitor
Generic)

-- | Part of the t'Graphics.UI.GLFW.MonitorCallback', for when a monitor gets
-- connected or disconnected.
data MonitorState =
    MonitorState'Connected
  | MonitorState'Disconnected
  deriving (Typeable MonitorState
Typeable MonitorState =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MonitorState -> c MonitorState)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MonitorState)
-> (MonitorState -> Constr)
-> (MonitorState -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MonitorState))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MonitorState))
-> ((forall b. Data b => b -> b) -> MonitorState -> MonitorState)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MonitorState -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MonitorState -> r)
-> (forall u. (forall d. Data d => d -> u) -> MonitorState -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MonitorState -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MonitorState -> m MonitorState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MonitorState -> m MonitorState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MonitorState -> m MonitorState)
-> Data MonitorState
MonitorState -> Constr
MonitorState -> DataType
(forall b. Data b => b -> b) -> MonitorState -> MonitorState
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) -> MonitorState -> u
forall u. (forall d. Data d => d -> u) -> MonitorState -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MonitorState -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MonitorState -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MonitorState -> m MonitorState
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MonitorState -> m MonitorState
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MonitorState
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MonitorState -> c MonitorState
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MonitorState)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MonitorState)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MonitorState -> c MonitorState
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MonitorState -> c MonitorState
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MonitorState
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MonitorState
$ctoConstr :: MonitorState -> Constr
toConstr :: MonitorState -> Constr
$cdataTypeOf :: MonitorState -> DataType
dataTypeOf :: MonitorState -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MonitorState)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MonitorState)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MonitorState)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MonitorState)
$cgmapT :: (forall b. Data b => b -> b) -> MonitorState -> MonitorState
gmapT :: (forall b. Data b => b -> b) -> MonitorState -> MonitorState
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MonitorState -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MonitorState -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MonitorState -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MonitorState -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MonitorState -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MonitorState -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MonitorState -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MonitorState -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MonitorState -> m MonitorState
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MonitorState -> m MonitorState
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MonitorState -> m MonitorState
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MonitorState -> m MonitorState
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MonitorState -> m MonitorState
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MonitorState -> m MonitorState
Data, MonitorState -> MonitorState -> Bool
(MonitorState -> MonitorState -> Bool)
-> (MonitorState -> MonitorState -> Bool) -> Eq MonitorState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MonitorState -> MonitorState -> Bool
== :: MonitorState -> MonitorState -> Bool
$c/= :: MonitorState -> MonitorState -> Bool
/= :: MonitorState -> MonitorState -> Bool
Eq, Eq MonitorState
Eq MonitorState =>
(MonitorState -> MonitorState -> Ordering)
-> (MonitorState -> MonitorState -> Bool)
-> (MonitorState -> MonitorState -> Bool)
-> (MonitorState -> MonitorState -> Bool)
-> (MonitorState -> MonitorState -> Bool)
-> (MonitorState -> MonitorState -> MonitorState)
-> (MonitorState -> MonitorState -> MonitorState)
-> Ord MonitorState
MonitorState -> MonitorState -> Bool
MonitorState -> MonitorState -> Ordering
MonitorState -> MonitorState -> MonitorState
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
$ccompare :: MonitorState -> MonitorState -> Ordering
compare :: MonitorState -> MonitorState -> Ordering
$c< :: MonitorState -> MonitorState -> Bool
< :: MonitorState -> MonitorState -> Bool
$c<= :: MonitorState -> MonitorState -> Bool
<= :: MonitorState -> MonitorState -> Bool
$c> :: MonitorState -> MonitorState -> Bool
> :: MonitorState -> MonitorState -> Bool
$c>= :: MonitorState -> MonitorState -> Bool
>= :: MonitorState -> MonitorState -> Bool
$cmax :: MonitorState -> MonitorState -> MonitorState
max :: MonitorState -> MonitorState -> MonitorState
$cmin :: MonitorState -> MonitorState -> MonitorState
min :: MonitorState -> MonitorState -> MonitorState
Ord, ReadPrec [MonitorState]
ReadPrec MonitorState
Int -> ReadS MonitorState
ReadS [MonitorState]
(Int -> ReadS MonitorState)
-> ReadS [MonitorState]
-> ReadPrec MonitorState
-> ReadPrec [MonitorState]
-> Read MonitorState
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MonitorState
readsPrec :: Int -> ReadS MonitorState
$creadList :: ReadS [MonitorState]
readList :: ReadS [MonitorState]
$creadPrec :: ReadPrec MonitorState
readPrec :: ReadPrec MonitorState
$creadListPrec :: ReadPrec [MonitorState]
readListPrec :: ReadPrec [MonitorState]
Read, Int -> MonitorState -> ShowS
[MonitorState] -> ShowS
MonitorState -> String
(Int -> MonitorState -> ShowS)
-> (MonitorState -> String)
-> ([MonitorState] -> ShowS)
-> Show MonitorState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MonitorState -> ShowS
showsPrec :: Int -> MonitorState -> ShowS
$cshow :: MonitorState -> String
show :: MonitorState -> String
$cshowList :: [MonitorState] -> ShowS
showList :: [MonitorState] -> ShowS
Show, Typeable, (forall x. MonitorState -> Rep MonitorState x)
-> (forall x. Rep MonitorState x -> MonitorState)
-> Generic MonitorState
forall x. Rep MonitorState x -> MonitorState
forall x. MonitorState -> Rep MonitorState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MonitorState -> Rep MonitorState x
from :: forall x. MonitorState -> Rep MonitorState x
$cto :: forall x. Rep MonitorState x -> MonitorState
to :: forall x. Rep MonitorState x -> MonitorState
Generic)

instance NFData MonitorState

-- | See <http://www.glfw.org/docs/3.3/monitor.html#monitor_modes Video Modes>
data VideoMode = VideoMode
  { VideoMode -> Int
videoModeWidth       :: {-# UNPACK #-} !Int
  , VideoMode -> Int
videoModeHeight      :: {-# UNPACK #-} !Int
  , VideoMode -> Int
videoModeRedBits     :: {-# UNPACK #-} !Int
  , VideoMode -> Int
videoModeGreenBits   :: {-# UNPACK #-} !Int
  , VideoMode -> Int
videoModeBlueBits    :: {-# UNPACK #-} !Int
  , VideoMode -> Int
videoModeRefreshRate :: {-# UNPACK #-} !Int
  } deriving (Typeable VideoMode
Typeable VideoMode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> VideoMode -> c VideoMode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c VideoMode)
-> (VideoMode -> Constr)
-> (VideoMode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c VideoMode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VideoMode))
-> ((forall b. Data b => b -> b) -> VideoMode -> VideoMode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VideoMode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VideoMode -> r)
-> (forall u. (forall d. Data d => d -> u) -> VideoMode -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> VideoMode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VideoMode -> m VideoMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VideoMode -> m VideoMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VideoMode -> m VideoMode)
-> Data VideoMode
VideoMode -> Constr
VideoMode -> DataType
(forall b. Data b => b -> b) -> VideoMode -> VideoMode
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) -> VideoMode -> u
forall u. (forall d. Data d => d -> u) -> VideoMode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VideoMode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VideoMode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VideoMode -> m VideoMode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VideoMode -> m VideoMode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VideoMode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VideoMode -> c VideoMode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VideoMode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VideoMode)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VideoMode -> c VideoMode
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VideoMode -> c VideoMode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VideoMode
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VideoMode
$ctoConstr :: VideoMode -> Constr
toConstr :: VideoMode -> Constr
$cdataTypeOf :: VideoMode -> DataType
dataTypeOf :: VideoMode -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VideoMode)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VideoMode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VideoMode)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VideoMode)
$cgmapT :: (forall b. Data b => b -> b) -> VideoMode -> VideoMode
gmapT :: (forall b. Data b => b -> b) -> VideoMode -> VideoMode
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VideoMode -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VideoMode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VideoMode -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VideoMode -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VideoMode -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> VideoMode -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VideoMode -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VideoMode -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VideoMode -> m VideoMode
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VideoMode -> m VideoMode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VideoMode -> m VideoMode
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VideoMode -> m VideoMode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VideoMode -> m VideoMode
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VideoMode -> m VideoMode
Data, VideoMode -> VideoMode -> Bool
(VideoMode -> VideoMode -> Bool)
-> (VideoMode -> VideoMode -> Bool) -> Eq VideoMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VideoMode -> VideoMode -> Bool
== :: VideoMode -> VideoMode -> Bool
$c/= :: VideoMode -> VideoMode -> Bool
/= :: VideoMode -> VideoMode -> Bool
Eq, Eq VideoMode
Eq VideoMode =>
(VideoMode -> VideoMode -> Ordering)
-> (VideoMode -> VideoMode -> Bool)
-> (VideoMode -> VideoMode -> Bool)
-> (VideoMode -> VideoMode -> Bool)
-> (VideoMode -> VideoMode -> Bool)
-> (VideoMode -> VideoMode -> VideoMode)
-> (VideoMode -> VideoMode -> VideoMode)
-> Ord VideoMode
VideoMode -> VideoMode -> Bool
VideoMode -> VideoMode -> Ordering
VideoMode -> VideoMode -> VideoMode
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
$ccompare :: VideoMode -> VideoMode -> Ordering
compare :: VideoMode -> VideoMode -> Ordering
$c< :: VideoMode -> VideoMode -> Bool
< :: VideoMode -> VideoMode -> Bool
$c<= :: VideoMode -> VideoMode -> Bool
<= :: VideoMode -> VideoMode -> Bool
$c> :: VideoMode -> VideoMode -> Bool
> :: VideoMode -> VideoMode -> Bool
$c>= :: VideoMode -> VideoMode -> Bool
>= :: VideoMode -> VideoMode -> Bool
$cmax :: VideoMode -> VideoMode -> VideoMode
max :: VideoMode -> VideoMode -> VideoMode
$cmin :: VideoMode -> VideoMode -> VideoMode
min :: VideoMode -> VideoMode -> VideoMode
Ord, ReadPrec [VideoMode]
ReadPrec VideoMode
Int -> ReadS VideoMode
ReadS [VideoMode]
(Int -> ReadS VideoMode)
-> ReadS [VideoMode]
-> ReadPrec VideoMode
-> ReadPrec [VideoMode]
-> Read VideoMode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VideoMode
readsPrec :: Int -> ReadS VideoMode
$creadList :: ReadS [VideoMode]
readList :: ReadS [VideoMode]
$creadPrec :: ReadPrec VideoMode
readPrec :: ReadPrec VideoMode
$creadListPrec :: ReadPrec [VideoMode]
readListPrec :: ReadPrec [VideoMode]
Read, Int -> VideoMode -> ShowS
[VideoMode] -> ShowS
VideoMode -> String
(Int -> VideoMode -> ShowS)
-> (VideoMode -> String)
-> ([VideoMode] -> ShowS)
-> Show VideoMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VideoMode -> ShowS
showsPrec :: Int -> VideoMode -> ShowS
$cshow :: VideoMode -> String
show :: VideoMode -> String
$cshowList :: [VideoMode] -> ShowS
showList :: [VideoMode] -> ShowS
Show, Typeable, (forall x. VideoMode -> Rep VideoMode x)
-> (forall x. Rep VideoMode x -> VideoMode) -> Generic VideoMode
forall x. Rep VideoMode x -> VideoMode
forall x. VideoMode -> Rep VideoMode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. VideoMode -> Rep VideoMode x
from :: forall x. VideoMode -> Rep VideoMode x
$cto :: forall x. Rep VideoMode x -> VideoMode
to :: forall x. Rep VideoMode x -> VideoMode
Generic)

instance NFData VideoMode

-- | Lets you adjust the gamma of a monitor. To ensure that only valid values are created, use 'makeGammaRamp'.
-- See <http://www.glfw.org/docs/3.3/monitor.html#monitor_gamma Gamma Ramp>.
data GammaRamp = GammaRamp
  -- NOTE: It would be bad to give clients a way to construct invalid gamma ramps
  -- with lists of unequal length, so this constructor should not be exported.
  { GammaRamp -> [Int]
gammaRampRed   :: [Int]
  , GammaRamp -> [Int]
gammaRampGreen :: [Int]
  , GammaRamp -> [Int]
gammaRampBlue  :: [Int]
  } deriving (Typeable GammaRamp
Typeable GammaRamp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GammaRamp -> c GammaRamp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GammaRamp)
-> (GammaRamp -> Constr)
-> (GammaRamp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GammaRamp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GammaRamp))
-> ((forall b. Data b => b -> b) -> GammaRamp -> GammaRamp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GammaRamp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GammaRamp -> r)
-> (forall u. (forall d. Data d => d -> u) -> GammaRamp -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GammaRamp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GammaRamp -> m GammaRamp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GammaRamp -> m GammaRamp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GammaRamp -> m GammaRamp)
-> Data GammaRamp
GammaRamp -> Constr
GammaRamp -> DataType
(forall b. Data b => b -> b) -> GammaRamp -> GammaRamp
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) -> GammaRamp -> u
forall u. (forall d. Data d => d -> u) -> GammaRamp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GammaRamp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GammaRamp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GammaRamp -> m GammaRamp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GammaRamp -> m GammaRamp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GammaRamp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GammaRamp -> c GammaRamp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GammaRamp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GammaRamp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GammaRamp -> c GammaRamp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GammaRamp -> c GammaRamp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GammaRamp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GammaRamp
$ctoConstr :: GammaRamp -> Constr
toConstr :: GammaRamp -> Constr
$cdataTypeOf :: GammaRamp -> DataType
dataTypeOf :: GammaRamp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GammaRamp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GammaRamp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GammaRamp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GammaRamp)
$cgmapT :: (forall b. Data b => b -> b) -> GammaRamp -> GammaRamp
gmapT :: (forall b. Data b => b -> b) -> GammaRamp -> GammaRamp
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GammaRamp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GammaRamp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GammaRamp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GammaRamp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GammaRamp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GammaRamp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GammaRamp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GammaRamp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GammaRamp -> m GammaRamp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GammaRamp -> m GammaRamp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GammaRamp -> m GammaRamp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GammaRamp -> m GammaRamp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GammaRamp -> m GammaRamp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GammaRamp -> m GammaRamp
Data, GammaRamp -> GammaRamp -> Bool
(GammaRamp -> GammaRamp -> Bool)
-> (GammaRamp -> GammaRamp -> Bool) -> Eq GammaRamp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GammaRamp -> GammaRamp -> Bool
== :: GammaRamp -> GammaRamp -> Bool
$c/= :: GammaRamp -> GammaRamp -> Bool
/= :: GammaRamp -> GammaRamp -> Bool
Eq, Eq GammaRamp
Eq GammaRamp =>
(GammaRamp -> GammaRamp -> Ordering)
-> (GammaRamp -> GammaRamp -> Bool)
-> (GammaRamp -> GammaRamp -> Bool)
-> (GammaRamp -> GammaRamp -> Bool)
-> (GammaRamp -> GammaRamp -> Bool)
-> (GammaRamp -> GammaRamp -> GammaRamp)
-> (GammaRamp -> GammaRamp -> GammaRamp)
-> Ord GammaRamp
GammaRamp -> GammaRamp -> Bool
GammaRamp -> GammaRamp -> Ordering
GammaRamp -> GammaRamp -> GammaRamp
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
$ccompare :: GammaRamp -> GammaRamp -> Ordering
compare :: GammaRamp -> GammaRamp -> Ordering
$c< :: GammaRamp -> GammaRamp -> Bool
< :: GammaRamp -> GammaRamp -> Bool
$c<= :: GammaRamp -> GammaRamp -> Bool
<= :: GammaRamp -> GammaRamp -> Bool
$c> :: GammaRamp -> GammaRamp -> Bool
> :: GammaRamp -> GammaRamp -> Bool
$c>= :: GammaRamp -> GammaRamp -> Bool
>= :: GammaRamp -> GammaRamp -> Bool
$cmax :: GammaRamp -> GammaRamp -> GammaRamp
max :: GammaRamp -> GammaRamp -> GammaRamp
$cmin :: GammaRamp -> GammaRamp -> GammaRamp
min :: GammaRamp -> GammaRamp -> GammaRamp
Ord, ReadPrec [GammaRamp]
ReadPrec GammaRamp
Int -> ReadS GammaRamp
ReadS [GammaRamp]
(Int -> ReadS GammaRamp)
-> ReadS [GammaRamp]
-> ReadPrec GammaRamp
-> ReadPrec [GammaRamp]
-> Read GammaRamp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GammaRamp
readsPrec :: Int -> ReadS GammaRamp
$creadList :: ReadS [GammaRamp]
readList :: ReadS [GammaRamp]
$creadPrec :: ReadPrec GammaRamp
readPrec :: ReadPrec GammaRamp
$creadListPrec :: ReadPrec [GammaRamp]
readListPrec :: ReadPrec [GammaRamp]
Read, Int -> GammaRamp -> ShowS
[GammaRamp] -> ShowS
GammaRamp -> String
(Int -> GammaRamp -> ShowS)
-> (GammaRamp -> String)
-> ([GammaRamp] -> ShowS)
-> Show GammaRamp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GammaRamp -> ShowS
showsPrec :: Int -> GammaRamp -> ShowS
$cshow :: GammaRamp -> String
show :: GammaRamp -> String
$cshowList :: [GammaRamp] -> ShowS
showList :: [GammaRamp] -> ShowS
Show, Typeable, (forall x. GammaRamp -> Rep GammaRamp x)
-> (forall x. Rep GammaRamp x -> GammaRamp) -> Generic GammaRamp
forall x. Rep GammaRamp x -> GammaRamp
forall x. GammaRamp -> Rep GammaRamp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GammaRamp -> Rep GammaRamp x
from :: forall x. GammaRamp -> Rep GammaRamp x
$cto :: forall x. Rep GammaRamp x -> GammaRamp
to :: forall x. Rep GammaRamp x -> GammaRamp
Generic)

instance NFData GammaRamp

-- | Smart constructor for a 'GammaRamp'.
makeGammaRamp :: [Int] -> [Int] -> [Int] -> Maybe GammaRamp
makeGammaRamp :: [Int] -> [Int] -> [Int] -> Maybe GammaRamp
makeGammaRamp [Int]
rs [Int]
gs [Int]
bs
    | Bool
lengthsEqual = GammaRamp -> Maybe GammaRamp
forall a. a -> Maybe a
Just (GammaRamp -> Maybe GammaRamp) -> GammaRamp -> Maybe GammaRamp
forall a b. (a -> b) -> a -> b
$ [Int] -> [Int] -> [Int] -> GammaRamp
GammaRamp [Int]
rs [Int]
gs [Int]
bs
    | Bool
otherwise    = Maybe GammaRamp
forall a. Maybe a
Nothing
  where
    lengthsEqual :: Bool
lengthsEqual =
      let rsl :: Int
rsl = [Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
rs
          gsl :: Int
gsl = [Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
gs
          bsl :: Int
bsl = [Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
bs
      in Int
rsl Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
gsl Bool -> Bool -> Bool
&& Int
gsl Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
bsl

--------------------------------------------------------------------------------
-- Window handling

-- | Collects all the callbacks that can be associated with a Window into a single place.
data WindowCallbacks = WindowCallbacks
  { WindowCallbacks -> IORef C'GLFWcharfun
storedCharFun               :: !(IORef C'GLFWcharfun)
  , WindowCallbacks -> IORef C'GLFWcharmodsfun
storedCharModsFun           :: !(IORef C'GLFWcharmodsfun)
  , WindowCallbacks -> IORef C'GLFWcursorenterfun
storedCursorEnterFun        :: !(IORef C'GLFWcursorenterfun)
  , WindowCallbacks -> IORef C'GLFWcursorposfun
storedCursorPosFun          :: !(IORef C'GLFWcursorposfun)
  , WindowCallbacks -> IORef C'GLFWframebuffersizefun
storedFramebufferSizeFun    :: !(IORef C'GLFWframebuffersizefun)
  , WindowCallbacks -> IORef C'GLFWkeyfun
storedKeyFun                :: !(IORef C'GLFWkeyfun)
  , WindowCallbacks -> IORef C'GLFWmousebuttonfun
storedMouseButtonFun        :: !(IORef C'GLFWmousebuttonfun)
  , WindowCallbacks -> IORef C'GLFWcursorposfun
storedScrollFun             :: !(IORef C'GLFWscrollfun)
  , WindowCallbacks -> IORef C'GLFWwindowclosefun
storedWindowCloseFun        :: !(IORef C'GLFWwindowclosefun)
  , WindowCallbacks -> IORef C'GLFWcursorenterfun
storedWindowFocusFun        :: !(IORef C'GLFWwindowfocusfun)
  , WindowCallbacks -> IORef C'GLFWcursorenterfun
storedWindowIconifyFun      :: !(IORef C'GLFWwindowiconifyfun)
  , WindowCallbacks -> IORef C'GLFWframebuffersizefun
storedWindowPosFun          :: !(IORef C'GLFWwindowposfun)
  , WindowCallbacks -> IORef C'GLFWwindowclosefun
storedWindowRefreshFun      :: !(IORef C'GLFWwindowrefreshfun)
  , WindowCallbacks -> IORef C'GLFWframebuffersizefun
storedWindowSizeFun         :: !(IORef C'GLFWwindowsizefun)
  , WindowCallbacks -> IORef C'GLFWwindowcontentscalefun
storedWindowContentScaleFun :: !(IORef C'GLFWwindowcontentscalefun)
  , WindowCallbacks -> IORef C'GLFWcursorenterfun
storedWindowMaximizeFun     :: !(IORef C'GLFWwindowmaximizefun)
  , WindowCallbacks -> IORef C'GLFWdropfun
storedDropFun               :: !(IORef C'GLFWdropfun)
  }

-- | Represents a GLFW window value.
-- See the <http://www.glfw.org/docs/3.3/window.html Window Guide>
newtype Window = Window
  { Window -> Ptr C'GLFWwindow
unWindow :: Ptr C'GLFWwindow
  } deriving (Typeable Window
Typeable Window =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Window -> c Window)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Window)
-> (Window -> Constr)
-> (Window -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Window))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Window))
-> ((forall b. Data b => b -> b) -> Window -> Window)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Window -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Window -> r)
-> (forall u. (forall d. Data d => d -> u) -> Window -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Window -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Window -> m Window)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Window -> m Window)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Window -> m Window)
-> Data Window
Window -> Constr
Window -> DataType
(forall b. Data b => b -> b) -> Window -> Window
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) -> Window -> u
forall u. (forall d. Data d => d -> u) -> Window -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Window -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Window -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Window -> m Window
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Window -> m Window
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Window
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Window -> c Window
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Window)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Window)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Window -> c Window
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Window -> c Window
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Window
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Window
$ctoConstr :: Window -> Constr
toConstr :: Window -> Constr
$cdataTypeOf :: Window -> DataType
dataTypeOf :: Window -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Window)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Window)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Window)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Window)
$cgmapT :: (forall b. Data b => b -> b) -> Window -> Window
gmapT :: (forall b. Data b => b -> b) -> Window -> Window
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Window -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Window -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Window -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Window -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Window -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Window -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Window -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Window -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Window -> m Window
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Window -> m Window
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Window -> m Window
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Window -> m Window
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Window -> m Window
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Window -> m Window
Data, Window -> Window -> Bool
(Window -> Window -> Bool)
-> (Window -> Window -> Bool) -> Eq Window
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Window -> Window -> Bool
== :: Window -> Window -> Bool
$c/= :: Window -> Window -> Bool
/= :: Window -> Window -> Bool
Eq, Eq Window
Eq Window =>
(Window -> Window -> Ordering)
-> (Window -> Window -> Bool)
-> (Window -> Window -> Bool)
-> (Window -> Window -> Bool)
-> (Window -> Window -> Bool)
-> (Window -> Window -> Window)
-> (Window -> Window -> Window)
-> Ord Window
Window -> Window -> Bool
Window -> Window -> Ordering
Window -> Window -> Window
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
$ccompare :: Window -> Window -> Ordering
compare :: Window -> Window -> Ordering
$c< :: Window -> Window -> Bool
< :: Window -> Window -> Bool
$c<= :: Window -> Window -> Bool
<= :: Window -> Window -> Bool
$c> :: Window -> Window -> Bool
> :: Window -> Window -> Bool
$c>= :: Window -> Window -> Bool
>= :: Window -> Window -> Bool
$cmax :: Window -> Window -> Window
max :: Window -> Window -> Window
$cmin :: Window -> Window -> Window
min :: Window -> Window -> Window
Ord, Int -> Window -> ShowS
[Window] -> ShowS
Window -> String
(Int -> Window -> ShowS)
-> (Window -> String) -> ([Window] -> ShowS) -> Show Window
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Window -> ShowS
showsPrec :: Int -> Window -> ShowS
$cshow :: Window -> String
show :: Window -> String
$cshowList :: [Window] -> ShowS
showList :: [Window] -> ShowS
Show, Typeable, (forall x. Window -> Rep Window x)
-> (forall x. Rep Window x -> Window) -> Generic Window
forall x. Rep Window x -> Window
forall x. Window -> Rep Window x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Window -> Rep Window x
from :: forall x. Window -> Rep Window x
$cto :: forall x. Rep Window x -> Window
to :: forall x. Rep Window x -> Window
Generic)

-- | Lets you set various window hints before creating a 'Window'.
-- See <http://www.glfw.org/docs/3.3/window.html#window_hints Window Hints>,
-- particularly <http://www.glfw.org/docs/3.3/window.html#window_hints_values Supported and Default Values>.
data WindowHint =
    WindowHint'Resizable              !Bool
  | WindowHint'Visible                !Bool
  | WindowHint'Decorated              !Bool
  | WindowHint'RedBits                !(Maybe Int)
  | WindowHint'GreenBits              !(Maybe Int)
  | WindowHint'BlueBits               !(Maybe Int)
  | WindowHint'AlphaBits              !(Maybe Int)
  | WindowHint'DepthBits              !(Maybe Int)
  | WindowHint'StencilBits            !(Maybe Int)
  | WindowHint'AccumRedBits           !(Maybe Int)
  | WindowHint'AccumGreenBits         !(Maybe Int)
  | WindowHint'AccumBlueBits          !(Maybe Int)
  | WindowHint'AccumAlphaBits         !(Maybe Int)
  | WindowHint'AuxBuffers             !(Maybe Int)
  | WindowHint'Samples                !(Maybe Int)
  | WindowHint'RefreshRate            !(Maybe Int)
  | WindowHint'DoubleBuffer           !Bool
  | WindowHint'Stereo                 !Bool
  | WindowHint'sRGBCapable            !Bool
  | WindowHint'Floating               !Bool
  | WindowHint'Focused                !Bool
  | WindowHint'Maximized              !Bool
  | WindowHint'AutoIconify            !Bool
  | WindowHint'ClientAPI              !ClientAPI
  | WindowHint'ContextCreationAPI     !ContextCreationAPI
  | WindowHint'ContextVersionMajor    {-# UNPACK #-} !Int
  | WindowHint'ContextVersionMinor    {-# UNPACK #-} !Int
  | WindowHint'ContextRobustness      !ContextRobustness
  | WindowHint'ContextReleaseBehavior !ContextReleaseBehavior
  | WindowHint'ContextNoError         !Bool
  | WindowHint'OpenGLForwardCompat    !Bool
  | WindowHint'OpenGLDebugContext     !Bool
  | WindowHint'OpenGLProfile          !OpenGLProfile
  | WindowHint'TransparentFramebuffer !Bool
  | WindowHint'CenterCursor           !Bool
  | WindowHint'FocusOnShow            !Bool
  | WindowHint'ScaleToMonitor         !Bool
  | WindowHint'CocoaRetinaFramebuffer !Bool
  | WindowHint'CocoaGraphicsSwitching !Bool
  | WindowHint'CocoaFrameName         !String
  | WindowHint'X11ClassName           !String
  | WindowHint'X11InstanceName        !String
  deriving (Typeable WindowHint
Typeable WindowHint =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> WindowHint -> c WindowHint)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WindowHint)
-> (WindowHint -> Constr)
-> (WindowHint -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WindowHint))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c WindowHint))
-> ((forall b. Data b => b -> b) -> WindowHint -> WindowHint)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WindowHint -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WindowHint -> r)
-> (forall u. (forall d. Data d => d -> u) -> WindowHint -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> WindowHint -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WindowHint -> m WindowHint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WindowHint -> m WindowHint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WindowHint -> m WindowHint)
-> Data WindowHint
WindowHint -> Constr
WindowHint -> DataType
(forall b. Data b => b -> b) -> WindowHint -> WindowHint
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) -> WindowHint -> u
forall u. (forall d. Data d => d -> u) -> WindowHint -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WindowHint -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WindowHint -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WindowHint -> m WindowHint
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WindowHint -> m WindowHint
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WindowHint
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WindowHint -> c WindowHint
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WindowHint)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WindowHint)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WindowHint -> c WindowHint
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WindowHint -> c WindowHint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WindowHint
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WindowHint
$ctoConstr :: WindowHint -> Constr
toConstr :: WindowHint -> Constr
$cdataTypeOf :: WindowHint -> DataType
dataTypeOf :: WindowHint -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WindowHint)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WindowHint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WindowHint)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WindowHint)
$cgmapT :: (forall b. Data b => b -> b) -> WindowHint -> WindowHint
gmapT :: (forall b. Data b => b -> b) -> WindowHint -> WindowHint
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WindowHint -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WindowHint -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WindowHint -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WindowHint -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WindowHint -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> WindowHint -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WindowHint -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WindowHint -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WindowHint -> m WindowHint
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WindowHint -> m WindowHint
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WindowHint -> m WindowHint
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WindowHint -> m WindowHint
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WindowHint -> m WindowHint
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WindowHint -> m WindowHint
Data, WindowHint -> WindowHint -> Bool
(WindowHint -> WindowHint -> Bool)
-> (WindowHint -> WindowHint -> Bool) -> Eq WindowHint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WindowHint -> WindowHint -> Bool
== :: WindowHint -> WindowHint -> Bool
$c/= :: WindowHint -> WindowHint -> Bool
/= :: WindowHint -> WindowHint -> Bool
Eq, Eq WindowHint
Eq WindowHint =>
(WindowHint -> WindowHint -> Ordering)
-> (WindowHint -> WindowHint -> Bool)
-> (WindowHint -> WindowHint -> Bool)
-> (WindowHint -> WindowHint -> Bool)
-> (WindowHint -> WindowHint -> Bool)
-> (WindowHint -> WindowHint -> WindowHint)
-> (WindowHint -> WindowHint -> WindowHint)
-> Ord WindowHint
WindowHint -> WindowHint -> Bool
WindowHint -> WindowHint -> Ordering
WindowHint -> WindowHint -> WindowHint
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
$ccompare :: WindowHint -> WindowHint -> Ordering
compare :: WindowHint -> WindowHint -> Ordering
$c< :: WindowHint -> WindowHint -> Bool
< :: WindowHint -> WindowHint -> Bool
$c<= :: WindowHint -> WindowHint -> Bool
<= :: WindowHint -> WindowHint -> Bool
$c> :: WindowHint -> WindowHint -> Bool
> :: WindowHint -> WindowHint -> Bool
$c>= :: WindowHint -> WindowHint -> Bool
>= :: WindowHint -> WindowHint -> Bool
$cmax :: WindowHint -> WindowHint -> WindowHint
max :: WindowHint -> WindowHint -> WindowHint
$cmin :: WindowHint -> WindowHint -> WindowHint
min :: WindowHint -> WindowHint -> WindowHint
Ord, ReadPrec [WindowHint]
ReadPrec WindowHint
Int -> ReadS WindowHint
ReadS [WindowHint]
(Int -> ReadS WindowHint)
-> ReadS [WindowHint]
-> ReadPrec WindowHint
-> ReadPrec [WindowHint]
-> Read WindowHint
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS WindowHint
readsPrec :: Int -> ReadS WindowHint
$creadList :: ReadS [WindowHint]
readList :: ReadS [WindowHint]
$creadPrec :: ReadPrec WindowHint
readPrec :: ReadPrec WindowHint
$creadListPrec :: ReadPrec [WindowHint]
readListPrec :: ReadPrec [WindowHint]
Read, Int -> WindowHint -> ShowS
[WindowHint] -> ShowS
WindowHint -> String
(Int -> WindowHint -> ShowS)
-> (WindowHint -> String)
-> ([WindowHint] -> ShowS)
-> Show WindowHint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WindowHint -> ShowS
showsPrec :: Int -> WindowHint -> ShowS
$cshow :: WindowHint -> String
show :: WindowHint -> String
$cshowList :: [WindowHint] -> ShowS
showList :: [WindowHint] -> ShowS
Show, Typeable, (forall x. WindowHint -> Rep WindowHint x)
-> (forall x. Rep WindowHint x -> WindowHint) -> Generic WindowHint
forall x. Rep WindowHint x -> WindowHint
forall x. WindowHint -> Rep WindowHint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WindowHint -> Rep WindowHint x
from :: forall x. WindowHint -> Rep WindowHint x
$cto :: forall x. Rep WindowHint x -> WindowHint
to :: forall x. Rep WindowHint x -> WindowHint
Generic)

instance NFData WindowHint

-- | A window-specific attribute.
-- See <https://www.glfw.org/docs/3.3/window_guide.html#window_attribs Window Attributes>
data WindowAttrib
  = WindowAttrib'Decorated
  | WindowAttrib'Resizable
  | WindowAttrib'Floating
  | WindowAttrib'AutoIconify
  | WindowAttrib'FocusOnShow
  | WindowAttrib'Hovered
  deriving (WindowAttrib
WindowAttrib -> WindowAttrib -> Bounded WindowAttrib
forall a. a -> a -> Bounded a
$cminBound :: WindowAttrib
minBound :: WindowAttrib
$cmaxBound :: WindowAttrib
maxBound :: WindowAttrib
Bounded, Typeable WindowAttrib
Typeable WindowAttrib =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> WindowAttrib -> c WindowAttrib)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WindowAttrib)
-> (WindowAttrib -> Constr)
-> (WindowAttrib -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WindowAttrib))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c WindowAttrib))
-> ((forall b. Data b => b -> b) -> WindowAttrib -> WindowAttrib)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WindowAttrib -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WindowAttrib -> r)
-> (forall u. (forall d. Data d => d -> u) -> WindowAttrib -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> WindowAttrib -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WindowAttrib -> m WindowAttrib)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WindowAttrib -> m WindowAttrib)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WindowAttrib -> m WindowAttrib)
-> Data WindowAttrib
WindowAttrib -> Constr
WindowAttrib -> DataType
(forall b. Data b => b -> b) -> WindowAttrib -> WindowAttrib
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) -> WindowAttrib -> u
forall u. (forall d. Data d => d -> u) -> WindowAttrib -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WindowAttrib -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WindowAttrib -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WindowAttrib -> m WindowAttrib
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WindowAttrib -> m WindowAttrib
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WindowAttrib
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WindowAttrib -> c WindowAttrib
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WindowAttrib)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c WindowAttrib)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WindowAttrib -> c WindowAttrib
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WindowAttrib -> c WindowAttrib
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WindowAttrib
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WindowAttrib
$ctoConstr :: WindowAttrib -> Constr
toConstr :: WindowAttrib -> Constr
$cdataTypeOf :: WindowAttrib -> DataType
dataTypeOf :: WindowAttrib -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WindowAttrib)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WindowAttrib)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c WindowAttrib)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c WindowAttrib)
$cgmapT :: (forall b. Data b => b -> b) -> WindowAttrib -> WindowAttrib
gmapT :: (forall b. Data b => b -> b) -> WindowAttrib -> WindowAttrib
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WindowAttrib -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WindowAttrib -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WindowAttrib -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WindowAttrib -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WindowAttrib -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> WindowAttrib -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WindowAttrib -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WindowAttrib -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WindowAttrib -> m WindowAttrib
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WindowAttrib -> m WindowAttrib
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WindowAttrib -> m WindowAttrib
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WindowAttrib -> m WindowAttrib
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WindowAttrib -> m WindowAttrib
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WindowAttrib -> m WindowAttrib
Data, Int -> WindowAttrib
WindowAttrib -> Int
WindowAttrib -> [WindowAttrib]
WindowAttrib -> WindowAttrib
WindowAttrib -> WindowAttrib -> [WindowAttrib]
WindowAttrib -> WindowAttrib -> WindowAttrib -> [WindowAttrib]
(WindowAttrib -> WindowAttrib)
-> (WindowAttrib -> WindowAttrib)
-> (Int -> WindowAttrib)
-> (WindowAttrib -> Int)
-> (WindowAttrib -> [WindowAttrib])
-> (WindowAttrib -> WindowAttrib -> [WindowAttrib])
-> (WindowAttrib -> WindowAttrib -> [WindowAttrib])
-> (WindowAttrib -> WindowAttrib -> WindowAttrib -> [WindowAttrib])
-> Enum WindowAttrib
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: WindowAttrib -> WindowAttrib
succ :: WindowAttrib -> WindowAttrib
$cpred :: WindowAttrib -> WindowAttrib
pred :: WindowAttrib -> WindowAttrib
$ctoEnum :: Int -> WindowAttrib
toEnum :: Int -> WindowAttrib
$cfromEnum :: WindowAttrib -> Int
fromEnum :: WindowAttrib -> Int
$cenumFrom :: WindowAttrib -> [WindowAttrib]
enumFrom :: WindowAttrib -> [WindowAttrib]
$cenumFromThen :: WindowAttrib -> WindowAttrib -> [WindowAttrib]
enumFromThen :: WindowAttrib -> WindowAttrib -> [WindowAttrib]
$cenumFromTo :: WindowAttrib -> WindowAttrib -> [WindowAttrib]
enumFromTo :: WindowAttrib -> WindowAttrib -> [WindowAttrib]
$cenumFromThenTo :: WindowAttrib -> WindowAttrib -> WindowAttrib -> [WindowAttrib]
enumFromThenTo :: WindowAttrib -> WindowAttrib -> WindowAttrib -> [WindowAttrib]
Enum, WindowAttrib -> WindowAttrib -> Bool
(WindowAttrib -> WindowAttrib -> Bool)
-> (WindowAttrib -> WindowAttrib -> Bool) -> Eq WindowAttrib
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WindowAttrib -> WindowAttrib -> Bool
== :: WindowAttrib -> WindowAttrib -> Bool
$c/= :: WindowAttrib -> WindowAttrib -> Bool
/= :: WindowAttrib -> WindowAttrib -> Bool
Eq, Eq WindowAttrib
Eq WindowAttrib =>
(WindowAttrib -> WindowAttrib -> Ordering)
-> (WindowAttrib -> WindowAttrib -> Bool)
-> (WindowAttrib -> WindowAttrib -> Bool)
-> (WindowAttrib -> WindowAttrib -> Bool)
-> (WindowAttrib -> WindowAttrib -> Bool)
-> (WindowAttrib -> WindowAttrib -> WindowAttrib)
-> (WindowAttrib -> WindowAttrib -> WindowAttrib)
-> Ord WindowAttrib
WindowAttrib -> WindowAttrib -> Bool
WindowAttrib -> WindowAttrib -> Ordering
WindowAttrib -> WindowAttrib -> WindowAttrib
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
$ccompare :: WindowAttrib -> WindowAttrib -> Ordering
compare :: WindowAttrib -> WindowAttrib -> Ordering
$c< :: WindowAttrib -> WindowAttrib -> Bool
< :: WindowAttrib -> WindowAttrib -> Bool
$c<= :: WindowAttrib -> WindowAttrib -> Bool
<= :: WindowAttrib -> WindowAttrib -> Bool
$c> :: WindowAttrib -> WindowAttrib -> Bool
> :: WindowAttrib -> WindowAttrib -> Bool
$c>= :: WindowAttrib -> WindowAttrib -> Bool
>= :: WindowAttrib -> WindowAttrib -> Bool
$cmax :: WindowAttrib -> WindowAttrib -> WindowAttrib
max :: WindowAttrib -> WindowAttrib -> WindowAttrib
$cmin :: WindowAttrib -> WindowAttrib -> WindowAttrib
min :: WindowAttrib -> WindowAttrib -> WindowAttrib
Ord, ReadPrec [WindowAttrib]
ReadPrec WindowAttrib
Int -> ReadS WindowAttrib
ReadS [WindowAttrib]
(Int -> ReadS WindowAttrib)
-> ReadS [WindowAttrib]
-> ReadPrec WindowAttrib
-> ReadPrec [WindowAttrib]
-> Read WindowAttrib
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS WindowAttrib
readsPrec :: Int -> ReadS WindowAttrib
$creadList :: ReadS [WindowAttrib]
readList :: ReadS [WindowAttrib]
$creadPrec :: ReadPrec WindowAttrib
readPrec :: ReadPrec WindowAttrib
$creadListPrec :: ReadPrec [WindowAttrib]
readListPrec :: ReadPrec [WindowAttrib]
Read, Int -> WindowAttrib -> ShowS
[WindowAttrib] -> ShowS
WindowAttrib -> String
(Int -> WindowAttrib -> ShowS)
-> (WindowAttrib -> String)
-> ([WindowAttrib] -> ShowS)
-> Show WindowAttrib
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WindowAttrib -> ShowS
showsPrec :: Int -> WindowAttrib -> ShowS
$cshow :: WindowAttrib -> String
show :: WindowAttrib -> String
$cshowList :: [WindowAttrib] -> ShowS
showList :: [WindowAttrib] -> ShowS
Show, Typeable, (forall x. WindowAttrib -> Rep WindowAttrib x)
-> (forall x. Rep WindowAttrib x -> WindowAttrib)
-> Generic WindowAttrib
forall x. Rep WindowAttrib x -> WindowAttrib
forall x. WindowAttrib -> Rep WindowAttrib x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WindowAttrib -> Rep WindowAttrib x
from :: forall x. WindowAttrib -> Rep WindowAttrib x
$cto :: forall x. Rep WindowAttrib x -> WindowAttrib
to :: forall x. Rep WindowAttrib x -> WindowAttrib
Generic)

instance NFData WindowAttrib

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

instance NFData ContextRobustness

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

instance NFData OpenGLProfile

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

instance NFData ClientAPI

-- | The type of API to use for context creation.
-- See the <http://www.glfw.org/docs/latest/window_guide.html Window Guide> for
-- more information.
--
-- This is a hard constraint. If no client API is requested, this hint is
-- ignored. Best practice is to stick to one API or the other, otherwise may
-- segfault on Linux. OS X does not support the EGL API and will fail if this
-- hint is used.
data ContextCreationAPI
  = ContextCreationAPI'Native
  | ContextCreationAPI'EGL
  | ContextCreationAPI'OSMesa
  deriving (ContextCreationAPI
ContextCreationAPI
-> ContextCreationAPI -> Bounded ContextCreationAPI
forall a. a -> a -> Bounded a
$cminBound :: ContextCreationAPI
minBound :: ContextCreationAPI
$cmaxBound :: ContextCreationAPI
maxBound :: ContextCreationAPI
Bounded, Typeable ContextCreationAPI
Typeable ContextCreationAPI =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ContextCreationAPI
 -> c ContextCreationAPI)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ContextCreationAPI)
-> (ContextCreationAPI -> Constr)
-> (ContextCreationAPI -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ContextCreationAPI))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ContextCreationAPI))
-> ((forall b. Data b => b -> b)
    -> ContextCreationAPI -> ContextCreationAPI)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ContextCreationAPI -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ContextCreationAPI -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ContextCreationAPI -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ContextCreationAPI -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ContextCreationAPI -> m ContextCreationAPI)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ContextCreationAPI -> m ContextCreationAPI)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ContextCreationAPI -> m ContextCreationAPI)
-> Data ContextCreationAPI
ContextCreationAPI -> Constr
ContextCreationAPI -> DataType
(forall b. Data b => b -> b)
-> ContextCreationAPI -> ContextCreationAPI
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) -> ContextCreationAPI -> u
forall u. (forall d. Data d => d -> u) -> ContextCreationAPI -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContextCreationAPI -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContextCreationAPI -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContextCreationAPI -> m ContextCreationAPI
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContextCreationAPI -> m ContextCreationAPI
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContextCreationAPI
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ContextCreationAPI
-> c ContextCreationAPI
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContextCreationAPI)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContextCreationAPI)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ContextCreationAPI
-> c ContextCreationAPI
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ContextCreationAPI
-> c ContextCreationAPI
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContextCreationAPI
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContextCreationAPI
$ctoConstr :: ContextCreationAPI -> Constr
toConstr :: ContextCreationAPI -> Constr
$cdataTypeOf :: ContextCreationAPI -> DataType
dataTypeOf :: ContextCreationAPI -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContextCreationAPI)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContextCreationAPI)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContextCreationAPI)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContextCreationAPI)
$cgmapT :: (forall b. Data b => b -> b)
-> ContextCreationAPI -> ContextCreationAPI
gmapT :: (forall b. Data b => b -> b)
-> ContextCreationAPI -> ContextCreationAPI
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContextCreationAPI -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContextCreationAPI -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContextCreationAPI -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContextCreationAPI -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ContextCreationAPI -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ContextCreationAPI -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ContextCreationAPI -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ContextCreationAPI -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContextCreationAPI -> m ContextCreationAPI
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContextCreationAPI -> m ContextCreationAPI
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContextCreationAPI -> m ContextCreationAPI
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContextCreationAPI -> m ContextCreationAPI
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContextCreationAPI -> m ContextCreationAPI
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContextCreationAPI -> m ContextCreationAPI
Data, Int -> ContextCreationAPI
ContextCreationAPI -> Int
ContextCreationAPI -> [ContextCreationAPI]
ContextCreationAPI -> ContextCreationAPI
ContextCreationAPI -> ContextCreationAPI -> [ContextCreationAPI]
ContextCreationAPI
-> ContextCreationAPI -> ContextCreationAPI -> [ContextCreationAPI]
(ContextCreationAPI -> ContextCreationAPI)
-> (ContextCreationAPI -> ContextCreationAPI)
-> (Int -> ContextCreationAPI)
-> (ContextCreationAPI -> Int)
-> (ContextCreationAPI -> [ContextCreationAPI])
-> (ContextCreationAPI
    -> ContextCreationAPI -> [ContextCreationAPI])
-> (ContextCreationAPI
    -> ContextCreationAPI -> [ContextCreationAPI])
-> (ContextCreationAPI
    -> ContextCreationAPI
    -> ContextCreationAPI
    -> [ContextCreationAPI])
-> Enum ContextCreationAPI
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ContextCreationAPI -> ContextCreationAPI
succ :: ContextCreationAPI -> ContextCreationAPI
$cpred :: ContextCreationAPI -> ContextCreationAPI
pred :: ContextCreationAPI -> ContextCreationAPI
$ctoEnum :: Int -> ContextCreationAPI
toEnum :: Int -> ContextCreationAPI
$cfromEnum :: ContextCreationAPI -> Int
fromEnum :: ContextCreationAPI -> Int
$cenumFrom :: ContextCreationAPI -> [ContextCreationAPI]
enumFrom :: ContextCreationAPI -> [ContextCreationAPI]
$cenumFromThen :: ContextCreationAPI -> ContextCreationAPI -> [ContextCreationAPI]
enumFromThen :: ContextCreationAPI -> ContextCreationAPI -> [ContextCreationAPI]
$cenumFromTo :: ContextCreationAPI -> ContextCreationAPI -> [ContextCreationAPI]
enumFromTo :: ContextCreationAPI -> ContextCreationAPI -> [ContextCreationAPI]
$cenumFromThenTo :: ContextCreationAPI
-> ContextCreationAPI -> ContextCreationAPI -> [ContextCreationAPI]
enumFromThenTo :: ContextCreationAPI
-> ContextCreationAPI -> ContextCreationAPI -> [ContextCreationAPI]
Enum, ContextCreationAPI -> ContextCreationAPI -> Bool
(ContextCreationAPI -> ContextCreationAPI -> Bool)
-> (ContextCreationAPI -> ContextCreationAPI -> Bool)
-> Eq ContextCreationAPI
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContextCreationAPI -> ContextCreationAPI -> Bool
== :: ContextCreationAPI -> ContextCreationAPI -> Bool
$c/= :: ContextCreationAPI -> ContextCreationAPI -> Bool
/= :: ContextCreationAPI -> ContextCreationAPI -> Bool
Eq, Eq ContextCreationAPI
Eq ContextCreationAPI =>
(ContextCreationAPI -> ContextCreationAPI -> Ordering)
-> (ContextCreationAPI -> ContextCreationAPI -> Bool)
-> (ContextCreationAPI -> ContextCreationAPI -> Bool)
-> (ContextCreationAPI -> ContextCreationAPI -> Bool)
-> (ContextCreationAPI -> ContextCreationAPI -> Bool)
-> (ContextCreationAPI -> ContextCreationAPI -> ContextCreationAPI)
-> (ContextCreationAPI -> ContextCreationAPI -> ContextCreationAPI)
-> Ord ContextCreationAPI
ContextCreationAPI -> ContextCreationAPI -> Bool
ContextCreationAPI -> ContextCreationAPI -> Ordering
ContextCreationAPI -> ContextCreationAPI -> ContextCreationAPI
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
$ccompare :: ContextCreationAPI -> ContextCreationAPI -> Ordering
compare :: ContextCreationAPI -> ContextCreationAPI -> Ordering
$c< :: ContextCreationAPI -> ContextCreationAPI -> Bool
< :: ContextCreationAPI -> ContextCreationAPI -> Bool
$c<= :: ContextCreationAPI -> ContextCreationAPI -> Bool
<= :: ContextCreationAPI -> ContextCreationAPI -> Bool
$c> :: ContextCreationAPI -> ContextCreationAPI -> Bool
> :: ContextCreationAPI -> ContextCreationAPI -> Bool
$c>= :: ContextCreationAPI -> ContextCreationAPI -> Bool
>= :: ContextCreationAPI -> ContextCreationAPI -> Bool
$cmax :: ContextCreationAPI -> ContextCreationAPI -> ContextCreationAPI
max :: ContextCreationAPI -> ContextCreationAPI -> ContextCreationAPI
$cmin :: ContextCreationAPI -> ContextCreationAPI -> ContextCreationAPI
min :: ContextCreationAPI -> ContextCreationAPI -> ContextCreationAPI
Ord, ReadPrec [ContextCreationAPI]
ReadPrec ContextCreationAPI
Int -> ReadS ContextCreationAPI
ReadS [ContextCreationAPI]
(Int -> ReadS ContextCreationAPI)
-> ReadS [ContextCreationAPI]
-> ReadPrec ContextCreationAPI
-> ReadPrec [ContextCreationAPI]
-> Read ContextCreationAPI
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ContextCreationAPI
readsPrec :: Int -> ReadS ContextCreationAPI
$creadList :: ReadS [ContextCreationAPI]
readList :: ReadS [ContextCreationAPI]
$creadPrec :: ReadPrec ContextCreationAPI
readPrec :: ReadPrec ContextCreationAPI
$creadListPrec :: ReadPrec [ContextCreationAPI]
readListPrec :: ReadPrec [ContextCreationAPI]
Read, Int -> ContextCreationAPI -> ShowS
[ContextCreationAPI] -> ShowS
ContextCreationAPI -> String
(Int -> ContextCreationAPI -> ShowS)
-> (ContextCreationAPI -> String)
-> ([ContextCreationAPI] -> ShowS)
-> Show ContextCreationAPI
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContextCreationAPI -> ShowS
showsPrec :: Int -> ContextCreationAPI -> ShowS
$cshow :: ContextCreationAPI -> String
show :: ContextCreationAPI -> String
$cshowList :: [ContextCreationAPI] -> ShowS
showList :: [ContextCreationAPI] -> ShowS
Show, Typeable, (forall x. ContextCreationAPI -> Rep ContextCreationAPI x)
-> (forall x. Rep ContextCreationAPI x -> ContextCreationAPI)
-> Generic ContextCreationAPI
forall x. Rep ContextCreationAPI x -> ContextCreationAPI
forall x. ContextCreationAPI -> Rep ContextCreationAPI x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ContextCreationAPI -> Rep ContextCreationAPI x
from :: forall x. ContextCreationAPI -> Rep ContextCreationAPI x
$cto :: forall x. Rep ContextCreationAPI x -> ContextCreationAPI
to :: forall x. Rep ContextCreationAPI x -> ContextCreationAPI
Generic)

instance NFData ContextCreationAPI

-- | The context release behavior.
-- See the <http://www.glfw.org/docs/latest/window_guide.html Window Guide> for
-- more information.
--
-- Context release behaviors are described in detail by the
-- <https://www.khronos.org/registry/OpenGL/extensions/KHR/KHR_context_flush_control.txt KHR_context_flush_control>
-- extension.
data ContextReleaseBehavior
  = ContextReleaseBehavior'Any
  | ContextReleaseBehavior'None
  | ContextReleaseBehavior'Flush
  deriving (ContextReleaseBehavior
ContextReleaseBehavior
-> ContextReleaseBehavior -> Bounded ContextReleaseBehavior
forall a. a -> a -> Bounded a
$cminBound :: ContextReleaseBehavior
minBound :: ContextReleaseBehavior
$cmaxBound :: ContextReleaseBehavior
maxBound :: ContextReleaseBehavior
Bounded, Typeable ContextReleaseBehavior
Typeable ContextReleaseBehavior =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ContextReleaseBehavior
 -> c ContextReleaseBehavior)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ContextReleaseBehavior)
-> (ContextReleaseBehavior -> Constr)
-> (ContextReleaseBehavior -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ContextReleaseBehavior))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ContextReleaseBehavior))
-> ((forall b. Data b => b -> b)
    -> ContextReleaseBehavior -> ContextReleaseBehavior)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ContextReleaseBehavior
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ContextReleaseBehavior
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ContextReleaseBehavior -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ContextReleaseBehavior -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ContextReleaseBehavior -> m ContextReleaseBehavior)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ContextReleaseBehavior -> m ContextReleaseBehavior)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ContextReleaseBehavior -> m ContextReleaseBehavior)
-> Data ContextReleaseBehavior
ContextReleaseBehavior -> Constr
ContextReleaseBehavior -> DataType
(forall b. Data b => b -> b)
-> ContextReleaseBehavior -> ContextReleaseBehavior
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) -> ContextReleaseBehavior -> u
forall u.
(forall d. Data d => d -> u) -> ContextReleaseBehavior -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ContextReleaseBehavior
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ContextReleaseBehavior
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContextReleaseBehavior -> m ContextReleaseBehavior
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContextReleaseBehavior -> m ContextReleaseBehavior
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContextReleaseBehavior
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ContextReleaseBehavior
-> c ContextReleaseBehavior
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContextReleaseBehavior)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContextReleaseBehavior)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ContextReleaseBehavior
-> c ContextReleaseBehavior
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ContextReleaseBehavior
-> c ContextReleaseBehavior
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContextReleaseBehavior
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContextReleaseBehavior
$ctoConstr :: ContextReleaseBehavior -> Constr
toConstr :: ContextReleaseBehavior -> Constr
$cdataTypeOf :: ContextReleaseBehavior -> DataType
dataTypeOf :: ContextReleaseBehavior -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContextReleaseBehavior)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContextReleaseBehavior)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContextReleaseBehavior)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ContextReleaseBehavior)
$cgmapT :: (forall b. Data b => b -> b)
-> ContextReleaseBehavior -> ContextReleaseBehavior
gmapT :: (forall b. Data b => b -> b)
-> ContextReleaseBehavior -> ContextReleaseBehavior
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ContextReleaseBehavior
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ContextReleaseBehavior
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ContextReleaseBehavior
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ContextReleaseBehavior
-> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> ContextReleaseBehavior -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> ContextReleaseBehavior -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ContextReleaseBehavior -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ContextReleaseBehavior -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContextReleaseBehavior -> m ContextReleaseBehavior
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ContextReleaseBehavior -> m ContextReleaseBehavior
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContextReleaseBehavior -> m ContextReleaseBehavior
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContextReleaseBehavior -> m ContextReleaseBehavior
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContextReleaseBehavior -> m ContextReleaseBehavior
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ContextReleaseBehavior -> m ContextReleaseBehavior
Data, Int -> ContextReleaseBehavior
ContextReleaseBehavior -> Int
ContextReleaseBehavior -> [ContextReleaseBehavior]
ContextReleaseBehavior -> ContextReleaseBehavior
ContextReleaseBehavior
-> ContextReleaseBehavior -> [ContextReleaseBehavior]
ContextReleaseBehavior
-> ContextReleaseBehavior
-> ContextReleaseBehavior
-> [ContextReleaseBehavior]
(ContextReleaseBehavior -> ContextReleaseBehavior)
-> (ContextReleaseBehavior -> ContextReleaseBehavior)
-> (Int -> ContextReleaseBehavior)
-> (ContextReleaseBehavior -> Int)
-> (ContextReleaseBehavior -> [ContextReleaseBehavior])
-> (ContextReleaseBehavior
    -> ContextReleaseBehavior -> [ContextReleaseBehavior])
-> (ContextReleaseBehavior
    -> ContextReleaseBehavior -> [ContextReleaseBehavior])
-> (ContextReleaseBehavior
    -> ContextReleaseBehavior
    -> ContextReleaseBehavior
    -> [ContextReleaseBehavior])
-> Enum ContextReleaseBehavior
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ContextReleaseBehavior -> ContextReleaseBehavior
succ :: ContextReleaseBehavior -> ContextReleaseBehavior
$cpred :: ContextReleaseBehavior -> ContextReleaseBehavior
pred :: ContextReleaseBehavior -> ContextReleaseBehavior
$ctoEnum :: Int -> ContextReleaseBehavior
toEnum :: Int -> ContextReleaseBehavior
$cfromEnum :: ContextReleaseBehavior -> Int
fromEnum :: ContextReleaseBehavior -> Int
$cenumFrom :: ContextReleaseBehavior -> [ContextReleaseBehavior]
enumFrom :: ContextReleaseBehavior -> [ContextReleaseBehavior]
$cenumFromThen :: ContextReleaseBehavior
-> ContextReleaseBehavior -> [ContextReleaseBehavior]
enumFromThen :: ContextReleaseBehavior
-> ContextReleaseBehavior -> [ContextReleaseBehavior]
$cenumFromTo :: ContextReleaseBehavior
-> ContextReleaseBehavior -> [ContextReleaseBehavior]
enumFromTo :: ContextReleaseBehavior
-> ContextReleaseBehavior -> [ContextReleaseBehavior]
$cenumFromThenTo :: ContextReleaseBehavior
-> ContextReleaseBehavior
-> ContextReleaseBehavior
-> [ContextReleaseBehavior]
enumFromThenTo :: ContextReleaseBehavior
-> ContextReleaseBehavior
-> ContextReleaseBehavior
-> [ContextReleaseBehavior]
Enum, ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
(ContextReleaseBehavior -> ContextReleaseBehavior -> Bool)
-> (ContextReleaseBehavior -> ContextReleaseBehavior -> Bool)
-> Eq ContextReleaseBehavior
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
== :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
$c/= :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
/= :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
Eq, Eq ContextReleaseBehavior
Eq ContextReleaseBehavior =>
(ContextReleaseBehavior -> ContextReleaseBehavior -> Ordering)
-> (ContextReleaseBehavior -> ContextReleaseBehavior -> Bool)
-> (ContextReleaseBehavior -> ContextReleaseBehavior -> Bool)
-> (ContextReleaseBehavior -> ContextReleaseBehavior -> Bool)
-> (ContextReleaseBehavior -> ContextReleaseBehavior -> Bool)
-> (ContextReleaseBehavior
    -> ContextReleaseBehavior -> ContextReleaseBehavior)
-> (ContextReleaseBehavior
    -> ContextReleaseBehavior -> ContextReleaseBehavior)
-> Ord ContextReleaseBehavior
ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
ContextReleaseBehavior -> ContextReleaseBehavior -> Ordering
ContextReleaseBehavior
-> ContextReleaseBehavior -> ContextReleaseBehavior
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
$ccompare :: ContextReleaseBehavior -> ContextReleaseBehavior -> Ordering
compare :: ContextReleaseBehavior -> ContextReleaseBehavior -> Ordering
$c< :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
< :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
$c<= :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
<= :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
$c> :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
> :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
$c>= :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
>= :: ContextReleaseBehavior -> ContextReleaseBehavior -> Bool
$cmax :: ContextReleaseBehavior
-> ContextReleaseBehavior -> ContextReleaseBehavior
max :: ContextReleaseBehavior
-> ContextReleaseBehavior -> ContextReleaseBehavior
$cmin :: ContextReleaseBehavior
-> ContextReleaseBehavior -> ContextReleaseBehavior
min :: ContextReleaseBehavior
-> ContextReleaseBehavior -> ContextReleaseBehavior
Ord, ReadPrec [ContextReleaseBehavior]
ReadPrec ContextReleaseBehavior
Int -> ReadS ContextReleaseBehavior
ReadS [ContextReleaseBehavior]
(Int -> ReadS ContextReleaseBehavior)
-> ReadS [ContextReleaseBehavior]
-> ReadPrec ContextReleaseBehavior
-> ReadPrec [ContextReleaseBehavior]
-> Read ContextReleaseBehavior
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ContextReleaseBehavior
readsPrec :: Int -> ReadS ContextReleaseBehavior
$creadList :: ReadS [ContextReleaseBehavior]
readList :: ReadS [ContextReleaseBehavior]
$creadPrec :: ReadPrec ContextReleaseBehavior
readPrec :: ReadPrec ContextReleaseBehavior
$creadListPrec :: ReadPrec [ContextReleaseBehavior]
readListPrec :: ReadPrec [ContextReleaseBehavior]
Read, Int -> ContextReleaseBehavior -> ShowS
[ContextReleaseBehavior] -> ShowS
ContextReleaseBehavior -> String
(Int -> ContextReleaseBehavior -> ShowS)
-> (ContextReleaseBehavior -> String)
-> ([ContextReleaseBehavior] -> ShowS)
-> Show ContextReleaseBehavior
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContextReleaseBehavior -> ShowS
showsPrec :: Int -> ContextReleaseBehavior -> ShowS
$cshow :: ContextReleaseBehavior -> String
show :: ContextReleaseBehavior -> String
$cshowList :: [ContextReleaseBehavior] -> ShowS
showList :: [ContextReleaseBehavior] -> ShowS
Show, Typeable, (forall x. ContextReleaseBehavior -> Rep ContextReleaseBehavior x)
-> (forall x.
    Rep ContextReleaseBehavior x -> ContextReleaseBehavior)
-> Generic ContextReleaseBehavior
forall x. Rep ContextReleaseBehavior x -> ContextReleaseBehavior
forall x. ContextReleaseBehavior -> Rep ContextReleaseBehavior x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ContextReleaseBehavior -> Rep ContextReleaseBehavior x
from :: forall x. ContextReleaseBehavior -> Rep ContextReleaseBehavior x
$cto :: forall x. Rep ContextReleaseBehavior x -> ContextReleaseBehavior
to :: forall x. Rep ContextReleaseBehavior x -> ContextReleaseBehavior
Generic)

instance NFData ContextReleaseBehavior

--------------------------------------------------------------------------------
-- Input handling

-- | Part of the <http://www.glfw.org/docs/3.3/input.html#input_keyboard Keyboard Input> system.
data Key =
    Key'Unknown
  | Key'Space
  | Key'Apostrophe
  | Key'Comma
  | Key'Minus
  | Key'Period
  | Key'Slash
  | Key'0
  | Key'1
  | Key'2
  | Key'3
  | Key'4
  | Key'5
  | Key'6
  | Key'7
  | Key'8
  | Key'9
  | Key'Semicolon
  | Key'Equal
  | Key'A
  | Key'B
  | Key'C
  | Key'D
  | Key'E
  | Key'F
  | Key'G
  | Key'H
  | Key'I
  | Key'J
  | Key'K
  | Key'L
  | Key'M
  | Key'N
  | Key'O
  | Key'P
  | Key'Q
  | Key'R
  | Key'S
  | Key'T
  | Key'U
  | Key'V
  | Key'W
  | Key'X
  | Key'Y
  | Key'Z
  | Key'LeftBracket
  | Key'Backslash
  | Key'RightBracket
  | Key'GraveAccent
  | Key'World1
  | Key'World2
  | Key'Escape
  | Key'Enter
  | Key'Tab
  | Key'Backspace
  | Key'Insert
  | Key'Delete
  | Key'Right
  | Key'Left
  | Key'Down
  | Key'Up
  | Key'PageUp
  | Key'PageDown
  | Key'Home
  | Key'End
  | Key'CapsLock
  | Key'ScrollLock
  | Key'NumLock
  | Key'PrintScreen
  | Key'Pause
  | Key'F1
  | Key'F2
  | Key'F3
  | Key'F4
  | Key'F5
  | Key'F6
  | Key'F7
  | Key'F8
  | Key'F9
  | Key'F10
  | Key'F11
  | Key'F12
  | Key'F13
  | Key'F14
  | Key'F15
  | Key'F16
  | Key'F17
  | Key'F18
  | Key'F19
  | Key'F20
  | Key'F21
  | Key'F22
  | Key'F23
  | Key'F24
  | Key'F25
  | Key'Pad0
  | Key'Pad1
  | Key'Pad2
  | Key'Pad3
  | Key'Pad4
  | Key'Pad5
  | Key'Pad6
  | Key'Pad7
  | Key'Pad8
  | Key'Pad9
  | Key'PadDecimal
  | Key'PadDivide
  | Key'PadMultiply
  | Key'PadSubtract
  | Key'PadAdd
  | Key'PadEnter
  | Key'PadEqual
  | Key'LeftShift
  | Key'LeftControl
  | Key'LeftAlt
  | Key'LeftSuper
  | Key'RightShift
  | Key'RightControl
  | Key'RightAlt
  | Key'RightSuper
  | Key'Menu
  deriving (Key
Key -> Key -> Bounded Key
forall a. a -> a -> Bounded a
$cminBound :: Key
minBound :: Key
$cmaxBound :: Key
maxBound :: Key
Bounded, Typeable Key
Typeable Key =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Key -> c Key)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Key)
-> (Key -> Constr)
-> (Key -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Key))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Key))
-> ((forall b. Data b => b -> b) -> Key -> Key)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r)
-> (forall u. (forall d. Data d => d -> u) -> Key -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Key -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Key -> m Key)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Key -> m Key)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Key -> m Key)
-> Data Key
Key -> Constr
Key -> DataType
(forall b. Data b => b -> b) -> Key -> Key
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) -> Key -> u
forall u. (forall d. Data d => d -> u) -> Key -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Key -> m Key
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Key -> m Key
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Key
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Key -> c Key
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Key)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Key)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Key -> c Key
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Key -> c Key
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Key
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Key
$ctoConstr :: Key -> Constr
toConstr :: Key -> Constr
$cdataTypeOf :: Key -> DataType
dataTypeOf :: Key -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Key)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Key)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Key)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Key)
$cgmapT :: (forall b. Data b => b -> b) -> Key -> Key
gmapT :: (forall b. Data b => b -> b) -> Key -> Key
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Key -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Key -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Key -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Key -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Key -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Key -> m Key
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Key -> m Key
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Key -> m Key
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Key -> m Key
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Key -> m Key
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Key -> m Key
Data, Int -> Key
Key -> Int
Key -> [Key]
Key -> Key
Key -> Key -> [Key]
Key -> Key -> Key -> [Key]
(Key -> Key)
-> (Key -> Key)
-> (Int -> Key)
-> (Key -> Int)
-> (Key -> [Key])
-> (Key -> Key -> [Key])
-> (Key -> Key -> [Key])
-> (Key -> Key -> Key -> [Key])
-> Enum Key
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Key -> Key
succ :: Key -> Key
$cpred :: Key -> Key
pred :: Key -> Key
$ctoEnum :: Int -> Key
toEnum :: Int -> Key
$cfromEnum :: Key -> Int
fromEnum :: Key -> Int
$cenumFrom :: Key -> [Key]
enumFrom :: Key -> [Key]
$cenumFromThen :: Key -> Key -> [Key]
enumFromThen :: Key -> Key -> [Key]
$cenumFromTo :: Key -> Key -> [Key]
enumFromTo :: Key -> Key -> [Key]
$cenumFromThenTo :: Key -> Key -> Key -> [Key]
enumFromThenTo :: Key -> Key -> Key -> [Key]
Enum, Key -> Key -> Bool
(Key -> Key -> Bool) -> (Key -> Key -> Bool) -> Eq Key
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Key -> Key -> Bool
== :: Key -> Key -> Bool
$c/= :: Key -> Key -> Bool
/= :: Key -> Key -> Bool
Eq, Eq Key
Eq Key =>
(Key -> Key -> Ordering)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Bool)
-> (Key -> Key -> Key)
-> (Key -> Key -> Key)
-> Ord Key
Key -> Key -> Bool
Key -> Key -> Ordering
Key -> Key -> Key
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
$ccompare :: Key -> Key -> Ordering
compare :: Key -> Key -> Ordering
$c< :: Key -> Key -> Bool
< :: Key -> Key -> Bool
$c<= :: Key -> Key -> Bool
<= :: Key -> Key -> Bool
$c> :: Key -> Key -> Bool
> :: Key -> Key -> Bool
$c>= :: Key -> Key -> Bool
>= :: Key -> Key -> Bool
$cmax :: Key -> Key -> Key
max :: Key -> Key -> Key
$cmin :: Key -> Key -> Key
min :: Key -> Key -> Key
Ord, ReadPrec [Key]
ReadPrec Key
Int -> ReadS Key
ReadS [Key]
(Int -> ReadS Key)
-> ReadS [Key] -> ReadPrec Key -> ReadPrec [Key] -> Read Key
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Key
readsPrec :: Int -> ReadS Key
$creadList :: ReadS [Key]
readList :: ReadS [Key]
$creadPrec :: ReadPrec Key
readPrec :: ReadPrec Key
$creadListPrec :: ReadPrec [Key]
readListPrec :: ReadPrec [Key]
Read, Int -> Key -> ShowS
[Key] -> ShowS
Key -> String
(Int -> Key -> ShowS)
-> (Key -> String) -> ([Key] -> ShowS) -> Show Key
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Key -> ShowS
showsPrec :: Int -> Key -> ShowS
$cshow :: Key -> String
show :: Key -> String
$cshowList :: [Key] -> ShowS
showList :: [Key] -> ShowS
Show, Typeable, (forall x. Key -> Rep Key x)
-> (forall x. Rep Key x -> Key) -> Generic Key
forall x. Rep Key x -> Key
forall x. Key -> Rep Key x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Key -> Rep Key x
from :: forall x. Key -> Rep Key x
$cto :: forall x. Rep Key x -> Key
to :: forall x. Rep Key x -> Key
Generic)

instance NFData Key

-- | The state of an individual key when 'Graphics.UI.GLFW.getKey' is called.
data KeyState =
    KeyState'Pressed
  | KeyState'Released
  | KeyState'Repeating
  deriving (KeyState
KeyState -> KeyState -> Bounded KeyState
forall a. a -> a -> Bounded a
$cminBound :: KeyState
minBound :: KeyState
$cmaxBound :: KeyState
maxBound :: KeyState
Bounded, Typeable KeyState
Typeable KeyState =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> KeyState -> c KeyState)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c KeyState)
-> (KeyState -> Constr)
-> (KeyState -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c KeyState))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyState))
-> ((forall b. Data b => b -> b) -> KeyState -> KeyState)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyState -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyState -> r)
-> (forall u. (forall d. Data d => d -> u) -> KeyState -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> KeyState -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> KeyState -> m KeyState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyState -> m KeyState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyState -> m KeyState)
-> Data KeyState
KeyState -> Constr
KeyState -> DataType
(forall b. Data b => b -> b) -> KeyState -> KeyState
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) -> KeyState -> u
forall u. (forall d. Data d => d -> u) -> KeyState -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyState -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyState -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyState -> m KeyState
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyState -> m KeyState
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyState
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyState -> c KeyState
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyState)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyState)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyState -> c KeyState
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyState -> c KeyState
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyState
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyState
$ctoConstr :: KeyState -> Constr
toConstr :: KeyState -> Constr
$cdataTypeOf :: KeyState -> DataType
dataTypeOf :: KeyState -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyState)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyState)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyState)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyState)
$cgmapT :: (forall b. Data b => b -> b) -> KeyState -> KeyState
gmapT :: (forall b. Data b => b -> b) -> KeyState -> KeyState
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyState -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyState -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyState -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyState -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> KeyState -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> KeyState -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KeyState -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KeyState -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyState -> m KeyState
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyState -> m KeyState
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyState -> m KeyState
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyState -> m KeyState
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyState -> m KeyState
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyState -> m KeyState
Data, Int -> KeyState
KeyState -> Int
KeyState -> [KeyState]
KeyState -> KeyState
KeyState -> KeyState -> [KeyState]
KeyState -> KeyState -> KeyState -> [KeyState]
(KeyState -> KeyState)
-> (KeyState -> KeyState)
-> (Int -> KeyState)
-> (KeyState -> Int)
-> (KeyState -> [KeyState])
-> (KeyState -> KeyState -> [KeyState])
-> (KeyState -> KeyState -> [KeyState])
-> (KeyState -> KeyState -> KeyState -> [KeyState])
-> Enum KeyState
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: KeyState -> KeyState
succ :: KeyState -> KeyState
$cpred :: KeyState -> KeyState
pred :: KeyState -> KeyState
$ctoEnum :: Int -> KeyState
toEnum :: Int -> KeyState
$cfromEnum :: KeyState -> Int
fromEnum :: KeyState -> Int
$cenumFrom :: KeyState -> [KeyState]
enumFrom :: KeyState -> [KeyState]
$cenumFromThen :: KeyState -> KeyState -> [KeyState]
enumFromThen :: KeyState -> KeyState -> [KeyState]
$cenumFromTo :: KeyState -> KeyState -> [KeyState]
enumFromTo :: KeyState -> KeyState -> [KeyState]
$cenumFromThenTo :: KeyState -> KeyState -> KeyState -> [KeyState]
enumFromThenTo :: KeyState -> KeyState -> KeyState -> [KeyState]
Enum, KeyState -> KeyState -> Bool
(KeyState -> KeyState -> Bool)
-> (KeyState -> KeyState -> Bool) -> Eq KeyState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyState -> KeyState -> Bool
== :: KeyState -> KeyState -> Bool
$c/= :: KeyState -> KeyState -> Bool
/= :: KeyState -> KeyState -> Bool
Eq, Eq KeyState
Eq KeyState =>
(KeyState -> KeyState -> Ordering)
-> (KeyState -> KeyState -> Bool)
-> (KeyState -> KeyState -> Bool)
-> (KeyState -> KeyState -> Bool)
-> (KeyState -> KeyState -> Bool)
-> (KeyState -> KeyState -> KeyState)
-> (KeyState -> KeyState -> KeyState)
-> Ord KeyState
KeyState -> KeyState -> Bool
KeyState -> KeyState -> Ordering
KeyState -> KeyState -> KeyState
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
$ccompare :: KeyState -> KeyState -> Ordering
compare :: KeyState -> KeyState -> Ordering
$c< :: KeyState -> KeyState -> Bool
< :: KeyState -> KeyState -> Bool
$c<= :: KeyState -> KeyState -> Bool
<= :: KeyState -> KeyState -> Bool
$c> :: KeyState -> KeyState -> Bool
> :: KeyState -> KeyState -> Bool
$c>= :: KeyState -> KeyState -> Bool
>= :: KeyState -> KeyState -> Bool
$cmax :: KeyState -> KeyState -> KeyState
max :: KeyState -> KeyState -> KeyState
$cmin :: KeyState -> KeyState -> KeyState
min :: KeyState -> KeyState -> KeyState
Ord, ReadPrec [KeyState]
ReadPrec KeyState
Int -> ReadS KeyState
ReadS [KeyState]
(Int -> ReadS KeyState)
-> ReadS [KeyState]
-> ReadPrec KeyState
-> ReadPrec [KeyState]
-> Read KeyState
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS KeyState
readsPrec :: Int -> ReadS KeyState
$creadList :: ReadS [KeyState]
readList :: ReadS [KeyState]
$creadPrec :: ReadPrec KeyState
readPrec :: ReadPrec KeyState
$creadListPrec :: ReadPrec [KeyState]
readListPrec :: ReadPrec [KeyState]
Read, Int -> KeyState -> ShowS
[KeyState] -> ShowS
KeyState -> String
(Int -> KeyState -> ShowS)
-> (KeyState -> String) -> ([KeyState] -> ShowS) -> Show KeyState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyState -> ShowS
showsPrec :: Int -> KeyState -> ShowS
$cshow :: KeyState -> String
show :: KeyState -> String
$cshowList :: [KeyState] -> ShowS
showList :: [KeyState] -> ShowS
Show, Typeable, (forall x. KeyState -> Rep KeyState x)
-> (forall x. Rep KeyState x -> KeyState) -> Generic KeyState
forall x. Rep KeyState x -> KeyState
forall x. KeyState -> Rep KeyState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. KeyState -> Rep KeyState x
from :: forall x. KeyState -> Rep KeyState x
$cto :: forall x. Rep KeyState x -> KeyState
to :: forall x. Rep KeyState x -> KeyState
Generic)

instance NFData KeyState

-- | For use with the <http://www.glfw.org/docs/3.3/input.html#joystick Joystick Input> system.
data Joystick =
    Joystick'1
  | Joystick'2
  | Joystick'3
  | Joystick'4
  | Joystick'5
  | Joystick'6
  | Joystick'7
  | Joystick'8
  | Joystick'9
  | Joystick'10
  | Joystick'11
  | Joystick'12
  | Joystick'13
  | Joystick'14
  | Joystick'15
  | Joystick'16
  deriving (Joystick
Joystick -> Joystick -> Bounded Joystick
forall a. a -> a -> Bounded a
$cminBound :: Joystick
minBound :: Joystick
$cmaxBound :: Joystick
maxBound :: Joystick
Bounded, Typeable Joystick
Typeable Joystick =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Joystick -> c Joystick)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Joystick)
-> (Joystick -> Constr)
-> (Joystick -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Joystick))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Joystick))
-> ((forall b. Data b => b -> b) -> Joystick -> Joystick)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Joystick -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Joystick -> r)
-> (forall u. (forall d. Data d => d -> u) -> Joystick -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Joystick -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Joystick -> m Joystick)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Joystick -> m Joystick)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Joystick -> m Joystick)
-> Data Joystick
Joystick -> Constr
Joystick -> DataType
(forall b. Data b => b -> b) -> Joystick -> Joystick
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) -> Joystick -> u
forall u. (forall d. Data d => d -> u) -> Joystick -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Joystick -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Joystick -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Joystick -> m Joystick
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Joystick -> m Joystick
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Joystick
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Joystick -> c Joystick
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Joystick)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Joystick)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Joystick -> c Joystick
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Joystick -> c Joystick
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Joystick
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Joystick
$ctoConstr :: Joystick -> Constr
toConstr :: Joystick -> Constr
$cdataTypeOf :: Joystick -> DataType
dataTypeOf :: Joystick -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Joystick)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Joystick)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Joystick)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Joystick)
$cgmapT :: (forall b. Data b => b -> b) -> Joystick -> Joystick
gmapT :: (forall b. Data b => b -> b) -> Joystick -> Joystick
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Joystick -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Joystick -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Joystick -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Joystick -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Joystick -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Joystick -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Joystick -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Joystick -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Joystick -> m Joystick
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Joystick -> m Joystick
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Joystick -> m Joystick
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Joystick -> m Joystick
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Joystick -> m Joystick
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Joystick -> m Joystick
Data, Int -> Joystick
Joystick -> Int
Joystick -> [Joystick]
Joystick -> Joystick
Joystick -> Joystick -> [Joystick]
Joystick -> Joystick -> Joystick -> [Joystick]
(Joystick -> Joystick)
-> (Joystick -> Joystick)
-> (Int -> Joystick)
-> (Joystick -> Int)
-> (Joystick -> [Joystick])
-> (Joystick -> Joystick -> [Joystick])
-> (Joystick -> Joystick -> [Joystick])
-> (Joystick -> Joystick -> Joystick -> [Joystick])
-> Enum Joystick
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Joystick -> Joystick
succ :: Joystick -> Joystick
$cpred :: Joystick -> Joystick
pred :: Joystick -> Joystick
$ctoEnum :: Int -> Joystick
toEnum :: Int -> Joystick
$cfromEnum :: Joystick -> Int
fromEnum :: Joystick -> Int
$cenumFrom :: Joystick -> [Joystick]
enumFrom :: Joystick -> [Joystick]
$cenumFromThen :: Joystick -> Joystick -> [Joystick]
enumFromThen :: Joystick -> Joystick -> [Joystick]
$cenumFromTo :: Joystick -> Joystick -> [Joystick]
enumFromTo :: Joystick -> Joystick -> [Joystick]
$cenumFromThenTo :: Joystick -> Joystick -> Joystick -> [Joystick]
enumFromThenTo :: Joystick -> Joystick -> Joystick -> [Joystick]
Enum, Joystick -> Joystick -> Bool
(Joystick -> Joystick -> Bool)
-> (Joystick -> Joystick -> Bool) -> Eq Joystick
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Joystick -> Joystick -> Bool
== :: Joystick -> Joystick -> Bool
$c/= :: Joystick -> Joystick -> Bool
/= :: Joystick -> Joystick -> Bool
Eq, Eq Joystick
Eq Joystick =>
(Joystick -> Joystick -> Ordering)
-> (Joystick -> Joystick -> Bool)
-> (Joystick -> Joystick -> Bool)
-> (Joystick -> Joystick -> Bool)
-> (Joystick -> Joystick -> Bool)
-> (Joystick -> Joystick -> Joystick)
-> (Joystick -> Joystick -> Joystick)
-> Ord Joystick
Joystick -> Joystick -> Bool
Joystick -> Joystick -> Ordering
Joystick -> Joystick -> Joystick
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
$ccompare :: Joystick -> Joystick -> Ordering
compare :: Joystick -> Joystick -> Ordering
$c< :: Joystick -> Joystick -> Bool
< :: Joystick -> Joystick -> Bool
$c<= :: Joystick -> Joystick -> Bool
<= :: Joystick -> Joystick -> Bool
$c> :: Joystick -> Joystick -> Bool
> :: Joystick -> Joystick -> Bool
$c>= :: Joystick -> Joystick -> Bool
>= :: Joystick -> Joystick -> Bool
$cmax :: Joystick -> Joystick -> Joystick
max :: Joystick -> Joystick -> Joystick
$cmin :: Joystick -> Joystick -> Joystick
min :: Joystick -> Joystick -> Joystick
Ord, ReadPrec [Joystick]
ReadPrec Joystick
Int -> ReadS Joystick
ReadS [Joystick]
(Int -> ReadS Joystick)
-> ReadS [Joystick]
-> ReadPrec Joystick
-> ReadPrec [Joystick]
-> Read Joystick
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Joystick
readsPrec :: Int -> ReadS Joystick
$creadList :: ReadS [Joystick]
readList :: ReadS [Joystick]
$creadPrec :: ReadPrec Joystick
readPrec :: ReadPrec Joystick
$creadListPrec :: ReadPrec [Joystick]
readListPrec :: ReadPrec [Joystick]
Read, Int -> Joystick -> ShowS
[Joystick] -> ShowS
Joystick -> String
(Int -> Joystick -> ShowS)
-> (Joystick -> String) -> ([Joystick] -> ShowS) -> Show Joystick
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Joystick -> ShowS
showsPrec :: Int -> Joystick -> ShowS
$cshow :: Joystick -> String
show :: Joystick -> String
$cshowList :: [Joystick] -> ShowS
showList :: [Joystick] -> ShowS
Show, Typeable, (forall x. Joystick -> Rep Joystick x)
-> (forall x. Rep Joystick x -> Joystick) -> Generic Joystick
forall x. Rep Joystick x -> Joystick
forall x. Joystick -> Rep Joystick x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Joystick -> Rep Joystick x
from :: forall x. Joystick -> Rep Joystick x
$cto :: forall x. Rep Joystick x -> Joystick
to :: forall x. Rep Joystick x -> Joystick
Generic)

instance NFData Joystick

-- | If a given joystick button is pressed or not when
-- 'Graphics.UI.GLFW.getJoystickButtons' is called.
data JoystickButtonState =
    JoystickButtonState'Pressed
  | JoystickButtonState'Released
  deriving (JoystickButtonState
JoystickButtonState
-> JoystickButtonState -> Bounded JoystickButtonState
forall a. a -> a -> Bounded a
$cminBound :: JoystickButtonState
minBound :: JoystickButtonState
$cmaxBound :: JoystickButtonState
maxBound :: JoystickButtonState
Bounded, Typeable JoystickButtonState
Typeable JoystickButtonState =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> JoystickButtonState
 -> c JoystickButtonState)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c JoystickButtonState)
-> (JoystickButtonState -> Constr)
-> (JoystickButtonState -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c JoystickButtonState))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c JoystickButtonState))
-> ((forall b. Data b => b -> b)
    -> JoystickButtonState -> JoystickButtonState)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> JoystickButtonState -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> JoystickButtonState -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> JoystickButtonState -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> JoystickButtonState -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> JoystickButtonState -> m JoystickButtonState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> JoystickButtonState -> m JoystickButtonState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> JoystickButtonState -> m JoystickButtonState)
-> Data JoystickButtonState
JoystickButtonState -> Constr
JoystickButtonState -> DataType
(forall b. Data b => b -> b)
-> JoystickButtonState -> JoystickButtonState
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) -> JoystickButtonState -> u
forall u.
(forall d. Data d => d -> u) -> JoystickButtonState -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickButtonState -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickButtonState -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> JoystickButtonState -> m JoystickButtonState
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> JoystickButtonState -> m JoystickButtonState
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoystickButtonState
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> JoystickButtonState
-> c JoystickButtonState
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoystickButtonState)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoystickButtonState)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> JoystickButtonState
-> c JoystickButtonState
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> JoystickButtonState
-> c JoystickButtonState
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoystickButtonState
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoystickButtonState
$ctoConstr :: JoystickButtonState -> Constr
toConstr :: JoystickButtonState -> Constr
$cdataTypeOf :: JoystickButtonState -> DataType
dataTypeOf :: JoystickButtonState -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoystickButtonState)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoystickButtonState)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoystickButtonState)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoystickButtonState)
$cgmapT :: (forall b. Data b => b -> b)
-> JoystickButtonState -> JoystickButtonState
gmapT :: (forall b. Data b => b -> b)
-> JoystickButtonState -> JoystickButtonState
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickButtonState -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickButtonState -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickButtonState -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickButtonState -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> JoystickButtonState -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> JoystickButtonState -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> JoystickButtonState -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> JoystickButtonState -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> JoystickButtonState -> m JoystickButtonState
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> JoystickButtonState -> m JoystickButtonState
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> JoystickButtonState -> m JoystickButtonState
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> JoystickButtonState -> m JoystickButtonState
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> JoystickButtonState -> m JoystickButtonState
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> JoystickButtonState -> m JoystickButtonState
Data, Int -> JoystickButtonState
JoystickButtonState -> Int
JoystickButtonState -> [JoystickButtonState]
JoystickButtonState -> JoystickButtonState
JoystickButtonState -> JoystickButtonState -> [JoystickButtonState]
JoystickButtonState
-> JoystickButtonState
-> JoystickButtonState
-> [JoystickButtonState]
(JoystickButtonState -> JoystickButtonState)
-> (JoystickButtonState -> JoystickButtonState)
-> (Int -> JoystickButtonState)
-> (JoystickButtonState -> Int)
-> (JoystickButtonState -> [JoystickButtonState])
-> (JoystickButtonState
    -> JoystickButtonState -> [JoystickButtonState])
-> (JoystickButtonState
    -> JoystickButtonState -> [JoystickButtonState])
-> (JoystickButtonState
    -> JoystickButtonState
    -> JoystickButtonState
    -> [JoystickButtonState])
-> Enum JoystickButtonState
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: JoystickButtonState -> JoystickButtonState
succ :: JoystickButtonState -> JoystickButtonState
$cpred :: JoystickButtonState -> JoystickButtonState
pred :: JoystickButtonState -> JoystickButtonState
$ctoEnum :: Int -> JoystickButtonState
toEnum :: Int -> JoystickButtonState
$cfromEnum :: JoystickButtonState -> Int
fromEnum :: JoystickButtonState -> Int
$cenumFrom :: JoystickButtonState -> [JoystickButtonState]
enumFrom :: JoystickButtonState -> [JoystickButtonState]
$cenumFromThen :: JoystickButtonState -> JoystickButtonState -> [JoystickButtonState]
enumFromThen :: JoystickButtonState -> JoystickButtonState -> [JoystickButtonState]
$cenumFromTo :: JoystickButtonState -> JoystickButtonState -> [JoystickButtonState]
enumFromTo :: JoystickButtonState -> JoystickButtonState -> [JoystickButtonState]
$cenumFromThenTo :: JoystickButtonState
-> JoystickButtonState
-> JoystickButtonState
-> [JoystickButtonState]
enumFromThenTo :: JoystickButtonState
-> JoystickButtonState
-> JoystickButtonState
-> [JoystickButtonState]
Enum, JoystickButtonState -> JoystickButtonState -> Bool
(JoystickButtonState -> JoystickButtonState -> Bool)
-> (JoystickButtonState -> JoystickButtonState -> Bool)
-> Eq JoystickButtonState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JoystickButtonState -> JoystickButtonState -> Bool
== :: JoystickButtonState -> JoystickButtonState -> Bool
$c/= :: JoystickButtonState -> JoystickButtonState -> Bool
/= :: JoystickButtonState -> JoystickButtonState -> Bool
Eq, Eq JoystickButtonState
Eq JoystickButtonState =>
(JoystickButtonState -> JoystickButtonState -> Ordering)
-> (JoystickButtonState -> JoystickButtonState -> Bool)
-> (JoystickButtonState -> JoystickButtonState -> Bool)
-> (JoystickButtonState -> JoystickButtonState -> Bool)
-> (JoystickButtonState -> JoystickButtonState -> Bool)
-> (JoystickButtonState
    -> JoystickButtonState -> JoystickButtonState)
-> (JoystickButtonState
    -> JoystickButtonState -> JoystickButtonState)
-> Ord JoystickButtonState
JoystickButtonState -> JoystickButtonState -> Bool
JoystickButtonState -> JoystickButtonState -> Ordering
JoystickButtonState -> JoystickButtonState -> JoystickButtonState
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
$ccompare :: JoystickButtonState -> JoystickButtonState -> Ordering
compare :: JoystickButtonState -> JoystickButtonState -> Ordering
$c< :: JoystickButtonState -> JoystickButtonState -> Bool
< :: JoystickButtonState -> JoystickButtonState -> Bool
$c<= :: JoystickButtonState -> JoystickButtonState -> Bool
<= :: JoystickButtonState -> JoystickButtonState -> Bool
$c> :: JoystickButtonState -> JoystickButtonState -> Bool
> :: JoystickButtonState -> JoystickButtonState -> Bool
$c>= :: JoystickButtonState -> JoystickButtonState -> Bool
>= :: JoystickButtonState -> JoystickButtonState -> Bool
$cmax :: JoystickButtonState -> JoystickButtonState -> JoystickButtonState
max :: JoystickButtonState -> JoystickButtonState -> JoystickButtonState
$cmin :: JoystickButtonState -> JoystickButtonState -> JoystickButtonState
min :: JoystickButtonState -> JoystickButtonState -> JoystickButtonState
Ord, ReadPrec [JoystickButtonState]
ReadPrec JoystickButtonState
Int -> ReadS JoystickButtonState
ReadS [JoystickButtonState]
(Int -> ReadS JoystickButtonState)
-> ReadS [JoystickButtonState]
-> ReadPrec JoystickButtonState
-> ReadPrec [JoystickButtonState]
-> Read JoystickButtonState
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS JoystickButtonState
readsPrec :: Int -> ReadS JoystickButtonState
$creadList :: ReadS [JoystickButtonState]
readList :: ReadS [JoystickButtonState]
$creadPrec :: ReadPrec JoystickButtonState
readPrec :: ReadPrec JoystickButtonState
$creadListPrec :: ReadPrec [JoystickButtonState]
readListPrec :: ReadPrec [JoystickButtonState]
Read, Int -> JoystickButtonState -> ShowS
[JoystickButtonState] -> ShowS
JoystickButtonState -> String
(Int -> JoystickButtonState -> ShowS)
-> (JoystickButtonState -> String)
-> ([JoystickButtonState] -> ShowS)
-> Show JoystickButtonState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JoystickButtonState -> ShowS
showsPrec :: Int -> JoystickButtonState -> ShowS
$cshow :: JoystickButtonState -> String
show :: JoystickButtonState -> String
$cshowList :: [JoystickButtonState] -> ShowS
showList :: [JoystickButtonState] -> ShowS
Show, Typeable, (forall x. JoystickButtonState -> Rep JoystickButtonState x)
-> (forall x. Rep JoystickButtonState x -> JoystickButtonState)
-> Generic JoystickButtonState
forall x. Rep JoystickButtonState x -> JoystickButtonState
forall x. JoystickButtonState -> Rep JoystickButtonState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JoystickButtonState -> Rep JoystickButtonState x
from :: forall x. JoystickButtonState -> Rep JoystickButtonState x
$cto :: forall x. Rep JoystickButtonState x -> JoystickButtonState
to :: forall x. Rep JoystickButtonState x -> JoystickButtonState
Generic)

instance NFData JoystickButtonState

-- | Part of the t'Graphics.UI.GLFW.JoystickCallback', for when a monitor gets
-- connected or disconnected.
data JoystickState
  = JoystickState'Connected
  | JoystickState'Disconnected
  deriving (JoystickState
JoystickState -> JoystickState -> Bounded JoystickState
forall a. a -> a -> Bounded a
$cminBound :: JoystickState
minBound :: JoystickState
$cmaxBound :: JoystickState
maxBound :: JoystickState
Bounded, Typeable JoystickState
Typeable JoystickState =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> JoystickState -> c JoystickState)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c JoystickState)
-> (JoystickState -> Constr)
-> (JoystickState -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c JoystickState))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c JoystickState))
-> ((forall b. Data b => b -> b) -> JoystickState -> JoystickState)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> JoystickState -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> JoystickState -> r)
-> (forall u. (forall d. Data d => d -> u) -> JoystickState -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> JoystickState -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> JoystickState -> m JoystickState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> JoystickState -> m JoystickState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> JoystickState -> m JoystickState)
-> Data JoystickState
JoystickState -> Constr
JoystickState -> DataType
(forall b. Data b => b -> b) -> JoystickState -> JoystickState
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) -> JoystickState -> u
forall u. (forall d. Data d => d -> u) -> JoystickState -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickState -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickState -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JoystickState -> m JoystickState
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoystickState -> m JoystickState
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoystickState
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoystickState -> c JoystickState
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoystickState)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoystickState)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoystickState -> c JoystickState
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoystickState -> c JoystickState
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoystickState
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoystickState
$ctoConstr :: JoystickState -> Constr
toConstr :: JoystickState -> Constr
$cdataTypeOf :: JoystickState -> DataType
dataTypeOf :: JoystickState -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoystickState)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoystickState)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoystickState)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoystickState)
$cgmapT :: (forall b. Data b => b -> b) -> JoystickState -> JoystickState
gmapT :: (forall b. Data b => b -> b) -> JoystickState -> JoystickState
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickState -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickState -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickState -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickState -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> JoystickState -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> JoystickState -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JoystickState -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> JoystickState -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JoystickState -> m JoystickState
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> JoystickState -> m JoystickState
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoystickState -> m JoystickState
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoystickState -> m JoystickState
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoystickState -> m JoystickState
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> JoystickState -> m JoystickState
Data, Int -> JoystickState
JoystickState -> Int
JoystickState -> [JoystickState]
JoystickState -> JoystickState
JoystickState -> JoystickState -> [JoystickState]
JoystickState -> JoystickState -> JoystickState -> [JoystickState]
(JoystickState -> JoystickState)
-> (JoystickState -> JoystickState)
-> (Int -> JoystickState)
-> (JoystickState -> Int)
-> (JoystickState -> [JoystickState])
-> (JoystickState -> JoystickState -> [JoystickState])
-> (JoystickState -> JoystickState -> [JoystickState])
-> (JoystickState
    -> JoystickState -> JoystickState -> [JoystickState])
-> Enum JoystickState
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: JoystickState -> JoystickState
succ :: JoystickState -> JoystickState
$cpred :: JoystickState -> JoystickState
pred :: JoystickState -> JoystickState
$ctoEnum :: Int -> JoystickState
toEnum :: Int -> JoystickState
$cfromEnum :: JoystickState -> Int
fromEnum :: JoystickState -> Int
$cenumFrom :: JoystickState -> [JoystickState]
enumFrom :: JoystickState -> [JoystickState]
$cenumFromThen :: JoystickState -> JoystickState -> [JoystickState]
enumFromThen :: JoystickState -> JoystickState -> [JoystickState]
$cenumFromTo :: JoystickState -> JoystickState -> [JoystickState]
enumFromTo :: JoystickState -> JoystickState -> [JoystickState]
$cenumFromThenTo :: JoystickState -> JoystickState -> JoystickState -> [JoystickState]
enumFromThenTo :: JoystickState -> JoystickState -> JoystickState -> [JoystickState]
Enum, JoystickState -> JoystickState -> Bool
(JoystickState -> JoystickState -> Bool)
-> (JoystickState -> JoystickState -> Bool) -> Eq JoystickState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JoystickState -> JoystickState -> Bool
== :: JoystickState -> JoystickState -> Bool
$c/= :: JoystickState -> JoystickState -> Bool
/= :: JoystickState -> JoystickState -> Bool
Eq, Eq JoystickState
Eq JoystickState =>
(JoystickState -> JoystickState -> Ordering)
-> (JoystickState -> JoystickState -> Bool)
-> (JoystickState -> JoystickState -> Bool)
-> (JoystickState -> JoystickState -> Bool)
-> (JoystickState -> JoystickState -> Bool)
-> (JoystickState -> JoystickState -> JoystickState)
-> (JoystickState -> JoystickState -> JoystickState)
-> Ord JoystickState
JoystickState -> JoystickState -> Bool
JoystickState -> JoystickState -> Ordering
JoystickState -> JoystickState -> JoystickState
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
$ccompare :: JoystickState -> JoystickState -> Ordering
compare :: JoystickState -> JoystickState -> Ordering
$c< :: JoystickState -> JoystickState -> Bool
< :: JoystickState -> JoystickState -> Bool
$c<= :: JoystickState -> JoystickState -> Bool
<= :: JoystickState -> JoystickState -> Bool
$c> :: JoystickState -> JoystickState -> Bool
> :: JoystickState -> JoystickState -> Bool
$c>= :: JoystickState -> JoystickState -> Bool
>= :: JoystickState -> JoystickState -> Bool
$cmax :: JoystickState -> JoystickState -> JoystickState
max :: JoystickState -> JoystickState -> JoystickState
$cmin :: JoystickState -> JoystickState -> JoystickState
min :: JoystickState -> JoystickState -> JoystickState
Ord, ReadPrec [JoystickState]
ReadPrec JoystickState
Int -> ReadS JoystickState
ReadS [JoystickState]
(Int -> ReadS JoystickState)
-> ReadS [JoystickState]
-> ReadPrec JoystickState
-> ReadPrec [JoystickState]
-> Read JoystickState
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS JoystickState
readsPrec :: Int -> ReadS JoystickState
$creadList :: ReadS [JoystickState]
readList :: ReadS [JoystickState]
$creadPrec :: ReadPrec JoystickState
readPrec :: ReadPrec JoystickState
$creadListPrec :: ReadPrec [JoystickState]
readListPrec :: ReadPrec [JoystickState]
Read, Int -> JoystickState -> ShowS
[JoystickState] -> ShowS
JoystickState -> String
(Int -> JoystickState -> ShowS)
-> (JoystickState -> String)
-> ([JoystickState] -> ShowS)
-> Show JoystickState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JoystickState -> ShowS
showsPrec :: Int -> JoystickState -> ShowS
$cshow :: JoystickState -> String
show :: JoystickState -> String
$cshowList :: [JoystickState] -> ShowS
showList :: [JoystickState] -> ShowS
Show, Typeable, (forall x. JoystickState -> Rep JoystickState x)
-> (forall x. Rep JoystickState x -> JoystickState)
-> Generic JoystickState
forall x. Rep JoystickState x -> JoystickState
forall x. JoystickState -> Rep JoystickState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JoystickState -> Rep JoystickState x
from :: forall x. JoystickState -> Rep JoystickState x
$cto :: forall x. Rep JoystickState x -> JoystickState
to :: forall x. Rep JoystickState x -> JoystickState
Generic)

instance NFData JoystickState

-- | The valid hat states of a joystick. Part of the
-- <https://www.glfw.org/docs/3.3/input_guide.html#joystick_hat joystick hat>
-- system.
data JoystickHatState
  = JoystickHatState'Centered
  | JoystickHatState'Up
  | JoystickHatState'Right
  | JoystickHatState'Down
  | JoystickHatState'Left
  | JoystickHatState'RightUp
  | JoystickHatState'RightDown
  | JoystickHatState'LeftUp
  | JoystickHatState'LeftDown
  deriving (JoystickHatState
JoystickHatState -> JoystickHatState -> Bounded JoystickHatState
forall a. a -> a -> Bounded a
$cminBound :: JoystickHatState
minBound :: JoystickHatState
$cmaxBound :: JoystickHatState
maxBound :: JoystickHatState
Bounded, Typeable JoystickHatState
Typeable JoystickHatState =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> JoystickHatState -> c JoystickHatState)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c JoystickHatState)
-> (JoystickHatState -> Constr)
-> (JoystickHatState -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c JoystickHatState))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c JoystickHatState))
-> ((forall b. Data b => b -> b)
    -> JoystickHatState -> JoystickHatState)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> JoystickHatState -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> JoystickHatState -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> JoystickHatState -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> JoystickHatState -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> JoystickHatState -> m JoystickHatState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> JoystickHatState -> m JoystickHatState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> JoystickHatState -> m JoystickHatState)
-> Data JoystickHatState
JoystickHatState -> Constr
JoystickHatState -> DataType
(forall b. Data b => b -> b)
-> JoystickHatState -> JoystickHatState
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) -> JoystickHatState -> u
forall u. (forall d. Data d => d -> u) -> JoystickHatState -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickHatState -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickHatState -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> JoystickHatState -> m JoystickHatState
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> JoystickHatState -> m JoystickHatState
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoystickHatState
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoystickHatState -> c JoystickHatState
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoystickHatState)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoystickHatState)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoystickHatState -> c JoystickHatState
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> JoystickHatState -> c JoystickHatState
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoystickHatState
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c JoystickHatState
$ctoConstr :: JoystickHatState -> Constr
toConstr :: JoystickHatState -> Constr
$cdataTypeOf :: JoystickHatState -> DataType
dataTypeOf :: JoystickHatState -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoystickHatState)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c JoystickHatState)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoystickHatState)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c JoystickHatState)
$cgmapT :: (forall b. Data b => b -> b)
-> JoystickHatState -> JoystickHatState
gmapT :: (forall b. Data b => b -> b)
-> JoystickHatState -> JoystickHatState
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickHatState -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickHatState -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickHatState -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> JoystickHatState -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> JoystickHatState -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> JoystickHatState -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> JoystickHatState -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> JoystickHatState -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> JoystickHatState -> m JoystickHatState
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> JoystickHatState -> m JoystickHatState
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> JoystickHatState -> m JoystickHatState
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> JoystickHatState -> m JoystickHatState
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> JoystickHatState -> m JoystickHatState
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> JoystickHatState -> m JoystickHatState
Data, Int -> JoystickHatState
JoystickHatState -> Int
JoystickHatState -> [JoystickHatState]
JoystickHatState -> JoystickHatState
JoystickHatState -> JoystickHatState -> [JoystickHatState]
JoystickHatState
-> JoystickHatState -> JoystickHatState -> [JoystickHatState]
(JoystickHatState -> JoystickHatState)
-> (JoystickHatState -> JoystickHatState)
-> (Int -> JoystickHatState)
-> (JoystickHatState -> Int)
-> (JoystickHatState -> [JoystickHatState])
-> (JoystickHatState -> JoystickHatState -> [JoystickHatState])
-> (JoystickHatState -> JoystickHatState -> [JoystickHatState])
-> (JoystickHatState
    -> JoystickHatState -> JoystickHatState -> [JoystickHatState])
-> Enum JoystickHatState
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: JoystickHatState -> JoystickHatState
succ :: JoystickHatState -> JoystickHatState
$cpred :: JoystickHatState -> JoystickHatState
pred :: JoystickHatState -> JoystickHatState
$ctoEnum :: Int -> JoystickHatState
toEnum :: Int -> JoystickHatState
$cfromEnum :: JoystickHatState -> Int
fromEnum :: JoystickHatState -> Int
$cenumFrom :: JoystickHatState -> [JoystickHatState]
enumFrom :: JoystickHatState -> [JoystickHatState]
$cenumFromThen :: JoystickHatState -> JoystickHatState -> [JoystickHatState]
enumFromThen :: JoystickHatState -> JoystickHatState -> [JoystickHatState]
$cenumFromTo :: JoystickHatState -> JoystickHatState -> [JoystickHatState]
enumFromTo :: JoystickHatState -> JoystickHatState -> [JoystickHatState]
$cenumFromThenTo :: JoystickHatState
-> JoystickHatState -> JoystickHatState -> [JoystickHatState]
enumFromThenTo :: JoystickHatState
-> JoystickHatState -> JoystickHatState -> [JoystickHatState]
Enum, JoystickHatState -> JoystickHatState -> Bool
(JoystickHatState -> JoystickHatState -> Bool)
-> (JoystickHatState -> JoystickHatState -> Bool)
-> Eq JoystickHatState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JoystickHatState -> JoystickHatState -> Bool
== :: JoystickHatState -> JoystickHatState -> Bool
$c/= :: JoystickHatState -> JoystickHatState -> Bool
/= :: JoystickHatState -> JoystickHatState -> Bool
Eq, Eq JoystickHatState
Eq JoystickHatState =>
(JoystickHatState -> JoystickHatState -> Ordering)
-> (JoystickHatState -> JoystickHatState -> Bool)
-> (JoystickHatState -> JoystickHatState -> Bool)
-> (JoystickHatState -> JoystickHatState -> Bool)
-> (JoystickHatState -> JoystickHatState -> Bool)
-> (JoystickHatState -> JoystickHatState -> JoystickHatState)
-> (JoystickHatState -> JoystickHatState -> JoystickHatState)
-> Ord JoystickHatState
JoystickHatState -> JoystickHatState -> Bool
JoystickHatState -> JoystickHatState -> Ordering
JoystickHatState -> JoystickHatState -> JoystickHatState
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
$ccompare :: JoystickHatState -> JoystickHatState -> Ordering
compare :: JoystickHatState -> JoystickHatState -> Ordering
$c< :: JoystickHatState -> JoystickHatState -> Bool
< :: JoystickHatState -> JoystickHatState -> Bool
$c<= :: JoystickHatState -> JoystickHatState -> Bool
<= :: JoystickHatState -> JoystickHatState -> Bool
$c> :: JoystickHatState -> JoystickHatState -> Bool
> :: JoystickHatState -> JoystickHatState -> Bool
$c>= :: JoystickHatState -> JoystickHatState -> Bool
>= :: JoystickHatState -> JoystickHatState -> Bool
$cmax :: JoystickHatState -> JoystickHatState -> JoystickHatState
max :: JoystickHatState -> JoystickHatState -> JoystickHatState
$cmin :: JoystickHatState -> JoystickHatState -> JoystickHatState
min :: JoystickHatState -> JoystickHatState -> JoystickHatState
Ord, ReadPrec [JoystickHatState]
ReadPrec JoystickHatState
Int -> ReadS JoystickHatState
ReadS [JoystickHatState]
(Int -> ReadS JoystickHatState)
-> ReadS [JoystickHatState]
-> ReadPrec JoystickHatState
-> ReadPrec [JoystickHatState]
-> Read JoystickHatState
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS JoystickHatState
readsPrec :: Int -> ReadS JoystickHatState
$creadList :: ReadS [JoystickHatState]
readList :: ReadS [JoystickHatState]
$creadPrec :: ReadPrec JoystickHatState
readPrec :: ReadPrec JoystickHatState
$creadListPrec :: ReadPrec [JoystickHatState]
readListPrec :: ReadPrec [JoystickHatState]
Read, Int -> JoystickHatState -> ShowS
[JoystickHatState] -> ShowS
JoystickHatState -> String
(Int -> JoystickHatState -> ShowS)
-> (JoystickHatState -> String)
-> ([JoystickHatState] -> ShowS)
-> Show JoystickHatState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JoystickHatState -> ShowS
showsPrec :: Int -> JoystickHatState -> ShowS
$cshow :: JoystickHatState -> String
show :: JoystickHatState -> String
$cshowList :: [JoystickHatState] -> ShowS
showList :: [JoystickHatState] -> ShowS
Show, Typeable, (forall x. JoystickHatState -> Rep JoystickHatState x)
-> (forall x. Rep JoystickHatState x -> JoystickHatState)
-> Generic JoystickHatState
forall x. Rep JoystickHatState x -> JoystickHatState
forall x. JoystickHatState -> Rep JoystickHatState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. JoystickHatState -> Rep JoystickHatState x
from :: forall x. JoystickHatState -> Rep JoystickHatState x
$cto :: forall x. Rep JoystickHatState x -> JoystickHatState
to :: forall x. Rep JoystickHatState x -> JoystickHatState
Generic)

instance NFData JoystickHatState

-- | Part of the <http://www.Graphics.UI.GLFW.org/docs/3.3/input.html#input_mouse Mouse Input> system.
data MouseButton =
    MouseButton'1
  | MouseButton'2
  | MouseButton'3
  | MouseButton'4
  | MouseButton'5
  | MouseButton'6
  | MouseButton'7
  | MouseButton'8
  deriving (MouseButton
MouseButton -> MouseButton -> Bounded MouseButton
forall a. a -> a -> Bounded a
$cminBound :: MouseButton
minBound :: MouseButton
$cmaxBound :: MouseButton
maxBound :: MouseButton
Bounded, Typeable MouseButton
Typeable MouseButton =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MouseButton -> c MouseButton)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MouseButton)
-> (MouseButton -> Constr)
-> (MouseButton -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MouseButton))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MouseButton))
-> ((forall b. Data b => b -> b) -> MouseButton -> MouseButton)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MouseButton -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MouseButton -> r)
-> (forall u. (forall d. Data d => d -> u) -> MouseButton -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MouseButton -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MouseButton -> m MouseButton)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MouseButton -> m MouseButton)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MouseButton -> m MouseButton)
-> Data MouseButton
MouseButton -> Constr
MouseButton -> DataType
(forall b. Data b => b -> b) -> MouseButton -> MouseButton
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) -> MouseButton -> u
forall u. (forall d. Data d => d -> u) -> MouseButton -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButton -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButton -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MouseButton -> m MouseButton
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MouseButton -> m MouseButton
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MouseButton
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MouseButton -> c MouseButton
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MouseButton)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MouseButton)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MouseButton -> c MouseButton
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MouseButton -> c MouseButton
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MouseButton
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MouseButton
$ctoConstr :: MouseButton -> Constr
toConstr :: MouseButton -> Constr
$cdataTypeOf :: MouseButton -> DataType
dataTypeOf :: MouseButton -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MouseButton)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MouseButton)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MouseButton)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MouseButton)
$cgmapT :: (forall b. Data b => b -> b) -> MouseButton -> MouseButton
gmapT :: (forall b. Data b => b -> b) -> MouseButton -> MouseButton
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButton -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButton -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButton -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButton -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MouseButton -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MouseButton -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MouseButton -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MouseButton -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MouseButton -> m MouseButton
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MouseButton -> m MouseButton
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MouseButton -> m MouseButton
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MouseButton -> m MouseButton
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MouseButton -> m MouseButton
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MouseButton -> m MouseButton
Data, Int -> MouseButton
MouseButton -> Int
MouseButton -> [MouseButton]
MouseButton -> MouseButton
MouseButton -> MouseButton -> [MouseButton]
MouseButton -> MouseButton -> MouseButton -> [MouseButton]
(MouseButton -> MouseButton)
-> (MouseButton -> MouseButton)
-> (Int -> MouseButton)
-> (MouseButton -> Int)
-> (MouseButton -> [MouseButton])
-> (MouseButton -> MouseButton -> [MouseButton])
-> (MouseButton -> MouseButton -> [MouseButton])
-> (MouseButton -> MouseButton -> MouseButton -> [MouseButton])
-> Enum MouseButton
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: MouseButton -> MouseButton
succ :: MouseButton -> MouseButton
$cpred :: MouseButton -> MouseButton
pred :: MouseButton -> MouseButton
$ctoEnum :: Int -> MouseButton
toEnum :: Int -> MouseButton
$cfromEnum :: MouseButton -> Int
fromEnum :: MouseButton -> Int
$cenumFrom :: MouseButton -> [MouseButton]
enumFrom :: MouseButton -> [MouseButton]
$cenumFromThen :: MouseButton -> MouseButton -> [MouseButton]
enumFromThen :: MouseButton -> MouseButton -> [MouseButton]
$cenumFromTo :: MouseButton -> MouseButton -> [MouseButton]
enumFromTo :: MouseButton -> MouseButton -> [MouseButton]
$cenumFromThenTo :: MouseButton -> MouseButton -> MouseButton -> [MouseButton]
enumFromThenTo :: MouseButton -> MouseButton -> MouseButton -> [MouseButton]
Enum, MouseButton -> MouseButton -> Bool
(MouseButton -> MouseButton -> Bool)
-> (MouseButton -> MouseButton -> Bool) -> Eq MouseButton
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MouseButton -> MouseButton -> Bool
== :: MouseButton -> MouseButton -> Bool
$c/= :: MouseButton -> MouseButton -> Bool
/= :: MouseButton -> MouseButton -> Bool
Eq, Eq MouseButton
Eq MouseButton =>
(MouseButton -> MouseButton -> Ordering)
-> (MouseButton -> MouseButton -> Bool)
-> (MouseButton -> MouseButton -> Bool)
-> (MouseButton -> MouseButton -> Bool)
-> (MouseButton -> MouseButton -> Bool)
-> (MouseButton -> MouseButton -> MouseButton)
-> (MouseButton -> MouseButton -> MouseButton)
-> Ord MouseButton
MouseButton -> MouseButton -> Bool
MouseButton -> MouseButton -> Ordering
MouseButton -> MouseButton -> MouseButton
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
$ccompare :: MouseButton -> MouseButton -> Ordering
compare :: MouseButton -> MouseButton -> Ordering
$c< :: MouseButton -> MouseButton -> Bool
< :: MouseButton -> MouseButton -> Bool
$c<= :: MouseButton -> MouseButton -> Bool
<= :: MouseButton -> MouseButton -> Bool
$c> :: MouseButton -> MouseButton -> Bool
> :: MouseButton -> MouseButton -> Bool
$c>= :: MouseButton -> MouseButton -> Bool
>= :: MouseButton -> MouseButton -> Bool
$cmax :: MouseButton -> MouseButton -> MouseButton
max :: MouseButton -> MouseButton -> MouseButton
$cmin :: MouseButton -> MouseButton -> MouseButton
min :: MouseButton -> MouseButton -> MouseButton
Ord, ReadPrec [MouseButton]
ReadPrec MouseButton
Int -> ReadS MouseButton
ReadS [MouseButton]
(Int -> ReadS MouseButton)
-> ReadS [MouseButton]
-> ReadPrec MouseButton
-> ReadPrec [MouseButton]
-> Read MouseButton
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MouseButton
readsPrec :: Int -> ReadS MouseButton
$creadList :: ReadS [MouseButton]
readList :: ReadS [MouseButton]
$creadPrec :: ReadPrec MouseButton
readPrec :: ReadPrec MouseButton
$creadListPrec :: ReadPrec [MouseButton]
readListPrec :: ReadPrec [MouseButton]
Read, Int -> MouseButton -> ShowS
[MouseButton] -> ShowS
MouseButton -> String
(Int -> MouseButton -> ShowS)
-> (MouseButton -> String)
-> ([MouseButton] -> ShowS)
-> Show MouseButton
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MouseButton -> ShowS
showsPrec :: Int -> MouseButton -> ShowS
$cshow :: MouseButton -> String
show :: MouseButton -> String
$cshowList :: [MouseButton] -> ShowS
showList :: [MouseButton] -> ShowS
Show, Typeable, (forall x. MouseButton -> Rep MouseButton x)
-> (forall x. Rep MouseButton x -> MouseButton)
-> Generic MouseButton
forall x. Rep MouseButton x -> MouseButton
forall x. MouseButton -> Rep MouseButton x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MouseButton -> Rep MouseButton x
from :: forall x. MouseButton -> Rep MouseButton x
$cto :: forall x. Rep MouseButton x -> MouseButton
to :: forall x. Rep MouseButton x -> MouseButton
Generic)

instance NFData MouseButton

-- | If the mouse button is pressed or not when 'Graphics.UI.GLFW.getMouseButton' is
-- called.
data MouseButtonState =
    MouseButtonState'Pressed
  | MouseButtonState'Released
  deriving (MouseButtonState
MouseButtonState -> MouseButtonState -> Bounded MouseButtonState
forall a. a -> a -> Bounded a
$cminBound :: MouseButtonState
minBound :: MouseButtonState
$cmaxBound :: MouseButtonState
maxBound :: MouseButtonState
Bounded, Typeable MouseButtonState
Typeable MouseButtonState =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MouseButtonState -> c MouseButtonState)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MouseButtonState)
-> (MouseButtonState -> Constr)
-> (MouseButtonState -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MouseButtonState))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MouseButtonState))
-> ((forall b. Data b => b -> b)
    -> MouseButtonState -> MouseButtonState)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MouseButtonState -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MouseButtonState -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> MouseButtonState -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MouseButtonState -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MouseButtonState -> m MouseButtonState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MouseButtonState -> m MouseButtonState)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MouseButtonState -> m MouseButtonState)
-> Data MouseButtonState
MouseButtonState -> Constr
MouseButtonState -> DataType
(forall b. Data b => b -> b)
-> MouseButtonState -> MouseButtonState
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) -> MouseButtonState -> u
forall u. (forall d. Data d => d -> u) -> MouseButtonState -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButtonState -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButtonState -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MouseButtonState -> m MouseButtonState
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MouseButtonState -> m MouseButtonState
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MouseButtonState
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MouseButtonState -> c MouseButtonState
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MouseButtonState)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MouseButtonState)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MouseButtonState -> c MouseButtonState
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MouseButtonState -> c MouseButtonState
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MouseButtonState
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MouseButtonState
$ctoConstr :: MouseButtonState -> Constr
toConstr :: MouseButtonState -> Constr
$cdataTypeOf :: MouseButtonState -> DataType
dataTypeOf :: MouseButtonState -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MouseButtonState)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MouseButtonState)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MouseButtonState)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MouseButtonState)
$cgmapT :: (forall b. Data b => b -> b)
-> MouseButtonState -> MouseButtonState
gmapT :: (forall b. Data b => b -> b)
-> MouseButtonState -> MouseButtonState
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButtonState -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButtonState -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButtonState -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MouseButtonState -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MouseButtonState -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MouseButtonState -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MouseButtonState -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MouseButtonState -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MouseButtonState -> m MouseButtonState
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MouseButtonState -> m MouseButtonState
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MouseButtonState -> m MouseButtonState
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MouseButtonState -> m MouseButtonState
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MouseButtonState -> m MouseButtonState
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MouseButtonState -> m MouseButtonState
Data, Int -> MouseButtonState
MouseButtonState -> Int
MouseButtonState -> [MouseButtonState]
MouseButtonState -> MouseButtonState
MouseButtonState -> MouseButtonState -> [MouseButtonState]
MouseButtonState
-> MouseButtonState -> MouseButtonState -> [MouseButtonState]
(MouseButtonState -> MouseButtonState)
-> (MouseButtonState -> MouseButtonState)
-> (Int -> MouseButtonState)
-> (MouseButtonState -> Int)
-> (MouseButtonState -> [MouseButtonState])
-> (MouseButtonState -> MouseButtonState -> [MouseButtonState])
-> (MouseButtonState -> MouseButtonState -> [MouseButtonState])
-> (MouseButtonState
    -> MouseButtonState -> MouseButtonState -> [MouseButtonState])
-> Enum MouseButtonState
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: MouseButtonState -> MouseButtonState
succ :: MouseButtonState -> MouseButtonState
$cpred :: MouseButtonState -> MouseButtonState
pred :: MouseButtonState -> MouseButtonState
$ctoEnum :: Int -> MouseButtonState
toEnum :: Int -> MouseButtonState
$cfromEnum :: MouseButtonState -> Int
fromEnum :: MouseButtonState -> Int
$cenumFrom :: MouseButtonState -> [MouseButtonState]
enumFrom :: MouseButtonState -> [MouseButtonState]
$cenumFromThen :: MouseButtonState -> MouseButtonState -> [MouseButtonState]
enumFromThen :: MouseButtonState -> MouseButtonState -> [MouseButtonState]
$cenumFromTo :: MouseButtonState -> MouseButtonState -> [MouseButtonState]
enumFromTo :: MouseButtonState -> MouseButtonState -> [MouseButtonState]
$cenumFromThenTo :: MouseButtonState
-> MouseButtonState -> MouseButtonState -> [MouseButtonState]
enumFromThenTo :: MouseButtonState
-> MouseButtonState -> MouseButtonState -> [MouseButtonState]
Enum, MouseButtonState -> MouseButtonState -> Bool
(MouseButtonState -> MouseButtonState -> Bool)
-> (MouseButtonState -> MouseButtonState -> Bool)
-> Eq MouseButtonState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MouseButtonState -> MouseButtonState -> Bool
== :: MouseButtonState -> MouseButtonState -> Bool
$c/= :: MouseButtonState -> MouseButtonState -> Bool
/= :: MouseButtonState -> MouseButtonState -> Bool
Eq, Eq MouseButtonState
Eq MouseButtonState =>
(MouseButtonState -> MouseButtonState -> Ordering)
-> (MouseButtonState -> MouseButtonState -> Bool)
-> (MouseButtonState -> MouseButtonState -> Bool)
-> (MouseButtonState -> MouseButtonState -> Bool)
-> (MouseButtonState -> MouseButtonState -> Bool)
-> (MouseButtonState -> MouseButtonState -> MouseButtonState)
-> (MouseButtonState -> MouseButtonState -> MouseButtonState)
-> Ord MouseButtonState
MouseButtonState -> MouseButtonState -> Bool
MouseButtonState -> MouseButtonState -> Ordering
MouseButtonState -> MouseButtonState -> MouseButtonState
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
$ccompare :: MouseButtonState -> MouseButtonState -> Ordering
compare :: MouseButtonState -> MouseButtonState -> Ordering
$c< :: MouseButtonState -> MouseButtonState -> Bool
< :: MouseButtonState -> MouseButtonState -> Bool
$c<= :: MouseButtonState -> MouseButtonState -> Bool
<= :: MouseButtonState -> MouseButtonState -> Bool
$c> :: MouseButtonState -> MouseButtonState -> Bool
> :: MouseButtonState -> MouseButtonState -> Bool
$c>= :: MouseButtonState -> MouseButtonState -> Bool
>= :: MouseButtonState -> MouseButtonState -> Bool
$cmax :: MouseButtonState -> MouseButtonState -> MouseButtonState
max :: MouseButtonState -> MouseButtonState -> MouseButtonState
$cmin :: MouseButtonState -> MouseButtonState -> MouseButtonState
min :: MouseButtonState -> MouseButtonState -> MouseButtonState
Ord, ReadPrec [MouseButtonState]
ReadPrec MouseButtonState
Int -> ReadS MouseButtonState
ReadS [MouseButtonState]
(Int -> ReadS MouseButtonState)
-> ReadS [MouseButtonState]
-> ReadPrec MouseButtonState
-> ReadPrec [MouseButtonState]
-> Read MouseButtonState
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MouseButtonState
readsPrec :: Int -> ReadS MouseButtonState
$creadList :: ReadS [MouseButtonState]
readList :: ReadS [MouseButtonState]
$creadPrec :: ReadPrec MouseButtonState
readPrec :: ReadPrec MouseButtonState
$creadListPrec :: ReadPrec [MouseButtonState]
readListPrec :: ReadPrec [MouseButtonState]
Read, Int -> MouseButtonState -> ShowS
[MouseButtonState] -> ShowS
MouseButtonState -> String
(Int -> MouseButtonState -> ShowS)
-> (MouseButtonState -> String)
-> ([MouseButtonState] -> ShowS)
-> Show MouseButtonState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MouseButtonState -> ShowS
showsPrec :: Int -> MouseButtonState -> ShowS
$cshow :: MouseButtonState -> String
show :: MouseButtonState -> String
$cshowList :: [MouseButtonState] -> ShowS
showList :: [MouseButtonState] -> ShowS
Show, Typeable, (forall x. MouseButtonState -> Rep MouseButtonState x)
-> (forall x. Rep MouseButtonState x -> MouseButtonState)
-> Generic MouseButtonState
forall x. Rep MouseButtonState x -> MouseButtonState
forall x. MouseButtonState -> Rep MouseButtonState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MouseButtonState -> Rep MouseButtonState x
from :: forall x. MouseButtonState -> Rep MouseButtonState x
$cto :: forall x. Rep MouseButtonState x -> MouseButtonState
to :: forall x. Rep MouseButtonState x -> MouseButtonState
Generic)

instance NFData MouseButtonState

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

instance NFData CursorState

-- | Allows for special forms of mouse input.
-- See <http://www.glfw.org/docs/3.3/input.html#cursor_mode Cursor Modes>
data CursorInputMode =
    CursorInputMode'Normal
  | CursorInputMode'Hidden
  | CursorInputMode'Disabled
  deriving (CursorInputMode
CursorInputMode -> CursorInputMode -> Bounded CursorInputMode
forall a. a -> a -> Bounded a
$cminBound :: CursorInputMode
minBound :: CursorInputMode
$cmaxBound :: CursorInputMode
maxBound :: CursorInputMode
Bounded, Typeable CursorInputMode
Typeable CursorInputMode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CursorInputMode -> c CursorInputMode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CursorInputMode)
-> (CursorInputMode -> Constr)
-> (CursorInputMode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CursorInputMode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CursorInputMode))
-> ((forall b. Data b => b -> b)
    -> CursorInputMode -> CursorInputMode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CursorInputMode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CursorInputMode -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CursorInputMode -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CursorInputMode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CursorInputMode -> m CursorInputMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CursorInputMode -> m CursorInputMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CursorInputMode -> m CursorInputMode)
-> Data CursorInputMode
CursorInputMode -> Constr
CursorInputMode -> DataType
(forall b. Data b => b -> b) -> CursorInputMode -> CursorInputMode
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) -> CursorInputMode -> u
forall u. (forall d. Data d => d -> u) -> CursorInputMode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CursorInputMode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CursorInputMode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CursorInputMode -> m CursorInputMode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CursorInputMode -> m CursorInputMode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CursorInputMode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CursorInputMode -> c CursorInputMode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CursorInputMode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CursorInputMode)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CursorInputMode -> c CursorInputMode
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CursorInputMode -> c CursorInputMode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CursorInputMode
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CursorInputMode
$ctoConstr :: CursorInputMode -> Constr
toConstr :: CursorInputMode -> Constr
$cdataTypeOf :: CursorInputMode -> DataType
dataTypeOf :: CursorInputMode -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CursorInputMode)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CursorInputMode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CursorInputMode)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CursorInputMode)
$cgmapT :: (forall b. Data b => b -> b) -> CursorInputMode -> CursorInputMode
gmapT :: (forall b. Data b => b -> b) -> CursorInputMode -> CursorInputMode
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CursorInputMode -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CursorInputMode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CursorInputMode -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CursorInputMode -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CursorInputMode -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CursorInputMode -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CursorInputMode -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CursorInputMode -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CursorInputMode -> m CursorInputMode
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CursorInputMode -> m CursorInputMode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CursorInputMode -> m CursorInputMode
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CursorInputMode -> m CursorInputMode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CursorInputMode -> m CursorInputMode
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CursorInputMode -> m CursorInputMode
Data, Int -> CursorInputMode
CursorInputMode -> Int
CursorInputMode -> [CursorInputMode]
CursorInputMode -> CursorInputMode
CursorInputMode -> CursorInputMode -> [CursorInputMode]
CursorInputMode
-> CursorInputMode -> CursorInputMode -> [CursorInputMode]
(CursorInputMode -> CursorInputMode)
-> (CursorInputMode -> CursorInputMode)
-> (Int -> CursorInputMode)
-> (CursorInputMode -> Int)
-> (CursorInputMode -> [CursorInputMode])
-> (CursorInputMode -> CursorInputMode -> [CursorInputMode])
-> (CursorInputMode -> CursorInputMode -> [CursorInputMode])
-> (CursorInputMode
    -> CursorInputMode -> CursorInputMode -> [CursorInputMode])
-> Enum CursorInputMode
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: CursorInputMode -> CursorInputMode
succ :: CursorInputMode -> CursorInputMode
$cpred :: CursorInputMode -> CursorInputMode
pred :: CursorInputMode -> CursorInputMode
$ctoEnum :: Int -> CursorInputMode
toEnum :: Int -> CursorInputMode
$cfromEnum :: CursorInputMode -> Int
fromEnum :: CursorInputMode -> Int
$cenumFrom :: CursorInputMode -> [CursorInputMode]
enumFrom :: CursorInputMode -> [CursorInputMode]
$cenumFromThen :: CursorInputMode -> CursorInputMode -> [CursorInputMode]
enumFromThen :: CursorInputMode -> CursorInputMode -> [CursorInputMode]
$cenumFromTo :: CursorInputMode -> CursorInputMode -> [CursorInputMode]
enumFromTo :: CursorInputMode -> CursorInputMode -> [CursorInputMode]
$cenumFromThenTo :: CursorInputMode
-> CursorInputMode -> CursorInputMode -> [CursorInputMode]
enumFromThenTo :: CursorInputMode
-> CursorInputMode -> CursorInputMode -> [CursorInputMode]
Enum, CursorInputMode -> CursorInputMode -> Bool
(CursorInputMode -> CursorInputMode -> Bool)
-> (CursorInputMode -> CursorInputMode -> Bool)
-> Eq CursorInputMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CursorInputMode -> CursorInputMode -> Bool
== :: CursorInputMode -> CursorInputMode -> Bool
$c/= :: CursorInputMode -> CursorInputMode -> Bool
/= :: CursorInputMode -> CursorInputMode -> Bool
Eq, Eq CursorInputMode
Eq CursorInputMode =>
(CursorInputMode -> CursorInputMode -> Ordering)
-> (CursorInputMode -> CursorInputMode -> Bool)
-> (CursorInputMode -> CursorInputMode -> Bool)
-> (CursorInputMode -> CursorInputMode -> Bool)
-> (CursorInputMode -> CursorInputMode -> Bool)
-> (CursorInputMode -> CursorInputMode -> CursorInputMode)
-> (CursorInputMode -> CursorInputMode -> CursorInputMode)
-> Ord CursorInputMode
CursorInputMode -> CursorInputMode -> Bool
CursorInputMode -> CursorInputMode -> Ordering
CursorInputMode -> CursorInputMode -> CursorInputMode
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
$ccompare :: CursorInputMode -> CursorInputMode -> Ordering
compare :: CursorInputMode -> CursorInputMode -> Ordering
$c< :: CursorInputMode -> CursorInputMode -> Bool
< :: CursorInputMode -> CursorInputMode -> Bool
$c<= :: CursorInputMode -> CursorInputMode -> Bool
<= :: CursorInputMode -> CursorInputMode -> Bool
$c> :: CursorInputMode -> CursorInputMode -> Bool
> :: CursorInputMode -> CursorInputMode -> Bool
$c>= :: CursorInputMode -> CursorInputMode -> Bool
>= :: CursorInputMode -> CursorInputMode -> Bool
$cmax :: CursorInputMode -> CursorInputMode -> CursorInputMode
max :: CursorInputMode -> CursorInputMode -> CursorInputMode
$cmin :: CursorInputMode -> CursorInputMode -> CursorInputMode
min :: CursorInputMode -> CursorInputMode -> CursorInputMode
Ord, ReadPrec [CursorInputMode]
ReadPrec CursorInputMode
Int -> ReadS CursorInputMode
ReadS [CursorInputMode]
(Int -> ReadS CursorInputMode)
-> ReadS [CursorInputMode]
-> ReadPrec CursorInputMode
-> ReadPrec [CursorInputMode]
-> Read CursorInputMode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CursorInputMode
readsPrec :: Int -> ReadS CursorInputMode
$creadList :: ReadS [CursorInputMode]
readList :: ReadS [CursorInputMode]
$creadPrec :: ReadPrec CursorInputMode
readPrec :: ReadPrec CursorInputMode
$creadListPrec :: ReadPrec [CursorInputMode]
readListPrec :: ReadPrec [CursorInputMode]
Read, Int -> CursorInputMode -> ShowS
[CursorInputMode] -> ShowS
CursorInputMode -> String
(Int -> CursorInputMode -> ShowS)
-> (CursorInputMode -> String)
-> ([CursorInputMode] -> ShowS)
-> Show CursorInputMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CursorInputMode -> ShowS
showsPrec :: Int -> CursorInputMode -> ShowS
$cshow :: CursorInputMode -> String
show :: CursorInputMode -> String
$cshowList :: [CursorInputMode] -> ShowS
showList :: [CursorInputMode] -> ShowS
Show, Typeable, (forall x. CursorInputMode -> Rep CursorInputMode x)
-> (forall x. Rep CursorInputMode x -> CursorInputMode)
-> Generic CursorInputMode
forall x. Rep CursorInputMode x -> CursorInputMode
forall x. CursorInputMode -> Rep CursorInputMode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CursorInputMode -> Rep CursorInputMode x
from :: forall x. CursorInputMode -> Rep CursorInputMode x
$cto :: forall x. Rep CursorInputMode x -> CursorInputMode
to :: forall x. Rep CursorInputMode x -> CursorInputMode
Generic)

instance NFData CursorInputMode

-- | When sticky keys is enabled, once a key is pressed it will remain pressed
-- at least until the state is polled with 'Graphics.UI.GLFW.getKey'. After
-- that, if the key has been released it will switch back to released. This
-- helps prevent problems with low-resolution polling missing key pressed. Note
-- that use of the callbacks to avoid this problem the the recommended route,
-- and this is just for a fallback.
data StickyKeysInputMode =
    StickyKeysInputMode'Enabled
  | StickyKeysInputMode'Disabled
  deriving (StickyKeysInputMode
StickyKeysInputMode
-> StickyKeysInputMode -> Bounded StickyKeysInputMode
forall a. a -> a -> Bounded a
$cminBound :: StickyKeysInputMode
minBound :: StickyKeysInputMode
$cmaxBound :: StickyKeysInputMode
maxBound :: StickyKeysInputMode
Bounded, Typeable StickyKeysInputMode
Typeable StickyKeysInputMode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> StickyKeysInputMode
 -> c StickyKeysInputMode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StickyKeysInputMode)
-> (StickyKeysInputMode -> Constr)
-> (StickyKeysInputMode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StickyKeysInputMode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c StickyKeysInputMode))
-> ((forall b. Data b => b -> b)
    -> StickyKeysInputMode -> StickyKeysInputMode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StickyKeysInputMode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StickyKeysInputMode -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> StickyKeysInputMode -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StickyKeysInputMode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> StickyKeysInputMode -> m StickyKeysInputMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StickyKeysInputMode -> m StickyKeysInputMode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StickyKeysInputMode -> m StickyKeysInputMode)
-> Data StickyKeysInputMode
StickyKeysInputMode -> Constr
StickyKeysInputMode -> DataType
(forall b. Data b => b -> b)
-> StickyKeysInputMode -> StickyKeysInputMode
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) -> StickyKeysInputMode -> u
forall u.
(forall d. Data d => d -> u) -> StickyKeysInputMode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StickyKeysInputMode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StickyKeysInputMode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StickyKeysInputMode -> m StickyKeysInputMode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StickyKeysInputMode -> m StickyKeysInputMode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StickyKeysInputMode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StickyKeysInputMode
-> c StickyKeysInputMode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StickyKeysInputMode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StickyKeysInputMode)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StickyKeysInputMode
-> c StickyKeysInputMode
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StickyKeysInputMode
-> c StickyKeysInputMode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StickyKeysInputMode
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StickyKeysInputMode
$ctoConstr :: StickyKeysInputMode -> Constr
toConstr :: StickyKeysInputMode -> Constr
$cdataTypeOf :: StickyKeysInputMode -> DataType
dataTypeOf :: StickyKeysInputMode -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StickyKeysInputMode)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StickyKeysInputMode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StickyKeysInputMode)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StickyKeysInputMode)
$cgmapT :: (forall b. Data b => b -> b)
-> StickyKeysInputMode -> StickyKeysInputMode
gmapT :: (forall b. Data b => b -> b)
-> StickyKeysInputMode -> StickyKeysInputMode
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StickyKeysInputMode -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StickyKeysInputMode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StickyKeysInputMode -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StickyKeysInputMode -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> StickyKeysInputMode -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> StickyKeysInputMode -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StickyKeysInputMode -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StickyKeysInputMode -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StickyKeysInputMode -> m StickyKeysInputMode
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StickyKeysInputMode -> m StickyKeysInputMode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StickyKeysInputMode -> m StickyKeysInputMode
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StickyKeysInputMode -> m StickyKeysInputMode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StickyKeysInputMode -> m StickyKeysInputMode
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StickyKeysInputMode -> m StickyKeysInputMode
Data, Int -> StickyKeysInputMode
StickyKeysInputMode -> Int
StickyKeysInputMode -> [StickyKeysInputMode]
StickyKeysInputMode -> StickyKeysInputMode
StickyKeysInputMode -> StickyKeysInputMode -> [StickyKeysInputMode]
StickyKeysInputMode
-> StickyKeysInputMode
-> StickyKeysInputMode
-> [StickyKeysInputMode]
(StickyKeysInputMode -> StickyKeysInputMode)
-> (StickyKeysInputMode -> StickyKeysInputMode)
-> (Int -> StickyKeysInputMode)
-> (StickyKeysInputMode -> Int)
-> (StickyKeysInputMode -> [StickyKeysInputMode])
-> (StickyKeysInputMode
    -> StickyKeysInputMode -> [StickyKeysInputMode])
-> (StickyKeysInputMode
    -> StickyKeysInputMode -> [StickyKeysInputMode])
-> (StickyKeysInputMode
    -> StickyKeysInputMode
    -> StickyKeysInputMode
    -> [StickyKeysInputMode])
-> Enum StickyKeysInputMode
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: StickyKeysInputMode -> StickyKeysInputMode
succ :: StickyKeysInputMode -> StickyKeysInputMode
$cpred :: StickyKeysInputMode -> StickyKeysInputMode
pred :: StickyKeysInputMode -> StickyKeysInputMode
$ctoEnum :: Int -> StickyKeysInputMode
toEnum :: Int -> StickyKeysInputMode
$cfromEnum :: StickyKeysInputMode -> Int
fromEnum :: StickyKeysInputMode -> Int
$cenumFrom :: StickyKeysInputMode -> [StickyKeysInputMode]
enumFrom :: StickyKeysInputMode -> [StickyKeysInputMode]
$cenumFromThen :: StickyKeysInputMode -> StickyKeysInputMode -> [StickyKeysInputMode]
enumFromThen :: StickyKeysInputMode -> StickyKeysInputMode -> [StickyKeysInputMode]
$cenumFromTo :: StickyKeysInputMode -> StickyKeysInputMode -> [StickyKeysInputMode]
enumFromTo :: StickyKeysInputMode -> StickyKeysInputMode -> [StickyKeysInputMode]
$cenumFromThenTo :: StickyKeysInputMode
-> StickyKeysInputMode
-> StickyKeysInputMode
-> [StickyKeysInputMode]
enumFromThenTo :: StickyKeysInputMode
-> StickyKeysInputMode
-> StickyKeysInputMode
-> [StickyKeysInputMode]
Enum, StickyKeysInputMode -> StickyKeysInputMode -> Bool
(StickyKeysInputMode -> StickyKeysInputMode -> Bool)
-> (StickyKeysInputMode -> StickyKeysInputMode -> Bool)
-> Eq StickyKeysInputMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
== :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
$c/= :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
/= :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
Eq, Eq StickyKeysInputMode
Eq StickyKeysInputMode =>
(StickyKeysInputMode -> StickyKeysInputMode -> Ordering)
-> (StickyKeysInputMode -> StickyKeysInputMode -> Bool)
-> (StickyKeysInputMode -> StickyKeysInputMode -> Bool)
-> (StickyKeysInputMode -> StickyKeysInputMode -> Bool)
-> (StickyKeysInputMode -> StickyKeysInputMode -> Bool)
-> (StickyKeysInputMode
    -> StickyKeysInputMode -> StickyKeysInputMode)
-> (StickyKeysInputMode
    -> StickyKeysInputMode -> StickyKeysInputMode)
-> Ord StickyKeysInputMode
StickyKeysInputMode -> StickyKeysInputMode -> Bool
StickyKeysInputMode -> StickyKeysInputMode -> Ordering
StickyKeysInputMode -> StickyKeysInputMode -> StickyKeysInputMode
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
$ccompare :: StickyKeysInputMode -> StickyKeysInputMode -> Ordering
compare :: StickyKeysInputMode -> StickyKeysInputMode -> Ordering
$c< :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
< :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
$c<= :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
<= :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
$c> :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
> :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
$c>= :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
>= :: StickyKeysInputMode -> StickyKeysInputMode -> Bool
$cmax :: StickyKeysInputMode -> StickyKeysInputMode -> StickyKeysInputMode
max :: StickyKeysInputMode -> StickyKeysInputMode -> StickyKeysInputMode
$cmin :: StickyKeysInputMode -> StickyKeysInputMode -> StickyKeysInputMode
min :: StickyKeysInputMode -> StickyKeysInputMode -> StickyKeysInputMode
Ord, ReadPrec [StickyKeysInputMode]
ReadPrec StickyKeysInputMode
Int -> ReadS StickyKeysInputMode
ReadS [StickyKeysInputMode]
(Int -> ReadS StickyKeysInputMode)
-> ReadS [StickyKeysInputMode]
-> ReadPrec StickyKeysInputMode
-> ReadPrec [StickyKeysInputMode]
-> Read StickyKeysInputMode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StickyKeysInputMode
readsPrec :: Int -> ReadS StickyKeysInputMode
$creadList :: ReadS [StickyKeysInputMode]
readList :: ReadS [StickyKeysInputMode]
$creadPrec :: ReadPrec StickyKeysInputMode
readPrec :: ReadPrec StickyKeysInputMode
$creadListPrec :: ReadPrec [StickyKeysInputMode]
readListPrec :: ReadPrec [StickyKeysInputMode]
Read, Int -> StickyKeysInputMode -> ShowS
[StickyKeysInputMode] -> ShowS
StickyKeysInputMode -> String
(Int -> StickyKeysInputMode -> ShowS)
-> (StickyKeysInputMode -> String)
-> ([StickyKeysInputMode] -> ShowS)
-> Show StickyKeysInputMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StickyKeysInputMode -> ShowS
showsPrec :: Int -> StickyKeysInputMode -> ShowS
$cshow :: StickyKeysInputMode -> String
show :: StickyKeysInputMode -> String
$cshowList :: [StickyKeysInputMode] -> ShowS
showList :: [StickyKeysInputMode] -> ShowS
Show, Typeable, (forall x. StickyKeysInputMode -> Rep StickyKeysInputMode x)
-> (forall x. Rep StickyKeysInputMode x -> StickyKeysInputMode)
-> Generic StickyKeysInputMode
forall x. Rep StickyKeysInputMode x -> StickyKeysInputMode
forall x. StickyKeysInputMode -> Rep StickyKeysInputMode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. StickyKeysInputMode -> Rep StickyKeysInputMode x
from :: forall x. StickyKeysInputMode -> Rep StickyKeysInputMode x
$cto :: forall x. Rep StickyKeysInputMode x -> StickyKeysInputMode
to :: forall x. Rep StickyKeysInputMode x -> StickyKeysInputMode
Generic)

instance NFData StickyKeysInputMode

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

instance NFData StickyMouseButtonsInputMode

-- | Modifier keys that were pressed as part of another keypress event.
data ModifierKeys = ModifierKeys
  { ModifierKeys -> Bool
modifierKeysShift    :: !Bool
  , ModifierKeys -> Bool
modifierKeysControl  :: !Bool
  , ModifierKeys -> Bool
modifierKeysAlt      :: !Bool
  , ModifierKeys -> Bool
modifierKeysSuper    :: !Bool
  , ModifierKeys -> Bool
modifierKeysCapsLock :: !Bool
  , ModifierKeys -> Bool
modifierKeysNumLock  :: !Bool
  } deriving (Typeable ModifierKeys
Typeable ModifierKeys =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ModifierKeys -> c ModifierKeys)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModifierKeys)
-> (ModifierKeys -> Constr)
-> (ModifierKeys -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModifierKeys))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ModifierKeys))
-> ((forall b. Data b => b -> b) -> ModifierKeys -> ModifierKeys)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModifierKeys -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModifierKeys -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModifierKeys -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModifierKeys -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModifierKeys -> m ModifierKeys)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModifierKeys -> m ModifierKeys)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModifierKeys -> m ModifierKeys)
-> Data ModifierKeys
ModifierKeys -> Constr
ModifierKeys -> DataType
(forall b. Data b => b -> b) -> ModifierKeys -> ModifierKeys
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) -> ModifierKeys -> u
forall u. (forall d. Data d => d -> u) -> ModifierKeys -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModifierKeys -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModifierKeys -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModifierKeys -> m ModifierKeys
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModifierKeys -> m ModifierKeys
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModifierKeys
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModifierKeys -> c ModifierKeys
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModifierKeys)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModifierKeys)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModifierKeys -> c ModifierKeys
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModifierKeys -> c ModifierKeys
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModifierKeys
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModifierKeys
$ctoConstr :: ModifierKeys -> Constr
toConstr :: ModifierKeys -> Constr
$cdataTypeOf :: ModifierKeys -> DataType
dataTypeOf :: ModifierKeys -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModifierKeys)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModifierKeys)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModifierKeys)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModifierKeys)
$cgmapT :: (forall b. Data b => b -> b) -> ModifierKeys -> ModifierKeys
gmapT :: (forall b. Data b => b -> b) -> ModifierKeys -> ModifierKeys
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModifierKeys -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModifierKeys -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModifierKeys -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModifierKeys -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModifierKeys -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModifierKeys -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModifierKeys -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModifierKeys -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModifierKeys -> m ModifierKeys
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModifierKeys -> m ModifierKeys
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModifierKeys -> m ModifierKeys
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModifierKeys -> m ModifierKeys
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModifierKeys -> m ModifierKeys
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModifierKeys -> m ModifierKeys
Data, ModifierKeys -> ModifierKeys -> Bool
(ModifierKeys -> ModifierKeys -> Bool)
-> (ModifierKeys -> ModifierKeys -> Bool) -> Eq ModifierKeys
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ModifierKeys -> ModifierKeys -> Bool
== :: ModifierKeys -> ModifierKeys -> Bool
$c/= :: ModifierKeys -> ModifierKeys -> Bool
/= :: ModifierKeys -> ModifierKeys -> Bool
Eq, Eq ModifierKeys
Eq ModifierKeys =>
(ModifierKeys -> ModifierKeys -> Ordering)
-> (ModifierKeys -> ModifierKeys -> Bool)
-> (ModifierKeys -> ModifierKeys -> Bool)
-> (ModifierKeys -> ModifierKeys -> Bool)
-> (ModifierKeys -> ModifierKeys -> Bool)
-> (ModifierKeys -> ModifierKeys -> ModifierKeys)
-> (ModifierKeys -> ModifierKeys -> ModifierKeys)
-> Ord ModifierKeys
ModifierKeys -> ModifierKeys -> Bool
ModifierKeys -> ModifierKeys -> Ordering
ModifierKeys -> ModifierKeys -> ModifierKeys
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
$ccompare :: ModifierKeys -> ModifierKeys -> Ordering
compare :: ModifierKeys -> ModifierKeys -> Ordering
$c< :: ModifierKeys -> ModifierKeys -> Bool
< :: ModifierKeys -> ModifierKeys -> Bool
$c<= :: ModifierKeys -> ModifierKeys -> Bool
<= :: ModifierKeys -> ModifierKeys -> Bool
$c> :: ModifierKeys -> ModifierKeys -> Bool
> :: ModifierKeys -> ModifierKeys -> Bool
$c>= :: ModifierKeys -> ModifierKeys -> Bool
>= :: ModifierKeys -> ModifierKeys -> Bool
$cmax :: ModifierKeys -> ModifierKeys -> ModifierKeys
max :: ModifierKeys -> ModifierKeys -> ModifierKeys
$cmin :: ModifierKeys -> ModifierKeys -> ModifierKeys
min :: ModifierKeys -> ModifierKeys -> ModifierKeys
Ord, ReadPrec [ModifierKeys]
ReadPrec ModifierKeys
Int -> ReadS ModifierKeys
ReadS [ModifierKeys]
(Int -> ReadS ModifierKeys)
-> ReadS [ModifierKeys]
-> ReadPrec ModifierKeys
-> ReadPrec [ModifierKeys]
-> Read ModifierKeys
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ModifierKeys
readsPrec :: Int -> ReadS ModifierKeys
$creadList :: ReadS [ModifierKeys]
readList :: ReadS [ModifierKeys]
$creadPrec :: ReadPrec ModifierKeys
readPrec :: ReadPrec ModifierKeys
$creadListPrec :: ReadPrec [ModifierKeys]
readListPrec :: ReadPrec [ModifierKeys]
Read, Int -> ModifierKeys -> ShowS
[ModifierKeys] -> ShowS
ModifierKeys -> String
(Int -> ModifierKeys -> ShowS)
-> (ModifierKeys -> String)
-> ([ModifierKeys] -> ShowS)
-> Show ModifierKeys
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ModifierKeys -> ShowS
showsPrec :: Int -> ModifierKeys -> ShowS
$cshow :: ModifierKeys -> String
show :: ModifierKeys -> String
$cshowList :: [ModifierKeys] -> ShowS
showList :: [ModifierKeys] -> ShowS
Show, Typeable, (forall x. ModifierKeys -> Rep ModifierKeys x)
-> (forall x. Rep ModifierKeys x -> ModifierKeys)
-> Generic ModifierKeys
forall x. Rep ModifierKeys x -> ModifierKeys
forall x. ModifierKeys -> Rep ModifierKeys x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ModifierKeys -> Rep ModifierKeys x
from :: forall x. ModifierKeys -> Rep ModifierKeys x
$cto :: forall x. Rep ModifierKeys x -> ModifierKeys
to :: forall x. Rep ModifierKeys x -> ModifierKeys
Generic)

instance NFData ModifierKeys

-- | The different types of buttons we can find on a Gamepad.
data GamepadButton
  = GamepadButton'A
  | GamepadButton'B
  | GamepadButton'X
  | GamepadButton'Y
  | GamepadButton'LeftBumper
  | GamepadButton'RightBumper
  | GamepadButton'Back
  | GamepadButton'Start
  | GamepadButton'Guide
  | GamepadButton'LeftThumb
  | GamepadButton'RightThumb
  | GamepadButton'DpadUp
  | GamepadButton'DpadRight
  | GamepadButton'DpadDown
  | GamepadButton'DpadLeft
  | GamepadButton'Cross
  | GamepadButton'Circle
  | GamepadButton'Square
  | GamepadButton'Triangle
  deriving (GamepadButton
GamepadButton -> GamepadButton -> Bounded GamepadButton
forall a. a -> a -> Bounded a
$cminBound :: GamepadButton
minBound :: GamepadButton
$cmaxBound :: GamepadButton
maxBound :: GamepadButton
Bounded, Typeable GamepadButton
Typeable GamepadButton =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GamepadButton -> c GamepadButton)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GamepadButton)
-> (GamepadButton -> Constr)
-> (GamepadButton -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GamepadButton))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GamepadButton))
-> ((forall b. Data b => b -> b) -> GamepadButton -> GamepadButton)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GamepadButton -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GamepadButton -> r)
-> (forall u. (forall d. Data d => d -> u) -> GamepadButton -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GamepadButton -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GamepadButton -> m GamepadButton)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GamepadButton -> m GamepadButton)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GamepadButton -> m GamepadButton)
-> Data GamepadButton
GamepadButton -> Constr
GamepadButton -> DataType
(forall b. Data b => b -> b) -> GamepadButton -> GamepadButton
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) -> GamepadButton -> u
forall u. (forall d. Data d => d -> u) -> GamepadButton -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadButton -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadButton -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GamepadButton -> m GamepadButton
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GamepadButton -> m GamepadButton
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GamepadButton
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GamepadButton -> c GamepadButton
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GamepadButton)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GamepadButton)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GamepadButton -> c GamepadButton
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GamepadButton -> c GamepadButton
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GamepadButton
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GamepadButton
$ctoConstr :: GamepadButton -> Constr
toConstr :: GamepadButton -> Constr
$cdataTypeOf :: GamepadButton -> DataType
dataTypeOf :: GamepadButton -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GamepadButton)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GamepadButton)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GamepadButton)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GamepadButton)
$cgmapT :: (forall b. Data b => b -> b) -> GamepadButton -> GamepadButton
gmapT :: (forall b. Data b => b -> b) -> GamepadButton -> GamepadButton
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadButton -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadButton -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadButton -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadButton -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GamepadButton -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GamepadButton -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GamepadButton -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GamepadButton -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GamepadButton -> m GamepadButton
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GamepadButton -> m GamepadButton
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GamepadButton -> m GamepadButton
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GamepadButton -> m GamepadButton
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GamepadButton -> m GamepadButton
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GamepadButton -> m GamepadButton
Data, Int -> GamepadButton
GamepadButton -> Int
GamepadButton -> [GamepadButton]
GamepadButton -> GamepadButton
GamepadButton -> GamepadButton -> [GamepadButton]
GamepadButton -> GamepadButton -> GamepadButton -> [GamepadButton]
(GamepadButton -> GamepadButton)
-> (GamepadButton -> GamepadButton)
-> (Int -> GamepadButton)
-> (GamepadButton -> Int)
-> (GamepadButton -> [GamepadButton])
-> (GamepadButton -> GamepadButton -> [GamepadButton])
-> (GamepadButton -> GamepadButton -> [GamepadButton])
-> (GamepadButton
    -> GamepadButton -> GamepadButton -> [GamepadButton])
-> Enum GamepadButton
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: GamepadButton -> GamepadButton
succ :: GamepadButton -> GamepadButton
$cpred :: GamepadButton -> GamepadButton
pred :: GamepadButton -> GamepadButton
$ctoEnum :: Int -> GamepadButton
toEnum :: Int -> GamepadButton
$cfromEnum :: GamepadButton -> Int
fromEnum :: GamepadButton -> Int
$cenumFrom :: GamepadButton -> [GamepadButton]
enumFrom :: GamepadButton -> [GamepadButton]
$cenumFromThen :: GamepadButton -> GamepadButton -> [GamepadButton]
enumFromThen :: GamepadButton -> GamepadButton -> [GamepadButton]
$cenumFromTo :: GamepadButton -> GamepadButton -> [GamepadButton]
enumFromTo :: GamepadButton -> GamepadButton -> [GamepadButton]
$cenumFromThenTo :: GamepadButton -> GamepadButton -> GamepadButton -> [GamepadButton]
enumFromThenTo :: GamepadButton -> GamepadButton -> GamepadButton -> [GamepadButton]
Enum, GamepadButton -> GamepadButton -> Bool
(GamepadButton -> GamepadButton -> Bool)
-> (GamepadButton -> GamepadButton -> Bool) -> Eq GamepadButton
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GamepadButton -> GamepadButton -> Bool
== :: GamepadButton -> GamepadButton -> Bool
$c/= :: GamepadButton -> GamepadButton -> Bool
/= :: GamepadButton -> GamepadButton -> Bool
Eq, Eq GamepadButton
Eq GamepadButton =>
(GamepadButton -> GamepadButton -> Ordering)
-> (GamepadButton -> GamepadButton -> Bool)
-> (GamepadButton -> GamepadButton -> Bool)
-> (GamepadButton -> GamepadButton -> Bool)
-> (GamepadButton -> GamepadButton -> Bool)
-> (GamepadButton -> GamepadButton -> GamepadButton)
-> (GamepadButton -> GamepadButton -> GamepadButton)
-> Ord GamepadButton
GamepadButton -> GamepadButton -> Bool
GamepadButton -> GamepadButton -> Ordering
GamepadButton -> GamepadButton -> GamepadButton
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
$ccompare :: GamepadButton -> GamepadButton -> Ordering
compare :: GamepadButton -> GamepadButton -> Ordering
$c< :: GamepadButton -> GamepadButton -> Bool
< :: GamepadButton -> GamepadButton -> Bool
$c<= :: GamepadButton -> GamepadButton -> Bool
<= :: GamepadButton -> GamepadButton -> Bool
$c> :: GamepadButton -> GamepadButton -> Bool
> :: GamepadButton -> GamepadButton -> Bool
$c>= :: GamepadButton -> GamepadButton -> Bool
>= :: GamepadButton -> GamepadButton -> Bool
$cmax :: GamepadButton -> GamepadButton -> GamepadButton
max :: GamepadButton -> GamepadButton -> GamepadButton
$cmin :: GamepadButton -> GamepadButton -> GamepadButton
min :: GamepadButton -> GamepadButton -> GamepadButton
Ord, ReadPrec [GamepadButton]
ReadPrec GamepadButton
Int -> ReadS GamepadButton
ReadS [GamepadButton]
(Int -> ReadS GamepadButton)
-> ReadS [GamepadButton]
-> ReadPrec GamepadButton
-> ReadPrec [GamepadButton]
-> Read GamepadButton
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GamepadButton
readsPrec :: Int -> ReadS GamepadButton
$creadList :: ReadS [GamepadButton]
readList :: ReadS [GamepadButton]
$creadPrec :: ReadPrec GamepadButton
readPrec :: ReadPrec GamepadButton
$creadListPrec :: ReadPrec [GamepadButton]
readListPrec :: ReadPrec [GamepadButton]
Read, Int -> GamepadButton -> ShowS
[GamepadButton] -> ShowS
GamepadButton -> String
(Int -> GamepadButton -> ShowS)
-> (GamepadButton -> String)
-> ([GamepadButton] -> ShowS)
-> Show GamepadButton
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GamepadButton -> ShowS
showsPrec :: Int -> GamepadButton -> ShowS
$cshow :: GamepadButton -> String
show :: GamepadButton -> String
$cshowList :: [GamepadButton] -> ShowS
showList :: [GamepadButton] -> ShowS
Show, Typeable, (forall x. GamepadButton -> Rep GamepadButton x)
-> (forall x. Rep GamepadButton x -> GamepadButton)
-> Generic GamepadButton
forall x. Rep GamepadButton x -> GamepadButton
forall x. GamepadButton -> Rep GamepadButton x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GamepadButton -> Rep GamepadButton x
from :: forall x. GamepadButton -> Rep GamepadButton x
$cto :: forall x. Rep GamepadButton x -> GamepadButton
to :: forall x. Rep GamepadButton x -> GamepadButton
Generic)

instance NFData GamepadButton

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

instance NFData GamepadButtonState

-- | The different axes along which we can measure continuous input on a Gamepad
data GamepadAxis
  = GamepadAxis'LeftX
  | GamepadAxis'LeftY
  | GamepadAxis'RightX
  | GamepadAxis'RightY
  | GamepadAxis'LeftTrigger
  | GamepadAxis'RightTrigger
  deriving (GamepadAxis
GamepadAxis -> GamepadAxis -> Bounded GamepadAxis
forall a. a -> a -> Bounded a
$cminBound :: GamepadAxis
minBound :: GamepadAxis
$cmaxBound :: GamepadAxis
maxBound :: GamepadAxis
Bounded, Typeable GamepadAxis
Typeable GamepadAxis =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GamepadAxis -> c GamepadAxis)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GamepadAxis)
-> (GamepadAxis -> Constr)
-> (GamepadAxis -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GamepadAxis))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GamepadAxis))
-> ((forall b. Data b => b -> b) -> GamepadAxis -> GamepadAxis)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GamepadAxis -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GamepadAxis -> r)
-> (forall u. (forall d. Data d => d -> u) -> GamepadAxis -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GamepadAxis -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GamepadAxis -> m GamepadAxis)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GamepadAxis -> m GamepadAxis)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GamepadAxis -> m GamepadAxis)
-> Data GamepadAxis
GamepadAxis -> Constr
GamepadAxis -> DataType
(forall b. Data b => b -> b) -> GamepadAxis -> GamepadAxis
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) -> GamepadAxis -> u
forall u. (forall d. Data d => d -> u) -> GamepadAxis -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadAxis -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadAxis -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GamepadAxis -> m GamepadAxis
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GamepadAxis -> m GamepadAxis
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GamepadAxis
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GamepadAxis -> c GamepadAxis
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GamepadAxis)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GamepadAxis)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GamepadAxis -> c GamepadAxis
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GamepadAxis -> c GamepadAxis
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GamepadAxis
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GamepadAxis
$ctoConstr :: GamepadAxis -> Constr
toConstr :: GamepadAxis -> Constr
$cdataTypeOf :: GamepadAxis -> DataType
dataTypeOf :: GamepadAxis -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GamepadAxis)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GamepadAxis)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GamepadAxis)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GamepadAxis)
$cgmapT :: (forall b. Data b => b -> b) -> GamepadAxis -> GamepadAxis
gmapT :: (forall b. Data b => b -> b) -> GamepadAxis -> GamepadAxis
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadAxis -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadAxis -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadAxis -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GamepadAxis -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GamepadAxis -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GamepadAxis -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GamepadAxis -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GamepadAxis -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GamepadAxis -> m GamepadAxis
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GamepadAxis -> m GamepadAxis
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GamepadAxis -> m GamepadAxis
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GamepadAxis -> m GamepadAxis
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GamepadAxis -> m GamepadAxis
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GamepadAxis -> m GamepadAxis
Data, Int -> GamepadAxis
GamepadAxis -> Int
GamepadAxis -> [GamepadAxis]
GamepadAxis -> GamepadAxis
GamepadAxis -> GamepadAxis -> [GamepadAxis]
GamepadAxis -> GamepadAxis -> GamepadAxis -> [GamepadAxis]
(GamepadAxis -> GamepadAxis)
-> (GamepadAxis -> GamepadAxis)
-> (Int -> GamepadAxis)
-> (GamepadAxis -> Int)
-> (GamepadAxis -> [GamepadAxis])
-> (GamepadAxis -> GamepadAxis -> [GamepadAxis])
-> (GamepadAxis -> GamepadAxis -> [GamepadAxis])
-> (GamepadAxis -> GamepadAxis -> GamepadAxis -> [GamepadAxis])
-> Enum GamepadAxis
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: GamepadAxis -> GamepadAxis
succ :: GamepadAxis -> GamepadAxis
$cpred :: GamepadAxis -> GamepadAxis
pred :: GamepadAxis -> GamepadAxis
$ctoEnum :: Int -> GamepadAxis
toEnum :: Int -> GamepadAxis
$cfromEnum :: GamepadAxis -> Int
fromEnum :: GamepadAxis -> Int
$cenumFrom :: GamepadAxis -> [GamepadAxis]
enumFrom :: GamepadAxis -> [GamepadAxis]
$cenumFromThen :: GamepadAxis -> GamepadAxis -> [GamepadAxis]
enumFromThen :: GamepadAxis -> GamepadAxis -> [GamepadAxis]
$cenumFromTo :: GamepadAxis -> GamepadAxis -> [GamepadAxis]
enumFromTo :: GamepadAxis -> GamepadAxis -> [GamepadAxis]
$cenumFromThenTo :: GamepadAxis -> GamepadAxis -> GamepadAxis -> [GamepadAxis]
enumFromThenTo :: GamepadAxis -> GamepadAxis -> GamepadAxis -> [GamepadAxis]
Enum, GamepadAxis -> GamepadAxis -> Bool
(GamepadAxis -> GamepadAxis -> Bool)
-> (GamepadAxis -> GamepadAxis -> Bool) -> Eq GamepadAxis
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GamepadAxis -> GamepadAxis -> Bool
== :: GamepadAxis -> GamepadAxis -> Bool
$c/= :: GamepadAxis -> GamepadAxis -> Bool
/= :: GamepadAxis -> GamepadAxis -> Bool
Eq, Eq GamepadAxis
Eq GamepadAxis =>
(GamepadAxis -> GamepadAxis -> Ordering)
-> (GamepadAxis -> GamepadAxis -> Bool)
-> (GamepadAxis -> GamepadAxis -> Bool)
-> (GamepadAxis -> GamepadAxis -> Bool)
-> (GamepadAxis -> GamepadAxis -> Bool)
-> (GamepadAxis -> GamepadAxis -> GamepadAxis)
-> (GamepadAxis -> GamepadAxis -> GamepadAxis)
-> Ord GamepadAxis
GamepadAxis -> GamepadAxis -> Bool
GamepadAxis -> GamepadAxis -> Ordering
GamepadAxis -> GamepadAxis -> GamepadAxis
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
$ccompare :: GamepadAxis -> GamepadAxis -> Ordering
compare :: GamepadAxis -> GamepadAxis -> Ordering
$c< :: GamepadAxis -> GamepadAxis -> Bool
< :: GamepadAxis -> GamepadAxis -> Bool
$c<= :: GamepadAxis -> GamepadAxis -> Bool
<= :: GamepadAxis -> GamepadAxis -> Bool
$c> :: GamepadAxis -> GamepadAxis -> Bool
> :: GamepadAxis -> GamepadAxis -> Bool
$c>= :: GamepadAxis -> GamepadAxis -> Bool
>= :: GamepadAxis -> GamepadAxis -> Bool
$cmax :: GamepadAxis -> GamepadAxis -> GamepadAxis
max :: GamepadAxis -> GamepadAxis -> GamepadAxis
$cmin :: GamepadAxis -> GamepadAxis -> GamepadAxis
min :: GamepadAxis -> GamepadAxis -> GamepadAxis
Ord, ReadPrec [GamepadAxis]
ReadPrec GamepadAxis
Int -> ReadS GamepadAxis
ReadS [GamepadAxis]
(Int -> ReadS GamepadAxis)
-> ReadS [GamepadAxis]
-> ReadPrec GamepadAxis
-> ReadPrec [GamepadAxis]
-> Read GamepadAxis
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GamepadAxis
readsPrec :: Int -> ReadS GamepadAxis
$creadList :: ReadS [GamepadAxis]
readList :: ReadS [GamepadAxis]
$creadPrec :: ReadPrec GamepadAxis
readPrec :: ReadPrec GamepadAxis
$creadListPrec :: ReadPrec [GamepadAxis]
readListPrec :: ReadPrec [GamepadAxis]
Read, Int -> GamepadAxis -> ShowS
[GamepadAxis] -> ShowS
GamepadAxis -> String
(Int -> GamepadAxis -> ShowS)
-> (GamepadAxis -> String)
-> ([GamepadAxis] -> ShowS)
-> Show GamepadAxis
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GamepadAxis -> ShowS
showsPrec :: Int -> GamepadAxis -> ShowS
$cshow :: GamepadAxis -> String
show :: GamepadAxis -> String
$cshowList :: [GamepadAxis] -> ShowS
showList :: [GamepadAxis] -> ShowS
Show, Typeable, (forall x. GamepadAxis -> Rep GamepadAxis x)
-> (forall x. Rep GamepadAxis x -> GamepadAxis)
-> Generic GamepadAxis
forall x. Rep GamepadAxis x -> GamepadAxis
forall x. GamepadAxis -> Rep GamepadAxis x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GamepadAxis -> Rep GamepadAxis x
from :: forall x. GamepadAxis -> Rep GamepadAxis x
$cto :: forall x. Rep GamepadAxis x -> GamepadAxis
to :: forall x. Rep GamepadAxis x -> GamepadAxis
Generic)

instance NFData GamepadAxis

-- | This describes the input state of a gamepad
data GamepadState = GamepadState
                    { GamepadState -> GamepadButton -> GamepadButtonState
getButtonState :: GamepadButton -> GamepadButtonState
                      -- ^ Returns the current state of the given button
                    , GamepadState -> GamepadAxis -> Float
getAxisState :: GamepadAxis -> Float
                      -- ^ Returns a value in the range [-1.0, 1.0] for the
                      -- given game axis
                    } deriving (Typeable, (forall x. GamepadState -> Rep GamepadState x)
-> (forall x. Rep GamepadState x -> GamepadState)
-> Generic GamepadState
forall x. Rep GamepadState x -> GamepadState
forall x. GamepadState -> Rep GamepadState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GamepadState -> Rep GamepadState x
from :: forall x. GamepadState -> Rep GamepadState x
$cto :: forall x. Rep GamepadState x -> GamepadState
to :: forall x. Rep GamepadState x -> GamepadState
Generic)

instance Eq GamepadState where
  GamepadState
a == :: GamepadState -> GamepadState -> Bool
== GamepadState
b =
    let compareSt :: (GamepadState -> t -> a) -> t -> Bool -> Bool
compareSt GamepadState -> t -> a
f t
x = (Bool -> Bool -> Bool
&& (GamepadState -> t -> a
f GamepadState
a t
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== GamepadState -> t -> a
f GamepadState
b t
x))
     in (GamepadButton -> Bool -> Bool) -> Bool -> [GamepadButton] -> Bool
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ((GamepadState -> GamepadButton -> GamepadButtonState)
-> GamepadButton -> Bool -> Bool
forall {a} {t}.
Eq a =>
(GamepadState -> t -> a) -> t -> Bool -> Bool
compareSt GamepadState -> GamepadButton -> GamepadButtonState
getButtonState) Bool
True [GamepadButton
forall a. Bounded a => a
minBound..GamepadButton
forall a. Bounded a => a
maxBound] Bool -> Bool -> Bool
&&
        (GamepadAxis -> Bool -> Bool) -> Bool -> [GamepadAxis] -> Bool
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ((GamepadState -> GamepadAxis -> Float)
-> GamepadAxis -> Bool -> Bool
forall {a} {t}.
Eq a =>
(GamepadState -> t -> a) -> t -> Bool -> Bool
compareSt GamepadState -> GamepadAxis -> Float
getAxisState) Bool
True [GamepadAxis
forall a. Bounded a => a
minBound..GamepadAxis
forall a. Bounded a => a
maxBound]

instance NFData GamepadState

deriving instance Data CUChar

-- | GLFW image data, for setting up custom mouse cursor appearnaces.
data Image = Image
  { Image -> Int
imageWidth  :: {-# UNPACK #-} !Int
  , Image -> Int
imageHeight :: {-# UNPACK #-} !Int
  , Image -> [CUChar]
imagePixels :: [CUChar]
  } deriving (Typeable Image
Typeable Image =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Image -> c Image)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Image)
-> (Image -> Constr)
-> (Image -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Image))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Image))
-> ((forall b. Data b => b -> b) -> Image -> Image)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Image -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Image -> r)
-> (forall u. (forall d. Data d => d -> u) -> Image -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Image -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Image -> m Image)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Image -> m Image)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Image -> m Image)
-> Data Image
Image -> Constr
Image -> DataType
(forall b. Data b => b -> b) -> Image -> Image
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) -> Image -> u
forall u. (forall d. Data d => d -> u) -> Image -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Image -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Image -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Image -> m Image
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Image -> m Image
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Image
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Image -> c Image
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Image)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Image)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Image -> c Image
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Image -> c Image
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Image
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Image
$ctoConstr :: Image -> Constr
toConstr :: Image -> Constr
$cdataTypeOf :: Image -> DataType
dataTypeOf :: Image -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Image)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Image)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Image)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Image)
$cgmapT :: (forall b. Data b => b -> b) -> Image -> Image
gmapT :: (forall b. Data b => b -> b) -> Image -> Image
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Image -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Image -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Image -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Image -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Image -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Image -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Image -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Image -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Image -> m Image
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Image -> m Image
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Image -> m Image
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Image -> m Image
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Image -> m Image
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Image -> m Image
Data, Image -> Image -> Bool
(Image -> Image -> Bool) -> (Image -> Image -> Bool) -> Eq Image
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Image -> Image -> Bool
== :: Image -> Image -> Bool
$c/= :: Image -> Image -> Bool
/= :: Image -> Image -> Bool
Eq, Eq Image
Eq Image =>
(Image -> Image -> Ordering)
-> (Image -> Image -> Bool)
-> (Image -> Image -> Bool)
-> (Image -> Image -> Bool)
-> (Image -> Image -> Bool)
-> (Image -> Image -> Image)
-> (Image -> Image -> Image)
-> Ord Image
Image -> Image -> Bool
Image -> Image -> Ordering
Image -> Image -> Image
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
$ccompare :: Image -> Image -> Ordering
compare :: Image -> Image -> Ordering
$c< :: Image -> Image -> Bool
< :: Image -> Image -> Bool
$c<= :: Image -> Image -> Bool
<= :: Image -> Image -> Bool
$c> :: Image -> Image -> Bool
> :: Image -> Image -> Bool
$c>= :: Image -> Image -> Bool
>= :: Image -> Image -> Bool
$cmax :: Image -> Image -> Image
max :: Image -> Image -> Image
$cmin :: Image -> Image -> Image
min :: Image -> Image -> Image
Ord, ReadPrec [Image]
ReadPrec Image
Int -> ReadS Image
ReadS [Image]
(Int -> ReadS Image)
-> ReadS [Image]
-> ReadPrec Image
-> ReadPrec [Image]
-> Read Image
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Image
readsPrec :: Int -> ReadS Image
$creadList :: ReadS [Image]
readList :: ReadS [Image]
$creadPrec :: ReadPrec Image
readPrec :: ReadPrec Image
$creadListPrec :: ReadPrec [Image]
readListPrec :: ReadPrec [Image]
Read, Int -> Image -> ShowS
[Image] -> ShowS
Image -> String
(Int -> Image -> ShowS)
-> (Image -> String) -> ([Image] -> ShowS) -> Show Image
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Image -> ShowS
showsPrec :: Int -> Image -> ShowS
$cshow :: Image -> String
show :: Image -> String
$cshowList :: [Image] -> ShowS
showList :: [Image] -> ShowS
Show, Typeable, (forall x. Image -> Rep Image x)
-> (forall x. Rep Image x -> Image) -> Generic Image
forall x. Rep Image x -> Image
forall x. Image -> Rep Image x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Image -> Rep Image x
from :: forall x. Image -> Rep Image x
$cto :: forall x. Rep Image x -> Image
to :: forall x. Rep Image x -> Image
Generic)

-- | Create an image given the function to generate 8-bit RGBA values based on
-- the pixel location.
mkImage :: Int -> Int -> (Int -> Int -> (Word8, Word8, Word8, Word8)) -> Image
mkImage :: Int -> Int -> (Int -> Int -> (Word8, Word8, Word8, Word8)) -> Image
mkImage Int
width Int
height Int -> Int -> (Word8, Word8, Word8, Word8)
gen = Image
  { imageWidth :: Int
imageWidth = Int
width
  , imageHeight :: Int
imageHeight = Int
height
  , imagePixels :: [CUChar]
imagePixels = [ Word8 -> CUChar
CUChar Word8
channel | Int
y <- [Int
0..(Int
height Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)]
                                   , Int
x <- [Int
0..(Int
width Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)]
                                   , let (Word8
r, Word8
g, Word8
b, Word8
a) = Int -> Int -> (Word8, Word8, Word8, Word8)
gen Int
x Int
y
                                   , Word8
channel <- [Word8
r, Word8
g, Word8
b, Word8
a]
                  ]
  }

instance NFData Image

-- | Represents a GLFW cursor.
newtype Cursor = Cursor
  { Cursor -> Ptr C'GLFWcursor
unCursor :: Ptr C'GLFWcursor
  } deriving (Typeable Cursor
Typeable Cursor =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Cursor -> c Cursor)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Cursor)
-> (Cursor -> Constr)
-> (Cursor -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Cursor))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cursor))
-> ((forall b. Data b => b -> b) -> Cursor -> Cursor)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Cursor -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Cursor -> r)
-> (forall u. (forall d. Data d => d -> u) -> Cursor -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Cursor -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Cursor -> m Cursor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cursor -> m Cursor)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cursor -> m Cursor)
-> Data Cursor
Cursor -> Constr
Cursor -> DataType
(forall b. Data b => b -> b) -> Cursor -> Cursor
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) -> Cursor -> u
forall u. (forall d. Data d => d -> u) -> Cursor -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cursor -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cursor -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Cursor -> m Cursor
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cursor -> m Cursor
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Cursor
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cursor -> c Cursor
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Cursor)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cursor)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cursor -> c Cursor
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cursor -> c Cursor
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Cursor
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Cursor
$ctoConstr :: Cursor -> Constr
toConstr :: Cursor -> Constr
$cdataTypeOf :: Cursor -> DataType
dataTypeOf :: Cursor -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Cursor)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Cursor)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cursor)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cursor)
$cgmapT :: (forall b. Data b => b -> b) -> Cursor -> Cursor
gmapT :: (forall b. Data b => b -> b) -> Cursor -> Cursor
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cursor -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cursor -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cursor -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cursor -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Cursor -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Cursor -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Cursor -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Cursor -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Cursor -> m Cursor
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Cursor -> m Cursor
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cursor -> m Cursor
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cursor -> m Cursor
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cursor -> m Cursor
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cursor -> m Cursor
Data, Cursor -> Cursor -> Bool
(Cursor -> Cursor -> Bool)
-> (Cursor -> Cursor -> Bool) -> Eq Cursor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Cursor -> Cursor -> Bool
== :: Cursor -> Cursor -> Bool
$c/= :: Cursor -> Cursor -> Bool
/= :: Cursor -> Cursor -> Bool
Eq, Eq Cursor
Eq Cursor =>
(Cursor -> Cursor -> Ordering)
-> (Cursor -> Cursor -> Bool)
-> (Cursor -> Cursor -> Bool)
-> (Cursor -> Cursor -> Bool)
-> (Cursor -> Cursor -> Bool)
-> (Cursor -> Cursor -> Cursor)
-> (Cursor -> Cursor -> Cursor)
-> Ord Cursor
Cursor -> Cursor -> Bool
Cursor -> Cursor -> Ordering
Cursor -> Cursor -> Cursor
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
$ccompare :: Cursor -> Cursor -> Ordering
compare :: Cursor -> Cursor -> Ordering
$c< :: Cursor -> Cursor -> Bool
< :: Cursor -> Cursor -> Bool
$c<= :: Cursor -> Cursor -> Bool
<= :: Cursor -> Cursor -> Bool
$c> :: Cursor -> Cursor -> Bool
> :: Cursor -> Cursor -> Bool
$c>= :: Cursor -> Cursor -> Bool
>= :: Cursor -> Cursor -> Bool
$cmax :: Cursor -> Cursor -> Cursor
max :: Cursor -> Cursor -> Cursor
$cmin :: Cursor -> Cursor -> Cursor
min :: Cursor -> Cursor -> Cursor
Ord, Int -> Cursor -> ShowS
[Cursor] -> ShowS
Cursor -> String
(Int -> Cursor -> ShowS)
-> (Cursor -> String) -> ([Cursor] -> ShowS) -> Show Cursor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Cursor -> ShowS
showsPrec :: Int -> Cursor -> ShowS
$cshow :: Cursor -> String
show :: Cursor -> String
$cshowList :: [Cursor] -> ShowS
showList :: [Cursor] -> ShowS
Show, Typeable, (forall x. Cursor -> Rep Cursor x)
-> (forall x. Rep Cursor x -> Cursor) -> Generic Cursor
forall x. Rep Cursor x -> Cursor
forall x. Cursor -> Rep Cursor x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Cursor -> Rep Cursor x
from :: forall x. Cursor -> Rep Cursor x
$cto :: forall x. Rep Cursor x -> Cursor
to :: forall x. Rep Cursor x -> Cursor
Generic)

-- | Lets you use one of the standard cursor appearnaces that the local
-- system theme provides for.
-- See <http://www.glfw.org/docs/3.3/input.html#cursor_standard Standard Cursor Creation>.
data StandardCursorShape =
    StandardCursorShape'Arrow
  | StandardCursorShape'IBeam
  | StandardCursorShape'Crosshair
  | StandardCursorShape'Hand
  | StandardCursorShape'HResize
  | StandardCursorShape'VResize
  deriving (StandardCursorShape
StandardCursorShape
-> StandardCursorShape -> Bounded StandardCursorShape
forall a. a -> a -> Bounded a
$cminBound :: StandardCursorShape
minBound :: StandardCursorShape
$cmaxBound :: StandardCursorShape
maxBound :: StandardCursorShape
Bounded, Typeable StandardCursorShape
Typeable StandardCursorShape =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> StandardCursorShape
 -> c StandardCursorShape)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StandardCursorShape)
-> (StandardCursorShape -> Constr)
-> (StandardCursorShape -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StandardCursorShape))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c StandardCursorShape))
-> ((forall b. Data b => b -> b)
    -> StandardCursorShape -> StandardCursorShape)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StandardCursorShape -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StandardCursorShape -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> StandardCursorShape -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StandardCursorShape -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> StandardCursorShape -> m StandardCursorShape)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StandardCursorShape -> m StandardCursorShape)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StandardCursorShape -> m StandardCursorShape)
-> Data StandardCursorShape
StandardCursorShape -> Constr
StandardCursorShape -> DataType
(forall b. Data b => b -> b)
-> StandardCursorShape -> StandardCursorShape
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) -> StandardCursorShape -> u
forall u.
(forall d. Data d => d -> u) -> StandardCursorShape -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StandardCursorShape -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StandardCursorShape -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StandardCursorShape -> m StandardCursorShape
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandardCursorShape -> m StandardCursorShape
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StandardCursorShape
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StandardCursorShape
-> c StandardCursorShape
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StandardCursorShape)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StandardCursorShape)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StandardCursorShape
-> c StandardCursorShape
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StandardCursorShape
-> c StandardCursorShape
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StandardCursorShape
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StandardCursorShape
$ctoConstr :: StandardCursorShape -> Constr
toConstr :: StandardCursorShape -> Constr
$cdataTypeOf :: StandardCursorShape -> DataType
dataTypeOf :: StandardCursorShape -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StandardCursorShape)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StandardCursorShape)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StandardCursorShape)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StandardCursorShape)
$cgmapT :: (forall b. Data b => b -> b)
-> StandardCursorShape -> StandardCursorShape
gmapT :: (forall b. Data b => b -> b)
-> StandardCursorShape -> StandardCursorShape
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StandardCursorShape -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StandardCursorShape -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StandardCursorShape -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StandardCursorShape -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> StandardCursorShape -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> StandardCursorShape -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StandardCursorShape -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StandardCursorShape -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StandardCursorShape -> m StandardCursorShape
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StandardCursorShape -> m StandardCursorShape
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandardCursorShape -> m StandardCursorShape
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandardCursorShape -> m StandardCursorShape
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandardCursorShape -> m StandardCursorShape
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandardCursorShape -> m StandardCursorShape
Data, Int -> StandardCursorShape
StandardCursorShape -> Int
StandardCursorShape -> [StandardCursorShape]
StandardCursorShape -> StandardCursorShape
StandardCursorShape -> StandardCursorShape -> [StandardCursorShape]
StandardCursorShape
-> StandardCursorShape
-> StandardCursorShape
-> [StandardCursorShape]
(StandardCursorShape -> StandardCursorShape)
-> (StandardCursorShape -> StandardCursorShape)
-> (Int -> StandardCursorShape)
-> (StandardCursorShape -> Int)
-> (StandardCursorShape -> [StandardCursorShape])
-> (StandardCursorShape
    -> StandardCursorShape -> [StandardCursorShape])
-> (StandardCursorShape
    -> StandardCursorShape -> [StandardCursorShape])
-> (StandardCursorShape
    -> StandardCursorShape
    -> StandardCursorShape
    -> [StandardCursorShape])
-> Enum StandardCursorShape
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: StandardCursorShape -> StandardCursorShape
succ :: StandardCursorShape -> StandardCursorShape
$cpred :: StandardCursorShape -> StandardCursorShape
pred :: StandardCursorShape -> StandardCursorShape
$ctoEnum :: Int -> StandardCursorShape
toEnum :: Int -> StandardCursorShape
$cfromEnum :: StandardCursorShape -> Int
fromEnum :: StandardCursorShape -> Int
$cenumFrom :: StandardCursorShape -> [StandardCursorShape]
enumFrom :: StandardCursorShape -> [StandardCursorShape]
$cenumFromThen :: StandardCursorShape -> StandardCursorShape -> [StandardCursorShape]
enumFromThen :: StandardCursorShape -> StandardCursorShape -> [StandardCursorShape]
$cenumFromTo :: StandardCursorShape -> StandardCursorShape -> [StandardCursorShape]
enumFromTo :: StandardCursorShape -> StandardCursorShape -> [StandardCursorShape]
$cenumFromThenTo :: StandardCursorShape
-> StandardCursorShape
-> StandardCursorShape
-> [StandardCursorShape]
enumFromThenTo :: StandardCursorShape
-> StandardCursorShape
-> StandardCursorShape
-> [StandardCursorShape]
Enum, StandardCursorShape -> StandardCursorShape -> Bool
(StandardCursorShape -> StandardCursorShape -> Bool)
-> (StandardCursorShape -> StandardCursorShape -> Bool)
-> Eq StandardCursorShape
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StandardCursorShape -> StandardCursorShape -> Bool
== :: StandardCursorShape -> StandardCursorShape -> Bool
$c/= :: StandardCursorShape -> StandardCursorShape -> Bool
/= :: StandardCursorShape -> StandardCursorShape -> Bool
Eq, Eq StandardCursorShape
Eq StandardCursorShape =>
(StandardCursorShape -> StandardCursorShape -> Ordering)
-> (StandardCursorShape -> StandardCursorShape -> Bool)
-> (StandardCursorShape -> StandardCursorShape -> Bool)
-> (StandardCursorShape -> StandardCursorShape -> Bool)
-> (StandardCursorShape -> StandardCursorShape -> Bool)
-> (StandardCursorShape
    -> StandardCursorShape -> StandardCursorShape)
-> (StandardCursorShape
    -> StandardCursorShape -> StandardCursorShape)
-> Ord StandardCursorShape
StandardCursorShape -> StandardCursorShape -> Bool
StandardCursorShape -> StandardCursorShape -> Ordering
StandardCursorShape -> StandardCursorShape -> StandardCursorShape
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
$ccompare :: StandardCursorShape -> StandardCursorShape -> Ordering
compare :: StandardCursorShape -> StandardCursorShape -> Ordering
$c< :: StandardCursorShape -> StandardCursorShape -> Bool
< :: StandardCursorShape -> StandardCursorShape -> Bool
$c<= :: StandardCursorShape -> StandardCursorShape -> Bool
<= :: StandardCursorShape -> StandardCursorShape -> Bool
$c> :: StandardCursorShape -> StandardCursorShape -> Bool
> :: StandardCursorShape -> StandardCursorShape -> Bool
$c>= :: StandardCursorShape -> StandardCursorShape -> Bool
>= :: StandardCursorShape -> StandardCursorShape -> Bool
$cmax :: StandardCursorShape -> StandardCursorShape -> StandardCursorShape
max :: StandardCursorShape -> StandardCursorShape -> StandardCursorShape
$cmin :: StandardCursorShape -> StandardCursorShape -> StandardCursorShape
min :: StandardCursorShape -> StandardCursorShape -> StandardCursorShape
Ord, ReadPrec [StandardCursorShape]
ReadPrec StandardCursorShape
Int -> ReadS StandardCursorShape
ReadS [StandardCursorShape]
(Int -> ReadS StandardCursorShape)
-> ReadS [StandardCursorShape]
-> ReadPrec StandardCursorShape
-> ReadPrec [StandardCursorShape]
-> Read StandardCursorShape
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StandardCursorShape
readsPrec :: Int -> ReadS StandardCursorShape
$creadList :: ReadS [StandardCursorShape]
readList :: ReadS [StandardCursorShape]
$creadPrec :: ReadPrec StandardCursorShape
readPrec :: ReadPrec StandardCursorShape
$creadListPrec :: ReadPrec [StandardCursorShape]
readListPrec :: ReadPrec [StandardCursorShape]
Read, Int -> StandardCursorShape -> ShowS
[StandardCursorShape] -> ShowS
StandardCursorShape -> String
(Int -> StandardCursorShape -> ShowS)
-> (StandardCursorShape -> String)
-> ([StandardCursorShape] -> ShowS)
-> Show StandardCursorShape
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StandardCursorShape -> ShowS
showsPrec :: Int -> StandardCursorShape -> ShowS
$cshow :: StandardCursorShape -> String
show :: StandardCursorShape -> String
$cshowList :: [StandardCursorShape] -> ShowS
showList :: [StandardCursorShape] -> ShowS
Show, Typeable, (forall x. StandardCursorShape -> Rep StandardCursorShape x)
-> (forall x. Rep StandardCursorShape x -> StandardCursorShape)
-> Generic StandardCursorShape
forall x. Rep StandardCursorShape x -> StandardCursorShape
forall x. StandardCursorShape -> Rep StandardCursorShape x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. StandardCursorShape -> Rep StandardCursorShape x
from :: forall x. StandardCursorShape -> Rep StandardCursorShape x
$cto :: forall x. Rep StandardCursorShape x -> StandardCursorShape
to :: forall x. Rep StandardCursorShape x -> StandardCursorShape
Generic)

instance NFData StandardCursorShape

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

{-# ANN module "HLint: ignore Use camelCase" #-}