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

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

module GI.Pango.Enums
    ( 

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

    Alignment(..)                           ,


-- ** AttrType #enum:AttrType#

    AttrType(..)                            ,


-- ** BidiType #enum:BidiType#

    BidiType(..)                            ,


-- ** CoverageLevel #enum:CoverageLevel#

    CoverageLevel(..)                       ,


-- ** Direction #enum:Direction#

    Direction(..)                           ,


-- ** EllipsizeMode #enum:EllipsizeMode#

    EllipsizeMode(..)                       ,


-- ** Gravity #enum:Gravity#

    Gravity(..)                             ,


-- ** GravityHint #enum:GravityHint#

    GravityHint(..)                         ,


-- ** RenderPart #enum:RenderPart#

    RenderPart(..)                          ,


-- ** Script #enum:Script#

    Script(..)                              ,


-- ** Stretch #enum:Stretch#

    Stretch(..)                             ,


-- ** Style #enum:Style#

    Style(..)                               ,


-- ** TabAlign #enum:TabAlign#

    TabAlign(..)                            ,


-- ** Underline #enum:Underline#

    Underline(..)                           ,


-- ** Variant #enum:Variant#

    Variant(..)                             ,


-- ** Weight #enum:Weight#

    Weight(..)                              ,


-- ** WrapMode #enum:WrapMode#

    WrapMode(..)                            ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL


-- Enum WrapMode
-- | A t'GI.Pango.Enums.WrapMode' describes how to wrap the lines of a t'GI.Pango.Objects.Layout.Layout' to the desired width.
data WrapMode = 
      WrapModeWord
    -- ^ wrap lines at word boundaries.
    | WrapModeChar
    -- ^ wrap lines at character boundaries.
    | WrapModeWordChar
    -- ^ wrap lines at word boundaries, but fall back to character boundaries if there is not
    -- enough space for a full word.
    | AnotherWrapMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WrapMode -> ShowS
[WrapMode] -> ShowS
WrapMode -> String
(Int -> WrapMode -> ShowS)
-> (WrapMode -> String) -> ([WrapMode] -> ShowS) -> Show WrapMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WrapMode] -> ShowS
$cshowList :: [WrapMode] -> ShowS
show :: WrapMode -> String
$cshow :: WrapMode -> String
showsPrec :: Int -> WrapMode -> ShowS
$cshowsPrec :: Int -> WrapMode -> ShowS
Show, WrapMode -> WrapMode -> Bool
(WrapMode -> WrapMode -> Bool)
-> (WrapMode -> WrapMode -> Bool) -> Eq WrapMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WrapMode -> WrapMode -> Bool
$c/= :: WrapMode -> WrapMode -> Bool
== :: WrapMode -> WrapMode -> Bool
$c== :: WrapMode -> WrapMode -> Bool
Eq)

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

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

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

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

foreign import ccall "pango_wrap_mode_get_type" c_pango_wrap_mode_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum WrapMode

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

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

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

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

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

foreign import ccall "pango_weight_get_type" c_pango_weight_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum Weight

-- Enum Variant
-- | An enumeration specifying capitalization variant of the font.
data Variant = 
      VariantNormal
    -- ^ A normal font.
    | VariantSmallCaps
    -- ^ A font with the lower case characters
    -- replaced by smaller variants of the capital characters.
    | AnotherVariant Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Variant -> ShowS
[Variant] -> ShowS
Variant -> String
(Int -> Variant -> ShowS)
-> (Variant -> String) -> ([Variant] -> ShowS) -> Show Variant
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Variant] -> ShowS
$cshowList :: [Variant] -> ShowS
show :: Variant -> String
$cshow :: Variant -> String
showsPrec :: Int -> Variant -> ShowS
$cshowsPrec :: Int -> Variant -> ShowS
Show, Variant -> Variant -> Bool
(Variant -> Variant -> Bool)
-> (Variant -> Variant -> Bool) -> Eq Variant
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Variant -> Variant -> Bool
$c/= :: Variant -> Variant -> Bool
== :: Variant -> Variant -> Bool
$c== :: Variant -> Variant -> Bool
Eq)

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

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

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

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

foreign import ccall "pango_variant_get_type" c_pango_variant_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum Variant

