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

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

module GI.Pango.Enums
    ( 

 -- * Enumerations
-- ** Alignment #enum:Alignment#

    Alignment(..)                           ,


-- ** AttrType #enum:AttrType#

    AttrType(..)                            ,


-- ** BidiType #enum:BidiType#

    BidiType(..)                            ,


-- ** CoverageLevel #enum:CoverageLevel#

    CoverageLevel(..)                       ,


-- ** Direction #enum:Direction#

    Direction(..)                           ,


-- ** EllipsizeMode #enum:EllipsizeMode#

    EllipsizeMode(..)                       ,


-- ** Gravity #enum:Gravity#

    Gravity(..)                             ,


-- ** GravityHint #enum:GravityHint#

    GravityHint(..)                         ,


-- ** RenderPart #enum:RenderPart#

    RenderPart(..)                          ,


-- ** Script #enum:Script#

    Script(..)                              ,


-- ** Stretch #enum:Stretch#

    Stretch(..)                             ,


-- ** Style #enum:Style#

    Style(..)                               ,


-- ** TabAlign #enum:TabAlign#

    TabAlign(..)                            ,


-- ** 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.ManagedPtr as B.ManagedPtr
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 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


-- Enum WrapMode
-- | A t'GI.Pango.Enums.WrapMode' describes how to wrap the lines of a t'GI.Pango.Objects.Layout.Layout' to the desired width.
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 WrapModeWord = 0
    fromEnum WrapModeChar = 1
    fromEnum WrapModeWordChar = 2
    fromEnum (AnotherWrapMode k :: Int
k) = Int
k

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

instance P.Ord WrapMode where
    compare :: WrapMode -> WrapMode -> Ordering
compare a :: WrapMode
a b :: 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)

foreign import ccall "pango_wrap_mode_get_type" c_pango_wrap_mode_get_type :: 
    IO GType

instance BoxedEnum WrapMode where
    boxedEnumType :: WrapMode -> IO GType
boxedEnumType _ = IO GType
c_pango_wrap_mode_get_type

-- Enum Weight
-- | An enumeration specifying the weight (boldness) of a font. This is a numerical
-- value ranging from 100 to 1000, but there are some 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 WeightThin = 100
    fromEnum WeightUltralight = 200
    fromEnum WeightLight = 300
    fromEnum WeightSemilight = 350
    fromEnum WeightBook = 380
    fromEnum WeightNormal = 400
    fromEnum WeightMedium = 500
    fromEnum WeightSemibold = 600
    fromEnum WeightBold = 700
    fromEnum WeightUltrabold = 800
    fromEnum WeightHeavy = 900
    fromEnum WeightUltraheavy = 1000
    fromEnum (AnotherWeight k :: Int
k) = Int
k

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

instance P.Ord Weight where
    compare :: Weight -> Weight -> Ordering
compare a :: Weight
a b :: 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)

foreign import ccall "pango_weight_get_type" c_pango_weight_get_type :: 
    IO GType

instance BoxedEnum Weight where
    boxedEnumType :: Weight -> IO GType
boxedEnumType _ = IO GType
c_pango_weight_get_type

-- Enum Variant
-- | An enumeration specifying capitalization variant of the font.
data Variant = 
      VariantNormal
    -- ^ A normal font.
    | VariantSmallCaps
    -- ^ A font with the lower case characters
    -- replaced by smaller variants of the capital characters.
    | 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 VariantNormal = 0
    fromEnum VariantSmallCaps = 1
    fromEnum (AnotherVariant k :: Int
k) = Int
k

    toEnum :: Int -> Variant
toEnum 0 = Variant
VariantNormal
    toEnum 1 = Variant
VariantSmallCaps
    toEnum k :: Int
k = Int -> Variant
AnotherVariant Int
k

instance P.Ord Variant where
    compare :: Variant -> Variant -> Ordering
compare a :: Variant
a b :: 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)

foreign import ccall "pango_variant_get_type" c_pango_variant_get_type :: 
    IO GType

instance BoxedEnum Variant where
    boxedEnumType :: Variant -> IO GType
boxedEnumType _ = IO GType
c_pango_variant_get_type

