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

    -- ** FrameClockPhase #flag:FrameClockPhase#

        FrameClockPhase(..)                     ,

    -- ** GLAPI #flag:GLAPI#

        GLAPI(..)                               ,

    -- ** ModifierType #flag:ModifierType#

        ModifierType(..)                        ,

    -- ** PaintableFlags #flag:PaintableFlags#

        PaintableFlags(..)                      ,

    -- ** SeatCapabilities #flag:SeatCapabilities#

        SeatCapabilities(..)                    ,

    -- ** ToplevelCapabilities #flag:ToplevelCapabilities#

        ToplevelCapabilities(..)                ,

    -- ** ToplevelState #flag:ToplevelState#

        ToplevelState(..)                       ,

        ) 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 ToplevelState
    -- | Specifies the state of a toplevel surface.
    --
    -- On platforms that support information about individual edges, the
    -- 'GI.Gdk.Flags.ToplevelStateTiled' state will be set whenever any of the individual
    -- tiled states is set. On platforms that lack that support, the tiled state
    -- will give an indication of tiledness without any of the per-edge states
    -- being set.
    data ToplevelState =
          ToplevelStateMinimized
        -- ^ the surface is minimized
        | ToplevelStateMaximized
        -- ^ the surface is maximized
        | ToplevelStateSticky
        -- ^ the surface is sticky
        | ToplevelStateFullscreen
        -- ^ the surface is maximized without decorations
        | ToplevelStateAbove
        -- ^ the surface is kept above other surfaces
        | ToplevelStateBelow
        -- ^ the surface is kept below other surfaces
        | ToplevelStateFocused
        -- ^ the surface is presented as focused (with active decorations)
        | ToplevelStateTiled
        -- ^ the surface is in a tiled state
        | ToplevelStateTopTiled
        -- ^ whether the top edge is tiled
        | ToplevelStateTopResizable
        -- ^ whether the top edge is resizable
        | ToplevelStateRightTiled
        -- ^ whether the right edge is tiled
        | ToplevelStateRightResizable
        -- ^ whether the right edge is resizable
        | ToplevelStateBottomTiled
        -- ^ whether the bottom edge is tiled
        | ToplevelStateBottomResizable
        -- ^ whether the bottom edge is resizable
        | ToplevelStateLeftTiled
        -- ^ whether the left edge is tiled
        | ToplevelStateLeftResizable
        -- ^ whether the left edge is resizable
        | ToplevelStateSuspended
        -- ^ The surface is not visible to the user.
        --
        -- /Since: 4.12/
        | AnotherToplevelState Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ToplevelState -> ShowS
    [ToplevelState] -> ShowS
    ToplevelState -> String
    (Int -> ToplevelState -> ShowS)
    -> (ToplevelState -> String)
    -> ([ToplevelState] -> ShowS)
    -> Show ToplevelState
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ToplevelState -> ShowS
    showsPrec :: Int -> ToplevelState -> ShowS
    $cshow :: ToplevelState -> String
    show :: ToplevelState -> String
    $cshowList :: [ToplevelState] -> ShowS
    showList :: [ToplevelState] -> ShowS
    Show, ToplevelState -> ToplevelState -> Bool
    (ToplevelState -> ToplevelState -> Bool)
    -> (ToplevelState -> ToplevelState -> Bool) -> Eq ToplevelState
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ToplevelState -> ToplevelState -> Bool
    == :: ToplevelState -> ToplevelState -> Bool
    $c/= :: ToplevelState -> ToplevelState -> Bool
    /= :: ToplevelState -> ToplevelState -> Bool
    Eq)

    instance P.Enum ToplevelState where
        fromEnum :: ToplevelState -> Int
    fromEnum ToplevelState
    ToplevelStateMinimized = Int
    1
        fromEnum ToplevelState
    ToplevelStateMaximized = Int
    2
        fromEnum ToplevelState
    ToplevelStateSticky = Int
    4
        fromEnum ToplevelState
    ToplevelStateFullscreen = Int
    8
        fromEnum ToplevelState
    ToplevelStateAbove = Int
    16
        fromEnum ToplevelState
    ToplevelStateBelow = Int
    32
        fromEnum ToplevelState
    ToplevelStateFocused = Int
    64
        fromEnum ToplevelState
    ToplevelStateTiled = Int
    128
        fromEnum ToplevelState
    ToplevelStateTopTiled = Int
    256
        fromEnum ToplevelState
    ToplevelStateTopResizable = Int
    512
        fromEnum ToplevelState
    ToplevelStateRightTiled = Int
    1024
        fromEnum ToplevelState
    ToplevelStateRightResizable = Int
    2048
        fromEnum ToplevelState
    ToplevelStateBottomTiled = Int
    4096
        fromEnum ToplevelState
    ToplevelStateBottomResizable = Int
    8192
        fromEnum ToplevelState
    ToplevelStateLeftTiled = Int
    16384
        fromEnum ToplevelState
    ToplevelStateLeftResizable = Int
    32768
        fromEnum ToplevelState
    ToplevelStateSuspended = Int
    65536
        fromEnum (AnotherToplevelState Int
    k) = Int
    k

        toEnum :: Int -> ToplevelState
    toEnum Int
    1 = ToplevelState
    ToplevelStateMinimized
        toEnum Int
    2 = ToplevelState
    ToplevelStateMaximized
        toEnum Int
    4 = ToplevelState
    ToplevelStateSticky
        toEnum Int
    8 = ToplevelState
    ToplevelStateFullscreen
        toEnum Int
    16 = ToplevelState
    ToplevelStateAbove
        toEnum Int
    32 = ToplevelState
    ToplevelStateBelow
        toEnum Int
    64 = ToplevelState
    ToplevelStateFocused
        toEnum Int
    128 = ToplevelState
    ToplevelStateTiled
        toEnum Int
    256 = ToplevelState
    ToplevelStateTopTiled
        toEnum Int
    512 = ToplevelState
    ToplevelStateTopResizable
        toEnum Int
    1024 = ToplevelState
    ToplevelStateRightTiled
        toEnum Int
    2048 = ToplevelState
    ToplevelStateRightResizable
        toEnum Int
    4096 = ToplevelState
    ToplevelStateBottomTiled
        toEnum Int
    8192 = ToplevelState
    ToplevelStateBottomResizable
        toEnum Int
    16384 = ToplevelState
    ToplevelStateLeftTiled
        toEnum Int
    32768 = ToplevelState
    ToplevelStateLeftResizable
        toEnum Int
    65536 = ToplevelState
    ToplevelStateSuspended
        toEnum Int
    k = Int -> ToplevelState
    AnotherToplevelState Int
    k

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

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

    foreign import ccall "gdk_toplevel_state_get_type" c_gdk_toplevel_state_get_type ::
        IO GType

    instance B.Types.TypedObject ToplevelState where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_toplevel_state_get_type

    instance B.Types.BoxedFlags ToplevelState

    instance IsGFlag ToplevelState

    -- Flags ToplevelCapabilities
    -- | Reflects what features a @GdkToplevel@ supports.
    --
    -- /Since: 4.20/
    data ToplevelCapabilities =
          ToplevelCapabilitiesEdgeConstraints
        -- ^ Whether tiled window states are supported.
        --
        -- /Since: 4.20/
        | ToplevelCapabilitiesInhibitShortcuts
        -- ^ Whether inhibiting system shortcuts is supported.
        -- See 'GI.Gdk.Interfaces.Toplevel.toplevelInhibitSystemShortcuts'.
        --
        -- /Since: 4.20/
        | ToplevelCapabilitiesTitlebarGestures
        -- ^ Whether titlebar gestures are supported.
        -- See 'GI.Gdk.Interfaces.Toplevel.toplevelTitlebarGesture'.
        --
        -- /Since: 4.20/
        | ToplevelCapabilitiesWindowMenu
        -- ^ Whether showing the window menu is supported.
        -- See 'GI.Gdk.Interfaces.Toplevel.toplevelShowWindowMenu'.
        --
        -- /Since: 4.20/
        | ToplevelCapabilitiesMaximize
        -- ^ Whether the toplevel can be maximized.
        --
        -- /Since: 4.20/
        | ToplevelCapabilitiesFullscreen
        -- ^ Whether the toplevel can be made fullscreen.
        --
        -- /Since: 4.20/
        | ToplevelCapabilitiesMinimize
        -- ^ Whether the toplevel can be minimized.
        -- See 'GI.Gdk.Interfaces.Toplevel.toplevelMinimize'.
        --
        -- /Since: 4.20/
        | ToplevelCapabilitiesLower
        -- ^ Whether the toplevel can be lowered.
        -- See 'GI.Gdk.Interfaces.Toplevel.toplevelLower'.
        --
        -- /Since: 4.20/
        | AnotherToplevelCapabilities Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ToplevelCapabilities -> ShowS
    [ToplevelCapabilities] -> ShowS
    ToplevelCapabilities -> String
    (Int -> ToplevelCapabilities -> ShowS)
    -> (ToplevelCapabilities -> String)
    -> ([ToplevelCapabilities] -> ShowS)
    -> Show ToplevelCapabilities
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ToplevelCapabilities -> ShowS
    showsPrec :: Int -> ToplevelCapabilities -> ShowS
    $cshow :: ToplevelCapabilities -> String
    show :: ToplevelCapabilities -> String
    $cshowList :: [ToplevelCapabilities] -> ShowS
    showList :: [ToplevelCapabilities] -> ShowS
    Show, ToplevelCapabilities -> ToplevelCapabilities -> Bool
    (ToplevelCapabilities -> ToplevelCapabilities -> Bool)
    -> (ToplevelCapabilities -> ToplevelCapabilities -> Bool)
    -> Eq ToplevelCapabilities
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ToplevelCapabilities -> ToplevelCapabilities -> Bool
    == :: ToplevelCapabilities -> ToplevelCapabilities -> Bool
    $c/= :: ToplevelCapabilities -> ToplevelCapabilities -> Bool
    /= :: ToplevelCapabilities -> ToplevelCapabilities -> Bool
    Eq)

    instance P.Enum ToplevelCapabilities where
        fromEnum :: ToplevelCapabilities -> Int
    fromEnum ToplevelCapabilities
    ToplevelCapabilitiesEdgeConstraints = Int
    1
        fromEnum ToplevelCapabilities
    ToplevelCapabilitiesInhibitShortcuts = Int
    2
        fromEnum ToplevelCapabilities
    ToplevelCapabilitiesTitlebarGestures = Int
    4
        fromEnum ToplevelCapabilities
    ToplevelCapabilitiesWindowMenu = Int
    8
        fromEnum ToplevelCapabilities
    ToplevelCapabilitiesMaximize = Int
    16
        fromEnum ToplevelCapabilities
    ToplevelCapabilitiesFullscreen = Int
    32
        fromEnum ToplevelCapabilities
    ToplevelCapabilitiesMinimize = Int
    64
        fromEnum ToplevelCapabilities
    ToplevelCapabilitiesLower = Int
    128
        fromEnum (AnotherToplevelCapabilities Int
    k) = Int
    k

        toEnum :: Int -> ToplevelCapabilities
    toEnum Int
    1 = ToplevelCapabilities
    ToplevelCapabilitiesEdgeConstraints
        toEnum Int
    2 = ToplevelCapabilities
    ToplevelCapabilitiesInhibitShortcuts
        toEnum Int
    4 = ToplevelCapabilities
    ToplevelCapabilitiesTitlebarGestures
        toEnum Int
    8 = ToplevelCapabilities
    ToplevelCapabilitiesWindowMenu
        toEnum Int
    16 = ToplevelCapabilities
    ToplevelCapabilitiesMaximize
        toEnum Int
    32 = ToplevelCapabilities
    ToplevelCapabilitiesFullscreen
        toEnum Int
    64 = ToplevelCapabilities
    ToplevelCapabilitiesMinimize
        toEnum Int
    128 = ToplevelCapabilities
    ToplevelCapabilitiesLower
        toEnum Int
    k = Int -> ToplevelCapabilities
    AnotherToplevelCapabilities Int
    k

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

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

    foreign import ccall "gdk_toplevel_capabilities_get_type" c_gdk_toplevel_capabilities_get_type ::
        IO GType

    instance B.Types.TypedObject ToplevelCapabilities where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_toplevel_capabilities_get_type

    instance B.Types.BoxedFlags ToplevelCapabilities

    instance IsGFlag ToplevelCapabilities

    -- Flags SeatCapabilities
    -- | Flags describing the seat capabilities.
    data SeatCapabilities =
          SeatCapabilitiesNone
        -- ^ No input capabilities
        | SeatCapabilitiesPointer
        -- ^ The seat has a pointer (e.g. mouse)
        | SeatCapabilitiesTouch
        -- ^ The seat has touchscreen(s) attached
        | SeatCapabilitiesTabletStylus
        -- ^ The seat has drawing tablet(s) attached
        | SeatCapabilitiesKeyboard
        -- ^ The seat has keyboard(s) attached
        | SeatCapabilitiesTabletPad
        -- ^ The seat has drawing tablet pad(s) attached
        | SeatCapabilitiesAllPointing
        -- ^ The union of all pointing capabilities
        | SeatCapabilitiesAll
        -- ^ The union of all capabilities
        | AnotherSeatCapabilities Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SeatCapabilities -> ShowS
    [SeatCapabilities] -> ShowS
    SeatCapabilities -> String
    (Int -> SeatCapabilities -> ShowS)
    -> (SeatCapabilities -> String)
    -> ([SeatCapabilities] -> ShowS)
    -> Show SeatCapabilities
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $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
    SeatCapabilitiesTabletPad = Int
    16
        fromEnum SeatCapabilities
    SeatCapabilitiesAllPointing = Int
    7
        fromEnum SeatCapabilities
    SeatCapabilitiesAll = Int
    31
        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
    16 = SeatCapabilities
    SeatCapabilitiesTabletPad
        toEnum Int
    7 = SeatCapabilities
    SeatCapabilitiesAllPointing
        toEnum Int
    31 = 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 PaintableFlags
    -- | Flags about a paintable object.
    --
    -- Implementations use these for optimizations such as caching.
    data PaintableFlags =
          PaintableFlagsStaticSize
        -- ^ The size is immutable.
        --   The [Paintable::invalidateSize]("GI.Gdk.Interfaces.Paintable#g:signal:invalidateSize") signal will never be
        --   emitted.
        | PaintableFlagsStaticContents
        -- ^ The content is immutable.
        --   The [Paintable::invalidateContents]("GI.Gdk.Interfaces.Paintable#g:signal:invalidateContents") signal will never be
        --   emitted.
        | AnotherPaintableFlags Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PaintableFlags -> ShowS
    [PaintableFlags] -> ShowS
    PaintableFlags -> String
    (Int -> PaintableFlags -> ShowS)
    -> (PaintableFlags -> String)
    -> ([PaintableFlags] -> ShowS)
    -> Show PaintableFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PaintableFlags -> ShowS
    showsPrec :: Int -> PaintableFlags -> ShowS
    $cshow :: PaintableFlags -> String
    show :: PaintableFlags -> String
    $cshowList :: [PaintableFlags] -> ShowS
    showList :: [PaintableFlags] -> ShowS
    Show, PaintableFlags -> PaintableFlags -> Bool
    (PaintableFlags -> PaintableFlags -> Bool)
    -> (PaintableFlags -> PaintableFlags -> Bool) -> Eq PaintableFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PaintableFlags -> PaintableFlags -> Bool
    == :: PaintableFlags -> PaintableFlags -> Bool
    $c/= :: PaintableFlags -> PaintableFlags -> Bool
    /= :: PaintableFlags -> PaintableFlags -> Bool
    Eq)

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

        toEnum :: Int -> PaintableFlags
    toEnum Int
    1 = PaintableFlags
    PaintableFlagsStaticSize
        toEnum Int
    2 = PaintableFlags
    PaintableFlagsStaticContents
        toEnum Int
    k = Int -> PaintableFlags
    AnotherPaintableFlags Int
    k

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

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

    foreign import ccall "gdk_paintable_flags_get_type" c_gdk_paintable_flags_get_type ::
        IO GType

    instance B.Types.TypedObject PaintableFlags where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_paintable_flags_get_type

    instance B.Types.BoxedFlags PaintableFlags

    instance IsGFlag PaintableFlags

    -- Flags ModifierType
    -- | Flags to indicate the state of modifier keys and mouse buttons
    -- in events.
    --
    -- Typical modifier keys are Shift, Control, Meta, Super, Hyper, Alt, Compose,
    -- Apple, CapsLock or ShiftLock.
    --
    -- Note that GDK may add internal values to events which include values outside
    -- of this enumeration. Your code should preserve and ignore them. You can use
    -- 'GI.Gdk.Constants.MODIFIER_MASK' to remove all private values.
    data ModifierType =
          ModifierTypeNoModifierMask
        -- ^ No modifier.
        --
        -- /Since: 4.14/
        | ModifierTypeShiftMask
        -- ^ the Shift key.
        | ModifierTypeLockMask
        -- ^ a Lock key (depending on the Windowing System configuration,
        --    this may either be \<kbd>CapsLock\<\/kbd> or \<kbd>ShiftLock\<\/kbd>).
        | ModifierTypeControlMask
        -- ^ the Control key.
        | ModifierTypeAltMask
        -- ^ the fourth modifier key (it depends on the Windowing System
        --    configuration which key is interpreted as this modifier, but normally it
        --    is the \<kbd>Alt\<\/kbd> key).
        | 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.
        | ModifierTypeSuperMask
        -- ^ the Super modifier.
        | ModifierTypeHyperMask
        -- ^ the Hyper modifier.
        | ModifierTypeMetaMask
        -- ^ the Meta modifier. Maps to Command on macOS.
        | 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
    ModifierTypeNoModifierMask = Int
    0
        fromEnum ModifierType
    ModifierTypeShiftMask = Int
    1
        fromEnum ModifierType
    ModifierTypeLockMask = Int
    2
        fromEnum ModifierType
    ModifierTypeControlMask = Int
    4
        fromEnum ModifierType
    ModifierTypeAltMask = Int
    8
        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
    ModifierTypeSuperMask = Int
    67108864
        fromEnum ModifierType
    ModifierTypeHyperMask = Int
    134217728
        fromEnum ModifierType
    ModifierTypeMetaMask = Int
    268435456
        fromEnum (AnotherModifierType Int
    k) = Int
    k

        toEnum :: Int -> ModifierType
    toEnum Int
    0 = ModifierType
    ModifierTypeNoModifierMask
        toEnum Int
    1 = ModifierType
    ModifierTypeShiftMask
        toEnum Int
    2 = ModifierType
    ModifierTypeLockMask
        toEnum Int
    4 = ModifierType
    ModifierTypeControlMask
        toEnum Int
    8 = ModifierType
    ModifierTypeAltMask
        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
    67108864 = ModifierType
    ModifierTypeSuperMask
        toEnum Int
    134217728 = ModifierType
    ModifierTypeHyperMask
        toEnum Int
    268435456 = ModifierType
    ModifierTypeMetaMask
        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 GLAPI
    -- | The list of the different APIs that GdkGLContext can potentially support.
    --
    -- /Since: 4.6/
    data GLAPI =
          GLAPIGl
        -- ^ The OpenGL API
        | GLAPIGles
        -- ^ The OpenGL ES API
        | AnotherGLAPI Int
        -- ^ Catch-all for unknown values
        deriving (Int -> GLAPI -> ShowS
    [GLAPI] -> ShowS
    GLAPI -> String
    (Int -> GLAPI -> ShowS)
    -> (GLAPI -> String) -> ([GLAPI] -> ShowS) -> Show GLAPI
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> GLAPI -> ShowS
    showsPrec :: Int -> GLAPI -> ShowS
    $cshow :: GLAPI -> String
    show :: GLAPI -> String
    $cshowList :: [GLAPI] -> ShowS
    showList :: [GLAPI] -> ShowS
    Show, GLAPI -> GLAPI -> Bool
    (GLAPI -> GLAPI -> Bool) -> (GLAPI -> GLAPI -> Bool) -> Eq GLAPI
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: GLAPI -> GLAPI -> Bool
    == :: GLAPI -> GLAPI -> Bool
    $c/= :: GLAPI -> GLAPI -> Bool
    /= :: GLAPI -> GLAPI -> Bool
    Eq)

    instance P.Enum GLAPI where
        fromEnum :: GLAPI -> Int
    fromEnum GLAPI
    GLAPIGl = Int
    1
        fromEnum GLAPI
    GLAPIGles = Int
    2
        fromEnum (AnotherGLAPI Int
    k) = Int
    k

        toEnum :: Int -> GLAPI
    toEnum Int
    1 = GLAPI
    GLAPIGl
        toEnum Int
    2 = GLAPI
    GLAPIGles
        toEnum Int
    k = Int -> GLAPI
    AnotherGLAPI Int
    k

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

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

    foreign import ccall "gdk_gl_api_get_type" c_gdk_gl_api_get_type ::
        IO GType

    instance B.Types.TypedObject GLAPI where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_gl_api_get_type

    instance B.Types.BoxedFlags GLAPI

    instance IsGFlag GLAPI

    -- Flags FrameClockPhase
    -- | Used to represent the different paint clock phases that can be requested.
    --
    -- The elements of the enumeration correspond to the signals of @GdkFrameClock@.
    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). Should not be handled by applications.
        | 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 DragAction
    -- | Used in @GdkDrop@ and @GdkDrag@ to indicate the actions that the
    -- destination can and should do with the dropped data.
    data DragAction =
          DragActionNone
        -- ^ No action.
        --
        -- /Since: 4.20/
        | 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, and is not
        --   supported on all platforms.
        | 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
    DragActionNone = Int
    0
        fromEnum DragAction
    DragActionCopy = Int
    1
        fromEnum DragAction
    DragActionMove = Int
    2
        fromEnum DragAction
    DragActionLink = Int
    4
        fromEnum DragAction
    DragActionAsk = Int
    8
        fromEnum (AnotherDragAction Int
    k) = Int
    k

        toEnum :: Int -> DragAction
    toEnum Int
    0 = DragAction
    DragActionNone
        toEnum Int
    1 = DragAction
    DragActionCopy
        toEnum Int
    2 = DragAction
    DragActionMove
        toEnum Int
    4 = DragAction
    DragActionLink
        toEnum Int
    8 = 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.
    data AxisFlags =
          AxisFlagsX
        -- ^ X axis is present
        | AxisFlagsY
        -- ^ Y axis is present
        | AxisFlagsDeltaX
        -- ^ Scroll X delta axis is present
        | AxisFlagsDeltaY
        -- ^ Scroll Y delta 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
    AxisFlagsDeltaX = Int
    8
        fromEnum AxisFlags
    AxisFlagsDeltaY = Int
    16
        fromEnum AxisFlags
    AxisFlagsPressure = Int
    32
        fromEnum AxisFlags
    AxisFlagsXtilt = Int
    64
        fromEnum AxisFlags
    AxisFlagsYtilt = Int
    128
        fromEnum AxisFlags
    AxisFlagsWheel = Int
    256
        fromEnum AxisFlags
    AxisFlagsDistance = Int
    512
        fromEnum AxisFlags
    AxisFlagsRotation = Int
    1024
        fromEnum AxisFlags
    AxisFlagsSlider = Int
    2048
        fromEnum (AnotherAxisFlags Int
    k) = Int
    k

        toEnum :: Int -> AxisFlags
    toEnum Int
    2 = AxisFlags
    AxisFlagsX
        toEnum Int
    4 = AxisFlags
    AxisFlagsY
        toEnum Int
    8 = AxisFlags
    AxisFlagsDeltaX
        toEnum Int
    16 = AxisFlags
    AxisFlagsDeltaY
        toEnum Int
    32 = AxisFlags
    AxisFlagsPressure
        toEnum Int
    64 = AxisFlags
    AxisFlagsXtilt
        toEnum Int
    128 = AxisFlags
    AxisFlagsYtilt
        toEnum Int
    256 = AxisFlags
    AxisFlagsWheel
        toEnum Int
    512 = AxisFlags
    AxisFlagsDistance
        toEnum Int
    1024 = AxisFlags
    AxisFlagsRotation
        toEnum Int
    2048 = 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 surface relative to a rectangle.
    --
    -- These hints determine how the surface should be positioned in the case that
    -- the surface would fall off-screen if placed in its ideal position.
    --
    -- For example, 'GI.Gdk.Flags.AnchorHintsFlipX' will replace 'GI.Gdk.Enums.GravityNorthWest' with
    -- 'GI.Gdk.Enums.GravityNorthEast' and vice versa if the surface extends beyond the left
    -- or right edges of the monitor.
    --
    -- If 'GI.Gdk.Flags.AnchorHintsSlideX' is set, the surface can be shifted horizontally to fit
    -- on-screen. If 'GI.Gdk.Flags.AnchorHintsResizeX' is set, the surface can be shrunken
    -- horizontally to fit.
    --
    -- In general, when multiple flags are set, flipping should take precedence over
    -- sliding, which should take precedence over resizing.
    data AnchorHints =
          AnchorHintsFlipX
        -- ^ allow flipping anchors horizontally
        | AnchorHintsFlipY
        -- ^ allow flipping anchors vertically
        | AnchorHintsSlideX
        -- ^ allow sliding surface horizontally
        | AnchorHintsSlideY
        -- ^ allow sliding surface vertically
        | AnchorHintsResizeX
        -- ^ allow resizing surface horizontally
        | AnchorHintsResizeY
        -- ^ allow resizing surface vertically
        | AnchorHintsFlip
        -- ^ allow flipping anchors on both axes
        | AnchorHintsSlide
        -- ^ allow sliding surface on both axes
        | AnchorHintsResize
        -- ^ allow resizing surface on both axes
        | AnotherAnchorHints Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AnchorHints -> ShowS
    [AnchorHints] -> ShowS
    AnchorHints -> String
    (Int -> AnchorHints -> ShowS)
    -> (AnchorHints -> String)
    -> ([AnchorHints] -> ShowS)
    -> Show AnchorHints
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $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