-- | 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.Pango.Enums
    ( 

 -- * Enumerations


-- ** Alignment #enum:Alignment#

    Alignment(..)                           ,


-- ** AttrType #enum:AttrType#

    AttrType(..)                            ,


-- ** BaselineShift #enum:BaselineShift#

    BaselineShift(..)                       ,


-- ** BidiType #enum:BidiType#

    BidiType(..)                            ,


-- ** CoverageLevel #enum:CoverageLevel#

    CoverageLevel(..)                       ,


-- ** Direction #enum:Direction#

    Direction(..)                           ,


-- ** EllipsizeMode #enum:EllipsizeMode#

    EllipsizeMode(..)                       ,


-- ** FontScale #enum:FontScale#

    FontScale(..)                           ,


-- ** Gravity #enum:Gravity#

    Gravity(..)                             ,


-- ** GravityHint #enum:GravityHint#

    GravityHint(..)                         ,


-- ** LayoutDeserializeError #enum:LayoutDeserializeError#

    LayoutDeserializeError(..)              ,
    catchLayoutDeserializeError             ,
    handleLayoutDeserializeError            ,


-- ** Overline #enum:Overline#

    Overline(..)                            ,


-- ** RenderPart #enum:RenderPart#

    RenderPart(..)                          ,


-- ** Script #enum:Script#

    Script(..)                              ,


-- ** Stretch #enum:Stretch#

    Stretch(..)                             ,


-- ** Style #enum:Style#

    Style(..)                               ,


-- ** TabAlign #enum:TabAlign#

    TabAlign(..)                            ,


-- ** TextTransform #enum:TextTransform#

    TextTransform(..)                       ,


-- ** Underline #enum:Underline#

    Underline(..)                           ,


-- ** Variant #enum:Variant#

    Variant(..)                             ,


-- ** Weight #enum:Weight#

    Weight(..)                              ,


-- ** WrapMode #enum:WrapMode#

    WrapMode(..)                            ,




    ) 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


-- Enum WrapMode
-- | @PangoWrapMode@ describes how to wrap the lines of a @PangoLayout@
-- to the desired width.
-- 
-- For /@pANGOWRAPWORD@/, Pango uses break opportunities that are determined
-- by the Unicode line breaking algorithm. For /@pANGOWRAPCHAR@/, Pango allows
-- breaking at grapheme boundaries that are determined by the Unicode text
-- segmentation algorithm.
data WrapMode = 
      WrapModeWord
    -- ^ wrap lines at word boundaries.
    | WrapModeChar
    -- ^ wrap lines at character boundaries.
    | WrapModeWordChar
    -- ^ wrap lines at word boundaries, but fall back to
    --   character boundaries if there is not enough space for a full word.
    | AnotherWrapMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WrapMode -> ShowS
[WrapMode] -> ShowS
WrapMode -> String
(Int -> WrapMode -> ShowS)
-> (WrapMode -> String) -> ([WrapMode] -> ShowS) -> Show WrapMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WrapMode] -> ShowS
$cshowList :: [WrapMode] -> ShowS
show :: WrapMode -> String
$cshow :: WrapMode -> String
showsPrec :: Int -> WrapMode -> ShowS
$cshowsPrec :: Int -> WrapMode -> ShowS
Show, WrapMode -> WrapMode -> Bool
(WrapMode -> WrapMode -> Bool)
-> (WrapMode -> WrapMode -> Bool) -> Eq WrapMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WrapMode -> WrapMode -> Bool
$c/= :: WrapMode -> WrapMode -> Bool
== :: WrapMode -> WrapMode -> Bool
$c== :: WrapMode -> WrapMode -> Bool
Eq)

instance P.Enum WrapMode where
    fromEnum :: WrapMode -> Int
fromEnum WrapMode
WrapModeWord = Int
0
    fromEnum WrapMode
WrapModeChar = Int
1
    fromEnum WrapMode
WrapModeWordChar = Int
2
    fromEnum (AnotherWrapMode Int
k) = Int
k

    toEnum :: Int -> WrapMode
toEnum Int
0 = WrapMode
WrapModeWord
    toEnum Int
1 = WrapMode
WrapModeChar
    toEnum Int
2 = WrapMode
WrapModeWordChar
    toEnum Int
k = Int -> WrapMode
AnotherWrapMode Int
k

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

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

foreign import ccall "pango_wrap_mode_get_type" c_pango_wrap_mode_get_type :: 
    IO GType

instance B.Types.TypedObject WrapMode where
    glibType :: IO GType
glibType = IO GType
c_pango_wrap_mode_get_type

instance B.Types.BoxedEnum WrapMode

-- Enum Weight
-- | An enumeration specifying the weight (boldness) of a font.
-- 
-- Weight is specified as a numeric value ranging from 100 to 1000.
-- This enumeration simply provides some common, predefined values.
data Weight = 
      WeightThin
    -- ^ the thin weight (= 100) Since: 1.24
    | WeightUltralight
    -- ^ the ultralight weight (= 200)
    | WeightLight
    -- ^ the light weight (= 300)
    | WeightSemilight
    -- ^ the semilight weight (= 350) Since: 1.36.7
    | WeightBook
    -- ^ the book weight (= 380) Since: 1.24)
    | WeightNormal
    -- ^ the default weight (= 400)
    | WeightMedium
    -- ^ the normal weight (= 500) Since: 1.24
    | WeightSemibold
    -- ^ the semibold weight (= 600)
    | WeightBold
    -- ^ the bold weight (= 700)
    | WeightUltrabold
    -- ^ the ultrabold weight (= 800)
    | WeightHeavy
    -- ^ the heavy weight (= 900)
    | WeightUltraheavy
    -- ^ the ultraheavy weight (= 1000) Since: 1.24
    | AnotherWeight Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Weight -> ShowS
[Weight] -> ShowS
Weight -> String
(Int -> Weight -> ShowS)
-> (Weight -> String) -> ([Weight] -> ShowS) -> Show Weight
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Weight] -> ShowS
$cshowList :: [Weight] -> ShowS
show :: Weight -> String
$cshow :: Weight -> String
showsPrec :: Int -> Weight -> ShowS
$cshowsPrec :: Int -> Weight -> ShowS
Show, Weight -> Weight -> Bool
(Weight -> Weight -> Bool)
-> (Weight -> Weight -> Bool) -> Eq Weight
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Weight -> Weight -> Bool
$c/= :: Weight -> Weight -> Bool
== :: Weight -> Weight -> Bool
$c== :: Weight -> Weight -> Bool
Eq)

instance P.Enum Weight where
    fromEnum :: Weight -> Int
fromEnum Weight
WeightThin = Int
100
    fromEnum Weight
WeightUltralight = Int
200
    fromEnum Weight
WeightLight = Int
300
    fromEnum Weight
WeightSemilight = Int
350
    fromEnum Weight
WeightBook = Int
380
    fromEnum Weight
WeightNormal = Int
400
    fromEnum Weight
WeightMedium = Int
500
    fromEnum Weight
WeightSemibold = Int
600
    fromEnum Weight
WeightBold = Int
700
    fromEnum Weight
WeightUltrabold = Int
800
    fromEnum Weight
WeightHeavy = Int
900
    fromEnum Weight
WeightUltraheavy = Int
1000
    fromEnum (AnotherWeight Int
k) = Int
k

    toEnum :: Int -> Weight
toEnum Int
100 = Weight
WeightThin
    toEnum Int
200 = Weight
WeightUltralight
    toEnum Int
300 = Weight
WeightLight
    toEnum Int
350 = Weight
WeightSemilight
    toEnum Int
380 = Weight
WeightBook
    toEnum Int
400 = Weight
WeightNormal
    toEnum Int
500 = Weight
WeightMedium
    toEnum Int
600 = Weight
WeightSemibold
    toEnum Int
700 = Weight
WeightBold
    toEnum Int
800 = Weight
WeightUltrabold
    toEnum Int
900 = Weight
WeightHeavy
    toEnum Int
1000 = Weight
WeightUltraheavy
    toEnum Int
k = Int -> Weight
AnotherWeight Int
k

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

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

foreign import ccall "pango_weight_get_type" c_pango_weight_get_type :: 
    IO GType

instance B.Types.TypedObject Weight where
    glibType :: IO GType
glibType = IO GType
c_pango_weight_get_type

instance B.Types.BoxedEnum Weight

-- Enum Variant
-- | An enumeration specifying capitalization variant of the font.
-- 
-- Values other than @PANGO_VARIANT_NORMAL@ and @PANGO_VARIANT_SMALL_CAPS@ are
-- available since 1.50.
data Variant = 
      VariantNormal
    -- ^ A normal font.
    | VariantSmallCaps
    -- ^ A font with the lower case characters
    --   replaced by smaller variants of the capital characters.
    | VariantAllSmallCaps
    -- ^ A font with all characters
    --   replaced by smaller variants of the capital characters.
    | VariantPetiteCaps
    -- ^ A font with the lower case characters
    --   replaced by smaller variants of the capital characters.
    --   Petite Caps can be even smaller than Small Caps.
    | VariantAllPetiteCaps
    -- ^ A font with all characters
    --   replaced by smaller variants of the capital characters.
    --   Petite Caps can be even smaller than Small Caps.
    | VariantUnicase
    -- ^ A font with the upper case characters
    --   replaced by smaller variants of the capital letters.
    | VariantTitleCaps
    -- ^ A font with capital letters that
    --   are more suitable for all-uppercase titles.
    | AnotherVariant Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Variant -> ShowS
[Variant] -> ShowS
Variant -> String
(Int -> Variant -> ShowS)
-> (Variant -> String) -> ([Variant] -> ShowS) -> Show Variant
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Variant] -> ShowS
$cshowList :: [Variant] -> ShowS
show :: Variant -> String
$cshow :: Variant -> String
showsPrec :: Int -> Variant -> ShowS
$cshowsPrec :: Int -> Variant -> ShowS
Show, Variant -> Variant -> Bool
(Variant -> Variant -> Bool)
-> (Variant -> Variant -> Bool) -> Eq Variant
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Variant -> Variant -> Bool
$c/= :: Variant -> Variant -> Bool
== :: Variant -> Variant -> Bool
$c== :: Variant -> Variant -> Bool
Eq)

instance P.Enum Variant where
    fromEnum :: Variant -> Int
fromEnum Variant
VariantNormal = Int
0
    fromEnum Variant
VariantSmallCaps = Int
1
    fromEnum Variant
VariantAllSmallCaps = Int
2
    fromEnum Variant
VariantPetiteCaps = Int
3
    fromEnum Variant
VariantAllPetiteCaps = Int
4
    fromEnum Variant
VariantUnicase = Int
5
    fromEnum Variant
VariantTitleCaps = Int
6
    fromEnum (AnotherVariant Int
k) = Int
k

    toEnum :: Int -> Variant
toEnum Int
0 = Variant
VariantNormal
    toEnum Int
1 = Variant
VariantSmallCaps
    toEnum Int
2 = Variant
VariantAllSmallCaps
    toEnum Int
3 = Variant
VariantPetiteCaps
    toEnum Int
4 = Variant
VariantAllPetiteCaps
    toEnum Int
5 = Variant
VariantUnicase
    toEnum Int
6 = Variant
VariantTitleCaps
    toEnum Int
k = Int -> Variant
AnotherVariant Int
k

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

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

foreign import ccall "pango_variant_get_type" c_pango_variant_get_type :: 
    IO GType

instance B.Types.TypedObject Variant where
    glibType :: IO GType
glibType = IO GType
c_pango_variant_get_type

instance B.Types.BoxedEnum Variant

