-- | 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(..)                        ,


-- ** SeatCapabilities #flag:SeatCapabilities#

    SeatCapabilities(..)                    ,


-- ** WMDecoration #flag:WMDecoration#

    WMDecoration(..)                        ,


-- ** WMFunction #flag:WMFunction#

    WMFunction(..)                          ,


-- ** WindowAttributesType #flag:WindowAttributesType#

    WindowAttributesType(..)                ,


-- ** WindowHints #flag:WindowHints#

    WindowHints(..)                         ,


-- ** WindowState #flag:WindowState#

    WindowState(..)                         ,




    ) 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.BasicTypes as B.Types
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 Control.Monad.IO.Class as MIO
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 WindowState
-- | Specifies the state of a toplevel window.
data WindowState = 
      WindowStateWithdrawn
    -- ^ the window is not shown.
    | WindowStateIconified
    -- ^ the window is minimized.
    | WindowStateMaximized
    -- ^ the window is maximized.
    | WindowStateSticky
    -- ^ the window is sticky.
    | WindowStateFullscreen
    -- ^ the window is maximized without
    --   decorations.
    | WindowStateAbove
    -- ^ the window is kept above other windows.
    | WindowStateBelow
    -- ^ the window is kept below other windows.
    | WindowStateFocused
    -- ^ the window is presented as focused (with active decorations).
    | WindowStateTiled
    -- ^ the window is in a tiled state, Since 3.10. Since 3.22.23, this
    --                          is deprecated in favor of per-edge information.
    | WindowStateTopTiled
    -- ^ whether the top edge is tiled, Since 3.22.23
    | WindowStateTopResizable
    -- ^ whether the top edge is resizable, Since 3.22.23
    | WindowStateRightTiled
    -- ^ whether the right edge is tiled, Since 3.22.23
    | WindowStateRightResizable
    -- ^ whether the right edge is resizable, Since 3.22.23
    | WindowStateBottomTiled
    -- ^ whether the bottom edge is tiled, Since 3.22.23
    | WindowStateBottomResizable
    -- ^ whether the bottom edge is resizable, Since 3.22.23
    | WindowStateLeftTiled
    -- ^ whether the left edge is tiled, Since 3.22.23
    | WindowStateLeftResizable
    -- ^ whether the left edge is resizable, Since 3.22.23
    | AnotherWindowState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WindowState -> ShowS
[WindowState] -> ShowS
WindowState -> String
(Int -> WindowState -> ShowS)
-> (WindowState -> String)
-> ([WindowState] -> ShowS)
-> Show WindowState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowState] -> ShowS
$cshowList :: [WindowState] -> ShowS
show :: WindowState -> String
$cshow :: WindowState -> String
showsPrec :: Int -> WindowState -> ShowS
$cshowsPrec :: Int -> WindowState -> ShowS
Show, WindowState -> WindowState -> Bool
(WindowState -> WindowState -> Bool)
-> (WindowState -> WindowState -> Bool) -> Eq WindowState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowState -> WindowState -> Bool
$c/= :: WindowState -> WindowState -> Bool
== :: WindowState -> WindowState -> Bool
$c== :: WindowState -> WindowState -> Bool
Eq)

instance P.Enum WindowState where
    fromEnum :: WindowState -> Int
fromEnum WindowState
WindowStateWithdrawn = Int
1
    fromEnum WindowState
WindowStateIconified = Int
2
    fromEnum WindowState
WindowStateMaximized = Int
4
    fromEnum WindowState
WindowStateSticky = Int
8
    fromEnum WindowState
WindowStateFullscreen = Int
16
    fromEnum WindowState
WindowStateAbove = Int
32
    fromEnum WindowState
WindowStateBelow = Int
64
    fromEnum WindowState
WindowStateFocused = Int
128
    fromEnum WindowState
WindowStateTiled = Int
256
    fromEnum WindowState
WindowStateTopTiled = Int
512
    fromEnum WindowState
WindowStateTopResizable = Int
1024
    fromEnum WindowState
WindowStateRightTiled = Int
2048
    fromEnum WindowState
WindowStateRightResizable = Int
4096
    fromEnum WindowState
WindowStateBottomTiled = Int
8192
    fromEnum WindowState
WindowStateBottomResizable = Int
16384
    fromEnum WindowState
WindowStateLeftTiled = Int
32768
    fromEnum WindowState