-- Enum Underline
-- | The t'GI.Pango.Enums.Underline' 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
    -- ^ a wavy underline should be drawn below.
    -- This underline is typically used to indicate
    -- an error such as a possilble mispelling; in some
    -- cases a contrasting color may automatically
    -- be used. This type of underlining is available since Pango 1.4.
    | 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 UnderlineNone = 0
    fromEnum UnderlineSingle = 1
    fromEnum UnderlineDouble = 2
    fromEnum UnderlineLow = 3
    fromEnum UnderlineError = 4
    fromEnum (AnotherUnderline k :: Int
k) = Int
k

    toEnum :: Int -> Underline
toEnum 0 = Underline
UnderlineNone
    toEnum 1 = Underline
UnderlineSingle
    toEnum 2 = Underline
UnderlineDouble
    toEnum 3 = Underline
UnderlineLow
    toEnum 4 = Underline
UnderlineError
    toEnum k :: Int
k = Int -> Underline
AnotherUnderline Int
k

instance P.Ord Underline where
    compare :: Underline -> Underline -> Ordering
compare a :: Underline
a b :: 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)

foreign import ccall "pango_underline_get_type" c_pango_underline_get_type :: 
    IO GType

instance BoxedEnum Underline where
    boxedEnumType :: Underline -> IO GType
boxedEnumType _ = IO GType
c_pango_underline_get_type

-- Enum TabAlign
-- | A t'GI.Pango.Enums.TabAlign' specifies where a tab stop appears relative to the text.
data TabAlign = 
      TabAlignLeft
    -- ^ the tab stop appears to the left of the text.
    | 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 TabAlignLeft = 0
    fromEnum (AnotherTabAlign k :: Int
k) = Int
k

    toEnum :: Int -> TabAlign
toEnum 0 = TabAlign
TabAlignLeft
    toEnum k :: Int
k = Int -> TabAlign
AnotherTabAlign Int
k

instance P.Ord TabAlign where
    compare :: TabAlign -> TabAlign -> Ordering
compare a :: TabAlign
a b :: 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)

foreign import ccall "pango_tab_align_get_type" c_pango_tab_align_get_type :: 
    IO GType

instance BoxedEnum TabAlign where
    boxedEnumType :: TabAlign -> IO GType
boxedEnumType _ = IO GType
c_pango_tab_align_get_type

-- 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 StyleNormal = 0
    fromEnum StyleOblique = 1
    fromEnum StyleItalic = 2
    fromEnum (AnotherStyle k :: Int
k) = Int
k

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

instance P.Ord Style where
    compare :: Style -> Style -> Ordering
compare a :: Style
a b :: 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)

foreign import ccall "pango_style_get_type" c_pango_style_get_type :: 
    IO GType

instance BoxedEnum Style where
    boxedEnumType :: Style -> IO GType
boxedEnumType _ = IO GType
c_pango_style_get_type

-- 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 StretchUltraCondensed = 0
    fromEnum StretchExtraCondensed = 1
    fromEnum StretchCondensed = 2
    fromEnum StretchSemiCondensed = 3
    fromEnum StretchNormal = 4
    fromEnum StretchSemiExpanded = 5
    fromEnum StretchExpanded = 6
    fromEnum StretchExtraExpanded = 7
    fromEnum StretchUltraExpanded = 8
    fromEnum (AnotherStretch k :: Int
k) = Int
k

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

instance P.Ord Stretch where
    compare :: Stretch -> Stretch -> Ordering
compare a :: Stretch
a b :: 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)

foreign import ccall "pango_stretch_get_type" c_pango_stretch_get_type :: 
    IO GType

instance BoxedEnum Stretch where
    boxedEnumType :: Stretch -> IO GType
boxedEnumType _ = IO GType
c_pango_stretch_get_type

