-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gdk.Flags
    ( 

 -- * Flags
-- ** AnchorHints #flag:AnchorHints#

    AnchorHints(..)                         ,


-- ** AxisFlags #flag:AxisFlags#

    AxisFlags(..)                           ,


-- ** DragAction #flag:DragAction#

    DragAction(..)                          ,


-- ** EventMask #flag:EventMask#

    EventMask(..)                           ,


-- ** FrameClockPhase #flag:FrameClockPhase#

    FrameClockPhase(..)                     ,


-- ** ModifierType #flag:ModifierType#

    ModifierType(..)                        ,


-- ** PaintableFlags #flag:PaintableFlags#

    PaintableFlags(..)                      ,


-- ** SeatCapabilities #flag:SeatCapabilities#

    SeatCapabilities(..)                    ,


-- ** SurfaceHints #flag:SurfaceHints#

    SurfaceHints(..)                        ,


-- ** SurfaceState #flag:SurfaceState#

    SurfaceState(..)                        ,


-- ** WMDecoration #flag:WMDecoration#

    WMDecoration(..)                        ,


-- ** WMFunction #flag:WMFunction#

    WMFunction(..)                          ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL


-- Flags WMFunction
-- | These are hints originally defined by the Motif toolkit. The window manager
-- can use them when determining the functions to offer for the surface. The
-- hint must be set before mapping the surface.
data WMFunction = 
      WMFunctionAll
    -- ^ all functions should be offered.
    | WMFunctionResize
    -- ^ the surface should be resizable.
    | WMFunctionMove
    -- ^ the surface should be movable.
    | WMFunctionMinimize
    -- ^ the surface should be minimizable.
    | WMFunctionMaximize
    -- ^ the surface should be maximizable.
    | WMFunctionClose
    -- ^ the surface should be closable.
    | AnotherWMFunction Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WMFunction -> ShowS
[WMFunction] -> ShowS
WMFunction -> String
(Int -> WMFunction -> ShowS)
-> (WMFunction -> String)
-> ([WMFunction] -> ShowS)
-> Show WMFunction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WMFunction] -> ShowS
$cshowList :: [WMFunction] -> ShowS
show :: WMFunction -> String
$cshow :: WMFunction -> String
showsPrec :: Int -> WMFunction -> ShowS
$cshowsPrec :: Int -> WMFunction -> ShowS
Show, WMFunction -> WMFunction -> Bool
(WMFunction -> WMFunction -> Bool)
-> (WMFunction -> WMFunction -> Bool) -> Eq WMFunction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WMFunction -> WMFunction -> Bool
$c/= :: WMFunction -> WMFunction -> Bool
== :: WMFunction -> WMFunction -> Bool
$c== :: WMFunction -> WMFunction -> Bool
Eq)

instance P.Enum WMFunction where
    fromEnum :: WMFunction -> Int
fromEnum WMFunctionAll = 1
    fromEnum WMFunctionResize = 2
    fromEnum WMFunctionMove = 4
    fromEnum WMFunctionMinimize = 8
    fromEnum WMFunctionMaximize = 16
    fromEnum WMFunctionClose = 32
    fromEnum (AnotherWMFunction k :: Int
k) = Int
k

    toEnum :: Int -> WMFunction
toEnum 1 = WMFunction
WMFunctionAll
    toEnum 2 = WMFunction
WMFunctionResize
    toEnum 4 = WMFunction
WMFunctionMove
    toEnum 8 = WMFunction
WMFunctionMinimize
    toEnum 16 = WMFunction
WMFunctionMaximize
    toEnum 32 = WMFunction
WMFunctionClose
    toEnum k :: Int
k = Int -> WMFunction
AnotherWMFunction Int
k

instance P.Ord WMFunction where
    compare :: WMFunction -> WMFunction -> Ordering
compare a :: WMFunction
a b :: WMFunction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WMFunction -> Int
forall a. Enum a => a -> Int
P.fromEnum WMFunction
a) (WMFunction -> Int
forall a. Enum a => a -> Int
P.fromEnum WMFunction
b)

foreign import ccall "gdk_wm_function_get_type" c_gdk_wm_function_get_type :: 
    IO GType

instance BoxedFlags WMFunction where
    boxedFlagsType :: Proxy WMFunction -> IO GType
boxedFlagsType _ = IO GType
c_gdk_wm_function_get_type

instance IsGFlag WMFunction

-- Flags WMDecoration
-- | These are hints originally defined by the Motif toolkit.
-- The window manager can use them when determining how to decorate
-- the surface. The hint must be set before mapping the surface.
data WMDecoration = 
      WMDecorationAll
    -- ^ all decorations should be applied.
    | WMDecorationBorder
    -- ^ a frame should be drawn around the surface.
    | WMDecorationResizeh
    -- ^ the frame should have resize handles.
    | WMDecorationTitle
    -- ^ a titlebar should be placed above the surface.
    | WMDecorationMenu
    -- ^ a button for opening a menu should be included.
    | WMDecorationMinimize
    -- ^ a minimize button should be included.
    | WMDecorationMaximize
    -- ^ a maximize button should be included.
    | AnotherWMDecoration Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WMDecoration -> ShowS
[WMDecoration] -> ShowS
WMDecoration -> String
(Int -> WMDecoration -> ShowS)
-> (WMDecoration -> String)
-> ([WMDecoration] -> ShowS)
-> Show WMDecoration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WMDecoration] -> ShowS
$cshowList :: [WMDecoration] -> ShowS
show :: WMDecoration -> String
$cshow :: WMDecoration -> String
showsPrec :: Int -> WMDecoration -> ShowS
$cshowsPrec :: Int -> WMDecoration -> ShowS
Show, WMDecoration -> WMDecoration -> Bool
(WMDecoration -> WMDecoration -> Bool)
-> (WMDecoration -> WMDecoration -> Bool) -> Eq WMDecoration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WMDecoration -> WMDecoration -> Bool
$c/= :: WMDecoration -> WMDecoration -> Bool
== :: WMDecoration -> WMDecoration -> Bool
$c== :: WMDecoration -> WMDecoration -> Bool
Eq)

instance P.Enum WMDecoration where
    fromEnum :: WMDecoration -> Int
fromEnum WMDecorationAll = 1
    fromEnum WMDecorationBorder = 2
    fromEnum WMDecorationResizeh = 4
    fromEnum WMDecorationTitle = 8
    fromEnum WMDecorationMenu = 16
    fromEnum WMDecorationMinimize = 32
    fromEnum WMDecorationMaximize = 64
    fromEnum (AnotherWMDecoration k :: Int
k) = Int
k

    toEnum :: Int -> WMDecoration
toEnum 1 = WMDecoration
WMDecorationAll
    toEnum 2 = WMDecoration
WMDecorationBorder
    toEnum 4 = WMDecoration
WMDecorationResizeh
    toEnum 8 = WMDecoration
WMDecorationTitle
    toEnum 16 = WMDecoration
WMDecorationMenu
    toEnum 32 = WMDecoration
WMDecorationMinimize
    toEnum 64 = WMDecoration
WMDecorationMaximize
    toEnum k :: Int
k = Int -> WMDecoration
AnotherWMDecoration Int
k

instance P.Ord WMDecoration where
    compare :: WMDecoration -> WMDecoration -> Ordering
compare a :: WMDecoration
a b :: WMDecoration
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WMDecoration -> Int
forall a. Enum a => a -> Int
P.fromEnum WMDecoration
a) (WMDecoration -> Int
forall a. Enum a => a -> Int
P.fromEnum WMDecoration
b)

