    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    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.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    -- Enum WrapMode
    {- |
    A 'GI.Pango.Enums.WrapMode' describes how to wrap the lines of a '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 (Show, Eq)

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

        toEnum 0 = WrapModeWord
        toEnum 1 = WrapModeChar
        toEnum 2 = WrapModeWordChar
        toEnum k = AnotherWrapMode k

    instance P.Ord WrapMode where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_wrap_mode_get_type" c_pango_wrap_mode_get_type ::
        IO GType

    instance BoxedEnum WrapMode where
        boxedEnumType _ = 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 (Show, Eq)

    instance P.Enum Weight where
        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) = k

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

    instance P.Ord Weight where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_weight_get_type" c_pango_weight_get_type ::
        IO GType

    instance BoxedEnum Weight where
        boxedEnumType _ = 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 (Show, Eq)

    instance P.Enum Variant where
        fromEnum VariantNormal = 0
        fromEnum VariantSmallCaps = 1
        fromEnum (AnotherVariant k) = k

        toEnum 0 = VariantNormal
        toEnum 1 = VariantSmallCaps
        toEnum k = AnotherVariant k

    instance P.Ord Variant where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_variant_get_type" c_pango_variant_get_type ::
        IO GType

    instance BoxedEnum Variant where
        boxedEnumType _ = c_pango_variant_get_type

    -- Enum Underline
    {- |
    The '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 (Show, Eq)

    instance P.Enum Underline where
        fromEnum UnderlineNone = 0
        fromEnum UnderlineSingle = 1
        fromEnum UnderlineDouble = 2
        fromEnum UnderlineLow = 3
        fromEnum UnderlineError = 4
        fromEnum (AnotherUnderline k) = k

        toEnum 0 = UnderlineNone
        toEnum 1 = UnderlineSingle
        toEnum 2 = UnderlineDouble
        toEnum 3 = UnderlineLow
        toEnum 4 = UnderlineError
        toEnum k = AnotherUnderline k

    instance P.Ord Underline where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_underline_get_type" c_pango_underline_get_type ::
        IO GType

    instance BoxedEnum Underline where
        boxedEnumType _ = c_pango_underline_get_type

    -- Enum TabAlign
    {- |
    A '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 (Show, Eq)

    instance P.Enum TabAlign where
        fromEnum TabAlignLeft = 0
        fromEnum (AnotherTabAlign k) = k

        toEnum 0 = TabAlignLeft
        toEnum k = AnotherTabAlign k

    instance P.Ord TabAlign where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_tab_align_get_type" c_pango_tab_align_get_type ::
        IO GType

    instance BoxedEnum TabAlign where
        boxedEnumType _ = 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 (Show, Eq)

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

        toEnum 0 = StyleNormal
        toEnum 1 = StyleOblique
        toEnum 2 = StyleItalic
        toEnum k = AnotherStyle k

    instance P.Ord Style where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_style_get_type" c_pango_style_get_type ::
        IO GType

    instance BoxedEnum Style where
        boxedEnumType _ = 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 (Show, Eq)

    instance P.Enum Stretch where
        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) = k

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

    instance P.Ord Stretch where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_stretch_get_type" c_pango_stretch_get_type ::
        IO GType

    instance BoxedEnum Stretch where
        boxedEnumType _ = c_pango_stretch_get_type

    -- Enum Script
    {- |
    The '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
    '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 (Show, Eq)

    instance P.Enum Script where
        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) = k

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

    instance P.Ord Script where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_script_get_type" c_pango_script_get_type ::
        IO GType

    instance BoxedEnum Script where
        boxedEnumType _ = c_pango_script_get_type

    -- Enum RenderPart
    {- |
    '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 (Show, Eq)

    instance P.Enum RenderPart where
        fromEnum RenderPartForeground = 0
        fromEnum RenderPartBackground = 1
        fromEnum RenderPartUnderline = 2
        fromEnum RenderPartStrikethrough = 3
        fromEnum (AnotherRenderPart k) = k

        toEnum 0 = RenderPartForeground
        toEnum 1 = RenderPartBackground
        toEnum 2 = RenderPartUnderline
        toEnum 3 = RenderPartStrikethrough
        toEnum k = AnotherRenderPart k

    instance P.Ord RenderPart where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_render_part_get_type" c_pango_render_part_get_type ::
        IO GType

    instance BoxedEnum RenderPart where
        boxedEnumType _ = c_pango_render_part_get_type

    -- Enum GravityHint
    {- |
    The '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 '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 (Show, Eq)

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

        toEnum 0 = GravityHintNatural
        toEnum 1 = GravityHintStrong
        toEnum 2 = GravityHintLine
        toEnum k = AnotherGravityHint k

    instance P.Ord GravityHint where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_gravity_hint_get_type" c_pango_gravity_hint_get_type ::
        IO GType

    instance BoxedEnum GravityHint where
        boxedEnumType _ = c_pango_gravity_hint_get_type

    -- Enum Gravity
    {- |
    The '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 'GI.Pango.Enums.Gravity'.
    Not every value in this enumeration makes sense for every usage of
    '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: '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 (Show, Eq)

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

        toEnum 0 = GravitySouth
        toEnum 1 = GravityEast
        toEnum 2 = GravityNorth
        toEnum 3 = GravityWest
        toEnum 4 = GravityAuto
        toEnum k = AnotherGravity k

    instance P.Ord Gravity where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_gravity_get_type" c_pango_gravity_get_type ::
        IO GType

    instance BoxedEnum Gravity where
        boxedEnumType _ = c_pango_gravity_get_type

    -- Enum EllipsizeMode
    {- |
    The '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 (Show, Eq)

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

        toEnum 0 = EllipsizeModeNone
        toEnum 1 = EllipsizeModeStart
        toEnum 2 = EllipsizeModeMiddle
        toEnum 3 = EllipsizeModeEnd
        toEnum k = AnotherEllipsizeMode k

    instance P.Ord EllipsizeMode where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_ellipsize_mode_get_type" c_pango_ellipsize_mode_get_type ::
        IO GType

    instance BoxedEnum EllipsizeMode where
        boxedEnumType _ = c_pango_ellipsize_mode_get_type

    -- Enum Direction
    {- |
    The '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 '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 'GI.Pango.Enums.Gravity' for how
    vertical text is handled in Pango.
    -}
    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 (Show, Eq)

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

        toEnum 0 = DirectionLtr
        toEnum 1 = DirectionRtl
        toEnum 2 = DirectionTtbLtr
        toEnum 3 = DirectionTtbRtl
        toEnum 4 = DirectionWeakLtr
        toEnum 5 = DirectionWeakRtl
        toEnum 6 = DirectionNeutral
        toEnum k = AnotherDirection k

    instance P.Ord Direction where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_direction_get_type" c_pango_direction_get_type ::
        IO GType

    instance BoxedEnum Direction where
        boxedEnumType _ = 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 (Show, Eq)

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

        toEnum 0 = CoverageLevelNone
        toEnum 1 = CoverageLevelFallback
        toEnum 2 = CoverageLevelApproximate
        toEnum 3 = CoverageLevelExact
        toEnum k = AnotherCoverageLevel k

    instance P.Ord CoverageLevel where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_coverage_level_get_type" c_pango_coverage_level_get_type ::
        IO GType

    instance BoxedEnum CoverageLevel where
        boxedEnumType _ = c_pango_coverage_level_get_type

    -- Enum BidiType
    {- |
    The '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 (Show, Eq)

    instance P.Enum BidiType where
        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) = k

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

    instance P.Ord BidiType where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_bidi_type_get_type" c_pango_bidi_type_get_type ::
        IO GType

    instance BoxedEnum BidiType where
        boxedEnumType _ = c_pango_bidi_type_get_type

    -- Enum AttrType
    {- |
    The '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 ('GI.Pango.Structs.AttrLanguage.AttrLanguage')
        -}
        | AttrTypeFamily
        {- ^
        font family name list ('GI.Pango.Structs.AttrString.AttrString')
        -}
        | AttrTypeStyle
        {- ^
        font slant style ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeWeight
        {- ^
        font weight ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeVariant
        {- ^
        font variant (normal or small caps) ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeStretch
        {- ^
        font stretch ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeSize
        {- ^
        font size in points scaled by 'GI.Pango.Constants.SCALE' ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeFontDesc
        {- ^
        font description ('GI.Pango.Structs.AttrFontDesc.AttrFontDesc')
        -}
        | AttrTypeForeground
        {- ^
        foreground color ('GI.Pango.Structs.AttrColor.AttrColor')
        -}
        | AttrTypeBackground
        {- ^
        background color ('GI.Pango.Structs.AttrColor.AttrColor')
        -}
        | AttrTypeUnderline
        {- ^
        whether the text has an underline ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeStrikethrough
        {- ^
        whether the text is struck-through ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeRise
        {- ^
        baseline displacement ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeShape
        {- ^
        shape ('GI.Pango.Structs.AttrShape.AttrShape')
        -}
        | AttrTypeScale
        {- ^
        font size scale factor ('GI.Pango.Structs.AttrFloat.AttrFloat')
        -}
        | AttrTypeFallback
        {- ^
        whether fallback is enabled ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeLetterSpacing
        {- ^
        letter spacing ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeUnderlineColor
        {- ^
        underline color ('GI.Pango.Structs.AttrColor.AttrColor')
        -}
        | AttrTypeStrikethroughColor
        {- ^
        strikethrough color ('GI.Pango.Structs.AttrColor.AttrColor')
        -}
        | AttrTypeAbsoluteSize
        {- ^
        font size in pixels scaled by 'GI.Pango.Constants.SCALE' ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeGravity
        {- ^
        base text gravity ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeGravityHint
        {- ^
        gravity hint ('GI.Pango.Structs.AttrInt.AttrInt')
        -}
        | AttrTypeFontFeatures
        {- ^
        OpenType font features ('GI.Pango.Structs.AttrString.AttrString'). Since 1.38
        -}
        | AttrTypeForegroundAlpha
        {- ^
        foreground alpha ('GI.Pango.Structs.AttrInt.AttrInt'). Since 1.38
        -}
        | AttrTypeBackgroundAlpha
        {- ^
        background alpha ('GI.Pango.Structs.AttrInt.AttrInt'). Since 1.38
        -}
        | AnotherAttrType Int
        -- ^ Catch-all for unknown values
        deriving (Show, Eq)

    instance P.Enum AttrType where
        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) = k

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

    instance P.Ord AttrType where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_attr_type_get_type" c_pango_attr_type_get_type ::
        IO GType

    instance BoxedEnum AttrType where
        boxedEnumType _ = c_pango_attr_type_get_type

    -- Enum Alignment
    {- |
    A 'GI.Pango.Enums.Alignment' describes how to align the lines of a 'GI.Pango.Objects.Layout.Layout' within the
    available space. If the '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 (Show, Eq)

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

        toEnum 0 = AlignmentLeft
        toEnum 1 = AlignmentCenter
        toEnum 2 = AlignmentRight
        toEnum k = AnotherAlignment k

    instance P.Ord Alignment where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "pango_alignment_get_type" c_pango_alignment_get_type ::
        IO GType

    instance BoxedEnum Alignment where
        boxedEnumType _ = c_pango_alignment_get_type