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


-- | Build time configuration used during code generation.
module GI.Pango.Config

-- | Overrides used when generating these bindings.
overrides :: Text


module GI.Pango.Constants

-- | A string literal containing the version of Pango available at
--   compile-time.
pattern VERSION_STRING :: Text

-- | The minor component of the version of Pango available at compile-time.
pattern VERSION_MINOR :: Int32

-- | The micro component of the version of Pango available at compile-time.
pattern VERSION_MICRO :: Int32

-- | The major component of the version of Pango available at compile-time.
pattern VERSION_MAJOR :: Int32

-- | 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.
pattern SCALE :: Int32

-- | Flag used in <tt>PangoGlyph</tt> to turn a <tt>gunichar</tt> value of
--   a valid Unicode character into an unknown-character glyph for that
--   <tt>gunichar</tt>.
--   
--   Such unknown-character glyphs may be rendered as a 'hex box'.
pattern GLYPH_UNKNOWN_FLAG :: Word32

-- | A <tt>PangoGlyph</tt> value for invalid input.
--   
--   <tt>PangoLayout</tt> 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> set.
--   
--   <i>Since: 1.20</i>
pattern GLYPH_INVALID_INPUT :: Word32

-- | A <tt>PangoGlyph</tt> value that indicates a zero-width empty glpyh.
--   
--   This is useful for example in shaper modules, to use as the glyph for
--   various zero-width Unicode characters (those passing
--   [func<i><tt>isZeroWidth</tt></i>]).
pattern GLYPH_EMPTY :: Word32

-- | Value for <i><tt>endIndex</tt></i> in <tt>PangoAttribute</tt> that
--   indicates the end of the text.
--   
--   <i>Since: 1.24</i>
pattern ATTR_INDEX_TO_TEXT_END :: Word32

-- | Value for <i><tt>startIndex</tt></i> in <tt>PangoAttribute</tt> that
--   indicates the beginning of the text.
--   
--   <i>Since: 1.24</i>
pattern ATTR_INDEX_FROM_TEXT_BEGINNING :: Word32

-- | Whether to add a hyphen at the end of the run during shaping.
--   
--   <i>Since: 1.44</i>
pattern ANALYSIS_FLAG_NEED_HYPHEN :: Int32

-- | Whether this run holds ellipsized text.
--   
--   <i>Since: 1.36.7</i>
pattern ANALYSIS_FLAG_IS_ELLIPSIS :: Int32

-- | Whether the segment should be shifted to center around the baseline.
--   
--   This is mainly used in vertical writing directions.
--   
--   <i>Since: 1.16</i>
pattern ANALYSIS_FLAG_CENTERED_BASELINE :: Int32


module GI.Pango.Enums

-- | <tt>PangoAlignment</tt> describes how to align the lines of a
--   <tt>PangoLayout</tt> within the available space.
--   
--   If the <tt>PangoLayout</tt> is set to justify using
--   <a>layoutSetJustify</a>, this only affects partial lines.
--   
--   See <a>layoutSetAutoDir</a> for how text direction affects the
--   interpretation of <tt>PangoAlignment</tt> values.
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 <tt>PangoAttrType</tt> distinguishes between different types of
--   attributes.
--   
--   Along with the predefined values, it is possible to allocate
--   additional values for custom attributes using
--   <tt><i>AttrType.register</i></tt>. 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 ([struct<i><tt>pango</tt></i>.AttrLanguage])
AttrTypeLanguage :: AttrType

-- | font family name list ([struct<i><tt>pango</tt></i>.AttrString])
AttrTypeFamily :: AttrType

-- | font slant style ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeStyle :: AttrType

-- | font weight ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeWeight :: AttrType

-- | font variant (normal or small caps)
--   ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeVariant :: AttrType

-- | font stretch ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeStretch :: AttrType

-- | font size in points scaled by <a>SCALE</a>
--   ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeSize :: AttrType

-- | font description ([struct<i><tt>pango</tt></i>.AttrFontDesc])
AttrTypeFontDesc :: AttrType

-- | foreground color ([struct<i><tt>pango</tt></i>.AttrColor])
AttrTypeForeground :: AttrType

-- | background color ([struct<i><tt>pango</tt></i>.AttrColor])
AttrTypeBackground :: AttrType

-- | whether the text has an underline
--   ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeUnderline :: AttrType

-- | whether the text is struck-through
--   ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeStrikethrough :: AttrType

-- | baseline displacement ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeRise :: AttrType

-- | shape ([struct<i><tt>pango</tt></i>.AttrShape])
AttrTypeShape :: AttrType

-- | font size scale factor ([struct<i><tt>pango</tt></i>.AttrFloat])
AttrTypeScale :: AttrType

-- | whether fallback is enabled ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeFallback :: AttrType

-- | letter spacing ([struct<i><tt>pangoAttrInt</tt></i>])
AttrTypeLetterSpacing :: AttrType

-- | underline color ([struct<i><tt>pango</tt></i>.AttrColor])
AttrTypeUnderlineColor :: AttrType

-- | strikethrough color ([struct<i><tt>pango</tt></i>.AttrColor])
AttrTypeStrikethroughColor :: AttrType

-- | font size in pixels scaled by <a>SCALE</a>
--   ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeAbsoluteSize :: AttrType

-- | base text gravity ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeGravity :: AttrType

-- | gravity hint ([struct<i><tt>pango</tt></i>.AttrInt])
AttrTypeGravityHint :: AttrType

-- | OpenType font features
--   ([struct<i><tt>pango</tt></i>.AttrFontFeatures]). Since 1.38
AttrTypeFontFeatures :: AttrType

-- | foreground alpha ([struct<i><tt>pango</tt></i>.AttrInt]). Since 1.38
AttrTypeForegroundAlpha :: AttrType

-- | background alpha ([struct<i><tt>pango</tt></i>.AttrInt]). Since 1.38
AttrTypeBackgroundAlpha :: AttrType

-- | whether breaks are allowed ([struct<i><tt>pango</tt></i>.AttrInt]).
--   Since 1.44
AttrTypeAllowBreaks :: AttrType

-- | how to render invisible characters
--   ([struct<i><tt>pango</tt></i>.AttrInt]). Since 1.44
AttrTypeShow :: AttrType

-- | whether to insert hyphens at intra-word line breaks
--   ([struct<i><tt>pango</tt></i>.AttrInt]). Since 1.44
AttrTypeInsertHyphens :: AttrType

-- | whether the text has an overline
--   ([struct<i><tt>pango</tt></i>.AttrInt]). Since 1.46
AttrTypeOverline :: AttrType

-- | overline color ([struct<i><tt>pango</tt></i>.AttrColor]). Since 1.46
AttrTypeOverlineColor :: AttrType

-- | line height factor ([struct<i><tt>pango</tt></i>.AttrFloat]). Since:
--   1.50
AttrTypeLineHeight :: AttrType

-- | line height ([struct<i><tt>pango</tt></i>.AttrInt]). Since: 1.50
AttrTypeAbsoluteLineHeight :: AttrType

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

-- | override segmentation to classify the range of the attribute as a
--   single word ([struct<i><tt>pango</tt></i>.AttrInt]). Since 1.50
AttrTypeWord :: AttrType

-- | override segmentation to classify the range of the attribute as a
--   single sentence ([struct<i><tt>pango</tt></i>.AttrInt]). Since 1.50
AttrTypeSentence :: AttrType

-- | baseline displacement ([struct<i><tt>pango</tt></i>.AttrInt]). Since
--   1.50
AttrTypeBaselineShift :: AttrType

-- | font-relative size change ([struct<i><tt>pango</tt></i>.AttrInt]).
--   Since 1.50
AttrTypeFontScale :: AttrType

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

-- | An enumeration that affects baseline shifts between runs.
--   
--   <i>Since: 1.50</i>
data BaselineShift

-- | Leave the baseline unchanged
BaselineShiftNone :: BaselineShift

-- | Shift the baseline to the superscript position, relative to the
--   previous run
BaselineShiftSuperscript :: BaselineShift

-- | Shift the baseline to the subscript position, relative to the previous
--   run
BaselineShiftSubscript :: BaselineShift

-- | Catch-all for unknown values
AnotherBaselineShift :: Int -> BaselineShift

-- | <tt>PangoBidiType</tt> represents the bidirectional character type of
--   a Unicode character.
--   
--   The values in this enumeration are specified by the <a>Unicode
--   bidirectional algorithm</a>.
--   
--   <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

-- | Left-to-Right isolate. Since 1.48.6
BidiTypeLri :: BidiType

-- | Right-to-Left isolate. Since 1.48.6
BidiTypeRli :: BidiType

-- | First strong isolate. Since 1.48.6
BidiTypeFsi :: BidiType

-- | Pop directional isolate. Since 1.48.6
BidiTypePdi :: BidiType

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

-- | <tt>PangoCoverageLevel</tt> is used to indicate how well a font can
--   represent a particular Unicode character for a particular script.
--   
--   Since 1.44, only <a>CoverageLevelNone</a> and
--   <a>CoverageLevelExact</a> will be returned.
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

-- | <tt>PangoDirection</tt> represents a direction in the Unicode
--   bidirectional algorithm.
--   
--   Not every value in this enumeration makes sense for every usage of
--   <tt>PangoDirection</tt>; for example, the return value of
--   [func<i><tt>unicharDirection</tt></i>] and
--   [func<i><tt>findBaseDir</tt></i>] cannot be
--   <tt>PANGO_DIRECTION_WEAK_LTR</tt> or
--   <tt>PANGO_DIRECTION_WEAK_RTL</tt>, since every character is either
--   neutral or has a strong direction; on the other hand
--   <tt>PANGO_DIRECTION_NEUTRAL</tt> doesn't make sense to pass to
--   [func<i><tt>itemizeWithBaseDir</tt></i>].
--   
--   The <tt>PANGO_DIRECTION_TTB_LTR</tt>, <tt>PANGO_DIRECTION_TTB_RTL</tt>
--   values come from an earlier interpretation of this enumeration as the
--   writing direction of a block of text and are no longer used. See
--   <tt>PangoGravity</tt> for how vertical text is handled in Pango.
--   
--   If you are interested in text direction, you should really use fribidi
--   directly. <tt>PangoDirection</tt> 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 <tt>PANGO_DIRECTION_RTL</tt>.
DirectionTtbLtr :: Direction

-- | Deprecated value; treated the same as <tt>PANGO_DIRECTION_LTR</tt>
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

-- | <tt>PangoEllipsizeMode</tt> describes what sort of ellipsization
--   should be applied to 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

-- | An enumeration that affects font sizes for superscript and subscript
--   positioning and for (emulated) Small Caps.
--   
--   <i>Since: 1.50</i>
data FontScale

-- | Leave the font size unchanged
FontScaleNone :: FontScale

-- | Change the font to a size suitable for superscripts
FontScaleSuperscript :: FontScale

-- | Change the font to a size suitable for subscripts
FontScaleSubscript :: FontScale

-- | Change the font to a size suitable for Small Caps
FontScaleSmallCaps :: FontScale

-- | Catch-all for unknown values
AnotherFontScale :: Int -> FontScale

-- | <tt>PangoGravity</tt> 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
--   [struct<i><tt>pango</tt></i>.Matrix], and then glyph orientation is
--   controlled using <tt>PangoGravity</tt>.
--   
--   Not every value in this enumeration makes sense for every usage of
--   <tt>PangoGravity</tt>; 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) &lt;img align="right" valign="center"
--   src="m-south.png"&gt;
GravitySouth :: Gravity

-- | Glyphs are rotated 90 degrees counter-clockwise. &lt;img align="right"
--   valign="center" src="m-east.png"&gt;
GravityEast :: Gravity

-- | Glyphs are upside-down. &lt;img align="right" valign="cener"
--   src="m-north.png"&gt;
GravityNorth :: Gravity

-- | Glyphs are rotated 90 degrees clockwise. &lt;img align="right"
--   valign="center" src="m-west.png"&gt;
GravityWest :: Gravity

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

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

-- | <tt>PangoGravityHint</tt> defines how horizontal scripts should behave
--   in a vertical context.
--   
--   That is, English excerpts in a vertical paragraph for example.
--   
--   See also <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

-- | Errors that can be returned by
--   [func<i><tt>pango</tt></i>.Layout.deserialize].
--   
--   <i>Since: 1.50</i>
data LayoutDeserializeError

-- | Unspecified error
LayoutDeserializeErrorInvalid :: LayoutDeserializeError

-- | A JSon value could not be interpreted
LayoutDeserializeErrorInvalidValue :: LayoutDeserializeError

-- | A required JSon member was not found
LayoutDeserializeErrorMissingValue :: LayoutDeserializeError

-- | Catch-all for unknown values
AnotherLayoutDeserializeError :: Int -> LayoutDeserializeError