WindowStateLeftResizable = Int
65536
    fromEnum (AnotherWindowState Int
k) = Int
k

    toEnum :: Int -> WindowState
toEnum Int
1 = WindowState
WindowStateWithdrawn
    toEnum Int
2 = WindowState
WindowStateIconified
    toEnum Int
4 = WindowState
WindowStateMaximized
    toEnum Int
8 = WindowState
WindowStateSticky
    toEnum Int
16 = WindowState
WindowStateFullscreen
    toEnum Int
32 = WindowState
WindowStateAbove
    toEnum Int
64 = WindowState
WindowStateBelow
    toEnum Int
128 = WindowState
WindowStateFocused
    toEnum Int
256 = WindowState
WindowStateTiled
    toEnum Int
512 = WindowState
WindowStateTopTiled
    toEnum Int
1024 = WindowState
WindowStateTopResizable
    toEnum Int
2048 = WindowState
WindowStateRightTiled
    toEnum Int
4096 = WindowState
WindowStateRightResizable
    toEnum Int
8192 = WindowState
WindowStateBottomTiled
    toEnum Int
16384 = WindowState
WindowStateBottomResizable
    toEnum Int
32768 = WindowState
WindowStateLeftTiled
    toEnum Int
65536 = WindowState
WindowStateLeftResizable
    toEnum Int
k = Int -> WindowState
AnotherWindowState Int
k

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

type instance O.ParentTypes WindowState = '[]
instance O.HasParentTypes WindowState

foreign import ccall "gdk_window_state_get_type" c_gdk_window_state_get_type :: 
    IO GType

instance B.Types.TypedObject WindowState where
    glibType :: IO GType
glibType = IO GType
c_gdk_window_state_get_type

instance B.Types.BoxedFlags WindowState

instance IsGFlag WindowState

-- Flags WindowHints
-- | 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 WindowHints = 
      WindowHintsPos
    -- ^ indicates that the program has positioned the window
    | WindowHintsMinSize
    -- ^ min size fields are set
    | WindowHintsMaxSize
    -- ^ max size fields are set
    | WindowHintsBaseSize
    -- ^ base size fields are set
    | WindowHintsAspect
    -- ^ aspect ratio fields are set
    | WindowHintsResizeInc
    -- ^ resize increment fields are set
    | WindowHintsWinGravity
    -- ^ window gravity field is set
    | WindowHintsUserPos
    -- ^ indicates that the window’s position was explicitly set
    --  by the user
    | WindowHintsUserSize
    -- ^ indicates that the window’s size was explicitly set by
    --  the user
    | AnotherWindowHints Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WindowHints -> ShowS
[WindowHints] -> ShowS
WindowHints -> String
(Int -> WindowHints -> ShowS)
-> (WindowHints -> String)
-> ([WindowHints] -> ShowS)
-> Show WindowHints
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowHints] -> ShowS
$cshowList :: [WindowHints] -> ShowS
show :: WindowHints -> String
$cshow :: WindowHints -> String
showsPrec :: Int -> WindowHints -> ShowS
$cshowsPrec :: Int -> WindowHints -> ShowS
Show, WindowHints -> WindowHints -> Bool
(WindowHints -> WindowHints -> Bool)
-> (WindowHints -> WindowHints -> Bool) -> Eq WindowHints
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowHints -> WindowHints -> Bool
$c/= :: WindowHints -> WindowHints -> Bool
== :: WindowHints -> WindowHints -> Bool
$c== :: WindowHints -> WindowHints -> Bool
Eq)

instance P.Enum WindowHints where
    fromEnum :: WindowHints -> Int
fromEnum WindowHints
WindowHintsPos = Int
1
    fromEnum WindowHints
WindowHintsMinSize = Int
2
    fromEnum WindowHints
WindowHintsMaxSize = Int
4
    fromEnum WindowHints
WindowHintsBaseSize = Int
8
    fromEnum WindowHints
WindowHintsAspect = Int
16
    fromEnum WindowHints
WindowHintsResizeInc = Int
32
    fromEnum WindowHints
WindowHintsWinGravity = Int
64
    fromEnum WindowHints
WindowHintsUserPos = Int
128
    fromEnum WindowHints
WindowHintsUserSize = Int
256
    fromEnum (AnotherWindowHints Int
k) = Int
k

    toEnum :: Int -> WindowHints
toEnum Int
1 = WindowHints
WindowHintsPos
    toEnum Int
2 = WindowHints
WindowHintsMinSize
    toEnum Int
