#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.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
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
showList :: [OtVarAxisFlagsT] -> ShowS
$cshowList :: [OtVarAxisFlagsT] -> ShowS
show :: OtVarAxisFlagsT -> String
$cshow :: OtVarAxisFlagsT -> String
showsPrec :: Int -> OtVarAxisFlagsT -> ShowS
$cshowsPrec :: Int -> OtVarAxisFlagsT -> ShowS
Show, OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
(OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool)
-> (OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool)
-> Eq OtVarAxisFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
$c/= :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
== :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
$c== :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
Eq)
instance P.Enum OtVarAxisFlagsT where
fromEnum :: OtVarAxisFlagsT -> Int
fromEnum OtVarAxisFlagsTHidden = 1
fromEnum (AnotherOtVarAxisFlagsT k :: Int
k) = Int
k
toEnum :: Int -> OtVarAxisFlagsT
toEnum 1 = OtVarAxisFlagsT
OtVarAxisFlagsTHidden
toEnum k :: Int
k = Int -> OtVarAxisFlagsT
AnotherOtVarAxisFlagsT Int
k
instance P.Ord OtVarAxisFlagsT where
compare :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Ordering
compare a :: OtVarAxisFlagsT
a b :: 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
showList :: [OtMathGlyphPartFlagsT] -> ShowS
$cshowList :: [OtMathGlyphPartFlagsT] -> ShowS
show :: OtMathGlyphPartFlagsT -> String
$cshow :: OtMathGlyphPartFlagsT -> String
showsPrec :: Int -> OtMathGlyphPartFlagsT -> ShowS
$cshowsPrec :: Int -> OtMathGlyphPartFlagsT -> ShowS
Show, OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
(OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool)
-> (OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool)
-> Eq OtMathGlyphPartFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
$c/= :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
== :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
$c== :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
Eq)
instance P.Enum OtMathGlyphPartFlagsT where
fromEnum :: OtMathGlyphPartFlagsT -> Int
fromEnum OtMathGlyphPartFlagsTExtender = 1
fromEnum (AnotherOtMathGlyphPartFlagsT k :: Int
k) = Int
k
toEnum :: Int -> OtMathGlyphPartFlagsT
toEnum 1 = OtMathGlyphPartFlagsT
OtMathGlyphPartFlagsTExtender
toEnum k :: Int
k = Int -> OtMathGlyphPartFlagsT
AnotherOtMathGlyphPartFlagsT Int
k
instance P.Ord OtMathGlyphPartFlagsT where
compare :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Ordering
compare a :: OtMathGlyphPartFlagsT
a b :: 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
showList :: [OtColorPaletteFlagsT] -> ShowS
$cshowList :: [OtColorPaletteFlagsT] -> ShowS
show :: OtColorPaletteFlagsT -> String
$cshow :: OtColorPaletteFlagsT -> String
showsPrec :: Int -> OtColorPaletteFlagsT -> ShowS
$cshowsPrec :: Int -> OtColorPaletteFlagsT -> ShowS
Show, OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
(OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool)
-> (OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool)
-> Eq OtColorPaletteFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
$c/= :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
== :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
$c== :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
Eq)
instance P.Enum OtColorPaletteFlagsT where
fromEnum :: OtColorPaletteFlagsT -> Int
fromEnum OtColorPaletteFlagsTDefault = 0
fromEnum OtColorPaletteFlagsTUsableWithLightBackground = 1
fromEnum OtColorPaletteFlagsTUsableWithDarkBackground = 2
fromEnum (AnotherOtColorPaletteFlagsT k :: Int
k) = Int
k
toEnum :: Int -> OtColorPaletteFlagsT
toEnum 0 = OtColorPaletteFlagsT
OtColorPaletteFlagsTDefault
toEnum 1 = OtColorPaletteFlagsT
OtColorPaletteFlagsTUsableWithLightBackground
toEnum 2 = OtColorPaletteFlagsT
OtColorPaletteFlagsTUsableWithDarkBackground
toEnum k :: Int
k = Int -> OtColorPaletteFlagsT
AnotherOtColorPaletteFlagsT Int
k
instance P.Ord OtColorPaletteFlagsT where
compare :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Ordering
compare a :: OtColorPaletteFlagsT
a b :: 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
| 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
showList :: [GlyphFlagsT] -> ShowS
$cshowList :: [GlyphFlagsT] -> ShowS
show :: GlyphFlagsT -> String
$cshow :: GlyphFlagsT -> String
showsPrec :: Int -> GlyphFlagsT -> ShowS
$cshowsPrec :: Int -> GlyphFlagsT -> ShowS
Show, GlyphFlagsT -> GlyphFlagsT -> Bool
(GlyphFlagsT -> GlyphFlagsT -> Bool)
-> (GlyphFlagsT -> GlyphFlagsT -> Bool) -> Eq GlyphFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlyphFlagsT -> GlyphFlagsT -> Bool
$c/= :: GlyphFlagsT -> GlyphFlagsT -> Bool
== :: GlyphFlagsT -> GlyphFlagsT -> Bool
$c== :: GlyphFlagsT -> GlyphFlagsT -> Bool
Eq)
instance P.Enum GlyphFlagsT where
fromEnum :: GlyphFlagsT -> Int
fromEnum GlyphFlagsTUnsafeToBreak = 1
fromEnum GlyphFlagsTDefined = 1
fromEnum (AnotherGlyphFlagsT k :: Int
k) = Int
k
toEnum :: Int -> GlyphFlagsT
toEnum 1 = GlyphFlagsT
GlyphFlagsTUnsafeToBreak
toEnum k :: Int
k = Int -> GlyphFlagsT
AnotherGlyphFlagsT Int
k
instance P.Ord GlyphFlagsT where
compare :: GlyphFlagsT -> GlyphFlagsT -> Ordering
compare a :: GlyphFlagsT
a b :: 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
| 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
showList :: [BufferSerializeFlagsT] -> ShowS
$cshowList :: [BufferSerializeFlagsT] -> ShowS
show :: BufferSerializeFlagsT -> String
$cshow :: BufferSerializeFlagsT -> String
showsPrec :: Int -> BufferSerializeFlagsT -> ShowS
$cshowsPrec :: Int -> BufferSerializeFlagsT -> ShowS
Show, BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
(BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool)
-> (BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool)
-> Eq BufferSerializeFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
$c/= :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
== :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
$c== :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
Eq)
instance P.Enum BufferSerializeFlagsT where
fromEnum :: BufferSerializeFlagsT -> Int
fromEnum BufferSerializeFlagsTDefault = 0
fromEnum BufferSerializeFlagsTNoClusters = 1
fromEnum BufferSerializeFlagsTNoPositions = 2
fromEnum BufferSerializeFlagsTNoGlyphNames = 4
fromEnum BufferSerializeFlagsTGlyphExtents = 8
fromEnum BufferSerializeFlagsTGlyphFlags = 16
fromEnum BufferSerializeFlagsTNoAdvances = 32
fromEnum (AnotherBufferSerializeFlagsT k :: Int
k) = Int
k
toEnum :: Int -> BufferSerializeFlagsT
toEnum 0 = BufferSerializeFlagsT
BufferSerializeFlagsTDefault
toEnum 1 = BufferSerializeFlagsT
BufferSerializeFlagsTNoClusters
toEnum 2 = BufferSerializeFlagsT
BufferSerializeFlagsTNoPositions
toEnum 4 = BufferSerializeFlagsT
BufferSerializeFlagsTNoGlyphNames
toEnum 8 = BufferSerializeFlagsT
BufferSerializeFlagsTGlyphExtents
toEnum 16 = BufferSerializeFlagsT
BufferSerializeFlagsTGlyphFlags
toEnum 32 = BufferSerializeFlagsT
BufferSerializeFlagsTNoAdvances
toEnum k :: Int
k = Int -> BufferSerializeFlagsT
AnotherBufferSerializeFlagsT Int
k
instance P.Ord BufferSerializeFlagsT where
compare :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Ordering
compare a :: BufferSerializeFlagsT
a b :: 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
| 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
showList :: [BufferFlagsT] -> ShowS
$cshowList :: [BufferFlagsT] -> ShowS
show :: BufferFlagsT -> String
$cshow :: BufferFlagsT -> String
showsPrec :: Int -> BufferFlagsT -> ShowS
$cshowsPrec :: Int -> BufferFlagsT -> ShowS
Show, BufferFlagsT -> BufferFlagsT -> Bool
(BufferFlagsT -> BufferFlagsT -> Bool)
-> (BufferFlagsT -> BufferFlagsT -> Bool) -> Eq BufferFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BufferFlagsT -> BufferFlagsT -> Bool
$c/= :: BufferFlagsT -> BufferFlagsT -> Bool
== :: BufferFlagsT -> BufferFlagsT -> Bool
$c== :: BufferFlagsT -> BufferFlagsT -> Bool
Eq)
instance P.Enum BufferFlagsT where
fromEnum :: BufferFlagsT -> Int
fromEnum BufferFlagsTDefault = 0
fromEnum BufferFlagsTBot = 1
fromEnum BufferFlagsTEot = 2
fromEnum BufferFlagsTPreserveDefaultIgnorables = 4
fromEnum BufferFlagsTRemoveDefaultIgnorables = 8
fromEnum BufferFlagsTDoNotInsertDottedCircle = 16
fromEnum (AnotherBufferFlagsT k :: Int
k) = Int
k
toEnum :: Int -> BufferFlagsT
toEnum 0 = BufferFlagsT
BufferFlagsTDefault
toEnum 1 = BufferFlagsT
BufferFlagsTBot
toEnum 2 = BufferFlagsT
BufferFlagsTEot
toEnum 4 = BufferFlagsT
BufferFlagsTPreserveDefaultIgnorables
toEnum 8 = BufferFlagsT
BufferFlagsTRemoveDefaultIgnorables
toEnum 16 = BufferFlagsT
BufferFlagsTDoNotInsertDottedCircle
toEnum k :: Int
k = Int -> BufferFlagsT
AnotherBufferFlagsT Int
k
instance P.Ord BufferFlagsT where
compare :: BufferFlagsT -> BufferFlagsT -> Ordering
compare a :: BufferFlagsT
a b :: 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
showList :: [BufferDiffFlagsT] -> ShowS
$cshowList :: [BufferDiffFlagsT] -> ShowS
show :: BufferDiffFlagsT -> String
$cshow :: BufferDiffFlagsT -> String
showsPrec :: Int -> BufferDiffFlagsT -> ShowS
$cshowsPrec :: Int -> BufferDiffFlagsT -> ShowS
Show, BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
(BufferDiffFlagsT -> BufferDiffFlagsT -> Bool)
-> (BufferDiffFlagsT -> BufferDiffFlagsT -> Bool)
-> Eq BufferDiffFlagsT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
$c/= :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
== :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
$c== :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
Eq)
instance P.Enum BufferDiffFlagsT where
fromEnum :: BufferDiffFlagsT -> Int
fromEnum BufferDiffFlagsTEqual = 0
fromEnum BufferDiffFlagsTContentTypeMismatch = 1
fromEnum BufferDiffFlagsTLengthMismatch = 2
fromEnum BufferDiffFlagsTNotdefPresent = 4
fromEnum BufferDiffFlagsTDottedCirclePresent = 8
fromEnum BufferDiffFlagsTCodepointMismatch = 16
fromEnum BufferDiffFlagsTClusterMismatch = 32
fromEnum BufferDiffFlagsTGlyphFlagsMismatch = 64
fromEnum BufferDiffFlagsTPositionMismatch = 128
fromEnum (AnotherBufferDiffFlagsT k :: Int
k) = Int
k
toEnum :: Int -> BufferDiffFlagsT
toEnum 0 = BufferDiffFlagsT
BufferDiffFlagsTEqual
toEnum 1 = BufferDiffFlagsT
BufferDiffFlagsTContentTypeMismatch
toEnum 2 = BufferDiffFlagsT
BufferDiffFlagsTLengthMismatch
toEnum 4 = BufferDiffFlagsT
BufferDiffFlagsTNotdefPresent
toEnum 8 = BufferDiffFlagsT
BufferDiffFlagsTDottedCirclePresent
toEnum 16 = BufferDiffFlagsT
BufferDiffFlagsTCodepointMismatch
toEnum 32 = BufferDiffFlagsT
BufferDiffFlagsTClusterMismatch
toEnum 64 = BufferDiffFlagsT
BufferDiffFlagsTGlyphFlagsMismatch
toEnum 128 = BufferDiffFlagsT
BufferDiffFlagsTPositionMismatch
toEnum k :: Int
k = Int -> BufferDiffFlagsT
AnotherBufferDiffFlagsT Int
k
instance P.Ord BufferDiffFlagsT where
compare :: BufferDiffFlagsT -> BufferDiffFlagsT -> Ordering
compare a :: BufferDiffFlagsT
a b :: 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