-- | Catch exceptions of type <a>LayoutDeserializeError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchLayoutDeserializeError :: IO a -> (LayoutDeserializeError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>LayoutDeserializeError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleLayoutDeserializeError :: (LayoutDeserializeError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | The <tt>PangoOverline</tt> enumeration is used to specify whether text
--   should be overlined, and if so, the type of line.
--   
--   <i>Since: 1.46</i>
data Overline

-- | no overline should be drawn
OverlineNone :: Overline

-- | Draw a single line above the ink extents of the text being underlined.
OverlineSingle :: Overline

-- | Catch-all for unknown values
AnotherOverline :: Int -> Overline

-- | <tt>PangoRenderPart</tt> 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

-- | overlines
RenderPartOverline :: RenderPart

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

-- | The <tt>PangoScript</tt> enumeration identifies different writing
--   systems.
--   
--   The values correspond to the names as defined in the Unicode standard.
--   See <a>Unicode Standard Annex 24: Script names</a>
--   
--   Note that this enumeration is deprecated and will not be updated to
--   include values in newer versions of the Unicode standard. Applications
--   should use the <a>UnicodeScript</a> enumeration instead, whose values
--   are interchangeable with <tt>PangoScript</tt>.
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

-- | <tt>PangoTabAlign</tt> specifies where the text appears relative to
--   the tab stop position.
data TabAlign

-- | the text appears to the right of the tab stop position
TabAlignLeft :: TabAlign

-- | the text appears to the left of the tab stop position until the
--   available space is filled. Since: 1.50
TabAlignRight :: TabAlign

-- | the text is centered at the tab stop position until the available
--   space is filled. Since: 1.50
TabAlignCenter :: TabAlign

-- | text before the first occurrence of the decimal point character
--   appears to the left of the tab stop position (until the available
--   space is filled), the rest to the right. Since: 1.50
TabAlignDecimal :: TabAlign

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

-- | An enumeration that affects how Pango treats characters during
--   shaping.
--   
--   <i>Since: 1.50</i>
data TextTransform

-- | Leave text unchanged
TextTransformNone :: TextTransform

-- | Display letters and numbers as lowercase
TextTransformLowercase :: TextTransform

-- | Display letters and numbers as uppercase
TextTransformUppercase :: TextTransform

-- | Display the first character of a word in titlecase
TextTransformCapitalize :: TextTransform

-- | Catch-all for unknown values
AnotherTextTransform :: Int -> TextTransform

-- | The <tt>PangoUnderline</tt> 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

-- | an underline indicating an error should be drawn below. The exact
--   style of rendering is up to the <tt>PangoRenderer</tt> in use, but
--   typical styles include wavy or dotted lines. This underline is
--   typically used to indicate an error such as a possible mispelling; in
--   some cases a contrasting color may automatically be used. This type of
--   underlining is available since Pango 1.4.
UnderlineError :: Underline

-- | Like <i><tt>pANGOUNDERLINESINGLE</tt></i>, but drawn continuously
--   across multiple runs. This type of underlining is available since
--   Pango 1.46.
UnderlineSingleLine :: Underline

-- | Like <i><tt>pANGOUNDERLINEDOUBLE</tt></i>, but drawn continuously
--   across multiple runs. This type of underlining is available since
--   Pango 1.46.
UnderlineDoubleLine :: Underline

-- | Like <i><tt>pANGOUNDERLINEERROR</tt></i>, but drawn continuously
--   across multiple runs. This type of underlining is available since
--   Pango 1.46.
UnderlineErrorLine :: 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

-- | A font with all characters replaced by smaller variants of the capital
--   characters. Since: 1.50
VariantAllSmallCaps :: Variant

-- | A font with the lower case characters replaced by smaller variants of
--   the capital characters. Petite Caps can be even smaller than Small
--   Caps. Since: 1.50
VariantPetiteCaps :: Variant

-- | A font with all characters replaced by smaller variants of the capital
--   characters. Petite Caps can be even smaller than Small Caps. Since:
--   1.50
VariantAllPetiteCaps :: Variant

-- | A font with the upper case characters replaced by smaller variants of
--   the capital letters. Since: 1.50
VariantUnicase :: Variant

-- | A font with capital letters that are more suitable for all-uppercase
--   titles. Since: 1.50
VariantTitleCaps :: Variant

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

-- | An enumeration specifying the weight (boldness) of a font.
--   
--   Weight is specified as a numeric value ranging from 100 to 1000. This
--   enumeration simply provides some common, 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 medium 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

-- | <tt>PangoWrapMode</tt> describes how to wrap the lines of a
--   <tt>PangoLayout</tt> to the desired width.
--   
--   For <i><tt>pANGOWRAPWORD</tt></i>, Pango uses break opportunities that
--   are determined by the Unicode line breaking algorithm. For
--   <i><tt>pANGOWRAPCHAR</tt></i>, Pango allows breaking at grapheme
--   boundaries that are determined by the Unicode text segmentation
--   algorithm.
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.WrapMode
instance GHC.Show.Show GI.Pango.Enums.WrapMode
instance GHC.Classes.Eq GI.Pango.Enums.Weight
instance GHC.Show.Show GI.Pango.Enums.Weight
instance GHC.Classes.Eq GI.Pango.Enums.Variant
instance GHC.Show.Show GI.Pango.Enums.Variant
instance GHC.Classes.Eq GI.Pango.Enums.Underline
instance GHC.Show.Show GI.Pango.Enums.Underline
instance GHC.Classes.Eq GI.Pango.Enums.TextTransform
instance GHC.Show.Show GI.Pango.Enums.TextTransform
instance GHC.Classes.Eq GI.Pango.Enums.TabAlign
instance GHC.Show.Show GI.Pango.Enums.TabAlign
instance GHC.Classes.Eq GI.Pango.Enums.Style
instance GHC.Show.Show GI.Pango.Enums.Style
instance GHC.Classes.Eq GI.Pango.Enums.Stretch
instance GHC.Show.Show GI.Pango.Enums.Stretch
instance GHC.Classes.Eq GI.Pango.Enums.Script
instance GHC.Show.Show GI.Pango.Enums.Script
instance GHC.Classes.Eq GI.Pango.Enums.RenderPart
instance GHC.Show.Show GI.Pango.Enums.RenderPart
instance GHC.Classes.Eq GI.Pango.Enums.Overline
instance GHC.Show.Show GI.Pango.Enums.Overline
instance GHC.Classes.Eq GI.Pango.Enums.LayoutDeserializeError
instance GHC.Show.Show GI.Pango.Enums.LayoutDeserializeError
instance GHC.Classes.Eq GI.Pango.Enums.GravityHint
instance GHC.Show.Show GI.Pango.Enums.GravityHint
instance GHC.Classes.Eq GI.Pango.Enums.Gravity
instance GHC.Show.Show GI.Pango.Enums.Gravity
instance GHC.Classes.Eq GI.Pango.Enums.FontScale
instance GHC.Show.Show GI.Pango.Enums.FontScale
instance GHC.Classes.Eq GI.Pango.Enums.EllipsizeMode
instance GHC.Show.Show GI.Pango.Enums.EllipsizeMode
instance GHC.Classes.Eq GI.Pango.Enums.Direction
instance GHC.Show.Show GI.Pango.Enums.Direction
instance GHC.Classes.Eq GI.Pango.Enums.CoverageLevel
instance GHC.Show.Show GI.Pango.Enums.CoverageLevel
instance GHC.Classes.Eq GI.Pango.Enums.BidiType
instance GHC.Show.Show GI.Pango.Enums.BidiType
instance GHC.Classes.Eq GI.Pango.Enums.BaselineShift
instance GHC.Show.Show GI.Pango.Enums.BaselineShift
instance GHC.Classes.Eq GI.Pango.Enums.AttrType
instance GHC.Show.Show GI.Pango.Enums.AttrType
instance GHC.Classes.Eq GI.Pango.Enums.Alignment
instance GHC.Show.Show GI.Pango.Enums.Alignment
instance GHC.Enum.Enum GI.Pango.Enums.Alignment
instance GHC.Classes.Ord GI.Pango.Enums.Alignment
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Enums.Alignment
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.AttrType
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Enums.AttrType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.AttrType
instance GHC.Enum.Enum GI.Pango.Enums.BaselineShift
instance GHC.Classes.Ord GI.Pango.Enums.BaselineShift
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Enums.BaselineShift
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Enums.BaselineShift
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.BaselineShift
instance GHC.Enum.Enum GI.Pango.Enums.BidiType
instance GHC.Classes.Ord GI.Pango.Enums.BidiType
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Enums.BidiType
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.CoverageLevel
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.Direction
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.EllipsizeMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Enums.EllipsizeMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.EllipsizeMode
instance GHC.Enum.Enum GI.Pango.Enums.FontScale
instance GHC.Classes.Ord GI.Pango.Enums.FontScale
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Enums.FontScale
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Enums.FontScale
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.FontScale
instance GHC.Enum.Enum GI.Pango.Enums.Gravity
instance GHC.Classes.Ord GI.Pango.Enums.Gravity
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Enums.Gravity
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.GravityHint
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Enums.GravityHint
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.GravityHint
instance GHC.Enum.Enum GI.Pango.Enums.LayoutDeserializeError
instance GHC.Classes.Ord GI.Pango.Enums.LayoutDeserializeError
instance Data.GI.Base.GError.GErrorClass GI.Pango.Enums.LayoutDeserializeError
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Enums.LayoutDeserializeError
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Enums.LayoutDeserializeError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.LayoutDeserializeError
instance GHC.Enum.Enum GI.Pango.Enums.Overline
instance GHC.Classes.Ord GI.Pango.Enums.Overline
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Enums.Overline
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Enums.Overline
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.Overline
instance GHC.Enum.Enum GI.Pango.Enums.RenderPart
instance GHC.Classes.Ord GI.Pango.Enums.RenderPart
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Enums.RenderPart
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.Script
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.Stretch
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.Style
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.TabAlign
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Enums.TabAlign
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.TabAlign
instance GHC.Enum.Enum GI.Pango.Enums.TextTransform
instance GHC.Classes.Ord GI.Pango.Enums.TextTransform
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Enums.TextTransform
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Enums.TextTransform
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.TextTransform
instance GHC.Enum.Enum GI.Pango.Enums.Underline
instance GHC.Classes.Ord GI.Pango.Enums.Underline
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Enums.Underline
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.Variant
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.Weight
instance Data.GI.Base.BasicTypes.TypedObject 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.Overloading.HasParentTypes GI.Pango.Enums.WrapMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Enums.WrapMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Pango.Enums.WrapMode


module GI.Pango.Flags

-- | The bits in a <tt>PangoFontMask</tt> correspond to the set fields in a
--   <tt>PangoFontDescription</tt>.
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

-- | Flags that influence the behavior of
--   [func<i><tt>pango</tt></i>.Layout.deserialize].
--   
--   New members may be added to this enumeration over time.
--   
--   <i>Since: 1.50</i>
data LayoutDeserializeFlags

-- | Default behavior
LayoutDeserializeFlagsDefault :: LayoutDeserializeFlags

-- | Apply context information from the serialization to the
--   <tt>PangoContext</tt>
LayoutDeserializeFlagsContext :: LayoutDeserializeFlags

-- | Catch-all for unknown values
AnotherLayoutDeserializeFlags :: Int -> LayoutDeserializeFlags

-- | Flags that influence the behavior of <a>layoutSerialize</a>.
--   
--   New members may be added to this enumeration over time.
--   
--   <i>Since: 1.50</i>
data LayoutSerializeFlags

-- | Default behavior
LayoutSerializeFlagsDefault :: LayoutSerializeFlags

-- | Include context information
LayoutSerializeFlagsContext :: LayoutSerializeFlags

-- | Include information about the formatted output
LayoutSerializeFlagsOutput :: LayoutSerializeFlags

-- | Catch-all for unknown values
AnotherLayoutSerializeFlags :: Int -> LayoutSerializeFlags

-- | Flags influencing the shaping process.
--   
--   <tt>PangoShapeFlags</tt> can be passed to <a>shapeWithFlags</a>.
--   
--   <i>Since: 1.44</i>
data ShapeFlags

-- | Default value
ShapeFlagsNone :: ShapeFlags

-- | Round glyph positions and widths to whole device units This option
--   should be set if the target renderer can't do subpixel positioning of
--   glyphs
ShapeFlagsRoundPositions :: ShapeFlags

-- | Catch-all for unknown values
AnotherShapeFlags :: Int -> ShapeFlags

-- | These flags affect how Pango treats characters that are normally not
--   visible in the output.
--   
--   <i>Since: 1.44</i>
data ShowFlags

-- | No special treatment for invisible characters
ShowFlagsNone :: ShowFlags

-- | Render spaces, tabs and newlines visibly
ShowFlagsSpaces :: ShowFlags

-- | Render line breaks visibly
ShowFlagsLineBreaks :: ShowFlags

-- | Render default-ignorable Unicode characters visibly
ShowFlagsIgnorables :: ShowFlags

-- | Catch-all for unknown values
AnotherShowFlags :: Int -> ShowFlags
instance GHC.Classes.Eq GI.Pango.Flags.ShowFlags
instance GHC.Show.Show GI.Pango.Flags.ShowFlags
instance GHC.Classes.Eq GI.Pango.Flags.ShapeFlags
instance GHC.Show.Show GI.Pango.Flags.ShapeFlags
instance GHC.Classes.Eq GI.Pango.Flags.LayoutSerializeFlags
instance GHC.Show.Show GI.Pango.Flags.LayoutSerializeFlags
instance GHC.Classes.Eq GI.Pango.Flags.LayoutDeserializeFlags
instance GHC.Show.Show GI.Pango.Flags.LayoutDeserializeFlags
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.Overloading.HasParentTypes GI.Pango.Flags.FontMask
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Flags.FontMask
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Pango.Flags.FontMask
instance Data.GI.Base.BasicTypes.IsGFlag GI.Pango.Flags.FontMask
instance GHC.Enum.Enum GI.Pango.Flags.LayoutDeserializeFlags
instance GHC.Classes.Ord GI.Pango.Flags.LayoutDeserializeFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Flags.LayoutDeserializeFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Flags.LayoutDeserializeFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Pango.Flags.LayoutDeserializeFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Pango.Flags.LayoutDeserializeFlags
instance GHC.Enum.Enum GI.Pango.Flags.LayoutSerializeFlags
instance GHC.Classes.Ord GI.Pango.Flags.LayoutSerializeFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Flags.LayoutSerializeFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Flags.LayoutSerializeFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Pango.Flags.LayoutSerializeFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Pango.Flags.LayoutSerializeFlags
instance GHC.Enum.Enum GI.Pango.Flags.ShapeFlags
instance GHC.Classes.Ord GI.Pango.Flags.ShapeFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Flags.ShapeFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Flags.ShapeFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Pango.Flags.ShapeFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Pango.Flags.ShapeFlags
instance GHC.Enum.Enum GI.Pango.Flags.ShowFlags
instance GHC.Classes.Ord GI.Pango.Flags.ShowFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Flags.ShowFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Flags.ShowFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Pango.Flags.ShowFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Pango.Flags.ShowFlags


-- | A <tt>PangoCoverage</tt> structure is a map from Unicode characters to
--   <a>CoverageLevel</a> values.
--   
--   It is often necessary in Pango to determine if a particular font can
--   represent a particular character, and also how well it can represent
--   that character. The <tt>PangoCoverage</tt> is a data structure that is
--   used to represent that information. It is an opaque structure with no
--   public fields.
module GI.Pango.Objects.Coverage

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

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

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

-- | Copy an existing <tt>PangoCoverage</tt>.
coverageCopy :: (HasCallStack, MonadIO m, IsCoverage a) => a -> m Coverage

-- | Convert data generated from <a>coverageToBytes</a> back to a
--   <tt>PangoCoverage</tt>.

-- | <i>Deprecated: (Since version 1.44)This returns <a>Nothing</a></i>
coverageFromBytes :: (HasCallStack, MonadIO m) => ByteString -> m (Maybe Coverage)

-- | Determine whether a particular index is covered by
--   <i><tt>coverage</tt></i>.
coverageGet :: (HasCallStack, MonadIO m, IsCoverage a) => a -> 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>.

-- | <i>Deprecated: (Since version 1.44)This function does nothing</i>
coverageMax :: (HasCallStack, MonadIO m, IsCoverage a, IsCoverage b) => a -> b -> m ()

-- | Create a new <tt>PangoCoverage</tt>
coverageNew :: (HasCallStack, MonadIO m) => m Coverage

-- | Increase the reference count on the <tt>PangoCoverage</tt> by one.

-- | <i>Deprecated: (Since version 1.52)Use g_object_ref instead</i>
coverageRef :: (HasCallStack, MonadIO m, IsCoverage a) => a -> m Coverage

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

-- | Convert a <tt>PangoCoverage</tt> structure into a flat binary format.

-- | <i>Deprecated: (Since version 1.44)This returns <a>Nothing</a></i>
coverageToBytes :: (HasCallStack, MonadIO m, IsCoverage a) => a -> m ByteString

-- | Decrease the reference count on the <tt>PangoCoverage</tt> by one.
--   
--   If the result is zero, free the coverage and all associated memory.

-- | <i>Deprecated: (Since version 1.52)Use g_object_unref instead</i>
coverageUnref :: (HasCallStack, MonadIO m, IsCoverage a) => a -> m ()
instance GHC.Classes.Eq GI.Pango.Objects.Coverage.Coverage
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Pango.Objects.Coverage.Coverage o) => GI.Pango.Objects.Coverage.IsCoverage o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Objects.Coverage.Coverage
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Objects.Coverage.Coverage
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Coverage.Coverage
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Coverage.Coverage
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Objects.Coverage.Coverage)


-- | The <tt>PangoColor</tt> 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

-- | Creates a copy of <i><tt>src</tt></i>.
--   
--   The copy 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) => Maybe Color -> m (Maybe Color)