-- Enum Underline
-- | The t'GI.Pango.Enums.Underline' enumeration is used to specify
-- whether text should be underlined, and if so, the type
-- of underlining.
data Underline = 
      UnderlineNone
    -- ^ no underline should be drawn
    | UnderlineSingle
    -- ^ a single underline should be drawn
    | UnderlineDouble
    -- ^ a double underline should be drawn
    | UnderlineLow
    -- ^ a single underline should be drawn at a
    --     position beneath the ink extents of the text being
    --     underlined. This should be used only for underlining
    --     single characters, such as for keyboard accelerators.
    --     'GI.Pango.Enums.UnderlineSingle' should be used for extended
    --     portions of text.
    | UnderlineError
    -- ^ a wavy underline should be drawn below.
    --     This underline is typically used to indicate an error such
    --     as a possible mispelling; in some cases a contrasting color
    --     may automatically be used. This type of underlining is
    --     available since Pango 1.4.
    | AnotherUnderline Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Underline -> ShowS
[Underline] -> ShowS
Underline -> String
(Int -> Underline -> ShowS)
-> (Underline -> String)
-> ([Underline] -> ShowS)
-> Show Underline
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Underline] -> ShowS
$cshowList :: [Underline] -> ShowS
show :: Underline -> String
$cshow :: Underline -> String
showsPrec :: Int -> Underline -> ShowS
$cshowsPrec :: Int -> Underline -> ShowS
Show, Underline -> Underline -> Bool
(Underline -> Underline -> Bool)
-> (Underline -> Underline -> Bool) -> Eq Underline
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Underline -> Underline -> Bool
$c/= :: Underline -> Underline -> Bool
== :: Underline -> Underline -> Bool
$c== :: Underline -> Underline -> Bool
Eq)

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

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

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

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

foreign import ccall "pango_underline_get_type" c_pango_underline_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum Underline

-- Enum TabAlign
-- | A t'GI.Pango.Enums.TabAlign' specifies where a tab stop appears relative to the text.
data TabAlign = 
      TabAlignLeft
    -- ^ the tab stop appears to the left of the text.
    | AnotherTabAlign Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TabAlign -> ShowS
[TabAlign] -> ShowS
TabAlign -> String
(Int -> TabAlign -> ShowS)
-> (TabAlign -> String) -> ([TabAlign] -> ShowS) -> Show TabAlign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TabAlign] -> ShowS
$cshowList :: [TabAlign] -> ShowS
show :: TabAlign -> String
$cshow :: TabAlign -> String
showsPrec :: Int -> TabAlign -> ShowS
$cshowsPrec :: Int -> TabAlign -> ShowS
Show, TabAlign -> TabAlign -> Bool
(TabAlign -> TabAlign -> Bool)
-> (TabAlign -> TabAlign -> Bool) -> Eq TabAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TabAlign -> TabAlign -> Bool
$c/= :: TabAlign -> TabAlign -> Bool
== :: TabAlign -> TabAlign -> Bool
$c== :: TabAlign -> TabAlign -> Bool
Eq)

instance P.Enum TabAlign where
    fromEnum :: TabAlign -> Int
fromEnum TabAlign
TabAlignLeft = Int
0
    fromEnum (AnotherTabAlign Int
k) = Int
k

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

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

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

foreign import ccall "pango_tab_align_get_type" c_pango_tab_align_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum TabAlign

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

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

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

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

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

foreign import ccall "pango_style_get_type" c_pango_style_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum Style

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

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

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

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

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

foreign import ccall "pango_stretch_get_type" c_pango_stretch_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum Stretch

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

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

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

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

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

foreign import ccall "pango_script_get_type" c_pango_script_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum Script

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

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

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

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

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

foreign import ccall "pango_render_part_get_type" c_pango_render_part_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum RenderPart

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

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

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

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

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

foreign import ccall "pango_gravity_hint_get_type" c_pango_gravity_hint_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum GravityHint

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

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

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

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

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

foreign import ccall "pango_gravity_get_type" c_pango_gravity_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum Gravity

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

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

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

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

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

foreign import ccall "pango_ellipsize_mode_get_type" c_pango_ellipsize_mode_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum EllipsizeMode

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

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

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

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

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

foreign import ccall "pango_direction_get_type" c_pango_direction_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum Direction

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

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

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

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

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

foreign import ccall "pango_coverage_level_get_type" c_pango_coverage_level_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum CoverageLevel

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

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

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

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

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

foreign import ccall "pango_bidi_type_get_type" c_pango_bidi_type_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum BidiType

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

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

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

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

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

foreign import ccall "pango_attr_type_get_type" c_pango_attr_type_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum AttrType

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

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

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

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

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

foreign import ccall "pango_alignment_get_type" c_pango_alignment_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum Alignment