#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.HarfBuzz.Flags
(
BufferDiffFlagsT(..) ,
BufferFlagsT(..) ,
BufferSerializeFlagsT(..) ,
GlyphFlagsT(..) ,
OtColorPaletteFlagsT(..) ,
OtMathGlyphPartFlagsT(..) ,
OtVarAxisFlagsT(..) ,
) 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
data OtVarAxisFlagsT =
OtVarAxisFlagsTHidden
| AnotherOtVarAxisFlagsT Int
deriving (Int -> OtVarAxisFlagsT -> ShowS
[OtVarAxisFlagsT] -> ShowS
OtVarAxisFlagsT -> String
(Int -> OtVarAxisFlagsT -> ShowS)
-> (OtVarAxisFlagsT -> String)
-> ([OtVarAxisFlagsT] -> ShowS)
-> Show OtVarAxisFlagsT
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OtVarAxisFlagsT -> ShowS
showsPrec :: Int -> OtVarAxisFlagsT -> ShowS
$cshow :: OtVarAxisFlagsT -> String
show :: OtVarAxisFlagsT -> String
$cshowList :: [OtVarAxisFlagsT] -> ShowS
showList :: [OtVarAxisFlagsT] -> ShowS
Show, OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
(OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool)
-> (OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool)
-> Eq OtVarAxisFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
== :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
$c/= :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
/= :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
Eq)
instance P.Enum OtVarAxisFlagsT where
fromEnum :: OtVarAxisFlagsT -> Int
fromEnum OtVarAxisFlagsT
OtVarAxisFlagsTHidden = Int
1
fromEnum (AnotherOtVarAxisFlagsT Int
k) = Int
k
toEnum :: Int -> OtVarAxisFlagsT
toEnum Int
1 = OtVarAxisFlagsT
OtVarAxisFlagsTHidden
toEnum Int
k = Int -> OtVarAxisFlagsT
AnotherOtVarAxisFlagsT Int
k
instance P.Ord OtVarAxisFlagsT where
compare :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Ordering
compare OtVarAxisFlagsT
a OtVarAxisFlagsT
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (OtVarAxisFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum OtVarAxisFlagsT
a) (OtVarAxisFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum OtVarAxisFlagsT
b)
type instance O.ParentTypes OtVarAxisFlagsT = '[]
instance O.HasParentTypes OtVarAxisFlagsT
foreign import ccall "hb_gobject_ot_var_axis_flags_get_type" c_hb_gobject_ot_var_axis_flags_get_type ::
IO GType
instance B.Types.TypedObject OtVarAxisFlagsT where
glibType :: IO GType
glibType = IO GType
c_hb_gobject_ot_var_axis_flags_get_type
instance B.Types.BoxedFlags OtVarAxisFlagsT
instance IsGFlag OtVarAxisFlagsT
data OtMathGlyphPartFlagsT =
OtMathGlyphPartFlagsTExtender
| AnotherOtMathGlyphPartFlagsT Int
deriving (Int -> OtMathGlyphPartFlagsT -> ShowS
[OtMathGlyphPartFlagsT] -> ShowS
OtMathGlyphPartFlagsT -> String
(Int -> OtMathGlyphPartFlagsT -> ShowS)
-> (OtMathGlyphPartFlagsT -> String)
-> ([OtMathGlyphPartFlagsT] -> ShowS)
-> Show OtMathGlyphPartFlagsT
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OtMathGlyphPartFlagsT -> ShowS
showsPrec :: Int -> OtMathGlyphPartFlagsT -> ShowS
$cshow :: OtMathGlyphPartFlagsT -> String
show :: OtMathGlyphPartFlagsT -> String
$cshowList :: [OtMathGlyphPartFlagsT] -> ShowS
showList :: [OtMathGlyphPartFlagsT] -> ShowS
Show, OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
(OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool)
-> (OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool)
-> Eq OtMathGlyphPartFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
== :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
$c/= :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
/= :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
Eq)
instance P.Enum OtMathGlyphPartFlagsT where
fromEnum :: OtMathGlyphPartFlagsT -> Int
fromEnum OtMathGlyphPartFlagsT
OtMathGlyphPartFlagsTExtender = Int
1
fromEnum (AnotherOtMathGlyphPartFlagsT Int
k) = Int
k
toEnum :: Int -> OtMathGlyphPartFlagsT
toEnum Int
1 = OtMathGlyphPartFlagsT
OtMathGlyphPartFlagsTExtender
toEnum Int
k = Int -> OtMathGlyphPartFlagsT
AnotherOtMathGlyphPartFlagsT Int
k
instance P.Ord OtMathGlyphPartFlagsT where
compare :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Ordering
compare OtMathGlyphPartFlagsT
a OtMathGlyphPartFlagsT
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (OtMathGlyphPartFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum OtMathGlyphPartFlagsT
a) (OtMathGlyphPartFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum OtMathGlyphPartFlagsT
b)
type instance O.ParentTypes OtMathGlyphPartFlagsT = '[]
instance O.HasParentTypes OtMathGlyphPartFlagsT
foreign import ccall "hb_gobject_ot_math_glyph_part_flags_get_type" c_hb_gobject_ot_math_glyph_part_flags_get_type ::
IO GType
instance B.Types.TypedObject OtMathGlyphPartFlagsT where
glibType :: IO GType
glibType = IO GType
c_hb_gobject_ot_math_glyph_part_flags_get_type
instance B.Types.BoxedFlags OtMathGlyphPartFlagsT
instance IsGFlag OtMathGlyphPartFlagsT
data OtColorPaletteFlagsT =
OtColorPaletteFlagsTDefault
| OtColorPaletteFlagsTUsableWithLightBackground
| OtColorPaletteFlagsTUsableWithDarkBackground
| AnotherOtColorPaletteFlagsT Int
deriving (Int -> OtColorPaletteFlagsT -> ShowS
[OtColorPaletteFlagsT] -> ShowS
OtColorPaletteFlagsT -> String
(Int -> OtColorPaletteFlagsT -> ShowS)
-> (OtColorPaletteFlagsT -> String)
-> ([OtColorPaletteFlagsT] -> ShowS)
-> Show OtColorPaletteFlagsT
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OtColorPaletteFlagsT -> ShowS
showsPrec :: Int -> OtColorPaletteFlagsT -> ShowS
$cshow :: OtColorPaletteFlagsT -> String
show :: OtColorPaletteFlagsT -> String
$cshowList :: [OtColorPaletteFlagsT] -> ShowS
showList :: [OtColorPaletteFlagsT] -> ShowS
Show, OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
(OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool)
-> (OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool)
-> Eq OtColorPaletteFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
== :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
$c/= :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
/= :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
Eq)
instance P.Enum OtColorPaletteFlagsT where
fromEnum :: OtColorPaletteFlagsT -> Int
fromEnum OtColorPaletteFlagsT
OtColorPaletteFlagsTDefault = Int
0
fromEnum OtColorPaletteFlagsT
OtColorPaletteFlagsTUsableWithLightBackground = Int
1
fromEnum OtColorPaletteFlagsT
OtColorPaletteFlagsTUsableWithDarkBackground = Int
2
fromEnum (AnotherOtColorPaletteFlagsT Int
k) = Int
k
toEnum :: Int -> OtColorPaletteFlagsT
toEnum Int
0 = OtColorPaletteFlagsT
OtColorPaletteFlagsTDefault
toEnum Int
1 = OtColorPaletteFlagsT
OtColorPaletteFlagsTUsableWithLightBackground
toEnum Int
2 = OtColorPaletteFlagsT
OtColorPaletteFlagsTUsableWithDarkBackground
toEnum Int
k = Int -> OtColorPaletteFlagsT
AnotherOtColorPaletteFlagsT Int
k
instance P.Ord OtColorPaletteFlagsT where
compare :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Ordering
compare OtColorPaletteFlagsT
a OtColorPaletteFlagsT
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (OtColorPaletteFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum OtColorPaletteFlagsT
a) (OtColorPaletteFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum OtColorPaletteFlagsT
b)
type instance O.ParentTypes OtColorPaletteFlagsT = '[]
instance O.HasParentTypes OtColorPaletteFlagsT
foreign import ccall "hb_gobject_ot_color_palette_flags_get_type" c_hb_gobject_ot_color_palette_flags_get_type ::
IO GType
instance B.Types.TypedObject OtColorPaletteFlagsT where
glibType :: IO GType
glibType = IO GType
c_hb_gobject_ot_color_palette_flags_get_type
instance B.Types.BoxedFlags OtColorPaletteFlagsT
instance IsGFlag OtColorPaletteFlagsT
data GlyphFlagsT =
GlyphFlagsTUnsafeToBreak
| GlyphFlagsTUnsafeToConcat
| GlyphFlagsTSafeToInsertTatweel
| GlyphFlagsTDefined
| AnotherGlyphFlagsT Int
deriving (Int -> GlyphFlagsT -> ShowS
[GlyphFlagsT] -> ShowS
GlyphFlagsT -> String
(Int -> GlyphFlagsT -> ShowS)
-> (GlyphFlagsT -> String)
-> ([GlyphFlagsT] -> ShowS)
-> Show GlyphFlagsT
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GlyphFlagsT -> ShowS
showsPrec :: Int -> GlyphFlagsT -> ShowS
$cshow :: GlyphFlagsT -> String
show :: GlyphFlagsT -> String
$cshowList :: [GlyphFlagsT] -> ShowS
showList :: [GlyphFlagsT] -> ShowS
Show, GlyphFlagsT -> GlyphFlagsT -> Bool
(GlyphFlagsT -> GlyphFlagsT -> Bool)
-> (GlyphFlagsT -> GlyphFlagsT -> Bool) -> Eq GlyphFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GlyphFlagsT -> GlyphFlagsT -> Bool
== :: GlyphFlagsT -> GlyphFlagsT -> Bool
$c/= :: GlyphFlagsT -> GlyphFlagsT -> Bool
/= :: GlyphFlagsT -> GlyphFlagsT -> Bool
Eq)
instance P.Enum GlyphFlagsT where
fromEnum :: GlyphFlagsT -> Int
fromEnum GlyphFlagsT
GlyphFlagsTUnsafeToBreak = Int
1
fromEnum GlyphFlagsT
GlyphFlagsTUnsafeToConcat = Int
2
fromEnum GlyphFlagsT
GlyphFlagsTSafeToInsertTatweel = Int
4
fromEnum GlyphFlagsT
GlyphFlagsTDefined = Int
7
fromEnum (AnotherGlyphFlagsT Int
k) = Int
k
toEnum :: Int -> GlyphFlagsT
toEnum Int
1 = GlyphFlagsT
GlyphFlagsTUnsafeToBreak
toEnum Int
2 = GlyphFlagsT
GlyphFlagsTUnsafeToConcat
toEnum Int
4 = GlyphFlagsT
GlyphFlagsTSafeToInsertTatweel
toEnum Int
7 = GlyphFlagsT
GlyphFlagsTDefined
toEnum Int
k = Int -> GlyphFlagsT
AnotherGlyphFlagsT Int
k
instance P.Ord GlyphFlagsT where
compare :: GlyphFlagsT -> GlyphFlagsT -> Ordering
compare GlyphFlagsT
a GlyphFlagsT
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (GlyphFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum GlyphFlagsT
a) (GlyphFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum GlyphFlagsT
b)
type instance O.ParentTypes GlyphFlagsT = '[]
instance O.HasParentTypes GlyphFlagsT
foreign import ccall "hb_gobject_glyph_flags_get_type" c_hb_gobject_glyph_flags_get_type ::
IO GType
instance B.Types.TypedObject GlyphFlagsT where
glibType :: IO GType
glibType = IO GType
c_hb_gobject_glyph_flags_get_type
instance B.Types.BoxedFlags GlyphFlagsT
instance IsGFlag GlyphFlagsT
data BufferSerializeFlagsT =
BufferSerializeFlagsTDefault
| BufferSerializeFlagsTNoClusters
| BufferSerializeFlagsTNoPositions
| BufferSerializeFlagsTNoGlyphNames
| BufferSerializeFlagsTGlyphExtents
| BufferSerializeFlagsTGlyphFlags
| BufferSerializeFlagsTNoAdvances
| BufferSerializeFlagsTDefined
| AnotherBufferSerializeFlagsT Int
deriving (Int -> BufferSerializeFlagsT -> ShowS
[BufferSerializeFlagsT] -> ShowS
BufferSerializeFlagsT -> String
(Int -> BufferSerializeFlagsT -> ShowS)
-> (BufferSerializeFlagsT -> String)
-> ([BufferSerializeFlagsT] -> ShowS)
-> Show BufferSerializeFlagsT
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BufferSerializeFlagsT -> ShowS
showsPrec :: Int -> BufferSerializeFlagsT -> ShowS
$cshow :: BufferSerializeFlagsT -> String
show :: BufferSerializeFlagsT -> String
$cshowList :: [BufferSerializeFlagsT] -> ShowS
showList :: [BufferSerializeFlagsT] -> ShowS
Show, BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
(BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool)
-> (BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool)
-> Eq BufferSerializeFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
== :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
$c/= :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
/= :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
Eq)
instance P.Enum BufferSerializeFlagsT where
fromEnum :: BufferSerializeFlagsT -> Int
fromEnum BufferSerializeFlagsT
BufferSerializeFlagsTDefault = Int
0
fromEnum BufferSerializeFlagsT
BufferSerializeFlagsTNoClusters = Int
1
fromEnum BufferSerializeFlagsT
BufferSerializeFlagsTNoPositions = Int
2
fromEnum BufferSerializeFlagsT
BufferSerializeFlagsTNoGlyphNames = Int
4
fromEnum BufferSerializeFlagsT
BufferSerializeFlagsTGlyphExtents = Int
8
fromEnum BufferSerializeFlagsT
BufferSerializeFlagsTGlyphFlags = Int
16
fromEnum BufferSerializeFlagsT
BufferSerializeFlagsTNoAdvances = Int
32
fromEnum BufferSerializeFlagsT
BufferSerializeFlagsTDefined = Int
63
fromEnum (AnotherBufferSerializeFlagsT Int
k) = Int
k
toEnum :: Int -> BufferSerializeFlagsT
toEnum Int
0 = BufferSerializeFlagsT
BufferSerializeFlagsTDefault
toEnum Int
1 = BufferSerializeFlagsT
BufferSerializeFlagsTNoClusters
toEnum Int
2 = BufferSerializeFlagsT
BufferSerializeFlagsTNoPositions
toEnum Int
4 = BufferSerializeFlagsT
BufferSerializeFlagsTNoGlyphNames
toEnum Int
8 = BufferSerializeFlagsT
BufferSerializeFlagsTGlyphExtents
toEnum Int
16 = BufferSerializeFlagsT
BufferSerializeFlagsTGlyphFlags
toEnum Int
32 = BufferSerializeFlagsT
BufferSerializeFlagsTNoAdvances
toEnum Int
63 = BufferSerializeFlagsT
BufferSerializeFlagsTDefined
toEnum Int
k = Int -> BufferSerializeFlagsT
AnotherBufferSerializeFlagsT Int
k
instance P.Ord BufferSerializeFlagsT where
compare :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Ordering
compare BufferSerializeFlagsT
a BufferSerializeFlagsT
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BufferSerializeFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferSerializeFlagsT
a) (BufferSerializeFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferSerializeFlagsT
b)
type instance O.ParentTypes BufferSerializeFlagsT = '[]
instance O.HasParentTypes BufferSerializeFlagsT
foreign import ccall "hb_gobject_buffer_serialize_flags_get_type" c_hb_gobject_buffer_serialize_flags_get_type ::
IO GType
instance B.Types.TypedObject BufferSerializeFlagsT where
glibType :: IO GType
glibType = IO GType
c_hb_gobject_buffer_serialize_flags_get_type
instance B.Types.BoxedFlags BufferSerializeFlagsT
instance IsGFlag BufferSerializeFlagsT
data BufferFlagsT =
BufferFlagsTDefault
| BufferFlagsTBot
| BufferFlagsTEot
| BufferFlagsTPreserveDefaultIgnorables
| BufferFlagsTRemoveDefaultIgnorables
| BufferFlagsTDoNotInsertDottedCircle
| BufferFlagsTVerify
| BufferFlagsTProduceUnsafeToConcat
| BufferFlagsTProduceSafeToInsertTatweel
| BufferFlagsTDefined
| AnotherBufferFlagsT Int
deriving (Int -> BufferFlagsT -> ShowS
[BufferFlagsT] -> ShowS
BufferFlagsT -> String
(Int -> BufferFlagsT -> ShowS)
-> (BufferFlagsT -> String)
-> ([BufferFlagsT] -> ShowS)
-> Show BufferFlagsT
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BufferFlagsT -> ShowS
showsPrec :: Int -> BufferFlagsT -> ShowS
$cshow :: BufferFlagsT -> String
show :: BufferFlagsT -> String
$cshowList :: [BufferFlagsT] -> ShowS
showList :: [BufferFlagsT] -> ShowS
Show, BufferFlagsT -> BufferFlagsT -> Bool
(BufferFlagsT -> BufferFlagsT -> Bool)
-> (BufferFlagsT -> BufferFlagsT -> Bool) -> Eq BufferFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BufferFlagsT -> BufferFlagsT -> Bool
== :: BufferFlagsT -> BufferFlagsT -> Bool
$c/= :: BufferFlagsT -> BufferFlagsT -> Bool
/= :: BufferFlagsT -> BufferFlagsT -> Bool
Eq)
instance P.Enum BufferFlagsT where
fromEnum :: BufferFlagsT -> Int
fromEnum BufferFlagsT
BufferFlagsTDefault = Int
0
fromEnum BufferFlagsT
BufferFlagsTBot = Int
1
fromEnum BufferFlagsT
BufferFlagsTEot = Int
2
fromEnum BufferFlagsT
BufferFlagsTPreserveDefaultIgnorables = Int
4
fromEnum BufferFlagsT
BufferFlagsTRemoveDefaultIgnorables = Int
8
fromEnum BufferFlagsT
BufferFlagsTDoNotInsertDottedCircle = Int
16
fromEnum BufferFlagsT
BufferFlagsTVerify = Int
32
fromEnum BufferFlagsT
BufferFlagsTProduceUnsafeToConcat = Int
64
fromEnum BufferFlagsT
BufferFlagsTProduceSafeToInsertTatweel = Int
128
fromEnum BufferFlagsT
BufferFlagsTDefined = Int
255
fromEnum (AnotherBufferFlagsT Int
k) = Int
k
toEnum :: Int -> BufferFlagsT
toEnum Int
0 = BufferFlagsT
BufferFlagsTDefault
toEnum Int
1 = BufferFlagsT
BufferFlagsTBot
toEnum Int
2 = BufferFlagsT
BufferFlagsTEot
toEnum Int
4 = BufferFlagsT
BufferFlagsTPreserveDefaultIgnorables
toEnum Int
8 = BufferFlagsT
BufferFlagsTRemoveDefaultIgnorables
toEnum Int
16 = BufferFlagsT
BufferFlagsTDoNotInsertDottedCircle
toEnum Int
32 = BufferFlagsT
BufferFlagsTVerify
toEnum Int
64 = BufferFlagsT
BufferFlagsTProduceUnsafeToConcat
toEnum Int
128 = BufferFlagsT
BufferFlagsTProduceSafeToInsertTatweel
toEnum Int
255 = BufferFlagsT
BufferFlagsTDefined
toEnum Int
k = Int -> BufferFlagsT
AnotherBufferFlagsT Int
k
instance P.Ord BufferFlagsT where
compare :: BufferFlagsT -> BufferFlagsT -> Ordering
compare BufferFlagsT
a BufferFlagsT
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BufferFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferFlagsT
a) (BufferFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferFlagsT
b)
type instance O.ParentTypes BufferFlagsT = '[]
instance O.HasParentTypes BufferFlagsT
foreign import ccall "hb_gobject_buffer_flags_get_type" c_hb_gobject_buffer_flags_get_type ::
IO GType
instance B.Types.TypedObject BufferFlagsT where
glibType :: IO GType
glibType = IO GType
c_hb_gobject_buffer_flags_get_type
instance B.Types.BoxedFlags BufferFlagsT
instance IsGFlag BufferFlagsT
data BufferDiffFlagsT =
BufferDiffFlagsTEqual
| BufferDiffFlagsTContentTypeMismatch
| BufferDiffFlagsTLengthMismatch
| BufferDiffFlagsTNotdefPresent
| BufferDiffFlagsTDottedCirclePresent
| BufferDiffFlagsTCodepointMismatch
| BufferDiffFlagsTClusterMismatch
| BufferDiffFlagsTGlyphFlagsMismatch
| BufferDiffFlagsTPositionMismatch
| AnotherBufferDiffFlagsT Int
deriving (Int -> BufferDiffFlagsT -> ShowS
[BufferDiffFlagsT] -> ShowS
BufferDiffFlagsT -> String
(Int -> BufferDiffFlagsT -> ShowS)
-> (BufferDiffFlagsT -> String)
-> ([BufferDiffFlagsT] -> ShowS)
-> Show BufferDiffFlagsT
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BufferDiffFlagsT -> ShowS
showsPrec :: Int -> BufferDiffFlagsT -> ShowS
$cshow :: BufferDiffFlagsT -> String
show :: BufferDiffFlagsT -> String
$cshowList :: [BufferDiffFlagsT] -> ShowS
showList :: [BufferDiffFlagsT] -> ShowS
Show, BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
(BufferDiffFlagsT -> BufferDiffFlagsT -> Bool)
-> (BufferDiffFlagsT -> BufferDiffFlagsT -> Bool)
-> Eq BufferDiffFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
== :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
$c/= :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
/= :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
Eq)
instance P.Enum BufferDiffFlagsT where
fromEnum :: BufferDiffFlagsT -> Int
fromEnum BufferDiffFlagsT
BufferDiffFlagsTEqual = Int
0
fromEnum BufferDiffFlagsT
BufferDiffFlagsTContentTypeMismatch = Int
1
fromEnum BufferDiffFlagsT
BufferDiffFlagsTLengthMismatch = Int
2
fromEnum BufferDiffFlagsT
BufferDiffFlagsTNotdefPresent = Int
4
fromEnum BufferDiffFlagsT
BufferDiffFlagsTDottedCirclePresent = Int
8
fromEnum BufferDiffFlagsT
BufferDiffFlagsTCodepointMismatch = Int
16
fromEnum BufferDiffFlagsT
BufferDiffFlagsTClusterMismatch = Int
32
fromEnum BufferDiffFlagsT
BufferDiffFlagsTGlyphFlagsMismatch = Int
64
fromEnum BufferDiffFlagsT
BufferDiffFlagsTPositionMismatch = Int
128
fromEnum (AnotherBufferDiffFlagsT Int
k) = Int
k
toEnum :: Int -> BufferDiffFlagsT
toEnum Int
0 = BufferDiffFlagsT
BufferDiffFlagsTEqual
toEnum Int
1 = BufferDiffFlagsT
BufferDiffFlagsTContentTypeMismatch
toEnum Int
2 = BufferDiffFlagsT
BufferDiffFlagsTLengthMismatch
toEnum Int
4 = BufferDiffFlagsT
BufferDiffFlagsTNotdefPresent
toEnum Int
8 = BufferDiffFlagsT
BufferDiffFlagsTDottedCirclePresent
toEnum Int
16 = BufferDiffFlagsT
BufferDiffFlagsTCodepointMismatch
toEnum Int
32 = BufferDiffFlagsT
BufferDiffFlagsTClusterMismatch
toEnum Int
64 = BufferDiffFlagsT
BufferDiffFlagsTGlyphFlagsMismatch
toEnum Int
128 = BufferDiffFlagsT
BufferDiffFlagsTPositionMismatch
toEnum Int
k = Int -> BufferDiffFlagsT
AnotherBufferDiffFlagsT Int
k
instance P.Ord BufferDiffFlagsT where
compare :: BufferDiffFlagsT -> BufferDiffFlagsT -> Ordering
compare BufferDiffFlagsT
a BufferDiffFlagsT
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BufferDiffFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferDiffFlagsT
a) (BufferDiffFlagsT -> Int
forall a. Enum a => a -> Int
P.fromEnum BufferDiffFlagsT
b)
type instance O.ParentTypes BufferDiffFlagsT = '[]
instance O.HasParentTypes BufferDiffFlagsT
foreign import ccall "hb_gobject_buffer_diff_flags_get_type" c_hb_gobject_buffer_diff_flags_get_type ::
IO GType
instance B.Types.TypedObject BufferDiffFlagsT where
glibType :: IO GType
glibType = IO GType
c_hb_gobject_buffer_diff_flags_get_type
instance B.Types.BoxedFlags BufferDiffFlagsT
instance IsGFlag BufferDiffFlagsT