-- Enum Underline
-- | The @PangoUnderline@ enumeration is used to specify whether text
-- should be underlined, and if so, the type of underlining.
data Underline = 
      UnderlineNone
    -- ^ no underline should be drawn
    | UnderlineSingle
    -- ^ a single underline should be drawn
    | UnderlineDouble
    -- ^ a double underline should be drawn
    | UnderlineLow
    -- ^ a single underline should be drawn at a
    --   position beneath the ink extents of the text being
    --   underlined. This should be used only for underlining
    --   single characters, such as for keyboard accelerators.
    --   'GI.Pango.Enums.UnderlineSingle' should be used for extended
    --   portions of text.
    | UnderlineError
    -- ^ an underline indicating an error should
    --   be drawn below. The exact style of rendering is up to the
    --   @PangoRenderer@ in use, but typical styles include wavy
    --   or dotted lines.
    --   This underline is typically used to indicate an error such
    --   as a possible mispelling; in some cases a contrasting color
    --   may automatically be used. This type of underlining is
    --   available since Pango 1.4.
    | UnderlineSingleLine
    -- ^ Like /@pANGOUNDERLINESINGLE@/, but
    --   drawn continuously across multiple runs. This type
    --   of underlining is available since Pango 1.46.
    | UnderlineDoubleLine
    -- ^ Like /@pANGOUNDERLINEDOUBLE@/, but
    --   drawn continuously across multiple runs. This type
    --   of underlining is available since Pango 1.46.
    | UnderlineErrorLine
    -- ^ Like /@pANGOUNDERLINEERROR@/, but
    --   drawn continuously across multiple runs. This type
    --   of underlining is available since Pango 1.46.
    | AnotherUnderline Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Underline -> ShowS
[Underline] -> ShowS
Underline -> String
(Int -> Underline -> ShowS)
-> (Underline -> String)
-> ([Underline] -> ShowS)
-> Show Underline
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Underline] -> ShowS
$cshowList :: [Underline] -> ShowS
show :: Underline -> String
$cshow :: Underline -> String
showsPrec :: Int -> Underline -> ShowS
$cshowsPrec :: Int -> Underline -> ShowS
Show, Underline -> Underline -> Bool
(Underline -> Underline -> Bool)
-> (Underline -> Underline -> Bool) -> Eq Underline
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Underline -> Underline -> Bool
$c/= :: Underline -> Underline -> Bool
== :: Underline -> Underline -> Bool
$c== :: Underline -> Underline -> Bool
Eq)

instance P.Enum Underline where
    fromEnum :: Underline -> Int
fromEnum Underline
UnderlineNone = Int
0
    fromEnum Underline
UnderlineSingle = Int
1
    fromEnum Underline
UnderlineDouble = Int
2
    fromEnum Underline
UnderlineLow = Int
3
    fromEnum Underline
UnderlineError = Int
4
    fromEnum Underline
UnderlineSingleLine = Int
5
    fromEnum Underline
UnderlineDoubleLine = Int
6
    fromEnum Underline
UnderlineErrorLine = Int
7
    fromEnum (AnotherUnderline Int
k) = Int
k

    toEnum :: Int -> Underline
toEnum Int
0 = Underline
UnderlineNone
    toEnum Int
1 = Underline
UnderlineSingle
    toEnum Int
2 = Underline
UnderlineDouble
    toEnum Int
3 = Underline
UnderlineLow
    toEnum Int
4 = Underline
UnderlineError
    toEnum Int
5 = Underline
UnderlineSingleLine
    toEnum Int
6 = Underline
UnderlineDoubleLine
    toEnum Int
7 = Underline
UnderlineErrorLine
    toEnum Int
k = Int -> Underline
AnotherUnderline Int
k

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

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

foreign import ccall "pango_underline_get_type" c_pango_underline_get_type :: 
    IO GType

instance B.Types.TypedObject Underline where
    glibType :: IO GType
glibType = IO GType
c_pango_underline_get_type

instance B.Types.BoxedEnum Underline

-- Enum TextTransform
-- | An enumeration that affects how Pango treats characters during shaping.
-- 
-- /Since: 1.50/
data TextTransform = 
      TextTransformNone
    -- ^ Leave text unchanged
    | TextTransformLowercase
    -- ^ Display letters and numbers as lowercase
    | TextTransformUppercase
    -- ^ Display letters and numbers as uppercase
    | TextTransformCapitalize
    -- ^ Display the first character of a word
    --   in titlecase
    | AnotherTextTransform Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextTransform -> ShowS
[TextTransform] -> ShowS
TextTransform -> String
(Int -> TextTransform -> ShowS)
-> (TextTransform -> String)
-> ([TextTransform] -> ShowS)
-> Show TextTransform
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextTransform] -> ShowS
$cshowList :: [TextTransform] -> ShowS
show :: TextTransform -> String
$cshow :: TextTransform -> String
showsPrec :: Int -> TextTransform -> ShowS
$cshowsPrec :: Int -> TextTransform -> ShowS
Show, TextTransform -> TextTransform -> Bool
(TextTransform -> TextTransform -> Bool)
-> (TextTransform -> TextTransform -> Bool) -> Eq TextTransform
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextTransform -> TextTransform -> Bool
$c/= :: TextTransform -> TextTransform -> Bool
== :: TextTransform -> TextTransform -> Bool
$c== :: TextTransform -> TextTransform -> Bool
Eq)

instance P.Enum TextTransform where
    fromEnum :: TextTransform -> Int
fromEnum TextTransform
TextTransformNone = Int
0
    fromEnum TextTransform
TextTransformLowercase = Int
1
    fromEnum TextTransform
TextTransformUppercase = Int
2
    fromEnum TextTransform
TextTransformCapitalize = Int
3
    fromEnum (AnotherTextTransform Int
k) = Int
k

    toEnum :: Int -> TextTransform
toEnum Int
0 = TextTransform
TextTransformNone
    toEnum Int
1 = TextTransform
TextTransformLowercase
    toEnum Int
2 = TextTransform
TextTransformUppercase
    toEnum Int
3 = TextTransform
TextTransformCapitalize
    toEnum Int
k = Int -> TextTransform
AnotherTextTransform Int
k

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

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

foreign import ccall "pango_text_transform_get_type" c_pango_text_transform_get_type :: 
    IO GType

instance B.Types.TypedObject TextTransform where
    glibType :: IO GType
glibType = IO GType
c_pango_text_transform_get_type

instance B.Types.BoxedEnum TextTransform

-- Enum TabAlign
-- | @PangoTabAlign@ specifies where the text appears relative to the tab stop
-- position.
-- 
-- Support for tab alignments other than 'GI.Pango.Enums.TabAlignLeft' was added
-- in Pango 1.50.
data TabAlign = 
      TabAlignLeft
    -- ^ the text appears to the right of the tab stop position
    | TabAlignRight
    -- ^ the text appears to the left of the tab stop position
    --   until the available space is filled
    | TabAlignCenter
    -- ^ the text is centered at the tab stop position
    --   until the available space is filled
    | TabAlignDecimal
    -- ^ text before the first occurrence of the decimal point
    --   character appears to the left of the tab stop position (until the available
    --   space is filled), the rest to the right
    | AnotherTabAlign Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TabAlign -> ShowS
[TabAlign] -> ShowS
TabAlign -> String
(Int -> TabAlign -> ShowS)
-> (TabAlign -> String) -> ([TabAlign] -> ShowS) -> Show TabAlign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TabAlign] -> ShowS
$cshowList :: [TabAlign] -> ShowS
show :: TabAlign -> String
$cshow :: TabAlign -> String
showsPrec :: Int -> TabAlign -> ShowS
$cshowsPrec :: Int -> TabAlign -> ShowS
Show, TabAlign -> TabAlign -> Bool
(TabAlign -> TabAlign -> Bool)
-> (TabAlign -> TabAlign -> Bool) -> Eq TabAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TabAlign -> TabAlign -> Bool
$c/= :: TabAlign -> TabAlign -> Bool
== :: TabAlign -> TabAlign -> Bool
$c== :: TabAlign -> TabAlign -> Bool
Eq)

instance P.Enum TabAlign where
    fromEnum :: TabAlign -> Int
fromEnum TabAlign
TabAlignLeft = Int
0
    fromEnum TabAlign
TabAlignRight = Int
1
    fromEnum TabAlign
TabAlignCenter = Int
2
    fromEnum TabAlign
TabAlignDecimal = Int
3
    fromEnum (AnotherTabAlign Int
k) = Int
k

    toEnum :: Int -> TabAlign
toEnum Int
0 = TabAlign
TabAlignLeft
    toEnum Int
1 = TabAlign
TabAlignRight
    toEnum Int
2 = TabAlign
TabAlignCenter
    toEnum Int
3 = TabAlign
TabAlignDecimal
    toEnum Int
k = Int -> TabAlign
AnotherTabAlign Int
k

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

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

foreign import ccall "pango_tab_align_get_type" c_pango_tab_align_get_type :: 
    IO GType

instance B.Types.TypedObject TabAlign where
    glibType :: IO GType
glibType = IO GType
c_pango_tab_align_get_type

instance B.Types.BoxedEnum TabAlign

-- Enum Style
-- | An enumeration specifying the various slant styles possible for a font.
data Style = 
      StyleNormal
    -- ^ the font is upright.
    | StyleOblique
    -- ^ the font is slanted, but in a roman style.
    | StyleItalic
    -- ^ the font is slanted in an italic style.
    | AnotherStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Style -> ShowS
[Style] -> ShowS
Style -> String
(Int -> Style -> ShowS)
-> (Style -> String) -> ([Style] -> ShowS) -> Show Style
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Style] -> ShowS
$cshowList :: [Style] -> ShowS
show :: Style -> String
$cshow :: Style -> String
showsPrec :: Int -> Style -> ShowS
$cshowsPrec :: Int -> Style -> ShowS
Show, Style -> Style -> Bool
(Style -> Style -> Bool) -> (Style -> Style -> Bool) -> Eq Style
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Style -> Style -> Bool
$c/= :: Style -> Style -> Bool
== :: Style -> Style -> Bool
$c== :: Style -> Style -> Bool
Eq)

instance P.Enum Style where
    fromEnum :: Style -> Int
fromEnum Style
StyleNormal = Int
0
    fromEnum Style
StyleOblique = Int
1
    fromEnum Style
StyleItalic = Int
2
    fromEnum (AnotherStyle Int
k) = Int
k

    toEnum :: Int -> Style
toEnum Int
0 = Style
StyleNormal
    toEnum Int
1 = Style
StyleOblique
    toEnum Int
2 = Style
StyleItalic
    toEnum Int
k = Int -> Style
AnotherStyle Int
k

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

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

foreign import ccall "pango_style_get_type" c_pango_style_get_type :: 
    IO GType

instance B.Types.TypedObject Style where
    glibType :: IO GType
glibType = IO GType
c_pango_style_get_type

instance B.Types.BoxedEnum Style

-- Enum Stretch
-- | An enumeration specifying the width of the font relative to other designs
-- within a family.
data Stretch = 
      StretchUltraCondensed
    -- ^ ultra condensed width
    | StretchExtraCondensed
    -- ^ extra condensed width
    | StretchCondensed
    -- ^ condensed width
    | StretchSemiCondensed
    -- ^ semi condensed width
    | StretchNormal
    -- ^ the normal width
    | StretchSemiExpanded
    -- ^ semi expanded width
    | StretchExpanded
    -- ^ expanded width
    | StretchExtraExpanded
    -- ^ extra expanded width
    | StretchUltraExpanded
    -- ^ ultra expanded width
    | AnotherStretch Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Stretch -> ShowS
[Stretch] -> ShowS
Stretch -> String
(Int -> Stretch -> ShowS)
-> (Stretch -> String) -> ([Stretch] -> ShowS) -> Show Stretch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Stretch] -> ShowS
$cshowList :: [Stretch] -> ShowS
show :: Stretch -> String
$cshow :: Stretch -> String
showsPrec :: Int -> Stretch -> ShowS
$cshowsPrec :: Int -> Stretch -> ShowS
Show, Stretch -> Stretch -> Bool
(Stretch -> Stretch -> Bool)
-> (Stretch -> Stretch -> Bool) -> Eq Stretch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Stretch -> Stretch -> Bool
$c/= :: Stretch -> Stretch -> Bool
== :: Stretch -> Stretch -> Bool
$c== :: Stretch -> Stretch -> Bool
Eq)

instance P.Enum Stretch where
    fromEnum :: Stretch -> Int
fromEnum Stretch
StretchUltraCondensed = Int
0
    fromEnum Stretch
StretchExtraCondensed = Int
1
    fromEnum Stretch
StretchCondensed = Int
2
    fromEnum Stretch
StretchSemiCondensed = Int
3
    fromEnum Stretch
StretchNormal = Int
4
    fromEnum Stretch
StretchSemiExpanded = Int
5
    fromEnum Stretch
StretchExpanded = Int
6
    fromEnum Stretch
StretchExtraExpanded = Int
7
    fromEnum Stretch
StretchUltraExpanded = Int
8
    fromEnum (AnotherStretch Int
k) = Int
k

    toEnum :: Int -> Stretch