4 = WindowHints
WindowHintsMaxSize
    toEnum Int
8 = WindowHints
WindowHintsBaseSize
    toEnum Int
16 = WindowHints
WindowHintsAspect
    toEnum Int
32 = WindowHints
WindowHintsResizeInc
    toEnum Int
64 = WindowHints
WindowHintsWinGravity
    toEnum Int
128 = WindowHints
WindowHintsUserPos
    toEnum Int
256 = WindowHints
WindowHintsUserSize
    toEnum Int
k = Int -> WindowHints
AnotherWindowHints Int
k

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

type instance O.ParentTypes WindowHints = '[]
instance O.HasParentTypes WindowHints

foreign import ccall "gdk_window_hints_get_type" c_gdk_window_hints_get_type :: 
    IO GType

instance B.Types.TypedObject WindowHints where
    glibType :: IO GType
glibType = IO GType
c_gdk_window_hints_get_type

instance B.Types.BoxedFlags WindowHints

instance IsGFlag WindowHints

-- Flags WindowAttributesType
-- | Used to indicate which fields in the t'GI.Gdk.Structs.WindowAttr.WindowAttr' struct should be honored.
-- For example, if you filled in the “cursor” and “x” fields of t'GI.Gdk.Structs.WindowAttr.WindowAttr',
-- pass “/@gDKWAX@/ | /@gDKWACURSOR@/” to 'GI.Gdk.Objects.Window.windowNew'. Fields in
-- t'GI.Gdk.Structs.WindowAttr.WindowAttr' not covered by a bit in this enum are required; for example,
-- the /@width@/\//@height@/, /@wclass@/, and /@windowType@/ fields are required, they have
-- no corresponding flag in t'GI.Gdk.Flags.WindowAttributesType'.
data WindowAttributesType = 
      WindowAttributesTypeTitle
    -- ^ Honor the title field
    | WindowAttributesTypeX
    -- ^ Honor the X coordinate field
    | WindowAttributesTypeY
    -- ^ Honor the Y coordinate field
    | WindowAttributesTypeCursor
    -- ^ Honor the cursor field
    | WindowAttributesTypeVisual
    -- ^ Honor the visual field
    | WindowAttributesTypeWmclass
    -- ^ Honor the wmclass_class and wmclass_name fields
    | WindowAttributesTypeNoredir
    -- ^ Honor the override_redirect field
    | WindowAttributesTypeTypeHint
    -- ^ Honor the type_hint field
    | AnotherWindowAttributesType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WindowAttributesType -> ShowS
[WindowAttributesType] -> ShowS
WindowAttributesType -> String
(Int -> WindowAttributesType -> ShowS)
-> (WindowAttributesType -> String)
-> ([WindowAttributesType] -> ShowS)
-> Show WindowAttributesType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowAttributesType] -> ShowS
$cshowList :: [WindowAttributesType] -> ShowS
show :: WindowAttributesType -> String
$cshow :: WindowAttributesType -> String
showsPrec :: Int -> WindowAttributesType -> ShowS
$cshowsPrec :: Int -> WindowAttributesType -> ShowS
Show, WindowAttributesType -> WindowAttributesType -> Bool
(WindowAttributesType -> WindowAttributesType -> Bool)
-> (WindowAttributesType -> WindowAttributesType -> Bool)
-> Eq WindowAttributesType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowAttributesType -> WindowAttributesType -> Bool
$c/= :: WindowAttributesType -> WindowAttributesType -> Bool
== :: WindowAttributesType -> WindowAttributesType -> Bool
$c== :: WindowAttributesType -> WindowAttributesType -> Bool
Eq)

instance P.Enum WindowAttributesType where
    fromEnum :: WindowAttributesType -> Int
fromEnum WindowAttributesType
WindowAttributesTypeTitle = Int
2
    fromEnum WindowAttributesType
WindowAttributesTypeX = Int
4
    fromEnum WindowAttributesType
WindowAttributesTypeY = Int
8
    fromEnum WindowAttributesType
WindowAttributesTypeCursor = Int
16
    fromEnum WindowAttributesType
WindowAttributesTypeVisual = Int
32
    fromEnum WindowAttributesType
WindowAttributesTypeWmclass = Int
64
    fromEnum WindowAttributesType
WindowAttributesTypeNoredir = Int
128
    fromEnum WindowAttributesType