-- | Frees a color allocated by <a>colorCopy</a>.
colorFree :: (HasCallStack, MonadIO m) => Maybe 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 Color <a>specification</a>, or it can be a value in the
--   form <tt>#rgb</tt>, <tt>#rrggbb</tt>, <tt>#rrrgggbbb</tt> or
--   <tt>#rrrrggggbbbb</tt>, where <tt>r</tt>, <tt>g</tt> and <tt>b</tt>
--   are hex digits of the red, green, and blue components of the color,
--   respectively. (White in the four forms is <tt>#fff</tt>,
--   <tt>#ffffff</tt>, <tt>#fffffffff</tt> and <tt>#ffffffffffff</tt>.)
colorParse :: (HasCallStack, MonadIO m) => Maybe Color -> Text -> m Bool

-- | 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 Color <a>specification</a>, or it can be a hexadecimal
--   value in the form <tt>#rgb</tt>, <tt>#rrggbb</tt>, <tt>#rrrgggbbb</tt>
--   or <tt>#rrrrggggbbbb</tt> where <tt>r</tt>, <tt>g</tt> and <tt>b</tt>
--   are hex digits of the red, green, and blue components of the color,
--   respectively. (White in the four forms is <tt>#fff</tt>,
--   <tt>#ffffff</tt>, <tt>#fffffffff</tt> and <tt>#ffffffffffff</tt>.)
--   
--   Additionally, parse strings of the form <tt>#rgba</tt>,
--   <tt>#rrggbbaa</tt>, <tt>#rrrrggggbbbbaaaa</tt>, if
--   <i><tt>alpha</tt></i> is not <a>Nothing</a>, and set
--   <i><tt>alpha</tt></i> to the value specified by the hex digits for
--   <tt>a</tt>. If no alpha component is found in <i><tt>spec</tt></i>,
--   <i><tt>alpha</tt></i> is set to 0xffff (for a solid color).
--   
--   <i>Since: 1.46</i>
colorParseWithAlpha :: (HasCallStack, MonadIO m) => Maybe Color -> Text -> m (Bool, Word16)

-- | Returns a textual specification of <i><tt>color</tt></i>.
--   
--   The string is in the hexadecimal form <tt>#rrrrggggbbbb</tt>, where
--   <tt>r</tt>, <tt>g</tt> and <tt>b</tt> 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 GHC.Classes.Eq GI.Pango.Structs.Color.Color
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.Color.Color
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.Color.Color
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.Color.Color
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.Color.Color
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.Color.Color)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Color.Color tag


-- | A <tt>PangoFontDescription</tt> describes a font in an
--   implementation-independent manner.
--   
--   <tt>PangoFontDescription</tt> 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

-- | 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 <a>StyleOblique</a> and <a>StyleItalic</a> 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 <tt>PangoFontDescription</tt>.
fontDescriptionCopy :: (HasCallStack, MonadIO m) => Maybe FontDescription -> m (Maybe FontDescription)

-- | Make a copy of a <tt>PangoFontDescription</tt>, but don't duplicate
--   allocated fields.
--   
--   This is 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) => Maybe 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) => Maybe FontDescription -> m ()

-- | Creates a new font description from a string representation.
--   
--   The string must have the form
--   
--   "\[FAMILY-LIST] \[STYLE-OPTIONS] \[SIZE] \[VARIATIONS]",
--   
--   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.
--   VARIATIONS is a comma-separated list of font variation specifications
--   of the form "@axis=value" (the = sign is optional).
--   
--   The following words are understood as styles: "Normal", "Roman",
--   "Oblique", "Italic".
--   
--   The following words are understood as variants: "Small-Caps",
--   "All-Small-Caps", "Petite-Caps", "All-Petite-Caps", "Unicase",
--   "Title-Caps".
--   
--   The following words are understood as weights: "Thin", "Ultra-Light",
--   "Extra-Light", "Light", "Semi-Light", "Demi-Light", "Book", "Regular",
--   "Medium", "Semi-Bold", "Demi-Bold", "Bold", "Ultra-Bold",
--   "Extra-Bold", "Heavy", "Black", "Ultra-Black", "Extra-Black".
--   
--   The following words are understood as stretch values:
--   "Ultra-Condensed", "Extra-Condensed", "Condensed", "Semi-Condensed",
--   "Semi-Expanded", "Expanded", "Extra-Expanded", "Ultra-Expanded".
--   
--   The following words are understood as gravity values: "Not-Rotated",
--   "South", "Upside-Down", "North", "Rotated-Left", "East",
--   "Rotated-Right", "West".
--   
--   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.
--   
--   A typical example:
--   
--   "Cantarell Italic Light 15 @wght=200"
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 <tt>PangoFontDescription</tt>.
--   
--   See <a>fontDescriptionSetStyle</a>.
fontDescriptionGetStyle :: (HasCallStack, MonadIO m) => FontDescription -> m Style

-- | Gets the variant field of a <tt>PangoFontDescription</tt>.
--   
--   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 <tt>PangoFontDescription</tt> structure.
--   
--   This is 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 ()

-- | Merges the fields that are set in <i><tt>descToMerge</tt></i> into the
--   fields in <i><tt>desc</tt></i>, without copying allocated fields.
--   
--   This is 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 <tt>PangoFontFamily</tt>. In some uses of
--   <tt>PangoFontDescription</tt>, it is also possible to use a comma
--   separated list of family names for this field.
fontDescriptionSetFamily :: (HasCallStack, MonadIO m) => FontDescription -> Text -> m ()

-- | Sets the family name field of a font description, without copying the
--   string.
--   
--   This is 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 <tt>PangoContext</tt>.
--   
--   <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 <a>Stretch</a> field specifies how narrow or wide the font should
--   be.
fontDescriptionSetStretch :: (HasCallStack, MonadIO m) => FontDescription -> Stretch -> m ()

-- | Sets the style field of a <tt>PangoFontDescription</tt>.
--   
--   The <a>Style</a> enumeration describes whether the font is slanted and
--   the manner in which it is slanted; it can be either
--   <a>StyleNormal</a>, <a>StyleItalic</a>, or <a>StyleOblique</a>.
--   
--   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 and freetype have API for this. See for example
--   <a>hb_ot_var_get_axis_infos</a>.
--   
--   <i>Since: 1.42</i>
fontDescriptionSetVariations :: (HasCallStack, MonadIO m) => FontDescription -> Maybe Text -> m ()

-- | Sets the variations field of a font description.
--   
--   This is 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 (Maybe Text)

-- | Creates a string representation of a font description.
--   
--   See [func<i><tt>pango</tt></i>.FontDescription.from_string] 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 <tt>PangoFontDescription</tt>.
--   
--   The unset fields will get back to their default values.
fontDescriptionUnsetFields :: (HasCallStack, MonadIO m) => FontDescription -> [FontMask] -> m ()
instance GHC.Classes.Eq GI.Pango.Structs.FontDescription.FontDescription
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.FontDescription.FontDescription
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.FontDescription.FontDescription
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.FontDescription.FontDescription
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.FontDescription.FontDescription
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.FontDescription.FontDescription)


-- | A <tt>PangoFontFamily</tt> is used to represent a family of related
--   font faces.
--   
--   The font faces in a family share a common design, but differ in slant,
--   weight, width or 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

-- | Gets the <tt>PangoFontFace</tt> of <i><tt>family</tt></i> with the
--   given name.
--   
--   <i>Since: 1.46</i>
fontFamilyGetFace :: (HasCallStack, MonadIO m, IsFontFamily a) => a -> Maybe Text -> m (Maybe FontFace)

-- | Gets the name of the family.
--   
--   The name is unique among all fonts for the font backend and can be
--   used in a <tt>PangoFontDescription</tt> 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.
--   
--   Such axes are also known as _variations_; see
--   <a>fontDescriptionSetVariations</a> for more information.
--   
--   <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.
--   
--   Note that the returned faces are not in any particular order, and
--   multiple faces may have the same name or characteristics.
--   
--   <tt>PangoFontFamily</tt> also implemented the <a>ListModel</a>
--   interface for enumerating faces.
fontFamilyListFaces :: (HasCallStack, MonadIO m, IsFontFamily a) => a -> m [FontFace]

-- | Get the value of the “<tt>is-monospace</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontFamily #isMonospace
--   </pre>
getFontFamilyIsMonospace :: (MonadIO m, IsFontFamily o) => o -> m Bool

-- | Get the value of the “<tt>is-variable</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontFamily #isVariable
--   </pre>
getFontFamilyIsVariable :: (MonadIO m, IsFontFamily o) => o -> m Bool

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontFamily #itemType
--   </pre>
getFontFamilyItemType :: (MonadIO m, IsFontFamily o) => o -> m GType

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontFamily #nItems
--   </pre>
getFontFamilyNItems :: (MonadIO m, IsFontFamily o) => o -> m Word32

-- | Get the value of the “<tt>name</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontFamily #name
--   </pre>
getFontFamilyName :: (MonadIO m, IsFontFamily o) => o -> m Text
instance GHC.Classes.Eq GI.Pango.Objects.FontFamily.FontFamily
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.ManagedPtrNewtype GI.Pango.Objects.FontFamily.FontFamily
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Objects.FontFamily.FontFamily
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontFamily.FontFamily
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.FontFamily.FontFamily
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Objects.FontFamily.FontFamily)


-- | A <tt>PangoFontFace</tt> is used to represent a group of fonts with
--   the same family, slant, weight, and 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

-- | Returns a font description that matches the face.
--   
--   The resulting font description will have the family, style, variant,
--   weight and stretch of the face, but its size field will be unset.
fontFaceDescribe :: (HasCallStack, MonadIO m, IsFontFace a) => a -> m FontDescription

-- | Gets a name representing the style of this face.
--   
--   Note that a font family may contain multiple faces with the same name
--   (e.g. a variable and a non-variable face for the same style).
fontFaceGetFaceName :: (HasCallStack, MonadIO m, IsFontFace a) => a -> m Text

-- | Gets the <tt>PangoFontFamily</tt> that <i><tt>face</tt></i> belongs
--   to.
--   
--   <i>Since: 1.46</i>
fontFaceGetFamily :: (HasCallStack, MonadIO m, IsFontFace a) => a -> m FontFamily

-- | Returns whether a <tt>PangoFontFace</tt> is synthesized.
--   
--   This will be the case if the underlying font rendering engine creates
--   this face from another face, by shearing, emboldening, lightening or
--   modifying it in some other way.
--   
--   <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 GHC.Classes.Eq GI.Pango.Objects.FontFace.FontFace
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.ManagedPtrNewtype GI.Pango.Objects.FontFace.FontFace
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Objects.FontFace.FontFace
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontFace.FontFace
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.FontFace.FontFace
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Objects.FontFace.FontFace)


-- | A <tt>PangoFontMetrics</tt> structure holds the overall metric
--   information for a font.
--   
--   The information in a <tt>PangoFontMetrics</tt> structure may be
--   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.
--   
--   For an overview of the most important metrics, see:
--   
--   &lt;picture&gt; &lt;source srcset="fontmetrics-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Font metrics"
--   src="fontmetrics-light.png"&gt; &lt;/picture&gt;
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

-- | 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 line height from a font metrics structure.
--   
--   The line height is the recommended distance between successive
--   baselines in wrapped text using this font.
--   
--   If the line height is not available, 0 is returned.
--   
--   <i>Since: 1.44</i>
fontMetricsGetHeight :: (HasCallStack, MonadIO m) => FontMetrics -> m Int32

-- | Gets the suggested position to draw the strikethrough.
--   
--   The value returned is the distance *above* 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 *above* 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

-- | Increase the reference count of a font metrics structure by one.
fontMetricsRef :: (HasCallStack, MonadIO m) => Maybe 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) => Maybe FontMetrics -> m ()
instance GHC.Classes.Eq GI.Pango.Structs.FontMetrics.FontMetrics
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.FontMetrics.FontMetrics
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.FontMetrics.FontMetrics
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.FontMetrics.FontMetrics
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.FontMetrics.FontMetrics
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.FontMetrics.FontMetrics)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.FontMetrics.FontMetrics tag


-- | The <tt>PangoGlyphGeometry</tt> structure contains width and
--   positioning information for a single glyph.
--   
--   Note that <i><tt>width</tt></i> is not guaranteed to be the same as
--   the glyph extents. Kerning and other positioning applied during
--   shaping will affect both the <i><tt>width</tt></i> and the
--   <i><tt>xOffset</tt></i> for the glyphs in the glyph string that
--   results from shaping.
--   
--   The information in this struct is intended for rendering the glyphs,
--   as follows:
--   
--   <ol>
--   <li>Assume the current point is (x, y)</li>
--   <li>Render the current glyph at (x + x_offset, y + y_offset),</li>
--   <li>Advance the current point to (x + width, y)</li>
--   <li>Render the next glyph</li>
--   </ol>
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

-- | 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 GHC.Classes.Eq GI.Pango.Structs.GlyphGeometry.GlyphGeometry
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.GlyphGeometry.GlyphGeometry
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.GlyphGeometry.GlyphGeometry
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.GlyphGeometry.GlyphGeometry
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphGeometry.GlyphGeometry tag


-- | A <tt>PangoGlyphVisAttr</tt> structure communicates information
--   between the shaping and rendering phases.
--   
--   Currently, it contains cluster start and color information. More
--   attributes may be added in the future.
--   
--   Clusters are stored in visual order, within the cluster, glyphs are
--   always ordered in logical order, since visual order is meaningless;
--   that is, in Arabic text, accent glyphs follow the glyphs for the base
--   character.
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

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

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