foreign import ccall "gdk_wm_decoration_get_type" c_gdk_wm_decoration_get_type :: 
    IO GType

instance BoxedFlags WMDecoration where
    boxedFlagsType :: Proxy WMDecoration -> IO GType
boxedFlagsType _ = IO GType
c_gdk_wm_decoration_get_type

instance IsGFlag WMDecoration

-- Flags SurfaceState
-- | Specifies the state of a toplevel surface.
-- 
-- On platforms that support information about individual edges, the 'GI.Gdk.Flags.SurfaceStateTiled'
-- state will be set whenever any of the individual tiled states is set. On platforms
-- that lack that support, the tiled state will give an indication of tiledness without
-- any of the per-edge states being set.
data SurfaceState = 
      SurfaceStateWithdrawn
    -- ^ the surface is not shown
    | SurfaceStateIconified
    -- ^ the surface is minimized
    | SurfaceStateMaximized
    -- ^ the surface is maximized
    | SurfaceStateSticky
    -- ^ the surface is sticky
    | SurfaceStateFullscreen
    -- ^ the surface is maximized without decorations
    | SurfaceStateAbove
    -- ^ the surface is kept above other surfaces
    | SurfaceStateBelow
    -- ^ the surface is kept below other surfaces
    | SurfaceStateFocused
    -- ^ the surface is presented as focused (with active decorations)
    | SurfaceStateTiled
    -- ^ the surface is in a tiled state
    | SurfaceStateTopTiled
    -- ^ whether the top edge is tiled
    | SurfaceStateTopResizable
    -- ^ whether the top edge is resizable
    | SurfaceStateRightTiled
    -- ^ whether the right edge is tiled
    | SurfaceStateRightResizable
    -- ^ whether the right edge is resizable
    | SurfaceStateBottomTiled
    -- ^ whether the bottom edge is tiled
    | SurfaceStateBottomResizable
    -- ^ whether the bottom edge is resizable
    | SurfaceStateLeftTiled
    -- ^ whether the left edge is tiled
    | SurfaceStateLeftResizable
    -- ^ whether the left edge is resizable
    | AnotherSurfaceState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SurfaceState -> ShowS
[SurfaceState] -> ShowS
SurfaceState -> String
(Int -> SurfaceState -> ShowS)
-> (SurfaceState -> String)
-> ([SurfaceState] -> ShowS)
-> Show SurfaceState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SurfaceState] -> ShowS
$cshowList :: [SurfaceState] -> ShowS
show :: SurfaceState -> String
$cshow :: SurfaceState -> String
showsPrec :: Int -> SurfaceState -> ShowS
$cshowsPrec :: Int -> SurfaceState -> ShowS
Show, SurfaceState -> SurfaceState -> Bool
(SurfaceState -> SurfaceState -> Bool)
-> (SurfaceState -> SurfaceState -> Bool) -> Eq SurfaceState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SurfaceState -> SurfaceState -> Bool
$c/= :: SurfaceState -> SurfaceState -> Bool
== :: SurfaceState -> SurfaceState -> Bool
$c== :: SurfaceState -> SurfaceState -> Bool
Eq)

instance P.Enum SurfaceState where
    fromEnum :: SurfaceState -> Int
fromEnum SurfaceStateWithdrawn = 1
    fromEnum SurfaceStateIconified = 2
    fromEnum SurfaceStateMaximized = 4
    fromEnum SurfaceStateSticky = 8
    fromEnum SurfaceStateFullscreen = 16
    fromEnum SurfaceStateAbove = 32
    fromEnum SurfaceStateBelow = 64
    fromEnum SurfaceStateFocused = 128
    fromEnum SurfaceStateTiled = 256
    fromEnum SurfaceStateTopTiled = 512
    fromEnum SurfaceStateTopResizable = 1024
    fromEnum SurfaceStateRightTiled = 2048
    fromEnum SurfaceStateRightResizable = 4096
    fromEnum SurfaceStateBottomTiled = 8192
    fromEnum SurfaceStateBottomResizable = 16384
    fromEnum SurfaceStateLeftTiled = 32768
    fromEnum SurfaceStateLeftResizable = 65536
    fromEnum (AnotherSurfaceState k :: Int
k) = Int
k

    toEnum :: Int -> SurfaceState
toEnum 1 = SurfaceState
SurfaceStateWithdrawn
    toEnum 2 = SurfaceState
SurfaceStateIconified
    toEnum 4 = SurfaceState
SurfaceStateMaximized
    toEnum 8 = SurfaceState
SurfaceStateSticky
    toEnum 16 = SurfaceState
SurfaceStateFullscreen
    toEnum 32 = SurfaceState
SurfaceStateAbove
    toEnum 64 = SurfaceState
SurfaceStateBelow
    toEnum 128 = SurfaceState
SurfaceStateFocused
    toEnum 256 = SurfaceState
SurfaceStateTiled
    toEnum 512 = SurfaceState
SurfaceStateTopTiled
    toEnum 1024 = SurfaceState
SurfaceStateTopResizable
    toEnum 2048 = SurfaceState
SurfaceStateRightTiled
    toEnum 4096 = SurfaceState
SurfaceStateRightResizable
    toEnum 8192 = SurfaceState
SurfaceStateBottomTiled
    toEnum 16384 = SurfaceState
SurfaceStateBottomResizable
    toEnum 32768 = SurfaceState
SurfaceStateLeftTiled
    toEnum 65536 = SurfaceState
SurfaceStateLeftResizable
    toEnum k :: Int
k = Int -> SurfaceState
AnotherSurfaceState Int
k

instance P.Ord SurfaceState where
    compare :: SurfaceState -> SurfaceState -> Ordering
compare a :: SurfaceState
a b :: SurfaceState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SurfaceState -> Int
forall a. Enum a => a -> Int
P.fromEnum SurfaceState
a) (SurfaceState -> Int
forall a. Enum a => a -> Int
P.fromEnum SurfaceState
b)

foreign import ccall "gdk_surface_state_get_type" c_gdk_surface_state_get_type :: 
    IO GType

instance BoxedFlags SurfaceState where
    boxedFlagsType :: Proxy SurfaceState -> IO GType
boxedFlagsType _ = IO GType
c_gdk_surface_state_get_type

instance IsGFlag SurfaceState

-- Flags SurfaceHints
-- | Used to indicate which fields of a t'GI.Gdk.Structs.Geometry.Geometry' struct should be paid
-- attention to. Also, the presence\/absence of /@gDKHINTPOS@/,
-- /@gDKHINTUSERPOS@/, and /@gDKHINTUSERSIZE@/ is significant, though they don\'t
-- directly refer to t'GI.Gdk.Structs.Geometry.Geometry' fields. /@gDKHINTUSERPOS@/ will be set
-- automatically by @/GtkWindow/@ if you call @/gtk_window_move()/@.
-- /@gDKHINTUSERPOS@/ and /@gDKHINTUSERSIZE@/ should be set if the user
-- specified a size\/position using a --geometry command-line argument;
-- @/gtk_window_parse_geometry()/@ automatically sets these flags.
data SurfaceHints = 
      SurfaceHintsPos
    -- ^ indicates that the program has positioned the surface
    | SurfaceHintsMinSize
    -- ^ min size fields are set
    | SurfaceHintsMaxSize
    -- ^ max size fields are set
    | SurfaceHintsBaseSize
    -- ^ base size fields are set
    | SurfaceHintsAspect
    -- ^ aspect ratio fields are set
    | SurfaceHintsResizeInc
    -- ^ resize increment fields are set
    | SurfaceHintsWinGravity
    -- ^ surface gravity field is set
    | SurfaceHintsUserPos
    -- ^ indicates that the surface’s position was explicitly set
    --  by the user
    | SurfaceHintsUserSize
    -- ^ indicates that the surface’s size was explicitly set by
    --  the user
    | AnotherSurfaceHints Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SurfaceHints -> ShowS