toEnum Int
0 = Stretch
StretchUltraCondensed
    toEnum Int
1 = Stretch
StretchExtraCondensed
    toEnum Int
2 = Stretch
StretchCondensed
    toEnum Int
3 = Stretch
StretchSemiCondensed
    toEnum Int
4 = Stretch
StretchNormal
    toEnum Int
5 = Stretch
StretchSemiExpanded
    toEnum Int
6 = Stretch
StretchExpanded
    toEnum Int
7 = Stretch
StretchExtraExpanded
    toEnum Int
8 = Stretch
StretchUltraExpanded
    toEnum Int
k = Int -> Stretch
AnotherStretch Int
k

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

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

foreign import ccall "pango_stretch_get_type" c_pango_stretch_get_type :: 
    IO GType

instance B.Types.TypedObject Stretch where
    glibType :: IO GType
glibType = IO GType
c_pango_stretch_get_type

instance B.Types.BoxedEnum Stretch

-- Enum Script
-- | The @PangoScript@ enumeration identifies different writing
-- systems.
-- 
-- The values correspond to the names as defined in the Unicode standard. See
-- <http://www.unicode.org/reports/tr24/ Unicode Standard Annex 24: Script names>
-- 
-- Note that this enumeration is deprecated and will not be updated to include values
-- in newer versions of the Unicode standard. Applications should use the
-- t'GI.GLib.Enums.UnicodeScript' enumeration instead,
-- whose values are interchangeable with @PangoScript@.
data Script = 
      ScriptInvalidCode
    -- ^ a value never returned from 'GI.Pango.Functions.scriptForUnichar'
    | ScriptCommon
    -- ^ a character used by multiple different scripts
    | ScriptInherited
    -- ^ a mark glyph that takes its script from the
    -- base glyph to which it is attached
    | ScriptArabic
    -- ^ Arabic
    | ScriptArmenian
    -- ^ Armenian
    | ScriptBengali
    -- ^ Bengali
    | ScriptBopomofo
    -- ^ Bopomofo
    | ScriptCherokee
    -- ^ Cherokee
    | ScriptCoptic
    -- ^ Coptic
    | ScriptCyrillic
    -- ^ Cyrillic
    | ScriptDeseret
    -- ^ Deseret
    | ScriptDevanagari
    -- ^ Devanagari
    | ScriptEthiopic
    -- ^ Ethiopic
    | ScriptGeorgian
    -- ^ Georgian
    | ScriptGothic
    -- ^ Gothic
    | ScriptGreek
    -- ^ Greek
    | ScriptGujarati
    -- ^ Gujarati
    | ScriptGurmukhi
    -- ^ Gurmukhi
    | ScriptHan
    -- ^ Han
    | ScriptHangul
    -- ^ Hangul
    | ScriptHebrew
    -- ^ Hebrew
    | ScriptHiragana
    -- ^ Hiragana
    | ScriptKannada
    -- ^ Kannada
    | ScriptKatakana
    -- ^ Katakana
    | ScriptKhmer
    -- ^ Khmer
    | ScriptLao
    -- ^ Lao
    | ScriptLatin
    -- ^ Latin
    | ScriptMalayalam
    -- ^ Malayalam
    | ScriptMongolian
    -- ^ Mongolian
    | ScriptMyanmar
    -- ^ Myanmar
    | ScriptOgham
    -- ^ Ogham
    | ScriptOldItalic
    -- ^ Old Italic
    | ScriptOriya
    -- ^ Oriya
    | ScriptRunic
    -- ^ Runic
    | ScriptSinhala
    -- ^ Sinhala
    | ScriptSyriac
    -- ^ Syriac
    | ScriptTamil
    -- ^ Tamil
    | ScriptTelugu
    -- ^ Telugu
    | ScriptThaana
    -- ^ Thaana
    | ScriptThai
    -- ^ Thai
    | ScriptTibetan
    -- ^ Tibetan
    | ScriptCanadianAboriginal
    -- ^ Canadian Aboriginal
    | ScriptYi
    -- ^ Yi
    | ScriptTagalog
    -- ^ Tagalog
    | ScriptHanunoo
    -- ^ Hanunoo
    | ScriptBuhid
    -- ^ Buhid
    | ScriptTagbanwa
    -- ^ Tagbanwa
    | ScriptBraille
    -- ^ Braille
    | ScriptCypriot
    -- ^ Cypriot
    | ScriptLimbu
    -- ^ Limbu
    | ScriptOsmanya
    -- ^ Osmanya
    | ScriptShavian
    -- ^ Shavian
    | ScriptLinearB
    -- ^ Linear B
    | ScriptTaiLe
    -- ^ Tai Le
    | ScriptUgaritic
    -- ^ Ugaritic
    | ScriptNewTaiLue
    -- ^ New Tai Lue. Since 1.10
    | ScriptBuginese
    -- ^ Buginese. Since 1.10
    | ScriptGlagolitic
    -- ^ Glagolitic. Since 1.10
    | ScriptTifinagh
    -- ^ Tifinagh. Since 1.10
    | ScriptSylotiNagri
    -- ^ Syloti Nagri. Since 1.10
    | ScriptOldPersian
    -- ^ Old Persian. Since 1.10
    | ScriptKharoshthi
    -- ^ Kharoshthi. Since 1.10
    | ScriptUnknown
    -- ^ an unassigned code point. Since 1.14
    | ScriptBalinese
    -- ^ Balinese. Since 1.14
    | ScriptCuneiform
    -- ^ Cuneiform. Since 1.14
    | ScriptPhoenician
    -- ^ Phoenician. Since 1.14
    | ScriptPhagsPa
    -- ^ Phags-pa. Since 1.14
    | ScriptNko
    -- ^ N\'Ko. Since 1.14
    | ScriptKayahLi
    -- ^ Kayah Li. Since 1.20.1
    | ScriptLepcha
    -- ^ Lepcha. Since 1.20.1
    | ScriptRejang
    -- ^ Rejang. Since 1.20.1
    | ScriptSundanese
    -- ^ Sundanese. Since 1.20.1
    | ScriptSaurashtra
    -- ^ Saurashtra. Since 1.20.1
    | ScriptCham
    -- ^ Cham. Since 1.20.1
    | ScriptOlChiki
    -- ^ Ol Chiki. Since 1.20.1
    | ScriptVai
    -- ^ Vai. Since 1.20.1
    | ScriptCarian
    -- ^ Carian. Since 1.20.1
    | ScriptLycian
    -- ^ Lycian. Since 1.20.1
    | ScriptLydian
    -- ^ Lydian. Since 1.20.1
    | ScriptBatak
    -- ^ Batak. Since 1.32
    | ScriptBrahmi
    -- ^ Brahmi. Since 1.32
    | ScriptMandaic
    -- ^ Mandaic. Since 1.32
    | ScriptChakma
    -- ^ Chakma. Since: 1.32
    | ScriptMeroiticCursive
    -- ^ Meroitic Cursive. Since: 1.32
    | ScriptMeroiticHieroglyphs
    -- ^ Meroitic Hieroglyphs. Since: 1.32
    | ScriptMiao
    -- ^ Miao. Since: 1.32
    | ScriptSharada
    -- ^ Sharada. Since: 1.32
    | ScriptSoraSompeng
    -- ^ Sora Sompeng. Since: 1.32
    | ScriptTakri
    -- ^ Takri. Since: 1.32
    | ScriptBassaVah
    -- ^ Bassa. Since: 1.40
    | ScriptCaucasianAlbanian
    -- ^ Caucasian Albanian. Since: 1.40
    | ScriptDuployan
    -- ^ Duployan. Since: 1.40
    | ScriptElbasan
    -- ^ Elbasan. Since: 1.40
    | ScriptGrantha
    -- ^ Grantha. Since: 1.40
    | ScriptKhojki
    -- ^ Kjohki. Since: 1.40
    | ScriptKhudawadi
    -- ^ Khudawadi, Sindhi. Since: 1.40
    | ScriptLinearA
    -- ^ Linear A. Since: 1.40
    | ScriptMahajani
    -- ^ Mahajani. Since: 1.40
    | ScriptManichaean
    -- ^ Manichaean. Since: 1.40
    | ScriptMendeKikakui
    -- ^ Mende Kikakui. Since: 1.40
    | ScriptModi
    -- ^ Modi. Since: 1.40
    | ScriptMro
    -- ^ Mro. Since: 1.40
    | ScriptNabataean
    -- ^ Nabataean. Since: 1.40
    | ScriptOldNorthArabian
    -- ^ Old North Arabian. Since: 1.40
    | ScriptOldPermic
    -- ^ Old Permic. Since: 1.40
    | ScriptPahawhHmong
    -- ^ Pahawh Hmong. Since: 1.40
    | ScriptPalmyrene
    -- ^ Palmyrene. Since: 1.40
    | ScriptPauCinHau
    -- ^ Pau Cin Hau. Since: 1.40
    | ScriptPsalterPahlavi
    -- ^ Psalter Pahlavi. Since: 1.40
    | ScriptSiddham
    -- ^ Siddham. Since: 1.40
    | ScriptTirhuta
    -- ^ Tirhuta. Since: 1.40
    | ScriptWarangCiti
    -- ^ Warang Citi. Since: 1.40
    | ScriptAhom
    -- ^ Ahom. Since: 1.40
    | ScriptAnatolianHieroglyphs
    -- ^ Anatolian Hieroglyphs. Since: 1.40
    | ScriptHatran
    -- ^ Hatran. Since: 1.40
    | ScriptMultani
    -- ^ Multani. Since: 1.40
    | ScriptOldHungarian
    -- ^ Old Hungarian. Since: 1.40
    | ScriptSignwriting
    -- ^ Signwriting. Since: 1.40
    | AnotherScript Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Script -> ShowS
[Script] -> ShowS
Script -> String
(Int -> Script -> ShowS)
-> (Script -> String) -> ([Script] -> ShowS) -> Show Script
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Script] -> ShowS
$cshowList :: [Script] -> ShowS
show :: Script -> String
$cshow :: Script -> String
showsPrec :: Int -> Script -> ShowS
$cshowsPrec :: Int -> Script -> ShowS
Show, Script -> Script -> Bool
(Script -> Script -> Bool)
-> (Script -> Script -> Bool) -> Eq Script
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Script -> Script -> Bool
$c/= :: Script -> Script -> Bool
== :: Script -> Script -> Bool
$c== :: Script -> Script -> Bool
Eq)

instance P.Enum Script where
    fromEnum :: Script -> Int
fromEnum Script
ScriptInvalidCode = Int
-1
    fromEnum Script
ScriptCommon = Int
0
    fromEnum Script
ScriptInherited = Int
1
    fromEnum Script
ScriptArabic = Int
2
    fromEnum Script
ScriptArmenian = Int
3
    fromEnum Script
ScriptBengali = Int
4
    fromEnum Script
ScriptBopomofo = Int
5
    fromEnum Script
ScriptCherokee = Int
6
    fromEnum Script
ScriptCoptic = Int
7
    fromEnum Script
ScriptCyrillic = Int
8
    fromEnum Script
ScriptDeseret = Int
9
    fromEnum Script
ScriptDevanagari = Int
10
    fromEnum Script
ScriptEthiopic = Int
11
    fromEnum Script
ScriptGeorgian = Int
12
    fromEnum Script
ScriptGothic = Int
13
    fromEnum Script
ScriptGreek = Int
14
    fromEnum Script
ScriptGujarati = Int
15
    fromEnum Script
ScriptGurmukhi = Int
16
    fromEnum Script
ScriptHan = Int
17
    fromEnum Script
ScriptHangul = Int
18
    fromEnum Script
ScriptHebrew = Int
19
    fromEnum Script
ScriptHiragana = Int
20
    fromEnum Script
ScriptKannada = Int
21
    fromEnum Script
ScriptKatakana = Int
22
    fromEnum Script
ScriptKhmer = Int
23
    fromEnum Script
ScriptLao = Int
24
    fromEnum Script
ScriptLatin = Int
25
    fromEnum Script
ScriptMalayalam = Int
26
    fromEnum Script
ScriptMongolian = Int
27
    fromEnum Script
ScriptMyanmar = Int
28
    fromEnum Script
ScriptOgham = Int
29
    fromEnum Script
ScriptOldItalic = Int
30
    fromEnum Script