-- | Set the value of the “<tt>is_color</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphVisAttr [ #isColor <a>:=</a> value ]
--   </pre>
setGlyphVisAttrIsColor :: MonadIO m => GlyphVisAttr -> Word32 -> m ()
instance GHC.Classes.Eq GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr tag


-- | A <tt>PangoGlyphInfo</tt> structure represents a single glyph with
--   positioning information and visual attributes.
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

-- | 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 GHC.Classes.Eq GI.Pango.Structs.GlyphInfo.GlyphInfo
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.GlyphInfo.GlyphInfo
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.GlyphInfo.GlyphInfo
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.GlyphInfo.GlyphInfo
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphInfo.GlyphInfo tag


-- | The <tt>PangoLanguage</tt> structure is used to represent a language.
--   
--   <tt>PangoLanguage</tt> 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

-- | Convert a language tag to a <tt>PangoLanguage</tt>.
--   
--   The language tag must be in a RFC-3066 format. <tt>PangoLanguage</tt>
--   pointers 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 [func<i><tt>pango</tt></i>.Language.get_default] if you want to
--   get the <tt>PangoLanguage</tt> for the current locale of the process.
languageFromString :: (HasCallStack, MonadIO m) => Maybe Text -> m (Maybe Language)

-- | Returns the <tt>PangoLanguage</tt> for the current locale of the
--   process.
--   
--   On Unix systems, this is the return value is derived from
--   <tt>setlocale (LC_CTYPE, NULL)</tt>, 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 <tt>setlocale(LC_ALL, "")</tt> 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 the <tt><i>setlocale()</i></tt> manpage for more details.
--   
--   Note that the default language can change over the life of an
--   application.
--   
--   Also note that this function will not do the right thing if you use
--   per-thread locales with <tt><i>uselocale()</i></tt>. In that case, you
--   should just call <a>languageFromString</a> yourself.
--   
--   <i>Since: 1.16</i>
languageGetDefault :: (HasCallStack, MonadIO m) => m Language

-- | Returns the list of languages that the user prefers.
--   
--   The list is specified by the <tt>PANGO_LANGUAGE</tt> or
--   <tt>LANGUAGE</tt> environment variables, in order of preference. Note
--   that this list does not necessarily include the language returned by
--   [func<i><tt>pango</tt></i>.Language.get_default].
--   
--   When choosing language-specific resources, such as the sample text
--   returned by <a>languageGetSampleString</a>, you should first try the
--   default language, followed by the languages returned by this function.
--   
--   <i>Since: 1.48</i>
languageGetPreferred :: (HasCallStack, MonadIO m) => m (Maybe [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 [func<i><tt>pango</tt></i>.Language.get_default] 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:
--   
--   <pre>
--   pango_language_get_sample_string (pango_language_from_string ("xx"))
--   </pre>
languageGetSampleString :: (HasCallStack, MonadIO m) => Maybe Language -> m Text

-- | Determines the scripts used to to write <i><tt>language</tt></i>.
--   
--   If nothing is known about the language tag <i><tt>language</tt></i>,
--   or if <i><tt>language</tt></i> is <a>Nothing</a>, then <a>Nothing</a>
--   is returned. The list of scripts returned starts with the script that
--   the language uses most and continues to the one it uses least.
--   
--   The value <i><tt>numScript</tt></i> points at will be set to the
--   number of scripts in the returned array (or zero if <a>Nothing</a> is
--   returned).
--   
--   Most languages use only one script for writing, but there are some
--   that use two (Latin and Cyrillic for example), and a few use three
--   (Japanese for example). Applications should not make any assumptions
--   on the maximum number of scripts returned though, except that it is
--   positive if the return value is not <a>Nothing</a>, and it is a small
--   number.
--   
--   The <a>languageIncludesScript</a> function uses this function
--   internally.
--   
--   Note: while the return value is declared as <tt>PangoScript</tt>, the
--   returned values are from the <tt>GUnicodeScript</tt> enumeration,
--   which may have more values. Callers need to handle unknown values.
--   
--   <i>Since: 1.22</i>
languageGetScripts :: (HasCallStack, MonadIO m) => Maybe Language -> m (Maybe [Script])

-- | 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) => Maybe 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) => Maybe Language -> Text -> m Bool

-- | Gets the RFC-3066 format string representing the given language tag.
--   
--   Returns (transfer none): a string representing the language tag
languageToString :: (HasCallStack, MonadIO m) => Language -> m Text
instance GHC.Classes.Eq GI.Pango.Structs.Language.Language
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.Language.Language
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.Language.Language
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.Language.Language
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.Language.Language
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.Language.Language)


-- | The <tt>PangoLogAttr</tt> 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

-- | 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>break_inserts_hyphen</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logAttr #breakInsertsHyphen
--   </pre>
getLogAttrBreakInsertsHyphen :: MonadIO m => LogAttr -> m Word32

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

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

-- | Set the value of the “<tt>break_removes_preceding</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #breakRemovesPreceding <a>:=</a> value ]
--   </pre>
setLogAttrBreakRemovesPreceding :: 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 ()

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

-- | Set the value of the “<tt>reserved</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logAttr [ #reserved <a>:=</a> value ]
--   </pre>
setLogAttrReserved :: MonadIO m => LogAttr -> Word32 -> m ()
instance GHC.Classes.Eq GI.Pango.Structs.LogAttr.LogAttr
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.LogAttr.LogAttr
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.LogAttr.LogAttr
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.LogAttr.LogAttr
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.LogAttr.LogAttr tag


-- | The <tt>PangoRectangle</tt> structure represents a rectangle.
--   
--   <tt>PangoRectangle</tt> 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

-- | 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 GHC.Classes.Eq GI.Pango.Structs.Rectangle.Rectangle
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.Rectangle.Rectangle
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.Rectangle.Rectangle
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.Rectangle.Rectangle
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Rectangle.Rectangle tag


-- | A <tt>PangoMatrix</tt> specifies a transformation between user-space
--   and device coordinates.
--   
--   The transformation is given by
--   
--   <pre>
--   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;
--   </pre>
--   
--   <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

-- | 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 <tt>PangoMatrix</tt>.
--   
--   <i>Since: 1.6</i>
matrixCopy :: (HasCallStack, MonadIO m) => Maybe Matrix -> m (Maybe Matrix)

-- | Free a <tt>PangoMatrix</tt>.
--   
--   <i>Since: 1.6</i>
matrixFree :: (HasCallStack, MonadIO m) => Maybe 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) => Maybe 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) => Maybe Matrix -> m (Double, Double)

-- | Gets the slant ratio of a matrix.
--   
--   For a simple shear matrix in the form:
--   
--   1 λ 0 1
--   
--   this is simply λ.
--   
--   <i>Since: 1.50</i>
matrixGetSlantRatio :: (HasCallStack, MonadIO m) => Matrix -> m 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:
--   
--   <pre>
--   dx2 = dx1 * xx + dy1 * xy;
--   dy2 = dx1 * yx + dy1 * yy;
--   </pre>
--   
--   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) => Maybe 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.
--   
--   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 [func<i><tt>extentsToPixels</tt></i>]'s first argument.
--   
--   <i>Since: 1.16</i>
matrixTransformPixelRectangle :: (HasCallStack, MonadIO m) => Maybe 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) => Maybe 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 GHC.Classes.Eq GI.Pango.Structs.Matrix.Matrix
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.Matrix.Matrix
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.Matrix.Matrix
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.Matrix.Matrix
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.Matrix.Matrix
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.Matrix.Matrix)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Matrix.Matrix tag


module GI.Pango.Callbacks

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

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

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

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_AttrClassCopyFieldCallback :: MonadIO m => AttrClassCopyFieldCallback -> m (GClosure C_AttrClassCopyFieldCallback)

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

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>AttrClassCopyFieldCallback</a></tt>.
noAttrClassCopyFieldCallback :: Maybe AttrClassCopyFieldCallback

-- | Wrap a <a>AttrClassCopyFieldCallback</a> into a
--   <a>C_AttrClassCopyFieldCallback</a>.
wrap_AttrClassCopyFieldCallback :: Maybe (Ptr (FunPtr C_AttrClassCopyFieldCallback)) -> AttrClassCopyFieldCallback -> C_AttrClassCopyFieldCallback

-- | <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 = -- | __Returns:__ new copy of /@userData@/. IO (Ptr ())

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

-- | 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@/: a Pango attribute Attribute -> -- | __Returns:__ 'P.True' if the attribute should be selected for --   filtering, 'P.False' otherwise. IO Bool

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

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

-- | Callback used when enumerating fonts in a fontset.
--   
--   See <a>fontsetForeach</a>.
--   
--   <i>Since: 1.4</i>
type FontsetForeachFunc = -- | /@fontset@/: a @PangoFontset@ Fontset -> -- | /@font@/: a font from /@fontset@/ Font -> -- | __Returns:__ if 'P.True', stop iteration and return immediately. IO Bool

-- | Callback used when enumerating fonts in a fontset.
--   
--   See <a>fontsetForeach</a>.
--   
--   <i>Since: 1.4</i>
type FontsetForeachFunc_WithClosures = -- | /@fontset@/: a @PangoFontset@ Fontset -> -- | /@font@/: a font from /@fontset@/ Font -> -- | /@userData@/: callback data Ptr () -> -- | __Returns:__ if 'P.True', stop iteration and return immediately. IO Bool

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


-- | The <tt>PangoItem</tt> structure stores information about a segment of
--   text.
--   
--   You typically obtain <tt>PangoItems</tt> by itemizing a piece of text
--   with [func<i><tt>itemize</tt></i>].
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

-- | Add attributes to a <tt>PangoItem</tt>.
--   
--   The idea is that you have attributes that don't affect itemization,
--   such as font features, so you filter them out using
--   <a>attrListFilter</a>, itemize your text, then reapply the attributes
--   to the resulting items using this function.
--   
--   The <i><tt>iter</tt></i> should be positioned before the range of the
--   item, and will be advanced past it. This function is meant to be
--   called in a loop over the items resulting from itemization, while
--   passing the iter to each call.
--   
--   <i>Since: 1.44</i>
itemApplyAttrs :: (HasCallStack, MonadIO m) => Item -> AttrIterator -> m ()

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

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

-- | Returns the character offset of the item from the beginning of the
--   itemized text.
--   
--   If the item has not been obtained from Pango's itemization machinery,
--   then the character offset is not available. In that case, this
--   function returns -1.
--   
--   <i>Since: 1.54</i>
itemGetCharOffset :: (HasCallStack, MonadIO m) => Item -> m Int32

-- | Creates a new <tt>PangoItem</tt> 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 <tt>pango_item_split()</tt>
--   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 GHC.Classes.Eq GI.Pango.Structs.Item.Item
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.Item.Item
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.Item.Item
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.Item.Item
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.Item.Item
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.Item.Item)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Item.Item tag


-- | A <tt>PangoGlyphString</tt> 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

-- | Copy a glyph string and associated storage.
glyphStringCopy :: (HasCallStack, MonadIO m) => Maybe 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.
--   
--   Examples of logical (red) and ink (green) rects:
--   
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) => Maybe GlyphString -> m ()

-- | Given a <tt>PangoGlyphString</tt> and corresponding text, determine
--   the 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.
--   
--   This 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
--   <i><tt>geometry</tt></i>.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.
--   
--   The X position is measured from the left edge of the run. Character
--   positions are obtained using font metrics for ligatures where
--   available, and computed by dividing up each cluster into equal
--   portions, otherwise.
--   
--   &lt;picture&gt; &lt;source srcset="glyphstring-positions-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Glyph positions"
--   src="glyphstring-positions-light.png"&gt; &lt;/picture&gt;
glyphStringIndexToX :: (HasCallStack, MonadIO m) => GlyphString -> Text -> Int32 -> Analysis -> Int32 -> Bool -> m Int32

-- | Converts from character position to x position.
--   
--   This variant of <a>glyphStringIndexToX</a> additionally accepts a
--   <tt>PangoLogAttr</tt> array. The grapheme boundary information in it
--   can be used to disambiguate positioning inside some complex clusters.
--   
--   <i>Since: 1.50</i>
glyphStringIndexToXFull :: (HasCallStack, MonadIO m) => GlyphString -> Text -> Int32 -> Analysis -> Maybe LogAttr -> Int32 -> Bool -> m Int32

-- | Create a new <tt>PangoGlyphString</tt>.
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 GHC.Classes.Eq GI.Pango.Structs.GlyphString.GlyphString
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.GlyphString.GlyphString
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.GlyphString.GlyphString
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.GlyphString.GlyphString
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.GlyphString.GlyphString
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.GlyphString.GlyphString)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphString.GlyphString tag


-- | A <tt>PangoGlyphItemIter</tt> is an iterator over the clusters in a
--   <tt>PangoGlyphItem</tt>.
--   
--   The *forward direction* 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
--   <tt>glyph_item-&gt;item-&gt;analysis.level</tt> 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
--   <a>glyphItemIterInitStart</a> or <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:
--   
--   <pre>
--   PangoGlyphItemIter cluster_iter;
--   gboolean have_cluster;
--   
--   for (have_cluster = pango_glyph_item_iter_init_start (&amp;cluster_iter,
--                                                         glyph_item, text);
--        have_cluster;
--        have_cluster = pango_glyph_item_iter_next_cluster (&amp;cluster_iter))
--   {
--     ...
--   }
--   </pre>
--   
--   Note that <i><tt>text</tt></i> is the start of the text for layout,
--   which is then indexed by <tt>glyph_item-&gt;item-&gt;offset</tt> 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 <tt>PangoGlyphItemIter</tt> 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

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

-- | Frees a <tt>PangoGlyphItem</tt>Iter.
--   
--   <i>Since: 1.22</i>
glyphItemIterFree :: (HasCallStack, MonadIO m) => Maybe GlyphItemIter -> m ()

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

-- | Initializes a <tt>PangoGlyphItemIter</tt> structure to point to the
--   first cluster in a glyph item.
--   
--   See <tt>PangoGlyphItemIter</tt> 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 <tt>PangoGlyphItemIter</tt> 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
--   <tt>PangoGlyphItemIter</tt> 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 GHC.Classes.Eq GI.Pango.Structs.GlyphItemIter.GlyphItemIter
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.GlyphItemIter.GlyphItemIter
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.GlyphItemIter.GlyphItemIter
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.GlyphItemIter.GlyphItemIter
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.GlyphItemIter.GlyphItemIter
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.GlyphItemIter.GlyphItemIter)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphItemIter.GlyphItemIter tag


-- | A <tt>PangoGlyphItem</tt> is a pair of a <tt>PangoItem</tt> and the
--   glyphs resulting from shaping the items text.
--   
--   As an example of the usage of <tt>PangoGlyphItem</tt>, the results of
--   shaping text with <tt>PangoLayout</tt> is a list of
--   <tt>PangoLayoutLine</tt>, each of which contains a list of
--   <tt>PangoGlyphItem</tt>.
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

-- | Splits a shaped item (<tt>PangoGlyphItem</tt>) 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 <i><tt>item</tt></i>-&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 <tt>PangoGlyphItem</tt> structure.
--   
--   <i>Since: 1.20</i>
glyphItemCopy :: (HasCallStack, MonadIO m) => Maybe GlyphItem -> m (Maybe GlyphItem)

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

-- | Given a <tt>PangoGlyphItem</tt> and the corresponding text, determine
--   the 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 (Maybe GlyphItem)

-- | Get the value of the “<tt>end_x_offset</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItem #endXOffset
--   </pre>
getGlyphItemEndXOffset :: MonadIO m => GlyphItem -> m Int32

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

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

-- | Get the value of the “<tt>start_x_offset</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> glyphItem #startXOffset
--   </pre>
getGlyphItemStartXOffset :: MonadIO m => GlyphItem -> m Int32

