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

    #if !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.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    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.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    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
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)

    #else

    #endif

    -- 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
    $cshowsPrec :: Int -> WindowState -> ShowS
    showsPrec :: Int -> WindowState -> ShowS
    $cshow :: WindowState -> String
    show :: WindowState -> String
    $cshowList :: [WindowState] -> ShowS
    showList :: [WindowState] -> ShowS
    Show, WindowState -> WindowState -> Bool
    (WindowState -> WindowState -> Bool)
    -> (WindowState -> WindowState -> Bool) -> Eq WindowState
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WindowState -> WindowState -> Bool
    == :: WindowState -> WindowState -> Bool
    $c/= :: WindowState -> WindowState -> Bool
    /= :: 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
    $cshowsPrec :: Int -> WindowHints -> ShowS
    showsPrec :: Int -> WindowHints -> ShowS
    $cshow :: WindowHints -> String
    show :: WindowHints -> String
    $cshowList :: [WindowHints] -> ShowS
    showList :: [WindowHints] -> ShowS
    Show, WindowHints -> WindowHints -> Bool
    (WindowHints -> WindowHints -> Bool)
    -> (WindowHints -> WindowHints -> Bool) -> Eq WindowHints
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WindowHints -> WindowHints -> Bool
    == :: WindowHints -> WindowHints -> Bool
    $c/= :: WindowHints -> WindowHints -> Bool
    /= :: 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
    $cshowsPrec :: Int -> WindowAttributesType -> ShowS
    showsPrec :: Int -> WindowAttributesType -> ShowS
    $cshow :: WindowAttributesType -> String
    show :: WindowAttributesType -> String
    $cshowList :: [WindowAttributesType] -> ShowS
    showList :: [WindowAttributesType] -> ShowS
    Show, WindowAttributesType -> WindowAttributesType -> Bool
    (WindowAttributesType -> WindowAttributesType -> Bool)
    -> (WindowAttributesType -> WindowAttributesType -> Bool)
    -> Eq WindowAttributesType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WindowAttributesType -> WindowAttributesType -> Bool
    == :: WindowAttributesType -> WindowAttributesType -> Bool
    $c/= :: WindowAttributesType -> WindowAttributesType -> Bool
    /= :: 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
    $cshowsPrec :: Int -> WMFunction -> ShowS
    showsPrec :: Int -> WMFunction -> ShowS
    $cshow :: WMFunction -> String
    show :: WMFunction -> String
    $cshowList :: [WMFunction] -> ShowS
    showList :: [WMFunction] -> ShowS
    Show, WMFunction -> WMFunction -> Bool
    (WMFunction -> WMFunction -> Bool)
    -> (WMFunction -> WMFunction -> Bool) -> Eq WMFunction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WMFunction -> WMFunction -> Bool
    == :: WMFunction -> WMFunction -> Bool
    $c/= :: WMFunction -> WMFunction -> Bool
    /= :: 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
    $cshowsPrec :: Int -> WMDecoration -> ShowS
    showsPrec :: Int -> WMDecoration -> ShowS
    $cshow :: WMDecoration -> String
    show :: WMDecoration -> String
    $cshowList :: [WMDecoration] -> ShowS
    showList :: [WMDecoration] -> ShowS
    Show, WMDecoration -> WMDecoration -> Bool
    (WMDecoration -> WMDecoration -> Bool)
    -> (WMDecoration -> WMDecoration -> Bool) -> Eq WMDecoration
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WMDecoration -> WMDecoration -> Bool
    == :: WMDecoration -> WMDecoration -> Bool
    $c/= :: WMDecoration -> WMDecoration -> Bool
    /= :: 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
    $cshowsPrec :: Int -> SeatCapabilities -> ShowS
    showsPrec :: Int -> SeatCapabilities -> ShowS
    $cshow :: SeatCapabilities -> String
    show :: SeatCapabilities -> String
    $cshowList :: [SeatCapabilities] -> ShowS
    showList :: [SeatCapabilities] -> ShowS
    Show, SeatCapabilities -> SeatCapabilities -> Bool
    (SeatCapabilities -> SeatCapabilities -> Bool)
    -> (SeatCapabilities -> SeatCapabilities -> Bool)
    -> Eq SeatCapabilities
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SeatCapabilities -> SeatCapabilities -> Bool
    == :: SeatCapabilities -> SeatCapabilities -> Bool
    $c/= :: SeatCapabilities -> SeatCapabilities -> Bool
    /= :: 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
    $cshowsPrec :: Int -> ModifierType -> ShowS
    showsPrec :: Int -> ModifierType -> ShowS
    $cshow :: ModifierType -> String
    show :: ModifierType -> String
    $cshowList :: [ModifierType] -> ShowS
    showList :: [ModifierType] -> ShowS
    Show, ModifierType -> ModifierType -> Bool
    (ModifierType -> ModifierType -> Bool)
    -> (ModifierType -> ModifierType -> Bool) -> Eq ModifierType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ModifierType -> ModifierType -> Bool
    == :: ModifierType -> ModifierType -> Bool
    $c/= :: ModifierType -> ModifierType -> Bool
    /= :: 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
    $cshowsPrec :: Int -> FrameClockPhase -> ShowS
    showsPrec :: Int -> FrameClockPhase -> ShowS
    $cshow :: FrameClockPhase -> String
    show :: FrameClockPhase -> String
    $cshowList :: [FrameClockPhase] -> ShowS
    showList :: [FrameClockPhase] -> ShowS
    Show, FrameClockPhase -> FrameClockPhase -> Bool
    (FrameClockPhase -> FrameClockPhase -> Bool)
    -> (FrameClockPhase -> FrameClockPhase -> Bool)
    -> Eq FrameClockPhase
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FrameClockPhase -> FrameClockPhase -> Bool
    == :: FrameClockPhase -> FrameClockPhase -> Bool
    $c/= :: FrameClockPhase -> FrameClockPhase -> Bool
    /= :: 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
    $cshowsPrec :: Int -> EventMask -> ShowS
    showsPrec :: Int -> EventMask -> ShowS
    $cshow :: EventMask -> String
    show :: EventMask -> String
    $cshowList :: [EventMask] -> ShowS
    showList :: [EventMask] -> ShowS
    Show, EventMask -> EventMask -> Bool
    (EventMask -> EventMask -> Bool)
    -> (EventMask -> EventMask -> Bool) -> Eq EventMask
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EventMask -> EventMask -> Bool
    == :: EventMask -> EventMask -> Bool
    $c/= :: EventMask -> EventMask -> Bool
    /= :: 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
    $cshowsPrec :: Int -> DragAction -> ShowS
    showsPrec :: Int -> DragAction -> ShowS
    $cshow :: DragAction -> String
    show :: DragAction -> String
    $cshowList :: [DragAction] -> ShowS
    showList :: [DragAction] -> ShowS
    Show, DragAction -> DragAction -> Bool
    (DragAction -> DragAction -> Bool)
    -> (DragAction -> DragAction -> Bool) -> Eq DragAction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DragAction -> DragAction -> Bool
    == :: DragAction -> DragAction -> Bool
    $c/= :: DragAction -> DragAction -> Bool
    /= :: 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
    $cshowsPrec :: Int -> AxisFlags -> ShowS
    showsPrec :: Int -> AxisFlags -> ShowS
    $cshow :: AxisFlags -> String
    show :: AxisFlags -> String
    $cshowList :: [AxisFlags] -> ShowS
    showList :: [AxisFlags] -> ShowS
    Show, AxisFlags -> AxisFlags -> Bool
    (AxisFlags -> AxisFlags -> Bool)
    -> (AxisFlags -> AxisFlags -> Bool) -> Eq AxisFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AxisFlags -> AxisFlags -> Bool
    == :: AxisFlags -> AxisFlags -> Bool
    $c/= :: AxisFlags -> AxisFlags -> Bool
    /= :: 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
    $cshowsPrec :: Int -> AnchorHints -> ShowS
    showsPrec :: Int -> AnchorHints -> ShowS
    $cshow :: AnchorHints -> String
    show :: AnchorHints -> String
    $cshowList :: [AnchorHints] -> ShowS
    showList :: [AnchorHints] -> ShowS
    Show, AnchorHints -> AnchorHints -> Bool
    (AnchorHints -> AnchorHints -> Bool)
    -> (AnchorHints -> AnchorHints -> Bool) -> Eq AnchorHints
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AnchorHints -> AnchorHints -> Bool
    == :: AnchorHints -> AnchorHints -> Bool
    $c/= :: AnchorHints -> AnchorHints -> Bool
    /= :: 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