ScriptOriya = Int
31
    fromEnum Script
ScriptRunic = Int
32
    fromEnum Script
ScriptSinhala = Int
33
    fromEnum Script
ScriptSyriac = Int
34
    fromEnum Script
ScriptTamil = Int
35
    fromEnum Script
ScriptTelugu = Int
36
    fromEnum Script
ScriptThaana = Int
37
    fromEnum Script
ScriptThai = Int
38
    fromEnum Script
ScriptTibetan = Int
39
    fromEnum Script
ScriptCanadianAboriginal = Int
40
    fromEnum Script
ScriptYi = Int
41
    fromEnum Script
ScriptTagalog = Int
42
    fromEnum Script
ScriptHanunoo = Int
43
    fromEnum Script
ScriptBuhid = Int
44
    fromEnum Script
ScriptTagbanwa = Int
45
    fromEnum Script
ScriptBraille = Int
46
    fromEnum Script
ScriptCypriot = Int
47
    fromEnum Script
ScriptLimbu = Int
48
    fromEnum Script
ScriptOsmanya = Int
49
    fromEnum Script
ScriptShavian = Int
50
    fromEnum Script
ScriptLinearB = Int
51
    fromEnum Script
ScriptTaiLe = Int
52
    fromEnum Script
ScriptUgaritic = Int
53
    fromEnum Script
ScriptNewTaiLue = Int
54
    fromEnum Script
ScriptBuginese = Int
55
    fromEnum Script
ScriptGlagolitic = Int
56
    fromEnum Script
ScriptTifinagh = Int
57
    fromEnum Script
ScriptSylotiNagri = Int
58
    fromEnum Script
ScriptOldPersian = Int
59
    fromEnum Script
ScriptKharoshthi = Int
60
    fromEnum Script
ScriptUnknown = Int
61
    fromEnum Script
ScriptBalinese = Int
62
    fromEnum Script
ScriptCuneiform = Int
63
    fromEnum Script
ScriptPhoenician = Int
64
    fromEnum Script
ScriptPhagsPa = Int
65
    fromEnum Script
ScriptNko = Int
66
    fromEnum Script
ScriptKayahLi = Int
67
    fromEnum Script
ScriptLepcha = Int
68
    fromEnum Script
ScriptRejang = Int
69
    fromEnum Script
ScriptSundanese = Int
70
    fromEnum Script
ScriptSaurashtra = Int
71
    fromEnum Script
ScriptCham = Int
72
    fromEnum Script
ScriptOlChiki = Int
73
    fromEnum Script
ScriptVai = Int
74
    fromEnum Script
ScriptCarian = Int
75
    fromEnum Script
ScriptLycian = Int
76
    fromEnum Script
ScriptLydian = Int
77
    fromEnum Script
ScriptBatak = Int
78
    fromEnum Script
ScriptBrahmi = Int
79
    fromEnum Script
ScriptMandaic = Int
80
    fromEnum Script
ScriptChakma = Int
81
    fromEnum Script
ScriptMeroiticCursive = Int
82
    fromEnum Script
ScriptMeroiticHieroglyphs = Int
83
    fromEnum Script
ScriptMiao = Int
84
    fromEnum Script
ScriptSharada = Int
85
    fromEnum Script
ScriptSoraSompeng = Int
86
    fromEnum Script
ScriptTakri = Int
87
    fromEnum Script
ScriptBassaVah = Int
88
    fromEnum Script
ScriptCaucasianAlbanian = Int
89
    fromEnum Script
ScriptDuployan = Int
90
    fromEnum Script
ScriptElbasan = Int
91
    fromEnum Script
ScriptGrantha = Int
92
    fromEnum Script
ScriptKhojki = Int
93
    fromEnum Script
ScriptKhudawadi = Int
94
    fromEnum Script
ScriptLinearA = Int
95
    fromEnum Script
ScriptMahajani = Int
96
    fromEnum Script
ScriptManichaean = Int
97
    fromEnum Script
ScriptMendeKikakui = Int
98
    fromEnum Script
ScriptModi = Int
99
    fromEnum Script
ScriptMro = Int
100
    fromEnum Script
ScriptNabataean = Int
101
    fromEnum Script
ScriptOldNorthArabian = Int
102
    fromEnum Script
ScriptOldPermic = Int
103
    fromEnum Script
ScriptPahawhHmong = Int
104
    fromEnum Script
ScriptPalmyrene = Int
105
    fromEnum Script
ScriptPauCinHau = Int
106
    fromEnum Script
ScriptPsalterPahlavi = Int
107
    fromEnum Script
ScriptSiddham = Int
108
    fromEnum Script
ScriptTirhuta = Int
109
    fromEnum Script
ScriptWarangCiti = Int
110
    fromEnum Script
ScriptAhom = Int
111
    fromEnum Script
ScriptAnatolianHieroglyphs = Int
112
    fromEnum Script
ScriptHatran = Int
113
    fromEnum Script
ScriptMultani = Int
114
    fromEnum Script
ScriptOldHungarian = Int
115
    fromEnum Script
ScriptSignwriting = Int
116
    fromEnum (AnotherScript Int
k) = Int
k

    toEnum :: Int -> Script
toEnum Int
-1 = Script
ScriptInvalidCode
    toEnum Int
0 = Script
ScriptCommon
    toEnum Int
1 = Script
ScriptInherited
    toEnum Int
2 = Script
ScriptArabic
    toEnum Int
3 = Script
ScriptArmenian
    toEnum Int
4 = Script
ScriptBengali
    toEnum Int
5 = Script
ScriptBopomofo
    toEnum Int
6 = Script
ScriptCherokee
    toEnum Int
7 = Script
ScriptCoptic
    toEnum Int
8 = Script
ScriptCyrillic
    toEnum Int
9 = Script
ScriptDeseret
    toEnum Int
10 = Script
ScriptDevanagari
    toEnum Int
11 = Script
ScriptEthiopic
    toEnum Int
12 = Script
ScriptGeorgian
    toEnum Int
13 = Script
ScriptGothic
    toEnum Int
14 = Script
ScriptGreek
    toEnum Int
15 = Script
ScriptGujarati
    toEnum Int
16 = Script
ScriptGurmukhi
    toEnum Int
17 = Script
ScriptHan
    toEnum Int
18 = Script
ScriptHangul
    toEnum Int
19 = Script
ScriptHebrew
    toEnum Int
20 = Script
ScriptHiragana
    toEnum Int
21 = Script
ScriptKannada
    toEnum Int
22 = Script
ScriptKatakana
    toEnum Int
23 = Script
ScriptKhmer
    toEnum Int
24 = Script
ScriptLao
    toEnum Int
25 = Script
ScriptLatin
    toEnum Int
26 = Script
ScriptMalayalam
    toEnum Int
27 = Script
ScriptMongolian
    toEnum Int
28 = Script
ScriptMyanmar
    toEnum Int
29 = Script
ScriptOgham
    toEnum Int
30 = Script
ScriptOldItalic
    toEnum Int
31 = Script
ScriptOriya
    toEnum Int
32 = Script
ScriptRunic
    toEnum Int
33 = Script
ScriptSinhala
    toEnum Int
34 = Script
ScriptSyriac
    toEnum Int
35 = Script
ScriptTamil
    toEnum Int
36 = Script
ScriptTelugu
    toEnum Int
37 = Script
ScriptThaana
    toEnum Int
38 = Script
ScriptThai
    toEnum Int
39 = Script
ScriptTibetan
    toEnum Int
40 = Script
ScriptCanadianAboriginal
    toEnum Int
41 = Script
ScriptYi
    toEnum Int
42 = Script
ScriptTagalog
    toEnum Int
43 = Script
ScriptHanunoo
    toEnum Int
44 = Script
ScriptBuhid
    toEnum Int
45 = Script
ScriptTagbanwa
    toEnum Int
46 = Script
ScriptBraille
    toEnum Int
47 = Script
ScriptCypriot
    toEnum Int
48 = Script
ScriptLimbu
    toEnum Int
49 = Script
ScriptOsmanya
    toEnum Int
50 = Script
ScriptShavian
    toEnum Int
51 = Script
ScriptLinearB
    toEnum Int
52 = Script
ScriptTaiLe
    toEnum Int
53 = Script
ScriptUgaritic
    toEnum Int
54 = Script
ScriptNewTaiLue
    toEnum Int
55 = Script
ScriptBuginese
    toEnum Int
56 = Script
ScriptGlagolitic
    toEnum Int
57 = Script
ScriptTifinagh
    toEnum Int
58 = Script
ScriptSylotiNagri
    toEnum Int
59 = Script
ScriptOldPersian
    toEnum Int
60 = Script
ScriptKharoshthi
    toEnum Int
61 = Script
ScriptUnknown
    toEnum Int
62 = Script
ScriptBalinese
    toEnum Int
63 = Script
ScriptCuneiform
    toEnum Int
64 = Script
ScriptPhoenician
    toEnum Int
65 = Script
ScriptPhagsPa
    toEnum Int
66 = Script
ScriptNko
    toEnum Int
67 = Script
ScriptKayahLi
    toEnum Int
68 = Script
ScriptLepcha
    toEnum Int
69 = Script
ScriptRejang
    toEnum Int
70 = Script
ScriptSundanese
    toEnum Int
71 = Script
ScriptSaurashtra
    toEnum Int
72 = Script
ScriptCham
    toEnum Int
73 = Script
ScriptOlChiki
    toEnum Int
74 = Script
ScriptVai
    toEnum Int
75 = Script
ScriptCarian
    toEnum Int
76 = Script
ScriptLycian
    toEnum Int
77 = Script
ScriptLydian
    toEnum Int
78 = Script
ScriptBatak
    toEnum Int
79 = Script
ScriptBrahmi
    toEnum Int
80 = Script
ScriptMandaic
    toEnum Int
81 = Script
ScriptChakma
    toEnum Int
82 = Script
ScriptMeroiticCursive
    toEnum Int
83 = Script
ScriptMeroiticHieroglyphs
    toEnum Int
84 = Script
ScriptMiao
    toEnum Int
85 = Script
ScriptSharada
    toEnum Int
86 = Script
ScriptSoraSompeng
    toEnum Int
87 = Script
ScriptTakri
    toEnum Int
88 = Script
ScriptBassaVah
    toEnum Int
89 = Script
ScriptCaucasianAlbanian
    toEnum Int
90 = Script
ScriptDuployan
    toEnum Int
91 = Script
ScriptElbasan
    toEnum Int
92 = Script
ScriptGrantha
    toEnum Int
93 = Script
ScriptKhojki
    toEnum Int
94 = Script
ScriptKhudawadi
    toEnum Int
95 = Script
ScriptLinearA
    toEnum Int
96 = Script
ScriptMahajani
    toEnum Int
97 = Script
ScriptManichaean
    toEnum Int
98 = Script
ScriptMendeKikakui
    toEnum Int
99 = Script
ScriptModi
    toEnum Int
100 = Script
ScriptMro
    toEnum Int
101 = Script
ScriptNabataean
    toEnum Int
102 = Script
ScriptOldNorthArabian
    toEnum Int
103 = Script
ScriptOldPermic
    toEnum Int
104 = Script
ScriptPahawhHmong
    toEnum Int
105 = Script
ScriptPalmyrene
    toEnum Int
106 = Script
ScriptPauCinHau
    toEnum Int
107 = Script
ScriptPsalterPahlavi
    toEnum Int
108 = Script
ScriptSiddham
    toEnum Int
109 = Script
ScriptTirhuta
    toEnum Int
110 = Script
ScriptWarangCiti
    toEnum Int
111 = Script
ScriptAhom
    toEnum Int
112 = Script
ScriptAnatolianHieroglyphs
    toEnum Int
113 = Script
ScriptHatran
    toEnum Int
114 = Script
ScriptMultani
    toEnum Int
115 = Script
ScriptOldHungarian
    toEnum Int
116 = Script
ScriptSignwriting
    toEnum Int
k = Int -> Script
AnotherScript Int
k

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

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

foreign import ccall "pango_script_get_type" c_pango_script_get_type :: 
    IO GType

instance B.Types.TypedObject Script where
    glibType :: IO GType
glibType = IO GType
c_pango_script_get_type

instance B.Types.BoxedEnum Script