WindowAttributesTypeTypeHint = Int
256
    fromEnum (AnotherWindowAttributesType Int
k) = Int
k

    toEnum :: Int -> WindowAttributesType
toEnum Int
2 = WindowAttributesType
WindowAttributesTypeTitle
    toEnum Int
4 = WindowAttributesType
WindowAttributesTypeX
    toEnum Int
8 = WindowAttributesType
WindowAttributesTypeY
    toEnum Int
16 = WindowAttributesType
WindowAttributesTypeCursor
    toEnum Int
32 = WindowAttributesType
WindowAttributesTypeVisual
    toEnum Int
64 = WindowAttributesType
WindowAttributesTypeWmclass
    toEnum Int
128 = WindowAttributesType
WindowAttributesTypeNoredir
    toEnum Int
256 = WindowAttributesType
WindowAttributesTypeTypeHint
    toEnum Int
k = Int -> WindowAttributesType
AnotherWindowAttributesType Int
k

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

type instance O.ParentTypes WindowAttributesType = '[]
instance O.HasParentTypes WindowAttributesType

foreign import ccall "gdk_window_attributes_type_get_type" c_gdk_window_attributes_type_get_type :: 
    IO GType

instance B.Types.TypedObject WindowAttributesType where
    glibType :: IO GType
glibType = IO GType
c_gdk_window_attributes_type_get_type

instance B.Types.BoxedFlags WindowAttributesType

instance IsGFlag WindowAttributesType

-- 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 window. The
-- hint must be set before mapping the window.
data WMFunction = 
      WMFunctionAll
    -- ^ all functions should be offered.
    | WMFunctionResize
    -- ^ the window should be resizable.
    | WMFunctionMove
    -- ^ the window should be movable.
    | WMFunctionMinimize
    -- ^ the window should be minimizable.
    | WMFunctionMaximize
    -- ^ the window should be maximizable.
    | WMFunctionClose
    -- ^ the window 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 WMFunction
WMFunctionAll = Int
1
    fromEnum WMFunction
WMFunctionResize = Int
2
    fromEnum WMFunction
WMFunctionMove = Int
4
    fromEnum WMFunction
WMFunctionMinimize = Int
8
    fromEnum WMFunction
WMFunctionMaximize = Int
16
    fromEnum WMFunction
WMFunctionClose = Int
32
    fromEnum (AnotherWMFunction Int
k) = Int
k

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

instance P.Ord WMFunction where
    compare :: WMFunction -> WMFunction -> Ordering
compare WMFunction
a 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)

type instance O.ParentTypes WMFunction = '[]
instance O.HasParentTypes WMFunction

foreign import ccall "gdk_wm_function_get_type" c_gdk_wm_function_get_type :: 
    IO GType

instance B.Types.TypedObject WMFunction where
    glibType :: IO GType
glibType = IO GType
c_gdk_wm_function_get_type

instance B.Types.BoxedFlags WMFunction

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 window. The hint must be set before mapping the window.
data WMDecoration = 
      WMDecorationAll
    -- ^ all decorations should be applied.
    | WMDecorationBorder
    -- ^ a frame should be drawn around the window.
    | WMDecorationResizeh
    -- ^ the frame should have resize handles.
    | WMDecorationTitle
    -- ^ a titlebar should be placed above the window.
    | 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 WMDecoration
WMDecorationAll = Int
1
    fromEnum WMDecoration
WMDecorationBorder = Int
2
    fromEnum WMDecoration
WMDecorationResizeh = Int
4
    fromEnum WMDecoration
WMDecorationTitle = Int
8
    fromEnum WMDecoration
WMDecorationMenu = Int
16
    fromEnum WMDecoration
WMDecorationMinimize = Int
32
    fromEnum WMDecoration
WMDecorationMaximize = Int
64
    fromEnum (AnotherWMDecoration Int
k) = Int
k

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

instance P.Ord WMDecoration where
    compare :: WMDecoration -> WMDecoration -> Ordering
compare WMDecoration
a 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)

type instance O.ParentTypes WMDecoration = '[]
instance O.HasParentTypes WMDecoration

foreign import ccall "gdk_wm_decoration_get_type" c_gdk_wm_decoration_get_type :: 
    IO GType

instance B.Types.TypedObject WMDecoration where
    glibType :: IO GType
glibType = IO GType
c_gdk_wm_decoration_get_type

instance B.Types.BoxedFlags WMDecoration

instance IsGFlag WMDecoration