[SurfaceHints] -> ShowS
SurfaceHints -> String
(Int -> SurfaceHints -> ShowS)
-> (SurfaceHints -> String)
-> ([SurfaceHints] -> ShowS)
-> Show SurfaceHints
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SurfaceHints] -> ShowS
$cshowList :: [SurfaceHints] -> ShowS
show :: SurfaceHints -> String
$cshow :: SurfaceHints -> String
showsPrec :: Int -> SurfaceHints -> ShowS
$cshowsPrec :: Int -> SurfaceHints -> ShowS
Show, SurfaceHints -> SurfaceHints -> Bool
(SurfaceHints -> SurfaceHints -> Bool)
-> (SurfaceHints -> SurfaceHints -> Bool) -> Eq SurfaceHints
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SurfaceHints -> SurfaceHints -> Bool
$c/= :: SurfaceHints -> SurfaceHints -> Bool
== :: SurfaceHints -> SurfaceHints -> Bool
$c== :: SurfaceHints -> SurfaceHints -> Bool
Eq)

instance P.Enum SurfaceHints where
    fromEnum :: SurfaceHints -> Int
fromEnum SurfaceHintsPos = 1
    fromEnum SurfaceHintsMinSize = 2
    fromEnum SurfaceHintsMaxSize = 4
    fromEnum SurfaceHintsBaseSize = 8
    fromEnum SurfaceHintsAspect = 16
    fromEnum SurfaceHintsResizeInc = 32
    fromEnum SurfaceHintsWinGravity = 64
    fromEnum SurfaceHintsUserPos = 128
    fromEnum SurfaceHintsUserSize = 256
    fromEnum (AnotherSurfaceHints k :: Int
k) = Int
k

    toEnum :: Int -> SurfaceHints
toEnum 1 = SurfaceHints
SurfaceHintsPos
    toEnum 2 = SurfaceHints
SurfaceHintsMinSize
    toEnum 4 = SurfaceHints
SurfaceHintsMaxSize
    toEnum 8 = SurfaceHints
SurfaceHintsBaseSize
    toEnum 16 = SurfaceHints
SurfaceHintsAspect
    toEnum 32 = SurfaceHints
SurfaceHintsResizeInc
    toEnum 64 = SurfaceHints
SurfaceHintsWinGravity
    toEnum 128 = SurfaceHints
SurfaceHintsUserPos
    toEnum 256 = SurfaceHints
SurfaceHintsUserSize
    toEnum k :: Int
k = Int -> SurfaceHints
AnotherSurfaceHints Int
k

instance P.Ord SurfaceHints where
    compare :: SurfaceHints -> SurfaceHints -> Ordering
compare a :: SurfaceHints
a b :: SurfaceHints
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SurfaceHints -> Int
forall a. Enum a => a -> Int
P.fromEnum SurfaceHints
a) (SurfaceHints -> Int
forall a. Enum a => a -> Int
P.fromEnum SurfaceHints
b)

foreign import ccall "gdk_surface_hints_get_type" c_gdk_surface_hints_get_type :: 
    IO GType

instance BoxedFlags SurfaceHints where
    boxedFlagsType :: Proxy SurfaceHints -> IO GType
boxedFlagsType _ = IO GType
c_gdk_surface_hints_get_type

instance IsGFlag SurfaceHints

-- Flags SeatCapabilities
-- | Flags describing the seat capabilities.
data SeatCapabilities = 
      SeatCapabilitiesNone
    -- ^ No input capabilities
    | SeatCapabilitiesPointer
    -- ^ The seat has a pointer (e.g. mouse)
    | SeatCapabilitiesTouch
    -- ^ The seat has touchscreen(s) attached
    | SeatCapabilitiesTabletStylus
    -- ^ The seat has drawing tablet(s) attached
    | SeatCapabilitiesKeyboard
    -- ^ The seat has keyboard(s) attached
    | SeatCapabilitiesTabletPad
    -- ^ The seat has drawing tablet pad(s) attached
    | SeatCapabilitiesAllPointing
    -- ^ The union of all pointing capabilities
    | SeatCapabilitiesAll
    -- ^ The union of all capabilities
    | AnotherSeatCapabilities Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SeatCapabilities -> ShowS
[SeatCapabilities] -> ShowS
SeatCapabilities -> String
(Int -> SeatCapabilities -> ShowS)
-> (SeatCapabilities -> String)
-> ([SeatCapabilities] -> ShowS)
-> Show SeatCapabilities
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SeatCapabilities] -> ShowS
$cshowList :: [SeatCapabilities] -> ShowS
show :: SeatCapabilities -> String
$cshow :: SeatCapabilities -> String
showsPrec :: Int -> SeatCapabilities -> ShowS
$cshowsPrec :: Int -> SeatCapabilities -> ShowS
Show, SeatCapabilities -> SeatCapabilities -> Bool
(SeatCapabilities -> SeatCapabilities -> Bool)
-> (SeatCapabilities -> SeatCapabilities -> Bool)
-> Eq SeatCapabilities
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SeatCapabilities -> SeatCapabilities -> Bool
$c/= :: SeatCapabilities -> SeatCapabilities -> Bool
== :: SeatCapabilities -> SeatCapabilities -> Bool
$c== :: SeatCapabilities -> SeatCapabilities -> Bool
Eq)

instance P.Enum SeatCapabilities where
    fromEnum :: SeatCapabilities -> Int
fromEnum SeatCapabilitiesNone = 0
    fromEnum SeatCapabilitiesPointer = 1
    fromEnum SeatCapabilitiesTouch = 2
    fromEnum SeatCapabilitiesTabletStylus = 4
    fromEnum SeatCapabilitiesKeyboard = 8
    fromEnum SeatCapabilitiesTabletPad = 16
    fromEnum SeatCapabilitiesAllPointing = 7
    fromEnum SeatCapabilitiesAll = 15
    fromEnum (AnotherSeatCapabilities k :: Int
k) = Int
k

    toEnum :: Int -> SeatCapabilities
toEnum 0 = SeatCapabilities
SeatCapabilitiesNone
    toEnum 1 = SeatCapabilities
SeatCapabilitiesPointer
    toEnum 2 = SeatCapabilities
SeatCapabilitiesTouch
    toEnum 4 = SeatCapabilities
SeatCapabilitiesTabletStylus
    toEnum 8 = SeatCapabilities
SeatCapabilitiesKeyboard
    toEnum 16 = SeatCapabilities
SeatCapabilitiesTabletPad
    toEnum 7 = SeatCapabilities
SeatCapabilitiesAllPointing
    toEnum 15 = SeatCapabilities
SeatCapabilitiesAll
    toEnum k :: Int
k = Int -> SeatCapabilities
AnotherSeatCapabilities Int
k

instance P.Ord SeatCapabilities where
    compare :: SeatCapabilities -> SeatCapabilities -> Ordering