-- | Set the value of the “<tt>start_x_offset</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> glyphItem [ #startXOffset <a>:=</a> value ]
--   </pre>
setGlyphItemStartXOffset :: MonadIO m => GlyphItem -> 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> glyphItem #yOffset
--   </pre>
getGlyphItemYOffset :: MonadIO m => GlyphItem -> 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> glyphItem [ #yOffset <a>:=</a> value ]
--   </pre>
setGlyphItemYOffset :: MonadIO m => GlyphItem -> Int32 -> m ()
instance GHC.Classes.Eq GI.Pango.Structs.GlyphItem.GlyphItem
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.GlyphItem.GlyphItem
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.GlyphItem.GlyphItem
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.GlyphItem.GlyphItem
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.GlyphItem.GlyphItem
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.GlyphItem.GlyphItem)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphItem.GlyphItem tag


-- | The <tt>PangoAttribute</tt> 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

-- | Returns the attribute cast to <tt>PangoAttrColor</tt>.
--   
--   This is mainly useful for language bindings.
--   
--   <i>Since: 1.50</i>
attributeAsColor :: (HasCallStack, MonadIO m) => Attribute -> m (Maybe AttrColor)

-- | Returns the attribute cast to <tt>PangoAttrFloat</tt>.
--   
--   This is mainly useful for language bindings.
--   
--   <i>Since: 1.50</i>
attributeAsFloat :: (HasCallStack, MonadIO m) => Attribute -> m (Maybe AttrFloat)

-- | Returns the attribute cast to <tt>PangoAttrFontDesc</tt>.
--   
--   This is mainly useful for language bindings.
--   
--   <i>Since: 1.50</i>
attributeAsFontDesc :: (HasCallStack, MonadIO m) => Attribute -> m (Maybe AttrFontDesc)

-- | Returns the attribute cast to <tt>PangoAttrFontFeatures</tt>.
--   
--   This is mainly useful for language bindings.
--   
--   <i>Since: 1.50</i>
attributeAsFontFeatures :: (HasCallStack, MonadIO m) => Attribute -> m (Maybe AttrFontFeatures)

-- | Returns the attribute cast to <tt>PangoAttrInt</tt>.
--   
--   This is mainly useful for language bindings.
--   
--   <i>Since: 1.50</i>
attributeAsInt :: (HasCallStack, MonadIO m) => Attribute -> m (Maybe AttrInt)

-- | Returns the attribute cast to <tt>PangoAttrLanguage</tt>.
--   
--   This is mainly useful for language bindings.
--   
--   <i>Since: 1.50</i>
attributeAsLanguage :: (HasCallStack, MonadIO m) => Attribute -> m (Maybe AttrLanguage)

-- | Returns the attribute cast to <tt>PangoAttrShape</tt>.
--   
--   This is mainly useful for language bindings.
--   
--   <i>Since: 1.50</i>
attributeAsShape :: (HasCallStack, MonadIO m) => Attribute -> m (Maybe AttrShape)

-- | Returns the attribute cast to <tt>PangoAttrSize</tt>.
--   
--   This is mainly useful for language bindings.
--   
--   <i>Since: 1.50</i>
attributeAsSize :: (HasCallStack, MonadIO m) => Attribute -> m (Maybe AttrSize)

-- | Returns the attribute cast to <tt>PangoAttrString</tt>.
--   
--   This is mainly useful for language bindings.
--   
--   <i>Since: 1.50</i>
attributeAsString :: (HasCallStack, MonadIO m) => Attribute -> m (Maybe AttrString)

-- | Make a copy of an attribute.
attributeCopy :: (HasCallStack, MonadIO m) => Attribute -> m Attribute

-- | Destroy a <tt>PangoAttribute</tt> 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 <a>ATTR_INDEX_TO_TEXT_END</a> 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 GHC.Classes.Eq GI.Pango.Structs.Attribute.Attribute
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.Attribute.Attribute
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.Attribute.Attribute
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.Attribute.Attribute
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.Attribute.Attribute
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.Attribute.Attribute)


-- | The <tt>PangoAttrString</tt> 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

-- | 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 GHC.Classes.Eq GI.Pango.Structs.AttrString.AttrString
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrString.AttrString
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.AttrString.AttrString
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.AttrString.AttrString
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrString.AttrString tag


-- | The <tt>PangoAttrSize</tt> 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

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

-- | Create a new font-size attribute in device units.
--   
--   <i>Since: 1.8</i>
attrSizeNewAbsolute :: (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 GHC.Classes.Eq GI.Pango.Structs.AttrSize.AttrSize
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrSize.AttrSize
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.AttrSize.AttrSize
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.AttrSize.AttrSize
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrSize.AttrSize tag


-- | The <tt>PangoAttrShape</tt> 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

-- | 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
--   <tt>PangoLayout</tt>.
attrShapeNew :: (HasCallStack, MonadIO m) => Rectangle -> Rectangle -> m Attribute

-- | Creates a new shape attribute.
--   
--   Like [func<i><tt>pango</tt></i>.AttrShape.new], but a user data
--   pointer is also provided; this pointer can be accessed when later
--   rendering the glyph.
--   
--   <i>Since: 1.8</i>
attrShapeNewWithData :: (HasCallStack, MonadIO m) => Rectangle -> Rectangle -> Ptr () -> Maybe AttrDataCopyFunc -> Maybe DestroyNotify -> 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_WithClosures)

-- | 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 GHC.Classes.Eq GI.Pango.Structs.AttrShape.AttrShape
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrShape.AttrShape
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.AttrShape.AttrShape
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.AttrShape.AttrShape
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrShape.AttrShape tag


-- | A <tt>PangoAttrList</tt> represents a list of attributes that apply to
--   a section of text.
--   
--   The attributes in a <tt>PangoAttrList</tt> 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 <tt>PangoAttrList</tt> 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 <tt>PangoAttrList</tt> for
--   more than one paragraph of text.
module GI.Pango.Structs.AttrList

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

-- | Insert the given attribute into the <tt>PangoAttrList</tt>.
--   
--   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 an
--   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) => Maybe AttrList -> m (Maybe AttrList)

-- | Checks whether <i><tt>list</tt></i> and <i><tt>otherList</tt></i>
--   contain the same attributes and whether those attributes apply to the
--   same ranges.
--   
--   Beware that this will return wrong values if any list contains
--   duplicates.
--   
--   <i>Since: 1.46</i>
attrListEqual :: (HasCallStack, MonadIO m) => AttrList -> AttrList -> m Bool

-- | Given a <tt>PangoAttrList</tt> 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)

-- | Deserializes a <tt>PangoAttrList</tt> from a string.
--   
--   This is the counterpart to <a>attrListToString</a>. See that functions
--   for details about the format.
--   
--   <i>Since: 1.50</i>
attrListFromString :: (HasCallStack, MonadIO m) => Text -> m (Maybe AttrList)

-- | Gets a list of all attributes in <i><tt>list</tt></i>.
--   
--   <i>Since: 1.44</i>
attrListGetAttributes :: (HasCallStack, MonadIO m) => AttrList -> m [Attribute]

-- | Create a iterator initialized to the beginning of the list.
--   
--   <i><tt>list</tt></i> must not be modified until this iterator is
--   freed.
attrListGetIterator :: (HasCallStack, MonadIO m) => AttrList -> m AttrIterator

-- | Insert the given attribute into the <tt>PangoAttrList</tt>.
--   
--   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 <tt>PangoAttrList</tt>.
--   
--   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) => Maybe 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>, and limited in length to
--   <i><tt>len</tt></i>).
--   
--   This operation proves useful for, for instance, inserting a pre-edit
--   string in the middle of an edit buffer.
--   
--   For backwards compatibility, the function behaves differently when
--   <i><tt>len</tt></i> is 0. In this case, the attributes from
--   <i><tt>other</tt></i> are not imited to <i><tt>len</tt></i>, and are
--   just overlayed on top of <i><tt>list</tt></i>.
--   
--   This mode is useful for merging two lists of attributes together.
attrListSplice :: (HasCallStack, MonadIO m) => AttrList -> AttrList -> Int32 -> Int32 -> m ()

-- | Serializes a <tt>PangoAttrList</tt> to a string.
--   
--   In the resulting string, serialized attributes are separated by
--   newlines or commas. Individual attributes are serialized to a string
--   of the form
--   
--   START END TYPE VALUE
--   
--   Where START and END are the indices (with -1 being accepted in place
--   of MAXUINT), TYPE is the nickname of the attribute value type, e.g.
--   _weight_ or _stretch_, and the value is serialized according to its
--   type:
--   
--   <ul>
--   <li>enum values as nick or numeric value</li>
--   <li>boolean values as _true_ or _false_</li>
--   <li>integers and floats as numbers</li>
--   <li>strings as string, optionally quoted</li>
--   <li>font features as quoted string</li>
--   <li>PangoLanguage as string</li>
--   <li>PangoFontDescription as serialized by
--   <a>fontDescriptionToString</a>, quoted</li>
--   <li>PangoColor as serialized by <a>colorToString</a></li>
--   </ul>
--   
--   Examples:
--   
--   <pre>
--   0 10 foreground red, 5 15 weight bold, 0 200 font-desc "Sans 10"
--   </pre>
--   
--   <pre>
--   0 -1 weight 700
--   0 100 family Times
--   </pre>
--   
--   To parse the returned value, use
--   [func<i><tt>pango</tt></i>.AttrList.from_string].
--   
--   Note that shape attributes can not be serialized.
--   
--   <i>Since: 1.50</i>
attrListToString :: (HasCallStack, MonadIO m) => AttrList -> m Text

-- | 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) => Maybe AttrList -> m ()

-- | Update indices of attributes in <i><tt>list</tt></i> for a change in
--   the text they refer to.
--   
--   The change that this function applies is removing
--   <i><tt>remove</tt></i> bytes at position <i><tt>pos</tt></i> and
--   inserting <i><tt>add</tt></i> bytes instead.
--   
--   Attributes that fall entirely in the (<i><tt>pos</tt></i>,
--   <i><tt>pos</tt></i> + <i><tt>remove</tt></i>) range are removed.
--   
--   Attributes that start or end inside the (<i><tt>pos</tt></i>,
--   <i><tt>pos</tt></i> + <i><tt>remove</tt></i>) range are shortened to
--   reflect the removal.
--   
--   Attributes start and end positions are updated if they are behind
--   <i><tt>pos</tt></i> + <i><tt>remove</tt></i>.
--   
--   <i>Since: 1.44</i>
attrListUpdate :: (HasCallStack, MonadIO m) => AttrList -> Int32 -> Int32 -> Int32 -> m ()
instance GHC.Classes.Eq GI.Pango.Structs.AttrList.AttrList
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrList.AttrList
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.AttrList.AttrList
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.AttrList.AttrList
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.AttrList.AttrList
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.AttrList.AttrList)


-- | The <tt>PangoAttrLanguage</tt> 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

-- | 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 GHC.Classes.Eq GI.Pango.Structs.AttrLanguage.AttrLanguage
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrLanguage.AttrLanguage
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.AttrLanguage.AttrLanguage
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.AttrLanguage.AttrLanguage
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrLanguage.AttrLanguage tag


-- | A <tt>PangoAttrIterator</tt> is used to iterate through a
--   <tt>PangoAttrList</tt>.
--   
--   A new iterator is created with <a>attrListGetIterator</a>. 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

-- | Copy a <tt>PangoAttrIterator</tt>.
attrIteratorCopy :: (HasCallStack, MonadIO m) => AttrIterator -> m AttrIterator

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

-- | Find the current attribute of a particular type at the iterator
--   location.
--   
--   When multiple attributes of the same type overlap, the attribute whose
--   range starts closest to the current location is used.
attrIteratorGet :: (HasCallStack, MonadIO m) => AttrIterator -> AttrType -> m (Maybe Attribute)

-- | 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 -> m (Maybe Language, [Attribute])

-- | 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 <tt>PangoAttribute</tt>. 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 GHC.Classes.Eq GI.Pango.Structs.AttrIterator.AttrIterator
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrIterator.AttrIterator
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.AttrIterator.AttrIterator
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.AttrIterator.AttrIterator
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.AttrIterator.AttrIterator
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.AttrIterator.AttrIterator)


-- | The <tt>PangoAttrInt</tt> 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

-- | 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 GHC.Classes.Eq GI.Pango.Structs.AttrInt.AttrInt
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrInt.AttrInt
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.AttrInt.AttrInt
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.AttrInt.AttrInt
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrInt.AttrInt tag


-- | The <tt>PangoAttrFontFeatures</tt> 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

-- | Create a new font features tag attribute.
--   
--   You can use this attribute to select OpenType font features like
--   small-caps, alternative glyphs, ligatures, etc. for fonts that support
--   them.
--   
--   <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 GHC.Classes.Eq GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures tag


-- | The <tt>PangoAttrFontDesc</tt> 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

-- | 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 GHC.Classes.Eq GI.Pango.Structs.AttrFontDesc.AttrFontDesc
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrFontDesc.AttrFontDesc
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.AttrFontDesc.AttrFontDesc
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.AttrFontDesc.AttrFontDesc
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrFontDesc.AttrFontDesc tag


-- | The <tt>PangoAttrFloat</tt> 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

-- | 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 GHC.Classes.Eq GI.Pango.Structs.AttrFloat.AttrFloat
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrFloat.AttrFloat
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.AttrFloat.AttrFloat
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.AttrFloat.AttrFloat
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrFloat.AttrFloat tag


-- | The <tt>PangoAttrColor</tt> 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

-- | 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 GHC.Classes.Eq GI.Pango.Structs.AttrColor.AttrColor
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrColor.AttrColor
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.AttrColor.AttrColor
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.AttrColor.AttrColor
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrColor.AttrColor tag


-- | The <tt>PangoAttrClass</tt> 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
--   <tt>PangoAttribute</tt>.
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

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

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

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

-- | 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 GHC.Classes.Eq GI.Pango.Structs.AttrClass.AttrClass
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.AttrClass.AttrClass
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.AttrClass.AttrClass
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.AttrClass.AttrClass
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrClass.AttrClass tag


-- | The <tt>PangoAnalysis</tt> 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

-- | 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 (Ptr ())

-- | 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 () -> 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 (Ptr ())

-- | 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 () -> m ()
instance GHC.Classes.Eq GI.Pango.Structs.Analysis.Analysis
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.Analysis.Analysis
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Pango.Structs.Analysis.Analysis
instance Data.GI.Base.BasicTypes.CallocPtr GI.Pango.Structs.Analysis.Analysis
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Analysis.Analysis tag


-- | <tt>PangoFontsetSimple</tt> is a implementation of the abstract
--   <tt>PangoFontset</tt> base class as an array of fonts.
--   
--   When creating a <tt>PangoFontsetSimple</tt>, you have to provide the
--   array of fonts that make up the fontset.
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

-- | Adds a font to the fontset.
--   
--   The fontset takes ownership of <i><tt>font</tt></i>.
fontsetSimpleAppend :: (HasCallStack, MonadIO m, IsFontsetSimple a, IsFont b) => a -> b -> m ()

-- | Creates a new <tt>PangoFontsetSimple</tt> 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 GHC.Classes.Eq GI.Pango.Objects.FontsetSimple.FontsetSimple
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.ManagedPtrNewtype GI.Pango.Objects.FontsetSimple.FontsetSimple
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Objects.FontsetSimple.FontsetSimple
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontsetSimple.FontsetSimple
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.FontsetSimple.FontsetSimple
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Objects.FontsetSimple.FontsetSimple)


-- | A <tt>PangoFontset</tt> represents a set of <tt>PangoFont</tt> to use
--   when rendering text.
--   
--   A <tt>PangoFontset</tt> is the result of resolving a
--   <tt>PangoFontDescription</tt> against a particular
--   <tt>PangoContext</tt>. 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

-- | 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 a
--   Unicode character.
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 GHC.Classes.Eq GI.Pango.Objects.Fontset.Fontset
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.ManagedPtrNewtype GI.Pango.Objects.Fontset.Fontset
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Objects.Fontset.Fontset
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Fontset.Fontset
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Fontset.Fontset
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Objects.Fontset.Fontset)


-- | A <tt>PangoFontMap</tt> represents the set of fonts available for a
--   particular rendering system.
--   
--   This is a virtual object with implementations being specific to
--   particular rendering systems.
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

-- | Forces a change in the context, which will cause any
--   <tt>PangoContext</tt> 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 <tt>PangoContext</tt> 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 <tt>PangoContext</tt>. For instance,
--   the GTK toolkit has, among others,
--   <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

-- | Gets a font family by name.
--   
--   <i>Since: 1.46</i>
fontMapGetFamily :: (HasCallStack, MonadIO m, IsFontMap a) => a -> Text -> m FontFamily

-- | 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
--   <tt>PangoFontMap</tt>, like in <tt>PangoContext</tt>.
--   
--   <i>Since: 1.32.4</i>
fontMapGetSerial :: (HasCallStack, MonadIO m, IsFontMap a) => a -> m Word32

-- | List all families for a fontmap.
--   
--   Note that the returned families are not in any particular order.
--   
--   <tt>PangoFontMap</tt> also implemented the <a>ListModel</a> interface
--   for enumerating families.
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)