-- Flags SeatCapabilities
-- | Flags describing the seat capabilities.
-- 
-- /Since: 3.20/
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
    | 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 SeatCapabilities
SeatCapabilitiesNone = Int
0
    fromEnum SeatCapabilities
SeatCapabilitiesPointer = Int
1
    fromEnum SeatCapabilities
SeatCapabilitiesTouch = Int
2
    fromEnum SeatCapabilities
SeatCapabilitiesTabletStylus = Int
4
    fromEnum SeatCapabilities
SeatCapabilitiesKeyboard = Int
8
    fromEnum SeatCapabilities
SeatCapabilitiesAllPointing = Int
7
    fromEnum SeatCapabilities
SeatCapabilitiesAll = Int
15
    fromEnum (AnotherSeatCapabilities Int
k) = Int
k

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

instance P.Ord SeatCapabilities where
    compare :: SeatCapabilities -> SeatCapabilities -> Ordering
compare SeatCapabilities
a 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)

type instance O.ParentTypes SeatCapabilities = '[]
instance O.HasParentTypes SeatCapabilities

foreign import ccall "gdk_seat_capabilities_get_type" c_gdk_seat_capabilities_get_type :: 
    IO GType

instance B.Types.TypedObject SeatCapabilities where
    glibType :: IO GType
glibType = IO GType
c_gdk_seat_capabilities_get_type

instance B.Types.BoxedFlags SeatCapabilities

instance IsGFlag SeatCapabilities

-- 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.
-- 
-- Since 2.10, 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. Since 2.10
    | ModifierTypeHyperMask
    -- ^ the Hyper modifier. Since 2.10
    | ModifierTypeMetaMask
    -- ^ the Meta modifier. Since 2.10
    | 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 ModifierType
ModifierTypeShiftMask = Int
1
    fromEnum ModifierType
ModifierTypeLockMask = Int
2
    fromEnum ModifierType
ModifierTypeControlMask = Int
4
    fromEnum ModifierType
ModifierTypeMod1Mask = Int
8
    fromEnum ModifierType
ModifierTypeMod2Mask = Int
16
    fromEnum ModifierType
ModifierTypeMod3Mask = Int
32
    fromEnum ModifierType
ModifierTypeMod4Mask = Int
64
    fromEnum ModifierType
ModifierTypeMod5Mask = Int
128
    fromEnum ModifierType
ModifierTypeButton1Mask = Int
256
    fromEnum ModifierType
ModifierTypeButton2Mask = Int
512
    fromEnum ModifierType
ModifierTypeButton3Mask = Int
1024
    fromEnum ModifierType
ModifierTypeButton4Mask = Int
2048
    fromEnum ModifierType
ModifierTypeButton5Mask = Int
4096
    fromEnum ModifierType
ModifierTypeModifierReserved13Mask = Int
8192
    fromEnum ModifierType
ModifierTypeModifierReserved14Mask = Int
16384
    fromEnum ModifierType
ModifierTypeModifierReserved15Mask = Int
32768
    fromEnum ModifierType
ModifierTypeModifierReserved16Mask = Int
65536
    fromEnum ModifierType
ModifierTypeModifierReserved17Mask = Int
131072
    fromEnum ModifierType
ModifierTypeModifierReserved18Mask = Int
262144
    fromEnum ModifierType
ModifierTypeModifierReserved19Mask = Int
524288
    fromEnum ModifierType
ModifierTypeModifierReserved20Mask = Int
1048576
    fromEnum ModifierType
ModifierTypeModifierReserved21Mask = Int
2097152
    fromEnum ModifierType
ModifierTypeModifierReserved22Mask = Int
4194304
    fromEnum ModifierType
ModifierTypeModifierReserved23Mask = Int
8388608
    fromEnum ModifierType
ModifierTypeModifierReserved24Mask = Int
16777216
    fromEnum ModifierType
ModifierTypeModifierReserved25Mask = Int
33554432
    fromEnum ModifierType
ModifierTypeSuperMask = Int
67108864
    fromEnum ModifierType
ModifierTypeHyperMask = Int
134217728
    fromEnum ModifierType
ModifierTypeMetaMask = Int
268435456
    fromEnum ModifierType
ModifierTypeModifierReserved29Mask = Int
536870912
    fromEnum ModifierType
ModifierTypeReleaseMask = Int
1073741824
    fromEnum ModifierType
ModifierTypeModifierMask = Int
1543512063
    fromEnum (AnotherModifierType Int
k) = Int
k

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