-- Enum RenderPart
-- | @PangoRenderPart@ defines different items to render for such
-- purposes as setting colors.
-- 
-- /Since: 1.8/
data RenderPart = 
      RenderPartForeground
    -- ^ the text itself
    | RenderPartBackground
    -- ^ the area behind the text
    | RenderPartUnderline
    -- ^ underlines
    | RenderPartStrikethrough
    -- ^ strikethrough lines
    | RenderPartOverline
    -- ^ overlines
    | AnotherRenderPart Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RenderPart -> ShowS
[RenderPart] -> ShowS
RenderPart -> String
(Int -> RenderPart -> ShowS)
-> (RenderPart -> String)
-> ([RenderPart] -> ShowS)
-> Show RenderPart
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RenderPart] -> ShowS
$cshowList :: [RenderPart] -> ShowS
show :: RenderPart -> String
$cshow :: RenderPart -> String
showsPrec :: Int -> RenderPart -> ShowS
$cshowsPrec :: Int -> RenderPart -> ShowS
Show, RenderPart -> RenderPart -> Bool
(RenderPart -> RenderPart -> Bool)
-> (RenderPart -> RenderPart -> Bool) -> Eq RenderPart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RenderPart -> RenderPart -> Bool
$c/= :: RenderPart -> RenderPart -> Bool
== :: RenderPart -> RenderPart -> Bool
$c== :: RenderPart -> RenderPart -> Bool
Eq)

instance P.Enum RenderPart where
    fromEnum :: RenderPart -> Int
fromEnum RenderPart
RenderPartForeground = Int
0
    fromEnum RenderPart
RenderPartBackground = Int
1
    fromEnum RenderPart
RenderPartUnderline = Int
2
    fromEnum RenderPart
RenderPartStrikethrough = Int
3
    fromEnum RenderPart
RenderPartOverline = Int
4
    fromEnum (AnotherRenderPart Int
k) = Int
k

    toEnum :: Int -> RenderPart
toEnum Int
0 = RenderPart
RenderPartForeground
    toEnum Int
1 = RenderPart
RenderPartBackground
    toEnum Int
2 = RenderPart
RenderPartUnderline
    toEnum Int
3 = RenderPart
RenderPartStrikethrough
    toEnum Int
4 = RenderPart
RenderPartOverline
    toEnum Int
k = Int -> RenderPart
AnotherRenderPart Int
k

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

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

foreign import ccall "pango_render_part_get_type" c_pango_render_part_get_type :: 
    IO GType

instance B.Types.TypedObject RenderPart where
    glibType :: IO GType
glibType = IO GType
c_pango_render_part_get_type

instance B.Types.BoxedEnum RenderPart

-- Enum Overline
-- | The @PangoOverline@ enumeration is used to specify whether text
-- should be overlined, and if so, the type of line.
-- 
-- /Since: 1.46/
data Overline = 
      OverlineNone
    -- ^ no overline should be drawn
    | OverlineSingle
    -- ^ Draw a single line above the ink
    --   extents of the text being underlined.
    | AnotherOverline Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Overline -> ShowS
[Overline] -> ShowS
Overline -> String
(Int -> Overline -> ShowS)
-> (Overline -> String) -> ([Overline] -> ShowS) -> Show Overline
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Overline] -> ShowS
$cshowList :: [Overline] -> ShowS
show :: Overline -> String
$cshow :: Overline -> String
showsPrec :: Int -> Overline -> ShowS
$cshowsPrec :: Int -> Overline -> ShowS
Show, Overline -> Overline -> Bool
(Overline -> Overline -> Bool)
-> (Overline -> Overline -> Bool) -> Eq Overline
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Overline -> Overline -> Bool
$c/= :: Overline -> Overline -> Bool
== :: Overline -> Overline -> Bool
$c== :: Overline -> Overline -> Bool
Eq)

instance P.Enum Overline where
    fromEnum :: Overline -> Int
fromEnum Overline
OverlineNone = Int
0
    fromEnum Overline
OverlineSingle = Int
1
    fromEnum (AnotherOverline Int
k) = Int
k

    toEnum :: Int -> Overline
toEnum Int
0 = Overline
OverlineNone
    toEnum Int
1 = Overline
OverlineSingle
    toEnum Int
k = Int -> Overline
AnotherOverline Int
k

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

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

foreign import ccall "pango_overline_get_type" c_pango_overline_get_type :: 
    IO GType

instance B.Types.TypedObject Overline where
    glibType :: IO GType
glibType = IO GType
c_pango_overline_get_type

instance B.Types.BoxedEnum Overline

-- Enum LayoutDeserializeError
-- | Errors that can be returned by [func/@pango@/.Layout.deserialize].
-- 
-- /Since: 1.50/
data LayoutDeserializeError = 
      LayoutDeserializeErrorInvalid
    -- ^ Unspecified error
    | LayoutDeserializeErrorInvalidValue
    -- ^ A JSon value could not be
    --   interpreted
    | LayoutDeserializeErrorMissingValue
    -- ^ A required JSon member was
    --   not found
    | AnotherLayoutDeserializeError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> LayoutDeserializeError -> ShowS
[LayoutDeserializeError] -> ShowS
LayoutDeserializeError -> String
(Int -> LayoutDeserializeError -> ShowS)
-> (LayoutDeserializeError -> String)
-> ([LayoutDeserializeError] -> ShowS)
-> Show LayoutDeserializeError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LayoutDeserializeError] -> ShowS
$cshowList :: [LayoutDeserializeError] -> ShowS
show :: LayoutDeserializeError -> String
$cshow :: LayoutDeserializeError -> String
showsPrec :: Int -> LayoutDeserializeError -> ShowS
$cshowsPrec :: Int -> LayoutDeserializeError -> ShowS
Show, LayoutDeserializeError -> LayoutDeserializeError -> Bool
(LayoutDeserializeError -> LayoutDeserializeError -> Bool)
-> (LayoutDeserializeError -> LayoutDeserializeError -> Bool)
-> Eq LayoutDeserializeError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LayoutDeserializeError -> LayoutDeserializeError -> Bool
$c/= :: LayoutDeserializeError -> LayoutDeserializeError -> Bool
== :: LayoutDeserializeError -> LayoutDeserializeError -> Bool
$c== :: LayoutDeserializeError -> LayoutDeserializeError -> Bool
Eq)

instance P.Enum LayoutDeserializeError where
    fromEnum :: LayoutDeserializeError -> Int
fromEnum LayoutDeserializeError
LayoutDeserializeErrorInvalid = Int
0
    fromEnum LayoutDeserializeError
LayoutDeserializeErrorInvalidValue = Int
1
    fromEnum LayoutDeserializeError
LayoutDeserializeErrorMissingValue = Int
2
    fromEnum (AnotherLayoutDeserializeError Int
k) = Int
k

    toEnum :: Int -> LayoutDeserializeError
toEnum Int
0 = LayoutDeserializeError
LayoutDeserializeErrorInvalid
    toEnum Int
1 = LayoutDeserializeError
LayoutDeserializeErrorInvalidValue
    toEnum Int
2 = LayoutDeserializeError
LayoutDeserializeErrorMissingValue
    toEnum Int
k = Int -> LayoutDeserializeError
AnotherLayoutDeserializeError Int
k

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

instance GErrorClass LayoutDeserializeError where
    gerrorClassDomain :: LayoutDeserializeError -> Text
gerrorClassDomain LayoutDeserializeError
_ = Text
"pango-layout-deserialize-error-quark"

-- | Catch exceptions of type `LayoutDeserializeError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchLayoutDeserializeError ::
    IO a ->
    (LayoutDeserializeError -> GErrorMessage -> IO a) ->
    IO a
catchLayoutDeserializeError :: forall a. IO a -> (LayoutDeserializeError -> Text -> IO a) -> IO a
catchLayoutDeserializeError = IO a -> (LayoutDeserializeError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `LayoutDeserializeError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleLayoutDeserializeError ::
    (LayoutDeserializeError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleLayoutDeserializeError :: forall a. (LayoutDeserializeError -> Text -> IO a) -> IO a -> IO a
handleLayoutDeserializeError = (LayoutDeserializeError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

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

foreign import ccall "pango_layout_deserialize_error_get_type" c_pango_layout_deserialize_error_get_type :: 
    IO GType

instance B.Types.TypedObject LayoutDeserializeError where
    glibType :: IO GType
glibType = IO GType
c_pango_layout_deserialize_error_get_type

instance B.Types.BoxedEnum LayoutDeserializeError

-- Enum GravityHint
-- | @PangoGravityHint@ defines how horizontal scripts should behave in a
-- vertical context.
-- 
-- That is, English excerpts in a vertical paragraph for example.
-- 
-- See also t'GI.Pango.Enums.Gravity'
-- 
-- /Since: 1.16/
data GravityHint = 
      GravityHintNatural
    -- ^ scripts will take their natural gravity based
    --   on the base gravity and the script.  This is the default.
    | GravityHintStrong
    -- ^ always use the base gravity set, regardless of
    --   the script.
    | GravityHintLine
    -- ^ for scripts not in their natural direction (eg.
    --   Latin in East gravity), choose per-script gravity such that every script
    --   respects the line progression. This means, Latin and Arabic will take
    --   opposite gravities and both flow top-to-bottom for example.
    | AnotherGravityHint Int
    -- ^ Catch-all for unknown values
    deriving (Int -> GravityHint -> ShowS
[GravityHint] -> ShowS
GravityHint -> String
(Int -> GravityHint -> ShowS)
-> (GravityHint -> String)
-> ([GravityHint] -> ShowS)
-> Show GravityHint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GravityHint] -> ShowS
$cshowList :: [GravityHint] -> ShowS
show :: GravityHint -> String
$cshow :: GravityHint -> String
showsPrec :: Int -> GravityHint -> ShowS
$cshowsPrec :: Int -> GravityHint -> ShowS
Show, GravityHint -> GravityHint -> Bool
(GravityHint -> GravityHint -> Bool)
-> (GravityHint -> GravityHint -> Bool) -> Eq GravityHint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GravityHint -> GravityHint -> Bool
$c/= :: GravityHint -> GravityHint -> Bool
== :: GravityHint -> GravityHint -> Bool
$c== :: GravityHint -> GravityHint -> Bool
Eq)

instance P.Enum GravityHint where
    fromEnum :: GravityHint -> Int
fromEnum GravityHint
GravityHintNatural = Int
0
    fromEnum GravityHint
GravityHintStrong = Int
1
    fromEnum GravityHint
GravityHintLine = Int
2
    fromEnum (AnotherGravityHint Int
k) = Int
k

    toEnum :: Int -> GravityHint
toEnum Int
0 = GravityHint
GravityHintNatural
    toEnum Int
1 = GravityHint
GravityHintStrong
    toEnum Int
2 = GravityHint
GravityHintLine
    toEnum Int
k = Int -> GravityHint
AnotherGravityHint Int
k

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

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

foreign import ccall "pango_gravity_hint_get_type" c_pango_gravity_hint_get_type :: 
    IO GType

instance B.Types.TypedObject GravityHint where
    glibType :: IO GType
glibType = IO GType
c_pango_gravity_hint_get_type

instance B.Types.BoxedEnum GravityHint

-- Enum Gravity
-- | @PangoGravity@ represents the orientation of glyphs in a segment
-- of text.
-- 
-- This is useful when rendering vertical text layouts. In those situations,
-- the layout is rotated using a non-identity [struct/@pango@/.Matrix], and then
-- glyph orientation is controlled using @PangoGravity@.
-- 
-- Not every value in this enumeration makes sense for every usage of
-- @PangoGravity@; for example, 'GI.Pango.Enums.GravityAuto' only can be passed to
-- 'GI.Pango.Objects.Context.contextSetBaseGravity' and can only be returned by
-- 'GI.Pango.Objects.Context.contextGetBaseGravity'.
-- 
-- See also: t'GI.Pango.Enums.GravityHint'
-- 
-- /Since: 1.16/
data Gravity = 
      GravitySouth
    -- ^ Glyphs stand upright (default) \<img align=\"right\" valign=\"center\" src=\"m-south.png\">
    | GravityEast
    -- ^ Glyphs are rotated 90 degrees counter-clockwise. \<img align=\"right\" valign=\"center\" src=\"m-east.png\">
    | GravityNorth
    -- ^ Glyphs are upside-down. \<img align=\"right\" valign=\"cener\" src=\"m-north.png\">
    | GravityWest
    -- ^ Glyphs are rotated 90 degrees clockwise. \<img align=\"right\" valign=\"center\" src=\"m-west.png\">
    | GravityAuto
    -- ^ Gravity is resolved from the context matrix
    | AnotherGravity Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Gravity -> ShowS
[Gravity] -> ShowS
Gravity -> String
(Int -> Gravity -> ShowS)
-> (Gravity -> String) -> ([Gravity] -> ShowS) -> Show Gravity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Gravity] -> ShowS
$cshowList :: [Gravity] -> ShowS
show :: Gravity -> String
$cshow :: Gravity -> String
showsPrec :: Int -> Gravity -> ShowS
$cshowsPrec :: Int -> Gravity -> ShowS
Show, Gravity -> Gravity -> Bool
(Gravity -> Gravity -> Bool)
-> (Gravity -> Gravity -> Bool) -> Eq Gravity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Gravity -> Gravity -> Bool
$c/= :: Gravity -> Gravity -> Bool
== :: Gravity -> Gravity -> Bool
$c== :: Gravity -> Gravity -> Bool
Eq)

