-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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.HarfBuzz.Flags
    ( 

 -- * Flags


-- ** BufferDiffFlagsT #flag:BufferDiffFlagsT#

    BufferDiffFlagsT(..)                    ,


-- ** BufferFlagsT #flag:BufferFlagsT#

    BufferFlagsT(..)                        ,


-- ** BufferSerializeFlagsT #flag:BufferSerializeFlagsT#

    BufferSerializeFlagsT(..)               ,


-- ** GlyphFlagsT #flag:GlyphFlagsT#

    GlyphFlagsT(..)                         ,


-- ** OtColorPaletteFlagsT #flag:OtColorPaletteFlagsT#

    OtColorPaletteFlagsT(..)                ,


-- ** OtMathGlyphPartFlagsT #flag:OtMathGlyphPartFlagsT#

    OtMathGlyphPartFlagsT(..)               ,


-- ** OtVarAxisFlagsT #flag:OtVarAxisFlagsT#

    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.Coerce as Coerce
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 ot_var_axis_flags_t
-- | Flags for t'GI.HarfBuzz.Structs.OtVarAxisInfoT.OtVarAxisInfoT'.
-- 
-- /Since: 2.2.0/
data OtVarAxisFlagsT = 
      OtVarAxisFlagsTHidden
    -- ^ The axis should not be exposed directly in user interfaces.
    | AnotherOtVarAxisFlagsT Int
    -- ^ Catch-all for unknown values
    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 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

-- Flags ot_math_glyph_part_flags_t
-- | Flags for math glyph parts.
-- 
-- /Since: 1.3.3/
data OtMathGlyphPartFlagsT = 
      OtMathGlyphPartFlagsTExtender
    -- ^ This is an extender glyph part that
    -- can be repeated to reach the desired length.
    | AnotherOtMathGlyphPartFlagsT Int
    -- ^ Catch-all for unknown values
    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 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

-- Flags ot_color_palette_flags_t
-- | Flags that describe the properties of color palette.
-- 
-- /Since: 2.1.0/
data OtColorPaletteFlagsT = 
      OtColorPaletteFlagsTDefault
    -- ^ Default indicating that there is nothing special
    --   to note about a color palette.
    | OtColorPaletteFlagsTUsableWithLightBackground
    -- ^ Flag indicating that the color
    --   palette is appropriate to use when displaying the font on a light background such as white.
    | OtColorPaletteFlagsTUsableWithDarkBackground
    -- ^ Flag indicating that the color
    --   palette is appropriate to use when displaying the font on a dark background such as black.
    | AnotherOtColorPaletteFlagsT Int
    -- ^ Catch-all for unknown values
    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 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

-- Flags glyph_flags_t
-- | Flags for t'GI.HarfBuzz.Structs.GlyphInfoT.GlyphInfoT'.
-- 
-- /Since: 1.5.0/
data GlyphFlagsT = 
      GlyphFlagsTUnsafeToBreak
    -- ^ Indicates that if input text is broken at the
    -- 				   beginning of the cluster this glyph is part of,
    -- 				   then both sides need to be re-shaped, as the
    -- 				   result might be different.  On the flip side,
    -- 				   it means that when this flag is not present,
    -- 				   then it\'s safe to break the glyph-run at the
    -- 				   beginning of this cluster, and the two sides
    -- 				   represent the exact same result one would get
    -- 				   if breaking input text at the beginning of
    -- 				   this cluster and shaping the two sides
    -- 				   separately.  This can be used to optimize
    -- 				   paragraph layout, by avoiding re-shaping
    -- 				   of each line after line-breaking, or limiting
    -- 				   the reshaping to a small piece around the
    -- 				   breaking point only.
    | GlyphFlagsTDefined
    -- ^ All the currently defined flags.
    | AnotherGlyphFlagsT Int
    -- ^ Catch-all for unknown values
    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 GlyphFlagsT
GlyphFlagsTUnsafeToBreak = Int
1
    fromEnum GlyphFlagsT
GlyphFlagsTDefined = Int
1
    fromEnum (AnotherGlyphFlagsT Int
k) = Int
k

    toEnum :: Int -> GlyphFlagsT
toEnum Int
1 = GlyphFlagsT
GlyphFlagsTUnsafeToBreak
    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

-- Flags buffer_serialize_flags_t
-- | Flags that control what glyph information are serialized in 'GI.HarfBuzz.Functions.bufferSerializeGlyphs'.
-- 
-- /Since: 0.9.20/
data BufferSerializeFlagsT = 
      BufferSerializeFlagsTDefault
    -- ^ serialize glyph names, clusters and positions.
    | BufferSerializeFlagsTNoClusters
    -- ^ do not serialize glyph cluster.
    | BufferSerializeFlagsTNoPositions
    -- ^ do not serialize glyph position information.
    | BufferSerializeFlagsTNoGlyphNames
    -- ^ do no serialize glyph name.
    | BufferSerializeFlagsTGlyphExtents
    -- ^ serialize glyph extents.
    | BufferSerializeFlagsTGlyphFlags
    -- ^ serialize glyph flags. Since: 1.5.0
    | BufferSerializeFlagsTNoAdvances
    -- ^ do not serialize glyph advances,
    --  glyph offsets will reflect absolute glyph positions. Since: 1.8.0
    | AnotherBufferSerializeFlagsT Int
    -- ^ Catch-all for unknown values
    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 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 (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
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

-- Flags buffer_flags_t
-- | Flags for t'GI.HarfBuzz.Structs.BufferT.BufferT'.
-- 
-- /Since: 0.9.20/
data BufferFlagsT = 
      BufferFlagsTDefault
    -- ^ the default buffer flag.
    | BufferFlagsTBot
    -- ^ flag indicating that special handling of the beginning
    --                      of text paragraph can be applied to this buffer. Should usually
    --                      be set, unless you are passing to the buffer only part
    --                      of the text without the full context.
    | BufferFlagsTEot
    -- ^ flag indicating that special handling of the end of text
    --                      paragraph can be applied to this buffer, similar to
    --                      /@hBBUFFERFLAGBOT@/.
    | BufferFlagsTPreserveDefaultIgnorables
    -- ^ flag indication that character with Default_Ignorable
    --                      Unicode property should use the corresponding glyph
    --                      from the font, instead of hiding them (done by
    --                      replacing them with the space glyph and zeroing the
    --                      advance width.)  This flag takes precedence over
    --                      /@hBBUFFERFLAGREMOVEDEFAULTIGNORABLES@/.
    | BufferFlagsTRemoveDefaultIgnorables
    -- ^ flag indication that character with Default_Ignorable
    --                      Unicode property should be removed from glyph string
    --                      instead of hiding them (done by replacing them with the
    --                      space glyph and zeroing the advance width.)
    --                      /@hBBUFFERFLAGPRESERVEDEFAULTIGNORABLES@/ takes
    --                      precedence over this flag. Since: 1.8.0
    | BufferFlagsTDoNotInsertDottedCircle
    -- ^ flag indicating that a dotted circle should
    --                      not be inserted in the rendering of incorrect
    --                      character sequences (such at \<0905 093E>). Since: 2.4
    | AnotherBufferFlagsT Int
    -- ^ Catch-all for unknown values
    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 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 (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
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

-- Flags buffer_diff_flags_t
-- | Flags from comparing two t'GI.HarfBuzz.Structs.BufferT.BufferT'\'s.
-- 
-- Buffer with different t'GI.HarfBuzz.Enums.BufferContentTypeT' cannot be meaningfully
-- compared in any further detail.
-- 
-- For buffers with differing length, the per-glyph comparison is not
-- attempted, though we do still scan reference buffer for dotted circle and
-- @.notdef@ glyphs.
-- 
-- If the buffers have the same length, we compare them glyph-by-glyph and
-- report which aspect(s) of the glyph info\/position are different.
-- 
-- /Since: 1.5.0/
data BufferDiffFlagsT = 
      BufferDiffFlagsTEqual
    -- ^ equal buffers.
    | BufferDiffFlagsTContentTypeMismatch
    -- ^ buffers with different
    --     t'GI.HarfBuzz.Enums.BufferContentTypeT'.
    | BufferDiffFlagsTLengthMismatch
    -- ^ buffers with differing length.
    | BufferDiffFlagsTNotdefPresent
    -- ^ @.notdef@ glyph is present in the
    --     reference buffer.
    | BufferDiffFlagsTDottedCirclePresent
    -- ^ dotted circle glyph is present
    --     in the reference buffer.
    | BufferDiffFlagsTCodepointMismatch
    -- ^ difference in t'GI.HarfBuzz.Structs.GlyphInfoT.GlyphInfoT'.@/codepoint/@
    | BufferDiffFlagsTClusterMismatch
    -- ^ difference in t'GI.HarfBuzz.Structs.GlyphInfoT.GlyphInfoT'.@/cluster/@
    | BufferDiffFlagsTGlyphFlagsMismatch
    -- ^ difference in t'GI.HarfBuzz.Flags.GlyphFlagsT'.
    | BufferDiffFlagsTPositionMismatch
    -- ^ difference in t'GI.HarfBuzz.Structs.GlyphPositionT.GlyphPositionT'.
    | AnotherBufferDiffFlagsT Int
    -- ^ Catch-all for unknown values
    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 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