-- | Returns a new font that is like <i><tt>font</tt></i>, except that its
--   size is multiplied by <i><tt>scale</tt></i>, its backend-dependent
--   configuration (e.g. cairo font options) is replaced by the one in
--   <i><tt>context</tt></i>, and its variations are replaced by
--   <i><tt>variations</tt></i>.
--   
--   <i>Since: 1.52</i>
fontMapReloadFont :: (HasCallStack, MonadIO m, IsFontMap a, IsFont b, IsContext c) => a -> b -> Double -> Maybe c -> Maybe Text -> m Font

-- | Get the value of the “<tt>item-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontMap #itemType
--   </pre>
getFontMapItemType :: (MonadIO m, IsFontMap o) => o -> m GType

-- | Get the value of the “<tt>n-items</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> fontMap #nItems
--   </pre>
getFontMapNItems :: (MonadIO m, IsFontMap o) => o -> m Word32
instance GHC.Classes.Eq GI.Pango.Objects.FontMap.FontMap
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.ManagedPtrNewtype GI.Pango.Objects.FontMap.FontMap
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Objects.FontMap.FontMap
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontMap.FontMap
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.FontMap.FontMap
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Objects.FontMap.FontMap)


-- | A <tt>PangoFont</tt> is used to represent a font in a
--   rendering-system-independent manner.
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

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

-- | Loads data previously created via <a>fontSerialize</a>.
--   
--   For a discussion of the supported format, see that function.
--   
--   Note: to verify that the returned font is identical to the one that
--   was serialized, you can compare <i><tt>bytes</tt></i> to the result of
--   serializing the font again.
--   
--   <i>Since: 1.50</i>
fontDeserialize :: (HasCallStack, MonadIO m, IsContext a) => a -> Bytes -> m (Maybe Font)

-- | Computes the coverage map for a given font and language tag.
fontGetCoverage :: (HasCallStack, MonadIO m, IsFont a) => a -> Language -> m Coverage

-- | Gets the <tt>PangoFontFace</tt> to which <i><tt>font</tt></i> belongs.
--   
--   <i>Since: 1.46</i>
fontGetFace :: (HasCallStack, MonadIO m, IsFont a) => a -> m FontFace

-- | Obtain the OpenType features that are provided by the font.
--   
--   These are passed to the rendering system, together with features that
--   have been explicitly set via attributes.
--   
--   Note that this does not include OpenType features which the rendering
--   system enables by default.
--   
--   <i>Since: 1.44</i>
fontGetFeatures :: (HasCallStack, MonadIO m, IsFont a) => a -> [FeatureT] -> Word32 -> m ([FeatureT], Word32)

-- | Gets the font map for which the font was created.
--   
--   Note that the font maintains a *weak* 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
--   <tt>PangoContext</tt> holds a reference to the font map.
--   
--   <i>Since: 1.10</i>
fontGetFontMap :: (HasCallStack, MonadIO m, IsFont a) => Maybe 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) => Maybe a -> Word32 -> m (Rectangle, Rectangle)

-- | Returns the languages that are supported by <i><tt>font</tt></i>.
--   
--   If the font backend does not provide this information, <a>Nothing</a>
--   is returned. For the fontconfig backend, this corresponds to the
--   FC_LANG member of the FcPattern.
--   
--   The returned array is only valid as long as the font and its fontmap
--   are valid.
--   
--   <i>Since: 1.50</i>
fontGetLanguages :: (HasCallStack, MonadIO m, IsFont a) => a -> m (Maybe [Language])

-- | 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) => Maybe a -> Maybe Language -> m FontMetrics

-- | Returns whether the font provides a glyph for this character.
--   
--   <i>Since: 1.44</i>
fontHasChar :: (HasCallStack, MonadIO m, IsFont a) => a -> Char -> m Bool

-- | Serializes the <i><tt>font</tt></i> in a way that can be uniquely
--   identified.
--   
--   There are no guarantees about the format of the output across
--   different versions of Pango.
--   
--   The intended use of this function is testing, benchmarking and
--   debugging. The format is not meant as a permanent storage format.
--   
--   To recreate a font from its serialized form, use
--   [func<i><tt>pango</tt></i>.Font.deserialize].
--   
--   <i>Since: 1.50</i>
fontSerialize :: (HasCallStack, MonadIO m, IsFont a) => a -> m Bytes
instance GHC.Classes.Eq GI.Pango.Objects.Font.Font
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.ManagedPtrNewtype GI.Pango.Objects.Font.Font
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Objects.Font.Font
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Font.Font
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Font.Font
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Objects.Font.Font)


-- | A <tt>PangoContext</tt> stores global information used to control the
--   itemization process.
--   
--   The information stored by <tt>PangoContext</tt> includes the fontmap
--   used to look up fonts, and default values such as the default
--   language, default gravity, or default font.
--   
--   To obtain a <tt>PangoContext</tt>, use <a>fontMapCreateContext</a>.
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

-- | Forces a change in the context, which will cause any
--   <tt>PangoLayout</tt> 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 (Maybe FontDescription)

-- | Gets the <tt>PangoFontMap</tt> used to look up fonts for this context.
--   
--   <i>Since: 1.6</i>
contextGetFontMap :: (HasCallStack, MonadIO m, IsContext a) => a -> m (Maybe 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
--   [func<i><tt>pango</tt></i>.Gravity.get_for_matrix] 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 <tt>PangoFontDescription</tt> is interpreted in the same way as by
--   [func<i><tt>itemize</tt></i>], and the family name may be a comma
--   separated list of names. 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 whether font rendering with this context should round glyph
--   positions and widths.
--   
--   <i>Since: 1.44</i>
contextGetRoundGlyphPositions :: (HasCallStack, MonadIO m, IsContext a) => a -> m Bool

-- | 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
--   <tt>PangoFontMap</tt> 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
--   <tt>PangoContext</tt>, and is only useful when implementing objects
--   that need update when their <tt>PangoContext</tt> changes, like
--   <tt>PangoLayout</tt>.
--   
--   <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 <tt>PangoContext</tt> 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 <tt>PangoContext</tt>. For instance,
--   the GTK toolkit has, among others,
--   <tt>gtk_widget_get_pango_context()</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 -> Maybe 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
--   <tt>PangoContext</tt> obtained via one of the recommended methods
--   should already have a suitable font map.
contextSetFontMap :: (HasCallStack, MonadIO m, IsContext a, IsFontMap b) => a -> Maybe 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 to <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 [func<i><tt>pango</tt></i>.Language.get_default].
contextSetLanguage :: (HasCallStack, MonadIO m, IsContext a) => a -> Maybe 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 ()

-- | Sets whether font rendering with this context should round glyph
--   positions and widths to integral positions, in device units.
--   
--   This is useful when the renderer can't handle subpixel positioning of
--   glyphs.
--   
--   The default value is to round glyph positions, to remain compatible
--   with previous Pango behavior.
--   
--   <i>Since: 1.44</i>
contextSetRoundGlyphPositions :: (HasCallStack, MonadIO m, IsContext a) => a -> Bool -> m ()
instance GHC.Classes.Eq GI.Pango.Objects.Context.Context
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.ManagedPtrNewtype GI.Pango.Objects.Context.Context
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Objects.Context.Context
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Context.Context
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Context.Context
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Objects.Context.Context)


module GI.Pango.Functions

-- | Create a new allow-breaks attribute.
--   
--   If breaks are disabled, the range will be kept in a single run, as far
--   as possible.
--   
--   <i>Since: 1.44</i>
attrAllowBreaksNew :: (HasCallStack, MonadIO m) => Bool -> m Attribute

-- | 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 baseline displacement attribute.
--   
--   The effect of this attribute is to shift the baseline of a run,
--   relative to the run of preceding run.
--   
--   &lt;picture&gt; &lt;source srcset="baseline-shift-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Baseline Shift"
--   src="baseline-shift-light.png"&gt; &lt;/picture&gt;
--   
--   <i>Since: 1.50</i>
attrBaselineShiftNew :: (HasCallStack, MonadIO m) => Int32 -> m Attribute

-- | Apply customization from attributes to the breaks in
--   <i><tt>attrs</tt></i>.
--   
--   The line breaks are assumed to have been produced by
--   <a>defaultBreak</a> and <a>tailorBreak</a>.
--   
--   <i>Since: 1.50</i>
attrBreak :: (HasCallStack, MonadIO m) => Text -> Int32 -> AttrList -> Int32 -> [LogAttr] -> m ()

-- | 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 font scale attribute.
--   
--   The effect of this attribute is to change the font size of a run,
--   relative to the size of preceding run.
--   
--   <i>Since: 1.50</i>
attrFontScaleNew :: (HasCallStack, MonadIO m) => FontScale -> 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 insert-hyphens attribute.
--   
--   Pango will insert hyphens when breaking lines in the middle of a word.
--   This attribute can be used to suppress the hyphen.
--   
--   <i>Since: 1.44</i>
attrInsertHyphensNew :: (HasCallStack, MonadIO m) => Bool -> m Attribute

-- | Create a new letter-spacing attribute.
--   
--   <i>Since: 1.6</i>
attrLetterSpacingNew :: (HasCallStack, MonadIO m) => Int32 -> m Attribute

-- | Modify the height of logical line extents by a factor.
--   
--   This affects the values returned by <a>layoutLineGetExtents</a>,
--   <a>layoutLineGetPixelExtents</a> and <a>layoutIterGetLineExtents</a>.
--   
--   <i>Since: 1.50</i>
attrLineHeightNew :: (HasCallStack, MonadIO m) => Double -> m Attribute

-- | Override the height of logical line extents to be
--   <i><tt>height</tt></i>.
--   
--   This affects the values returned by <a>layoutLineGetExtents</a>,
--   <a>layoutLineGetPixelExtents</a> and <a>layoutIterGetLineExtents</a>.
--   
--   <i>Since: 1.50</i>
attrLineHeightNewAbsolute :: (HasCallStack, MonadIO m) => Int32 -> m Attribute

-- | Create a new overline color attribute.
--   
--   This attribute modifies the color of overlines. If not set, overlines
--   will use the foreground color.
--   
--   <i>Since: 1.46</i>
attrOverlineColorNew :: (HasCallStack, MonadIO m) => Word16 -> Word16 -> Word16 -> m Attribute

-- | Create a new overline-style attribute.
--   
--   <i>Since: 1.46</i>
attrOverlineNew :: (HasCallStack, MonadIO m) => Overline -> 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

-- | Marks the range of the attribute as a single sentence.
--   
--   Note that this may require adjustments to word and sentence
--   classification around the range.
--   
--   <i>Since: 1.50</i>
attrSentenceNew :: (HasCallStack, MonadIO m) => m Attribute

-- | Create a new attribute that influences how invisible characters are
--   rendered.
--   
--   <i>Since: 1.44</i>
attrShowNew :: (HasCallStack, MonadIO m) => [ShowFlags] -> 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 attribute that influences how characters are transformed
--   during shaping.
--   
--   <i>Since: 1.50</i>
attrTextTransformNew :: (HasCallStack, MonadIO m) => TextTransform -> 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

-- | Marks the range of the attribute as a single word.
--   
--   Note that this may require adjustments to word and sentence
--   classification around the range.
--   
--   <i>Since: 1.50</i>
attrWordNew :: (HasCallStack, MonadIO m) => 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>.

-- | <i>Deprecated: (Since version 1.44)Use <a>defaultBreak</a>,
--   <a>tailorBreak</a> and <a>attrBreak</a>.</i>
break :: (HasCallStack, MonadIO m) => Text -> Int32 -> Analysis -> [LogAttr] -> m ()

-- | This is the default break algorithm.
--   
--   It applies rules from the <a>Unicode Line Breaking Algorithm</a>
--   without language-specific tailoring, therefore the
--   <i><tt>analyis</tt></i> argument is unused and can be <a>Nothing</a>.
--   
--   See <a>tailorBreak</a> for language-specific breaks.
--   
--   See <a>attrBreak</a> for attribute-based customization.
defaultBreak :: (HasCallStack, MonadIO m) => Text -> Int32 -> Maybe Analysis -> LogAttr -> Int32 -> m ()

-- | Converts extents from Pango units to device units.
--   
--   The conversion is done by 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
--   next paragraph (index after all delimiters) is stored n
--   <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)

-- | Computes a <tt>PangoLogAttr</tt> for each character in
--   <i><tt>text</tt></i>.
--   
--   The <i><tt>attrs</tt></i> array must have one <tt>PangoLogAttr</tt>
--   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 ()

-- | Returns the mirrored character of a Unicode character.
--   
--   Mirror characters are determined by the Unicode mirrored property.

-- | <i>Deprecated: (Since version 1.30)Use <a>unicharGetMirrorChar</a>
--   instead; the docs for that function provide full details.</i>
getMirrorChar :: (HasCallStack, MonadIO m) => Char -> Char -> m Bool

-- | Checks if a character that should not be normally rendered.
--   
--   This includes all Unicode characters with "ZERO WIDTH" in their name,
--   as well as *bidi* 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 font.
--   
--   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 <tt>pango_itemize()</tt>, but with an explicitly specified base
--   direction.
--   
--   The base direction is used when computing bidirectional levels.
--   [func<i><tt>itemize</tt></i>] gets the base direction from the
--   <tt>PangoContext</tt> (see <a>contextSetBaseDir</a>).
--   
--   <i>Since: 1.4</i>
itemizeWithBaseDir :: (HasCallStack, MonadIO m, IsContext a) => a -> Direction -> Text -> Int32 -> Int32 -> AttrList -> Maybe AttrIterator -> m [Item]

-- | Return the bidirectional embedding levels of the input paragraph.
--   
--   The bidirectional embedding levels are defined by the
--   &lt;<a>http://www.unicode.org/reports/tr9/</a> Unicode Bidirectional
--   Algorithm&gt;.
--   
--   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

-- | Finishes parsing markup.
--   
--   After feeding a Pango markup parser some data with
--   <a>markupParseContextParse</a>, use this function to get the list of
--   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)

-- | Incrementally parses marked-up text to create a plain-text string and
--   an attribute list.
--   
--   See the <a>Pango Markup</a> docs for details about the supported
--   markup.
--   
--   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
--   [func<i><tt>markupParserFinish</tt></i>]. 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 [struct<i><tt>gLib</tt></i>.MarkupParseContext]. When
--   done with feeding markup to the parser, use
--   [func<i><tt>markupParserFinish</tt></i>] 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
--   <a>parseMarkup</a> API is recommended instead.
--   
--   <i>Since: 1.31.0</i>
markupParserNew :: (HasCallStack, MonadIO m) => Char -> m MarkupParseContext

-- | 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 to create a plain-text string and an attribute
--   list.
--   
--   See the <a>Pango Markup</a> docs for details about the supported
--   markup.
--   
--   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
--   [func<i><tt>markupParserNew</tt></i>].
--   
--   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)

-- | Parses a font stretch.
--   
--   The allowed values are "ultra_condensed", "extra_condensed",
--   "condensed", "semi_condensed", "normal", "semi_expanded", "expanded",
--   "extra_expanded" and "ultra_expanded". Case variations are ignored and
--   the '_' characters may be omitted.
parseStretch :: (HasCallStack, MonadIO m) => Text -> Bool -> m (Bool, Stretch)

-- | Parses a font style.
--   
--   The allowed values are "normal", "italic" and "oblique", case
--   variations being ignored.
parseStyle :: (HasCallStack, MonadIO m) => Text -> Bool -> m (Bool, Style)

