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

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

module GI.Gdk.Flags
    ( 

 -- * Flags


-- ** AnchorHints #flag:AnchorHints#

    AnchorHints(..)                         ,


-- ** AxisFlags #flag:AxisFlags#

    AxisFlags(..)                           ,


-- ** DragAction #flag:DragAction#

    DragAction(..)                          ,


-- ** FrameClockPhase #flag:FrameClockPhase#

    FrameClockPhase(..)                     ,


-- ** ModifierType #flag:ModifierType#

    ModifierType(..)                        ,


-- ** PaintableFlags #flag:PaintableFlags#

    PaintableFlags(..)                      ,


-- ** SeatCapabilities #flag:SeatCapabilities#

    SeatCapabilities(..)                    ,


-- ** 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.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


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

instance P.Enum SeatCapabilities where
    fromEnum :: SeatCapabilities -> Int
fromEnum 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
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
16 = SeatCapabilities
SeatCapabilitiesTabletPad
    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 PaintableFlags
-- | Flags about this object. Implementations use these for optimizations
-- such as caching.
data PaintableFlags = 
      PaintableFlagsSize
    -- ^ The size is immutable.
    --     The [invalidateSize]("GI.Gdk.Interfaces.Paintable#g:signal:invalidateSize") signal will never be
    --     emitted.
    | PaintableFlagsContents
    -- ^ The content is immutable.
    --     The [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
showList :: [PaintableFlags] -> ShowS
$cshowList :: [PaintableFlags] -> ShowS
show :: PaintableFlags -> String
$cshow :: PaintableFlags -> String
showsPrec :: Int -> PaintableFlags -> ShowS
$cshowsPrec :: Int -> PaintableFlags -> ShowS
Show, PaintableFlags -> PaintableFlags -> Bool
(PaintableFlags -> PaintableFlags -> Bool)
-> (PaintableFlags -> PaintableFlags -> Bool) -> Eq PaintableFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PaintableFlags -> PaintableFlags -> Bool
$c/= :: PaintableFlags -> PaintableFlags -> Bool
== :: PaintableFlags -> PaintableFlags -> Bool
$c== :: PaintableFlags -> PaintableFlags -> Bool
Eq)

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

    toEnum :: Int -> PaintableFlags
toEnum Int
1 = PaintableFlags
PaintableFlagsSize
    toEnum Int
2 = PaintableFlags
PaintableFlagsContents
    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
-- | 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.
-- 
-- 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 = 
      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.
    | ModifierTypeAltMask
    -- ^ 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).
    | 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
    | AnotherModifierType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ModifierType -> ShowS
[ModifierType] -> ShowS
ModifierType -> String
(Int -> ModifierType -> ShowS)
-> (ModifierType -> String)
-> ([ModifierType] -> ShowS)
-> Show ModifierType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModifierType] -> ShowS
$cshowList :: [ModifierType] -> ShowS
show :: ModifierType -> String
$cshow :: ModifierType -> String
showsPrec :: Int -> ModifierType -> ShowS
$cshowsPrec :: Int -> ModifierType -> ShowS
Show, ModifierType -> ModifierType -> Bool
(ModifierType -> ModifierType -> Bool)
-> (ModifierType -> ModifierType -> Bool) -> Eq ModifierType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifierType -> ModifierType -> Bool
$c/= :: ModifierType -> ModifierType -> Bool
== :: ModifierType -> ModifierType -> Bool
$c== :: ModifierType -> ModifierType -> Bool
Eq)

instance P.Enum ModifierType where
    fromEnum :: ModifierType -> Int
fromEnum ModifierType
ModifierTypeShiftMask = Int
1
    fromEnum ModifierType
ModifierTypeLockMask = Int
2
    fromEnum ModifierType