instance P.Enum Gravity where
    fromEnum :: Gravity -> Int
fromEnum Gravity
GravitySouth = Int
0
    fromEnum Gravity
GravityEast = Int
1
    fromEnum Gravity
GravityNorth = Int
2
    fromEnum Gravity
GravityWest = Int
3
    fromEnum Gravity
GravityAuto = Int
4
    fromEnum (AnotherGravity Int
k) = Int
k

    toEnum :: Int -> Gravity
toEnum Int
0 = Gravity
GravitySouth
    toEnum Int
1 = Gravity
GravityEast
    toEnum Int
2 = Gravity
GravityNorth
    toEnum Int
3 = Gravity
GravityWest
    toEnum Int
4 = Gravity
GravityAuto
    toEnum Int
k = Int -> Gravity
AnotherGravity Int
k

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

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

foreign import ccall "pango_gravity_get_type" c_pango_gravity_get_type :: 
    IO GType

instance B.Types.TypedObject Gravity where
    glibType :: IO GType
glibType = IO GType
c_pango_gravity_get_type

instance B.Types.BoxedEnum Gravity

-- Enum FontScale
-- | An enumeration that affects font sizes for superscript
-- and subscript positioning and for (emulated) Small Caps.
-- 
-- /Since: 1.50/
data FontScale = 
      FontScaleNone
    -- ^ Leave the font size unchanged
    | FontScaleSuperscript
    -- ^ Change the font to a size suitable for superscripts
    | FontScaleSubscript
    -- ^ Change the font to a size suitable for subscripts
    | FontScaleSmallCaps
    -- ^ Change the font to a size suitable for Small Caps
    | AnotherFontScale Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FontScale -> ShowS
[FontScale] -> ShowS
FontScale -> String
(Int -> FontScale -> ShowS)
-> (FontScale -> String)
-> ([FontScale] -> ShowS)
-> Show FontScale
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FontScale] -> ShowS
$cshowList :: [FontScale] -> ShowS
show :: FontScale -> String
$cshow :: FontScale -> String
showsPrec :: Int -> FontScale -> ShowS
$cshowsPrec :: Int -> FontScale -> ShowS
Show, FontScale -> FontScale -> Bool
(FontScale -> FontScale -> Bool)
-> (FontScale -> FontScale -> Bool) -> Eq FontScale
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FontScale -> FontScale -> Bool
$c/= :: FontScale -> FontScale -> Bool
== :: FontScale -> FontScale -> Bool
$c== :: FontScale -> FontScale -> Bool
Eq)

instance P.Enum FontScale where
    fromEnum :: FontScale -> Int
fromEnum FontScale
FontScaleNone = Int
0
    fromEnum FontScale
FontScaleSuperscript = Int
1
    fromEnum FontScale
FontScaleSubscript = Int
2
    fromEnum FontScale
FontScaleSmallCaps = Int
3
    fromEnum (AnotherFontScale Int
k) = Int
k

    toEnum :: Int -> FontScale
toEnum Int
0 = FontScale
FontScaleNone
    toEnum Int
1 = FontScale
FontScaleSuperscript
    toEnum Int
2 = FontScale
FontScaleSubscript
    toEnum Int
3 = FontScale
FontScaleSmallCaps
    toEnum Int
k = Int -> FontScale
AnotherFontScale Int
k

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

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

foreign import ccall "pango_font_scale_get_type" c_pango_font_scale_get_type :: 
    IO GType

instance B.Types.TypedObject FontScale where
    glibType :: IO GType
glibType = IO GType
c_pango_font_scale_get_type

instance B.Types.BoxedEnum FontScale

-- Enum EllipsizeMode
-- | @PangoEllipsizeMode@ describes what sort of ellipsization
-- should be applied to text.
-- 
-- In the ellipsization process characters are removed from the
-- text in order to make it fit to a given width and replaced
-- with an ellipsis.
data EllipsizeMode = 
      EllipsizeModeNone
    -- ^ No ellipsization
    | EllipsizeModeStart
    -- ^ Omit characters at the start of the text
    | EllipsizeModeMiddle
    -- ^ Omit characters in the middle of the text
    | EllipsizeModeEnd
    -- ^ Omit characters at the end of the text
    | AnotherEllipsizeMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EllipsizeMode -> ShowS
[EllipsizeMode] -> ShowS
EllipsizeMode -> String
(Int -> EllipsizeMode -> ShowS)
-> (EllipsizeMode -> String)
-> ([EllipsizeMode] -> ShowS)
-> Show EllipsizeMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EllipsizeMode] -> ShowS
$cshowList :: [EllipsizeMode] -> ShowS
show :: EllipsizeMode -> String
$cshow :: EllipsizeMode -> String
showsPrec :: Int -> EllipsizeMode -> ShowS
$cshowsPrec :: Int -> EllipsizeMode -> ShowS
Show, EllipsizeMode -> EllipsizeMode -> Bool
(EllipsizeMode -> EllipsizeMode -> Bool)
-> (EllipsizeMode -> EllipsizeMode -> Bool) -> Eq EllipsizeMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EllipsizeMode -> EllipsizeMode -> Bool
$c/= :: EllipsizeMode -> EllipsizeMode -> Bool
== :: EllipsizeMode -> EllipsizeMode -> Bool
$c== :: EllipsizeMode -> EllipsizeMode -> Bool
Eq)

instance P.Enum EllipsizeMode where
    fromEnum :: EllipsizeMode -> Int
fromEnum EllipsizeMode
EllipsizeModeNone = Int
0
    fromEnum EllipsizeMode
EllipsizeModeStart = Int
1
    fromEnum EllipsizeMode
EllipsizeModeMiddle = Int
2
    fromEnum EllipsizeMode
EllipsizeModeEnd = Int
3
    fromEnum (AnotherEllipsizeMode Int
k) = Int
k

    toEnum :: Int -> EllipsizeMode
toEnum Int
0 = EllipsizeMode
EllipsizeModeNone
    toEnum Int
1 = EllipsizeMode
EllipsizeModeStart
    toEnum Int
2 = EllipsizeMode
EllipsizeModeMiddle
    toEnum Int
3 = EllipsizeMode
EllipsizeModeEnd
    toEnum Int
k = Int -> EllipsizeMode
AnotherEllipsizeMode Int
k

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

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

foreign import ccall "pango_ellipsize_mode_get_type" c_pango_ellipsize_mode_get_type :: 
    IO GType

instance B.Types.TypedObject EllipsizeMode where
    glibType :: IO GType
glibType = IO GType
c_pango_ellipsize_mode_get_type

instance B.Types.BoxedEnum EllipsizeMode

-- Enum Direction
-- | @PangoDirection@ represents a direction in the Unicode bidirectional
-- algorithm.
-- 
-- Not every value in this enumeration makes sense for every usage of
-- @PangoDirection@; for example, the return value of [func/@unicharDirection@/]
-- and [func/@findBaseDir@/] cannot be @PANGO_DIRECTION_WEAK_LTR@ or
-- @PANGO_DIRECTION_WEAK_RTL@, since every character is either neutral
-- or has a strong direction; on the other hand @PANGO_DIRECTION_NEUTRAL@
-- doesn\'t make sense to pass to [func/@itemizeWithBaseDir@/].
-- 
-- The @PANGO_DIRECTION_TTB_LTR@, @PANGO_DIRECTION_TTB_RTL@ values come from
-- an earlier interpretation of this enumeration as the writing direction
-- of a block of text and are no longer used. See @PangoGravity@ for how
-- vertical text is handled in Pango.
-- 
-- If you are interested in text direction, you should really use fribidi
-- directly. @PangoDirection@ is only retained because it is used in some
-- public apis.
data Direction = 
      DirectionLtr
    -- ^ A strong left-to-right direction
    | DirectionRtl
    -- ^ A strong right-to-left direction
    | DirectionTtbLtr
    -- ^ Deprecated value; treated the
    --   same as @PANGO_DIRECTION_RTL@.
    | DirectionTtbRtl
    -- ^ Deprecated value; treated the
    --   same as @PANGO_DIRECTION_LTR@
    | DirectionWeakLtr
    -- ^ A weak left-to-right direction
    | DirectionWeakRtl
    -- ^ A weak right-to-left direction
    | DirectionNeutral
    -- ^ No direction specified
    | AnotherDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Direction -> ShowS
[Direction] -> ShowS
Direction -> String
(Int -> Direction -> ShowS)
-> (Direction -> String)
-> ([Direction] -> ShowS)
-> Show Direction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Direction] -> ShowS
$cshowList :: [Direction] -> ShowS
show :: Direction -> String
$cshow :: Direction -> String
showsPrec :: Int -> Direction -> ShowS
$cshowsPrec :: Int -> Direction -> ShowS
Show, Direction -> Direction -> Bool
(Direction -> Direction -> Bool)
-> (Direction -> Direction -> Bool) -> Eq Direction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Direction -> Direction -> Bool
$c/= :: Direction -> Direction -> Bool
== :: Direction -> Direction -> Bool
$c== :: Direction -> Direction -> Bool
Eq)

instance P.Enum Direction where
    fromEnum :: Direction -> Int
fromEnum Direction
DirectionLtr = Int
0
    fromEnum Direction
DirectionRtl = Int
1
    fromEnum Direction
DirectionTtbLtr = Int
2
    fromEnum Direction
DirectionTtbRtl = Int
3
    fromEnum Direction
DirectionWeakLtr = Int
4
    fromEnum Direction
DirectionWeakRtl = Int
5
    fromEnum Direction
DirectionNeutral = Int
6
    fromEnum (AnotherDirection Int
k) = Int
k

    toEnum :: Int -> Direction
toEnum Int
0 = Direction
DirectionLtr
    toEnum Int
1 = Direction
DirectionRtl
    toEnum Int
2 = Direction
DirectionTtbLtr
    toEnum Int
3 = Direction
DirectionTtbRtl
    toEnum Int
4 = Direction
DirectionWeakLtr
    toEnum Int
5 = Direction
DirectionWeakRtl
    toEnum Int
6 = Direction
DirectionNeutral
    toEnum Int
k = Int -> Direction
AnotherDirection Int
k

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

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

foreign import ccall "pango_direction_get_type" c_pango_direction_get_type :: 
    IO GType

instance B.Types.TypedObject Direction where
    glibType :: IO GType
glibType = IO GType
c_pango_direction_get_type

instance B.Types.BoxedEnum Direction

-- Enum CoverageLevel
-- | @PangoCoverageLevel@ is used to indicate how well a font can
-- represent a particular Unicode character for a particular script.
-- 
-- Since 1.44, only 'GI.Pango.Enums.CoverageLevelNone' and 'GI.Pango.Enums.CoverageLevelExact'
-- will be returned.
data CoverageLevel = 
      CoverageLevelNone
    -- ^ The character is not representable with
    --   the font.
    | CoverageLevelFallback
    -- ^ The character is represented in a
    --   way that may be comprehensible but is not the correct
    --   graphical form. For instance, a Hangul character represented
    --   as a a sequence of Jamos, or a Latin transliteration of a
    --   Cyrillic word.
    | CoverageLevelApproximate
    -- ^ The character is represented as
    --   basically the correct graphical form, but with a stylistic
    --   variant inappropriate for the current script.
    | CoverageLevelExact
    -- ^ The character is represented as the
    --   correct graphical form.
    | AnotherCoverageLevel Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CoverageLevel -> ShowS