-- | Parses a font variant.
--   
--   The allowed values are "normal", "small-caps", "all-small-caps",
--   "petite-caps", "all-petite-caps", "unicase" and "title-caps", case
--   variations being ignored.
parseVariant :: (HasCallStack, MonadIO m) => Text -> Bool -> m (Bool, Variant)

-- | Parses a font weight.
--   
--   The allowed values are "heavy", "ultrabold", "bold", "normal",
--   "light", "ultraleight" and integers. Case variations are ignored.
parseWeight :: (HasCallStack, MonadIO m) => Text -> Bool -> m (Bool, Weight)

-- | Quantizes the thickness and position of a line to whole device pixels.
--   
--   This is typically used for underline or strikethrough. 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 () -> String -> m Int32

-- | Reorder items from logical order to visual order.
--   
--   The visual order is determined from the associated directional levels
--   of the items. The original list is unmodified.
--   
--   (Please open a bug if you use this function. It is not a particularly
--   convenient interface, and the code is duplicated elsewhere in Pango
--   for that reason.)
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 <tt>GString</tt> 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 -> String -> m (Bool, Text)

-- | Scans a word into a <tt>GString</tt> 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 -> String -> m (Bool, Text)

-- | Convert the characters in <i><tt>text</tt></i> into glyphs.
--   
--   Given a segment of text and the corresponding <tt>PangoAnalysis</tt>
--   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.
--   
--   Some aspects of hyphen insertion and text transformation (in
--   particular, capitalization) require log attrs, and thus can only be
--   handled by <a>shapeItem</a>.
--   
--   Note that the extra attributes in the <i><tt>analyis</tt></i> that is
--   returned from <a>itemize</a> have indices that are relative to the
--   entire paragraph, so you need to subtract the item offset from their
--   indices before calling <a>shape</a>.
shape :: (HasCallStack, MonadIO m) => Text -> Int32 -> Analysis -> GlyphString -> m ()

-- | Convert the characters in <i><tt>text</tt></i> into glyphs.
--   
--   Given a segment of text and the corresponding <tt>PangoAnalysis</tt>
--   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.
--   
--   Some aspects of hyphen insertion and text transformation (in
--   particular, capitalization) require log attrs, and thus can only be
--   handled by <a>shapeItem</a>.
--   
--   Note that the extra attributes in the <i><tt>analyis</tt></i> that is
--   returned from <a>itemize</a> have indices that are relative to the
--   entire paragraph, so you do not pass the full paragraph text as
--   <i><tt>paragraphText</tt></i>, you need to subtract the item offset
--   from their indices before calling <a>shapeFull</a>.
--   
--   <i>Since: 1.32</i>
shapeFull :: (HasCallStack, MonadIO m) => Text -> Int32 -> Maybe Text -> Int32 -> Analysis -> GlyphString -> m ()

-- | Convert the characters in <i><tt>item</tt></i> into glyphs.
--   
--   This is similar to <a>shapeWithFlags</a>, except it takes a
--   <tt>PangoItem</tt> instead of separate <i><tt>itemText</tt></i> and
--   <i><tt>analysis</tt></i> arguments.
--   
--   It also takes <i><tt>logAttrs</tt></i>, which are needed for
--   implementing some aspects of hyphen insertion and text transforms (in
--   particular, capitalization).
--   
--   Note that the extra attributes in the <i><tt>analyis</tt></i> that is
--   returned from <a>itemize</a> have indices that are relative to the
--   entire paragraph, so you do not pass the full paragraph text as
--   <i><tt>paragraphText</tt></i>, you need to subtract the item offset
--   from their indices before calling <a>shapeWithFlags</a>.
--   
--   <i>Since: 1.50</i>
shapeItem :: (HasCallStack, MonadIO m) => Item -> Maybe Text -> Int32 -> Maybe LogAttr -> GlyphString -> [ShapeFlags] -> m ()

-- | Convert the characters in <i><tt>text</tt></i> into glyphs.
--   
--   Given a segment of text and the corresponding <tt>PangoAnalysis</tt>
--   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>shapeFull</a>, except it also takes flags that
--   can influence the shaping process.
--   
--   Some aspects of hyphen insertion and text transformation (in
--   particular, capitalization) require log attrs, and thus can only be
--   handled by <a>shapeItem</a>.
--   
--   Note that the extra attributes in the <i><tt>analyis</tt></i> that is
--   returned from <a>itemize</a> have indices that are relative to the
--   entire paragraph, so you do not pass the full paragraph text as
--   <i><tt>paragraphText</tt></i>, you need to subtract the item offset
--   from their indices before calling <a>shapeWithFlags</a>.
--   
--   <i>Since: 1.44</i>
shapeWithFlags :: (HasCallStack, MonadIO m) => Text -> Int32 -> Maybe Text -> Int32 -> Analysis -> GlyphString -> [ShapeFlags] -> 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]

-- | Apply language-specific tailoring to the breaks in
--   <i><tt>attrs</tt></i>.
--   
--   The line breaks are assumed to have been produced by
--   <a>defaultBreak</a>.
--   
--   If <i><tt>offset</tt></i> is not -1, it is used to apply attributes
--   from <i><tt>analysis</tt></i> that are relevant to line breaking.
--   
--   Note that it is better to pass -1 for <i><tt>offset</tt></i> and use
--   <a>attrBreak</a> to apply attributes to the whole paragraph.
--   
--   <i>Since: 1.44</i>
tailorBreak :: (HasCallStack, MonadIO m) => Text -> Int32 -> Analysis -> Int32 -> [LogAttr] -> m ()

-- | 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.
--   
--   The inherent direction is either <tt>PANGO_DIRECTION_LTR</tt>,
--   <tt>PANGO_DIRECTION_RTL</tt>, or <tt>PANGO_DIRECTION_NEUTRAL</tt>.
--   
--   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,
--   [func<i><tt>pango</tt></i>.BidiType.for_unichar] can be used instead.
unicharDirection :: (HasCallStack, MonadIO m) => Char -> m Direction

-- | Converts a floating-point number to Pango units.
--   
--   The conversion is done by multiplying <i><tt>d</tt></i> by
--   <a>SCALE</a> and rounding the result to nearest integer.
--   
--   <i>Since: 1.16</i>
unitsFromDouble :: (HasCallStack, MonadIO m) => Double -> m Int32

-- | Converts a number in Pango units to floating-point.
--   
--   The conversion is done by dividing <i><tt>i</tt></i> by <a>SCALE</a>.
--   
--   <i>Since: 1.16</i>
unitsToDouble :: (HasCallStack, MonadIO m) => Int32 -> m Double

-- | Returns the encoded version of Pango available at run-time.
--   
--   This is similar to the macro <tt><i>PANGO_VERSION</i></tt> except that
--   the macro returns the encoded 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 <a>VERSION_MAJOR</a>,
--   <a>VERSION_MINOR</a>, <a>VERSION_MICRO</a> 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)

-- | Returns the version of Pango available at run-time.
--   
--   This is similar to the macro <a>VERSION_STRING</a> except that the
--   macro returns the version available at compile-time.
--   
--   <i>Since: 1.16</i>
versionString :: (HasCallStack, MonadIO m) => m Text


-- | A <tt>PangoScriptIter</tt> 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

-- | Frees a <tt>PangoScriptIter</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)
--   
--   Note that while the type of the <i><tt>script</tt></i> argument is
--   declared as <tt>PangoScript</tt>, as of Pango 1.18, this function
--   simply returns <tt>GUnicodeScript</tt> values. Callers must be
--   prepared to handle unknown values.
--   
--   <i>Since: 1.4</i>
scriptIterGetRange :: (HasCallStack, MonadIO m) => ScriptIter -> m (Text, Text, Script)

-- | Create a new <tt>PangoScriptIter</tt>, used to break a string of
--   Unicode text into runs by Unicode script.
--   
--   No copy is made of <i><tt>text</tt></i>, so the caller needs to make
--   sure it remains valid until the iterator is freed with
--   <a>scriptIterFree</a>.
--   
--   <i>Since: 1.4</i>
scriptIterNew :: (HasCallStack, MonadIO m) => Text -> Int32 -> m ScriptIter

-- | Advances a <tt>PangoScriptIter</tt> 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 GHC.Classes.Eq GI.Pango.Structs.ScriptIter.ScriptIter
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.ScriptIter.ScriptIter
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.ScriptIter.ScriptIter
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.ScriptIter.ScriptIter
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.ScriptIter.ScriptIter
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.ScriptIter.ScriptIter)


-- | A <tt>PangoTabArray</tt> contains an array of tab stops.
--   
--   <tt>PangoTabArray</tt> can be used to set tab stops in a
--   <tt>PangoLayout</tt>. Each tab stop has an alignment, a position, and
--   optionally a character to use as decimal point.
module GI.Pango.Structs.TabArray

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

-- | Copies a <tt>PangoTabArray</tt>.
tabArrayCopy :: (HasCallStack, MonadIO m) => TabArray -> m TabArray

-- | Frees a tab array and associated resources.
tabArrayFree :: (HasCallStack, MonadIO m) => TabArray -> m ()

-- | Deserializes a <tt>PangoTabArray</tt> from a string.
--   
--   This is the counterpart to <a>tabArrayToString</a>. See that functions
--   for details about the format.
--   
--   <i>Since: 1.50</i>
tabArrayFromString :: (HasCallStack, MonadIO m) => Text -> m (Maybe TabArray)

-- | Gets the Unicode character to use as decimal point.
--   
--   This is only relevant for tabs with <a>TabAlignDecimal</a> alignment,
--   which align content at the first occurrence of the decimal point
--   character.
--   
--   The default value of 0 means that Pango will use the decimal point
--   according to the current locale.
--   
--   <i>Since: 1.50</i>
tabArrayGetDecimalPoint :: (HasCallStack, MonadIO m) => TabArray -> Int32 -> m Char

-- | 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 Unicode character to use as decimal point.
--   
--   This is only relevant for tabs with <a>TabAlignDecimal</a> alignment,
--   which align content at the first occurrence of the decimal point
--   character.
--   
--   By default, Pango uses the decimal point according to the current
--   locale.
--   
--   <i>Since: 1.50</i>
tabArraySetDecimalPoint :: (HasCallStack, MonadIO m) => TabArray -> Int32 -> Char -> m ()

-- | Sets whether positions in this array are specified in pixels.
--   
--   <i>Since: 1.50</i>
tabArraySetPositionsInPixels :: (HasCallStack, MonadIO m) => TabArray -> Bool -> m ()

-- | Sets the alignment and location of a tab stop.
tabArraySetTab :: (HasCallStack, MonadIO m) => TabArray -> Int32 -> TabAlign -> Int32 -> m ()

-- | Utility function to ensure that the tab stops are in increasing order.
--   
--   <i>Since: 1.50</i>
tabArraySort :: (HasCallStack, MonadIO m) => TabArray -> m ()

-- | Serializes a <tt>PangoTabArray</tt> to a string.
--   
--   No guarantees are made about the format of the string, it may change
--   between Pango versions.
--   
--   The intended use of this function is testing and debugging. The format
--   is not meant as a permanent storage format.
--   
--   <i>Since: 1.50</i>
tabArrayToString :: (HasCallStack, MonadIO m) => TabArray -> m Text
instance GHC.Classes.Eq GI.Pango.Structs.TabArray.TabArray
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.TabArray.TabArray
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.TabArray.TabArray
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.TabArray.TabArray
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.TabArray.TabArray
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.TabArray.TabArray)


-- | A <tt>PangoLayoutLine</tt> represents one of the lines resulting from
--   laying out a paragraph via <tt>PangoLayout</tt>.
--   
--   <tt>PangoLayoutLine</tt> structures are obtained by calling
--   <a>layoutGetLine</a> and are only valid until the text, attributes, or
--   settings of the parent <tt>PangoLayout</tt> are modified.
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

-- | 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 height of the line, as the maximum of the heights of
--   fonts used in this line.
--   
--   Note that the actual baseline-to-baseline distance between lines of
--   text is influenced by other factors, such as <a>layoutSetSpacing</a>
--   and <a>layoutSetLineSpacing</a>.
--   
--   <i>Since: 1.44</i>
layoutLineGetHeight :: (HasCallStack, MonadIO m) => LayoutLine -> m Int32

-- | Returns the length of the line, in bytes.
--   
--   <i>Since: 1.50</i>
layoutLineGetLength :: (HasCallStack, MonadIO m) => LayoutLine -> m Int32

-- | 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
--   [func<i><tt>extentsToPixels</tt></i>] 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 [func<i><tt>extentsToPixels</tt></i>]).
layoutLineGetPixelExtents :: (HasCallStack, MonadIO m) => LayoutLine -> m (Rectangle, Rectangle)

-- | Returns the resolved direction of the line.
--   
--   <i>Since: 1.50</i>
layoutLineGetResolvedDirection :: (HasCallStack, MonadIO m) => LayoutLine -> m Direction

-- | Returns the start index of the line, as byte index into the text of
--   the layout.
--   
--   <i>Since: 1.50</i>
layoutLineGetStartIndex :: (HasCallStack, MonadIO m) => LayoutLine -> m Int32

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

-- | Returns whether this is the first line of the paragraph.
--   
--   <i>Since: 1.50</i>
layoutLineIsParagraphStart :: (HasCallStack, MonadIO m) => LayoutLine -> m Bool

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

-- | Decrease the reference count of a <tt>PangoLayoutLine</tt> 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 GHC.Classes.Eq GI.Pango.Structs.LayoutLine.LayoutLine
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.LayoutLine.LayoutLine
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.LayoutLine.LayoutLine
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.LayoutLine.LayoutLine
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.LayoutLine.LayoutLine
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.LayoutLine.LayoutLine)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.LayoutLine.LayoutLine tag


-- | A <tt>PangoLayoutIter</tt> can be used to iterate over the visual
--   extents of a <tt>PangoLayout</tt>.
--   
--   To obtain a <tt>PangoLayoutIter</tt>, use <a>layoutGetIter</a>.
--   
--   The <tt>PangoLayoutIter</tt> structure is opaque, and has no
--   user-visible fields.
module GI.Pango.Structs.LayoutIter

-- | Memory-managed wrapper type.
newtype LayoutIter
LayoutIter :: ManagedPtr LayoutIter -> 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 <tt>PangoLayoutIter</tt>.
--   
--   <i>Since: 1.20</i>
layoutIterCopy :: (HasCallStack, MonadIO m) => Maybe LayoutIter -> m (Maybe LayoutIter)

-- | Frees an iterator that's no longer in use.
layoutIterFree :: (HasCallStack, MonadIO m) => Maybe LayoutIter -> m ()

-- | Gets the Y position of the current line's baseline, in layout
--   coordinates.
--   
--   Layout coordinates have the origin at the top left of the entire
--   layout.
layoutIterGetBaseline :: (HasCallStack, MonadIO m) => LayoutIter -> m Int32

-- | Gets the extents of the current character, in layout coordinates.
--   
--   Layout coordinates have the origin at 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.
--   
--   Layout coordinates have the origin at 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 <tt>PangoLayoutIter</tt>.
--   
--   <i>Since: 1.20</i>
layoutIterGetLayout :: (HasCallStack, MonadIO m) => LayoutIter -> m (Maybe Layout)

-- | Obtains the extents of the <tt>PangoLayout</tt> being iterated over.
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 (Maybe LayoutLine)

-- | Obtains the extents of the current line.
--   
--   Extents are in layout coordinates (origin is the top-left corner of
--   the entire <tt>PangoLayout</tt>). 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 (Maybe LayoutLine)

