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

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !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.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.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 '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.

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 (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
{-# DEPRECATED BidiType ["(Since version 1.44)","Use fribidi for this information"] #-}
{- |
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