-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Pango bindings
--   
--   Bindings for Pango, autogenerated by haskell-gi.
@package gi-pango
@version 1.0.21

module GI.Pango.Config
overrides :: Text


module GI.Pango.Constants

-- | A macro that should be defined by the user prior to including the
--   pango.h header. The definition should be one of the predefined Pango
--   version macros: <tt><i>PANGO_VERSION_1_2</i></tt>,
--   <tt><i>PANGO_VERSION_1_4</i></tt>,...
--   
--   This macro defines the earliest version of Pango that the package is
--   required to be able to compile against.
--   
--   If the compiler is configured to warn about the use of deprecated
--   functions, then using functions that were deprecated in version
--   <a>VERSION_MIN_REQUIRED</a> or earlier will cause warnings (but using
--   functions deprecated in later releases will not).
--   
--   <i>Since: 1.42</i>

-- | <i>No description available in the introspection data.</i>

-- | <i>No description available in the introspection data.</i>

-- | The <a>SCALE</a> macro represents the scale between dimensions used
--   for Pango distances and device units. (The definition of device units
--   is dependent on the output device; it will typically be pixels for a
--   screen, and points for a printer.) <a>SCALE</a> is currently 1024, but
--   this may be changed in the future.
--   
--   When setting font sizes, device units are always considered to be
--   points (as in "12 point font"), rather than pixels.

-- | A string constant defining the render type for engines that are not
--   rendering-system specific.

-- | <i>Deprecated: (Since version 1.38)</i>

-- | The <a>GLYPH_UNKNOWN_FLAG</a> macro is a flag value that can be added
--   to a <tt><i>gunichar</i></tt> value of a valid Unicode character, to
--   produce a <tt><i>PangoGlyph</i></tt> value, representing an
--   unknown-character glyph for the respective <tt><i>gunichar</i></tt>.

-- | The <a>GLYPH_INVALID_INPUT</a> macro represents a
--   <tt><i>PangoGlyph</i></tt> value that has a special meaning of invalid
--   input. <a>Layout</a> produces one such glyph per invalid input UTF-8
--   byte and such a glyph is rendered as a crossed box.
--   
--   Note that this value is defined such that it has the
--   <a>GLYPH_UNKNOWN_FLAG</a> on.
--   
--   <i>Since: 1.20</i>

-- | The <a>GLYPH_EMPTY</a> macro represents a <tt><i>PangoGlyph</i></tt>
--   value that has a special meaning, which is a zero-width empty glyph.
--   This is useful for example in shaper modules, to use as the glyph for
--   various zero-width Unicode characters (those passing
--   <a>isZeroWidth</a>).

-- | A string constant defining the engine type for shaping engines. These
--   engines derive from <a>EngineShape</a>.

-- | <i>Deprecated: (Since version 1.38)</i>

-- | A string constant defining the engine type for language engines. These
--   engines derive from <a>EngineLang</a>.

-- | <i>Deprecated: (Since version 1.38)</i>

-- | This value can be used to set the start_index member of a
--   <a>Attribute</a> such that the attribute covers from the beginning of
--   the text.
--   
--   <i>Since: 1.24</i>

-- | This flag is used to mark runs that hold ellipsized text, in an
--   ellipsized layout.
--   
--   <i>Since: 1.36.7</i>

-- | Whether the segment should be shifted to center around the baseline.
--   Used in vertical writing directions mostly.
--   
--   <i>Since: 1.16</i>


module GI.Pango.Enums

-- | A <a>Alignment</a> describes how to align the lines of a <a>Layout</a>
--   within the available space. If the <a>Layout</a> is set to justify
--   using <a>layoutSetJustify</a>, this only has effect for partial lines.
data Alignment

-- | Put all available space on the right
AlignmentLeft :: Alignment

-- | Center the line within the available space
AlignmentCenter :: Alignment

-- | Put all available space on the left
AlignmentRight :: Alignment

-- | Catch-all for unknown values
AnotherAlignment :: Int -> Alignment

-- | The <a>AttrType</a> distinguishes between different types of
--   attributes. Along with the predefined values, it is possible to
--   allocate additional values for custom attributes using
--   <a>attrTypeRegister</a>. The predefined values are given below. The
--   type of structure used to store the attribute is listed in parentheses
--   after the description.
data AttrType

-- | does not happen
AttrTypeInvalid :: AttrType

-- | language (<a>AttrLanguage</a>)
AttrTypeLanguage :: AttrType

-- | font family name list (<a>AttrString</a>)
AttrTypeFamily :: AttrType

-- | font slant style (<a>AttrInt</a>)
AttrTypeStyle :: AttrType

-- | font weight (<a>AttrInt</a>)
AttrTypeWeight :: AttrType

-- | font variant (normal or small caps) (<a>AttrInt</a>)
AttrTypeVariant :: AttrType

-- | font stretch (<a>AttrInt</a>)
AttrTypeStretch :: AttrType

-- | font size in points scaled by <a>SCALE</a> (<a>AttrInt</a>)
AttrTypeSize :: AttrType

-- | font description (<a>AttrFontDesc</a>)
AttrTypeFontDesc :: AttrType

-- | foreground color (<a>AttrColor</a>)
AttrTypeForeground :: AttrType

-- | background color (<a>AttrColor</a>)
AttrTypeBackground :: AttrType

-- | whether the text has an underline (<a>AttrInt</a>)
AttrTypeUnderline :: AttrType

-- | whether the text is struck-through (<a>AttrInt</a>)
AttrTypeStrikethrough :: AttrType

-- | baseline displacement (<a>AttrInt</a>)
AttrTypeRise :: AttrType

-- | shape (<a>AttrShape</a>)
AttrTypeShape :: AttrType

-- | font size scale factor (<a>AttrFloat</a>)
AttrTypeScale :: AttrType

-- | whether fallback is enabled (<a>AttrInt</a>)
AttrTypeFallback :: AttrType

-- | letter spacing (<a>AttrInt</a>)
AttrTypeLetterSpacing :: AttrType

-- | underline color (<a>AttrColor</a>)
AttrTypeUnderlineColor :: AttrType

-- | strikethrough color (<a>AttrColor</a>)
AttrTypeStrikethroughColor :: AttrType

-- | font size in pixels scaled by <a>SCALE</a> (<a>AttrInt</a>)
AttrTypeAbsoluteSize :: AttrType

-- | base text gravity (<a>AttrInt</a>)
AttrTypeGravity :: AttrType

-- | gravity hint (<a>AttrInt</a>)
AttrTypeGravityHint :: AttrType

-- | OpenType font features (<a>AttrString</a>). Since 1.38
AttrTypeFontFeatures :: AttrType

-- | foreground alpha (<a>AttrInt</a>). Since 1.38
AttrTypeForegroundAlpha :: AttrType

-- | background alpha (<a>AttrInt</a>). Since 1.38
AttrTypeBackgroundAlpha :: AttrType

-- | Catch-all for unknown values
AnotherAttrType :: Int -> AttrType

-- | The <a>BidiType</a> type represents the bidirectional character type
--   of a Unicode character as specified by the &lt;ulink
--   url="http://www.unicode.org/reports/tr9/"&gt;Unicode bidirectional
--   algorithm&lt;/ulink&gt;.
--   
--   <i>Since: 1.22</i>

-- | <i>Deprecated: (Since version 1.44)Use fribidi for this
--   information</i>
data BidiType

-- | Left-to-Right
BidiTypeL :: BidiType

-- | Left-to-Right Embedding
BidiTypeLre :: BidiType

-- | Left-to-Right Override
BidiTypeLro :: BidiType

-- | Right-to-Left
BidiTypeR :: BidiType

-- | Right-to-Left Arabic
BidiTypeAl :: BidiType

-- | Right-to-Left Embedding
BidiTypeRle :: BidiType

-- | Right-to-Left Override
BidiTypeRlo :: BidiType

-- | Pop Directional Format
BidiTypePdf :: BidiType

-- | European Number
BidiTypeEn :: BidiType

-- | European Number Separator
BidiTypeEs :: BidiType

-- | European Number Terminator
BidiTypeEt :: BidiType

-- | Arabic Number
BidiTypeAn :: BidiType

-- | Common Number Separator
BidiTypeCs :: BidiType

-- | Nonspacing Mark
BidiTypeNsm :: BidiType

-- | Boundary Neutral
BidiTypeBn :: BidiType

-- | Paragraph Separator
BidiTypeB :: BidiType

-- | Segment Separator
BidiTypeS :: BidiType

-- | Whitespace
BidiTypeWs :: BidiType

-- | Other Neutrals
BidiTypeOn :: BidiType

-- | Catch-all for unknown values
AnotherBidiType :: Int -> BidiType

-- | Used to indicate how well a font can represent a particular Unicode
--   character point for a particular script.
data CoverageLevel

-- | The character is not representable with the font.
CoverageLevelNone :: CoverageLevel

-- | 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.
CoverageLevelFallback :: CoverageLevel

-- | The character is represented as basically the correct graphical form,
--   but with a stylistic variant inappropriate for the current script.
CoverageLevelApproximate :: CoverageLevel

-- | The character is represented as the correct graphical form.
CoverageLevelExact :: CoverageLevel

-- | Catch-all for unknown values
AnotherCoverageLevel :: Int -> CoverageLevel

-- | The <a>Direction</a> type represents a direction in the Unicode
--   bidirectional algorithm; not every value in this enumeration makes
--   sense for every usage of <a>Direction</a>; for example, the return
--   value of <a>unicharDirection</a> and <a>findBaseDir</a> cannot be
--   <a>DirectionWeakLtr</a> or <a>DirectionWeakRtl</a>, since every
--   character is either neutral or has a strong direction; on the other
--   hand <a>DirectionNeutral</a> doesn't make sense to pass to
--   <a>itemizeWithBaseDir</a>.
--   
--   The <a>DirectionTtbLtr</a>, <a>DirectionTtbRtl</a> values come from an
--   earlier interpretation of this enumeration as the writing direction of
--   a block of text and are no longer used; See <a>Gravity</a> 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

-- | A strong left-to-right direction
DirectionLtr :: Direction

-- | A strong right-to-left direction
DirectionRtl :: Direction

-- | Deprecated value; treated the same as <a>DirectionRtl</a>.
DirectionTtbLtr :: Direction

-- | Deprecated value; treated the same as <a>DirectionLtr</a>
DirectionTtbRtl :: Direction

-- | A weak left-to-right direction
DirectionWeakLtr :: Direction

-- | A weak right-to-left direction
DirectionWeakRtl :: Direction

-- | No direction specified
DirectionNeutral :: Direction

-- | Catch-all for unknown values
AnotherDirection :: Int -> Direction

-- | The <a>EllipsizeMode</a> 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

-- | No ellipsization
EllipsizeModeNone :: EllipsizeMode

-- | Omit characters at the start of the text
EllipsizeModeStart :: EllipsizeMode

-- | Omit characters in the middle of the text
EllipsizeModeMiddle :: EllipsizeMode

-- | Omit characters at the end of the text
EllipsizeModeEnd :: EllipsizeMode

-- | Catch-all for unknown values
AnotherEllipsizeMode :: Int -> EllipsizeMode

-- | The <a>Gravity</a> 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
--   <a>Gravity</a>. Not every value in this enumeration makes sense for
--   every usage of <a>Gravity</a>; for example, <a>GravityAuto</a> only
--   can be passed to <a>contextSetBaseGravity</a> and can only be returned
--   by <a>contextGetBaseGravity</a>.
--   
--   See also: <a>GravityHint</a>
--   
--   <i>Since: 1.16</i>
data Gravity

-- | Glyphs stand upright (default)
GravitySouth :: Gravity

-- | Glyphs are rotated 90 degrees clockwise
GravityEast :: Gravity

-- | Glyphs are upside-down
GravityNorth :: Gravity

-- | Glyphs are rotated 90 degrees counter-clockwise
GravityWest :: Gravity

-- | Gravity is resolved from the context matrix
GravityAuto :: Gravity

-- | Catch-all for unknown values
AnotherGravity :: Int -> Gravity

-- | The <a>GravityHint</a> defines how horizontal scripts should behave in
--   a vertical context. That is, English excerpt in a vertical paragraph
--   for example.
--   
--   See <a>Gravity</a>.
--   
--   <i>Since: 1.16</i>
data GravityHint

-- | scripts will take their natural gravity based on the base gravity and
--   the script. This is the default.
GravityHintNatural :: GravityHint

-- | always use the base gravity set, regardless of the script.
GravityHintStrong :: GravityHint

-- | 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.
GravityHintLine :: GravityHint

-- | Catch-all for unknown values
AnotherGravityHint :: Int -> GravityHint

-- | <a>RenderPart</a> defines different items to render for such purposes
--   as setting colors.
--   
--   <i>Since: 1.8</i>
data RenderPart

-- | the text itself
RenderPartForeground :: RenderPart

-- | the area behind the text
RenderPartBackground :: RenderPart

-- | underlines
RenderPartUnderline :: RenderPart

-- | strikethrough lines
RenderPartStrikethrough :: RenderPart

-- | Catch-all for unknown values
AnotherRenderPart :: Int -> RenderPart

-- | The <a>Script</a> 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 <a>UnicodeScript</a>. See &lt;ulink
--   url="http://www.unicode.org/reports/tr24/"&gt;Unicode Standard Annex
--   <tt><i>24</i></tt>: Script names&lt;/ulink&gt;.
data Script

-- | a value never returned from <a>scriptForUnichar</a>
ScriptInvalidCode :: Script

-- | a character used by multiple different scripts
ScriptCommon :: Script

-- | a mark glyph that takes its script from the base glyph to which it is
--   attached
ScriptInherited :: Script

-- | Arabic
ScriptArabic :: Script

-- | Armenian
ScriptArmenian :: Script

-- | Bengali
ScriptBengali :: Script

-- | Bopomofo
ScriptBopomofo :: Script

-- | Cherokee
ScriptCherokee :: Script

-- | Coptic
ScriptCoptic :: Script

-- | Cyrillic
ScriptCyrillic :: Script

-- | Deseret
ScriptDeseret :: Script

-- | Devanagari
ScriptDevanagari :: Script

-- | Ethiopic
ScriptEthiopic :: Script

-- | Georgian
ScriptGeorgian :: Script

-- | Gothic
ScriptGothic :: Script

-- | Greek
ScriptGreek :: Script

-- | Gujarati
ScriptGujarati :: Script

-- | Gurmukhi
ScriptGurmukhi :: Script

-- | Han
ScriptHan :: Script

-- | Hangul
ScriptHangul :: Script

-- | Hebrew
ScriptHebrew :: Script

-- | Hiragana
ScriptHiragana :: Script

-- | Kannada
ScriptKannada :: Script

-- | Katakana
ScriptKatakana :: Script

-- | Khmer
ScriptKhmer :: Script

-- | Lao
ScriptLao :: Script

-- | Latin
ScriptLatin :: Script

-- | Malayalam
ScriptMalayalam :: Script

-- | Mongolian
ScriptMongolian :: Script

-- | Myanmar
ScriptMyanmar :: Script

-- | Ogham
ScriptOgham :: Script

-- | Old Italic
ScriptOldItalic :: Script

-- | Oriya
ScriptOriya :: Script

-- | Runic
ScriptRunic :: Script

-- | Sinhala
ScriptSinhala :: Script

-- | Syriac
ScriptSyriac :: Script

-- | Tamil
ScriptTamil :: Script

-- | Telugu
ScriptTelugu :: Script

-- | Thaana
ScriptThaana :: Script

-- | Thai
ScriptThai :: Script

-- | Tibetan
ScriptTibetan :: Script

-- | Canadian Aboriginal
ScriptCanadianAboriginal :: Script

-- | Yi
ScriptYi :: Script

-- | Tagalog
ScriptTagalog :: Script

-- | Hanunoo
ScriptHanunoo :: Script

-- | Buhid
ScriptBuhid :: Script

-- | Tagbanwa
ScriptTagbanwa :: Script

-- | Braille
ScriptBraille :: Script

-- | Cypriot
ScriptCypriot :: Script

-- | Limbu
ScriptLimbu :: Script

-- | Osmanya
ScriptOsmanya :: Script

-- | Shavian
ScriptShavian :: Script

-- | Linear B
ScriptLinearB :: Script

-- | Tai Le
ScriptTaiLe :: Script

-- | Ugaritic
ScriptUgaritic :: Script

-- | New Tai Lue. Since 1.10
ScriptNewTaiLue :: Script

-- | Buginese. Since 1.10
ScriptBuginese :: Script

-- | Glagolitic. Since 1.10
ScriptGlagolitic :: Script

-- | Tifinagh. Since 1.10
ScriptTifinagh :: Script

-- | Syloti Nagri. Since 1.10
ScriptSylotiNagri :: Script

-- | Old Persian. Since 1.10
ScriptOldPersian :: Script

-- | Kharoshthi. Since 1.10
ScriptKharoshthi :: Script

-- | an unassigned code point. Since 1.14
ScriptUnknown :: Script

-- | Balinese. Since 1.14
ScriptBalinese :: Script

-- | Cuneiform. Since 1.14
ScriptCuneiform :: Script

-- | Phoenician. Since 1.14
ScriptPhoenician :: Script

-- | Phags-pa. Since 1.14
ScriptPhagsPa :: Script

-- | N'Ko. Since 1.14
ScriptNko :: Script

-- | Kayah Li. Since 1.20.1
ScriptKayahLi :: Script

-- | Lepcha. Since 1.20.1
ScriptLepcha :: Script

-- | Rejang. Since 1.20.1
ScriptRejang :: Script

-- | Sundanese. Since 1.20.1
ScriptSundanese :: Script

-- | Saurashtra. Since 1.20.1
ScriptSaurashtra :: Script

-- | Cham. Since 1.20.1
ScriptCham :: Script

-- | Ol Chiki. Since 1.20.1
ScriptOlChiki :: Script

-- | Vai. Since 1.20.1
ScriptVai :: Script

-- | Carian. Since 1.20.1
ScriptCarian :: Script

-- | Lycian. Since 1.20.1
ScriptLycian :: Script

-- | Lydian. Since 1.20.1
ScriptLydian :: Script

-- | Batak. Since 1.32
ScriptBatak :: Script

-- | Brahmi. Since 1.32
ScriptBrahmi :: Script

-- | Mandaic. Since 1.32
ScriptMandaic :: Script

-- | Chakma. Since: 1.32
ScriptChakma :: Script

-- | Meroitic Cursive. Since: 1.32
ScriptMeroiticCursive :: Script

-- | Meroitic Hieroglyphs. Since: 1.32
ScriptMeroiticHieroglyphs :: Script

-- | Miao. Since: 1.32
ScriptMiao :: Script

-- | Sharada. Since: 1.32
ScriptSharada :: Script

-- | Sora Sompeng. Since: 1.32
ScriptSoraSompeng :: Script

-- | Takri. Since: 1.32
ScriptTakri :: Script

-- | Bassa. Since: 1.40
ScriptBassaVah :: Script

-- | Caucasian Albanian. Since: 1.40
ScriptCaucasianAlbanian :: Script

-- | Duployan. Since: 1.40
ScriptDuployan :: Script

-- | Elbasan. Since: 1.40
ScriptElbasan :: Script

-- | Grantha. Since: 1.40
ScriptGrantha :: Script

-- | Kjohki. Since: 1.40
ScriptKhojki :: Script

-- | Khudawadi, Sindhi. Since: 1.40
ScriptKhudawadi :: Script

-- | Linear A. Since: 1.40
ScriptLinearA :: Script

-- | Mahajani. Since: 1.40
ScriptMahajani :: Script

-- | Manichaean. Since: 1.40
ScriptManichaean :: Script

-- | Mende Kikakui. Since: 1.40
ScriptMendeKikakui :: Script

-- | Modi. Since: 1.40
ScriptModi :: Script

-- | Mro. Since: 1.40
ScriptMro :: Script

-- | Nabataean. Since: 1.40
ScriptNabataean :: Script

-- | Old North Arabian. Since: 1.40
ScriptOldNorthArabian :: Script

-- | Old Permic. Since: 1.40
ScriptOldPermic :: Script

-- | Pahawh Hmong. Since: 1.40
ScriptPahawhHmong :: Script

-- | Palmyrene. Since: 1.40
ScriptPalmyrene :: Script

-- | Pau Cin Hau. Since: 1.40
ScriptPauCinHau :: Script

-- | Psalter Pahlavi. Since: 1.40
ScriptPsalterPahlavi :: Script

-- | Siddham. Since: 1.40
ScriptSiddham :: Script

-- | Tirhuta. Since: 1.40
ScriptTirhuta :: Script

-- | Warang Citi. Since: 1.40
ScriptWarangCiti :: Script

-- | Ahom. Since: 1.40
ScriptAhom :: Script

-- | Anatolian Hieroglyphs. Since: 1.40
ScriptAnatolianHieroglyphs :: Script

-- | Hatran. Since: 1.40
ScriptHatran :: Script

-- | Multani. Since: 1.40
ScriptMultani :: Script

-- | Old Hungarian. Since: 1.40
ScriptOldHungarian :: Script

-- | Signwriting. Since: 1.40
ScriptSignwriting :: Script

-- | Catch-all for unknown values
AnotherScript :: Int -> Script

-- | An enumeration specifying the width of the font relative to other
--   designs within a family.
data Stretch

-- | ultra condensed width
StretchUltraCondensed :: Stretch

-- | extra condensed width
StretchExtraCondensed :: Stretch

-- | condensed width
StretchCondensed :: Stretch

-- | semi condensed width
StretchSemiCondensed :: Stretch

-- | the normal width
StretchNormal :: Stretch

-- | semi expanded width
StretchSemiExpanded :: Stretch

-- | expanded width
StretchExpanded :: Stretch

-- | extra expanded width
StretchExtraExpanded :: Stretch

-- | ultra expanded width
StretchUltraExpanded :: Stretch

-- | Catch-all for unknown values
AnotherStretch :: Int -> Stretch

-- | An enumeration specifying the various slant styles possible for a
--   font.
data Style

-- | the font is upright.
StyleNormal :: Style

-- | the font is slanted, but in a roman style.
StyleOblique :: Style

-- | the font is slanted in an italic style.
StyleItalic :: Style

-- | Catch-all for unknown values
AnotherStyle :: Int -> Style

-- | A <a>TabAlign</a> specifies where a tab stop appears relative to the
--   text.
data TabAlign

-- | the tab stop appears to the left of the text.
TabAlignLeft :: TabAlign

-- | Catch-all for unknown values
AnotherTabAlign :: Int -> TabAlign

-- | The <a>Underline</a> enumeration is used to specify whether text
--   should be underlined, and if so, the type of underlining.
data Underline

-- | no underline should be drawn
UnderlineNone :: Underline

-- | a single underline should be drawn
UnderlineSingle :: Underline

-- | a double underline should be drawn
UnderlineDouble :: Underline

-- | 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.
--   <a>UnderlineSingle</a> should be used for extended portions of text.
UnderlineLow :: Underline

-- | 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.
UnderlineError :: Underline

-- | Catch-all for unknown values
AnotherUnderline :: Int -> Underline

-- | An enumeration specifying capitalization variant of the font.
data Variant

-- | A normal font.
VariantNormal :: Variant

-- | A font with the lower case characters replaced by smaller variants of
--   the capital characters.
VariantSmallCaps :: Variant

-- | Catch-all for unknown values
AnotherVariant :: Int -> Variant

-- | 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

-- | the thin weight (= 100; Since: 1.24)
WeightThin :: Weight

-- | the ultralight weight (= 200)
WeightUltralight :: Weight

-- | the light weight (= 300)
WeightLight :: Weight

-- | the semilight weight (= 350; Since: 1.36.7)
WeightSemilight :: Weight

-- | the book weight (= 380; Since: 1.24)
WeightBook :: Weight

-- | the default weight (= 400)
WeightNormal :: Weight

-- | the normal weight (= 500; Since: 1.24)
WeightMedium :: Weight

-- | the semibold weight (= 600)
WeightSemibold :: Weight

-- | the bold weight (= 700)
WeightBold :: Weight

-- | the ultrabold weight (= 800)
WeightUltrabold :: Weight

-- | the heavy weight (= 900)
WeightHeavy :: Weight

-- | the ultraheavy weight (= 1000; Since: 1.24)
WeightUltraheavy :: Weight

-- | Catch-all for unknown values
AnotherWeight :: Int -> Weight

-- | A <a>WrapMode</a> describes how to wrap the lines of a <a>Layout</a>
--   to the desired width.
data WrapMode

-- | wrap lines at word boundaries.
WrapModeWord :: WrapMode

-- | wrap lines at character boundaries.
WrapModeChar :: WrapMode

-- | wrap lines at word boundaries, but fall back to character boundaries
--   if there is not enough space for a full word.
WrapModeWordChar :: WrapMode

-- | Catch-all for unknown values
AnotherWrapMode :: Int -> WrapMode
instance GHC.Classes.Eq GI.Pango.Enums.Alignment
instance GHC.Show.Show GI.Pango.Enums.Alignment
instance GHC.Classes.Eq GI.Pango.Enums.AttrType
instance GHC.Show.Show GI.Pango.Enums.AttrType
instance GHC.Classes.Eq GI.Pango.Enums.BidiType
instance GHC.Show.Show GI.Pango.Enums.BidiType
instance GHC.Classes.Eq GI.Pango.Enums.CoverageLevel
instance GHC.Show.Show GI.Pango.Enums.CoverageLevel
instance GHC.Classes.Eq GI.Pango.Enums.Direction
instance GHC.Show.Show GI.Pango.Enums.Direction
instance GHC.Classes.Eq GI.Pango.Enums.EllipsizeMode
instance GHC.Show.Show GI.Pango.Enums.EllipsizeMode
instance GHC.Classes.Eq GI.Pango.Enums.Gravity
instance GHC.Show.Show GI.Pango.Enums.Gravity
instance GHC.Classes.Eq GI.Pango.Enums.GravityHint
instance GHC.Show.Show GI.Pango.Enums.GravityHint
instance GHC.Classes.Eq GI.Pango.Enums.RenderPart
instance GHC.Show.Show GI.Pango.Enums.RenderPart
instance GHC.Classes.Eq GI.Pango.Enums.Script
instance GHC.Show.Show GI.Pango.Enums.Script
instance GHC.Classes.Eq GI.Pango.Enums.Stretch
instance GHC.Show.Show GI.Pango.Enums.Stretch
instance GHC.Classes.Eq GI.Pango.Enums.Style
instance GHC.Show.Show GI.Pango.Enums.Style
instance GHC.Classes.Eq GI.Pango.Enums.TabAlign
instance GHC.Show.Show GI.Pango.Enums.TabAlign
instance GHC.Classes.Eq GI.Pango.Enums.Underline
instance GHC.Show.Show GI.Pango.Enums.Underline
instance GHC.Classes.Eq GI.Pango.Enums.Variant
instance GHC.Show.Show GI.Pango.Enums.Variant
instance GHC.Classes.Eq GI.Pango.Enums.Weight
instance GHC.Show.Show GI.Pango.Enums.Weight
instance GHC.Classes.Eq GI.Pango.Enums.WrapMode
instance GHC.Show.Show GI.Pango.Enums.WrapMode
instance GHC.Enum.Enum GI.Pango.Enums.Alignment
instance GHC.Classes.Ord GI.Pango.Enums.Alignment
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.Alignment
instance GHC.Enum.Enum GI.Pango.Enums.AttrType
instance GHC.Classes.Ord GI.Pango.Enums.AttrType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.AttrType
instance GHC.Enum.Enum GI.Pango.Enums.BidiType
instance GHC.Classes.Ord GI.Pango.Enums.BidiType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.BidiType
instance GHC.Enum.Enum GI.Pango.Enums.CoverageLevel
instance GHC.Classes.Ord GI.Pango.Enums.CoverageLevel
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.CoverageLevel
instance GHC.Enum.Enum GI.Pango.Enums.Direction
instance GHC.Classes.Ord GI.Pango.Enums.Direction
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.Direction
instance GHC.Enum.Enum GI.Pango.Enums.EllipsizeMode
instance GHC.Classes.Ord GI.Pango.Enums.EllipsizeMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.EllipsizeMode
instance GHC.Enum.Enum GI.Pango.Enums.Gravity
instance GHC.Classes.Ord GI.Pango.Enums.Gravity
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.Gravity
instance GHC.Enum.Enum GI.Pango.Enums.GravityHint
instance GHC.Classes.Ord GI.Pango.Enums.GravityHint
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.GravityHint
instance GHC.Enum.Enum GI.Pango.Enums.RenderPart
instance GHC.Classes.Ord GI.Pango.Enums.RenderPart
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.RenderPart
instance GHC.Enum.Enum GI.Pango.Enums.Script
instance GHC.Classes.Ord GI.Pango.Enums.Script
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.Script
instance GHC.Enum.Enum GI.Pango.Enums.Stretch
instance GHC.Classes.Ord GI.Pango.Enums.Stretch
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.Stretch
instance GHC.Enum.Enum GI.Pango.Enums.Style
instance GHC.Classes.Ord GI.Pango.Enums.Style
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.Style
instance GHC.Enum.Enum GI.Pango.Enums.TabAlign
instance GHC.Classes.Ord GI.Pango.Enums.TabAlign
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.TabAlign
instance GHC.Enum.Enum GI.Pango.Enums.Underline
instance GHC.Classes.Ord GI.Pango.Enums.Underline
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.Underline
instance GHC.Enum.Enum GI.Pango.Enums.Variant
instance GHC.Classes.Ord GI.Pango.Enums.Variant
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.Variant
instance GHC.Enum.Enum GI.Pango.Enums.Weight
instance GHC.Classes.Ord GI.Pango.Enums.Weight
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.Weight
instance GHC.Enum.Enum GI.Pango.Enums.WrapMode
instance GHC.Classes.Ord GI.Pango.Enums.WrapMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.WrapMode