-- Enum Script
-- | The t'GI.Pango.Enums.Script' enumeration identifies different writing
-- systems. The values correspond to the names as defined in the
-- Unicode standard.
-- Note that new types may be added in the future. Applications should be ready
-- to handle unknown values.  This enumeration is interchangeable with
-- t'GI.GLib.Enums.UnicodeScript'.  See \<ulink
-- url=\"http:\/\/www.unicode.org\/reports\/tr24\/\">Unicode Standard Annex
-- @/24/@: Script names\<\/ulink>.
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 ScriptInvalidCode = -1
    fromEnum ScriptCommon = 0
    fromEnum ScriptInherited = 1
    fromEnum ScriptArabic = 2
    fromEnum ScriptArmenian = 3
    fromEnum ScriptBengali = 4
    fromEnum ScriptBopomofo = 5
    fromEnum ScriptCherokee = 6
    fromEnum ScriptCoptic = 7
    fromEnum ScriptCyrillic = 8
    fromEnum ScriptDeseret = 9
    fromEnum ScriptDevanagari = 10
    fromEnum ScriptEthiopic = 11
    fromEnum ScriptGeorgian = 12
    fromEnum ScriptGothic = 13
    fromEnum ScriptGreek = 14
    fromEnum ScriptGujarati = 15
    fromEnum ScriptGurmukhi = 16
    fromEnum ScriptHan = 17
    fromEnum ScriptHangul = 18
    fromEnum ScriptHebrew = 19
    fromEnum ScriptHiragana = 20
    fromEnum ScriptKannada = 21
    fromEnum ScriptKatakana = 22
    fromEnum ScriptKhmer = 23
    fromEnum ScriptLao = 24
    fromEnum ScriptLatin = 25
    fromEnum ScriptMalayalam = 26
    fromEnum ScriptMongolian = 27
    fromEnum ScriptMyanmar = 28
    fromEnum ScriptOgham = 29
    fromEnum ScriptOldItalic = 30
    fromEnum ScriptOriya = 31
    fromEnum ScriptRunic = 32
    fromEnum ScriptSinhala = 33
    fromEnum ScriptSyriac = 34
    fromEnum ScriptTamil = 35
    fromEnum ScriptTelugu = 36
    fromEnum ScriptThaana = 37
    fromEnum ScriptThai = 38
    fromEnum ScriptTibetan = 39
    fromEnum ScriptCanadianAboriginal = 40
    fromEnum ScriptYi = 41
    fromEnum ScriptTagalog = 42
    fromEnum ScriptHanunoo = 43
    fromEnum ScriptBuhid = 44
    fromEnum ScriptTagbanwa = 45
    fromEnum ScriptBraille = 46
    fromEnum ScriptCypriot = 47
    fromEnum ScriptLimbu = 48
    fromEnum ScriptOsmanya = 49
    fromEnum ScriptShavian = 50
    fromEnum ScriptLinearB = 51
    fromEnum ScriptTaiLe = 52
    fromEnum ScriptUgaritic = 53
    fromEnum ScriptNewTaiLue = 54
    fromEnum ScriptBuginese = 55
    fromEnum ScriptGlagolitic = 56
    fromEnum ScriptTifinagh = 57
    fromEnum ScriptSylotiNagri = 58
    fromEnum ScriptOldPersian = 59
    fromEnum ScriptKharoshthi = 60
    fromEnum ScriptUnknown = 61
    fromEnum ScriptBalinese = 62
    fromEnum ScriptCuneiform = 63
    fromEnum ScriptPhoenician = 64
    fromEnum ScriptPhagsPa = 65
    fromEnum ScriptNko = 66
    fromEnum ScriptKayahLi = 67
    fromEnum ScriptLepcha = 68
    fromEnum ScriptRejang = 69
    fromEnum ScriptSundanese = 70
    fromEnum ScriptSaurashtra = 71
    fromEnum ScriptCham = 72
    fromEnum ScriptOlChiki = 73
    fromEnum ScriptVai = 74
    fromEnum ScriptCarian = 75
    fromEnum ScriptLycian = 76
    fromEnum ScriptLydian = 77
    fromEnum ScriptBatak = 78
    fromEnum ScriptBrahmi = 79
    fromEnum ScriptMandaic = 80
    fromEnum ScriptChakma = 81
    fromEnum ScriptMeroiticCursive = 82
    fromEnum ScriptMeroiticHieroglyphs = 83
    fromEnum ScriptMiao = 84
    fromEnum ScriptSharada = 85
    fromEnum ScriptSoraSompeng = 86
    fromEnum ScriptTakri = 87
    fromEnum ScriptBassaVah = 88
    fromEnum ScriptCaucasianAlbanian = 89
    fromEnum ScriptDuployan = 90
    fromEnum ScriptElbasan = 91
    fromEnum ScriptGrantha = 92
    fromEnum ScriptKhojki = 93
    fromEnum ScriptKhudawadi = 94
    fromEnum ScriptLinearA = 95
    fromEnum ScriptMahajani = 96
    fromEnum ScriptManichaean = 97
    fromEnum ScriptMendeKikakui = 98
    fromEnum ScriptModi = 99
    fromEnum ScriptMro = 100
    fromEnum ScriptNabataean = 101
    fromEnum ScriptOldNorthArabian = 102
    fromEnum ScriptOldPermic = 103
    fromEnum ScriptPahawhHmong = 104
    fromEnum ScriptPalmyrene = 105
    fromEnum ScriptPauCinHau = 106
    fromEnum ScriptPsalterPahlavi = 107
    fromEnum ScriptSiddham = 108
    fromEnum ScriptTirhuta = 109
    fromEnum ScriptWarangCiti = 110
    fromEnum ScriptAhom = 111
    fromEnum ScriptAnatolianHieroglyphs = 112
    fromEnum ScriptHatran = 113
    fromEnum ScriptMultani = 114
    fromEnum ScriptOldHungarian = 115
    fromEnum ScriptSignwriting = 116
    fromEnum (AnotherScript k :: Int
k) = Int
k

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