compare a :: SeatCapabilities
a b :: SeatCapabilities
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SeatCapabilities -> Int
forall a. Enum a => a -> Int
P.fromEnum SeatCapabilities
a) (SeatCapabilities -> Int
forall a. Enum a => a -> Int
P.fromEnum SeatCapabilities
b)

foreign import ccall "gdk_seat_capabilities_get_type" c_gdk_seat_capabilities_get_type :: 
    IO GType

instance BoxedFlags SeatCapabilities where
    boxedFlagsType :: Proxy SeatCapabilities -> IO GType
boxedFlagsType _ = IO GType
c_gdk_seat_capabilities_get_type

instance IsGFlag SeatCapabilities

-- Flags PaintableFlags
-- | Flags about this object. Implementations use these for optimizations
-- such as caching.
data PaintableFlags = 
      PaintableFlagsSize
    -- ^ The size is immutable.
    --     The GdkPaintable[invalidateSize](#signal:invalidateSize) signal will never be
    --     emitted.
    | PaintableFlagsContents
    -- ^ The content is immutable.
    --     The GdkPaintable[invalidateContent](#signal:invalidateContent) signal will never be
    --     emitted.
    | AnotherPaintableFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PaintableFlags -> ShowS
[PaintableFlags] -> ShowS
PaintableFlags -> String
(Int -> PaintableFlags -> ShowS)
-> (PaintableFlags -> String)
-> ([PaintableFlags] -> ShowS)
-> Show PaintableFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PaintableFlags] -> ShowS
$cshowList :: [PaintableFlags] -> ShowS
show :: PaintableFlags -> String
$cshow :: PaintableFlags -> String
showsPrec :: Int -> PaintableFlags -> ShowS
$cshowsPrec :: Int -> PaintableFlags -> ShowS
Show, PaintableFlags -> PaintableFlags -> Bool
(PaintableFlags -> PaintableFlags -> Bool)
-> (PaintableFlags -> PaintableFlags -> Bool) -> Eq PaintableFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PaintableFlags -> PaintableFlags -> Bool
$c/= :: PaintableFlags -> PaintableFlags -> Bool
== :: PaintableFlags -> PaintableFlags -> Bool
$c== :: PaintableFlags -> PaintableFlags -> Bool
Eq)

instance P.Enum PaintableFlags where
    fromEnum :: PaintableFlags -> Int
fromEnum PaintableFlagsSize = 1
    fromEnum PaintableFlagsContents = 2
    fromEnum (AnotherPaintableFlags k :: Int
k) = Int
k

    toEnum :: Int -> PaintableFlags
toEnum 1 = PaintableFlags
PaintableFlagsSize
    toEnum 2 = PaintableFlags
PaintableFlagsContents
    toEnum k :: Int
k = Int -> PaintableFlags
AnotherPaintableFlags Int
k

instance P.Ord PaintableFlags where
    compare :: PaintableFlags -> PaintableFlags -> Ordering
compare a :: PaintableFlags
a b :: PaintableFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PaintableFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PaintableFlags
a) (PaintableFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum PaintableFlags
b)

foreign import ccall "gdk_paintable_flags_get_type" c_gdk_paintable_flags_get_type :: 
    IO GType

instance BoxedFlags PaintableFlags where
    boxedFlagsType :: Proxy PaintableFlags -> IO GType
boxedFlagsType _ = IO GType
c_gdk_paintable_flags_get_type

instance IsGFlag PaintableFlags

-- Flags ModifierType
-- | A set of bit-flags to indicate the state of modifier keys and mouse buttons
-- in various event types. Typical modifier keys are Shift, Control, Meta,
-- Super, Hyper, Alt, Compose, Apple, CapsLock or ShiftLock.
-- 
-- Like the X Window System, GDK supports 8 modifier keys and 5 mouse buttons.
-- 
-- GDK recognizes which of the Meta, Super or Hyper keys are mapped
-- to Mod2 - Mod5, and indicates this by setting 'GI.Gdk.Flags.ModifierTypeSuperMask',
-- 'GI.Gdk.Flags.ModifierTypeHyperMask' or 'GI.Gdk.Flags.ModifierTypeMetaMask' in the state field of key events.
-- 
-- Note that GDK may add internal values to events which include
-- reserved values such as 'GI.Gdk.Flags.ModifierTypeModifierReserved13Mask'.  Your code
-- should preserve and ignore them.  You can use 'GI.Gdk.Flags.ModifierTypeModifierMask' to
-- remove all reserved values.
-- 
-- Also note that the GDK X backend interprets button press events for button
-- 4-7 as scroll events, so 'GI.Gdk.Flags.ModifierTypeButton4Mask' and 'GI.Gdk.Flags.ModifierTypeButton5Mask' will never
-- be set.
data ModifierType = 
      ModifierTypeShiftMask
    -- ^ the Shift key.
    | ModifierTypeLockMask
    -- ^ a Lock key (depending on the modifier mapping of the
    --  X server this may either be CapsLock or ShiftLock).
    | ModifierTypeControlMask
    -- ^ the Control key.
    | ModifierTypeMod1Mask
    -- ^ the fourth modifier key (it depends on the modifier
    --  mapping of the X server which key is interpreted as this modifier, but
    --  normally it is the Alt key).
    | ModifierTypeMod2Mask
    -- ^ the fifth modifier key (it depends on the modifier
    --  mapping of the X server which key is interpreted as this modifier).
    | ModifierTypeMod3Mask
    -- ^ the sixth modifier key (it depends on the modifier
    --  mapping of the X server which key is interpreted as this modifier).
    | ModifierTypeMod4Mask
    -- ^ the seventh modifier key (it depends on the modifier
    --  mapping of the X server which key is interpreted as this modifier).
    | ModifierTypeMod5Mask
    -- ^ the eighth modifier key (it depends on the modifier
    --  mapping of the X server which key is interpreted as this modifier).
    | ModifierTypeButton1Mask
    -- ^ the first mouse button.
    | ModifierTypeButton2Mask
    -- ^ the second mouse button.
    | ModifierTypeButton3Mask
    -- ^ the third mouse button.
    | ModifierTypeButton4Mask
    -- ^ the fourth mouse button.
    | ModifierTypeButton5Mask
    -- ^ the fifth mouse button.
    | ModifierTypeModifierReserved13Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved14Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved15Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved16Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved17Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved18Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved19Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved20Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved21Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved22Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved23Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved24Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeModifierReserved25Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeSuperMask
    -- ^ the Super modifier
    | ModifierTypeHyperMask
    -- ^ the Hyper modifier
    | ModifierTypeMetaMask
    -- ^ the Meta modifier
    | ModifierTypeModifierReserved29Mask
    -- ^ A reserved bit flag; do not use in your own code
    | ModifierTypeReleaseMask
    -- ^ not used in GDK itself. GTK uses it to differentiate
    --  between (keyval, modifiers) pairs from key press and release events.
    | ModifierTypeModifierMask
    -- ^ a mask covering all modifier types.
    | AnotherModifierType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ModifierType -> ShowS