module GI.Pango.Flags

-- | The bits in a <a>FontMask</a> correspond to fields in a
--   <a>FontDescription</a> that have been set.
data FontMask

-- | the font family is specified.
FontMaskFamily :: FontMask

-- | the font style is specified.
FontMaskStyle :: FontMask

-- | the font variant is specified.
FontMaskVariant :: FontMask

-- | the font weight is specified.
FontMaskWeight :: FontMask

-- | the font stretch is specified.
FontMaskStretch :: FontMask

-- | the font size is specified.
FontMaskSize :: FontMask

-- | the font gravity is specified (Since: 1.16.)
FontMaskGravity :: FontMask

-- | OpenType font variations are specified (Since: 1.42)
FontMaskVariations :: FontMask

-- | Catch-all for unknown values
AnotherFontMask :: Int -> FontMask
instance GHC.Classes.Eq GI.Pango.Flags.FontMask
instance GHC.Show.Show GI.Pango.Flags.FontMask
instance GHC.Enum.Enum GI.Pango.Flags.FontMask
instance GHC.Classes.Ord GI.Pango.Flags.FontMask
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Pango.Flags.FontMask
instance Data.GI.Base.BasicTypes.IsGFlag GI.Pango.Flags.FontMask


-- | <a>Engine</a> is the base class for all types of language and script
--   specific engines. It has no functionality by itself.
module GI.Pango.Objects.Engine

-- | Memory-managed wrapper type.
newtype Engine
Engine :: ManagedPtr Engine -> Engine

-- | Type class for types which can be safely cast to <a>Engine</a>, for
--   instance with <a>toEngine</a>.
class (GObject o, IsDescendantOf Engine o) => IsEngine o

-- | Cast to <a>Engine</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toEngine :: (MonadIO m, IsEngine o) => o -> m Engine

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Engine</a>.
noEngine :: Maybe Engine
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.Engine.Engine o) => GI.Pango.Objects.Engine.IsEngine o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Engine.Engine
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Engine.Engine


-- | The <a>EngineLang</a> class is implemented by engines that customize
--   the rendering-system independent part of the Pango pipeline for a
--   particular script or language. For instance, a custom
--   <a>EngineLang</a> could be provided for Thai to implement the
--   dictionary-based word boundary lookups needed for that language.
module GI.Pango.Objects.EngineLang

-- | Memory-managed wrapper type.
newtype EngineLang
EngineLang :: ManagedPtr EngineLang -> EngineLang

-- | Type class for types which can be safely cast to <a>EngineLang</a>,
--   for instance with <a>toEngineLang</a>.
class (GObject o, IsDescendantOf EngineLang o) => IsEngineLang o

-- | Cast to <a>EngineLang</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toEngineLang :: (MonadIO m, IsEngineLang o) => o -> m EngineLang

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>EngineLang</a>.
noEngineLang :: Maybe EngineLang
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.EngineLang.EngineLang o) => GI.Pango.Objects.EngineLang.IsEngineLang o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.EngineLang.EngineLang
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.EngineLang.EngineLang


-- | The <a>EngineShape</a> class is implemented by engines that customize
--   the rendering-system dependent part of the Pango pipeline for a
--   particular script or language. A <a>EngineShape</a> implementation is
--   then specific to both a particular rendering system or group of
--   rendering systems and to a particular script. For instance, there is
--   one <a>EngineShape</a> implementation to handle shaping Arabic for
--   Fontconfig-based backends.
module GI.Pango.Objects.EngineShape

-- | Memory-managed wrapper type.
newtype EngineShape
EngineShape :: ManagedPtr EngineShape -> EngineShape

-- | Type class for types which can be safely cast to <a>EngineShape</a>,
--   for instance with <a>toEngineShape</a>.
class (GObject o, IsDescendantOf EngineShape o) => IsEngineShape o

-- | Cast to <a>EngineShape</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toEngineShape :: (MonadIO m, IsEngineShape o) => o -> m EngineShape

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>EngineShape</a>.
noEngineShape :: Maybe EngineShape
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.EngineShape.EngineShape o) => GI.Pango.Objects.EngineShape.IsEngineShape o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.EngineShape.EngineShape
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.EngineShape.EngineShape


-- | The <a>FontFamily</a> structure is used to represent a family of
--   related font faces. The faces in a family share a common design, but
--   differ in slant, weight, width and other aspects.
module GI.Pango.Objects.FontFamily

-- | Memory-managed wrapper type.
newtype FontFamily
FontFamily :: ManagedPtr FontFamily -> FontFamily

-- | Type class for types which can be safely cast to <a>FontFamily</a>,
--   for instance with <a>toFontFamily</a>.
class (GObject o, IsDescendantOf FontFamily o) => IsFontFamily o

-- | Cast to <a>FontFamily</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFontFamily :: (MonadIO m, IsFontFamily o) => o -> m FontFamily

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>FontFamily</a>.
noFontFamily :: Maybe FontFamily

-- | Gets the name of the family. The name is unique among all fonts for
--   the font backend and can be used in a <a>FontDescription</a> to
--   specify that a face from this family is desired.
fontFamilyGetName :: (HasCallStack, MonadIO m, IsFontFamily a) => a -> m Text

-- | A monospace font is a font designed for text display where the the
--   characters form a regular grid. For Western languages this would mean
--   that the advance width of all characters are the same, but this
--   categorization also includes Asian fonts which include double-width
--   characters: characters that occupy two grid cells.
--   <a>unicharIswide</a> returns a result that indicates whether a
--   character is typically double-width in a monospace font.
--   
--   The best way to find out the grid-cell size is to call
--   <a>fontMetricsGetApproximateDigitWidth</a>, since the results of
--   <a>fontMetricsGetApproximateCharWidth</a> may be affected by
--   double-width characters.
--   
--   <i>Since: 1.4</i>
fontFamilyIsMonospace :: (HasCallStack, MonadIO m, IsFontFamily a) => a -> m Bool

-- | A variable font is a font which has axes that can be modified to
--   produce different faces.
--   
--   <i>Since: 1.44</i>
fontFamilyIsVariable :: (HasCallStack, MonadIO m, IsFontFamily a) => a -> m Bool

-- | Lists the different font faces that make up <i><tt>family</tt></i>.
--   The faces in a family share a common design, but differ in slant,
--   weight, width and other aspects.
fontFamilyListFaces :: (HasCallStack, MonadIO m, IsFontFamily a) => a -> m [FontFace]
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.FontFamily.FontFamily o) => GI.Pango.Objects.FontFamily.IsFontFamily o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontFamily.FontFamily
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.FontFamily.FontFamily


-- | The <a>AttrString</a> structure is used to represent attributes with a
--   string value.
module GI.Pango.Structs.AttrString

-- | Memory-managed wrapper type.
newtype AttrString
AttrString :: ManagedPtr AttrString -> AttrString

-- | Construct a <a>AttrString</a> struct initialized to zero.
newZeroAttrString :: MonadIO m => m AttrString

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrString</a>.
noAttrString :: Maybe AttrString

-- | Get the value of the “<tt>attr</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrString #attr
--   </pre>
getAttrStringAttr :: MonadIO m => AttrString -> m Attribute