[CoverageLevel] -> ShowS
CoverageLevel -> String
(Int -> CoverageLevel -> ShowS)
-> (CoverageLevel -> String)
-> ([CoverageLevel] -> ShowS)
-> Show CoverageLevel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CoverageLevel] -> ShowS
$cshowList :: [CoverageLevel] -> ShowS
show :: CoverageLevel -> String
$cshow :: CoverageLevel -> String
showsPrec :: Int -> CoverageLevel -> ShowS
$cshowsPrec :: Int -> CoverageLevel -> ShowS
Show, CoverageLevel -> CoverageLevel -> Bool
(CoverageLevel -> CoverageLevel -> Bool)
-> (CoverageLevel -> CoverageLevel -> Bool) -> Eq CoverageLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CoverageLevel -> CoverageLevel -> Bool
$c/= :: CoverageLevel -> CoverageLevel -> Bool
== :: CoverageLevel -> CoverageLevel -> Bool
$c== :: CoverageLevel -> CoverageLevel -> Bool
Eq)

instance P.Enum CoverageLevel where
    fromEnum :: CoverageLevel -> Int
fromEnum CoverageLevel
CoverageLevelNone = Int
0
    fromEnum CoverageLevel
CoverageLevelFallback = Int
1
    fromEnum CoverageLevel
CoverageLevelApproximate = Int
2
    fromEnum CoverageLevel
CoverageLevelExact = Int
3
    fromEnum (AnotherCoverageLevel Int
k) = Int
k

    toEnum :: Int -> CoverageLevel
toEnum Int
0 = CoverageLevel
CoverageLevelNone
    toEnum Int
1 = CoverageLevel
CoverageLevelFallback
    toEnum Int
2 = CoverageLevel
CoverageLevelApproximate
    toEnum Int
3 = CoverageLevel
CoverageLevelExact
    toEnum Int
k = Int -> CoverageLevel
AnotherCoverageLevel Int
k

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

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

foreign import ccall "pango_coverage_level_get_type" c_pango_coverage_level_get_type :: 
    IO GType

instance B.Types.TypedObject CoverageLevel where
    glibType :: IO GType
glibType = IO GType
c_pango_coverage_level_get_type

instance B.Types.BoxedEnum CoverageLevel

-- Enum BidiType
{-# DEPRECATED BidiType ["(Since version 1.44)","Use fribidi for this information"] #-}
-- | @PangoBidiType@ represents the bidirectional character
-- type of a Unicode character.
-- 
-- The values in this enumeration are specified by the
-- <http://www.unicode.org/reports/tr9/ Unicode bidirectional algorithm>.
-- 
-- /Since: 1.22/
data BidiType = 
      BidiTypeL
    -- ^ Left-to-Right
    | BidiTypeLre
    -- ^ Left-to-Right Embedding
    | BidiTypeLro
    -- ^ Left-to-Right Override
    | BidiTypeR
    -- ^ Right-to-Left
    | BidiTypeAl
    -- ^ Right-to-Left Arabic
    | BidiTypeRle
    -- ^ Right-to-Left Embedding
    | BidiTypeRlo
    -- ^ Right-to-Left Override
    | BidiTypePdf
    -- ^ Pop Directional Format
    | BidiTypeEn
    -- ^ European Number
    | BidiTypeEs
    -- ^ European Number Separator
    | BidiTypeEt
    -- ^ European Number Terminator
    | BidiTypeAn
    -- ^ Arabic Number
    | BidiTypeCs
    -- ^ Common Number Separator
    | BidiTypeNsm
    -- ^ Nonspacing Mark
    | BidiTypeBn
    -- ^ Boundary Neutral
    | BidiTypeB
    -- ^ Paragraph Separator
    | BidiTypeS
    -- ^ Segment Separator
    | BidiTypeWs
    -- ^ Whitespace
    | BidiTypeOn
    -- ^ Other Neutrals
    | BidiTypeLri
    -- ^ Left-to-Right isolate. Since 1.48.6
    | BidiTypeRli
    -- ^ Right-to-Left isolate. Since 1.48.6
    | BidiTypeFsi
    -- ^ First strong isolate. Since 1.48.6
    | BidiTypePdi
    -- ^ Pop directional isolate. Since 1.48.6
    | AnotherBidiType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BidiType -> ShowS
[BidiType] -> ShowS
BidiType -> String
(Int -> BidiType -> ShowS)
-> (BidiType -> String) -> ([BidiType] -> ShowS) -> Show BidiType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BidiType] -> ShowS
$cshowList :: [BidiType] -> ShowS
show :: BidiType -> String
$cshow :: BidiType -> String
showsPrec :: Int -> BidiType -> ShowS
$cshowsPrec :: Int -> BidiType -> ShowS
Show, BidiType -> BidiType -> Bool
(BidiType -> BidiType -> Bool)
-> (BidiType -> BidiType -> Bool) -> Eq BidiType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BidiType -> BidiType -> Bool
$c/= :: BidiType -> BidiType -> Bool
== :: BidiType -> BidiType -> Bool
$c== :: BidiType -> BidiType -> Bool
Eq)

instance P.Enum BidiType where
    fromEnum :: BidiType -> Int
fromEnum BidiType
BidiTypeL = Int
0
    fromEnum BidiType
BidiTypeLre = Int
1
    fromEnum BidiType
BidiTypeLro = Int
2
    fromEnum BidiType
BidiTypeR = Int
3
    fromEnum BidiType
BidiTypeAl = Int
4
    fromEnum BidiType
BidiTypeRle = Int
5
    fromEnum BidiType
BidiTypeRlo = Int
6
    fromEnum BidiType
BidiTypePdf = Int
7
    fromEnum BidiType
BidiTypeEn = Int
8
    fromEnum BidiType
BidiTypeEs = Int
9
    fromEnum BidiType
BidiTypeEt = Int
10
    fromEnum BidiType
BidiTypeAn = Int
11
    fromEnum BidiType
BidiTypeCs = Int
12
    fromEnum BidiType
BidiTypeNsm = Int
13
    fromEnum BidiType
BidiTypeBn = Int
14
    fromEnum BidiType
BidiTypeB = Int
15
    fromEnum BidiType
BidiTypeS = Int
16
    fromEnum BidiType
BidiTypeWs = Int
17
    fromEnum BidiType
BidiTypeOn = Int
18
    fromEnum BidiType
BidiTypeLri = Int
19
    fromEnum BidiType
BidiTypeRli = Int
20
    fromEnum BidiType
BidiTypeFsi = Int
21
    fromEnum BidiType
BidiTypePdi = Int
22
    fromEnum (AnotherBidiType Int
k) = Int
k

    toEnum :: Int -> BidiType
toEnum Int
0 = BidiType
BidiTypeL
    toEnum Int
1 = BidiType
BidiTypeLre
    toEnum Int
2 = BidiType
BidiTypeLro
    toEnum Int
3 = BidiType
BidiTypeR
    toEnum Int
4 = BidiType
BidiTypeAl
    toEnum Int
5 = BidiType
BidiTypeRle
    toEnum Int
6 = BidiType
BidiTypeRlo
    toEnum Int
7 = BidiType
BidiTypePdf
    toEnum Int
8 = BidiType
BidiTypeEn
    toEnum Int
9 = BidiType
BidiTypeEs
    toEnum Int
10 = BidiType
BidiTypeEt
    toEnum Int
11 = BidiType
BidiTypeAn
    toEnum Int
12 = BidiType
BidiTypeCs
    toEnum Int
13 = BidiType
BidiTypeNsm
    toEnum Int
14 = BidiType
BidiTypeBn
    toEnum Int
15 = BidiType
BidiTypeB
    toEnum Int
16 = BidiType
BidiTypeS
    toEnum Int
17 = BidiType
BidiTypeWs
    toEnum Int
18 = BidiType
BidiTypeOn
    toEnum Int
19 = BidiType
BidiTypeLri
    toEnum Int
20 = BidiType
BidiTypeRli
    toEnum Int
21 = BidiType
BidiTypeFsi
    toEnum Int
22 = BidiType
BidiTypePdi
    toEnum Int
k = Int -> BidiType
AnotherBidiType Int
k

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

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

foreign import ccall "pango_bidi_type_get_type" c_pango_bidi_type_get_type :: 
    IO GType

instance B.Types.TypedObject BidiType where
    glibType :: IO GType
glibType = IO GType
c_pango_bidi_type_get_type

instance B.Types.BoxedEnum BidiType

-- Enum BaselineShift
-- | An enumeration that affects baseline shifts between runs.
-- 
-- /Since: 1.50/
data BaselineShift = 
      BaselineShiftNone
    -- ^ Leave the baseline unchanged
    | BaselineShiftSuperscript
    -- ^ Shift the baseline to the superscript position,
    --   relative to the previous run
    | BaselineShiftSubscript
    -- ^ Shift the baseline to the subscript position,
    --   relative to the previous run
    | AnotherBaselineShift Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BaselineShift -> ShowS
[BaselineShift] -> ShowS
BaselineShift -> String
(Int -> BaselineShift -> ShowS)
-> (BaselineShift -> String)
-> ([BaselineShift] -> ShowS)
-> Show BaselineShift
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BaselineShift] -> ShowS
$cshowList :: [BaselineShift] -> ShowS
show :: BaselineShift -> String
$cshow :: BaselineShift -> String
showsPrec :: Int -> BaselineShift -> ShowS
$cshowsPrec :: Int -> BaselineShift -> ShowS
Show, BaselineShift -> BaselineShift -> Bool
(BaselineShift -> BaselineShift -> Bool)
-> (BaselineShift -> BaselineShift -> Bool) -> Eq BaselineShift
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BaselineShift -> BaselineShift -> Bool
$c/= :: BaselineShift -> BaselineShift -> Bool
== :: BaselineShift -> BaselineShift -> Bool
$c== :: BaselineShift -> BaselineShift -> Bool
Eq)

instance P.Enum BaselineShift where
    fromEnum :: BaselineShift -> Int
fromEnum BaselineShift
BaselineShiftNone = Int
0
    fromEnum BaselineShift
BaselineShiftSuperscript = Int
1
    fromEnum BaselineShift
BaselineShiftSubscript = Int
2
    fromEnum (AnotherBaselineShift Int
k) = Int
k

    toEnum :: Int -> BaselineShift
toEnum Int
0 = BaselineShift
BaselineShiftNone
    toEnum Int
1 = BaselineShift
BaselineShiftSuperscript
    toEnum Int
2 = BaselineShift
BaselineShiftSubscript
    toEnum Int
k = Int -> BaselineShift
AnotherBaselineShift Int
k

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

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

foreign import ccall "pango_baseline_shift_get_type" c_pango_baseline_shift_get_type :: 
    IO GType

instance B.Types.TypedObject BaselineShift where
    glibType :: IO GType
glibType = IO GType
c_pango_baseline_shift_get_type

instance B.Types.BoxedEnum BaselineShift