instance P.Ord Script where
    compare :: Script -> Script -> Ordering
compare a :: Script
a b :: 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)

foreign import ccall "pango_script_get_type" c_pango_script_get_type :: 
    IO GType

instance BoxedEnum Script where
    boxedEnumType :: Script -> IO GType
boxedEnumType _ = IO GType
c_pango_script_get_type

-- Enum RenderPart
-- | t'GI.Pango.Enums.RenderPart' 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
    | 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 RenderPartForeground = 0
    fromEnum RenderPartBackground = 1
    fromEnum RenderPartUnderline = 2
    fromEnum RenderPartStrikethrough = 3
    fromEnum (AnotherRenderPart k :: Int
k) = Int
k

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

instance P.Ord RenderPart where
    compare :: RenderPart -> RenderPart -> Ordering
compare a :: RenderPart
a b :: 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)

foreign import ccall "pango_render_part_get_type" c_pango_render_part_get_type :: 
    IO GType

instance BoxedEnum RenderPart where
    boxedEnumType :: RenderPart -> IO GType
boxedEnumType _ = IO GType
c_pango_render_part_get_type

-- Enum GravityHint
-- | The t'GI.Pango.Enums.GravityHint' defines how horizontal scripts should behave in a
-- vertical context.  That is, English excerpt in a vertical paragraph for
-- example.
-- 
-- See 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 GravityHintNatural = 0
    fromEnum GravityHintStrong = 1
    fromEnum GravityHintLine = 2
    fromEnum (AnotherGravityHint k :: Int
k) = Int
k

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

instance P.Ord GravityHint where
    compare :: GravityHint -> GravityHint -> Ordering
compare a :: GravityHint
a b :: 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)

foreign import ccall "pango_gravity_hint_get_type" c_pango_gravity_hint_get_type :: 
    IO GType

instance BoxedEnum GravityHint where
    boxedEnumType :: GravityHint -> IO GType
boxedEnumType _ = IO GType
c_pango_gravity_hint_get_type

-- Enum Gravity
-- | The t'GI.Pango.Enums.Gravity' type 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 PangoMatrix,
-- and then glyph orientation is controlled using t'GI.Pango.Enums.Gravity'.
-- Not every value in this enumeration makes sense for every usage of
-- t'GI.Pango.Enums.Gravity'; 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)
    | GravityEast
    -- ^ Glyphs are rotated 90 degrees clockwise
    | GravityNorth
    -- ^ Glyphs are upside-down
    | GravityWest
    -- ^ Glyphs are rotated 90 degrees counter-clockwise
    | 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 GravitySouth = 0
    fromEnum GravityEast = 1
    fromEnum GravityNorth = 2
    fromEnum GravityWest = 3
    fromEnum GravityAuto = 4
    fromEnum (AnotherGravity k :: Int
k) = Int
k

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

instance P.Ord Gravity where
    compare :: Gravity -> Gravity -> Ordering
compare a :: Gravity
a b :: 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)

foreign import ccall "pango_gravity_get_type" c_pango_gravity_get_type :: 
    IO GType

instance BoxedEnum Gravity where
    boxedEnumType :: Gravity -> IO GType