instance P.Ord ModifierType where
    compare :: ModifierType -> ModifierType -> Ordering
compare ModifierType
a 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)

type instance O.ParentTypes ModifierType = '[]
instance O.HasParentTypes ModifierType

foreign import ccall "gdk_modifier_type_get_type" c_gdk_modifier_type_get_type :: 
    IO GType

instance B.Types.TypedObject ModifierType where
    glibType :: IO GType
glibType = IO GType
c_gdk_modifier_type_get_type

instance B.Types.BoxedFlags ModifierType

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'.
-- 
-- /Since: 3.8/
data FrameClockPhase = 
      FrameClockPhaseNone
    -- ^ no phase
    | FrameClockPhaseFlushEvents
    -- ^ corresponds to GdkFrameClock[flushEvents](#g:signal:flushEvents). Should not be handled by applications.
    | FrameClockPhaseBeforePaint
    -- ^ corresponds to GdkFrameClock[beforePaint](#g:signal:beforePaint). Should not be handled by applications.
    | FrameClockPhaseUpdate
    -- ^ corresponds to GdkFrameClock[update](#g:signal:update).
    | FrameClockPhaseLayout
    -- ^ corresponds to GdkFrameClock[layout](#g:signal:layout).
    | FrameClockPhasePaint
    -- ^ corresponds to GdkFrameClock[paint](#g:signal:paint).
    | FrameClockPhaseResumeEvents
    -- ^ corresponds to GdkFrameClock[resumeEvents](#g:signal:resumeEvents). Should not be handled by applications.
    | FrameClockPhaseAfterPaint
    -- ^ corresponds to GdkFrameClock[afterPaint](#g: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 FrameClockPhase
FrameClockPhaseNone = Int
0
    fromEnum FrameClockPhase
FrameClockPhaseFlushEvents = Int
1
    fromEnum FrameClockPhase
FrameClockPhaseBeforePaint = Int
2
    fromEnum FrameClockPhase
FrameClockPhaseUpdate = Int
4
    fromEnum FrameClockPhase
FrameClockPhaseLayout = Int
8
    fromEnum FrameClockPhase
FrameClockPhasePaint = Int
16
    fromEnum FrameClockPhase
FrameClockPhaseResumeEvents = Int
32
    fromEnum FrameClockPhase
FrameClockPhaseAfterPaint = Int
64
    fromEnum (AnotherFrameClockPhase Int
k) = Int
k

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

instance P.Ord FrameClockPhase where
    compare :: FrameClockPhase -> FrameClockPhase -> Ordering
compare FrameClockPhase
a 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)

type instance O.ParentTypes FrameClockPhase = '[]
instance O.HasParentTypes FrameClockPhase

foreign import ccall "gdk_frame_clock_phase_get_type" c_gdk_frame_clock_phase_get_type :: 
    IO GType

instance B.Types.TypedObject FrameClockPhase where
    glibType :: IO GType
glibType = IO GType
c_gdk_frame_clock_phase_get_type

instance B.Types.BoxedFlags FrameClockPhase

instance IsGFlag FrameClockPhase

-- Flags EventMask
-- | A set of bit-flags to indicate which events a window 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].
-- 
-- 'GI.Gdk.Flags.EventMaskPointerMotionHintMask' is deprecated. It is a special mask
-- to reduce the number of 'GI.Gdk.Enums.EventTypeMotionNotify' events received. When using
-- 'GI.Gdk.Flags.EventMaskPointerMotionHintMask', fewer 'GI.Gdk.Enums.EventTypeMotionNotify' events will
-- be sent, some of which are marked as a hint (the is_hint member is
-- 'P.True'). To receive more motion events after a motion hint event,
-- the application needs to asks for more, by calling
-- 'GI.Gdk.Functions.eventRequestMotions'.
-- 
-- Since GTK 3.8, motion events are already compressed by default, independent
-- of this mechanism. This compression can be disabled with
-- 'GI.Gdk.Objects.Window.windowSetEventCompression'. See the documentation of that function
-- for details.
-- 
-- If 'GI.Gdk.Flags.EventMaskTouchMask' is enabled, the window 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.Unions.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
    | EventMaskPointerMotionHintMask
    -- ^ deprecated. see the explanation above
    | 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 window enter events
    | EventMaskLeaveNotifyMask
    -- ^ receive window leave events
    | EventMaskFocusChangeMask
    -- ^ receive focus change events
    | EventMaskStructureMask
    -- ^ receive events about window configuration change
    | EventMaskPropertyChangeMask
    -- ^ receive property change events
    | EventMaskVisibilityNotifyMask
    -- ^ receive visibility change events
    | EventMaskProximityInMask
    -- ^ receive proximity in events
    | EventMaskProximityOutMask
    -- ^ receive proximity out events
    | EventMaskSubstructureMask
    -- ^ receive events about window configuration changes of
    --   child windows
    | EventMaskScrollMask
    -- ^ receive scroll events
    | EventMaskTouchMask
    -- ^ receive touch events. Since 3.4
    | EventMaskSmoothScrollMask
    -- ^ receive smooth scrolling events. Since 3.4
    | EventMaskTouchpadGestureMask
    -- ^ receive touchpad gesture events. Since 3.18
    | EventMaskTabletPadMask
    -- ^ receive tablet pad events. Since 3.22
    | 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 EventMask
EventMaskExposureMask = Int
2
    fromEnum EventMask
EventMaskPointerMotionMask = Int
4
    fromEnum EventMask
EventMaskPointerMotionHintMask = Int
8
    fromEnum EventMask
EventMaskButtonMotionMask = Int
16
    fromEnum EventMask
EventMaskButton1MotionMask = Int
32
    fromEnum EventMask
EventMaskButton2MotionMask = Int
64
    fromEnum EventMask
EventMaskButton3MotionMask = Int
128
    fromEnum EventMask
EventMaskButtonPressMask = Int
256
    fromEnum EventMask
EventMaskButtonReleaseMask = Int
512
    fromEnum EventMask
EventMaskKeyPressMask = Int
1024
    fromEnum EventMask
EventMaskKeyReleaseMask = Int
2048
    fromEnum EventMask
EventMaskEnterNotifyMask = Int
4096
    fromEnum EventMask
EventMaskLeaveNotifyMask = Int
8192
    fromEnum EventMask
EventMaskFocusChangeMask = Int
16384
    fromEnum EventMask
EventMaskStructureMask = Int
32768
    fromEnum EventMask
EventMaskPropertyChangeMask = Int
65536
    fromEnum EventMask
EventMaskVisibilityNotifyMask = Int
131072
    fromEnum EventMask
EventMaskProximityInMask = Int
262144
    fromEnum EventMask
EventMaskProximityOutMask = Int
524288
    fromEnum EventMask
EventMaskSubstructureMask = Int
1048576
    fromEnum EventMask
EventMaskScrollMask = Int
2097152
    fromEnum EventMask
EventMaskTouchMask = Int
4194304
    fromEnum EventMask
EventMaskSmoothScrollMask = Int
8388608
    fromEnum EventMask
EventMaskTouchpadGestureMask = Int
16777216
    fromEnum EventMask
EventMaskTabletPadMask = Int
33554432
    fromEnum EventMask
EventMaskAllEventsMask = Int
67108862
    fromEnum (AnotherEventMask Int
k) = Int
k

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

instance P.Ord EventMask where
    compare :: EventMask -> EventMask -> Ordering
compare EventMask
a 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)

type instance O.ParentTypes EventMask = '[]
instance O.HasParentTypes EventMask

foreign import ccall "gdk_event_mask_get_type" c_gdk_event_mask_get_type :: 
    IO GType

instance B.Types.TypedObject EventMask where
    glibType :: IO GType
glibType = IO GType
c_gdk_event_mask_get_type

instance B.Types.BoxedFlags EventMask

instance IsGFlag EventMask

-- Flags DragAction
-- | Used in t'GI.Gdk.Objects.DragContext.DragContext' to indicate what the destination
-- should do with the dropped data.
data DragAction = 
      DragActionDefault
    -- ^ Means nothing, and should not be used.
    | 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.
    | DragActionPrivate
    -- ^ Special action which tells the source that the
    --  destination will do something that the source doesn’t understand.
    | 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 DragAction
DragActionDefault = Int
1
    fromEnum DragAction
DragActionCopy = Int
2
    fromEnum DragAction
DragActionMove = Int
4
    fromEnum DragAction
DragActionLink = Int
8
    fromEnum DragAction
DragActionPrivate = Int
16
    fromEnum DragAction
DragActionAsk = Int
32
    fromEnum (AnotherDragAction Int
k) = Int
k

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

instance P.Ord DragAction where
    compare :: DragAction -> DragAction -> Ordering
compare DragAction
a 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)

type instance O.ParentTypes DragAction = '[]
instance O.HasParentTypes DragAction

foreign import ccall "gdk_drag_action_get_type" c_gdk_drag_action_get_type :: 
    IO GType

instance B.Types.TypedObject DragAction where
    glibType :: IO GType
glibType = IO GType
c_gdk_drag_action_get_type

instance B.Types.BoxedFlags DragAction

instance IsGFlag DragAction

-- Flags AxisFlags
-- | Flags describing the current capabilities of a device\/tool.
-- 
-- /Since: 3.22/
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 AxisFlags
AxisFlagsX = Int
2
    fromEnum AxisFlags
AxisFlagsY = Int
4
    fromEnum AxisFlags
AxisFlagsPressure = Int
8
    fromEnum AxisFlags
AxisFlagsXtilt = Int
16
    fromEnum AxisFlags
AxisFlagsYtilt = Int
32
    fromEnum AxisFlags
AxisFlagsWheel = Int
64
    fromEnum AxisFlags
AxisFlagsDistance = Int
128
    fromEnum AxisFlags
AxisFlagsRotation = Int
256
    fromEnum AxisFlags
AxisFlagsSlider = Int
512
    fromEnum (AnotherAxisFlags Int
k) = Int
k

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

instance P.Ord AxisFlags where
    compare :: AxisFlags -> AxisFlags -> Ordering
compare AxisFlags
a 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)

type instance O.ParentTypes AxisFlags = '[]
instance O.HasParentTypes AxisFlags

foreign import ccall "gdk_axis_flags_get_type" c_gdk_axis_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AxisFlags where
    glibType :: IO GType
glibType = IO GType
c_gdk_axis_flags_get_type

instance B.Types.BoxedFlags AxisFlags

instance IsGFlag AxisFlags

-- Flags AnchorHints
-- | Positioning hints for aligning a window relative to a rectangle.
-- 
-- These hints determine how the window should be positioned in the case that
-- the window 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 window extends beyond the left
-- or right edges of the monitor.
-- 
-- If 'GI.Gdk.Flags.AnchorHintsSlideX' is set, the window can be shifted horizontally to fit
-- on-screen. If 'GI.Gdk.Flags.AnchorHintsResizeX' is set, the window 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.
-- 
-- /Since: 3.22/
data AnchorHints = 
      AnchorHintsFlipX
    -- ^ allow flipping anchors horizontally
    | AnchorHintsFlipY
    -- ^ allow flipping anchors vertically
    | AnchorHintsSlideX
    -- ^ allow sliding window horizontally
    | AnchorHintsSlideY
    -- ^ allow sliding window vertically
    | AnchorHintsResizeX
    -- ^ allow resizing window horizontally
    | AnchorHintsResizeY
    -- ^ allow resizing window vertically
    | AnchorHintsFlip
    -- ^ allow flipping anchors on both axes
    | AnchorHintsSlide
    -- ^ allow sliding window on both axes
    | AnchorHintsResize
    -- ^ allow resizing window 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 AnchorHints
AnchorHintsFlipX = Int
1
    fromEnum AnchorHints
AnchorHintsFlipY = Int
2
    fromEnum AnchorHints
AnchorHintsSlideX = Int
4
    fromEnum AnchorHints
AnchorHintsSlideY = Int
8
    fromEnum AnchorHints
AnchorHintsResizeX = Int
16
    fromEnum AnchorHints
AnchorHintsResizeY = Int
32
    fromEnum AnchorHints
AnchorHintsFlip = Int
3
    fromEnum AnchorHints
AnchorHintsSlide = Int
12
    fromEnum AnchorHints
AnchorHintsResize = Int
48
    fromEnum (AnotherAnchorHints Int
k) = Int
k

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

instance P.Ord AnchorHints where
    compare :: AnchorHints -> AnchorHints -> Ordering
compare AnchorHints
a 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)

type instance O.ParentTypes AnchorHints = '[]
instance O.HasParentTypes AnchorHints

foreign import ccall "gdk_anchor_hints_get_type" c_gdk_anchor_hints_get_type :: 
    IO GType

instance B.Types.TypedObject AnchorHints where
    glibType :: IO GType
glibType = IO GType
c_gdk_anchor_hints_get_type

instance B.Types.BoxedFlags AnchorHints

instance IsGFlag AnchorHints