-- | Set the value of the “<tt>value</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #value
--   </pre>
clearAttrStringValue :: MonadIO m => AttrString -> m ()

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrString #value
--   </pre>
getAttrStringValue :: MonadIO m => AttrString -> m (Maybe Text)

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrString [ #value <a>:=</a> value ]
--   </pre>
setAttrStringValue :: MonadIO m => AttrString -> CString -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrString.AttrString
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrString.AttrString tag


-- | The <a>AttrSize</a> structure is used to represent attributes which
--   set font size.
module GI.Pango.Structs.AttrSize

-- | Memory-managed wrapper type.
newtype AttrSize
AttrSize :: ManagedPtr AttrSize -> AttrSize

-- | Construct a <a>AttrSize</a> struct initialized to zero.
newZeroAttrSize :: MonadIO m => m AttrSize

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrSize</a>.
noAttrSize :: Maybe AttrSize

-- | Create a new font-size attribute in fractional points.
attrSizeNew :: (HasCallStack, MonadIO m) => Int32 -> m Attribute

-- | Get the value of the “<tt>absolute</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrSize #absolute
--   </pre>
getAttrSizeAbsolute :: MonadIO m => AttrSize -> m Word32

-- | Set the value of the “<tt>absolute</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrSize [ #absolute <a>:=</a> value ]
--   </pre>
setAttrSizeAbsolute :: MonadIO m => AttrSize -> Word32 -> m ()

-- | Get the value of the “<tt>attr</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrSize #attr
--   </pre>
getAttrSizeAttr :: MonadIO m => AttrSize -> m Attribute

-- | Get the value of the “<tt>size</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrSize #size
--   </pre>
getAttrSizeSize :: MonadIO m => AttrSize -> m Int32

-- | Set the value of the “<tt>size</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrSize [ #size <a>:=</a> value ]
--   </pre>
setAttrSizeSize :: MonadIO m => AttrSize -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrSize.AttrSize
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrSize.AttrSize tag


-- | The <a>AttrInt</a> structure is used to represent attributes with an
--   integer or enumeration value.
module GI.Pango.Structs.AttrInt

-- | Memory-managed wrapper type.
newtype AttrInt
AttrInt :: ManagedPtr AttrInt -> AttrInt

-- | Construct a <a>AttrInt</a> struct initialized to zero.
newZeroAttrInt :: MonadIO m => m AttrInt

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>AttrInt</a>.
noAttrInt :: Maybe AttrInt

-- | Get the value of the “<tt>attr</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrInt #attr
--   </pre>
getAttrIntAttr :: MonadIO m => AttrInt -> m Attribute

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrInt #value
--   </pre>
getAttrIntValue :: MonadIO m => AttrInt -> m Int32

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrInt [ #value <a>:=</a> value ]
--   </pre>
setAttrIntValue :: MonadIO m => AttrInt -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrInt.AttrInt
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrInt.AttrInt tag


-- | The <a>AttrFontFeatures</a> structure is used to represent OpenType
--   font features as an attribute.
--   
--   <i>Since: 1.38</i>
module GI.Pango.Structs.AttrFontFeatures

-- | Memory-managed wrapper type.
newtype AttrFontFeatures
AttrFontFeatures :: ManagedPtr AttrFontFeatures -> AttrFontFeatures

-- | Construct a <a>AttrFontFeatures</a> struct initialized to zero.
newZeroAttrFontFeatures :: MonadIO m => m AttrFontFeatures

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrFontFeatures</a>.
noAttrFontFeatures :: Maybe AttrFontFeatures

-- | Create a new font features tag attribute.
--   
--   <i>Since: 1.38</i>
attrFontFeaturesNew :: (HasCallStack, MonadIO m) => Text -> m Attribute

-- | Get the value of the “<tt>attr</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrFontFeatures #attr
--   </pre>
getAttrFontFeaturesAttr :: MonadIO m => AttrFontFeatures -> m Attribute

-- | Set the value of the “<tt>features</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #features
--   </pre>
clearAttrFontFeaturesFeatures :: MonadIO m => AttrFontFeatures -> m ()

-- | Get the value of the “<tt>features</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrFontFeatures #features
--   </pre>
getAttrFontFeaturesFeatures :: MonadIO m => AttrFontFeatures -> m (Maybe Text)

-- | Set the value of the “<tt>features</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrFontFeatures [ #features <a>:=</a> value ]
--   </pre>
setAttrFontFeaturesFeatures :: MonadIO m => AttrFontFeatures -> CString -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures tag


-- | The <a>AttrFloat</a> structure is used to represent attributes with a
--   float or double value.
module GI.Pango.Structs.AttrFloat

-- | Memory-managed wrapper type.
newtype AttrFloat
AttrFloat :: ManagedPtr AttrFloat -> AttrFloat

-- | Construct a <a>AttrFloat</a> struct initialized to zero.
newZeroAttrFloat :: MonadIO m => m AttrFloat

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrFloat</a>.
noAttrFloat :: Maybe AttrFloat

-- | Get the value of the “<tt>attr</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrFloat #attr
--   </pre>
getAttrFloatAttr :: MonadIO m => AttrFloat -> m Attribute

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrFloat #value
--   </pre>
getAttrFloatValue :: MonadIO m => AttrFloat -> m Double

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrFloat [ #value <a>:=</a> value ]
--   </pre>
setAttrFloatValue :: MonadIO m => AttrFloat -> Double -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrFloat.AttrFloat
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrFloat.AttrFloat tag


-- | The <a>Attribute</a> structure represents the common portions of all
--   attributes. Particular types of attributes include this structure as
--   their initial portion. The common portion of the attribute holds the
--   range to which the value in the type-specific part of the attribute
--   applies and should be initialized using <a>attributeInit</a>. By
--   default an attribute will have an all-inclusive range of
--   [0,<tt><i>G_MAXUINT</i></tt>].
module GI.Pango.Structs.Attribute

-- | Memory-managed wrapper type.
newtype Attribute
Attribute :: ManagedPtr Attribute -> Attribute

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>Attribute</a>.
noAttribute :: Maybe Attribute

-- | Destroy a <a>Attribute</a> and free all associated memory.
attributeDestroy :: (HasCallStack, MonadIO m) => Attribute -> m ()

-- | Compare two attributes for equality. This compares only the actual
--   value of the two attributes and not the ranges that the attributes
--   apply to.
attributeEqual :: (HasCallStack, MonadIO m) => Attribute -> Attribute -> m Bool

-- | Initializes <i><tt>attr</tt></i>'s klass to <i><tt>klass</tt></i>,
--   it's start_index to <a>ATTR_INDEX_FROM_TEXT_BEGINNING</a> and
--   end_index to <tt><i>PANGO_ATTR_INDEX_TO_TEXT_END</i></tt> such that
--   the attribute applies to the entire text by default.
--   
--   <i>Since: 1.20</i>
attributeInit :: (HasCallStack, MonadIO m) => Attribute -> AttrClass -> m ()

-- | Get the value of the “<tt>end_index</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attribute #endIndex
--   </pre>
getAttributeEndIndex :: MonadIO m => Attribute -> m Word32

-- | Set the value of the “<tt>end_index</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attribute [ #endIndex <a>:=</a> value ]
--   </pre>
setAttributeEndIndex :: MonadIO m => Attribute -> Word32 -> m ()

-- | Set the value of the “<tt>klass</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #klass
--   </pre>
clearAttributeKlass :: MonadIO m => Attribute -> m ()

-- | Get the value of the “<tt>klass</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attribute #klass
--   </pre>
getAttributeKlass :: MonadIO m => Attribute -> m (Maybe AttrClass)

-- | Set the value of the “<tt>klass</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attribute [ #klass <a>:=</a> value ]
--   </pre>
setAttributeKlass :: MonadIO m => Attribute -> Ptr AttrClass -> m ()

-- | Get the value of the “<tt>start_index</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attribute #startIndex
--   </pre>
getAttributeStartIndex :: MonadIO m => Attribute -> m Word32

-- | Set the value of the “<tt>start_index</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attribute [ #startIndex <a>:=</a> value ]
--   </pre>
setAttributeStartIndex :: MonadIO m => Attribute -> Word32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.Attribute.Attribute


-- | The <a>AttrColor</a> structure is used to represent attributes that
--   are colors.
module GI.Pango.Structs.AttrColor

-- | Memory-managed wrapper type.
newtype AttrColor
AttrColor :: ManagedPtr AttrColor -> AttrColor

-- | Construct a <a>AttrColor</a> struct initialized to zero.
newZeroAttrColor :: MonadIO m => m AttrColor

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrColor</a>.
noAttrColor :: Maybe AttrColor

-- | Get the value of the “<tt>attr</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrColor #attr
--   </pre>
getAttrColorAttr :: MonadIO m => AttrColor -> m Attribute

-- | Get the value of the “<tt>color</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrColor #color
--   </pre>
getAttrColorColor :: MonadIO m => AttrColor -> m Color
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrColor.AttrColor
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrColor.AttrColor tag


-- | The <a>Color</a> structure is used to represent a color in an
--   uncalibrated RGB color-space.
module GI.Pango.Structs.Color

-- | Memory-managed wrapper type.
newtype Color
Color :: ManagedPtr Color -> Color

-- | Construct a <a>Color</a> struct initialized to zero.
newZeroColor :: MonadIO m => m Color

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Color</a>.
noColor :: Maybe Color

-- | Creates a copy of <i><tt>src</tt></i>, which should be freed with
--   <a>colorFree</a>. Primarily used by language bindings, not that useful
--   otherwise (since colors can just be copied by assignment in C).
colorCopy :: (HasCallStack, MonadIO m) => Color -> m (Maybe Color)

-- | Frees a color allocated by <a>colorCopy</a>.
colorFree :: (HasCallStack, MonadIO m) => Color -> m ()

-- | Fill in the fields of a color from a string specification. The string
--   can either one of a large set of standard names. (Taken from the CSS
--   &lt;ulink
--   url="http://dev.w3.org/csswg/css-color/<tt><i>named</i></tt>-colors"&gt;specification&lt;/ulink&gt;),
--   or it can be a hexadecimal value in the form '&amp;num;rgb'
--   '&amp;num;rrggbb' '&amp;num;rrrgggbbb' or '&amp;num;rrrrggggbbbb'
--   where 'r', 'g' and 'b' are hex digits of the red, green, and blue
--   components of the color, respectively. (White in the four forms is
--   '&amp;num;fff' '&amp;num;ffffff' '&amp;num;fffffffff' and
--   '&amp;num;ffffffffffff')
colorParse :: (HasCallStack, MonadIO m) => Color -> Text -> m Bool

-- | Returns a textual specification of <i><tt>color</tt></i> in the
--   hexadecimal form &lt;literal&gt;&amp;num;rrrrggggbbbb&lt;/literal&gt;,
--   where &lt;literal&gt;r&lt;/literal&gt;,
--   &lt;literal&gt;g&lt;/literal&gt; and &lt;literal&gt;b&lt;/literal&gt;
--   are hex digits representing the red, green, and blue components
--   respectively.
--   
--   <i>Since: 1.16</i>
colorToString :: (HasCallStack, MonadIO m) => Color -> m Text

-- | Get the value of the “<tt>blue</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> color #blue
--   </pre>
getColorBlue :: MonadIO m => Color -> m Word16

-- | Set the value of the “<tt>blue</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> color [ #blue <a>:=</a> value ]
--   </pre>
setColorBlue :: MonadIO m => Color -> Word16 -> m ()

-- | Get the value of the “<tt>green</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> color #green
--   </pre>
getColorGreen :: MonadIO m => Color -> m Word16

-- | Set the value of the “<tt>green</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> color [ #green <a>:=</a> value ]
--   </pre>
setColorGreen :: MonadIO m => Color -> Word16 -> m ()

-- | Get the value of the “<tt>red</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> color #red
--   </pre>
getColorRed :: MonadIO m => Color -> m Word16

-- | Set the value of the “<tt>red</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> color [ #red <a>:=</a> value ]
--   </pre>
setColorRed :: MonadIO m => Color -> Word16 -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.Color.Color
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Color.Color tag


-- | The <a>Coverage</a> structure represents a map from Unicode characters
--   to <a>CoverageLevel</a>. It is an opaque structure with no public
--   fields.
module GI.Pango.Structs.Coverage

-- | Memory-managed wrapper type.
newtype Coverage
Coverage :: ManagedPtr Coverage -> Coverage

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>Coverage</a>.
noCoverage :: Maybe Coverage

-- | Determine whether a particular index is covered by
--   <i><tt>coverage</tt></i>
coverageGet :: (HasCallStack, MonadIO m) => Coverage -> Int32 -> m CoverageLevel

-- | Set the coverage for each index in <i><tt>coverage</tt></i> to be the
--   max (better) value of the current coverage for the index and the
--   coverage for the corresponding index in <i><tt>other</tt></i>.
coverageMax :: (HasCallStack, MonadIO m) => Coverage -> Coverage -> m ()

-- | Modify a particular index within <i><tt>coverage</tt></i>
coverageSet :: (HasCallStack, MonadIO m) => Coverage -> Int32 -> CoverageLevel -> m ()

-- | Convert a <a>Coverage</a> structure into a flat binary format
coverageToBytes :: (HasCallStack, MonadIO m) => Coverage -> m ByteString

-- | Decrease the reference count on the <a>Coverage</a> by one. If the
--   result is zero, free the coverage and all associated memory.
coverageUnref :: (HasCallStack, MonadIO m) => Coverage -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.Coverage.Coverage


module GI.Pango.Callbacks

-- | <i>No description available in the introspection data.</i>
type AttrClassDestroyFieldCallback = Attribute -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_AttrClassDestroyFieldCallback = Ptr Attribute -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_AttrClassDestroyFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_AttrClassDestroyFieldCallback -> Attribute -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_AttrClassDestroyFieldCallback :: MonadIO m => AttrClassDestroyFieldCallback -> m (GClosure C_AttrClassDestroyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_AttrClassDestroyFieldCallback</a>.
mk_AttrClassDestroyFieldCallback :: C_AttrClassDestroyFieldCallback -> IO (FunPtr C_AttrClassDestroyFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrClassDestroyFieldCallback</a></tt>.
noAttrClassDestroyFieldCallback :: Maybe AttrClassDestroyFieldCallback

-- | Wrap a <a>AttrClassDestroyFieldCallback</a> into a
--   <a>C_AttrClassDestroyFieldCallback</a>.
wrap_AttrClassDestroyFieldCallback :: Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback)) -> AttrClassDestroyFieldCallback -> C_AttrClassDestroyFieldCallback

-- | <i>No description available in the introspection data.</i>
type AttrClassEqualFieldCallback = Attribute -> Attribute -> IO Bool

-- | Type for the callback on the (unwrapped) C side.
type C_AttrClassEqualFieldCallback = Ptr Attribute -> Ptr Attribute -> IO CInt

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_AttrClassEqualFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_AttrClassEqualFieldCallback -> Attribute -> Attribute -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_AttrClassEqualFieldCallback :: MonadIO m => AttrClassEqualFieldCallback -> m (GClosure C_AttrClassEqualFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_AttrClassEqualFieldCallback</a>.
mk_AttrClassEqualFieldCallback :: C_AttrClassEqualFieldCallback -> IO (FunPtr C_AttrClassEqualFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrClassEqualFieldCallback</a></tt>.
noAttrClassEqualFieldCallback :: Maybe AttrClassEqualFieldCallback

-- | Wrap a <a>AttrClassEqualFieldCallback</a> into a
--   <a>C_AttrClassEqualFieldCallback</a>.
wrap_AttrClassEqualFieldCallback :: Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback)) -> AttrClassEqualFieldCallback -> C_AttrClassEqualFieldCallback

-- | Type of a function that can duplicate user data for an attribute.
type AttrDataCopyFunc = IO (Ptr ()) " __Returns:__ new copy of /@userData@/. "

-- | Type of a function that can duplicate user data for an attribute.
type AttrDataCopyFunc_WithClosures = Ptr () " /@userData@/: user data to copy " -> IO (Ptr ()) " __Returns:__ new copy of /@userData@/. "

-- | Type for the callback on the (unwrapped) C side.
type C_AttrDataCopyFunc = Ptr () -> IO (Ptr ())

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AttrDataCopyFunc :: AttrDataCopyFunc -> AttrDataCopyFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_AttrDataCopyFunc :: (HasCallStack, MonadIO m) => FunPtr C_AttrDataCopyFunc -> Ptr () -> m (Ptr ())

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_AttrDataCopyFunc :: MonadIO m => AttrDataCopyFunc -> m (GClosure C_AttrDataCopyFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_AttrDataCopyFunc</a>.
mk_AttrDataCopyFunc :: C_AttrDataCopyFunc -> IO (FunPtr C_AttrDataCopyFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrDataCopyFunc</a></tt>.
noAttrDataCopyFunc :: Maybe AttrDataCopyFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrDataCopyFunc_WithClosures</a></tt>.
noAttrDataCopyFunc_WithClosures :: Maybe AttrDataCopyFunc_WithClosures

-- | Wrap a <a>AttrDataCopyFunc</a> into a <a>C_AttrDataCopyFunc</a>.
wrap_AttrDataCopyFunc :: Maybe (Ptr (FunPtr C_AttrDataCopyFunc)) -> AttrDataCopyFunc_WithClosures -> C_AttrDataCopyFunc

-- | Type of a function filtering a list of attributes.
type AttrFilterFunc = Attribute " /@attribute@/: a Pango attribute " -> IO Bool " __Returns:__ 'True' if the attribute should be selected for filtering, 'False' otherwise. "

-- | Type of a function filtering a list of attributes.
type AttrFilterFunc_WithClosures = Attribute " /@attribute@/: a Pango attribute " -> Ptr () " /@userData@/: user data passed to the function " -> IO Bool " __Returns:__ 'True' if the attribute should be selected for filtering, 'False' otherwise. "

-- | Type for the callback on the (unwrapped) C side.
type C_AttrFilterFunc = Ptr Attribute -> Ptr () -> IO CInt

-- | A simple wrapper that ignores the closure arguments.
drop_closures_AttrFilterFunc :: AttrFilterFunc -> AttrFilterFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_AttrFilterFunc :: (HasCallStack, MonadIO m) => FunPtr C_AttrFilterFunc -> Attribute -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_AttrFilterFunc :: MonadIO m => AttrFilterFunc -> m (GClosure C_AttrFilterFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_AttrFilterFunc</a>.
mk_AttrFilterFunc :: C_AttrFilterFunc -> IO (FunPtr C_AttrFilterFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrFilterFunc</a></tt>.
noAttrFilterFunc :: Maybe AttrFilterFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrFilterFunc_WithClosures</a></tt>.
noAttrFilterFunc_WithClosures :: Maybe AttrFilterFunc_WithClosures

-- | Wrap a <a>AttrFilterFunc</a> into a <a>C_AttrFilterFunc</a>.
wrap_AttrFilterFunc :: Maybe (Ptr (FunPtr C_AttrFilterFunc)) -> AttrFilterFunc_WithClosures -> C_AttrFilterFunc

-- | Type for the callback on the (unwrapped) C side.
type C_FontsetForeachFunc = Ptr Fontset -> Ptr Font -> Ptr () -> IO CInt

-- | A callback function used by <a>fontsetForeach</a> when enumerating the
--   fonts in a fontset.
--   
--   <i>Since: 1.4</i>
type FontsetForeachFunc = Fontset " /@fontset@/: a 'GI.Pango.Objects.Fontset.Fontset' " -> Font " /@font@/: a font from /@fontset@/ " -> IO Bool " __Returns:__ if 'True', stop iteration and return immediately. "

-- | A callback function used by <a>fontsetForeach</a> when enumerating the
--   fonts in a fontset.
--   
--   <i>Since: 1.4</i>
type FontsetForeachFunc_WithClosures = Fontset " /@fontset@/: a 'GI.Pango.Objects.Fontset.Fontset' " -> Font " /@font@/: a font from /@fontset@/ " -> Ptr () " /@userData@/: callback data " -> IO Bool " __Returns:__ if 'True', stop iteration and return immediately. "

-- | A simple wrapper that ignores the closure arguments.
drop_closures_FontsetForeachFunc :: FontsetForeachFunc -> FontsetForeachFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_FontsetForeachFunc :: (HasCallStack, MonadIO m, IsFontset a, IsFont b) => FunPtr C_FontsetForeachFunc -> a -> b -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_FontsetForeachFunc :: MonadIO m => FontsetForeachFunc -> m (GClosure C_FontsetForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_FontsetForeachFunc</a>.
mk_FontsetForeachFunc :: C_FontsetForeachFunc -> IO (FunPtr C_FontsetForeachFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FontsetForeachFunc</a></tt>.
noFontsetForeachFunc :: Maybe FontsetForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>FontsetForeachFunc_WithClosures</a></tt>.
noFontsetForeachFunc_WithClosures :: Maybe FontsetForeachFunc_WithClosures

-- | Wrap a <a>FontsetForeachFunc</a> into a <a>C_FontsetForeachFunc</a>.
wrap_FontsetForeachFunc :: Maybe (Ptr (FunPtr C_FontsetForeachFunc)) -> FontsetForeachFunc_WithClosures -> C_FontsetForeachFunc

-- | Type for the callback on the (unwrapped) C side.
type C_IncludedModuleExitFieldCallback = IO ()

-- | <i>No description available in the introspection data.</i>
type IncludedModuleExitFieldCallback = IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_IncludedModuleExitFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IncludedModuleExitFieldCallback -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_IncludedModuleExitFieldCallback :: MonadIO m => IncludedModuleExitFieldCallback -> m (GClosure C_IncludedModuleExitFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_IncludedModuleExitFieldCallback</a>.
mk_IncludedModuleExitFieldCallback :: C_IncludedModuleExitFieldCallback -> IO (FunPtr C_IncludedModuleExitFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>IncludedModuleExitFieldCallback</a></tt>.
noIncludedModuleExitFieldCallback :: Maybe IncludedModuleExitFieldCallback

-- | Wrap a <a>IncludedModuleExitFieldCallback</a> into a
--   <a>C_IncludedModuleExitFieldCallback</a>.
wrap_IncludedModuleExitFieldCallback :: Maybe (Ptr (FunPtr C_IncludedModuleExitFieldCallback)) -> IncludedModuleExitFieldCallback -> C_IncludedModuleExitFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_IncludedModuleInitFieldCallback = Ptr TypeModule -> IO ()

-- | <i>No description available in the introspection data.</i>
type IncludedModuleInitFieldCallback = TypeModule -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_IncludedModuleInitFieldCallback :: (HasCallStack, MonadIO m, IsTypeModule a) => FunPtr C_IncludedModuleInitFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_IncludedModuleInitFieldCallback :: MonadIO m => IncludedModuleInitFieldCallback -> m (GClosure C_IncludedModuleInitFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_IncludedModuleInitFieldCallback</a>.
mk_IncludedModuleInitFieldCallback :: C_IncludedModuleInitFieldCallback -> IO (FunPtr C_IncludedModuleInitFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>IncludedModuleInitFieldCallback</a></tt>.
noIncludedModuleInitFieldCallback :: Maybe IncludedModuleInitFieldCallback

-- | Wrap a <a>IncludedModuleInitFieldCallback</a> into a
--   <a>C_IncludedModuleInitFieldCallback</a>.
wrap_IncludedModuleInitFieldCallback :: Maybe (Ptr (FunPtr C_IncludedModuleInitFieldCallback)) -> IncludedModuleInitFieldCallback -> C_IncludedModuleInitFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_IncludedModuleListFieldCallback = Ptr EngineInfo -> Int32 -> IO ()

-- | <i>No description available in the introspection data.</i>
type IncludedModuleListFieldCallback = EngineInfo -> Int32 -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_IncludedModuleListFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IncludedModuleListFieldCallback -> EngineInfo -> Int32 -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_IncludedModuleListFieldCallback :: MonadIO m => IncludedModuleListFieldCallback -> m (GClosure C_IncludedModuleListFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_IncludedModuleListFieldCallback</a>.
mk_IncludedModuleListFieldCallback :: C_IncludedModuleListFieldCallback -> IO (FunPtr C_IncludedModuleListFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>IncludedModuleListFieldCallback</a></tt>.
noIncludedModuleListFieldCallback :: Maybe IncludedModuleListFieldCallback

-- | Wrap a <a>IncludedModuleListFieldCallback</a> into a
--   <a>C_IncludedModuleListFieldCallback</a>.
wrap_IncludedModuleListFieldCallback :: Maybe (Ptr (FunPtr C_IncludedModuleListFieldCallback)) -> IncludedModuleListFieldCallback -> C_IncludedModuleListFieldCallback


-- | The <a>AttrList</a> structure represents a list of attributes that
--   apply to a section of text. The attributes are, in general, allowed to
--   overlap in an arbitrary fashion, however, if the attributes are
--   manipulated only through <a>attrListChange</a>, the overlap between
--   properties will meet stricter criteria.
--   
--   Since the <a>AttrList</a> structure is stored as a linear list, it is
--   not suitable for storing attributes for large amounts of text. In
--   general, you should not use a single <a>AttrList</a> for more than one
--   paragraph of text.
module GI.Pango.Structs.AttrList

-- | Memory-managed wrapper type.
newtype AttrList
AttrList :: ManagedPtr AttrList -> AttrList

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrList</a>.
noAttrList :: Maybe AttrList

-- | Insert the given attribute into the <a>AttrList</a>. It will replace
--   any attributes of the same type on that segment and be merged with any
--   adjoining attributes that are identical.
--   
--   This function is slower than <a>attrListInsert</a> for creating a
--   attribute list in order (potentially much slower for large lists).
--   However, <a>attrListInsert</a> is not suitable for continually
--   changing a set of attributes since it never removes or combines
--   existing attributes.
attrListChange :: (HasCallStack, MonadIO m) => AttrList -> Attribute -> m ()

-- | Copy <i><tt>list</tt></i> and return an identical new list.
attrListCopy :: (HasCallStack, MonadIO m) => AttrList -> m (Maybe AttrList)

-- | Given a <a>AttrList</a> and callback function, removes any elements of
--   <i><tt>list</tt></i> for which <i><tt>func</tt></i> returns
--   <a>True</a> and inserts them into a new list.
--   
--   <i>Since: 1.2</i>
attrListFilter :: (HasCallStack, MonadIO m) => AttrList -> AttrFilterFunc -> m (Maybe AttrList)

-- | Insert the given attribute into the <a>AttrList</a>. It will be
--   inserted after all other attributes with a matching
--   <i><tt>startIndex</tt></i>.
attrListInsert :: (HasCallStack, MonadIO m) => AttrList -> Attribute -> m ()

-- | Insert the given attribute into the <a>AttrList</a>. It will be
--   inserted before all other attributes with a matching
--   <i><tt>startIndex</tt></i>.
attrListInsertBefore :: (HasCallStack, MonadIO m) => AttrList -> Attribute -> m ()

-- | Create a new empty attribute list with a reference count of one.
attrListNew :: (HasCallStack, MonadIO m) => m AttrList

-- | Increase the reference count of the given attribute list by one.
--   
--   <i>Since: 1.10</i>
attrListRef :: (HasCallStack, MonadIO m) => AttrList -> m AttrList

-- | This function opens up a hole in <i><tt>list</tt></i>, fills it in
--   with attributes from the left, and then merges <i><tt>other</tt></i>
--   on top of the hole.
--   
--   This operation is equivalent to stretching every attribute that
--   applies at position <i><tt>pos</tt></i> in <i><tt>list</tt></i> by an
--   amount <i><tt>len</tt></i>, and then calling <a>attrListChange</a>
--   with a copy of each attribute in <i><tt>other</tt></i> in sequence
--   (offset in position by <i><tt>pos</tt></i>).
--   
--   This operation proves useful for, for instance, inserting a pre-edit
--   string in the middle of an edit buffer.
attrListSplice :: (HasCallStack, MonadIO m) => AttrList -> AttrList -> Int32 -> Int32 -> m ()

-- | Decrease the reference count of the given attribute list by one. If
--   the result is zero, free the attribute list and the attributes it
--   contains.
attrListUnref :: (HasCallStack, MonadIO m) => AttrList -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.AttrList.AttrList


-- | The <a>AttrClass</a> structure stores the type and operations for a
--   particular type of attribute. The functions in this structure should
--   not be called directly. Instead, one should use the wrapper functions
--   provided for <a>Attribute</a>.
module GI.Pango.Structs.AttrClass

-- | Memory-managed wrapper type.
newtype AttrClass
AttrClass :: ManagedPtr AttrClass -> AttrClass

-- | Construct a <a>AttrClass</a> struct initialized to zero.
newZeroAttrClass :: MonadIO m => m AttrClass

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrClass</a>.
noAttrClass :: Maybe AttrClass

-- | Set the value of the “<tt>destroy</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #destroy
--   </pre>
clearAttrClassDestroy :: MonadIO m => AttrClass -> m ()

-- | Get the value of the “<tt>destroy</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrClass #destroy
--   </pre>
getAttrClassDestroy :: MonadIO m => AttrClass -> m (Maybe AttrClassDestroyFieldCallback)

-- | Set the value of the “<tt>destroy</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrClass [ #destroy <a>:=</a> value ]
--   </pre>
setAttrClassDestroy :: MonadIO m => AttrClass -> FunPtr C_AttrClassDestroyFieldCallback -> m ()

-- | Set the value of the “<tt>equal</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #equal
--   </pre>
clearAttrClassEqual :: MonadIO m => AttrClass -> m ()

-- | Get the value of the “<tt>equal</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrClass #equal
--   </pre>
getAttrClassEqual :: MonadIO m => AttrClass -> m (Maybe AttrClassEqualFieldCallback)

-- | Set the value of the “<tt>equal</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrClass [ #equal <a>:=</a> value ]
--   </pre>
setAttrClassEqual :: MonadIO m => AttrClass -> FunPtr C_AttrClassEqualFieldCallback -> m ()

-- | Get the value of the “<tt>type</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrClass #type
--   </pre>
getAttrClassType :: MonadIO m => AttrClass -> m AttrType

-- | Set the value of the “<tt>type</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrClass [ #type <a>:=</a> value ]
--   </pre>
setAttrClassType :: MonadIO m => AttrClass -> AttrType -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrClass.AttrClass
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrClass.AttrClass tag


-- | The <a>EngineInfo</a> structure contains information about a
--   particular engine. It contains the following fields:
module GI.Pango.Structs.EngineInfo

-- | Memory-managed wrapper type.
newtype EngineInfo
EngineInfo :: ManagedPtr EngineInfo -> EngineInfo

-- | Construct a <a>EngineInfo</a> struct initialized to zero.
newZeroEngineInfo :: MonadIO m => m EngineInfo

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>EngineInfo</a>.
noEngineInfo :: Maybe EngineInfo

-- | Set the value of the “<tt>engine_type</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #engineType
--   </pre>
clearEngineInfoEngineType :: MonadIO m => EngineInfo -> m ()

-- | Get the value of the “<tt>engine_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> engineInfo #engineType
--   </pre>
getEngineInfoEngineType :: MonadIO m => EngineInfo -> m (Maybe Text)

-- | Set the value of the “<tt>engine_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> engineInfo [ #engineType <a>:=</a> value ]
--   </pre>
setEngineInfoEngineType :: MonadIO m => EngineInfo -> CString -> m ()

-- | Set the value of the “<tt>id</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #id
--   </pre>
clearEngineInfoId :: MonadIO m => EngineInfo -> m ()

-- | Get the value of the “<tt>id</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> engineInfo #id
--   </pre>
getEngineInfoId :: MonadIO m => EngineInfo -> m (Maybe Text)

-- | Set the value of the “<tt>id</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> engineInfo [ #id <a>:=</a> value ]
--   </pre>
setEngineInfoId :: MonadIO m => EngineInfo -> CString -> m ()

-- | Get the value of the “<tt>n_scripts</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> engineInfo #nScripts
--   </pre>
getEngineInfoNScripts :: MonadIO m => EngineInfo -> m Int32

-- | Set the value of the “<tt>n_scripts</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> engineInfo [ #nScripts <a>:=</a> value ]
--   </pre>
setEngineInfoNScripts :: MonadIO m => EngineInfo -> Int32 -> m ()

-- | Set the value of the “<tt>render_type</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #renderType
--   </pre>
clearEngineInfoRenderType :: MonadIO m => EngineInfo -> m ()

-- | Get the value of the “<tt>render_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> engineInfo #renderType
--   </pre>
getEngineInfoRenderType :: MonadIO m => EngineInfo -> m (Maybe Text)

-- | Set the value of the “<tt>render_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> engineInfo [ #renderType <a>:=</a> value ]
--   </pre>
setEngineInfoRenderType :: MonadIO m => EngineInfo -> CString -> m ()

-- | Set the value of the “<tt>scripts</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #scripts
--   </pre>
clearEngineInfoScripts :: MonadIO m => EngineInfo -> m ()

-- | Get the value of the “<tt>scripts</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> engineInfo #scripts
--   </pre>
getEngineInfoScripts :: MonadIO m => EngineInfo -> m (Maybe EngineScriptInfo)

-- | Set the value of the “<tt>scripts</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> engineInfo [ #scripts <a>:=</a> value ]
--   </pre>
setEngineInfoScripts :: MonadIO m => EngineInfo -> Ptr EngineScriptInfo -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.EngineInfo.EngineInfo
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.EngineInfo.EngineInfo tag


-- | The <a>EngineScriptInfo</a> structure contains information about how
--   the shaper covers a particular script.
module GI.Pango.Structs.EngineScriptInfo

-- | Memory-managed wrapper type.
newtype EngineScriptInfo
EngineScriptInfo :: ManagedPtr EngineScriptInfo -> EngineScriptInfo

-- | Construct a <a>EngineScriptInfo</a> struct initialized to zero.
newZeroEngineScriptInfo :: MonadIO m => m EngineScriptInfo

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>EngineScriptInfo</a>.
noEngineScriptInfo :: Maybe EngineScriptInfo

-- | Set the value of the “<tt>langs</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #langs
--   </pre>
clearEngineScriptInfoLangs :: MonadIO m => EngineScriptInfo -> m ()

-- | Get the value of the “<tt>langs</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> engineScriptInfo #langs
--   </pre>
getEngineScriptInfoLangs :: MonadIO m => EngineScriptInfo -> m (Maybe Text)

-- | Set the value of the “<tt>langs</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> engineScriptInfo [ #langs <a>:=</a> value ]
--   </pre>
setEngineScriptInfoLangs :: MonadIO m => EngineScriptInfo -> CString -> m ()

-- | Get the value of the “<tt>script</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> engineScriptInfo #script
--   </pre>
getEngineScriptInfoScript :: MonadIO m => EngineScriptInfo -> m Script

-- | Set the value of the “<tt>script</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> engineScriptInfo [ #script <a>:=</a> value ]
--   </pre>
setEngineScriptInfoScript :: MonadIO m => EngineScriptInfo -> Script -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.EngineScriptInfo.EngineScriptInfo
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.EngineScriptInfo.EngineScriptInfo tag


-- | The <a>AttrFontDesc</a> structure is used to store an attribute that
--   sets all aspects of the font description at once.
module GI.Pango.Structs.AttrFontDesc

-- | Memory-managed wrapper type.
newtype AttrFontDesc
AttrFontDesc :: ManagedPtr AttrFontDesc -> AttrFontDesc

-- | Construct a <a>AttrFontDesc</a> struct initialized to zero.
newZeroAttrFontDesc :: MonadIO m => m AttrFontDesc

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrFontDesc</a>.
noAttrFontDesc :: Maybe AttrFontDesc

-- | Create a new font description attribute. This attribute allows setting
--   family, style, weight, variant, stretch, and size simultaneously.
attrFontDescNew :: (HasCallStack, MonadIO m) => FontDescription -> m Attribute

-- | Get the value of the “<tt>attr</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrFontDesc #attr
--   </pre>
getAttrFontDescAttr :: MonadIO m => AttrFontDesc -> m Attribute

-- | Set the value of the “<tt>desc</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #desc
--   </pre>
clearAttrFontDescDesc :: MonadIO m => AttrFontDesc -> m ()

-- | Get the value of the “<tt>desc</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrFontDesc #desc
--   </pre>
getAttrFontDescDesc :: MonadIO m => AttrFontDesc -> m (Maybe FontDescription)

-- | Set the value of the “<tt>desc</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrFontDesc [ #desc <a>:=</a> value ]
--   </pre>
setAttrFontDescDesc :: MonadIO m => AttrFontDesc -> Ptr FontDescription -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrFontDesc.AttrFontDesc
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrFontDesc.AttrFontDesc tag


-- | The <a>FontFace</a> structure is used to represent a group of fonts
--   with the same family, slant, weight, width, but varying sizes.
module GI.Pango.Objects.FontFace

-- | Memory-managed wrapper type.
newtype FontFace
FontFace :: ManagedPtr FontFace -> FontFace

-- | Type class for types which can be safely cast to <a>FontFace</a>, for
--   instance with <a>toFontFace</a>.
class (GObject o, IsDescendantOf FontFace o) => IsFontFace o

-- | Cast to <a>FontFace</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toFontFace :: (MonadIO m, IsFontFace o) => o -> m FontFace

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>FontFace</a>.
noFontFace :: Maybe FontFace

-- | Returns the family, style, variant, weight and stretch of a
--   <a>FontFace</a>. The size field of the resulting font description will
--   be unset.
fontFaceDescribe :: (HasCallStack, MonadIO m, IsFontFace a) => a -> m FontDescription

-- | Gets a name representing the style of this face among the different
--   faces in the <a>FontFamily</a> for the face. This name is unique among
--   all faces in the family and is suitable for displaying to users.
fontFaceGetFaceName :: (HasCallStack, MonadIO m, IsFontFace a) => a -> m Text

-- | Returns whether a <a>FontFace</a> is synthesized by the underlying
--   font rendering engine from another face, perhaps by shearing,
--   emboldening, or lightening it.
--   
--   <i>Since: 1.18</i>
fontFaceIsSynthesized :: (HasCallStack, MonadIO m, IsFontFace a) => a -> m Bool

-- | List the available sizes for a font. This is only applicable to bitmap
--   fonts. For scalable fonts, stores <a>Nothing</a> at the location
--   pointed to by <i><tt>sizes</tt></i> and 0 at the location pointed to
--   by <i><tt>nSizes</tt></i>. The sizes returned are in Pango units and
--   are sorted in ascending order.
--   
--   <i>Since: 1.4</i>
fontFaceListSizes :: (HasCallStack, MonadIO m, IsFontFace a) => a -> m (Maybe [Int32])
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.FontFace.FontFace o) => GI.Pango.Objects.FontFace.IsFontFace o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontFace.FontFace
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.FontFace.FontFace


-- | The <a>FontDescription</a> structure represents the description of an
--   ideal font. These structures are used both to list what fonts are
--   available on the system and also for specifying the characteristics of
--   a font to load.
module GI.Pango.Structs.FontDescription

-- | Memory-managed wrapper type.
newtype FontDescription
FontDescription :: ManagedPtr FontDescription -> FontDescription

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>FontDescription</a>.
noFontDescription :: Maybe FontDescription

-- | Determines if the style attributes of <i><tt>newMatch</tt></i> are a
--   closer match for <i><tt>desc</tt></i> than those of
--   <i><tt>oldMatch</tt></i> are, or if <i><tt>oldMatch</tt></i> is
--   <a>Nothing</a>, determines if <i><tt>newMatch</tt></i> is a match at
--   all. Approximate matching is done for weight and style; other style
--   attributes must match exactly. Style attributes are all attributes
--   other than family and size-related attributes. Approximate matching
--   for style considers PANGO_STYLE_OBLIQUE and PANGO_STYLE_ITALIC as
--   matches, but not as good a match as when the styles are equal.
--   
--   Note that <i><tt>oldMatch</tt></i> must match <i><tt>desc</tt></i>.
fontDescriptionBetterMatch :: (HasCallStack, MonadIO m) => FontDescription -> Maybe FontDescription -> FontDescription -> m Bool

-- | Make a copy of a <a>FontDescription</a>.
fontDescriptionCopy :: (HasCallStack, MonadIO m) => FontDescription -> m (Maybe FontDescription)

-- | Like <a>fontDescriptionCopy</a>, but only a shallow copy is made of
--   the family name and other allocated fields. The result can only be
--   used until <i><tt>desc</tt></i> is modified or freed. This is meant to
--   be used when the copy is only needed temporarily.
fontDescriptionCopyStatic :: (HasCallStack, MonadIO m) => FontDescription -> m (Maybe FontDescription)

-- | Compares two font descriptions for equality. Two font descriptions are
--   considered equal if the fonts they describe are provably identical.
--   This means that their masks do not have to match, as long as other
--   fields are all the same. (Two font descriptions may result in
--   identical fonts being loaded, but still compare <a>False</a>.)
fontDescriptionEqual :: (HasCallStack, MonadIO m) => FontDescription -> FontDescription -> m Bool

-- | Frees a font description.
fontDescriptionFree :: (HasCallStack, MonadIO m) => FontDescription -> m ()

-- | Creates a new font description from a string representation in the
--   form "[FAMILY-LIST] [STYLE-OPTIONS] [SIZE]", where FAMILY-LIST is a
--   comma separated list of families optionally terminated by a comma,
--   STYLE_OPTIONS is a whitespace separated list of words where each word
--   describes one of style, variant, weight, stretch, or gravity, and SIZE
--   is a decimal number (size in points) or optionally followed by the
--   unit modifier "px" for absolute size. Any one of the options may be
--   absent. If FAMILY-LIST is absent, then the family_name field of the
--   resulting font description will be initialized to <a>Nothing</a>. If
--   STYLE-OPTIONS is missing, then all style options will be set to the
--   default values. If SIZE is missing, the size in the resulting font
--   description will be set to 0.
fontDescriptionFromString :: (HasCallStack, MonadIO m) => Text -> m FontDescription

-- | Gets the family name field of a font description. See
--   <a>fontDescriptionSetFamily</a>.
fontDescriptionGetFamily :: (HasCallStack, MonadIO m) => FontDescription -> m (Maybe Text)

-- | Gets the gravity field of a font description. See
--   <a>fontDescriptionSetGravity</a>.
--   
--   <i>Since: 1.16</i>
fontDescriptionGetGravity :: (HasCallStack, MonadIO m) => FontDescription -> m Gravity

-- | Determines which fields in a font description have been set.
fontDescriptionGetSetFields :: (HasCallStack, MonadIO m) => FontDescription -> m [FontMask]

-- | Gets the size field of a font description. See
--   <a>fontDescriptionSetSize</a>.
fontDescriptionGetSize :: (HasCallStack, MonadIO m) => FontDescription -> m Int32

-- | Determines whether the size of the font is in points (not absolute) or
--   device units (absolute). See <a>fontDescriptionSetSize</a> and
--   <a>fontDescriptionSetAbsoluteSize</a>.
--   
--   <i>Since: 1.8</i>
fontDescriptionGetSizeIsAbsolute :: (HasCallStack, MonadIO m) => FontDescription -> m Bool

-- | Gets the stretch field of a font description. See
--   <a>fontDescriptionSetStretch</a>.
fontDescriptionGetStretch :: (HasCallStack, MonadIO m) => FontDescription -> m Stretch

-- | Gets the style field of a <a>FontDescription</a>. See
--   <a>fontDescriptionSetStyle</a>.
fontDescriptionGetStyle :: (HasCallStack, MonadIO m) => FontDescription -> m Style

-- | Gets the variant field of a <a>FontDescription</a>. See
--   <a>fontDescriptionSetVariant</a>.
fontDescriptionGetVariant :: (HasCallStack, MonadIO m) => FontDescription -> m Variant

-- | Gets the variations field of a font description. See
--   <a>fontDescriptionSetVariations</a>.
--   
--   <i>Since: 1.42</i>
fontDescriptionGetVariations :: (HasCallStack, MonadIO m) => FontDescription -> m (Maybe Text)

-- | Gets the weight field of a font description. See
--   <a>fontDescriptionSetWeight</a>.
fontDescriptionGetWeight :: (HasCallStack, MonadIO m) => FontDescription -> m Weight

-- | Computes a hash of a <a>FontDescription</a> structure suitable to be
--   used, for example, as an argument to
--   <tt><i>g_hash_table_new()</i></tt>. The hash value is independent of
--   <i><tt>desc</tt></i>-&gt;mask.
fontDescriptionHash :: (HasCallStack, MonadIO m) => FontDescription -> m Word32

-- | Merges the fields that are set in <i><tt>descToMerge</tt></i> into the
--   fields in <i><tt>desc</tt></i>. If <i><tt>replaceExisting</tt></i> is
--   <a>False</a>, only fields in <i><tt>desc</tt></i> that are not already
--   set are affected. If <a>True</a>, then fields that are already set
--   will be replaced as well.
--   
--   If <i><tt>descToMerge</tt></i> is <a>Nothing</a>, this function
--   performs nothing.
fontDescriptionMerge :: (HasCallStack, MonadIO m) => FontDescription -> Maybe FontDescription -> Bool -> m ()

-- | Like <a>fontDescriptionMerge</a>, but only a shallow copy is made of
--   the family name and other allocated fields. <i><tt>desc</tt></i> can
--   only be used until <i><tt>descToMerge</tt></i> is modified or freed.
--   This is meant to be used when the merged font description is only
--   needed temporarily.
fontDescriptionMergeStatic :: (HasCallStack, MonadIO m) => FontDescription -> FontDescription -> Bool -> m ()

-- | Creates a new font description structure with all fields unset.
fontDescriptionNew :: (HasCallStack, MonadIO m) => m FontDescription

-- | Sets the size field of a font description, in device units. This is
--   mutually exclusive with <a>fontDescriptionSetSize</a> which sets the
--   font size in points.
--   
--   <i>Since: 1.8</i>
fontDescriptionSetAbsoluteSize :: (HasCallStack, MonadIO m) => FontDescription -> Double -> m ()

-- | Sets the family name field of a font description. The family name
--   represents a family of related font styles, and will resolve to a
--   particular <a>FontFamily</a>. In some uses of <a>FontDescription</a>,
--   it is also possible to use a comma separated list of family names for
--   this field.
fontDescriptionSetFamily :: (HasCallStack, MonadIO m) => FontDescription -> Text -> m ()

-- | Like <a>fontDescriptionSetFamily</a>, except that no copy of
--   <i><tt>family</tt></i> is made. The caller must make sure that the
--   string passed in stays around until <i><tt>desc</tt></i> has been
--   freed or the name is set again. This function can be used if
--   <i><tt>family</tt></i> is a static string such as a C string literal,
--   or if <i><tt>desc</tt></i> is only needed temporarily.
fontDescriptionSetFamilyStatic :: (HasCallStack, MonadIO m) => FontDescription -> Text -> m ()

-- | Sets the gravity field of a font description. The gravity field
--   specifies how the glyphs should be rotated. If <i><tt>gravity</tt></i>
--   is <a>GravityAuto</a>, this actually unsets the gravity mask on the
--   font description.
--   
--   This function is seldom useful to the user. Gravity should normally be
--   set on a <a>Context</a>.
--   
--   <i>Since: 1.16</i>
fontDescriptionSetGravity :: (HasCallStack, MonadIO m) => FontDescription -> Gravity -> m ()

-- | Sets the size field of a font description in fractional points. This
--   is mutually exclusive with <a>fontDescriptionSetAbsoluteSize</a>.
fontDescriptionSetSize :: (HasCallStack, MonadIO m) => FontDescription -> Int32 -> m ()

-- | Sets the stretch field of a font description. The stretch field
--   specifies how narrow or wide the font should be.
fontDescriptionSetStretch :: (HasCallStack, MonadIO m) => FontDescription -> Stretch -> m ()

-- | Sets the style field of a <a>FontDescription</a>. The <a>Style</a>
--   enumeration describes whether the font is slanted and the manner in
--   which it is slanted; it can be either
--   <tt><i>PANGO_STYLE_NORMAL</i></tt>,
--   <tt><i>PANGO_STYLE_ITALIC</i></tt>, or
--   <tt><i>PANGO_STYLE_OBLIQUE</i></tt>. Most fonts will either have a
--   italic style or an oblique style, but not both, and font matching in
--   Pango will match italic specifications with oblique fonts and
--   vice-versa if an exact match is not found.
fontDescriptionSetStyle :: (HasCallStack, MonadIO m) => FontDescription -> Style -> m ()

-- | Sets the variant field of a font description. The <a>Variant</a> can
--   either be <a>VariantNormal</a> or <a>VariantSmallCaps</a>.
fontDescriptionSetVariant :: (HasCallStack, MonadIO m) => FontDescription -> Variant -> m ()

-- | Sets the variations field of a font description. OpenType font
--   variations allow to select a font instance by specifying values for a
--   number of axes, such as width or weight.
--   
--   The format of the variations string is AXIS1=VALUE,AXIS2=VALUE...,
--   with each AXIS a 4 character tag that identifies a font axis, and each
--   VALUE a floating point number. Unknown axes are ignored, and values
--   are clamped to their allowed range.
--   
--   Pango does not currently have a way to find supported axes of a font.
--   Both harfbuzz or freetype have API for this.
--   
--   <i>Since: 1.42</i>
fontDescriptionSetVariations :: (HasCallStack, MonadIO m) => FontDescription -> Text -> m ()

-- | Like <a>fontDescriptionSetVariations</a>, except that no copy of
--   <i><tt>variations</tt></i> is made. The caller must make sure that the
--   string passed in stays around until <i><tt>desc</tt></i> has been
--   freed or the name is set again. This function can be used if
--   <i><tt>variations</tt></i> is a static string such as a C string
--   literal, or if <i><tt>desc</tt></i> is only needed temporarily.
--   
--   <i>Since: 1.42</i>
fontDescriptionSetVariationsStatic :: (HasCallStack, MonadIO m) => FontDescription -> Text -> m ()

-- | Sets the weight field of a font description. The weight field
--   specifies how bold or light the font should be. In addition to the
--   values of the <a>Weight</a> enumeration, other intermediate numeric
--   values are possible.
fontDescriptionSetWeight :: (HasCallStack, MonadIO m) => FontDescription -> Weight -> m ()

-- | Creates a filename representation of a font description. The filename
--   is identical to the result from calling
--   <a>fontDescriptionToString</a>, but with underscores instead of
--   characters that are untypical in filenames, and in lower case only.
fontDescriptionToFilename :: (HasCallStack, MonadIO m) => FontDescription -> m Text

-- | Creates a string representation of a font description. See
--   <a>fontDescriptionFromString</a> for a description of the format of
--   the string representation. The family list in the string description
--   will only have a terminating comma if the last word of the list is a
--   valid style option.
fontDescriptionToString :: (HasCallStack, MonadIO m) => FontDescription -> m Text

-- | Unsets some of the fields in a <a>FontDescription</a>. The unset
--   fields will get back to their default values.
fontDescriptionUnsetFields :: (HasCallStack, MonadIO m) => FontDescription -> [FontMask] -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.FontDescription.FontDescription


-- | A <a>Fontset</a> represents a set of <a>Font</a> to use when rendering
--   text. It is the result of resolving a <a>FontDescription</a> against a
--   particular <a>Context</a>. It has operations for finding the component
--   font for a particular Unicode character, and for finding a composite
--   set of metrics for the entire fontset.
module GI.Pango.Objects.Fontset

-- | Memory-managed wrapper type.
newtype Fontset
Fontset :: ManagedPtr Fontset -> Fontset

-- | Type class for types which can be safely cast to <a>Fontset</a>, for
--   instance with <a>toFontset</a>.
class (GObject o, IsDescendantOf Fontset o) => IsFontset o

-- | Cast to <a>Fontset</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toFontset :: (MonadIO m, IsFontset o) => o -> m Fontset

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Fontset</a>.
noFontset :: Maybe Fontset

-- | Iterates through all the fonts in a fontset, calling
--   <i><tt>func</tt></i> for each one. If <i><tt>func</tt></i> returns
--   <a>True</a>, that stops the iteration.
--   
--   <i>Since: 1.4</i>
fontsetForeach :: (HasCallStack, MonadIO m, IsFontset a) => a -> FontsetForeachFunc -> m ()

-- | Returns the font in the fontset that contains the best glyph for the
--   Unicode character <i><tt>wc</tt></i>.
fontsetGetFont :: (HasCallStack, MonadIO m, IsFontset a) => a -> Word32 -> m Font

-- | Get overall metric information for the fonts in the fontset.
fontsetGetMetrics :: (HasCallStack, MonadIO m, IsFontset a) => a -> m FontMetrics
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.Fontset.Fontset o) => GI.Pango.Objects.Fontset.IsFontset o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Fontset.Fontset
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Fontset.Fontset


-- | A <a>FontMetrics</a> structure holds the overall metric information
--   for a font (possibly restricted to a script). The fields of this
--   structure are private to implementations of a font backend. See the
--   documentation of the corresponding getters for documentation of their
--   meaning.
module GI.Pango.Structs.FontMetrics

-- | Memory-managed wrapper type.
newtype FontMetrics
FontMetrics :: ManagedPtr FontMetrics -> FontMetrics

-- | Construct a <a>FontMetrics</a> struct initialized to zero.
newZeroFontMetrics :: MonadIO m => m FontMetrics

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>FontMetrics</a>.
noFontMetrics :: Maybe FontMetrics

-- | Gets the approximate character width for a font metrics structure.
--   This is merely a representative value useful, for example, for
--   determining the initial size for a window. Actual characters in text
--   will be wider and narrower than this.
fontMetricsGetApproximateCharWidth :: (HasCallStack, MonadIO m) => FontMetrics -> m Int32

-- | Gets the approximate digit width for a font metrics structure. This is
--   merely a representative value useful, for example, for determining the
--   initial size for a window. Actual digits in text can be wider or
--   narrower than this, though this value is generally somewhat more
--   accurate than the result of <a>fontMetricsGetApproximateCharWidth</a>
--   for digits.
fontMetricsGetApproximateDigitWidth :: (HasCallStack, MonadIO m) => FontMetrics -> m Int32

-- | Gets the ascent from a font metrics structure. The ascent is the
--   distance from the baseline to the logical top of a line of text. (The
--   logical top may be above or below the top of the actual drawn ink. It
--   is necessary to lay out the text to figure where the ink will be.)
fontMetricsGetAscent :: (HasCallStack, MonadIO m) => FontMetrics -> m Int32

-- | Gets the descent from a font metrics structure. The descent is the
--   distance from the baseline to the logical bottom of a line of text.
--   (The logical bottom may be above or below the bottom of the actual
--   drawn ink. It is necessary to lay out the text to figure where the ink
--   will be.)
fontMetricsGetDescent :: (HasCallStack, MonadIO m) => FontMetrics -> m Int32

-- | Gets the suggested position to draw the strikethrough. The value
--   returned is the distance &lt;emphasis&gt;above&lt;/emphasis&gt; the
--   baseline of the top of the strikethrough.
--   
--   <i>Since: 1.6</i>
fontMetricsGetStrikethroughPosition :: (HasCallStack, MonadIO m) => FontMetrics -> m Int32

-- | Gets the suggested thickness to draw for the strikethrough.
--   
--   <i>Since: 1.6</i>
fontMetricsGetStrikethroughThickness :: (HasCallStack, MonadIO m) => FontMetrics -> m Int32

-- | Gets the suggested position to draw the underline. The value returned
--   is the distance &lt;emphasis&gt;above&lt;/emphasis&gt; the baseline of
--   the top of the underline. Since most fonts have underline positions
--   beneath the baseline, this value is typically negative.
--   
--   <i>Since: 1.6</i>
fontMetricsGetUnderlinePosition :: (HasCallStack, MonadIO m) => FontMetrics -> m Int32

-- | Gets the suggested thickness to draw for the underline.
--   
--   <i>Since: 1.6</i>
fontMetricsGetUnderlineThickness :: (HasCallStack, MonadIO m) => FontMetrics -> m Int32

-- | Creates a new <a>FontMetrics</a> structure. This is only for internal
--   use by Pango backends and there is no public way to set the fields of
--   the structure.
fontMetricsNew :: (HasCallStack, MonadIO m) => m FontMetrics

-- | Increase the reference count of a font metrics structure by one.
fontMetricsRef :: (HasCallStack, MonadIO m) => FontMetrics -> m (Maybe FontMetrics)

-- | Decrease the reference count of a font metrics structure by one. If
--   the result is zero, frees the structure and any associated memory.
fontMetricsUnref :: (HasCallStack, MonadIO m) => FontMetrics -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.FontMetrics.FontMetrics
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.FontMetrics.FontMetrics tag


-- | The <a>GlyphGeometry</a> structure contains width and positioning
--   information for a single glyph.
module GI.Pango.Structs.GlyphGeometry

-- | Memory-managed wrapper type.
newtype GlyphGeometry
GlyphGeometry :: ManagedPtr GlyphGeometry -> GlyphGeometry

-- | Construct a <a>GlyphGeometry</a> struct initialized to zero.
newZeroGlyphGeometry :: MonadIO m => m GlyphGeometry

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>GlyphGeometry</a>.
noGlyphGeometry :: Maybe GlyphGeometry

-- | Get the value of the “<tt>width</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphGeometry #width
--   </pre>
getGlyphGeometryWidth :: MonadIO m => GlyphGeometry -> m Int32

-- | Set the value of the “<tt>width</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphGeometry [ #width <a>:=</a> value ]
--   </pre>
setGlyphGeometryWidth :: MonadIO m => GlyphGeometry -> Int32 -> m ()

-- | Get the value of the “<tt>x_offset</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphGeometry #xOffset
--   </pre>
getGlyphGeometryXOffset :: MonadIO m => GlyphGeometry -> m Int32

-- | Set the value of the “<tt>x_offset</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphGeometry [ #xOffset <a>:=</a> value ]
--   </pre>
setGlyphGeometryXOffset :: MonadIO m => GlyphGeometry -> Int32 -> m ()

-- | Get the value of the “<tt>y_offset</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphGeometry #yOffset
--   </pre>
getGlyphGeometryYOffset :: MonadIO m => GlyphGeometry -> m Int32

-- | Set the value of the “<tt>y_offset</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphGeometry [ #yOffset <a>:=</a> value ]
--   </pre>
setGlyphGeometryYOffset :: MonadIO m => GlyphGeometry -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.GlyphGeometry.GlyphGeometry
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphGeometry.GlyphGeometry tag


-- | A <a>GlyphItemIter</a> is an iterator over the clusters in a
--   <a>GlyphItem</a>. The &lt;firstterm&gt;forward
--   direction&lt;/firstterm&gt; of the iterator is the logical direction
--   of text. That is, with increasing <i><tt>startIndex</tt></i> and
--   <i><tt>startChar</tt></i> values. If <i><tt>glyphItem</tt></i> is
--   right-to-left (that is, if
--   &lt;literal&gt;<i><tt>glyphItem</tt></i>-&gt;item-&gt;analysis.level&lt;/literal&gt;
--   is odd), then <i><tt>startGlyph</tt></i> decreases as the iterator
--   moves forward. Moreover, in right-to-left cases,
--   <i><tt>startGlyph</tt></i> is greater than <i><tt>endGlyph</tt></i>.
--   
--   An iterator should be initialized using either of
--   <a>glyphItemIterInitStart</a> and <a>glyphItemIterInitEnd</a>, for
--   forward and backward iteration respectively, and walked over using any
--   desired mixture of <a>glyphItemIterNextCluster</a> and
--   <a>glyphItemIterPrevCluster</a>. A common idiom for doing a forward
--   iteration over the clusters is: &lt;programlisting&gt;
--   PangoGlyphItemIter cluster_iter; gboolean have_cluster;
--   
--   for (have_cluster = pango_glyph_item_iter_init_start
--   (&amp;amp;cluster_iter, glyph_item, text); have_cluster; have_cluster
--   = pango_glyph_item_iter_next_cluster (&amp;amp;cluster_iter)) { ... }
--   &lt;/programlisting&gt;
--   
--   Note that <i><tt>text</tt></i> is the start of the text for layout,
--   which is then indexed by
--   &lt;literal&gt;<i><tt>glyphItem</tt></i>-&gt;item-&gt;offset&lt;/literal&gt;
--   to get to the text of <i><tt>glyphItem</tt></i>. The
--   <i><tt>startIndex</tt></i> and <i><tt>endIndex</tt></i> values can
--   directly index into <i><tt>text</tt></i>. The
--   <i><tt>startGlyph</tt></i>, <i><tt>endGlyph</tt></i>,
--   <i><tt>startChar</tt></i>, and <i><tt>endChar</tt></i> values however
--   are zero-based for the <i><tt>glyphItem</tt></i>. For each cluster,
--   the item pointed at by the start variables is included in the cluster
--   while the one pointed at by end variables is not.
--   
--   None of the members of a <a>GlyphItemIter</a> should be modified
--   manually.
--   
--   <i>Since: 1.22</i>
module GI.Pango.Structs.GlyphItemIter

-- | Memory-managed wrapper type.
newtype GlyphItemIter
GlyphItemIter :: ManagedPtr GlyphItemIter -> GlyphItemIter

-- | Construct a <a>GlyphItemIter</a> struct initialized to zero.
newZeroGlyphItemIter :: MonadIO m => m GlyphItemIter

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>GlyphItemIter</a>.
noGlyphItemIter :: Maybe GlyphItemIter

-- | Make a shallow copy of an existing <a>GlyphItemIter</a> structure.
--   
--   <i>Since: 1.22</i>
glyphItemIterCopy :: (HasCallStack, MonadIO m) => GlyphItemIter -> m (Maybe GlyphItemIter)

-- | Frees a <a>GlyphItemIter</a> created by <a>glyphItemIterCopy</a>.
--   
--   <i>Since: 1.22</i>
glyphItemIterFree :: (HasCallStack, MonadIO m) => GlyphItemIter -> m ()

-- | Initializes a <a>GlyphItemIter</a> structure to point to the last
--   cluster in a glyph item. See <a>GlyphItemIter</a> for details of
--   cluster orders.
--   
--   <i>Since: 1.22</i>
glyphItemIterInitEnd :: (HasCallStack, MonadIO m) => GlyphItemIter -> GlyphItem -> Text -> m Bool

-- | Initializes a <a>GlyphItemIter</a> structure to point to the first
--   cluster in a glyph item. See <a>GlyphItemIter</a> for details of
--   cluster orders.
--   
--   <i>Since: 1.22</i>
glyphItemIterInitStart :: (HasCallStack, MonadIO m) => GlyphItemIter -> GlyphItem -> Text -> m Bool

-- | Advances the iterator to the next cluster in the glyph item. See
--   <a>GlyphItemIter</a> for details of cluster orders.
--   
--   <i>Since: 1.22</i>
glyphItemIterNextCluster :: (HasCallStack, MonadIO m) => GlyphItemIter -> m Bool

-- | Moves the iterator to the preceding cluster in the glyph item. See
--   <a>GlyphItemIter</a> for details of cluster orders.
--   
--   <i>Since: 1.22</i>
glyphItemIterPrevCluster :: (HasCallStack, MonadIO m) => GlyphItemIter -> m Bool

-- | Get the value of the “<tt>end_char</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItemIter #endChar
--   </pre>
getGlyphItemIterEndChar :: MonadIO m => GlyphItemIter -> m Int32

-- | Set the value of the “<tt>end_char</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphItemIter [ #endChar <a>:=</a> value ]
--   </pre>
setGlyphItemIterEndChar :: MonadIO m => GlyphItemIter -> Int32 -> m ()

-- | Get the value of the “<tt>end_glyph</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItemIter #endGlyph
--   </pre>
getGlyphItemIterEndGlyph :: MonadIO m => GlyphItemIter -> m Int32

-- | Set the value of the “<tt>end_glyph</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphItemIter [ #endGlyph <a>:=</a> value ]
--   </pre>
setGlyphItemIterEndGlyph :: MonadIO m => GlyphItemIter -> Int32 -> m ()

-- | Get the value of the “<tt>end_index</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItemIter #endIndex
--   </pre>
getGlyphItemIterEndIndex :: MonadIO m => GlyphItemIter -> m Int32

-- | Set the value of the “<tt>end_index</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphItemIter [ #endIndex <a>:=</a> value ]
--   </pre>
setGlyphItemIterEndIndex :: MonadIO m => GlyphItemIter -> Int32 -> m ()

-- | Set the value of the “<tt>glyph_item</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #glyphItem
--   </pre>
clearGlyphItemIterGlyphItem :: MonadIO m => GlyphItemIter -> m ()

-- | Get the value of the “<tt>glyph_item</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItemIter #glyphItem
--   </pre>
getGlyphItemIterGlyphItem :: MonadIO m => GlyphItemIter -> m (Maybe GlyphItem)

-- | Set the value of the “<tt>glyph_item</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphItemIter [ #glyphItem <a>:=</a> value ]
--   </pre>
setGlyphItemIterGlyphItem :: MonadIO m => GlyphItemIter -> Ptr GlyphItem -> m ()

-- | Get the value of the “<tt>start_char</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItemIter #startChar
--   </pre>
getGlyphItemIterStartChar :: MonadIO m => GlyphItemIter -> m Int32

-- | Set the value of the “<tt>start_char</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphItemIter [ #startChar <a>:=</a> value ]
--   </pre>
setGlyphItemIterStartChar :: MonadIO m => GlyphItemIter -> Int32 -> m ()

-- | Get the value of the “<tt>start_glyph</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItemIter #startGlyph
--   </pre>
getGlyphItemIterStartGlyph :: MonadIO m => GlyphItemIter -> m Int32

-- | Set the value of the “<tt>start_glyph</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphItemIter [ #startGlyph <a>:=</a> value ]
--   </pre>
setGlyphItemIterStartGlyph :: MonadIO m => GlyphItemIter -> Int32 -> m ()

-- | Get the value of the “<tt>start_index</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItemIter #startIndex
--   </pre>
getGlyphItemIterStartIndex :: MonadIO m => GlyphItemIter -> m Int32

-- | Set the value of the “<tt>start_index</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphItemIter [ #startIndex <a>:=</a> value ]
--   </pre>
setGlyphItemIterStartIndex :: MonadIO m => GlyphItemIter -> Int32 -> m ()

-- | Set the value of the “<tt>text</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #text
--   </pre>
clearGlyphItemIterText :: MonadIO m => GlyphItemIter -> m ()

-- | Get the value of the “<tt>text</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItemIter #text
--   </pre>
getGlyphItemIterText :: MonadIO m => GlyphItemIter -> m (Maybe Text)

-- | Set the value of the “<tt>text</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphItemIter [ #text <a>:=</a> value ]
--   </pre>
setGlyphItemIterText :: MonadIO m => GlyphItemIter -> CString -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.GlyphItemIter.GlyphItemIter
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphItemIter.GlyphItemIter tag


-- | The <a>GlyphInfo</a> structure represents a single glyph together with
--   positioning information and visual attributes. It contains the
--   following fields.
module GI.Pango.Structs.GlyphInfo

-- | Memory-managed wrapper type.
newtype GlyphInfo
GlyphInfo :: ManagedPtr GlyphInfo -> GlyphInfo

-- | Construct a <a>GlyphInfo</a> struct initialized to zero.
newZeroGlyphInfo :: MonadIO m => m GlyphInfo

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>GlyphInfo</a>.
noGlyphInfo :: Maybe GlyphInfo

-- | Get the value of the “<tt>attr</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphInfo #attr
--   </pre>
getGlyphInfoAttr :: MonadIO m => GlyphInfo -> m GlyphVisAttr

-- | Get the value of the “<tt>geometry</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphInfo #geometry
--   </pre>
getGlyphInfoGeometry :: MonadIO m => GlyphInfo -> m GlyphGeometry

-- | Get the value of the “<tt>glyph</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphInfo #glyph
--   </pre>
getGlyphInfoGlyph :: MonadIO m => GlyphInfo -> m Word32

-- | Set the value of the “<tt>glyph</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphInfo [ #glyph <a>:=</a> value ]
--   </pre>
setGlyphInfoGlyph :: MonadIO m => GlyphInfo -> Word32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.GlyphInfo.GlyphInfo
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphInfo.GlyphInfo tag


-- | The PangoGlyphVisAttr is used to communicate information between the
--   shaping phase and the rendering phase. More attributes may be added in
--   the future.
module GI.Pango.Structs.GlyphVisAttr

-- | Memory-managed wrapper type.
newtype GlyphVisAttr
GlyphVisAttr :: ManagedPtr GlyphVisAttr -> GlyphVisAttr

-- | Construct a <a>GlyphVisAttr</a> struct initialized to zero.
newZeroGlyphVisAttr :: MonadIO m => m GlyphVisAttr

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>GlyphVisAttr</a>.
noGlyphVisAttr :: Maybe GlyphVisAttr

-- | Get the value of the “<tt>is_cluster_start</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphVisAttr #isClusterStart
--   </pre>
getGlyphVisAttrIsClusterStart :: MonadIO m => GlyphVisAttr -> m Word32

-- | Set the value of the “<tt>is_cluster_start</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphVisAttr [ #isClusterStart <a>:=</a> value ]
--   </pre>
setGlyphVisAttrIsClusterStart :: MonadIO m => GlyphVisAttr -> Word32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr tag


-- | The <a>IncludedModule</a> structure for a statically linked module
--   contains the functions that would otherwise be loaded from a
--   dynamically loaded module.
module GI.Pango.Structs.IncludedModule

-- | Memory-managed wrapper type.
newtype IncludedModule
IncludedModule :: ManagedPtr IncludedModule -> IncludedModule

-- | Construct a <a>IncludedModule</a> struct initialized to zero.
newZeroIncludedModule :: MonadIO m => m IncludedModule

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>IncludedModule</a>.
noIncludedModule :: Maybe IncludedModule

-- | Set the value of the “<tt>exit</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #exit
--   </pre>
clearIncludedModuleExit :: MonadIO m => IncludedModule -> m ()

-- | Get the value of the “<tt>exit</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> includedModule #exit
--   </pre>
getIncludedModuleExit :: MonadIO m => IncludedModule -> m (Maybe IncludedModuleExitFieldCallback)

-- | Set the value of the “<tt>exit</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> includedModule [ #exit <a>:=</a> value ]
--   </pre>
setIncludedModuleExit :: MonadIO m => IncludedModule -> FunPtr C_IncludedModuleExitFieldCallback -> m ()

-- | Set the value of the “<tt>init</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #init
--   </pre>
clearIncludedModuleInit :: MonadIO m => IncludedModule -> m ()

-- | Get the value of the “<tt>init</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> includedModule #init
--   </pre>
getIncludedModuleInit :: MonadIO m => IncludedModule -> m (Maybe IncludedModuleInitFieldCallback)

-- | Set the value of the “<tt>init</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> includedModule [ #init <a>:=</a> value ]
--   </pre>
setIncludedModuleInit :: MonadIO m => IncludedModule -> FunPtr C_IncludedModuleInitFieldCallback -> m ()

-- | Set the value of the “<tt>list</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #list
--   </pre>
clearIncludedModuleList :: MonadIO m => IncludedModule -> m ()

-- | Get the value of the “<tt>list</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> includedModule #list
--   </pre>
getIncludedModuleList :: MonadIO m => IncludedModule -> m (Maybe IncludedModuleListFieldCallback)

-- | Set the value of the “<tt>list</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> includedModule [ #list <a>:=</a> value ]
--   </pre>
setIncludedModuleList :: MonadIO m => IncludedModule -> FunPtr C_IncludedModuleListFieldCallback -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.IncludedModule.IncludedModule
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.IncludedModule.IncludedModule tag


-- | The <a>Item</a> structure stores information about a segment of text.
module GI.Pango.Structs.Item

-- | Memory-managed wrapper type.
newtype Item
Item :: ManagedPtr Item -> Item

-- | Construct a <a>Item</a> struct initialized to zero.
newZeroItem :: MonadIO m => m Item

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Item</a>.
noItem :: Maybe Item

-- | Copy an existing <a>Item</a> structure.
itemCopy :: (HasCallStack, MonadIO m) => Item -> m (Maybe Item)

-- | Free a <a>Item</a> and all associated memory.
itemFree :: (HasCallStack, MonadIO m) => Item -> m ()

-- | Creates a new <a>Item</a> structure initialized to default values.
itemNew :: (HasCallStack, MonadIO m) => m Item

-- | Modifies <i><tt>orig</tt></i> to cover only the text after
--   <i><tt>splitIndex</tt></i>, and returns a new item that covers the
--   text before <i><tt>splitIndex</tt></i> that used to be in
--   <i><tt>orig</tt></i>. You can think of <i><tt>splitIndex</tt></i> as
--   the length of the returned item. <i><tt>splitIndex</tt></i> may not be
--   0, and it may not be greater than or equal to the length of
--   <i><tt>orig</tt></i> (that is, there must be at least one byte
--   assigned to each item, you can't create a zero-length item).
--   <i><tt>splitOffset</tt></i> is the length of the first item in chars,
--   and must be provided because the text used to generate the item isn't
--   available, so <a>itemSplit</a> can't count the char length of the
--   split items itself.
itemSplit :: (HasCallStack, MonadIO m) => Item -> Int32 -> Int32 -> m Item

-- | Get the value of the “<tt>analysis</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> item #analysis
--   </pre>
getItemAnalysis :: MonadIO m => Item -> m Analysis

-- | Get the value of the “<tt>length</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> item #length
--   </pre>
getItemLength :: MonadIO m => Item -> m Int32

-- | Set the value of the “<tt>length</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> item [ #length <a>:=</a> value ]
--   </pre>
setItemLength :: MonadIO m => Item -> Int32 -> m ()

-- | Get the value of the “<tt>num_chars</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> item #numChars
--   </pre>
getItemNumChars :: MonadIO m => Item -> m Int32

-- | Set the value of the “<tt>num_chars</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> item [ #numChars <a>:=</a> value ]
--   </pre>
setItemNumChars :: MonadIO m => Item -> Int32 -> m ()

-- | Get the value of the “<tt>offset</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> item #offset
--   </pre>
getItemOffset :: MonadIO m => Item -> m Int32

-- | Set the value of the “<tt>offset</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> item [ #offset <a>:=</a> value ]
--   </pre>
setItemOffset :: MonadIO m => Item -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.Item.Item
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Item.Item tag


-- | The <a>AttrLanguage</a> structure is used to represent attributes that
--   are languages.
module GI.Pango.Structs.AttrLanguage

-- | Memory-managed wrapper type.
newtype AttrLanguage
AttrLanguage :: ManagedPtr AttrLanguage -> AttrLanguage

-- | Construct a <a>AttrLanguage</a> struct initialized to zero.
newZeroAttrLanguage :: MonadIO m => m AttrLanguage

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrLanguage</a>.
noAttrLanguage :: Maybe AttrLanguage

-- | Create a new language tag attribute.
attrLanguageNew :: (HasCallStack, MonadIO m) => Language -> m Attribute

-- | Get the value of the “<tt>attr</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrLanguage #attr
--   </pre>
getAttrLanguageAttr :: MonadIO m => AttrLanguage -> m Attribute

-- | Set the value of the “<tt>value</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #value
--   </pre>
clearAttrLanguageValue :: MonadIO m => AttrLanguage -> m ()

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrLanguage #value
--   </pre>
getAttrLanguageValue :: MonadIO m => AttrLanguage -> m (Maybe Language)

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrLanguage [ #value <a>:=</a> value ]
--   </pre>
setAttrLanguageValue :: MonadIO m => AttrLanguage -> Ptr Language -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrLanguage.AttrLanguage
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrLanguage.AttrLanguage tag


-- | The <a>AttrIterator</a> structure is used to represent an iterator
--   through a <a>AttrList</a>. A new iterator is created with
--   <tt><i>pango_attr_list_get_iterator()</i></tt>. Once the iterator is
--   created, it can be advanced through the style changes in the text
--   using <a>attrIteratorNext</a>. At each style change, the range of the
--   current style segment and the attributes currently in effect can be
--   queried.
module GI.Pango.Structs.AttrIterator

-- | Memory-managed wrapper type.
newtype AttrIterator
AttrIterator :: ManagedPtr AttrIterator -> AttrIterator

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrIterator</a>.
noAttrIterator :: Maybe AttrIterator

-- | Destroy a <a>AttrIterator</a> and free all associated memory.
attrIteratorDestroy :: (HasCallStack, MonadIO m) => AttrIterator -> m ()

-- | Gets a list of all attributes at the current position of the iterator.
--   
--   <i>Since: 1.2</i>
attrIteratorGetAttrs :: (HasCallStack, MonadIO m) => AttrIterator -> m [Attribute]

-- | Get the font and other attributes at the current iterator position.
attrIteratorGetFont :: (HasCallStack, MonadIO m) => AttrIterator -> FontDescription -> Maybe Language -> [Attribute] -> m ()

-- | Advance the iterator until the next change of style.
attrIteratorNext :: (HasCallStack, MonadIO m) => AttrIterator -> m Bool

-- | Get the range of the current segment. Note that the stored return
--   values are signed, not unsigned like the values in <a>Attribute</a>.
--   To deal with this API oversight, stored return values that wouldn't
--   fit into a signed integer are clamped to <tt><i>G_MAXINT</i></tt>.
attrIteratorRange :: (HasCallStack, MonadIO m) => AttrIterator -> m (Int32, Int32)
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrIterator.AttrIterator


-- | The <a>Analysis</a> structure stores information about the properties
--   of a segment of text.
module GI.Pango.Structs.Analysis

-- | Memory-managed wrapper type.
newtype Analysis
Analysis :: ManagedPtr Analysis -> Analysis

-- | Construct a <a>Analysis</a> struct initialized to zero.
newZeroAnalysis :: MonadIO m => m Analysis

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>Analysis</a>.
noAnalysis :: Maybe Analysis

-- | Set the value of the “<tt>extra_attrs</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #extraAttrs
--   </pre>
clearAnalysisExtraAttrs :: MonadIO m => Analysis -> m ()

-- | Get the value of the “<tt>extra_attrs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> analysis #extraAttrs
--   </pre>
getAnalysisExtraAttrs :: MonadIO m => Analysis -> m [Ptr ()]

-- | Set the value of the “<tt>extra_attrs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> analysis [ #extraAttrs <a>:=</a> value ]
--   </pre>
setAnalysisExtraAttrs :: MonadIO m => Analysis -> Ptr (GSList (Ptr ())) -> m ()

-- | Get the value of the “<tt>flags</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> analysis #flags
--   </pre>
getAnalysisFlags :: MonadIO m => Analysis -> m Word8

-- | Set the value of the “<tt>flags</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> analysis [ #flags <a>:=</a> value ]
--   </pre>
setAnalysisFlags :: MonadIO m => Analysis -> Word8 -> m ()

-- | Set the value of the “<tt>font</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #font
--   </pre>
clearAnalysisFont :: MonadIO m => Analysis -> m ()

-- | Get the value of the “<tt>font</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> analysis #font
--   </pre>
getAnalysisFont :: MonadIO m => Analysis -> m (Maybe Font)

-- | Set the value of the “<tt>font</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> analysis [ #font <a>:=</a> value ]
--   </pre>
setAnalysisFont :: MonadIO m => Analysis -> Ptr Font -> m ()

-- | Get the value of the “<tt>gravity</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> analysis #gravity
--   </pre>
getAnalysisGravity :: MonadIO m => Analysis -> m Word8

-- | Set the value of the “<tt>gravity</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> analysis [ #gravity <a>:=</a> value ]
--   </pre>
setAnalysisGravity :: MonadIO m => Analysis -> Word8 -> m ()

-- | Set the value of the “<tt>lang_engine</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #langEngine
--   </pre>
clearAnalysisLangEngine :: MonadIO m => Analysis -> m ()

-- | Get the value of the “<tt>lang_engine</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> analysis #langEngine
--   </pre>
getAnalysisLangEngine :: MonadIO m => Analysis -> m (Maybe EngineLang)

-- | Set the value of the “<tt>lang_engine</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> analysis [ #langEngine <a>:=</a> value ]
--   </pre>
setAnalysisLangEngine :: MonadIO m => Analysis -> Ptr EngineLang -> m ()

-- | Set the value of the “<tt>language</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #language
--   </pre>
clearAnalysisLanguage :: MonadIO m => Analysis -> m ()

-- | Get the value of the “<tt>language</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> analysis #language
--   </pre>
getAnalysisLanguage :: MonadIO m => Analysis -> m (Maybe Language)

-- | Set the value of the “<tt>language</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> analysis [ #language <a>:=</a> value ]
--   </pre>
setAnalysisLanguage :: MonadIO m => Analysis -> Ptr Language -> m ()

-- | Get the value of the “<tt>level</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> analysis #level
--   </pre>
getAnalysisLevel :: MonadIO m => Analysis -> m Word8

-- | Set the value of the “<tt>level</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> analysis [ #level <a>:=</a> value ]
--   </pre>
setAnalysisLevel :: MonadIO m => Analysis -> Word8 -> m ()

-- | Get the value of the “<tt>script</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> analysis #script
--   </pre>
getAnalysisScript :: MonadIO m => Analysis -> m Word8

-- | Set the value of the “<tt>script</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> analysis [ #script <a>:=</a> value ]
--   </pre>
setAnalysisScript :: MonadIO m => Analysis -> Word8 -> m ()

-- | Set the value of the “<tt>shape_engine</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #shapeEngine
--   </pre>
clearAnalysisShapeEngine :: MonadIO m => Analysis -> m ()

-- | Get the value of the “<tt>shape_engine</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> analysis #shapeEngine
--   </pre>
getAnalysisShapeEngine :: MonadIO m => Analysis -> m (Maybe EngineShape)

-- | Set the value of the “<tt>shape_engine</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> analysis [ #shapeEngine <a>:=</a> value ]
--   </pre>
setAnalysisShapeEngine :: MonadIO m => Analysis -> Ptr EngineShape -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.Analysis.Analysis
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Analysis.Analysis tag


-- | <a>FontsetSimple</a> is a implementation of the abstract
--   <a>Fontset</a> base class in terms of an array of fonts, which the
--   creator provides when constructing the <a>FontsetSimple</a>.
module GI.Pango.Objects.FontsetSimple

-- | Memory-managed wrapper type.
newtype FontsetSimple
FontsetSimple :: ManagedPtr FontsetSimple -> FontsetSimple

-- | Type class for types which can be safely cast to <a>FontsetSimple</a>,
--   for instance with <a>toFontsetSimple</a>.
class (GObject o, IsDescendantOf FontsetSimple o) => IsFontsetSimple o

-- | Cast to <a>FontsetSimple</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toFontsetSimple :: (MonadIO m, IsFontsetSimple o) => o -> m FontsetSimple

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>FontsetSimple</a>.
noFontsetSimple :: Maybe FontsetSimple

-- | Adds a font to the fontset.
fontsetSimpleAppend :: (HasCallStack, MonadIO m, IsFontsetSimple a, IsFont b) => a -> b -> m ()

-- | Creates a new <a>FontsetSimple</a> for the given language.
fontsetSimpleNew :: (HasCallStack, MonadIO m) => Language -> m FontsetSimple

-- | Returns the number of fonts in the fontset.
fontsetSimpleSize :: (HasCallStack, MonadIO m, IsFontsetSimple a) => a -> m Int32
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.FontsetSimple.FontsetSimple o) => GI.Pango.Objects.FontsetSimple.IsFontsetSimple o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontsetSimple.FontsetSimple
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.FontsetSimple.FontsetSimple


-- | The <a>FontMap</a> represents the set of fonts available for a
--   particular rendering system. This is a virtual object with
--   implementations being specific to particular rendering systems. To
--   create an implementation of a <a>FontMap</a>, the rendering-system
--   specific code should allocate a larger structure that contains a
--   nested <a>FontMap</a>, fill in the
--   &lt;structfield&gt;klass&lt;/structfield&gt; member of the nested
--   <a>FontMap</a> with a pointer to a appropriate <a>FontMapClass</a>,
--   then call <tt><i>pango_font_map_init()</i></tt> on the structure.
--   
--   The <a>FontMap</a> structure contains one member which the
--   implementation fills in.
module GI.Pango.Objects.FontMap

-- | Memory-managed wrapper type.
newtype FontMap
FontMap :: ManagedPtr FontMap -> FontMap

-- | Type class for types which can be safely cast to <a>FontMap</a>, for
--   instance with <a>toFontMap</a>.
class (GObject o, IsDescendantOf FontMap o) => IsFontMap o

-- | Cast to <a>FontMap</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toFontMap :: (MonadIO m, IsFontMap o) => o -> m FontMap

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>FontMap</a>.
noFontMap :: Maybe FontMap

-- | Forces a change in the context, which will cause any <a>Context</a>
--   using this fontmap to change.
--   
--   This function is only useful when implementing a new backend for
--   Pango, something applications won't do. Backends should call this
--   function if they have attached extra data to the context and such data
--   is changed.
--   
--   <i>Since: 1.34</i>
fontMapChanged :: (HasCallStack, MonadIO m, IsFontMap a) => a -> m ()

-- | Creates a <a>Context</a> connected to <i><tt>fontmap</tt></i>. This is
--   equivalent to <a>contextNew</a> followed by <a>contextSetFontMap</a>.
--   
--   If you are using Pango as part of a higher-level system, that system
--   may have it's own way of create a <a>Context</a>. For instance, the
--   GTK+ toolkit has, among others,
--   <tt><i>gdk_pango_context_get_for_screen()</i></tt>, and
--   <tt><i>gtk_widget_get_pango_context()</i></tt>. Use those instead.
--   
--   <i>Since: 1.22</i>
fontMapCreateContext :: (HasCallStack, MonadIO m, IsFontMap a) => a -> m Context

-- | Returns the current serial number of <i><tt>fontmap</tt></i>. The
--   serial number is initialized to an small number larger than zero when
--   a new fontmap is created and is increased whenever the fontmap is
--   changed. It may wrap, but will never have the value 0. Since it can
--   wrap, never compare it with "less than", always use "not equals".
--   
--   The fontmap can only be changed using backend-specific API, like
--   changing fontmap resolution.
--   
--   This can be used to automatically detect changes to a <a>FontMap</a>,
--   like in <a>Context</a>.
--   
--   <i>Since: 1.32.4</i>
fontMapGetSerial :: (HasCallStack, MonadIO m, IsFontMap a) => a -> m Word32

-- | Returns the render ID for shape engines for this fontmap. See the
--   &lt;structfield&gt;render_type&lt;/structfield&gt; field of
--   <a>EngineInfo</a>.
--   
--   <i>Since: 1.4</i>

-- | <i>Deprecated: (Since version 1.38)</i>
fontMapGetShapeEngineType :: (HasCallStack, MonadIO m, IsFontMap a) => a -> m Text

-- | List all families for a fontmap.
fontMapListFamilies :: (HasCallStack, MonadIO m, IsFontMap a) => a -> m [FontFamily]

-- | Load the font in the fontmap that is the closest match for
--   <i><tt>desc</tt></i>.
fontMapLoadFont :: (HasCallStack, MonadIO m, IsFontMap a, IsContext b) => a -> b -> FontDescription -> m (Maybe Font)

-- | Load a set of fonts in the fontmap that can be used to render a font
--   matching <i><tt>desc</tt></i>.
fontMapLoadFontset :: (HasCallStack, MonadIO m, IsFontMap a, IsContext b) => a -> b -> FontDescription -> Language -> m (Maybe Fontset)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.FontMap.FontMap o) => GI.Pango.Objects.FontMap.IsFontMap o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontMap.FontMap
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.FontMap.FontMap


-- | The <a>Language</a> structure is used to represent a language.
--   
--   <a>Language</a> pointers can be efficiently copied and compared with
--   each other.
module GI.Pango.Structs.Language

-- | Memory-managed wrapper type.
newtype Language
Language :: ManagedPtr Language -> Language

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>Language</a>.
noLanguage :: Maybe Language

-- | Take a RFC-3066 format language tag as a string and convert it to a
--   <a>Language</a> pointer that can be efficiently copied (copy the
--   pointer) and compared with other language tags (compare the pointer.)
--   
--   This function first canonicalizes the string by converting it to
--   lowercase, mapping '_' to '-', and stripping all characters other than
--   letters and '-'.
--   
--   Use <a>languageGetDefault</a> if you want to get the <a>Language</a>
--   for the current locale of the process.
languageFromString :: (HasCallStack, MonadIO m) => Maybe Text -> m (Maybe Language)

-- | Returns the <a>Language</a> for the current locale of the process.
--   Note that this can change over the life of an application.
--   
--   On Unix systems, this is the return value is derived from
--   &lt;literal&gt;setlocale(LC_CTYPE, NULL)&lt;/literal&gt;, and the user
--   can affect this through the environment variables LC_ALL, LC_CTYPE or
--   LANG (checked in that order). The locale string typically is in the
--   form lang_COUNTRY, where lang is an ISO-639 language code, and COUNTRY
--   is an ISO-3166 country code. For instance, sv_FI for Swedish as
--   written in Finland or pt_BR for Portuguese as written in Brazil.
--   
--   On Windows, the C library does not use any such environment variables,
--   and setting them won't affect the behavior of functions like
--   <tt><i>ctime()</i></tt>. The user sets the locale through the Regional
--   Options in the Control Panel. The C library (in the
--   <tt><i>setlocale()</i></tt> function) does not use country and
--   language codes, but country and language names spelled out in English.
--   However, this function does check the above environment variables, and
--   does return a Unix-style locale string based on either said
--   environment variables or the thread's current locale.
--   
--   Your application should call &lt;literal&gt;setlocale(LC_ALL,
--   "");&lt;/literal&gt; for the user settings to take effect. Gtk+ does
--   this in its initialization functions automatically (by calling
--   <tt><i>gtk_set_locale()</i></tt>). See &lt;literal&gt;man
--   setlocale&lt;/literal&gt; for more details.
--   
--   <i>Since: 1.16</i>
languageGetDefault :: (HasCallStack, MonadIO m) => m Language

-- | Get a string that is representative of the characters needed to render
--   a particular language.
--   
--   The sample text may be a pangram, but is not necessarily. It is chosen
--   to be demonstrative of normal text in the language, as well as
--   exposing font feature requirements unique to the language. It is
--   suitable for use as sample text in a font selection dialog.
--   
--   If <i><tt>language</tt></i> is <a>Nothing</a>, the default language as
--   found by <a>languageGetDefault</a> is used.
--   
--   If Pango does not have a sample string for <i><tt>language</tt></i>,
--   the classic "The quick brown fox..." is returned. This can be detected
--   by comparing the returned pointer value to that returned for
--   (non-existent) language code "xx". That is, compare to:
--   &lt;informalexample&gt;&lt;programlisting&gt;
--   pango_language_get_sample_string (pango_language_from_string ("xx"))
--   &lt;/programlisting&gt;&lt;/informalexample&gt;
languageGetSampleString :: (HasCallStack, MonadIO m) => Language -> m Text

-- | Determines if <i><tt>script</tt></i> is one of the scripts used to
--   write <i><tt>language</tt></i>. The returned value is conservative; if
--   nothing is known about the language tag <i><tt>language</tt></i>,
--   <a>True</a> will be returned, since, as far as Pango knows,
--   <i><tt>script</tt></i> might be used to write
--   <i><tt>language</tt></i>.
--   
--   This routine is used in Pango's itemization process when determining
--   if a supplied language tag is relevant to a particular section of
--   text. It probably is not useful for applications in most
--   circumstances.
--   
--   This function uses <a>languageGetScripts</a> internally.
--   
--   <i>Since: 1.4</i>
languageIncludesScript :: (HasCallStack, MonadIO m) => Language -> Script -> m Bool

-- | Checks if a language tag matches one of the elements in a list of
--   language ranges. A language tag is considered to match a range in the
--   list if the range is '*', the range is exactly the tag, or the range
--   is a prefix of the tag, and the character after it in the tag is '-'.
languageMatches :: (HasCallStack, MonadIO m) => Language -> Text -> m Bool

-- | Gets the RFC-3066 format string representing the given language tag.
languageToString :: (HasCallStack, MonadIO m) => Language -> m Text
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.Language.Language


-- | A <a>GlyphItem</a> is a pair of a <a>Item</a> and the glyphs resulting
--   from shaping the text corresponding to an item. As an example of the
--   usage of <a>GlyphItem</a>, the results of shaping text with
--   <a>Layout</a> is a list of <a>LayoutLine</a>, each of which contains a
--   list of <a>GlyphItem</a>.
module GI.Pango.Structs.GlyphItem

-- | Memory-managed wrapper type.
newtype GlyphItem
GlyphItem :: ManagedPtr GlyphItem -> GlyphItem

-- | Construct a <a>GlyphItem</a> struct initialized to zero.
newZeroGlyphItem :: MonadIO m => m GlyphItem

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>GlyphItem</a>.
noGlyphItem :: Maybe GlyphItem

-- | Splits a shaped item (PangoGlyphItem) into multiple items based on an
--   attribute list. The idea is that if you have attributes that don't
--   affect shaping, such as color or underline, to avoid affecting
--   shaping, you filter them out (<a>attrListFilter</a>), apply the
--   shaping process and then reapply them to the result using this
--   function.
--   
--   All attributes that start or end inside a cluster are applied to that
--   cluster; for instance, if half of a cluster is underlined and the
--   other-half strikethrough, then the cluster will end up with both
--   underline and strikethrough attributes. In these cases, it may happen
--   that item-&gt;extra_attrs for some of the result items can have
--   multiple attributes of the same type.
--   
--   This function takes ownership of <i><tt>glyphItem</tt></i>; it will be
--   reused as one of the elements in the list.
--   
--   <i>Since: 1.2</i>
glyphItemApplyAttrs :: (HasCallStack, MonadIO m) => GlyphItem -> Text -> AttrList -> m [GlyphItem]

-- | Make a deep copy of an existing <a>GlyphItem</a> structure.
--   
--   <i>Since: 1.20</i>
glyphItemCopy :: (HasCallStack, MonadIO m) => GlyphItem -> m (Maybe GlyphItem)

-- | Frees a <a>GlyphItem</a> and resources to which it points.
--   
--   <i>Since: 1.6</i>
glyphItemFree :: (HasCallStack, MonadIO m) => GlyphItem -> m ()

-- | Given a <a>GlyphItem</a> and the corresponding text, determine the
--   screen width corresponding to each character. When multiple characters
--   compose a single cluster, the width of the entire cluster is divided
--   equally among the characters.
--   
--   See also <a>glyphStringGetLogicalWidths</a>.
--   
--   <i>Since: 1.26</i>
glyphItemGetLogicalWidths :: (HasCallStack, MonadIO m) => GlyphItem -> Text -> [Int32] -> m ()

-- | Adds spacing between the graphemes of <i><tt>glyphItem</tt></i> to
--   give the effect of typographic letter spacing.
--   
--   <i>Since: 1.6</i>
glyphItemLetterSpace :: (HasCallStack, MonadIO m) => GlyphItem -> Text -> [LogAttr] -> Int32 -> m ()

-- | Modifies <i><tt>orig</tt></i> to cover only the text after
--   <i><tt>splitIndex</tt></i>, and returns a new item that covers the
--   text before <i><tt>splitIndex</tt></i> that used to be in
--   <i><tt>orig</tt></i>. You can think of <i><tt>splitIndex</tt></i> as
--   the length of the returned item. <i><tt>splitIndex</tt></i> may not be
--   0, and it may not be greater than or equal to the length of
--   <i><tt>orig</tt></i> (that is, there must be at least one byte
--   assigned to each item, you can't create a zero-length item).
--   
--   This function is similar in function to <a>itemSplit</a> (and uses it
--   internally.)
--   
--   <i>Since: 1.2</i>
glyphItemSplit :: (HasCallStack, MonadIO m) => GlyphItem -> Text -> Int32 -> m GlyphItem

-- | Set the value of the “<tt>glyphs</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #glyphs
--   </pre>
clearGlyphItemGlyphs :: MonadIO m => GlyphItem -> m ()

-- | Get the value of the “<tt>glyphs</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItem #glyphs
--   </pre>
getGlyphItemGlyphs :: MonadIO m => GlyphItem -> m (Maybe GlyphString)

-- | Set the value of the “<tt>glyphs</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphItem [ #glyphs <a>:=</a> value ]
--   </pre>
setGlyphItemGlyphs :: MonadIO m => GlyphItem -> Ptr GlyphString -> m ()

-- | Set the value of the “<tt>item</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #item
--   </pre>
clearGlyphItemItem :: MonadIO m => GlyphItem -> m ()

-- | Get the value of the “<tt>item</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItem #item
--   </pre>
getGlyphItemItem :: MonadIO m => GlyphItem -> m (Maybe Item)

-- | Set the value of the “<tt>item</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphItem [ #item <a>:=</a> value ]
--   </pre>
setGlyphItemItem :: MonadIO m => GlyphItem -> Ptr Item -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.GlyphItem.GlyphItem
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphItem.GlyphItem tag


-- | The <a>LogAttr</a> structure stores information about the attributes
--   of a single character.
module GI.Pango.Structs.LogAttr

-- | Memory-managed wrapper type.
newtype LogAttr
LogAttr :: ManagedPtr LogAttr -> LogAttr

-- | Construct a <a>LogAttr</a> struct initialized to zero.
newZeroLogAttr :: MonadIO m => m LogAttr

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>LogAttr</a>.
noLogAttr :: Maybe LogAttr

-- | Get the value of the “<tt>backspace_deletes_character</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #backspaceDeletesCharacter
--   </pre>
getLogAttrBackspaceDeletesCharacter :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>backspace_deletes_character</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #backspaceDeletesCharacter <a>:=</a> value ]
--   </pre>
setLogAttrBackspaceDeletesCharacter :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_char_break</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isCharBreak
--   </pre>
getLogAttrIsCharBreak :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_char_break</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isCharBreak <a>:=</a> value ]
--   </pre>
setLogAttrIsCharBreak :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_cursor_position</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isCursorPosition
--   </pre>
getLogAttrIsCursorPosition :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_cursor_position</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isCursorPosition <a>:=</a> value ]
--   </pre>
setLogAttrIsCursorPosition :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_expandable_space</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isExpandableSpace
--   </pre>
getLogAttrIsExpandableSpace :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_expandable_space</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isExpandableSpace <a>:=</a> value ]
--   </pre>
setLogAttrIsExpandableSpace :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_line_break</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isLineBreak
--   </pre>
getLogAttrIsLineBreak :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_line_break</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isLineBreak <a>:=</a> value ]
--   </pre>
setLogAttrIsLineBreak :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_mandatory_break</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isMandatoryBreak
--   </pre>
getLogAttrIsMandatoryBreak :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_mandatory_break</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isMandatoryBreak <a>:=</a> value ]
--   </pre>
setLogAttrIsMandatoryBreak :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_sentence_boundary</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isSentenceBoundary
--   </pre>
getLogAttrIsSentenceBoundary :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_sentence_boundary</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isSentenceBoundary <a>:=</a> value ]
--   </pre>
setLogAttrIsSentenceBoundary :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_sentence_end</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isSentenceEnd
--   </pre>
getLogAttrIsSentenceEnd :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_sentence_end</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isSentenceEnd <a>:=</a> value ]
--   </pre>
setLogAttrIsSentenceEnd :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_sentence_start</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isSentenceStart
--   </pre>
getLogAttrIsSentenceStart :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_sentence_start</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isSentenceStart <a>:=</a> value ]
--   </pre>
setLogAttrIsSentenceStart :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_white</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isWhite
--   </pre>
getLogAttrIsWhite :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_white</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isWhite <a>:=</a> value ]
--   </pre>
setLogAttrIsWhite :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_word_boundary</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isWordBoundary
--   </pre>
getLogAttrIsWordBoundary :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_word_boundary</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isWordBoundary <a>:=</a> value ]
--   </pre>
setLogAttrIsWordBoundary :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_word_end</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isWordEnd
--   </pre>
getLogAttrIsWordEnd :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_word_end</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isWordEnd <a>:=</a> value ]
--   </pre>
setLogAttrIsWordEnd :: MonadIO m => LogAttr -> Word32 -> m ()

-- | Get the value of the “<tt>is_word_start</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #isWordStart
--   </pre>
getLogAttrIsWordStart :: MonadIO m => LogAttr -> m Word32

-- | Set the value of the “<tt>is_word_start</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #isWordStart <a>:=</a> value ]
--   </pre>
setLogAttrIsWordStart :: MonadIO m => LogAttr -> Word32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.LogAttr.LogAttr
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.LogAttr.LogAttr tag


-- | <i>No description available in the introspection data.</i>
module GI.Pango.Structs.Map

-- | Memory-managed wrapper type.
newtype Map
Map :: ManagedPtr Map -> Map

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Map</a>.
noMap :: Maybe Map
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.Map.Map


-- | <i>No description available in the introspection data.</i>
module GI.Pango.Structs.MapEntry

-- | Memory-managed wrapper type.
newtype MapEntry
MapEntry :: ManagedPtr MapEntry -> MapEntry

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>MapEntry</a>.
noMapEntry :: Maybe MapEntry
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.MapEntry.MapEntry


-- | <a>Renderer</a> is a base class for objects that are used to render
--   Pango objects such as <a>GlyphString</a> and <a>Layout</a>.
--   
--   <i>Since: 1.8</i>
module GI.Pango.Objects.Renderer

-- | Memory-managed wrapper type.
newtype Renderer
Renderer :: ManagedPtr Renderer -> Renderer

-- | Type class for types which can be safely cast to <a>Renderer</a>, for
--   instance with <a>toRenderer</a>.
class (GObject o, IsDescendantOf Renderer o) => IsRenderer o

-- | Cast to <a>Renderer</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toRenderer :: (MonadIO m, IsRenderer o) => o -> m Renderer

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>Renderer</a>.
noRenderer :: Maybe Renderer

-- | Does initial setup before rendering operations on
--   <i><tt>renderer</tt></i>. <a>rendererDeactivate</a> should be called
--   when done drawing. Calls such as <a>rendererDrawLayout</a>
--   automatically activate the layout before drawing on it. Calls to
--   <a>rendererActivate</a> and <a>rendererDeactivate</a> can be nested
--   and the renderer will only be initialized and deinitialized once.
--   
--   <i>Since: 1.8</i>
rendererActivate :: (HasCallStack, MonadIO m, IsRenderer a) => a -> m ()

-- | Cleans up after rendering operations on <i><tt>renderer</tt></i>. See
--   docs for <a>rendererActivate</a>.
--   
--   <i>Since: 1.8</i>
rendererDeactivate :: (HasCallStack, MonadIO m, IsRenderer a) => a -> m ()

-- | Draw a squiggly line that approximately covers the given rectangle in
--   the style of an underline used to indicate a spelling error. (The
--   width of the underline is rounded to an integer number of up/down
--   segments and the resulting rectangle is centered in the original
--   rectangle)
--   
--   This should be called while <i><tt>renderer</tt></i> is already
--   active. Use <a>rendererActivate</a> to activate a renderer.
--   
--   <i>Since: 1.8</i>
rendererDrawErrorUnderline :: (HasCallStack, MonadIO m, IsRenderer a) => a -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws a single glyph with coordinates in device space.
--   
--   <i>Since: 1.8</i>
rendererDrawGlyph :: (HasCallStack, MonadIO m, IsRenderer a, IsFont b) => a -> b -> Word32 -> Double -> Double -> m ()

-- | Draws the glyphs in <i><tt>glyphItem</tt></i> with the specified
--   <a>Renderer</a>, embedding the text associated with the glyphs in the
--   output if the output format supports it (PDF for example).
--   
--   Note that <i><tt>text</tt></i> is the start of the text for layout,
--   which is then indexed by
--   &lt;literal&gt;<i><tt>glyphItem</tt></i>-&gt;item-&gt;offset&lt;/literal&gt;.
--   
--   If <i><tt>text</tt></i> is <a>Nothing</a>, this simply calls
--   <a>rendererDrawGlyphs</a>.
--   
--   The default implementation of this method simply falls back to
--   <a>rendererDrawGlyphs</a>.
--   
--   <i>Since: 1.22</i>
rendererDrawGlyphItem :: (HasCallStack, MonadIO m, IsRenderer a) => a -> Maybe Text -> GlyphItem -> Int32 -> Int32 -> m ()

-- | Draws the glyphs in <i><tt>glyphs</tt></i> with the specified
--   <a>Renderer</a>.
--   
--   <i>Since: 1.8</i>
rendererDrawGlyphs :: (HasCallStack, MonadIO m, IsRenderer a, IsFont b) => a -> b -> GlyphString -> Int32 -> Int32 -> m ()

-- | Draws <i><tt>layout</tt></i> with the specified <a>Renderer</a>.
--   
--   <i>Since: 1.8</i>
rendererDrawLayout :: (HasCallStack, MonadIO m, IsRenderer a, IsLayout b) => a -> b -> Int32 -> Int32 -> m ()

-- | Draws <i><tt>line</tt></i> with the specified <a>Renderer</a>.
--   
--   <i>Since: 1.8</i>
rendererDrawLayoutLine :: (HasCallStack, MonadIO m, IsRenderer a) => a -> LayoutLine -> Int32 -> Int32 -> m ()

-- | Draws an axis-aligned rectangle in user space coordinates with the
--   specified <a>Renderer</a>.
--   
--   This should be called while <i><tt>renderer</tt></i> is already
--   active. Use <a>rendererActivate</a> to activate a renderer.
--   
--   <i>Since: 1.8</i>
rendererDrawRectangle :: (HasCallStack, MonadIO m, IsRenderer a) => a -> RenderPart -> Int32 -> Int32 -> Int32 -> Int32 -> m ()

-- | Draws a trapezoid with the parallel sides aligned with the X axis
--   using the given <a>Renderer</a>; coordinates are in device space.
--   
--   <i>Since: 1.8</i>
rendererDrawTrapezoid :: (HasCallStack, MonadIO m, IsRenderer a) => a -> RenderPart -> Double -> Double -> Double -> Double -> Double -> Double -> m ()

-- | Gets the current alpha for the specified part.
--   
--   <i>Since: 1.38</i>
rendererGetAlpha :: (HasCallStack, MonadIO m, IsRenderer a) => a -> RenderPart -> m Word16

-- | Gets the current rendering color for the specified part.
--   
--   <i>Since: 1.8</i>
rendererGetColor :: (HasCallStack, MonadIO m, IsRenderer a) => a -> RenderPart -> m (Maybe Color)

-- | Gets the layout currently being rendered using
--   <i><tt>renderer</tt></i>. Calling this function only makes sense from
--   inside a subclass's methods, like in its draw_shape&lt;!----&gt;() for
--   example.
--   
--   The returned layout should not be modified while still being rendered.
--   
--   <i>Since: 1.20</i>
rendererGetLayout :: (HasCallStack, MonadIO m, IsRenderer a) => a -> m (Maybe Layout)

-- | Gets the layout line currently being rendered using
--   <i><tt>renderer</tt></i>. Calling this function only makes sense from
--   inside a subclass's methods, like in its draw_shape&lt;!----&gt;() for
--   example.
--   
--   The returned layout line should not be modified while still being
--   rendered.
--   
--   <i>Since: 1.20</i>
rendererGetLayoutLine :: (HasCallStack, MonadIO m, IsRenderer a) => a -> m (Maybe LayoutLine)

-- | Gets the transformation matrix that will be applied when rendering.
--   See <a>rendererSetMatrix</a>.
--   
--   <i>Since: 1.8</i>
rendererGetMatrix :: (HasCallStack, MonadIO m, IsRenderer a) => a -> m (Maybe Matrix)

-- | Informs Pango that the way that the rendering is done for
--   <i><tt>part</tt></i> has changed in a way that would prevent multiple
--   pieces being joined together into one drawing call. For instance, if a
--   subclass of <a>Renderer</a> was to add a stipple option for drawing
--   underlines, it needs to call
--   
--   &lt;informalexample&gt;&lt;programlisting&gt;
--   pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE);
--   &lt;/programlisting&gt;&lt;/informalexample&gt;
--   
--   When the stipple changes or underlines with different stipples might
--   be joined together. Pango automatically calls this for changes to
--   colors. (See <a>rendererSetColor</a>)
--   
--   <i>Since: 1.8</i>
rendererPartChanged :: (HasCallStack, MonadIO m, IsRenderer a) => a -> RenderPart -> m ()

-- | Sets the alpha for part of the rendering. Note that the alpha may only
--   be used if a color is specified for <i><tt>part</tt></i> as well.
--   
--   <i>Since: 1.38</i>
rendererSetAlpha :: (HasCallStack, MonadIO m, IsRenderer a) => a -> RenderPart -> Word16 -> m ()

-- | Sets the color for part of the rendering. Also see
--   <a>rendererSetAlpha</a>.
--   
--   <i>Since: 1.8</i>
rendererSetColor :: (HasCallStack, MonadIO m, IsRenderer a) => a -> RenderPart -> Maybe Color -> m ()

-- | Sets the transformation matrix that will be applied when rendering.
--   
--   <i>Since: 1.8</i>
rendererSetMatrix :: (HasCallStack, MonadIO m, IsRenderer a) => a -> Maybe Matrix -> m ()
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.Renderer.Renderer o) => GI.Pango.Objects.Renderer.IsRenderer o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Renderer.Renderer
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Renderer.Renderer


-- | The <a>Context</a> structure stores global information used to control
--   the itemization process.
module GI.Pango.Objects.Context

-- | Memory-managed wrapper type.
newtype Context
Context :: ManagedPtr Context -> Context

-- | Type class for types which can be safely cast to <a>Context</a>, for
--   instance with <a>toContext</a>.
class (GObject o, IsDescendantOf Context o) => IsContext o

-- | Cast to <a>Context</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toContext :: (MonadIO m, IsContext o) => o -> m Context

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Context</a>.
noContext :: Maybe Context

-- | Forces a change in the context, which will cause any <a>Layout</a>
--   using this context to re-layout.
--   
--   This function is only useful when implementing a new backend for
--   Pango, something applications won't do. Backends should call this
--   function if they have attached extra data to the context and such data
--   is changed.
--   
--   <i>Since: 1.32.4</i>
contextChanged :: (HasCallStack, MonadIO m, IsContext a) => a -> m ()

-- | Retrieves the base direction for the context. See
--   <a>contextSetBaseDir</a>.
contextGetBaseDir :: (HasCallStack, MonadIO m, IsContext a) => a -> m Direction

-- | Retrieves the base gravity for the context. See
--   <a>contextSetBaseGravity</a>.
--   
--   <i>Since: 1.16</i>
contextGetBaseGravity :: (HasCallStack, MonadIO m, IsContext a) => a -> m Gravity

-- | Retrieve the default font description for the context.
contextGetFontDescription :: (HasCallStack, MonadIO m, IsContext a) => a -> m FontDescription

-- | Gets the <a>FontMap</a> used to look up fonts for this context.
--   
--   <i>Since: 1.6</i>
contextGetFontMap :: (HasCallStack, MonadIO m, IsContext a) => a -> m FontMap

-- | Retrieves the gravity for the context. This is similar to
--   <a>contextGetBaseGravity</a>, except for when the base gravity is
--   <a>GravityAuto</a> for which <a>gravityGetForMatrix</a> is used to
--   return the gravity from the current context matrix.
--   
--   <i>Since: 1.16</i>
contextGetGravity :: (HasCallStack, MonadIO m, IsContext a) => a -> m Gravity

-- | Retrieves the gravity hint for the context. See
--   <a>contextSetGravityHint</a> for details.
--   
--   <i>Since: 1.16</i>
contextGetGravityHint :: (HasCallStack, MonadIO m, IsContext a) => a -> m GravityHint

-- | Retrieves the global language tag for the context.
contextGetLanguage :: (HasCallStack, MonadIO m, IsContext a) => a -> m Language

-- | Gets the transformation matrix that will be applied when rendering
--   with this context. See <a>contextSetMatrix</a>.
--   
--   <i>Since: 1.6</i>
contextGetMatrix :: (HasCallStack, MonadIO m, IsContext a) => a -> m (Maybe Matrix)

-- | Get overall metric information for a particular font description.
--   Since the metrics may be substantially different for different
--   scripts, a language tag can be provided to indicate that the metrics
--   should be retrieved that correspond to the script(s) used by that
--   language.
--   
--   The <a>FontDescription</a> is interpreted in the same way as by
--   <a>itemize</a>, and the family name may be a comma separated list of
--   figures. If characters from multiple of these families would be used
--   to render the string, then the returned fonts would be a composite of
--   the metrics for the fonts loaded for the individual families.
contextGetMetrics :: (HasCallStack, MonadIO m, IsContext a) => a -> Maybe FontDescription -> Maybe Language -> m FontMetrics

-- | Returns the current serial number of <i><tt>context</tt></i>. The
--   serial number is initialized to an small number larger than zero when
--   a new context is created and is increased whenever the context is
--   changed using any of the setter functions, or the <a>FontMap</a> it
--   uses to find fonts has changed. The serial may wrap, but will never
--   have the value 0. Since it can wrap, never compare it with "less
--   than", always use "not equals".
--   
--   This can be used to automatically detect changes to a <a>Context</a>,
--   and is only useful when implementing objects that need update when
--   their <a>Context</a> changes, like <a>Layout</a>.
--   
--   <i>Since: 1.32.4</i>
contextGetSerial :: (HasCallStack, MonadIO m, IsContext a) => a -> m Word32

-- | List all families for a context.
contextListFamilies :: (HasCallStack, MonadIO m, IsContext a) => a -> m [FontFamily]

-- | Loads the font in one of the fontmaps in the context that is the
--   closest match for <i><tt>desc</tt></i>.
contextLoadFont :: (HasCallStack, MonadIO m, IsContext a) => a -> FontDescription -> m (Maybe Font)

-- | Load a set of fonts in the context that can be used to render a font
--   matching <i><tt>desc</tt></i>.
contextLoadFontset :: (HasCallStack, MonadIO m, IsContext a) => a -> FontDescription -> Language -> m (Maybe Fontset)

-- | Creates a new <a>Context</a> initialized to default values.
--   
--   This function is not particularly useful as it should always be
--   followed by a <a>contextSetFontMap</a> call, and the function
--   <a>fontMapCreateContext</a> does these two steps together and hence
--   users are recommended to use that.
--   
--   If you are using Pango as part of a higher-level system, that system
--   may have it's own way of create a <a>Context</a>. For instance, the
--   GTK+ toolkit has, among others,
--   <tt><i>gdk_pango_context_get_for_screen()</i></tt>, and
--   <tt><i>gtk_widget_get_pango_context()</i></tt>. Use those instead.
contextNew :: (HasCallStack, MonadIO m) => m Context

-- | Sets the base direction for the context.
--   
--   The base direction is used in applying the Unicode bidirectional
--   algorithm; if the <i><tt>direction</tt></i> is <a>DirectionLtr</a> or
--   <a>DirectionRtl</a>, then the value will be used as the paragraph
--   direction in the Unicode bidirectional algorithm. A value of
--   <a>DirectionWeakLtr</a> or <a>DirectionWeakRtl</a> is used only for
--   paragraphs that do not contain any strong characters themselves.
contextSetBaseDir :: (HasCallStack, MonadIO m, IsContext a) => a -> Direction -> m ()

-- | Sets the base gravity for the context.
--   
--   The base gravity is used in laying vertical text out.
--   
--   <i>Since: 1.16</i>
contextSetBaseGravity :: (HasCallStack, MonadIO m, IsContext a) => a -> Gravity -> m ()

-- | Set the default font description for the context
contextSetFontDescription :: (HasCallStack, MonadIO m, IsContext a) => a -> FontDescription -> m ()

-- | Sets the font map to be searched when fonts are looked-up in this
--   context. This is only for internal use by Pango backends, a
--   <a>Context</a> obtained via one of the recommended methods should
--   already have a suitable font map.
contextSetFontMap :: (HasCallStack, MonadIO m, IsContext a, IsFontMap b) => a -> b -> m ()

-- | Sets the gravity hint for the context.
--   
--   The gravity hint is used in laying vertical text out, and is only
--   relevant if gravity of the context as returned by
--   <a>contextGetGravity</a> is set <a>GravityEast</a> or
--   <a>GravityWest</a>.
--   
--   <i>Since: 1.16</i>
contextSetGravityHint :: (HasCallStack, MonadIO m, IsContext a) => a -> GravityHint -> m ()

-- | Sets the global language tag for the context. The default language for
--   the locale of the running process can be found using
--   <a>languageGetDefault</a>.
contextSetLanguage :: (HasCallStack, MonadIO m, IsContext a) => a -> Language -> m ()

-- | Sets the transformation matrix that will be applied when rendering
--   with this context. Note that reported metrics are in the user space
--   coordinates before the application of the matrix, not device-space
--   coordinates after the application of the matrix. So, they don't scale
--   with the matrix, though they may change slightly for different
--   matrices, depending on how the text is fit to the pixel grid.
--   
--   <i>Since: 1.6</i>
contextSetMatrix :: (HasCallStack, MonadIO m, IsContext a) => a -> Maybe Matrix -> m ()
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.Context.Context o) => GI.Pango.Objects.Context.IsContext o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Context.Context
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Context.Context


-- | A structure specifying a transformation between user-space coordinates
--   and device coordinates. The transformation is given by
--   
--   &lt;programlisting&gt; x_device = x_user * matrix-&gt;xx + y_user *
--   matrix-&gt;xy + matrix-&gt;x0; y_device = x_user * matrix-&gt;yx +
--   y_user * matrix-&gt;yy + matrix-&gt;y0; &lt;/programlisting&gt;
--   
--   <i>Since: 1.6</i>
module GI.Pango.Structs.Matrix

-- | Memory-managed wrapper type.
newtype Matrix
Matrix :: ManagedPtr Matrix -> Matrix

-- | Construct a <a>Matrix</a> struct initialized to zero.
newZeroMatrix :: MonadIO m => m Matrix

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Matrix</a>.
noMatrix :: Maybe Matrix

-- | Changes the transformation represented by <i><tt>matrix</tt></i> to be
--   the transformation given by first applying transformation given by
--   <i><tt>newMatrix</tt></i> then applying the original transformation.
--   
--   <i>Since: 1.6</i>
matrixConcat :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> m ()

-- | Copies a <a>Matrix</a>.
--   
--   <i>Since: 1.6</i>
matrixCopy :: (HasCallStack, MonadIO m) => Matrix -> m (Maybe Matrix)

-- | Free a <a>Matrix</a> created with <a>matrixCopy</a>.
--   
--   <i>Since: 1.6</i>
matrixFree :: (HasCallStack, MonadIO m) => Matrix -> m ()

-- | Returns the scale factor of a matrix on the height of the font. That
--   is, the scale factor in the direction perpendicular to the vector that
--   the X coordinate is mapped to. If the scale in the X coordinate is
--   needed as well, use <a>matrixGetFontScaleFactors</a>.
--   
--   <i>Since: 1.12</i>
matrixGetFontScaleFactor :: (HasCallStack, MonadIO m) => Matrix -> m Double

-- | Calculates the scale factor of a matrix on the width and height of the
--   font. That is, <i><tt>xscale</tt></i> is the scale factor in the
--   direction of the X coordinate, and <i><tt>yscale</tt></i> is the scale
--   factor in the direction perpendicular to the vector that the X
--   coordinate is mapped to.
--   
--   Note that output numbers will always be non-negative.
--   
--   <i>Since: 1.38</i>
matrixGetFontScaleFactors :: (HasCallStack, MonadIO m) => Matrix -> m (Double, Double)

-- | Changes the transformation represented by <i><tt>matrix</tt></i> to be
--   the transformation given by first rotating by <i><tt>degrees</tt></i>
--   degrees counter-clockwise then applying the original transformation.
--   
--   <i>Since: 1.6</i>
matrixRotate :: (HasCallStack, MonadIO m) => Matrix -> Double -> m ()

-- | Changes the transformation represented by <i><tt>matrix</tt></i> to be
--   the transformation given by first scaling by <i><tt>sx</tt></i> in the
--   X direction and <i><tt>sy</tt></i> in the Y direction then applying
--   the original transformation.
--   
--   <i>Since: 1.6</i>
matrixScale :: (HasCallStack, MonadIO m) => Matrix -> Double -> Double -> m ()

-- | Transforms the distance vector (<i><tt>dx</tt></i>,<i><tt>dy</tt></i>)
--   by <i><tt>matrix</tt></i>. This is similar to
--   <a>matrixTransformPoint</a> except that the translation components of
--   the transformation are ignored. The calculation of the returned vector
--   is as follows:
--   
--   &lt;programlisting&gt; dx2 = dx1 * xx + dy1 * xy; dy2 = dx1 * yx + dy1
--   * yy; &lt;/programlisting&gt;
--   
--   Affine transformations are position invariant, so the same vector
--   always transforms to the same vector. If
--   (<i><tt>x1</tt></i>,<i><tt>y1</tt></i>) transforms to
--   (<i><tt>x2</tt></i>,<i><tt>y2</tt></i>) then
--   (<i><tt>x1</tt></i>+<i><tt>dx1</tt></i>,<i><tt>y1</tt></i>+<i><tt>dy1</tt></i>)
--   will transform to
--   (<i><tt>x1</tt></i>+<i><tt>dx2</tt></i>,<i><tt>y1</tt></i>+<i><tt>dy2</tt></i>)
--   for all values of <i><tt>x1</tt></i> and <i><tt>x2</tt></i>.
--   
--   <i>Since: 1.16</i>
matrixTransformDistance :: (HasCallStack, MonadIO m) => Matrix -> Double -> Double -> m (Double, Double)

-- | First transforms the <i><tt>rect</tt></i> using
--   <i><tt>matrix</tt></i>, then calculates the bounding box of the
--   transformed rectangle. The rectangle should be in device units
--   (pixels).
--   
--   This function is useful for example when you want to draw a rotated
--   <i><tt>pangoLayout</tt></i> to an image buffer, and want to know how
--   large the image should be and how much you should shift the layout
--   when rendering.
--   
--   For better accuracy, you should use <a>matrixTransformRectangle</a> on
--   original rectangle in Pango units and convert to pixels afterward
--   using 'GI.Pango.Functions.extentsToPixels'\'s first argument.
--   
--   <i>Since: 1.16</i>
matrixTransformPixelRectangle :: (HasCallStack, MonadIO m) => Matrix -> Maybe Rectangle -> m ()

-- | Transforms the point (<i><tt>x</tt></i>, <i><tt>y</tt></i>) by
--   <i><tt>matrix</tt></i>.
--   
--   <i>Since: 1.16</i>
matrixTransformPoint :: (HasCallStack, MonadIO m) => Matrix -> Double -> Double -> m (Double, Double)

-- | Changes the transformation represented by <i><tt>matrix</tt></i> to be
--   the transformation given by first translating by (<i><tt>tx</tt></i>,
--   <i><tt>ty</tt></i>) then applying the original transformation.
--   
--   <i>Since: 1.6</i>
matrixTranslate :: (HasCallStack, MonadIO m) => Matrix -> Double -> Double -> m ()

-- | Get the value of the “<tt>x0</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> matrix #x0
--   </pre>
getMatrixX0 :: MonadIO m => Matrix -> m Double

-- | Set the value of the “<tt>x0</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> matrix [ #x0 <a>:=</a> value ]
--   </pre>
setMatrixX0 :: MonadIO m => Matrix -> Double -> m ()

-- | Get the value of the “<tt>xx</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> matrix #xx
--   </pre>
getMatrixXx :: MonadIO m => Matrix -> m Double

-- | Set the value of the “<tt>xx</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> matrix [ #xx <a>:=</a> value ]
--   </pre>
setMatrixXx :: MonadIO m => Matrix -> Double -> m ()

-- | Get the value of the “<tt>xy</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> matrix #xy
--   </pre>
getMatrixXy :: MonadIO m => Matrix -> m Double

-- | Set the value of the “<tt>xy</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> matrix [ #xy <a>:=</a> value ]
--   </pre>
setMatrixXy :: MonadIO m => Matrix -> Double -> m ()

-- | Get the value of the “<tt>y0</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> matrix #y0
--   </pre>
getMatrixY0 :: MonadIO m => Matrix -> m Double

-- | Set the value of the “<tt>y0</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> matrix [ #y0 <a>:=</a> value ]
--   </pre>
setMatrixY0 :: MonadIO m => Matrix -> Double -> m ()

-- | Get the value of the “<tt>yx</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> matrix #yx
--   </pre>
getMatrixYx :: MonadIO m => Matrix -> m Double

-- | Set the value of the “<tt>yx</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> matrix [ #yx <a>:=</a> value ]
--   </pre>
setMatrixYx :: MonadIO m => Matrix -> Double -> m ()

-- | Get the value of the “<tt>yy</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> matrix #yy
--   </pre>
getMatrixYy :: MonadIO m => Matrix -> m Double

-- | Set the value of the “<tt>yy</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> matrix [ #yy <a>:=</a> value ]
--   </pre>
setMatrixYy :: MonadIO m => Matrix -> Double -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.Matrix.Matrix
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Matrix.Matrix tag


-- | The <a>LayoutLine</a> structure represents one of the lines resulting
--   from laying out a paragraph via <a>Layout</a>. <a>LayoutLine</a>
--   structures are obtained by calling <a>layoutGetLine</a> and are only
--   valid until the text, attributes, or settings of the parent
--   <a>Layout</a> are modified.
--   
--   Routines for rendering PangoLayout objects are provided in code
--   specific to each rendering system.
module GI.Pango.Structs.LayoutLine

-- | Memory-managed wrapper type.
newtype LayoutLine
LayoutLine :: ManagedPtr LayoutLine -> LayoutLine

-- | Construct a <a>LayoutLine</a> struct initialized to zero.
newZeroLayoutLine :: MonadIO m => m LayoutLine

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>LayoutLine</a>.
noLayoutLine :: Maybe LayoutLine

-- | Computes the logical and ink extents of a layout line. See
--   <a>fontGetGlyphExtents</a> for details about the interpretation of the
--   rectangles.
layoutLineGetExtents :: (HasCallStack, MonadIO m) => LayoutLine -> m (Rectangle, Rectangle)

-- | Computes the logical and ink extents of <i><tt>layoutLine</tt></i> in
--   device units. This function just calls <a>layoutLineGetExtents</a>
--   followed by two <a>extentsToPixels</a> calls, rounding
--   <i><tt>inkRect</tt></i> and <i><tt>logicalRect</tt></i> such that the
--   rounded rectangles fully contain the unrounded one (that is, passes
--   them as first argument to <a>extentsToPixels</a>).
layoutLineGetPixelExtents :: (HasCallStack, MonadIO m) => LayoutLine -> m (Rectangle, Rectangle)

-- | Gets a list of visual ranges corresponding to a given logical range.
--   This list is not necessarily minimal - there may be consecutive ranges
--   which are adjacent. The ranges will be sorted from left to right. The
--   ranges are with respect to the left edge of the entire layout, not
--   with respect to the line.
layoutLineGetXRanges :: (HasCallStack, MonadIO m) => LayoutLine -> Int32 -> Int32 -> m [Int32]

-- | Converts an index within a line to a X position.
layoutLineIndexToX :: (HasCallStack, MonadIO m) => LayoutLine -> Int32 -> Bool -> m Int32

-- | Increase the reference count of a <a>LayoutLine</a> by one.
--   
--   <i>Since: 1.10</i>
layoutLineRef :: (HasCallStack, MonadIO m) => LayoutLine -> m LayoutLine

-- | Decrease the reference count of a <a>LayoutLine</a> by one. If the
--   result is zero, the line and all associated memory will be freed.
layoutLineUnref :: (HasCallStack, MonadIO m) => LayoutLine -> m ()

-- | Converts from x offset to the byte index of the corresponding
--   character within the text of the layout. If <i><tt>xPos</tt></i> is
--   outside the line, <i><tt>index_</tt></i> and <i><tt>trailing</tt></i>
--   will point to the very first or very last position in the line. This
--   determination is based on the resolved direction of the paragraph; for
--   example, if the resolved direction is right-to-left, then an X
--   position to the right of the line (after it) results in 0 being stored
--   in <i><tt>index_</tt></i> and <i><tt>trailing</tt></i>. An X position
--   to the left of the line results in <i><tt>index_</tt></i> pointing to
--   the (logical) last grapheme in the line and <i><tt>trailing</tt></i>
--   being set to the number of characters in that grapheme. The reverse is
--   true for a left-to-right line.
layoutLineXToIndex :: (HasCallStack, MonadIO m) => LayoutLine -> Int32 -> m (Bool, Int32, Int32)

-- | Get the value of the “<tt>is_paragraph_start</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> layoutLine #isParagraphStart
--   </pre>
getLayoutLineIsParagraphStart :: MonadIO m => LayoutLine -> m Word32

-- | Set the value of the “<tt>is_paragraph_start</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> layoutLine [ #isParagraphStart <a>:=</a> value ]
--   </pre>
setLayoutLineIsParagraphStart :: MonadIO m => LayoutLine -> Word32 -> m ()

-- | Set the value of the “<tt>layout</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #layout
--   </pre>
clearLayoutLineLayout :: MonadIO m => LayoutLine -> m ()

-- | Get the value of the “<tt>layout</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> layoutLine #layout
--   </pre>
getLayoutLineLayout :: MonadIO m => LayoutLine -> m (Maybe Layout)

-- | Set the value of the “<tt>layout</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> layoutLine [ #layout <a>:=</a> value ]
--   </pre>
setLayoutLineLayout :: MonadIO m => LayoutLine -> Ptr Layout -> m ()

-- | Get the value of the “<tt>length</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> layoutLine #length
--   </pre>
getLayoutLineLength :: MonadIO m => LayoutLine -> m Int32

-- | Set the value of the “<tt>length</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> layoutLine [ #length <a>:=</a> value ]
--   </pre>
setLayoutLineLength :: MonadIO m => LayoutLine -> Int32 -> m ()

-- | Get the value of the “<tt>resolved_dir</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> layoutLine #resolvedDir
--   </pre>
getLayoutLineResolvedDir :: MonadIO m => LayoutLine -> m Word32

-- | Set the value of the “<tt>resolved_dir</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> layoutLine [ #resolvedDir <a>:=</a> value ]
--   </pre>
setLayoutLineResolvedDir :: MonadIO m => LayoutLine -> Word32 -> m ()

-- | Set the value of the “<tt>runs</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #runs
--   </pre>
clearLayoutLineRuns :: MonadIO m => LayoutLine -> m ()

-- | Get the value of the “<tt>runs</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> layoutLine #runs
--   </pre>
getLayoutLineRuns :: MonadIO m => LayoutLine -> m [GlyphItem]

-- | Set the value of the “<tt>runs</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> layoutLine [ #runs <a>:=</a> value ]
--   </pre>
setLayoutLineRuns :: MonadIO m => LayoutLine -> Ptr (GSList (Ptr GlyphItem)) -> m ()

-- | Get the value of the “<tt>start_index</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> layoutLine #startIndex
--   </pre>
getLayoutLineStartIndex :: MonadIO m => LayoutLine -> m Int32

-- | Set the value of the “<tt>start_index</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> layoutLine [ #startIndex <a>:=</a> value ]
--   </pre>
setLayoutLineStartIndex :: MonadIO m => LayoutLine -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.LayoutLine.LayoutLine
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.LayoutLine.LayoutLine tag


-- | A <a>LayoutIter</a> structure can be used to iterate over the visual
--   extents of a <a>Layout</a>.
--   
--   The <a>LayoutIter</a> structure is opaque, and has no user-visible
--   fields.
module GI.Pango.Structs.LayoutIter

-- | Memory-managed wrapper type.
newtype LayoutIter
LayoutIter :: ManagedPtr LayoutIter -> LayoutIter

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>LayoutIter</a>.
noLayoutIter :: Maybe LayoutIter

-- | Determines whether <i><tt>iter</tt></i> is on the last line of the
--   layout.
layoutIterAtLastLine :: (HasCallStack, MonadIO m) => LayoutIter -> m Bool

-- | Copies a <a>LayoutIter</a>.
--   
--   <i>Since: 1.20</i>
layoutIterCopy :: (HasCallStack, MonadIO m) => LayoutIter -> m (Maybe LayoutIter)

-- | Frees an iterator that's no longer in use.
layoutIterFree :: (HasCallStack, MonadIO m) => LayoutIter -> m ()

-- | Gets the Y position of the current line's baseline, in layout
--   coordinates (origin at top left of the entire layout).
layoutIterGetBaseline :: (HasCallStack, MonadIO m) => LayoutIter -> m Int32

-- | Gets the extents of the current character, in layout coordinates
--   (origin is the top left of the entire layout). Only logical extents
--   can sensibly be obtained for characters; ink extents make sense only
--   down to the level of clusters.
layoutIterGetCharExtents :: (HasCallStack, MonadIO m) => LayoutIter -> m Rectangle

-- | Gets the extents of the current cluster, in layout coordinates (origin
--   is the top left of the entire layout).
layoutIterGetClusterExtents :: (HasCallStack, MonadIO m) => LayoutIter -> m (Rectangle, Rectangle)

-- | Gets the current byte index. Note that iterating forward by char moves
--   in visual order, not logical order, so indexes may not be sequential.
--   Also, the index may be equal to the length of the text in the layout,
--   if on the <a>Nothing</a> run (see <a>layoutIterGetRun</a>).
layoutIterGetIndex :: (HasCallStack, MonadIO m) => LayoutIter -> m Int32

-- | Gets the layout associated with a <a>LayoutIter</a>.
--   
--   <i>Since: 1.20</i>
layoutIterGetLayout :: (HasCallStack, MonadIO m) => LayoutIter -> m Layout

-- | Obtains the extents of the <a>Layout</a> being iterated over.
--   <i><tt>inkRect</tt></i> or <i><tt>logicalRect</tt></i> can be
--   <a>Nothing</a> if you aren't interested in them.
layoutIterGetLayoutExtents :: (HasCallStack, MonadIO m) => LayoutIter -> m (Rectangle, Rectangle)

-- | Gets the current line.
--   
--   Use the faster <a>layoutIterGetLineReadonly</a> if you do not plan to
--   modify the contents of the line (glyphs, glyph widths, etc.).
layoutIterGetLine :: (HasCallStack, MonadIO m) => LayoutIter -> m LayoutLine

-- | Obtains the extents of the current line. <i><tt>inkRect</tt></i> or
--   <i><tt>logicalRect</tt></i> can be <a>Nothing</a> if you aren't
--   interested in them. Extents are in layout coordinates (origin is the
--   top-left corner of the entire <a>Layout</a>). Thus the extents
--   returned by this function will be the same width/height but not at the
--   same x/y as the extents returned from <a>layoutLineGetExtents</a>.
layoutIterGetLineExtents :: (HasCallStack, MonadIO m) => LayoutIter -> m (Rectangle, Rectangle)

-- | Gets the current line for read-only access.
--   
--   This is a faster alternative to <a>layoutIterGetLine</a>, but the user
--   is not expected to modify the contents of the line (glyphs, glyph
--   widths, etc.).
--   
--   <i>Since: 1.16</i>
layoutIterGetLineReadonly :: (HasCallStack, MonadIO m) => LayoutIter -> m LayoutLine

-- | Divides the vertical space in the <a>Layout</a> being iterated over
--   between the lines in the layout, and returns the space belonging to
--   the current line. A line's range includes the line's logical extents,
--   plus half of the spacing above and below the line, if
--   <a>layoutSetSpacing</a> has been called to set layout spacing. The Y
--   positions are in layout coordinates (origin at top left of the entire
--   layout).
layoutIterGetLineYrange :: (HasCallStack, MonadIO m) => LayoutIter -> m (Int32, Int32)

-- | Gets the current run. When iterating by run, at the end of each line,
--   there's a position with a <a>Nothing</a> run, so this function can
--   return <a>Nothing</a>. The <a>Nothing</a> run at the end of each line
--   ensures that all lines have at least one run, even lines consisting of
--   only a newline.
--   
--   Use the faster <a>layoutIterGetRunReadonly</a> if you do not plan to
--   modify the contents of the run (glyphs, glyph widths, etc.).
layoutIterGetRun :: (HasCallStack, MonadIO m) => LayoutIter -> m (Maybe GlyphItem)

-- | Gets the extents of the current run in layout coordinates (origin is
--   the top left of the entire layout).
layoutIterGetRunExtents :: (HasCallStack, MonadIO m) => LayoutIter -> m (Rectangle, Rectangle)

-- | Gets the current run. When iterating by run, at the end of each line,
--   there's a position with a <a>Nothing</a> run, so this function can
--   return <a>Nothing</a>. The <a>Nothing</a> run at the end of each line
--   ensures that all lines have at least one run, even lines consisting of
--   only a newline.
--   
--   This is a faster alternative to <a>layoutIterGetRun</a>, but the user
--   is not expected to modify the contents of the run (glyphs, glyph
--   widths, etc.).
--   
--   <i>Since: 1.16</i>
layoutIterGetRunReadonly :: (HasCallStack, MonadIO m) => LayoutIter -> m (Maybe GlyphItem)

-- | Moves <i><tt>iter</tt></i> forward to the next character in visual
--   order. If <i><tt>iter</tt></i> was already at the end of the layout,
--   returns <a>False</a>.
layoutIterNextChar :: (HasCallStack, MonadIO m) => LayoutIter -> m Bool

-- | Moves <i><tt>iter</tt></i> forward to the next cluster in visual
--   order. If <i><tt>iter</tt></i> was already at the end of the layout,
--   returns <a>False</a>.
layoutIterNextCluster :: (HasCallStack, MonadIO m) => LayoutIter -> m Bool

-- | Moves <i><tt>iter</tt></i> forward to the start of the next line. If
--   <i><tt>iter</tt></i> is already on the last line, returns
--   <a>False</a>.
layoutIterNextLine :: (HasCallStack, MonadIO m) => LayoutIter -> m Bool

-- | Moves <i><tt>iter</tt></i> forward to the next run in visual order. If
--   <i><tt>iter</tt></i> was already at the end of the layout, returns
--   <a>False</a>.
layoutIterNextRun :: (HasCallStack, MonadIO m) => LayoutIter -> m Bool
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.LayoutIter.LayoutIter


-- | The <a>GlyphString</a> structure is used to store strings of glyphs
--   with geometry and visual attribute information. The storage for the
--   glyph information is owned by the structure which simplifies memory
--   management.
module GI.Pango.Structs.GlyphString

-- | Memory-managed wrapper type.
newtype GlyphString
GlyphString :: ManagedPtr GlyphString -> GlyphString

-- | Construct a <a>GlyphString</a> struct initialized to zero.
newZeroGlyphString :: MonadIO m => m GlyphString

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>GlyphString</a>.
noGlyphString :: Maybe GlyphString

-- | Copy a glyph string and associated storage.
glyphStringCopy :: (HasCallStack, MonadIO m) => GlyphString -> m (Maybe GlyphString)

-- | Compute the logical and ink extents of a glyph string. See the
--   documentation for <a>fontGetGlyphExtents</a> for details about the
--   interpretation of the rectangles.
glyphStringExtents :: (HasCallStack, MonadIO m, IsFont a) => GlyphString -> a -> m (Rectangle, Rectangle)

-- | Computes the extents of a sub-portion of a glyph string. The extents
--   are relative to the start of the glyph string range (the origin of
--   their coordinate system is at the start of the range, not at the start
--   of the entire glyph string).
glyphStringExtentsRange :: (HasCallStack, MonadIO m, IsFont a) => GlyphString -> Int32 -> Int32 -> a -> m (Rectangle, Rectangle)

-- | Free a glyph string and associated storage.
glyphStringFree :: (HasCallStack, MonadIO m) => GlyphString -> m ()

-- | Given a <a>GlyphString</a> resulting from <a>shape</a> and the
--   corresponding text, determine the screen width corresponding to each
--   character. When multiple characters compose a single cluster, the
--   width of the entire cluster is divided equally among the characters.
--   
--   See also <a>glyphItemGetLogicalWidths</a>.
glyphStringGetLogicalWidths :: (HasCallStack, MonadIO m) => GlyphString -> Text -> Int32 -> Int32 -> [Int32] -> m ()

-- | Computes the logical width of the glyph string as can also be computed
--   using <a>glyphStringExtents</a>. However, since this only computes the
--   width, it's much faster. This is in fact only a convenience function
--   that computes the sum of geometry.width for each glyph in the
--   <i><tt>glyphs</tt></i>.
--   
--   <i>Since: 1.14</i>
glyphStringGetWidth :: (HasCallStack, MonadIO m) => GlyphString -> m Int32

-- | Converts from character position to x position. (X position is
--   measured from the left edge of the run). Character positions are
--   computed by dividing up each cluster into equal portions.
glyphStringIndexToX :: (HasCallStack, MonadIO m) => GlyphString -> Text -> Int32 -> Analysis -> Int32 -> Bool -> m Int32

-- | Create a new <a>GlyphString</a>.
glyphStringNew :: (HasCallStack, MonadIO m) => m GlyphString

-- | Resize a glyph string to the given length.
glyphStringSetSize :: (HasCallStack, MonadIO m) => GlyphString -> Int32 -> m ()

-- | Convert from x offset to character position. Character positions are
--   computed by dividing up each cluster into equal portions. In scripts
--   where positioning within a cluster is not allowed (such as Thai), the
--   returned value may not be a valid cursor position; the caller must
--   combine the result with the logical attributes for the text to compute
--   the valid cursor position.
glyphStringXToIndex :: (HasCallStack, MonadIO m) => GlyphString -> Text -> Int32 -> Analysis -> Int32 -> m (Int32, Int32)

-- | Get the value of the “<tt>log_clusters</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphString #logClusters
--   </pre>
getGlyphStringLogClusters :: MonadIO m => GlyphString -> m Int32

-- | Set the value of the “<tt>log_clusters</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphString [ #logClusters <a>:=</a> value ]
--   </pre>
setGlyphStringLogClusters :: MonadIO m => GlyphString -> Int32 -> m ()

-- | Get the value of the “<tt>num_glyphs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphString #numGlyphs
--   </pre>
getGlyphStringNumGlyphs :: MonadIO m => GlyphString -> m Int32

-- | Set the value of the “<tt>num_glyphs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphString [ #numGlyphs <a>:=</a> value ]
--   </pre>
setGlyphStringNumGlyphs :: MonadIO m => GlyphString -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.GlyphString.GlyphString
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphString.GlyphString tag


-- | The <a>AttrShape</a> structure is used to represent attributes which
--   impose shape restrictions.
module GI.Pango.Structs.AttrShape

-- | Memory-managed wrapper type.
newtype AttrShape
AttrShape :: ManagedPtr AttrShape -> AttrShape

-- | Construct a <a>AttrShape</a> struct initialized to zero.
newZeroAttrShape :: MonadIO m => m AttrShape

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrShape</a>.
noAttrShape :: Maybe AttrShape

-- | Create a new shape attribute. A shape is used to impose a particular
--   ink and logical rectangle on the result of shaping a particular glyph.
--   This might be used, for instance, for embedding a picture or a widget
--   inside a <a>Layout</a>.
attrShapeNew :: (HasCallStack, MonadIO m) => Rectangle -> Rectangle -> m Attribute

-- | Get the value of the “<tt>attr</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrShape #attr
--   </pre>
getAttrShapeAttr :: MonadIO m => AttrShape -> m Attribute

-- | Set the value of the “<tt>copy_func</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #copyFunc
--   </pre>
clearAttrShapeCopyFunc :: MonadIO m => AttrShape -> m ()

-- | Get the value of the “<tt>copy_func</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrShape #copyFunc
--   </pre>
getAttrShapeCopyFunc :: MonadIO m => AttrShape -> m (Maybe AttrDataCopyFunc_WithClosures)

-- | Set the value of the “<tt>copy_func</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrShape [ #copyFunc <a>:=</a> value ]
--   </pre>
setAttrShapeCopyFunc :: MonadIO m => AttrShape -> FunPtr C_AttrDataCopyFunc -> m ()

-- | Set the value of the “<tt>data</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #data
--   </pre>
clearAttrShapeData :: MonadIO m => AttrShape -> m ()

-- | Get the value of the “<tt>data</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrShape #data
--   </pre>
getAttrShapeData :: MonadIO m => AttrShape -> m (Ptr ())

-- | Set the value of the “<tt>data</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrShape [ #data <a>:=</a> value ]
--   </pre>
setAttrShapeData :: MonadIO m => AttrShape -> Ptr () -> m ()

-- | Set the value of the “<tt>destroy_func</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #destroyFunc
--   </pre>
clearAttrShapeDestroyFunc :: MonadIO m => AttrShape -> m ()

-- | Get the value of the “<tt>destroy_func</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrShape #destroyFunc
--   </pre>
getAttrShapeDestroyFunc :: MonadIO m => AttrShape -> m (Maybe DestroyNotify)

-- | Set the value of the “<tt>destroy_func</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> attrShape [ #destroyFunc <a>:=</a> value ]
--   </pre>
setAttrShapeDestroyFunc :: MonadIO m => AttrShape -> FunPtr C_DestroyNotify -> m ()

-- | Get the value of the “<tt>ink_rect</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrShape #inkRect
--   </pre>
getAttrShapeInkRect :: MonadIO m => AttrShape -> m Rectangle

-- | Get the value of the “<tt>logical_rect</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> attrShape #logicalRect
--   </pre>
getAttrShapeLogicalRect :: MonadIO m => AttrShape -> m Rectangle
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrShape.AttrShape
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrShape.AttrShape tag


-- | The <a>Font</a> structure is used to represent a font in a
--   rendering-system-independent matter. To create an implementation of a
--   <a>Font</a>, the rendering-system specific code should allocate a
--   larger structure that contains a nested <a>Font</a>, fill in the
--   &lt;structfield&gt;klass&lt;/structfield&gt; member of the nested
--   <a>Font</a> with a pointer to a appropriate <a>FontClass</a>, then
--   call <tt><i>pango_font_init()</i></tt> on the structure.
--   
--   The <a>Font</a> structure contains one member which the implementation
--   fills in.
module GI.Pango.Objects.Font

-- | Memory-managed wrapper type.
newtype Font
Font :: ManagedPtr Font -> Font

-- | Type class for types which can be safely cast to <a>Font</a>, for
--   instance with <a>toFont</a>.
class (GObject o, IsDescendantOf Font o) => IsFont o

-- | Cast to <a>Font</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toFont :: (MonadIO m, IsFont o) => o -> m Font

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Font</a>.
noFont :: Maybe Font

-- | Returns a description of the font, with font size set in points. Use
--   <a>fontDescribeWithAbsoluteSize</a> if you want the font size in
--   device units.
fontDescribe :: (HasCallStack, MonadIO m, IsFont a) => a -> m FontDescription

-- | Returns a description of the font, with absolute font size set (in
--   device units). Use <a>fontDescribe</a> if you want the font size in
--   points.
--   
--   <i>Since: 1.14</i>
fontDescribeWithAbsoluteSize :: (HasCallStack, MonadIO m, IsFont a) => a -> m FontDescription

-- | Frees an array of font descriptions.
fontDescriptionsFree :: (HasCallStack, MonadIO m) => Maybe [FontDescription] -> m ()

-- | Finds the best matching shaper for a font for a particular language
--   tag and character point.
fontFindShaper :: (HasCallStack, MonadIO m, IsFont a) => a -> Language -> Word32 -> m EngineShape

-- | Gets the font map for which the font was created.
--   
--   Note that the font maintains a &lt;firstterm&gt;weak&lt;/firstterm&gt;
--   reference to the font map, so if all references to font map are
--   dropped, the font map will be finalized even if there are fonts
--   created with the font map that are still alive. In that case this
--   function will return <a>Nothing</a>. It is the responsibility of the
--   user to ensure that the font map is kept alive. In most uses this is
--   not an issue as a <a>Context</a> holds a reference to the font map.
--   
--   <i>Since: 1.10</i>
fontGetFontMap :: (HasCallStack, MonadIO m, IsFont a) => a -> m (Maybe FontMap)

-- | Gets the logical and ink extents of a glyph within a font. The
--   coordinate system for each rectangle has its origin at the base line
--   and horizontal origin of the character with increasing coordinates
--   extending to the right and down. The macros
--   <tt><i>PANGO_ASCENT()</i></tt>, <tt><i>PANGO_DESCENT()</i></tt>,
--   <tt><i>PANGO_LBEARING()</i></tt>, and <tt><i>PANGO_RBEARING()</i></tt>
--   can be used to convert from the extents rectangle to more traditional
--   font metrics. The units of the rectangles are in 1/PANGO_SCALE of a
--   device unit.
--   
--   If <i><tt>font</tt></i> is <a>Nothing</a>, this function gracefully
--   sets some sane values in the output variables and returns.
fontGetGlyphExtents :: (HasCallStack, MonadIO m, IsFont a) => a -> Word32 -> m (Rectangle, Rectangle)

-- | Gets overall metric information for a font. Since the metrics may be
--   substantially different for different scripts, a language tag can be
--   provided to indicate that the metrics should be retrieved that
--   correspond to the script(s) used by that language.
--   
--   If <i><tt>font</tt></i> is <a>Nothing</a>, this function gracefully
--   sets some sane values in the output variables and returns.
fontGetMetrics :: (HasCallStack, MonadIO m, IsFont a) => a -> Maybe Language -> m FontMetrics
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.Font.Font o) => GI.Pango.Objects.Font.IsFont o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Font.Font
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Font.Font


module GI.Pango.Functions

-- | Create a new background alpha attribute.
--   
--   <i>Since: 1.38</i>
attrBackgroundAlphaNew :: (HasCallStack, MonadIO m) => Word16 -> m Attribute

-- | Create a new background color attribute.
attrBackgroundNew :: (HasCallStack, MonadIO m) => Word16 -> Word16 -> Word16 -> m Attribute

-- | Create a new font fallback attribute.
--   
--   If fallback is disabled, characters will only be used from the closest
--   matching font on the system. No fallback will be done to other fonts
--   on the system that might contain the characters in the text.
--   
--   <i>Since: 1.4</i>
attrFallbackNew :: (HasCallStack, MonadIO m) => Bool -> m Attribute

-- | Create a new font family attribute.
attrFamilyNew :: (HasCallStack, MonadIO m) => Text -> m Attribute

-- | Create a new foreground alpha attribute.
--   
--   <i>Since: 1.38</i>
attrForegroundAlphaNew :: (HasCallStack, MonadIO m) => Word16 -> m Attribute

-- | Create a new foreground color attribute.
attrForegroundNew :: (HasCallStack, MonadIO m) => Word16 -> Word16 -> Word16 -> m Attribute

-- | Create a new gravity hint attribute.
--   
--   <i>Since: 1.16</i>
attrGravityHintNew :: (HasCallStack, MonadIO m) => GravityHint -> m Attribute

-- | Create a new gravity attribute.
--   
--   <i>Since: 1.16</i>
attrGravityNew :: (HasCallStack, MonadIO m) => Gravity -> m Attribute

-- | Create a new letter-spacing attribute.
--   
--   <i>Since: 1.6</i>
attrLetterSpacingNew :: (HasCallStack, MonadIO m) => Int32 -> m Attribute

-- | Create a new baseline displacement attribute.
attrRiseNew :: (HasCallStack, MonadIO m) => Int32 -> m Attribute

-- | Create a new font size scale attribute. The base font for the affected
--   text will have its size multiplied by <i><tt>scaleFactor</tt></i>.
attrScaleNew :: (HasCallStack, MonadIO m) => Double -> m Attribute

-- | Create a new font stretch attribute
attrStretchNew :: (HasCallStack, MonadIO m) => Stretch -> m Attribute

-- | Create a new strikethrough color attribute. This attribute modifies
--   the color of strikethrough lines. If not set, strikethrough lines will
--   use the foreground color.
--   
--   <i>Since: 1.8</i>
attrStrikethroughColorNew :: (HasCallStack, MonadIO m) => Word16 -> Word16 -> Word16 -> m Attribute

-- | Create a new strike-through attribute.
attrStrikethroughNew :: (HasCallStack, MonadIO m) => Bool -> m Attribute

-- | Create a new font slant style attribute.
attrStyleNew :: (HasCallStack, MonadIO m) => Style -> m Attribute

-- | Create a new underline color attribute. This attribute modifies the
--   color of underlines. If not set, underlines will use the foreground
--   color.
--   
--   <i>Since: 1.8</i>
attrUnderlineColorNew :: (HasCallStack, MonadIO m) => Word16 -> Word16 -> Word16 -> m Attribute

-- | Create a new underline-style attribute.
attrUnderlineNew :: (HasCallStack, MonadIO m) => Underline -> m Attribute

-- | Create a new font variant attribute (normal or small caps)
attrVariantNew :: (HasCallStack, MonadIO m) => Variant -> m Attribute

-- | Create a new font weight attribute.
attrWeightNew :: (HasCallStack, MonadIO m) => Weight -> m Attribute

-- | Determines possible line, word, and character breaks for a string of
--   Unicode text with a single analysis. For most purposes you may want to
--   use <a>getLogAttrs</a>.
break :: (HasCallStack, MonadIO m) => Text -> Int32 -> Analysis -> [LogAttr] -> m ()

-- | Do not use. Does not do anything.

-- | <i>Deprecated: (Since version 1.38)</i>
configKeyGet :: (HasCallStack, MonadIO m) => Text -> m Text

-- | Do not use. Does not do anything.

-- | <i>Deprecated: (Since version 1.38)</i>
configKeyGetSystem :: (HasCallStack, MonadIO m) => Text -> m Text

-- | This is the default break algorithm, used if no language engine
--   overrides it. Normally you should use <a>break</a> instead. Unlike
--   <a>break</a>, <i><tt>analysis</tt></i> can be <a>Nothing</a>, but only
--   do that if you know what you're doing. If you need an analysis to pass
--   to <a>break</a>, you need to <a>itemize</a>. In most cases however you
--   should simply use <a>getLogAttrs</a>.
defaultBreak :: (HasCallStack, MonadIO m) => Text -> Int32 -> Maybe Analysis -> LogAttr -> Int32 -> m ()

-- | Converts extents from Pango units to device units, dividing by the
--   <a>SCALE</a> factor and performing rounding.
--   
--   The <i><tt>inclusive</tt></i> rectangle is converted by flooring the
--   x/y coordinates and extending width/height, such that the final
--   rectangle completely includes the original rectangle.
--   
--   The <i><tt>nearest</tt></i> rectangle is converted by rounding the
--   coordinates of the rectangle to the nearest device unit (pixel).
--   
--   The rule to which argument to use is: if you want the resulting
--   device-space rectangle to completely contain the original rectangle,
--   pass it in as <i><tt>inclusive</tt></i>. If you want two
--   touching-but-not-overlapping rectangles stay
--   touching-but-not-overlapping after rounding to device units, pass them
--   in as <i><tt>nearest</tt></i>.
--   
--   <i>Since: 1.16</i>
extentsToPixels :: (HasCallStack, MonadIO m) => Maybe Rectangle -> Maybe Rectangle -> m ()

-- | Searches a string the first character that has a strong direction,
--   according to the Unicode bidirectional algorithm.
--   
--   <i>Since: 1.4</i>
findBaseDir :: (HasCallStack, MonadIO m) => Text -> Int32 -> m Direction

-- | Locates a paragraph boundary in <i><tt>text</tt></i>. A boundary is
--   caused by delimiter characters, such as a newline, carriage return,
--   carriage return-newline pair, or Unicode paragraph separator
--   character. The index of the run of delimiters is returned in
--   <i><tt>paragraphDelimiterIndex</tt></i>. The index of the start of the
--   paragraph (index after all delimiters) is stored in
--   <i><tt>nextParagraphStart</tt></i>.
--   
--   If no delimiters are found, both
--   <i><tt>paragraphDelimiterIndex</tt></i> and
--   <i><tt>nextParagraphStart</tt></i> are filled with the length of
--   <i><tt>text</tt></i> (an index one off the end).
findParagraphBoundary :: (HasCallStack, MonadIO m) => Text -> Int32 -> m (Int32, Int32)

-- | Returns the name of the "pango" subdirectory of LIBDIR (which is set
--   at compile time).

-- | <i>Deprecated: (Since version 1.38)</i>
getLibSubdirectory :: (HasCallStack, MonadIO m) => m Text

-- | Computes a <a>LogAttr</a> for each character in <i><tt>text</tt></i>.
--   The <i><tt>logAttrs</tt></i> array must have one <a>LogAttr</a> for
--   each position in <i><tt>text</tt></i>; if <i><tt>text</tt></i>
--   contains N characters, it has N+1 positions, including the last
--   position at the end of the text. <i><tt>text</tt></i> should be an
--   entire paragraph; logical attributes can't be computed without context
--   (for example you need to see spaces on either side of a word to know
--   the word is a word).
getLogAttrs :: (HasCallStack, MonadIO m) => Text -> Int32 -> Int32 -> Language -> [LogAttr] -> m ()

-- | If <i><tt>ch</tt></i> has the Unicode mirrored property and there is
--   another Unicode character that typically has a glyph that is the
--   mirror image of <i><tt>ch</tt></i>'s glyph, puts that character in the
--   address pointed to by <i><tt>mirroredCh</tt></i>.
--   
--   Use <a>unicharGetMirrorChar</a> instead; the docs for that function
--   provide full details.
getMirrorChar :: (HasCallStack, MonadIO m) => Char -> Char -> m Bool

-- | Returns the name of the "pango" subdirectory of SYSCONFDIR (which is
--   set at compile time).

-- | <i>Deprecated: (Since version 1.38)</i>
getSysconfSubdirectory :: (HasCallStack, MonadIO m) => m Text

-- | Checks <i><tt>ch</tt></i> to see if it is a character that should not
--   be normally rendered on the screen. This includes all Unicode
--   characters with "ZERO WIDTH" in their name, as well as
--   &lt;firstterm&gt;bidi&lt;/firstterm&gt; formatting characters, and a
--   few other ones. This is totally different from
--   <a>unicharIszerowidth</a> and is at best misnamed.
--   
--   <i>Since: 1.10</i>
isZeroWidth :: (HasCallStack, MonadIO m) => Char -> m Bool

-- | Breaks a piece of text into segments with consistent directional level
--   and shaping engine. Each byte of <i><tt>text</tt></i> will be
--   contained in exactly one of the items in the returned list; the
--   generated list of items will be in logical order (the start offsets of
--   the items are ascending).
--   
--   <i><tt>cachedIter</tt></i> should be an iterator over
--   <i><tt>attrs</tt></i> currently positioned at a range before or
--   containing <i><tt>startIndex</tt></i>; <i><tt>cachedIter</tt></i> will
--   be advanced to the range covering the position just after
--   <i><tt>startIndex</tt></i> + <i><tt>length</tt></i>. (i.e. if
--   itemizing in a loop, just keep passing in the same
--   <i><tt>cachedIter</tt></i>).
itemize :: (HasCallStack, MonadIO m, IsContext a) => a -> Text -> Int32 -> Int32 -> AttrList -> Maybe AttrIterator -> m [Item]

-- | Like <a>itemize</a>, but the base direction to use when computing
--   bidirectional levels (see pango_context_set_base_dir ()), is specified
--   explicitly rather than gotten from the <a>Context</a>.
--   
--   <i>Since: 1.4</i>
itemizeWithBaseDir :: (HasCallStack, MonadIO m, IsContext a) => a -> Direction -> Text -> Int32 -> Int32 -> AttrList -> Maybe AttrIterator -> m [Item]

-- | This will return the bidirectional embedding levels of the input
--   paragraph as defined by the Unicode Bidirectional Algorithm available
--   at:
--   
--   http://www.unicode.org/reports/tr9/
--   
--   If the input base direction is a weak direction, the direction of the
--   characters in the text will determine the final resolved direction.
--   
--   <i>Since: 1.4</i>
log2visGetEmbeddingLevels :: (HasCallStack, MonadIO m) => Text -> Int32 -> Direction -> m Word8

-- | Look up all user defined aliases for the alias
--   <i><tt>fontname</tt></i>. The resulting font family names will be
--   stored in <i><tt>families</tt></i>, and the number of families in
--   <i><tt>nFamilies</tt></i>.

-- | <i>Deprecated: (Since version 1.32)This function is not
--   thread-safe.</i>
lookupAliases :: (HasCallStack, MonadIO m) => Text -> m [Text]

-- | After feeding a pango markup parser some data with
--   <a>markupParseContextParse</a>, use this function to get the list of
--   pango attributes and text out of the markup. This function will not
--   free <i><tt>context</tt></i>, use <a>markupParseContextFree</a> to do
--   so.
--   
--   <i>Since: 1.31.0</i>
markupParserFinish :: (HasCallStack, MonadIO m) => MarkupParseContext -> m (AttrList, Text, Char)

-- | Parses marked-up text (see &lt;link
--   linkend="PangoMarkupFormat"&gt;markup format&lt;/link&gt;) to create a
--   plain-text string and an attribute list.
--   
--   If <i><tt>accelMarker</tt></i> is nonzero, the given character will
--   mark the character following it as an accelerator. For example,
--   <i><tt>accelMarker</tt></i> might be an ampersand or underscore. All
--   characters marked as an accelerator will receive a <a>UnderlineLow</a>
--   attribute, and the first character so marked will be returned in
--   <i><tt>accelChar</tt></i>, when calling <tt><i>finish()</i></tt>. Two
--   <i><tt>accelMarker</tt></i> characters following each other produce a
--   single literal <i><tt>accelMarker</tt></i> character.
--   
--   To feed markup to the parser, use <a>markupParseContextParse</a> on
--   the returned <a>MarkupParseContext</a>. When done with feeding markup
--   to the parser, use <a>markupParserFinish</a> to get the data out of
--   it, and then use <a>markupParseContextFree</a> to free it.
--   
--   This function is designed for applications that read pango markup from
--   streams. To simply parse a string containing pango markup, the simpler
--   <a>parseMarkup</a> API is recommended instead.
--   
--   <i>Since: 1.31.0</i>
markupParserNew :: (HasCallStack, MonadIO m) => Char -> m MarkupParseContext

-- | Do not use. Does not do anything.

-- | <i>Deprecated: (Since version 1.38)</i>
moduleRegister :: (HasCallStack, MonadIO m) => IncludedModule -> m ()

-- | Parses an enum type and stores the result in <i><tt>value</tt></i>.
--   
--   If <i><tt>str</tt></i> does not match the nick name of any of the
--   possible values for the enum and is not an integer, <a>False</a> is
--   returned, a warning is issued if <i><tt>warn</tt></i> is <a>True</a>,
--   and a string representing the list of possible values is stored in
--   <i><tt>possibleValues</tt></i>. The list is slash-separated, eg.
--   "none/start/middle/end". If failed and <i><tt>possibleValues</tt></i>
--   is not <a>Nothing</a>, returned string should be freed using
--   <a>free</a>.
--   
--   <i>Since: 1.16</i>

-- | <i>Deprecated: (Since version 1.38)</i>
parseEnum :: (HasCallStack, MonadIO m) => GType -> Maybe Text -> Bool -> m (Bool, Int32, Text)

-- | Parses marked-up text (see &lt;link
--   linkend="PangoMarkupFormat"&gt;markup format&lt;/link&gt;) to create a
--   plain-text string and an attribute list.
--   
--   If <i><tt>accelMarker</tt></i> is nonzero, the given character will
--   mark the character following it as an accelerator. For example,
--   <i><tt>accelMarker</tt></i> might be an ampersand or underscore. All
--   characters marked as an accelerator will receive a <a>UnderlineLow</a>
--   attribute, and the first character so marked will be returned in
--   <i><tt>accelChar</tt></i>. Two <i><tt>accelMarker</tt></i> characters
--   following each other produce a single literal
--   <i><tt>accelMarker</tt></i> character.
--   
--   To parse a stream of pango markup incrementally, use
--   <a>markupParserNew</a>.
--   
--   If any error happens, none of the output arguments are touched except
--   for <i><tt>error</tt></i>.
parseMarkup :: (HasCallStack, MonadIO m) => Text -> Int32 -> Char -> m (AttrList, Text, Char)

-- | Quantizes the thickness and position of a line, typically an underline
--   or strikethrough, to whole device pixels, that is integer multiples of
--   <a>SCALE</a>. The purpose of this function is to avoid such lines
--   looking blurry.
--   
--   Care is taken to make sure <i><tt>thickness</tt></i> is at least one
--   pixel when this function returns, but returned
--   <i><tt>position</tt></i> may become zero as a result of rounding.
--   
--   <i>Since: 1.12</i>
quantizeLineGeometry :: (HasCallStack, MonadIO m) => Int32 -> Int32 -> m (Int32, Int32)

-- | Reads an entire line from a file into a buffer. Lines may be delimited
--   with '\n', '\r', '\n\r', or '\r\n'. The delimiter is not written into
--   the buffer. Text after a '#' character is treated as a comment and
--   skipped. '\' can be used to escape a # character. '\' proceeding a
--   line delimiter combines adjacent lines. A '\' proceeding any other
--   character is ignored and written into the output buffer unmodified.

-- | <i>Deprecated: (Since version 1.38)</i>
readLine :: (HasCallStack, MonadIO m) => Ptr () -> m (Int32, String)

-- | From a list of items in logical order and the associated directional
--   levels, produce a list in visual order. The original list is
--   unmodified.
reorderItems :: (HasCallStack, MonadIO m) => [Item] -> m [Item]

-- | Scans an integer. Leading white space is skipped.

-- | <i>Deprecated: (Since version 1.38)</i>
scanInt :: (HasCallStack, MonadIO m) => Text -> m (Bool, Text, Int32)

-- | Scans a string into a <a>String</a> buffer. The string may either be a
--   sequence of non-white-space characters, or a quoted string with '"'.
--   Instead a quoted string, '\"' represents a literal quote. Leading
--   white space outside of quotes is skipped.

-- | <i>Deprecated: (Since version 1.38)</i>
scanString :: (HasCallStack, MonadIO m) => Text -> m (Bool, Text, String)

-- | Scans a word into a <a>String</a> buffer. A word consists of [A-Za-z_]
--   followed by zero or more [A-Za-z_0-9] Leading white space is skipped.

-- | <i>Deprecated: (Since version 1.38)</i>
scanWord :: (HasCallStack, MonadIO m) => Text -> m (Bool, Text, String)

-- | Given a segment of text and the corresponding <a>Analysis</a>
--   structure returned from <a>itemize</a>, convert the characters into
--   glyphs. You may also pass in only a substring of the item from
--   <a>itemize</a>.
--   
--   It is recommended that you use <a>shapeFull</a> instead, since that
--   API allows for shaping interaction happening across text item
--   boundaries.
shape :: (HasCallStack, MonadIO m) => Text -> Int32 -> Analysis -> GlyphString -> m ()

-- | Given a segment of text and the corresponding <a>Analysis</a>
--   structure returned from <a>itemize</a>, convert the characters into
--   glyphs. You may also pass in only a substring of the item from
--   <a>itemize</a>.
--   
--   This is similar to <a>shape</a>, except it also can optionally take
--   the full paragraph text as input, which will then be used to perform
--   certain cross-item shaping interactions. If you have access to the
--   broader text of which <i><tt>itemText</tt></i> is part of, provide the
--   broader text as <i><tt>paragraphText</tt></i>. If
--   <i><tt>paragraphText</tt></i> is <a>Nothing</a>, item text is used
--   instead.
--   
--   <i>Since: 1.32</i>
shapeFull :: (HasCallStack, MonadIO m) => Text -> Int32 -> Maybe Text -> Int32 -> Analysis -> GlyphString -> m ()

-- | Skips 0 or more characters of white space.

-- | <i>Deprecated: (Since version 1.38)</i>
skipSpace :: (HasCallStack, MonadIO m) => Text -> m (Bool, Text)

-- | Splits a <a>SEARCHPATH_SEPARATOR</a>-separated list of files,
--   stripping white space and substituting ~/ with $HOME/.

-- | <i>Deprecated: (Since version 1.38)</i>
splitFileList :: (HasCallStack, MonadIO m) => Text -> m [Text]

-- | Trims leading and trailing whitespace from a string.

-- | <i>Deprecated: (Since version 1.38)</i>
trimString :: (HasCallStack, MonadIO m) => Text -> m Text

-- | Determines the inherent direction of a character; either
--   <a>DirectionLtr</a>, <a>DirectionRtl</a>, or <a>DirectionNeutral</a>.
--   
--   This function is useful to categorize characters into left-to-right
--   letters, right-to-left letters, and everything else. If full Unicode
--   bidirectional type of a character is needed, <a>bidiTypeForUnichar</a>
--   can be used instead.
unicharDirection :: (HasCallStack, MonadIO m) => Char -> m Direction

-- | Converts a floating-point number to Pango units: multiplies it by
--   <a>SCALE</a> and rounds to nearest integer.
--   
--   <i>Since: 1.16</i>
unitsFromDouble :: (HasCallStack, MonadIO m) => Double -> m Int32

-- | Converts a number in Pango units to floating-point: divides it by
--   <a>SCALE</a>.
--   
--   <i>Since: 1.16</i>
unitsToDouble :: (HasCallStack, MonadIO m) => Int32 -> m Double

-- | This is similar to the macro <tt><i>PANGO_VERSION</i></tt> except that
--   it returns the encoded version of Pango available at run-time, as
--   opposed to the version available at compile-time.
--   
--   A version number can be encoded into an integer using
--   <tt><i>PANGO_VERSION_ENCODE()</i></tt>.
--   
--   <i>Since: 1.16</i>
version :: (HasCallStack, MonadIO m) => m Int32

-- | Checks that the Pango library in use is compatible with the given
--   version. Generally you would pass in the constants
--   <tt><i>PANGO_VERSION_MAJOR</i></tt>,
--   <tt><i>PANGO_VERSION_MINOR</i></tt>,
--   <tt><i>PANGO_VERSION_MICRO</i></tt> as the three arguments to this
--   function; that produces a check that the library in use at run-time is
--   compatible with the version of Pango the application or module was
--   compiled against.
--   
--   Compatibility is defined by two things: first the version of the
--   running library is newer than the version
--   <i><tt>requiredMajor</tt></i>.required_minor.<i><tt>requiredMicro</tt></i>.
--   Second the running library must be binary compatible with the version
--   <i><tt>requiredMajor</tt></i>.required_minor.<i><tt>requiredMicro</tt></i>
--   (same major version.)
--   
--   For compile-time version checking use
--   <tt><i>PANGO_VERSION_CHECK()</i></tt>.
--   
--   <i>Since: 1.16</i>
versionCheck :: (HasCallStack, MonadIO m) => Int32 -> Int32 -> Int32 -> m (Maybe Text)

-- | This is similar to the macro <tt><i>PANGO_VERSION_STRING</i></tt>
--   except that it returns the version of Pango available at run-time, as
--   opposed to the version available at compile-time.
--   
--   <i>Since: 1.16</i>
versionString :: (HasCallStack, MonadIO m) => m Text


-- | The <a>Rectangle</a> structure represents a rectangle. It is
--   frequently used to represent the logical or ink extents of a single
--   glyph or section of text. (See, for instance,
--   <a>fontGetGlyphExtents</a>)
module GI.Pango.Structs.Rectangle

-- | Memory-managed wrapper type.
newtype Rectangle
Rectangle :: ManagedPtr Rectangle -> Rectangle

-- | Construct a <a>Rectangle</a> struct initialized to zero.
newZeroRectangle :: MonadIO m => m Rectangle

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>Rectangle</a>.
noRectangle :: Maybe Rectangle

-- | Get the value of the “<tt>height</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> rectangle #height
--   </pre>
getRectangleHeight :: MonadIO m => Rectangle -> m Int32

-- | Set the value of the “<tt>height</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> rectangle [ #height <a>:=</a> value ]
--   </pre>
setRectangleHeight :: MonadIO m => Rectangle -> Int32 -> m ()

-- | Get the value of the “<tt>width</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> rectangle #width
--   </pre>
getRectangleWidth :: MonadIO m => Rectangle -> m Int32

-- | Set the value of the “<tt>width</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> rectangle [ #width <a>:=</a> value ]
--   </pre>
setRectangleWidth :: MonadIO m => Rectangle -> Int32 -> m ()

-- | Get the value of the “<tt>x</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> rectangle #x
--   </pre>
getRectangleX :: MonadIO m => Rectangle -> m Int32

-- | Set the value of the “<tt>x</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> rectangle [ #x <a>:=</a> value ]
--   </pre>
setRectangleX :: MonadIO m => Rectangle -> Int32 -> m ()

-- | Get the value of the “<tt>y</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> rectangle #y
--   </pre>
getRectangleY :: MonadIO m => Rectangle -> m Int32

-- | Set the value of the “<tt>y</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> rectangle [ #y <a>:=</a> value ]
--   </pre>
setRectangleY :: MonadIO m => Rectangle -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.Rectangle.Rectangle
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Rectangle.Rectangle tag


-- | A <a>ScriptIter</a> is used to iterate through a string and identify
--   ranges in different scripts.
module GI.Pango.Structs.ScriptIter

-- | Memory-managed wrapper type.
newtype ScriptIter
ScriptIter :: ManagedPtr ScriptIter -> ScriptIter

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>ScriptIter</a>.
noScriptIter :: Maybe ScriptIter

-- | Frees a <a>ScriptIter</a> created with
--   <tt><i>pango_script_iter_new()</i></tt>.
--   
--   <i>Since: 1.4</i>
scriptIterFree :: (HasCallStack, MonadIO m) => ScriptIter -> m ()

-- | Gets information about the range to which <i><tt>iter</tt></i>
--   currently points. The range is the set of locations p where *start
--   &lt;= p &lt; *end. (That is, it doesn't include the character stored
--   at *end)
--   
--   <i>Since: 1.4</i>
scriptIterGetRange :: (HasCallStack, MonadIO m) => ScriptIter -> m (Text, Text, Script)

-- | Advances a <a>ScriptIter</a> to the next range. If
--   <i><tt>iter</tt></i> is already at the end, it is left unchanged and
--   <a>False</a> is returned.
--   
--   <i>Since: 1.4</i>
scriptIterNext :: (HasCallStack, MonadIO m) => ScriptIter -> m Bool
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.ScriptIter.ScriptIter


-- | The <a>Layout</a> structure represents an entire paragraph of text. It
--   is initialized with a <a>Context</a>, UTF-8 string and set of
--   attributes for that string. Once that is done, the set of formatted
--   lines can be extracted from the object, the layout can be rendered,
--   and conversion between logical character positions within the layout's
--   text, and the physical position of the resulting glyphs can be made.
--   
--   There are also a number of parameters to adjust the formatting of a
--   <a>Layout</a>, which are illustrated in &lt;xref
--   linkend="parameters"/&gt;. It is possible, as well, to ignore the 2-D
--   setup, and simply treat the results of a <a>Layout</a> as a list of
--   lines.
--   
--   &lt;figure id="parameters"&gt; &lt;title&gt;Adjustable parameters for
--   a PangoLayout&lt;/title&gt; &lt;graphic fileref="layout.gif"
--   format="GIF"&gt;&lt;/graphic&gt; &lt;/figure&gt;
--   
--   The <a>Layout</a> structure is opaque, and has no user-visible fields.
module GI.Pango.Objects.Layout

-- | Memory-managed wrapper type.
newtype Layout
Layout :: ManagedPtr Layout -> Layout

-- | Type class for types which can be safely cast to <a>Layout</a>, for
--   instance with <a>toLayout</a>.
class (GObject o, IsDescendantOf Layout o) => IsLayout o

-- | Cast to <a>Layout</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toLayout :: (MonadIO m, IsLayout o) => o -> m Layout

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Layout</a>.
noLayout :: Maybe Layout

-- | Forces recomputation of any state in the <a>Layout</a> that might
--   depend on the layout's context. This function should be called if you
--   make changes to the context subsequent to creating the layout.
layoutContextChanged :: (HasCallStack, MonadIO m, IsLayout a) => a -> m ()

-- | Does a deep copy-by-value of the <i><tt>src</tt></i> layout. The
--   attribute list, tab array, and text from the original layout are all
--   copied by value.
layoutCopy :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Layout

-- | Gets the alignment for the layout: how partial lines are positioned
--   within the horizontal space available.
layoutGetAlignment :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Alignment

-- | Gets the attribute list for the layout, if any.
layoutGetAttributes :: (HasCallStack, MonadIO m, IsLayout a) => a -> m AttrList

-- | Gets whether to calculate the bidirectional base direction for the
--   layout according to the contents of the layout. See
--   <a>layoutSetAutoDir</a>.
--   
--   <i>Since: 1.4</i>
layoutGetAutoDir :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool

-- | Gets the Y position of baseline of the first line in
--   <i><tt>layout</tt></i>.
--   
--   <i>Since: 1.22</i>
layoutGetBaseline :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32

-- | Returns the number of Unicode characters in the the text of
--   <i><tt>layout</tt></i>.
--   
--   <i>Since: 1.30</i>
layoutGetCharacterCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32

-- | Retrieves the <a>Context</a> used for this layout.
layoutGetContext :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Context

-- | Given an index within a layout, determines the positions that of the
--   strong and weak cursors if the insertion point is at that index. The
--   position of each cursor is stored as a zero-width rectangle. The
--   strong cursor location is the location where characters of the
--   directionality equal to the base direction of the layout are inserted.
--   The weak cursor location is the location where characters of the
--   directionality opposite to the base direction of the layout are
--   inserted.
layoutGetCursorPos :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Rectangle, Rectangle)

-- | Gets the type of ellipsization being performed for
--   <i><tt>layout</tt></i>. See <a>layoutSetEllipsize</a>
--   
--   <i>Since: 1.6</i>
layoutGetEllipsize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m EllipsizeMode

-- | Computes the logical and ink extents of <i><tt>layout</tt></i>.
--   Logical extents are usually what you want for positioning things. Note
--   that both extents may have non-zero x and y. You may want to use those
--   to offset where you render the layout. Not doing that is a very
--   typical bug that shows up as right-to-left layouts not being correctly
--   positioned in a layout with a set width.
--   
--   The extents are given in layout coordinates and in Pango units; layout
--   coordinates begin at the top left corner of the layout.
layoutGetExtents :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Rectangle, Rectangle)

-- | Gets the font description for the layout, if any.
--   
--   <i>Since: 1.8</i>
layoutGetFontDescription :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Maybe FontDescription)

-- | Gets the height of layout used for ellipsization. See
--   <a>layoutSetHeight</a> for details.
--   
--   <i>Since: 1.20</i>
layoutGetHeight :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32

-- | Gets the paragraph indent width in Pango units. A negative value
--   indicates a hanging indentation.
layoutGetIndent :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32

-- | Returns an iterator to iterate over the visual extents of the layout.
layoutGetIter :: (HasCallStack, MonadIO m, IsLayout a) => a -> m LayoutIter

-- | Gets whether each complete line should be stretched to fill the entire
--   width of the layout.
layoutGetJustify :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool

-- | Retrieves a particular line from a <a>Layout</a>.
--   
--   Use the faster <a>layoutGetLineReadonly</a> if you do not plan to
--   modify the contents of the line (glyphs, glyph widths, etc.).
layoutGetLine :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Maybe LayoutLine)

-- | Retrieves the count of lines for the <i><tt>layout</tt></i>.
layoutGetLineCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32

-- | Retrieves a particular line from a <a>Layout</a>.
--   
--   This is a faster alternative to <a>layoutGetLine</a>, but the user is
--   not expected to modify the contents of the line (glyphs, glyph widths,
--   etc.).
--   
--   <i>Since: 1.16</i>
layoutGetLineReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Maybe LayoutLine)

-- | Returns the lines of the <i><tt>layout</tt></i> as a list.
--   
--   Use the faster <a>layoutGetLinesReadonly</a> if you do not plan to
--   modify the contents of the lines (glyphs, glyph widths, etc.).
layoutGetLines :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LayoutLine]

-- | Returns the lines of the <i><tt>layout</tt></i> as a list.
--   
--   This is a faster alternative to <a>layoutGetLines</a>, but the user is
--   not expected to modify the contents of the lines (glyphs, glyph
--   widths, etc.).
--   
--   <i>Since: 1.16</i>
layoutGetLinesReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LayoutLine]

-- | Retrieves an array of logical attributes for each character in the
--   <i><tt>layout</tt></i>.
layoutGetLogAttrs :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LogAttr]

-- | Retrieves an array of logical attributes for each character in the
--   <i><tt>layout</tt></i>.
--   
--   This is a faster alternative to <a>layoutGetLogAttrs</a>. The returned
--   array is part of <i><tt>layout</tt></i> and must not be modified.
--   Modifying the layout will invalidate the returned array.
--   
--   The number of attributes returned in <i><tt>nAttrs</tt></i> will be
--   one more than the total number of characters in the layout, since
--   there need to be attributes corresponding to both the position before
--   the first character and the position after the last character.
--   
--   <i>Since: 1.30</i>
layoutGetLogAttrsReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LogAttr]

-- | Computes the logical and ink extents of <i><tt>layout</tt></i> in
--   device units. This function just calls <a>layoutGetExtents</a>
--   followed by two <a>extentsToPixels</a> calls, rounding
--   <i><tt>inkRect</tt></i> and <i><tt>logicalRect</tt></i> such that the
--   rounded rectangles fully contain the unrounded one (that is, passes
--   them as first argument to <a>extentsToPixels</a>).
layoutGetPixelExtents :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Rectangle, Rectangle)

-- | Determines the logical width and height of a <a>Layout</a> in device
--   units. (<a>layoutGetSize</a> returns the width and height scaled by
--   <a>SCALE</a>.) This is simply a convenience function around
--   <a>layoutGetPixelExtents</a>.
layoutGetPixelSize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Int32, Int32)

-- | Returns the current serial number of <i><tt>layout</tt></i>. The
--   serial number is initialized to an small number larger than zero when
--   a new layout is created and is increased whenever the layout is
--   changed using any of the setter functions, or the <a>Context</a> it
--   uses has changed. The serial may wrap, but will never have the value
--   0. Since it can wrap, never compare it with "less than", always use
--   "not equals".
--   
--   This can be used to automatically detect changes to a <a>Layout</a>,
--   and is useful for example to decide whether a layout needs redrawing.
--   To force the serial to be increased, use <a>layoutContextChanged</a>.
--   
--   <i>Since: 1.32.4</i>
layoutGetSerial :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Word32

-- | Obtains the value set by <a>layoutSetSingleParagraphMode</a>.
layoutGetSingleParagraphMode :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool

-- | Determines the logical width and height of a <a>Layout</a> in Pango
--   units (device units scaled by <a>SCALE</a>). This is simply a
--   convenience function around <a>layoutGetExtents</a>.
layoutGetSize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Int32, Int32)

-- | Gets the amount of spacing between the lines of the layout.
layoutGetSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32

-- | Gets the current <a>TabArray</a> used by this layout. If no
--   <a>TabArray</a> has been set, then the default tabs are in use and
--   <a>Nothing</a> is returned. Default tabs are every 8 spaces. The
--   return value should be freed with <a>tabArrayFree</a>.
layoutGetTabs :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Maybe TabArray)

-- | Gets the text in the layout. The returned text should not be freed or
--   modified.
layoutGetText :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Text

-- | Counts the number unknown glyphs in <i><tt>layout</tt></i>. That is,
--   zero if glyphs for all characters in the layout text were found, or
--   more than zero otherwise.
--   
--   This function can be used to determine if there are any fonts
--   available to render all characters in a certain string, or when used
--   in combination with <a>AttrTypeFallback</a>, to check if a certain
--   font supports all the characters in the string.
--   
--   <i>Since: 1.16</i>
layoutGetUnknownGlyphsCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32

-- | Gets the width to which the lines of the <a>Layout</a> should wrap.
layoutGetWidth :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32

-- | Gets the wrap mode for the layout.
--   
--   Use <a>layoutIsWrapped</a> to query whether any paragraphs were
--   actually wrapped.
layoutGetWrap :: (HasCallStack, MonadIO m, IsLayout a) => a -> m WrapMode

-- | Converts from byte <i><tt>index_</tt></i> within the
--   <i><tt>layout</tt></i> to line and X position. (X position is measured
--   from the left edge of the line)
layoutIndexToLineX :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> Bool -> m (Int32, Int32)

-- | Converts from an index within a <a>Layout</a> to the onscreen position
--   corresponding to the grapheme at that index, which is represented as
--   rectangle. Note that &lt;literal&gt;pos-&gt;x&lt;/literal&gt; is
--   always the leading edge of the grapheme and &lt;literal&gt;pos-&gt;x +
--   pos-&gt;width&lt;/literal&gt; the trailing edge of the grapheme. If
--   the directionality of the grapheme is right-to-left, then
--   &lt;literal&gt;pos-&gt;width&lt;/literal&gt; will be negative.
layoutIndexToPos :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m Rectangle

-- | Queries whether the layout had to ellipsize any paragraphs.
--   
--   This returns <a>True</a> if the ellipsization mode for
--   <i><tt>layout</tt></i> is not <a>EllipsizeModeNone</a>, a positive
--   width is set on <i><tt>layout</tt></i>, and there are paragraphs
--   exceeding that width that have to be ellipsized.
--   
--   <i>Since: 1.16</i>
layoutIsEllipsized :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool

-- | Queries whether the layout had to wrap any paragraphs.
--   
--   This returns <a>True</a> if a positive width is set on
--   <i><tt>layout</tt></i>, ellipsization mode of <i><tt>layout</tt></i>
--   is set to <a>EllipsizeModeNone</a>, and there are paragraphs exceeding
--   the layout width that have to be wrapped.
--   
--   <i>Since: 1.16</i>
layoutIsWrapped :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool

-- | Computes a new cursor position from an old position and a count of
--   positions to move visually. If <i><tt>direction</tt></i> is positive,
--   then the new strong cursor position will be one position to the right
--   of the old cursor position. If <i><tt>direction</tt></i> is negative,
--   then the new strong cursor position will be one position to the left
--   of the old cursor position.
--   
--   In the presence of bidirectional text, the correspondence between
--   logical and visual order will depend on the direction of the current
--   run, and there may be jumps when the cursor is moved off of the end of
--   a run.
--   
--   Motion here is in cursor positions, not in characters, so a single
--   call to <a>layoutMoveCursorVisually</a> may move the cursor over
--   multiple characters when multiple characters combine to form a single
--   grapheme.
layoutMoveCursorVisually :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> Int32 -> Int32 -> Int32 -> m (Int32, Int32)

-- | Create a new <a>Layout</a> object with attributes initialized to
--   default values for a particular <a>Context</a>.
layoutNew :: (HasCallStack, MonadIO m, IsContext a) => a -> m Layout

-- | Sets the alignment for the layout: how partial lines are positioned
--   within the horizontal space available.
layoutSetAlignment :: (HasCallStack, MonadIO m, IsLayout a) => a -> Alignment -> m ()

-- | Sets the text attributes for a layout object. References
--   <i><tt>attrs</tt></i>, so the caller can unref its reference.
layoutSetAttributes :: (HasCallStack, MonadIO m, IsLayout a) => a -> Maybe AttrList -> m ()

-- | Sets whether to calculate the bidirectional base direction for the
--   layout according to the contents of the layout; when this flag is on
--   (the default), then paragraphs in <i><tt>layout</tt></i> that begin
--   with strong right-to-left characters (Arabic and Hebrew principally),
--   will have right-to-left layout, paragraphs with letters from other
--   scripts will have left-to-right layout. Paragraphs with only neutral
--   characters get their direction from the surrounding paragraphs.
--   
--   When <a>False</a>, the choice between left-to-right and right-to-left
--   layout is done according to the base direction of the layout's
--   <a>Context</a>. (See <a>contextSetBaseDir</a>).
--   
--   When the auto-computed direction of a paragraph differs from the base
--   direction of the context, the interpretation of <a>AlignmentLeft</a>
--   and <a>AlignmentRight</a> are swapped.
--   
--   <i>Since: 1.4</i>
layoutSetAutoDir :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()

-- | Sets the type of ellipsization being performed for
--   <i><tt>layout</tt></i>. Depending on the ellipsization mode
--   <i><tt>ellipsize</tt></i> text is removed from the start, middle, or
--   end of text so they fit within the width and height of layout set with
--   <a>layoutSetWidth</a> and <a>layoutSetHeight</a>.
--   
--   If the layout contains characters such as newlines that force it to be
--   layed out in multiple paragraphs, then whether each paragraph is
--   ellipsized separately or the entire layout is ellipsized as a whole
--   depends on the set height of the layout. See <a>layoutSetHeight</a>
--   for details.
--   
--   <i>Since: 1.6</i>
layoutSetEllipsize :: (HasCallStack, MonadIO m, IsLayout a) => a -> EllipsizeMode -> m ()

-- | Sets the default font description for the layout. If no font
--   description is set on the layout, the font description from the
--   layout's context is used.
layoutSetFontDescription :: (HasCallStack, MonadIO m, IsLayout a) => a -> Maybe FontDescription -> m ()

-- | Sets the height to which the <a>Layout</a> should be ellipsized at.
--   There are two different behaviors, based on whether
--   <i><tt>height</tt></i> is positive or negative.
--   
--   If <i><tt>height</tt></i> is positive, it will be the maximum height
--   of the layout. Only lines would be shown that would fit, and if there
--   is any text omitted, an ellipsis added. At least one line is included
--   in each paragraph regardless of how small the height value is. A value
--   of zero will render exactly one line for the entire layout.
--   
--   If <i><tt>height</tt></i> is negative, it will be the (negative of)
--   maximum number of lines per paragraph. That is, the total number of
--   lines shown may well be more than this value if the layout contains
--   multiple paragraphs of text. The default value of -1 means that first
--   line of each paragraph is ellipsized. This behvaior may be changed in
--   the future to act per layout instead of per paragraph. File a bug
--   against pango at &lt;ulink
--   url="http://bugzilla.gnome.org/"&gt;http://bugzilla.gnome.org/&lt;/ulink&gt;
--   if your code relies on this behavior.
--   
--   Height setting only has effect if a positive width is set on
--   <i><tt>layout</tt></i> and ellipsization mode of
--   <i><tt>layout</tt></i> is not <a>EllipsizeModeNone</a>. The behavior
--   is undefined if a height other than -1 is set and ellipsization mode
--   is set to <a>EllipsizeModeNone</a>, and may change in the future.
--   
--   <i>Since: 1.20</i>
layoutSetHeight :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()

-- | Sets the width in Pango units to indent each paragraph. A negative
--   value of <i><tt>indent</tt></i> will produce a hanging indentation.
--   That is, the first line will have the full width, and subsequent lines
--   will be indented by the absolute value of <i><tt>indent</tt></i>.
--   
--   The indent setting is ignored if layout alignment is set to
--   <a>AlignmentCenter</a>.
layoutSetIndent :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()

-- | Sets whether each complete line should be stretched to fill the entire
--   width of the layout. This stretching is typically done by adding
--   whitespace, but for some scripts (such as Arabic), the justification
--   may be done in more complex ways, like extending the characters.
--   
--   Note that this setting is not implemented and so is ignored in Pango
--   older than 1.18.
layoutSetJustify :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()

-- | Same as <a>layoutSetMarkupWithAccel</a>, but the markup text isn't
--   scanned for accelerators.
layoutSetMarkup :: (HasCallStack, MonadIO m, IsLayout a) => a -> Text -> Int32 -> m ()

-- | If <i><tt>setting</tt></i> is <a>True</a>, do not treat newlines and
--   similar characters as paragraph separators; instead, keep all text in
--   a single paragraph, and display a glyph for paragraph separator
--   characters. Used when you want to allow editing of newlines on a
--   single text line.
layoutSetSingleParagraphMode :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()

-- | Sets the amount of spacing in Pango unit between the lines of the
--   layout.
layoutSetSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()

-- | Sets the tabs to use for <i><tt>layout</tt></i>, overriding the
--   default tabs (by default, tabs are every 8 spaces). If
--   <i><tt>tabs</tt></i> is <a>Nothing</a>, the default tabs are
--   reinstated. <i><tt>tabs</tt></i> is copied into the layout; you must
--   free your copy of <i><tt>tabs</tt></i> yourself.
layoutSetTabs :: (HasCallStack, MonadIO m, IsLayout a) => a -> Maybe TabArray -> m ()

-- | Sets the text of the layout.
--   
--   Note that if you have used <a>layoutSetMarkup</a> or
--   <a>layoutSetMarkupWithAccel</a> on <i><tt>layout</tt></i> before, you
--   may want to call <a>layoutSetAttributes</a> to clear the attributes
--   set on the layout from the markup as this function does not clear
--   attributes.
layoutSetText :: (HasCallStack, MonadIO m, IsLayout a) => a -> Text -> Int32 -> m ()

-- | Sets the width to which the lines of the <a>Layout</a> should wrap or
--   ellipsized. The default value is -1: no width set.
layoutSetWidth :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()

-- | Sets the wrap mode; the wrap mode only has effect if a width is set on
--   the layout with <a>layoutSetWidth</a>. To turn off wrapping, set the
--   width to -1.
layoutSetWrap :: (HasCallStack, MonadIO m, IsLayout a) => a -> WrapMode -> m ()

-- | Converts from X and Y position within a layout to the byte index to
--   the character at that logical position. If the Y position is not
--   inside the layout, the closest position is chosen (the position will
--   be clamped inside the layout). If the X position is not within the
--   layout, then the start or the end of the line is chosen as described
--   for <a>layoutLineXToIndex</a>. If either the X or Y positions were not
--   inside the layout, then the function returns <a>False</a>; on an exact
--   hit, it returns <a>True</a>.
layoutXyToIndex :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> Int32 -> m (Bool, Int32, Int32)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.Layout.Layout o) => GI.Pango.Objects.Layout.IsLayout o
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Layout.Layout
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Layout.Layout


module GI.Pango.Objects


-- | A <a>TabArray</a> struct contains an array of tab stops. Each tab stop
--   has an alignment and a position.
module GI.Pango.Structs.TabArray

-- | Memory-managed wrapper type.
newtype TabArray
TabArray :: ManagedPtr TabArray -> TabArray

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>TabArray</a>.
noTabArray :: Maybe TabArray

-- | Copies a <a>TabArray</a>
tabArrayCopy :: (HasCallStack, MonadIO m) => TabArray -> m TabArray

-- | Frees a tab array and associated resources.
tabArrayFree :: (HasCallStack, MonadIO m) => TabArray -> m ()

-- | Returns <a>True</a> if the tab positions are in pixels, <a>False</a>
--   if they are in Pango units.
tabArrayGetPositionsInPixels :: (HasCallStack, MonadIO m) => TabArray -> m Bool

-- | Gets the number of tab stops in <i><tt>tabArray</tt></i>.
tabArrayGetSize :: (HasCallStack, MonadIO m) => TabArray -> m Int32

-- | Gets the alignment and position of a tab stop.
tabArrayGetTab :: (HasCallStack, MonadIO m) => TabArray -> Int32 -> m (TabAlign, Int32)

-- | Creates an array of <i><tt>initialSize</tt></i> tab stops. Tab stops
--   are specified in pixel units if <i><tt>positionsInPixels</tt></i> is
--   <a>True</a>, otherwise in Pango units. All stops are initially at
--   position 0.
tabArrayNew :: (HasCallStack, MonadIO m) => Int32 -> Bool -> m TabArray

-- | Resizes a tab array. You must subsequently initialize any tabs that
--   were added as a result of growing the array.
tabArrayResize :: (HasCallStack, MonadIO m) => TabArray -> Int32 -> m ()

-- | Sets the alignment and location of a tab stop.
--   <i><tt>alignment</tt></i> must always be
--   <tt><i>PANGO_TAB_LEFT</i></tt> in the current implementation.
tabArraySetTab :: (HasCallStack, MonadIO m) => TabArray -> Int32 -> TabAlign -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.TabArray.TabArray


module GI.Pango.Structs


module GI.Pango