boxedEnumType _ = IO GType
c_pango_gravity_get_type

-- Enum EllipsizeMode
-- | The t'GI.Pango.Enums.EllipsizeMode' type describes what sort of (if any)
-- ellipsization should be applied to a line of 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 EllipsizeModeNone = 0
    fromEnum EllipsizeModeStart = 1
    fromEnum EllipsizeModeMiddle = 2
    fromEnum EllipsizeModeEnd = 3
    fromEnum (AnotherEllipsizeMode k :: Int
k) = Int
k

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

instance P.Ord EllipsizeMode where
    compare :: EllipsizeMode -> EllipsizeMode -> Ordering
compare a :: EllipsizeMode
a b :: 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)

foreign import ccall "pango_ellipsize_mode_get_type" c_pango_ellipsize_mode_get_type :: 
    IO GType

instance BoxedEnum EllipsizeMode where
    boxedEnumType :: EllipsizeMode -> IO GType
boxedEnumType _ = IO GType
c_pango_ellipsize_mode_get_type

-- Enum Direction
-- | The t'GI.Pango.Enums.Direction' type represents a direction in the
-- Unicode bidirectional algorithm; not every value in this
-- enumeration makes sense for every usage of t'GI.Pango.Enums.Direction';
-- for example, the return value of 'GI.Pango.Functions.unicharDirection'
-- and 'GI.Pango.Functions.findBaseDir' cannot be 'GI.Pango.Enums.DirectionWeakLtr'
-- or 'GI.Pango.Enums.DirectionWeakRtl', since every character is either
-- neutral or has a strong direction; on the other hand
-- 'GI.Pango.Enums.DirectionNeutral' doesn\'t make sense to pass
-- to 'GI.Pango.Functions.itemizeWithBaseDir'.
-- 
-- The 'GI.Pango.Enums.DirectionTtbLtr', 'GI.Pango.Enums.DirectionTtbRtl'
-- values come from an earlier interpretation of this
-- enumeration as the writing direction of a block of
-- text and are no longer used; See t'GI.Pango.Enums.Gravity' 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 'GI.Pango.Enums.DirectionRtl'.
    | DirectionTtbRtl
    -- ^ Deprecated value; treated the
    --   same as 'GI.Pango.Enums.DirectionLtr'
    | 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 DirectionLtr = 0
    fromEnum DirectionRtl = 1
    fromEnum DirectionTtbLtr = 2
    fromEnum DirectionTtbRtl = 3
    fromEnum DirectionWeakLtr = 4
    fromEnum DirectionWeakRtl = 5
    fromEnum DirectionNeutral = 6
    fromEnum (AnotherDirection k :: Int
k) = Int
k

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

instance P.Ord Direction where
    compare :: Direction -> Direction -> Ordering
compare a :: Direction
a b :: 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)

foreign import ccall "pango_direction_get_type" c_pango_direction_get_type :: 
    IO GType

instance BoxedEnum Direction where
    boxedEnumType :: Direction -> IO GType
boxedEnumType _ = IO GType
c_pango_direction_get_type

-- Enum CoverageLevel
-- | Used to indicate how well a font can represent a particular Unicode
-- character point for a particular script.
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 CoverageLevelNone = 0
    fromEnum CoverageLevelFallback = 1
    fromEnum CoverageLevelApproximate = 2
    fromEnum CoverageLevelExact = 3
    fromEnum (AnotherCoverageLevel k :: Int
k) = Int
k

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

instance P.Ord CoverageLevel where
    compare :: CoverageLevel -> CoverageLevel -> Ordering
compare a :: CoverageLevel
a b :: 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)

foreign import ccall "pango_coverage_level_get_type" c_pango_coverage_level_get_type :: 
    IO GType

instance BoxedEnum CoverageLevel where
    boxedEnumType :: CoverageLevel -> IO GType
boxedEnumType _ = IO GType
c_pango_coverage_level_get_type