[ModifierType] -> ShowS
ModifierType -> String
(Int -> ModifierType -> ShowS)
-> (ModifierType -> String)
-> ([ModifierType] -> ShowS)
-> Show ModifierType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModifierType] -> ShowS
$cshowList :: [ModifierType] -> ShowS
show :: ModifierType -> String
$cshow :: ModifierType -> String
showsPrec :: Int -> ModifierType -> ShowS
$cshowsPrec :: Int -> ModifierType -> ShowS
Show, ModifierType -> ModifierType -> Bool
(ModifierType -> ModifierType -> Bool)
-> (ModifierType -> ModifierType -> Bool) -> Eq ModifierType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifierType -> ModifierType -> Bool
$c/= :: ModifierType -> ModifierType -> Bool
== :: ModifierType -> ModifierType -> Bool
$c== :: ModifierType -> ModifierType -> Bool
Eq)

instance P.Enum ModifierType where
    fromEnum :: ModifierType -> Int
fromEnum ModifierTypeShiftMask = 1
    fromEnum ModifierTypeLockMask = 2
    fromEnum ModifierTypeControlMask = 4
    fromEnum ModifierTypeMod1Mask = 8
    fromEnum ModifierTypeMod2Mask = 16
    fromEnum ModifierTypeMod3Mask = 32
    fromEnum ModifierTypeMod4Mask = 64
    fromEnum ModifierTypeMod5Mask = 128
    fromEnum ModifierTypeButton1Mask = 256
    fromEnum ModifierTypeButton2Mask = 512
    fromEnum ModifierTypeButton3Mask = 1024
    fromEnum ModifierTypeButton4Mask = 2048
    fromEnum ModifierTypeButton5Mask = 4096
    fromEnum ModifierTypeModifierReserved13Mask = 8192
    fromEnum ModifierTypeModifierReserved14Mask = 16384
    fromEnum ModifierTypeModifierReserved15Mask = 32768
    fromEnum ModifierTypeModifierReserved16Mask = 65536
    fromEnum ModifierTypeModifierReserved17Mask = 131072
    fromEnum ModifierTypeModifierReserved18Mask = 262144
    fromEnum ModifierTypeModifierReserved19Mask = 524288
    fromEnum ModifierTypeModifierReserved20Mask = 1048576
    fromEnum ModifierTypeModifierReserved21Mask = 2097152
    fromEnum ModifierTypeModifierReserved22Mask = 4194304
    fromEnum ModifierTypeModifierReserved23Mask = 8388608
    fromEnum ModifierTypeModifierReserved24Mask = 16777216
    fromEnum ModifierTypeModifierReserved25Mask = 33554432
    fromEnum ModifierTypeSuperMask = 67108864
    fromEnum ModifierTypeHyperMask = 134217728
    fromEnum ModifierTypeMetaMask = 268435456
    fromEnum ModifierTypeModifierReserved29Mask = 536870912
    fromEnum ModifierTypeReleaseMask = 1073741824
    fromEnum ModifierTypeModifierMask = 1543512063
    fromEnum (AnotherModifierType k :: Int
k) = Int
k

    toEnum :: Int -> ModifierType
toEnum 1 = ModifierType
ModifierTypeShiftMask
    toEnum 2 = ModifierType
ModifierTypeLockMask
    toEnum 4 = ModifierType
ModifierTypeControlMask
    toEnum 8 = ModifierType
ModifierTypeMod1Mask
    toEnum 16 = ModifierType
ModifierTypeMod2Mask
    toEnum 32 = ModifierType
ModifierTypeMod3Mask
    toEnum 64 = ModifierType
ModifierTypeMod4Mask
    toEnum 128 = ModifierType
ModifierTypeMod5Mask
    toEnum 256 = ModifierType
ModifierTypeButton1Mask
    toEnum 512 = ModifierType
ModifierTypeButton2Mask
    toEnum 1024 = ModifierType
ModifierTypeButton3Mask
    toEnum 2048 = ModifierType
ModifierTypeButton4Mask
    toEnum 4096 = ModifierType
ModifierTypeButton5Mask
    toEnum 8192 = ModifierType
ModifierTypeModifierReserved13Mask
    toEnum 16384 = ModifierType
ModifierTypeModifierReserved14Mask
    toEnum 32768 = ModifierType
ModifierTypeModifierReserved15Mask
    toEnum 65536 = ModifierType
ModifierTypeModifierReserved16Mask
    toEnum 131072 = ModifierType
ModifierTypeModifierReserved17Mask
    toEnum 262144 = ModifierType
ModifierTypeModifierReserved18Mask
    toEnum 524288 = ModifierType
ModifierTypeModifierReserved19Mask
    toEnum 1048576 = ModifierType
ModifierTypeModifierReserved20Mask
    toEnum 2097152 = ModifierType
ModifierTypeModifierReserved21Mask
    toEnum 4194304 = ModifierType
ModifierTypeModifierReserved22Mask
    toEnum 8388608 = ModifierType
ModifierTypeModifierReserved23Mask
    toEnum 16777216 = ModifierType
ModifierTypeModifierReserved24Mask
    toEnum 33554432 = ModifierType
ModifierTypeModifierReserved25Mask
    toEnum 67108864 = ModifierType
ModifierTypeSuperMask
    toEnum 134217728 = ModifierType
ModifierTypeHyperMask
    toEnum 268435456 = ModifierType
ModifierTypeMetaMask
    toEnum 536870912 = ModifierType
ModifierTypeModifierReserved29Mask
    toEnum 1073741824 = ModifierType
ModifierTypeReleaseMask
    toEnum 1543512063 = ModifierType
ModifierTypeModifierMask
    toEnum k :: Int
k = Int -> ModifierType
AnotherModifierType Int
k

instance P.Ord ModifierType where
    compare :: ModifierType -> ModifierType -> Ordering
compare a :: ModifierType
a b :: ModifierType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ModifierType -> Int
forall a. Enum a => a -> Int
P.fromEnum ModifierType
a) (ModifierType -> Int
forall a. Enum a => a -> Int
P.fromEnum ModifierType
b)

foreign import ccall "gdk_modifier_type_get_type" c_gdk_modifier_type_get_type :: 
    IO GType

instance BoxedFlags ModifierType where
    boxedFlagsType :: Proxy ModifierType -> IO GType
boxedFlagsType _ = IO GType
c_gdk_modifier_type_get_type

instance IsGFlag ModifierType