-- | Divides the vertical space in the <tt>PangoLayout</tt> 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).
--   
--   Note: Since 1.44, Pango uses line heights for placing lines, and there
--   may be gaps between the ranges returned by this function.
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 Y position of the current run's baseline, in layout
--   coordinates.
--   
--   Layout coordinates have the origin at the top left of the entire
--   layout.
--   
--   The run baseline can be different from the line baseline, for example
--   due to superscript or subscript positioning.
--   
--   <i>Since: 1.50</i>
layoutIterGetRunBaseline :: (HasCallStack, MonadIO m) => LayoutIter -> m Int32

-- | Gets the extents of the current run in layout coordinates.
--   
--   Layout coordinates have the origin at the top left of the entire
--   layout.
layoutIterGetRunExtents :: (HasCallStack, MonadIO m) => LayoutIter -> m (Rectangle, Rectangle)

-- | Gets the current run for read-only access.
--   
--   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 GHC.Classes.Eq GI.Pango.Structs.LayoutIter.LayoutIter
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Pango.Structs.LayoutIter.LayoutIter
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Structs.LayoutIter.LayoutIter
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Structs.LayoutIter.LayoutIter
instance Data.GI.Base.BasicTypes.GBoxed GI.Pango.Structs.LayoutIter.LayoutIter
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Structs.LayoutIter.LayoutIter)


module GI.Pango.Structs


-- | <tt>PangoRenderer</tt> is a base class for objects that can render
--   text provided as <tt>PangoGlyphString</tt> or <tt>PangoLayout</tt>.
--   
--   By subclassing <tt>PangoRenderer</tt> and overriding operations such
--   as <i><tt>drawGlyphs</tt></i> and <i><tt>drawRectangle</tt></i>,
--   renderers for particular font backends and destinations can be
--   created.
--   
--   <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

-- | 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
--   <tt>PangoRenderer</tt>, embedding the text associated with the glyphs
--   in the output if the output format supports it.
--   
--   This is useful for rendering text in PDF.
--   
--   Note that this method does not handle attributes in
--   <i><tt>glyphItem</tt></i>. If you want colors, shapes and lines
--   handled automatically according to those attributes, you need to use
--   <a>rendererDrawLayoutLine</a> or <a>rendererDrawLayout</a>.
--   
--   Note that <i><tt>text</tt></i> is the start of the text for layout,
--   which is then indexed by <tt>glyph_item-&gt;item-&gt;offset</tt>.
--   
--   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
--   <tt>PangoRenderer</tt>.
--   
--   <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
--   <tt>PangoRenderer</tt>.
--   
--   This is equivalent to drawing the lines of the layout, at their
--   respective positions relative to <i><tt>x</tt></i>, <i><tt>y</tt></i>.
--   
--   <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 <tt>PangoRenderer</tt>.
--   
--   This draws the glyph items that make up the line, as well as shapes,
--   backgrounds and lines that are specified by the attributes of those
--   items.
--   
--   <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 <tt>PangoRenderer</tt>.
--   
--   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 <tt>PangoRenderer</tt>; 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 vfunc, 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 vfunc, 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.
--   
--   This should be called if the rendering changes in a way that would
--   prevent multiple pieces being joined together into one drawing call.
--   For instance, if a subclass of <tt>PangoRenderer</tt> was to add a
--   stipple option for drawing underlines, it needs to call
--   
--   <pre>
--   pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE);
--   </pre>
--   
--   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 GHC.Classes.Eq GI.Pango.Objects.Renderer.Renderer
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.ManagedPtrNewtype GI.Pango.Objects.Renderer.Renderer
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Objects.Renderer.Renderer
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Renderer.Renderer
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Renderer.Renderer
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Objects.Renderer.Renderer)


-- | A <tt>PangoLayout</tt> structure represents an entire paragraph of
--   text.
--   
--   While complete access to the layout capabilities of Pango is provided
--   using the detailed interfaces for itemization and shaping, using that
--   functionality directly involves writing a fairly large amount of code.
--   <tt>PangoLayout</tt> provides a high-level driver for formatting
--   entire paragraphs of text at once. This includes paragraph-level
--   functionality such as line breaking, justification, alignment and
--   ellipsization.
--   
--   A <tt>PangoLayout</tt> is initialized with a <tt>PangoContext</tt>,
--   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 a number of parameters to adjust the formatting of a
--   <tt>PangoLayout</tt>. The following image shows adjustable parameters
--   (on the left) and font metrics (on the right):
--   
--   &lt;picture&gt; &lt;source srcset="layout-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Pango Layout
--   Parameters" src="layout-light.png"&gt; &lt;/picture&gt;
--   
--   The following images demonstrate the effect of alignment and
--   justification on the layout of text:
--   
--   | | | | --- | --- | | | | | | | | | |
--   
--   It is possible, as well, to ignore the 2-D setup, and simply treat the
--   results of a <tt>PangoLayout</tt> as a list of lines.
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

-- | Forces recomputation of any state in the <tt>PangoLayout</tt> 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 ()

-- | Creates a deep copy-by-value of the 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

-- | Loads data previously created via <a>layoutSerialize</a>.
--   
--   For a discussion of the supported format, see that function.
--   
--   Note: to verify that the returned layout is identical to the one that
--   was serialized, you can compare <i><tt>bytes</tt></i> to the result of
--   serializing the layout again.
--   
--   <i>Since: 1.50</i>
layoutDeserialize :: (HasCallStack, MonadIO m, IsContext a) => a -> Bytes -> [LayoutDeserializeFlags] -> m (Maybe 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 (Maybe AttrList)

-- | Gets whether to calculate the base direction for the layout according
--   to its contents.
--   
--   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

-- | Given an index within a layout, determines the positions that of the
--   strong and weak cursors if the insertion point is at that index.
--   
--   This is a variant of <a>layoutGetCursorPos</a> that applies font
--   metric information about caret slope and offset to the positions it
--   returns.
--   
--   &lt;picture&gt; &lt;source srcset="caret-metrics-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Caret metrics"
--   src="caret-metrics-light.png"&gt; &lt;/picture&gt;
--   
--   <i>Since: 1.50</i>
layoutGetCaretPos :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Rectangle, Rectangle)

-- | 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 <tt>PangoContext</tt> 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 with
--   the height of the run extents.
--   
--   &lt;picture&gt; &lt;source srcset="cursor-positions-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Cursor
--   positions" src="cursor-positions-light.png"&gt; &lt;/picture&gt;
--   
--   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.
--   
--   The following example shows text with both a strong and a weak cursor.
--   
--   &lt;picture&gt; &lt;source srcset="split-cursor-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Strong and weak
--   cursors" src="split-cursor-light.png"&gt; &lt;/picture&gt;
--   
--   The strong cursor has a little arrow pointing to the right, the weak
--   cursor to the left. Typing a 'c' in this situation will insert the
--   character after the 'b', and typing another Hebrew character, like
--   'ג', will insert it at the end.
layoutGetCursorPos :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Rectangle, Rectangle)

-- | Gets the text direction at the given character position in
--   <i><tt>layout</tt></i>.
--   
--   <i>Since: 1.46</i>
layoutGetDirection :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m Direction

-- | Gets the type of ellipsization being performed for
--   <i><tt>layout</tt></i>.
--   
--   See <a>layoutSetEllipsize</a>.
--   
--   Use <a>layoutIsEllipsized</a> to query whether any paragraphs were
--   actually ellipsized.
--   
--   <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

-- | Gets whether the last line should be stretched to fill the entire
--   width of the layout.
--   
--   <i>Since: 1.50</i>
layoutGetJustifyLastLine :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool

-- | Retrieves a particular line from a <tt>PangoLayout</tt>.
--   
--   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 <tt>PangoLayout</tt>.
--   
--   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)

-- | Gets the line spacing factor of <i><tt>layout</tt></i>.
--   
--   See <a>layoutSetLineSpacing</a>.
--   
--   <i>Since: 1.44</i>
layoutGetLineSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Float

-- | 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
--   [func<i><tt>extentsToPixels</tt></i>] 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 <tt>PangoLayout</tt> 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
--   <tt>PangoContext</tt> 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
--   <tt>PangoLayout</tt>, 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 whether <i><tt>layout</tt></i> is in single paragraph mode.
--   
--   See <a>layoutSetSingleParagraphMode</a>.
layoutGetSingleParagraphMode :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool

-- | Determines the logical width and height of a <tt>PangoLayout</tt> in
--   Pango units.
--   
--   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 <tt>PangoTabArray</tt> used by this layout.
--   
--   If no <tt>PangoTabArray</tt> 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 of unknown glyphs in <i><tt>layout</tt></i>.
--   
--   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 <tt>PangoLayout</tt> 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.
--   
--   The 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 <tt>PangoLayout</tt> to the onscreen
--   position corresponding to the grapheme at that index.
--   
--   The returns is represented as rectangle. Note that <tt>pos-&gt;x</tt>
--   is always the leading edge of the grapheme and <tt>pos-&gt;x +
--   pos-&gt;width</tt> the trailing edge of the grapheme. If the
--   directionality of the grapheme is right-to-left, then
--   <tt>pos-&gt;width</tt> 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 direction.
--   
--   If <i><tt>direction</tt></i> is positive, then the new position will
--   cause the strong or weak cursor to be displayed one position to right
--   of where it was with the old cursor position. If
--   <i><tt>direction</tt></i> is negative, it will be moved to the left.
--   
--   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 this function 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 <tt>PangoLayout</tt> object with attributes initialized
--   to default values for a particular <tt>PangoContext</tt>.
layoutNew :: (HasCallStack, MonadIO m, IsContext a) => a -> m Layout

-- | Serializes the <i><tt>layout</tt></i> for later deserialization via
--   [func<i><tt>pango</tt></i>.Layout.deserialize].
--   
--   There are no guarantees about the format of the output across
--   different versions of Pango and
--   [func<i><tt>pango</tt></i>.Layout.deserialize] will reject data that
--   it cannot parse.
--   
--   The intended use of this function is testing, benchmarking and
--   debugging. The format is not meant as a permanent storage format.
--   
--   <i>Since: 1.50</i>
layoutSerialize :: (HasCallStack, MonadIO m, IsLayout a) => a -> [LayoutSerializeFlags] -> m Bytes

-- | Sets the alignment for the layout: how partial lines are positioned
--   within the horizontal space available.
--   
--   The default alignment is <a>AlignmentLeft</a>.
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 base direction for the layout according
--   to its contents.
--   
--   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
--   <tt>PangoContext</tt>. (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.
--   
--   The default value is <a>EllipsizeModeNone</a>.
--   
--   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 <tt>PangoLayout</tt> 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 the
--   first line of each paragraph is ellipsized. This behavior may be
--   changed in the future to act per layout instead of per paragraph. File
--   a bug against pango at <a>https://gitlab.gnome.org/gnome/pango</a> 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>.
--   
--   The default value is 0.
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.
--   
--   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.
--   
--   Note that tabs and justification conflict with each other:
--   Justification will move content away from its tab-aligned positions.
--   
--   The default value is <a>False</a>.
--   
--   Also see <a>layoutSetJustifyLastLine</a>.
layoutSetJustify :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()

-- | Sets whether the last line should be stretched to fill the entire
--   width of the layout.
--   
--   This only has an effect if <a>layoutSetJustify</a> has been called as
--   well.
--   
--   The default value is <a>False</a>.
--   
--   <i>Since: 1.50</i>
layoutSetJustifyLastLine :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()

-- | Sets a factor for line spacing.
--   
--   Typical values are: 0, 1, 1.5, 2. The default values is 0.
--   
--   If <i><tt>factor</tt></i> is non-zero, lines are placed so that
--   
--   baseline2 = baseline1 + factor * height2
--   
--   where height2 is the line height of the second line (as determined by
--   the font(s)). In this case, the spacing set with
--   <a>layoutSetSpacing</a> is ignored.
--   
--   If <i><tt>factor</tt></i> is zero (the default), spacing is applied as
--   before.
--   
--   Note: for semantics that are closer to the CSS line-height property,
--   see <a>attrLineHeightNew</a>.
--   
--   <i>Since: 1.44</i>
layoutSetLineSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> Float -> m ()

-- | Sets the layout text and attribute list from marked-up text.
--   
--   See <a>Pango Markup</a>).
--   
--   Replaces the current text and attribute list.
--   
--   This is the same as <a>layoutSetMarkupWithAccel</a>, but the markup
--   text isn't scanned for accelerators.
layoutSetMarkup :: (HasCallStack, MonadIO m, IsLayout a) => a -> Text -> Int32 -> m ()

-- | Sets the layout text and attribute list from marked-up text.
--   
--   See <a>Pango Markup</a>).
--   
--   Replaces the current text and 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.
layoutSetMarkupWithAccel :: (HasCallStack, MonadIO m, IsLayout a) => a -> Text -> Int32 -> Char -> m Char

-- | Sets the single paragraph mode of <i><tt>layout</tt></i>.
--   
--   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.
--   
--   The default value is <a>False</a>.
layoutSetSingleParagraphMode :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()

-- | Sets the amount of spacing in Pango units between the lines of the
--   layout.
--   
--   When placing lines with spacing, Pango arranges things so that
--   
--   line2.top = line1.bottom + spacing
--   
--   The default value is 0.
--   
--   Note: Since 1.44, Pango is using the line height (as determined by the
--   font) for placing lines when the line spacing factor is set to a
--   non-zero value with <a>layoutSetLineSpacing</a>. In that case, the
--   <i><tt>spacing</tt></i> set with this function is ignored.
--   
--   Note: for semantics that are closer to the CSS line-height property,
--   see <a>attrLineHeightNew</a>.
layoutSetSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()

-- | Sets the tabs to use for <i><tt>layout</tt></i>, overriding the
--   default tabs.
--   
--   <tt>PangoLayout</tt> will place content at the next tab position
--   whenever it meets a Tab character (U+0009).
--   
--   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.
--   
--   Note that tabs and justification conflict with each other:
--   Justification will move content away from its tab-aligned positions.
--   The same is true for alignments other than <a>AlignmentLeft</a>.
layoutSetTabs :: (HasCallStack, MonadIO m, IsLayout a) => a -> Maybe TabArray -> m ()

-- | Sets the text of the layout.
--   
--   This function validates <i><tt>text</tt></i> and renders invalid UTF-8
--   with a placeholder glyph.
--   
--   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 <tt>PangoLayout</tt> 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.
--   
--   The default value is <a>WrapModeWord</a>.
layoutSetWrap :: (HasCallStack, MonadIO m, IsLayout a) => a -> WrapMode -> m ()

-- | A convenience method to serialize a layout to a file.
--   
--   It is equivalent to calling <a>layoutSerialize</a> followed by
--   <a>fileSetContents</a>.
--   
--   See those two functions for details on the arguments.
--   
--   It is mostly intended for use inside a debugger to quickly dump a
--   layout to a file for later inspection.
--   
--   <i>Since: 1.50</i>
layoutWriteToFile :: (HasCallStack, MonadIO m, IsLayout a) => a -> [LayoutSerializeFlags] -> [Char] -> 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 GHC.Classes.Eq GI.Pango.Objects.Layout.Layout
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.ManagedPtrNewtype GI.Pango.Objects.Layout.Layout
instance Data.GI.Base.BasicTypes.TypedObject GI.Pango.Objects.Layout.Layout
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Layout.Layout
instance Data.GI.Base.Overloading.HasParentTypes GI.Pango.Objects.Layout.Layout
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Pango.Objects.Layout.Layout)


module GI.Pango.Objects


module GI.Pango