-- Enum BidiType
{-# DEPRECATED BidiType ["(Since version 1.44)","Use fribidi for this information"] #-}
-- | The t'GI.Pango.Enums.BidiType' type represents the bidirectional character
-- type of a Unicode character as specified by the
-- \<ulink url=\"http:\/\/www.unicode.org\/reports\/tr9\/\">Unicode bidirectional algorithm\<\/ulink>.
-- 
-- /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
    | 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 BidiTypeL = 0
    fromEnum BidiTypeLre = 1
    fromEnum BidiTypeLro = 2
    fromEnum BidiTypeR = 3
    fromEnum BidiTypeAl = 4
    fromEnum BidiTypeRle = 5
    fromEnum BidiTypeRlo = 6
    fromEnum BidiTypePdf = 7
    fromEnum BidiTypeEn = 8
    fromEnum BidiTypeEs = 9
    fromEnum BidiTypeEt = 10
    fromEnum BidiTypeAn = 11
    fromEnum BidiTypeCs = 12
    fromEnum BidiTypeNsm = 13
    fromEnum BidiTypeBn = 14
    fromEnum BidiTypeB = 15
    fromEnum BidiTypeS = 16
    fromEnum BidiTypeWs = 17
    fromEnum BidiTypeOn = 18
    fromEnum (AnotherBidiType k :: Int
k) = Int
k

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

instance P.Ord BidiType where
    compare :: BidiType -> BidiType -> Ordering
compare a :: BidiType
a b :: 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)

foreign import ccall "pango_bidi_type_get_type" c_pango_bidi_type_get_type :: 
    IO GType

instance BoxedEnum BidiType where
    boxedEnumType :: BidiType -> IO GType
boxedEnumType _ = IO GType
c_pango_bidi_type_get_type