-- Flags FrameClockPhase
-- | t'GI.Gdk.Flags.FrameClockPhase' is used to represent the different paint clock
-- phases that can be requested. The elements of the enumeration
-- correspond to the signals of t'GI.Gdk.Objects.FrameClock.FrameClock'.
data FrameClockPhase = 
      FrameClockPhaseNone
    -- ^ no phase
    | FrameClockPhaseFlushEvents
    -- ^ corresponds to GdkFrameClock[flushEvents](#signal:flushEvents). Should not be handled by applications.
    | FrameClockPhaseBeforePaint
    -- ^ corresponds to GdkFrameClock[beforePaint](#signal:beforePaint). Should not be handled by applications.
    | FrameClockPhaseUpdate
    -- ^ corresponds to GdkFrameClock[update](#signal:update).
    | FrameClockPhaseLayout
    -- ^ corresponds to GdkFrameClock[layout](#signal:layout).
    | FrameClockPhasePaint
    -- ^ corresponds to GdkFrameClock[paint](#signal:paint).
    | FrameClockPhaseResumeEvents
    -- ^ corresponds to GdkFrameClock[resumeEvents](#signal:resumeEvents). Should not be handled by applications.
    | FrameClockPhaseAfterPaint
    -- ^ corresponds to GdkFrameClock[afterPaint](#signal:afterPaint). Should not be handled by applications.
    | AnotherFrameClockPhase Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FrameClockPhase -> ShowS
[FrameClockPhase] -> ShowS
FrameClockPhase -> String
(Int -> FrameClockPhase -> ShowS)
-> (FrameClockPhase -> String)
-> ([FrameClockPhase] -> ShowS)
-> Show FrameClockPhase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FrameClockPhase] -> ShowS
$cshowList :: [FrameClockPhase] -> ShowS
show :: FrameClockPhase -> String
$cshow :: FrameClockPhase -> String
showsPrec :: Int -> FrameClockPhase -> ShowS
$cshowsPrec :: Int -> FrameClockPhase -> ShowS
Show, FrameClockPhase -> FrameClockPhase -> Bool
(FrameClockPhase -> FrameClockPhase -> Bool)
-> (FrameClockPhase -> FrameClockPhase -> Bool)
-> Eq FrameClockPhase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FrameClockPhase -> FrameClockPhase -> Bool
$c/= :: FrameClockPhase -> FrameClockPhase -> Bool
== :: FrameClockPhase -> FrameClockPhase -> Bool
$c== :: FrameClockPhase -> FrameClockPhase -> Bool
Eq)

instance P.Enum FrameClockPhase where
    fromEnum :: FrameClockPhase -> Int
fromEnum FrameClockPhaseNone = 0
    fromEnum FrameClockPhaseFlushEvents = 1
    fromEnum FrameClockPhaseBeforePaint = 2
    fromEnum FrameClockPhaseUpdate = 4
    fromEnum FrameClockPhaseLayout = 8
    fromEnum FrameClockPhasePaint = 16
    fromEnum FrameClockPhaseResumeEvents = 32
    fromEnum FrameClockPhaseAfterPaint = 64
    fromEnum (AnotherFrameClockPhase k :: Int
k) = Int
k

    toEnum :: Int -> FrameClockPhase
toEnum 0 = FrameClockPhase
FrameClockPhaseNone
    toEnum 1 = FrameClockPhase
FrameClockPhaseFlushEvents
    toEnum 2 = FrameClockPhase
FrameClockPhaseBeforePaint
    toEnum 4 = FrameClockPhase
FrameClockPhaseUpdate
    toEnum 8 = FrameClockPhase
FrameClockPhaseLayout
    toEnum 16 = FrameClockPhase
FrameClockPhasePaint
    toEnum 32 = FrameClockPhase
FrameClockPhaseResumeEvents
    toEnum 64 = FrameClockPhase
FrameClockPhaseAfterPaint
    toEnum k :: Int
k = Int -> FrameClockPhase
AnotherFrameClockPhase Int
k

instance P.Ord FrameClockPhase where
    compare :: FrameClockPhase -> FrameClockPhase -> Ordering
compare a :: FrameClockPhase
a b :: FrameClockPhase
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FrameClockPhase -> Int
forall a. Enum a => a -> Int
P.fromEnum FrameClockPhase
a) (FrameClockPhase -> Int
forall a. Enum a => a -> Int
P.fromEnum FrameClockPhase
b)

foreign import ccall "gdk_frame_clock_phase_get_type" c_gdk_frame_clock_phase_get_type :: 
    IO GType

instance BoxedFlags FrameClockPhase where
    boxedFlagsType :: Proxy FrameClockPhase -> IO GType
boxedFlagsType _ = IO GType
c_gdk_frame_clock_phase_get_type

instance IsGFlag FrameClockPhase

-- Flags EventMask
-- | A set of bit-flags to indicate which events a surface is to receive.
-- Most of these masks map onto one or more of the t'GI.Gdk.Enums.EventType' event types
-- above.
-- 
-- See the [input handling overview][chap-input-handling] for details of
-- [event masks][event-masks] and [event propagation][event-propagation].
-- 
-- If 'GI.Gdk.Flags.EventMaskTouchMask' is enabled, the surface will receive touch events
-- from touch-enabled devices. Those will come as sequences of t'GI.Gdk.Structs.EventTouch.EventTouch'
-- with type 'GI.Gdk.Enums.EventTypeTouchUpdate', enclosed by two events with
-- type 'GI.Gdk.Enums.EventTypeTouchBegin' and 'GI.Gdk.Enums.EventTypeTouchEnd' (or 'GI.Gdk.Enums.EventTypeTouchCancel').
-- 'GI.Gdk.Objects.Event.eventGetEventSequence' returns the event sequence for these
-- events, so different sequences may be distinguished.
data EventMask = 
      EventMaskExposureMask
    -- ^ receive expose events
    | EventMaskPointerMotionMask
    -- ^ receive all pointer motion events
    | EventMaskButtonMotionMask
    -- ^ receive pointer motion events while any button is pressed
    | EventMaskButton1MotionMask
    -- ^ receive pointer motion events while 1 button is pressed
    | EventMaskButton2MotionMask
    -- ^ receive pointer motion events while 2 button is pressed
    | EventMaskButton3MotionMask
    -- ^ receive pointer motion events while 3 button is pressed
    | EventMaskButtonPressMask
    -- ^ receive button press events
    | EventMaskButtonReleaseMask
    -- ^ receive button release events
    | EventMaskKeyPressMask
    -- ^ receive key press events
    | EventMaskKeyReleaseMask
    -- ^ receive key release events
    | EventMaskEnterNotifyMask
    -- ^ receive surface enter events
    | EventMaskLeaveNotifyMask
    -- ^ receive surface leave events
    | EventMaskFocusChangeMask
    -- ^ receive focus change events
    | EventMaskStructureMask
    -- ^ receive events about surface configuration change
    | EventMaskPropertyChangeMask
    -- ^ receive property change events
    | EventMaskProximityInMask
    -- ^ receive proximity in events
    | EventMaskProximityOutMask
    -- ^ receive proximity out events
    | EventMaskSubstructureMask
    -- ^ receive events about surface configuration changes of child surfaces
    | EventMaskScrollMask
    -- ^ receive scroll events
    | EventMaskTouchMask
    -- ^ receive touch events
    | EventMaskSmoothScrollMask
    -- ^ receive smooth scrolling events
    | EventMaskTouchpadGestureMask
    -- ^ receive touchpad gesture events
    | EventMaskTabletPadMask
    -- ^ receive tablet pad events
    | EventMaskAllEventsMask
    -- ^ the combination of all the above event masks.
    | AnotherEventMask Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EventMask -> ShowS
[EventMask] -> ShowS
EventMask -> String
(Int -> EventMask -> ShowS)
-> (EventMask -> String)
-> ([EventMask] -> ShowS)
-> Show EventMask
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EventMask] -> ShowS
$cshowList :: [EventMask] -> ShowS
show :: EventMask -> String
$cshow :: EventMask -> String
showsPrec :: Int -> EventMask -> ShowS
$cshowsPrec :: Int -> EventMask -> ShowS
Show, EventMask -> EventMask -> Bool
(EventMask -> EventMask -> Bool)
-> (EventMask -> EventMask -> Bool) -> Eq EventMask
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventMask -> EventMask -> Bool
$c/= :: EventMask -> EventMask -> Bool
== :: EventMask -> EventMask -> Bool
$c== :: EventMask -> EventMask -> Bool
Eq)

instance P.Enum EventMask where
    fromEnum :: EventMask -> Int
fromEnum EventMaskExposureMask = 2
    fromEnum EventMaskPointerMotionMask = 4
    fromEnum EventMaskButtonMotionMask = 16
    fromEnum EventMaskButton1MotionMask = 32
    fromEnum EventMaskButton2MotionMask = 64
    fromEnum EventMaskButton3MotionMask = 128
    fromEnum EventMaskButtonPressMask = 256
    fromEnum EventMaskButtonReleaseMask = 512
    fromEnum EventMaskKeyPressMask = 1024
    fromEnum EventMaskKeyReleaseMask = 2048
    fromEnum EventMaskEnterNotifyMask = 4096
    fromEnum EventMaskLeaveNotifyMask = 8192
    fromEnum EventMaskFocusChangeMask = 16384
    fromEnum EventMaskStructureMask = 32768
    fromEnum EventMaskPropertyChangeMask = 65536
    fromEnum EventMaskProximityInMask = 262144
    fromEnum EventMaskProximityOutMask = 524288
    fromEnum EventMaskSubstructureMask = 1048576
    fromEnum EventMaskScrollMask = 2097152
    fromEnum EventMaskTouchMask = 4194304
    fromEnum EventMaskSmoothScrollMask = 8388608
    fromEnum EventMaskTouchpadGestureMask = 16777216
    fromEnum EventMaskTabletPadMask = 33554432
    fromEnum EventMaskAllEventsMask = 67108862
    fromEnum (AnotherEventMask k :: Int
k) = Int
k

    toEnum :: Int -> EventMask
toEnum 2 = EventMask
EventMaskExposureMask
    toEnum 4 = EventMask
EventMaskPointerMotionMask
    toEnum 16 = EventMask
EventMaskButtonMotionMask
    toEnum 32 = EventMask
EventMaskButton1MotionMask
    toEnum 64 = EventMask
EventMaskButton2MotionMask
    toEnum 128 = EventMask
EventMaskButton3MotionMask
    toEnum 256 = EventMask
EventMaskButtonPressMask
    toEnum 512 = EventMask
EventMaskButtonReleaseMask
    toEnum 1024 = EventMask
EventMaskKeyPressMask
    toEnum 2048 = EventMask
EventMaskKeyReleaseMask
    toEnum 4096 = EventMask
EventMaskEnterNotifyMask
    toEnum 8192 = EventMask
EventMaskLeaveNotifyMask
    toEnum 16384 = EventMask
EventMaskFocusChangeMask
    toEnum 32768 = EventMask
EventMaskStructureMask
    toEnum 65536 = EventMask
EventMaskPropertyChangeMask
    toEnum 262144 = EventMask
EventMaskProximityInMask
    toEnum 524288 = EventMask
EventMaskProximityOutMask
    toEnum 1048576 = EventMask
EventMaskSubstructureMask
    toEnum 2097152 = EventMask
EventMaskScrollMask
    toEnum 4194304 = EventMask
EventMaskTouchMask
    toEnum 8388608 = EventMask
EventMaskSmoothScrollMask
    toEnum 16777216 = EventMask
EventMaskTouchpadGestureMask
    toEnum 33554432 = EventMask
EventMaskTabletPadMask
    toEnum 67108862 = EventMask
EventMaskAllEventsMask
    toEnum k :: Int
k = Int -> EventMask
AnotherEventMask Int
k

instance P.Ord EventMask where
    compare :: EventMask -> EventMask -> Ordering
compare a :: EventMask
a b :: EventMask
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (EventMask -> Int
forall a. Enum a => a -> Int
P.fromEnum EventMask
a) (EventMask -> Int
forall a. Enum a => a -> Int
P.fromEnum EventMask
b)

foreign import ccall "gdk_event_mask_get_type" c_gdk_event_mask_get_type :: 
    IO GType

instance BoxedFlags EventMask where
    boxedFlagsType :: Proxy EventMask -> IO GType
boxedFlagsType _ = IO GType
c_gdk_event_mask_get_type

instance IsGFlag EventMask

-- Flags DragAction
-- | Used in t'GI.Gdk.Objects.Drag.Drag' to indicate what the destination
-- should do with the dropped data.
data DragAction = 
      DragActionCopy
    -- ^ Copy the data.
    | DragActionMove
    -- ^ Move the data, i.e. first copy it, then delete
    --  it from the source using the DELETE target of the X selection protocol.
    | DragActionLink
    -- ^ Add a link to the data. Note that this is only
    --  useful if source and destination agree on what it means.
    | DragActionAsk
    -- ^ Ask the user what to do with the data.
    | AnotherDragAction Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DragAction -> ShowS
[DragAction] -> ShowS
DragAction -> String
(Int -> DragAction -> ShowS)
-> (DragAction -> String)
-> ([DragAction] -> ShowS)
-> Show DragAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DragAction] -> ShowS
$cshowList :: [DragAction] -> ShowS
show :: DragAction -> String
$cshow :: DragAction -> String
showsPrec :: Int -> DragAction -> ShowS
$cshowsPrec :: Int -> DragAction -> ShowS
Show, DragAction -> DragAction -> Bool
(DragAction -> DragAction -> Bool)
-> (DragAction -> DragAction -> Bool) -> Eq DragAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DragAction -> DragAction -> Bool
$c/= :: DragAction -> DragAction -> Bool
== :: DragAction -> DragAction -> Bool
$c== :: DragAction -> DragAction -> Bool
Eq)