-- Enum AttrType
-- | The @PangoAttrType@ distinguishes between different types of attributes.
-- 
-- Along with the predefined values, it is possible to allocate additional
-- values for custom attributes using @/AttrType.register/@. The predefined
-- values are given below. The type of structure used to store the attribute is
-- listed in parentheses after the description.
data AttrType = 
      AttrTypeInvalid
    -- ^ does not happen
    | AttrTypeLanguage
    -- ^ language ([struct/@pango@/.AttrLanguage])
    | AttrTypeFamily
    -- ^ font family name list ([struct/@pango@/.AttrString])
    | AttrTypeStyle
    -- ^ font slant style ([struct/@pango@/.AttrInt])
    | AttrTypeWeight
    -- ^ font weight ([struct/@pango@/.AttrInt])
    | AttrTypeVariant
    -- ^ font variant (normal or small caps) ([struct/@pango@/.AttrInt])
    | AttrTypeStretch
    -- ^ font stretch ([struct/@pango@/.AttrInt])
    | AttrTypeSize
    -- ^ font size in points scaled by 'GI.Pango.Constants.SCALE' ([struct/@pango@/.AttrInt])
    | AttrTypeFontDesc
    -- ^ font description ([struct/@pango@/.AttrFontDesc])
    | AttrTypeForeground
    -- ^ foreground color ([struct/@pango@/.AttrColor])
    | AttrTypeBackground
    -- ^ background color ([struct/@pango@/.AttrColor])
    | AttrTypeUnderline
    -- ^ whether the text has an underline ([struct/@pango@/.AttrInt])
    | AttrTypeStrikethrough
    -- ^ whether the text is struck-through ([struct/@pango@/.AttrInt])
    | AttrTypeRise
    -- ^ baseline displacement ([struct/@pango@/.AttrInt])
    | AttrTypeShape
    -- ^ shape ([struct/@pango@/.AttrShape])
    | AttrTypeScale
    -- ^ font size scale factor ([struct/@pango@/.AttrFloat])
    | AttrTypeFallback
    -- ^ whether fallback is enabled ([struct/@pango@/.AttrInt])
    | AttrTypeLetterSpacing
    -- ^ letter spacing ([struct/@pangoAttrInt@/])
    | AttrTypeUnderlineColor
    -- ^ underline color ([struct/@pango@/.AttrColor])
    | AttrTypeStrikethroughColor
    -- ^ strikethrough color ([struct/@pango@/.AttrColor])
    | AttrTypeAbsoluteSize
    -- ^ font size in pixels scaled by 'GI.Pango.Constants.SCALE' ([struct/@pango@/.AttrInt])
    | AttrTypeGravity
    -- ^ base text gravity ([struct/@pango@/.AttrInt])
    | AttrTypeGravityHint
    -- ^ gravity hint ([struct/@pango@/.AttrInt])
    | AttrTypeFontFeatures
    -- ^ OpenType font features ([struct/@pango@/.AttrFontFeatures]). Since 1.38
    | AttrTypeForegroundAlpha
    -- ^ foreground alpha ([struct/@pango@/.AttrInt]). Since 1.38
    | AttrTypeBackgroundAlpha
    -- ^ background alpha ([struct/@pango@/.AttrInt]). Since 1.38
    | AttrTypeAllowBreaks
    -- ^ whether breaks are allowed ([struct/@pango@/.AttrInt]). Since 1.44
    | AttrTypeShow
    -- ^ how to render invisible characters ([struct/@pango@/.AttrInt]). Since 1.44
    | AttrTypeInsertHyphens
    -- ^ whether to insert hyphens at intra-word line breaks ([struct/@pango@/.AttrInt]). Since 1.44
    | AttrTypeOverline
    -- ^ whether the text has an overline ([struct/@pango@/.AttrInt]). Since 1.46
    | AttrTypeOverlineColor
    -- ^ overline color ([struct/@pango@/.AttrColor]). Since 1.46
    | AttrTypeLineHeight
    -- ^ line height factor ([struct/@pango@/.AttrFloat]). Since: 1.50
    | AttrTypeAbsoluteLineHeight
    -- ^ line height ([struct/@pango@/.AttrInt]). Since: 1.50
    | AttrTypeTextTransform
    -- ^ /No description available in the introspection data./
    | AttrTypeWord
    -- ^ override segmentation to classify the range of the attribute as a single word ([struct/@pango@/.AttrInt]). Since 1.50
    | AttrTypeSentence
    -- ^ override segmentation to classify the range of the attribute as a single sentence ([struct/@pango@/.AttrInt]). Since 1.50
    | AttrTypeBaselineShift
    -- ^ baseline displacement ([struct/@pango@/.AttrInt]). Since 1.50
    | AttrTypeFontScale
    -- ^ font-relative size change ([struct/@pango@/.AttrInt]). Since 1.50
    | AnotherAttrType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AttrType -> ShowS
[AttrType] -> ShowS
AttrType -> String
(Int -> AttrType -> ShowS)
-> (AttrType -> String) -> ([AttrType] -> ShowS) -> Show AttrType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AttrType] -> ShowS
$cshowList :: [AttrType] -> ShowS
show :: AttrType -> String
$cshow :: AttrType -> String
showsPrec :: Int -> AttrType -> ShowS
$cshowsPrec :: Int -> AttrType -> ShowS
Show, AttrType -> AttrType -> Bool
(AttrType -> AttrType -> Bool)
-> (AttrType -> AttrType -> Bool) -> Eq AttrType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AttrType -> AttrType -> Bool
$c/= :: AttrType -> AttrType -> Bool
== :: AttrType -> AttrType -> Bool
$c== :: AttrType -> AttrType -> Bool
Eq)

instance P.Enum AttrType where
    fromEnum :: AttrType -> Int
fromEnum AttrType
AttrTypeInvalid = Int
0
    fromEnum AttrType
AttrTypeLanguage = Int
1
    fromEnum AttrType
AttrTypeFamily = Int
2
    fromEnum AttrType
AttrTypeStyle = Int
3
    fromEnum AttrType
AttrTypeWeight = Int
4
    fromEnum AttrType
AttrTypeVariant = Int
5
    fromEnum AttrType
AttrTypeStretch = Int
6
    fromEnum AttrType
AttrTypeSize = Int
7
    fromEnum AttrType
AttrTypeFontDesc = Int
8
    fromEnum AttrType
AttrTypeForeground = Int
9
    fromEnum AttrType
AttrTypeBackground = Int
10
    fromEnum AttrType
AttrTypeUnderline = Int
11
    fromEnum AttrType
AttrTypeStrikethrough = Int
12
    fromEnum AttrType
AttrTypeRise = Int
13
    fromEnum AttrType
AttrTypeShape = Int
14
    fromEnum AttrType
AttrTypeScale = Int
15
    fromEnum AttrType
AttrTypeFallback = Int
16
    fromEnum AttrType
AttrTypeLetterSpacing = Int
17
    fromEnum AttrType
AttrTypeUnderlineColor = Int
18
    fromEnum AttrType
AttrTypeStrikethroughColor = Int
19
    fromEnum AttrType
AttrTypeAbsoluteSize = Int
20
    fromEnum AttrType
AttrTypeGravity = Int
21
    fromEnum AttrType
AttrTypeGravityHint = Int
22
    fromEnum AttrType
AttrTypeFontFeatures = Int
23
    fromEnum AttrType
AttrTypeForegroundAlpha = Int
24
    fromEnum AttrType
AttrTypeBackgroundAlpha = Int
25
    fromEnum AttrType
AttrTypeAllowBreaks = Int
26
    fromEnum AttrType
AttrTypeShow = Int
27
    fromEnum AttrType
AttrTypeInsertHyphens = Int
28
    fromEnum AttrType
AttrTypeOverline = Int
29
    fromEnum AttrType
AttrTypeOverlineColor = Int
30
    fromEnum AttrType
AttrTypeLineHeight = Int
31
    fromEnum AttrType
AttrTypeAbsoluteLineHeight = Int
32
    fromEnum AttrType
AttrTypeTextTransform = Int
33
    fromEnum AttrType
AttrTypeWord = Int
34
    fromEnum AttrType
AttrTypeSentence = Int
35
    fromEnum AttrType
AttrTypeBaselineShift = Int
36
    fromEnum AttrType
AttrTypeFontScale = Int
37
    fromEnum (AnotherAttrType Int
k) = Int
k

    toEnum :: Int -> AttrType
toEnum Int
0 = AttrType
AttrTypeInvalid
    toEnum Int
1 = AttrType
AttrTypeLanguage
    toEnum Int
2 = AttrType
AttrTypeFamily
    toEnum Int
3 = AttrType
AttrTypeStyle
    toEnum Int
4 = AttrType
AttrTypeWeight
    toEnum Int
5 = AttrType
AttrTypeVariant
    toEnum Int
6 = AttrType
AttrTypeStretch
    toEnum Int
7 = AttrType
AttrTypeSize
    toEnum Int
8 = AttrType
AttrTypeFontDesc
    toEnum Int
9 = AttrType
AttrTypeForeground
    toEnum Int
10 = AttrType
AttrTypeBackground
    toEnum Int
11 = AttrType
AttrTypeUnderline
    toEnum Int
12 = AttrType
AttrTypeStrikethrough
    toEnum Int
13 = AttrType
AttrTypeRise
    toEnum Int
14 = AttrType
AttrTypeShape
    toEnum Int
15 = AttrType
AttrTypeScale
    toEnum Int
16 = AttrType
AttrTypeFallback
    toEnum Int
17 = AttrType
AttrTypeLetterSpacing
    toEnum Int
18 = AttrType
AttrTypeUnderlineColor
    toEnum Int
19 = AttrType
AttrTypeStrikethroughColor
    toEnum Int
20 = AttrType
AttrTypeAbsoluteSize
    toEnum Int
21 = AttrType
AttrTypeGravity
    toEnum Int
22 = AttrType
AttrTypeGravityHint
    toEnum Int
23 = AttrType
AttrTypeFontFeatures
    toEnum Int
24 = AttrType
AttrTypeForegroundAlpha
    toEnum Int
25 = AttrType
AttrTypeBackgroundAlpha
    toEnum Int
26 = AttrType
AttrTypeAllowBreaks
    toEnum Int
27 = AttrType
AttrTypeShow
    toEnum Int
28 = AttrType
AttrTypeInsertHyphens
    toEnum Int
29 = AttrType
AttrTypeOverline
    toEnum Int
30 = AttrType
AttrTypeOverlineColor
    toEnum Int
31 = AttrType
AttrTypeLineHeight
    toEnum Int
32 = AttrType
AttrTypeAbsoluteLineHeight
    toEnum Int
33 = AttrType
AttrTypeTextTransform
    toEnum Int
34 = AttrType
AttrTypeWord
    toEnum Int
35 = AttrType
AttrTypeSentence
    toEnum Int
36 = AttrType
AttrTypeBaselineShift
    toEnum Int
37 = AttrType
AttrTypeFontScale
    toEnum Int
k = Int -> AttrType
AnotherAttrType Int
k

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

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

foreign import ccall "pango_attr_type_get_type" c_pango_attr_type_get_type :: 
    IO GType

instance B.Types.TypedObject AttrType where
    glibType :: IO GType
glibType = IO GType
c_pango_attr_type_get_type

instance B.Types.BoxedEnum AttrType

-- Enum Alignment
-- | @PangoAlignment@ describes how to align the lines of a @PangoLayout@
-- within the available space.
-- 
-- If the @PangoLayout@ is set to justify using 'GI.Pango.Objects.Layout.layoutSetJustify',
-- this only affects partial lines.
-- 
-- See 'GI.Pango.Objects.Layout.layoutSetAutoDir' for how text direction affects
-- the interpretation of @PangoAlignment@ values.
data Alignment = 
      AlignmentLeft
    -- ^ Put all available space on the right
    | AlignmentCenter
    -- ^ Center the line within the available space
    | AlignmentRight
    -- ^ Put all available space on the left
    | AnotherAlignment Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Alignment -> ShowS
[Alignment] -> ShowS
Alignment -> String
(Int -> Alignment -> ShowS)
-> (Alignment -> String)
-> ([Alignment] -> ShowS)
-> Show Alignment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Alignment] -> ShowS
$cshowList :: [Alignment] -> ShowS
show :: Alignment -> String
$cshow :: Alignment -> String
showsPrec :: Int -> Alignment -> ShowS
$cshowsPrec :: Int -> Alignment -> ShowS
Show, Alignment -> Alignment -> Bool
(Alignment -> Alignment -> Bool)
-> (Alignment -> Alignment -> Bool) -> Eq Alignment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Alignment -> Alignment -> Bool
$c/= :: Alignment -> Alignment -> Bool
== :: Alignment -> Alignment -> Bool
$c== :: Alignment -> Alignment -> Bool
Eq)

instance P.Enum Alignment where
    fromEnum :: Alignment -> Int
fromEnum Alignment
AlignmentLeft = Int
0
    fromEnum Alignment
AlignmentCenter = Int
1
    fromEnum Alignment
AlignmentRight = Int
2
    fromEnum (AnotherAlignment Int
k) = Int
k

    toEnum :: Int -> Alignment
toEnum Int
0 = Alignment
AlignmentLeft
    toEnum Int
1 = Alignment
AlignmentCenter
    toEnum Int
2 = Alignment
AlignmentRight
    toEnum Int
k = Int -> Alignment
AnotherAlignment Int
k

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

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

foreign import ccall "pango_alignment_get_type" c_pango_alignment_get_type :: 
    IO GType

instance B.Types.TypedObject Alignment where
    glibType :: IO GType
glibType = IO GType
c_pango_alignment_get_type

instance B.Types.BoxedEnum Alignment