-- Enum AttrType
-- | The t'GI.Pango.Enums.AttrType'
-- distinguishes between different types of attributes. Along with the
-- predefined values, it is possible to allocate additional values
-- for custom attributes using 'GI.Pango.Functions.attrTypeRegister'. 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 (t'GI.Pango.Structs.AttrLanguage.AttrLanguage')
    | AttrTypeFamily
    -- ^ font family name list (t'GI.Pango.Structs.AttrString.AttrString')
    | AttrTypeStyle
    -- ^ font slant style (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeWeight
    -- ^ font weight (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeVariant
    -- ^ font variant (normal or small caps) (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeStretch
    -- ^ font stretch (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeSize
    -- ^ font size in points scaled by 'GI.Pango.Constants.SCALE' (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeFontDesc
    -- ^ font description (t'GI.Pango.Structs.AttrFontDesc.AttrFontDesc')
    | AttrTypeForeground
    -- ^ foreground color (t'GI.Pango.Structs.AttrColor.AttrColor')
    | AttrTypeBackground
    -- ^ background color (t'GI.Pango.Structs.AttrColor.AttrColor')
    | AttrTypeUnderline
    -- ^ whether the text has an underline (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeStrikethrough
    -- ^ whether the text is struck-through (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeRise
    -- ^ baseline displacement (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeShape
    -- ^ shape (t'GI.Pango.Structs.AttrShape.AttrShape')
    | AttrTypeScale
    -- ^ font size scale factor (t'GI.Pango.Structs.AttrFloat.AttrFloat')
    | AttrTypeFallback
    -- ^ whether fallback is enabled (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeLetterSpacing
    -- ^ letter spacing (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeUnderlineColor
    -- ^ underline color (t'GI.Pango.Structs.AttrColor.AttrColor')
    | AttrTypeStrikethroughColor
    -- ^ strikethrough color (t'GI.Pango.Structs.AttrColor.AttrColor')
    | AttrTypeAbsoluteSize
    -- ^ font size in pixels scaled by 'GI.Pango.Constants.SCALE' (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeGravity
    -- ^ base text gravity (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeGravityHint
    -- ^ gravity hint (t'GI.Pango.Structs.AttrInt.AttrInt')
    | AttrTypeFontFeatures
    -- ^ OpenType font features (t'GI.Pango.Structs.AttrString.AttrString'). Since 1.38
    | AttrTypeForegroundAlpha
    -- ^ foreground alpha (t'GI.Pango.Structs.AttrInt.AttrInt'). Since 1.38
    | AttrTypeBackgroundAlpha
    -- ^ background alpha (t'GI.Pango.Structs.AttrInt.AttrInt'). Since 1.38
    | 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 AttrTypeInvalid = 0
    fromEnum AttrTypeLanguage = 1
    fromEnum AttrTypeFamily = 2
    fromEnum AttrTypeStyle = 3
    fromEnum AttrTypeWeight = 4
    fromEnum AttrTypeVariant = 5
    fromEnum AttrTypeStretch = 6
    fromEnum AttrTypeSize = 7
    fromEnum AttrTypeFontDesc = 8
    fromEnum AttrTypeForeground = 9
    fromEnum AttrTypeBackground = 10
    fromEnum AttrTypeUnderline = 11
    fromEnum AttrTypeStrikethrough = 12
    fromEnum AttrTypeRise = 13
    fromEnum AttrTypeShape = 14
    fromEnum AttrTypeScale = 15
    fromEnum AttrTypeFallback = 16
    fromEnum AttrTypeLetterSpacing = 17
    fromEnum AttrTypeUnderlineColor = 18
    fromEnum AttrTypeStrikethroughColor = 19
    fromEnum AttrTypeAbsoluteSize = 20
    fromEnum AttrTypeGravity = 21
    fromEnum AttrTypeGravityHint = 22
    fromEnum AttrTypeFontFeatures = 23
    fromEnum AttrTypeForegroundAlpha = 24
    fromEnum AttrTypeBackgroundAlpha = 25
    fromEnum (AnotherAttrType k :: Int
k) = Int
k

    toEnum :: Int -> AttrType
toEnum 0 = AttrType
AttrTypeInvalid
    toEnum 1 = AttrType
AttrTypeLanguage
    toEnum 2 = AttrType
AttrTypeFamily
    toEnum 3 = AttrType
AttrTypeStyle
    toEnum 4 = AttrType
AttrTypeWeight
    toEnum 5 = AttrType
AttrTypeVariant
    toEnum 6 = AttrType
AttrTypeStretch
    toEnum 7 = AttrType
AttrTypeSize
    toEnum 8 = AttrType
AttrTypeFontDesc
    toEnum 9 = AttrType
AttrTypeForeground
    toEnum 10 = AttrType
AttrTypeBackground
    toEnum 11 = AttrType
AttrTypeUnderline
    toEnum 12 = AttrType
AttrTypeStrikethrough
    toEnum 13 = AttrType
AttrTypeRise
    toEnum 14 = AttrType
AttrTypeShape
    toEnum 15 = AttrType
AttrTypeScale
    toEnum 16 = AttrType
AttrTypeFallback
    toEnum 17 = AttrType
AttrTypeLetterSpacing
    toEnum 18 = AttrType
AttrTypeUnderlineColor
    toEnum 19 = AttrType
AttrTypeStrikethroughColor
    toEnum 20 = AttrType
AttrTypeAbsoluteSize
    toEnum 21 = AttrType
AttrTypeGravity
    toEnum 22 = AttrType
AttrTypeGravityHint
    toEnum 23 = AttrType
AttrTypeFontFeatures
    toEnum 24 = AttrType
AttrTypeForegroundAlpha
    toEnum 25 = AttrType
AttrTypeBackgroundAlpha
    toEnum k :: Int
k = Int -> AttrType
AnotherAttrType Int
k

instance P.Ord AttrType where
    compare :: AttrType -> AttrType -> Ordering
compare a :: AttrType
a b :: 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)

foreign import ccall "pango_attr_type_get_type" c_pango_attr_type_get_type :: 
    IO GType

instance BoxedEnum AttrType where
    boxedEnumType :: AttrType -> IO GType
boxedEnumType _ = IO GType
c_pango_attr_type_get_type

-- Enum Alignment
-- | A t'GI.Pango.Enums.Alignment' describes how to align the lines of a t'GI.Pango.Objects.Layout.Layout' within the
-- available space. If the t'GI.Pango.Objects.Layout.Layout' is set to justify
-- using 'GI.Pango.Objects.Layout.layoutSetJustify', this only has effect for partial lines.
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 AlignmentLeft = 0
    fromEnum AlignmentCenter = 1
    fromEnum AlignmentRight = 2
    fromEnum (AnotherAlignment k :: Int
k) = Int
k

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

instance P.Ord Alignment where
    compare :: Alignment -> Alignment -> Ordering
compare a :: Alignment
a b :: 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)

foreign import ccall "pango_alignment_get_type" c_pango_alignment_get_type :: 
    IO GType

instance BoxedEnum Alignment where
    boxedEnumType :: Alignment -> IO GType
boxedEnumType _ = IO GType
c_pango_alignment_get_type