ModifierTypeControlMask = Int
4
    fromEnum ModifierType
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
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 FrameClockPhase
-- | t'GI.Gdk.Flags.FrameClockPhase' is used to represent the different paint clock
-- phases that can be requested. The elements of the enumeration
-- correspond to the signals of t'GI.Gdk.Objects.FrameClock.FrameClock'.
data FrameClockPhase = 
      FrameClockPhaseNone
    -- ^ no phase
    | FrameClockPhaseFlushEvents
    -- ^ corresponds to GdkFrameClock[flushEvents](#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 applicatiosn.
    | FrameClockPhasePaint
    -- ^ corresponds to GdkFrameClock[paint](#g:signal:paint).
    | FrameClockPhaseResumeEvents
    -- ^ corresponds to GdkFrameClock[resumeEvents](#g:signal:resumeEvents). Should not be handled by applications.
    | FrameClockPhaseAfterPaint
    -- ^ corresponds to GdkFrameClock[afterPaint](#g:signal:afterPaint). Should not be handled by applications.
    | AnotherFrameClockPhase Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FrameClockPhase -> ShowS
[FrameClockPhase] -> ShowS
FrameClockPhase -> String
(Int -> FrameClockPhase -> ShowS)
-> (FrameClockPhase -> String)
-> ([FrameClockPhase] -> ShowS)
-> Show FrameClockPhase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FrameClockPhase] -> ShowS
$cshowList :: [FrameClockPhase] -> ShowS
show :: FrameClockPhase -> String
$cshow :: FrameClockPhase -> String
showsPrec :: Int -> FrameClockPhase -> ShowS
$cshowsPrec :: Int -> FrameClockPhase -> ShowS
Show, FrameClockPhase -> FrameClockPhase -> Bool
(FrameClockPhase -> FrameClockPhase -> Bool)
-> (FrameClockPhase -> FrameClockPhase -> Bool)
-> Eq FrameClockPhase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FrameClockPhase -> FrameClockPhase -> Bool
$c/= :: FrameClockPhase -> FrameClockPhase -> Bool
== :: FrameClockPhase -> FrameClockPhase -> Bool
$c== :: FrameClockPhase -> FrameClockPhase -> Bool
Eq)

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

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

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

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

foreign import ccall "gdk_frame_clock_phase_get_type" c_gdk_frame_clock_phase_get_type :: 
    IO GType

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

instance B.Types.BoxedFlags FrameClockPhase

instance IsGFlag FrameClockPhase

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

instance P.Enum DragAction where
    fromEnum :: DragAction -> Int
fromEnum DragAction
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
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
showList :: [AxisFlags] -> ShowS
$cshowList :: [AxisFlags] -> ShowS
show :: AxisFlags -> String
$cshow :: AxisFlags -> String
showsPrec :: Int -> AxisFlags -> ShowS
$cshowsPrec :: Int -> AxisFlags -> ShowS
Show, AxisFlags -> AxisFlags -> Bool
(AxisFlags -> AxisFlags -> Bool)
-> (AxisFlags -> AxisFlags -> Bool) -> Eq AxisFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AxisFlags -> AxisFlags -> Bool
$c/= :: AxisFlags -> AxisFlags -> Bool
== :: AxisFlags -> AxisFlags -> Bool
$c== :: AxisFlags -> AxisFlags -> Bool
Eq)

instance P.Enum AxisFlags where
    fromEnum :: AxisFlags -> Int
fromEnum AxisFlags
AxisFlagsX = Int
2
    fromEnum AxisFlags
AxisFlagsY = Int
4
    fromEnum AxisFlags
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
showList :: [AnchorHints] -> ShowS
$cshowList :: [AnchorHints] -> ShowS
show :: AnchorHints -> String
$cshow :: AnchorHints -> String
showsPrec :: Int -> AnchorHints -> ShowS
$cshowsPrec :: Int -> AnchorHints -> ShowS
Show, AnchorHints -> AnchorHints -> Bool
(AnchorHints -> AnchorHints -> Bool)
-> (AnchorHints -> AnchorHints -> Bool) -> Eq AnchorHints
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnchorHints -> AnchorHints -> Bool
$c/= :: AnchorHints -> AnchorHints -> Bool
== :: AnchorHints -> AnchorHints -> Bool
$c== :: AnchorHints -> AnchorHints -> Bool
Eq)

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

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

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

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

foreign import ccall "gdk_anchor_hints_get_type" c_gdk_anchor_hints_get_type :: 
    IO GType

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

instance B.Types.BoxedFlags AnchorHints

instance IsGFlag AnchorHints