instance P.Enum DragAction where
    fromEnum :: DragAction -> Int
fromEnum DragActionCopy = 1
    fromEnum DragActionMove = 2
    fromEnum DragActionLink = 4
    fromEnum DragActionAsk = 8
    fromEnum (AnotherDragAction k :: Int
k) = Int
k

    toEnum :: Int -> DragAction
toEnum 1 = DragAction
DragActionCopy
    toEnum 2 = DragAction
DragActionMove
    toEnum 4 = DragAction
DragActionLink
    toEnum 8 = DragAction
DragActionAsk
    toEnum k :: Int
k = Int -> DragAction
AnotherDragAction Int
k

instance P.Ord DragAction where
    compare :: DragAction -> DragAction -> Ordering
compare a :: DragAction
a b :: DragAction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DragAction -> Int
forall a. Enum a => a -> Int
P.fromEnum DragAction
a) (DragAction -> Int
forall a. Enum a => a -> Int
P.fromEnum DragAction
b)

foreign import ccall "gdk_drag_action_get_type" c_gdk_drag_action_get_type :: 
    IO GType

instance BoxedFlags DragAction where
    boxedFlagsType :: Proxy DragAction -> IO GType
boxedFlagsType _ = IO GType
c_gdk_drag_action_get_type

instance IsGFlag DragAction

-- Flags AxisFlags
-- | Flags describing the current capabilities of a device\/tool.
data AxisFlags = 
      AxisFlagsX
    -- ^ X axis is present
    | AxisFlagsY
    -- ^ Y axis is present
    | AxisFlagsPressure
    -- ^ Pressure axis is present
    | AxisFlagsXtilt
    -- ^ X tilt axis is present
    | AxisFlagsYtilt
    -- ^ Y tilt axis is present
    | AxisFlagsWheel
    -- ^ Wheel axis is present
    | AxisFlagsDistance
    -- ^ Distance axis is present
    | AxisFlagsRotation
    -- ^ Z-axis rotation is present
    | AxisFlagsSlider
    -- ^ Slider axis is present
    | AnotherAxisFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AxisFlags -> ShowS
[AxisFlags] -> ShowS
AxisFlags -> String
(Int -> AxisFlags -> ShowS)
-> (AxisFlags -> String)
-> ([AxisFlags] -> ShowS)
-> Show AxisFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AxisFlags] -> ShowS
$cshowList :: [AxisFlags] -> ShowS
show :: AxisFlags -> String
$cshow :: AxisFlags -> String
showsPrec :: Int -> AxisFlags -> ShowS
$cshowsPrec :: Int -> AxisFlags -> ShowS
Show, AxisFlags -> AxisFlags -> Bool
(AxisFlags -> AxisFlags -> Bool)
-> (AxisFlags -> AxisFlags -> Bool) -> Eq AxisFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AxisFlags -> AxisFlags -> Bool
$c/= :: AxisFlags -> AxisFlags -> Bool
== :: AxisFlags -> AxisFlags -> Bool
$c== :: AxisFlags -> AxisFlags -> Bool
Eq)

instance P.Enum AxisFlags where
    fromEnum :: AxisFlags -> Int
fromEnum AxisFlagsX = 2
    fromEnum AxisFlagsY = 4
    fromEnum AxisFlagsPressure = 8
    fromEnum AxisFlagsXtilt = 16
    fromEnum AxisFlagsYtilt = 32
    fromEnum AxisFlagsWheel = 64
    fromEnum AxisFlagsDistance = 128
    fromEnum AxisFlagsRotation = 256
    fromEnum AxisFlagsSlider = 512
    fromEnum (AnotherAxisFlags k :: Int
k) = Int
k

    toEnum :: Int -> AxisFlags
toEnum 2 = AxisFlags
AxisFlagsX
    toEnum 4 = AxisFlags
AxisFlagsY
    toEnum 8 = AxisFlags
AxisFlagsPressure
    toEnum 16 = AxisFlags
AxisFlagsXtilt
    toEnum 32 = AxisFlags
AxisFlagsYtilt
    toEnum 64 = AxisFlags
AxisFlagsWheel
    toEnum 128 = AxisFlags
AxisFlagsDistance
    toEnum 256 = AxisFlags
AxisFlagsRotation
    toEnum 512 = AxisFlags
AxisFlagsSlider
    toEnum k :: Int
k = Int -> AxisFlags
AnotherAxisFlags Int
k

instance P.Ord AxisFlags where
    compare :: AxisFlags -> AxisFlags -> Ordering
compare a :: AxisFlags
a b :: AxisFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AxisFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AxisFlags
a) (AxisFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AxisFlags
b)

foreign import ccall "gdk_axis_flags_get_type" c_gdk_axis_flags_get_type :: 
    IO GType

instance BoxedFlags AxisFlags where
    boxedFlagsType :: Proxy AxisFlags -> IO GType
boxedFlagsType _ = IO GType
c_gdk_axis_flags_get_type

instance IsGFlag AxisFlags

-- Flags AnchorHints
-- | Positioning hints for aligning a surface relative to a rectangle.
-- 
-- These hints determine how the surface should be positioned in the case that
-- the surface would fall off-screen if placed in its ideal position.
-- 
-- For example, 'GI.Gdk.Flags.AnchorHintsFlipX' will replace 'GI.Gdk.Enums.GravityNorthWest' with
-- 'GI.Gdk.Enums.GravityNorthEast' and vice versa if the surface extends beyond the left
-- or right edges of the monitor.
-- 
-- If 'GI.Gdk.Flags.AnchorHintsSlideX' is set, the surface can be shifted horizontally to fit
-- on-screen. If 'GI.Gdk.Flags.AnchorHintsResizeX' is set, the surface can be shrunken
-- horizontally to fit.
-- 
-- In general, when multiple flags are set, flipping should take precedence over
-- sliding, which should take precedence over resizing.
data AnchorHints = 
      AnchorHintsFlipX
    -- ^ allow flipping anchors horizontally
    | AnchorHintsFlipY
    -- ^ allow flipping anchors vertically
    | AnchorHintsSlideX
    -- ^ allow sliding surface horizontally
    | AnchorHintsSlideY
    -- ^ allow sliding surface vertically
    | AnchorHintsResizeX
    -- ^ allow resizing surface horizontally
    | AnchorHintsResizeY
    -- ^ allow resizing surface vertically
    | AnchorHintsFlip
    -- ^ allow flipping anchors on both axes
    | AnchorHintsSlide
    -- ^ allow sliding surface on both axes
    | AnchorHintsResize
    -- ^ allow resizing surface on both axes
    | AnotherAnchorHints Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AnchorHints -> ShowS
[AnchorHints] -> ShowS
AnchorHints -> String
(Int -> AnchorHints -> ShowS)
-> (AnchorHints -> String)
-> ([AnchorHints] -> ShowS)
-> Show AnchorHints
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnchorHints] -> ShowS
$cshowList :: [AnchorHints] -> ShowS
show :: AnchorHints -> String
$cshow :: AnchorHints -> String
showsPrec :: Int -> AnchorHints -> ShowS
$cshowsPrec :: Int -> AnchorHints -> ShowS
Show, AnchorHints -> AnchorHints -> Bool
(AnchorHints -> AnchorHints -> Bool)
-> (AnchorHints -> AnchorHints -> Bool) -> Eq AnchorHints
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnchorHints -> AnchorHints -> Bool
$c/= :: AnchorHints -> AnchorHints -> Bool
== :: AnchorHints -> AnchorHints -> Bool
$c== :: AnchorHints -> AnchorHints -> Bool
Eq)

instance P.Enum AnchorHints where
    fromEnum :: AnchorHints -> Int
fromEnum AnchorHintsFlipX = 1
    fromEnum AnchorHintsFlipY = 2
    fromEnum AnchorHintsSlideX = 4
    fromEnum AnchorHintsSlideY = 8
    fromEnum AnchorHintsResizeX = 16
    fromEnum AnchorHintsResizeY = 32
    fromEnum AnchorHintsFlip = 3
    fromEnum AnchorHintsSlide = 12
    fromEnum AnchorHintsResize = 48
    fromEnum (AnotherAnchorHints k :: Int
k) = Int
k

    toEnum :: Int -> AnchorHints
toEnum 1 = AnchorHints
AnchorHintsFlipX
    toEnum 2 = AnchorHints
AnchorHintsFlipY
    toEnum 4 = AnchorHints
AnchorHintsSlideX
    toEnum 8 = AnchorHints
AnchorHintsSlideY
    toEnum 16 = AnchorHints
AnchorHintsResizeX
    toEnum 32 = AnchorHints
AnchorHintsResizeY
    toEnum 3 = AnchorHints
AnchorHintsFlip
    toEnum 12 = AnchorHints
AnchorHintsSlide
    toEnum 48 = AnchorHints
AnchorHintsResize
    toEnum k :: Int
k = Int -> AnchorHints
AnotherAnchorHints Int
k

instance P.Ord AnchorHints where
    compare :: AnchorHints -> AnchorHints -> Ordering
compare a :: AnchorHints
a b :: AnchorHints
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AnchorHints -> Int
forall a. Enum a => a -> Int
P.fromEnum AnchorHints
a) (AnchorHints -> Int
forall a. Enum a => a -> Int
P.fromEnum AnchorHints
b)

foreign import ccall "gdk_anchor_hints_get_type" c_gdk_anchor_hints_get_type :: 
    IO GType

instance BoxedFlags AnchorHints where
    boxedFlagsType :: Proxy AnchorHints -> IO GType
boxedFlagsType _ = IO GType
c_gdk_anchor_hints_get_type

instance IsGFlag AnchorHints