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


module GI.Pango.Structs.ScriptForLang
newtype ScriptForLang
ScriptForLang :: (ManagedPtr ScriptForLang) -> ScriptForLang

-- | Construct a <a>ScriptForLang</a> struct initialized to zero.
newZeroScriptForLang :: MonadIO m => m ScriptForLang
noScriptForLang :: Maybe ScriptForLang
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.ScriptForLang.ScriptForLang
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.ScriptForLang.ScriptForLang tag
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.ScriptForLang.ScriptForLang
instance (info ~ GI.Pango.Structs.ScriptForLang.ResolveScriptForLangMethod t GI.Pango.Structs.ScriptForLang.ScriptForLang, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.ScriptForLang.ScriptForLang p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.ScriptForLang.ScriptForLang -> p)
instance (info ~ GI.Pango.Structs.ScriptForLang.ResolveScriptForLangMethod t GI.Pango.Structs.ScriptForLang.ScriptForLang, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.ScriptForLang.ScriptForLang p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.ScriptForLang.ScriptForLang -> p)


-- | The <a>Rectangle</a> structure represents a rectangle. It is
--   frequently used to represent the logical or ink extents of a single
--   glyph or section of text. (See, for instance,
--   <a>fontGetGlyphExtents</a>)
module GI.Pango.Structs.Rectangle
newtype Rectangle
Rectangle :: (ManagedPtr Rectangle) -> Rectangle

-- | Construct a <a>Rectangle</a> struct initialized to zero.
newZeroRectangle :: MonadIO m => m Rectangle
noRectangle :: Maybe Rectangle
getRectangleHeight :: MonadIO m => Rectangle -> m Int32
rectangle_height :: AttrLabelProxy "height"
setRectangleHeight :: MonadIO m => Rectangle -> Int32 -> m ()
getRectangleWidth :: MonadIO m => Rectangle -> m Int32
rectangle_width :: AttrLabelProxy "width"
setRectangleWidth :: MonadIO m => Rectangle -> Int32 -> m ()
getRectangleX :: MonadIO m => Rectangle -> m Int32
rectangle_x :: AttrLabelProxy "x"
setRectangleX :: MonadIO m => Rectangle -> Int32 -> m ()
getRectangleY :: MonadIO m => Rectangle -> m Int32
rectangle_y :: AttrLabelProxy "y"
setRectangleY :: MonadIO m => Rectangle -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.Rectangle.Rectangle
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Rectangle.Rectangle tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Rectangle.RectangleXFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Rectangle.RectangleYFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Rectangle.RectangleWidthFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Rectangle.RectangleHeightFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.Rectangle.Rectangle
instance (info ~ GI.Pango.Structs.Rectangle.ResolveRectangleMethod t GI.Pango.Structs.Rectangle.Rectangle, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Rectangle.Rectangle p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.Rectangle.Rectangle -> p)
instance (info ~ GI.Pango.Structs.Rectangle.ResolveRectangleMethod t GI.Pango.Structs.Rectangle.Rectangle, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Rectangle.Rectangle p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.Rectangle.Rectangle -> p)


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

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

-- | 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.
matrixConcat :: (HasCallStack, MonadIO m) => Matrix -> Matrix -> m ()
data MatrixCopyMethodInfo

-- | Copies a <a>Matrix</a>.
matrixCopy :: (HasCallStack, MonadIO m) => Matrix -> m (Maybe Matrix)
data MatrixFreeMethodInfo

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

-- | 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>.
matrixGetFontScaleFactor :: (HasCallStack, MonadIO m) => Matrix -> m Double
data MatrixGetFontScaleFactorsMethodInfo

-- | 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.
matrixGetFontScaleFactors :: (HasCallStack, MonadIO m) => Matrix -> m (Double, Double)
data MatrixRotateMethodInfo

-- | 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.
matrixRotate :: (HasCallStack, MonadIO m) => Matrix -> Double -> m ()
data MatrixScaleMethodInfo

-- | 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.
matrixScale :: (HasCallStack, MonadIO m) => Matrix -> Double -> Double -> m ()
data MatrixTransformDistanceMethodInfo

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

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

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

-- | 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.
matrixTranslate :: (HasCallStack, MonadIO m) => Matrix -> Double -> Double -> m ()
getMatrixX0 :: MonadIO m => Matrix -> m Double
matrix_x0 :: AttrLabelProxy "x0"
setMatrixX0 :: MonadIO m => Matrix -> Double -> m ()
getMatrixXx :: MonadIO m => Matrix -> m Double
matrix_xx :: AttrLabelProxy "xx"
setMatrixXx :: MonadIO m => Matrix -> Double -> m ()
getMatrixXy :: MonadIO m => Matrix -> m Double
matrix_xy :: AttrLabelProxy "xy"
setMatrixXy :: MonadIO m => Matrix -> Double -> m ()
getMatrixY0 :: MonadIO m => Matrix -> m Double
matrix_y0 :: AttrLabelProxy "y0"
setMatrixY0 :: MonadIO m => Matrix -> Double -> m ()
getMatrixYx :: MonadIO m => Matrix -> m Double
matrix_yx :: AttrLabelProxy "yx"
setMatrixYx :: MonadIO m => Matrix -> Double -> m ()
getMatrixYy :: MonadIO m => Matrix -> m Double
matrix_yy :: AttrLabelProxy "yy"
setMatrixYy :: MonadIO m => Matrix -> Double -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.Matrix.Matrix
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Matrix.Matrix tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Matrix.MatrixXxFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Matrix.MatrixXyFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Matrix.MatrixYxFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Matrix.MatrixYyFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Matrix.MatrixX0FieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Matrix.MatrixY0FieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.Matrix.Matrix
instance (signature ~ (GI.Pango.Structs.Matrix.Matrix -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Matrix.MatrixConcatMethodInfo GI.Pango.Structs.Matrix.Matrix signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.Matrix.Matrix), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Matrix.MatrixCopyMethodInfo GI.Pango.Structs.Matrix.Matrix signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Matrix.MatrixFreeMethodInfo GI.Pango.Structs.Matrix.Matrix signature
instance (signature ~ m GHC.Types.Double, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Matrix.MatrixGetFontScaleFactorMethodInfo GI.Pango.Structs.Matrix.Matrix signature
instance (signature ~ m (GHC.Types.Double, GHC.Types.Double), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Matrix.MatrixGetFontScaleFactorsMethodInfo GI.Pango.Structs.Matrix.Matrix signature
instance (signature ~ (GHC.Types.Double -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Matrix.MatrixRotateMethodInfo GI.Pango.Structs.Matrix.Matrix signature
instance (signature ~ (GHC.Types.Double -> GHC.Types.Double -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Matrix.MatrixScaleMethodInfo GI.Pango.Structs.Matrix.Matrix signature
instance (signature ~ (GHC.Types.Double -> GHC.Types.Double -> m (GHC.Types.Double, GHC.Types.Double)), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Matrix.MatrixTransformDistanceMethodInfo GI.Pango.Structs.Matrix.Matrix signature
instance (signature ~ (GHC.Base.Maybe GI.Pango.Structs.Rectangle.Rectangle -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Matrix.MatrixTransformPixelRectangleMethodInfo GI.Pango.Structs.Matrix.Matrix signature
instance (signature ~ (GHC.Types.Double -> GHC.Types.Double -> m (GHC.Types.Double, GHC.Types.Double)), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Matrix.MatrixTransformPointMethodInfo GI.Pango.Structs.Matrix.Matrix signature
instance (signature ~ (GHC.Types.Double -> GHC.Types.Double -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Matrix.MatrixTranslateMethodInfo GI.Pango.Structs.Matrix.Matrix signature
instance (info ~ GI.Pango.Structs.Matrix.ResolveMatrixMethod t GI.Pango.Structs.Matrix.Matrix, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Matrix.Matrix p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.Matrix.Matrix -> p)
instance (info ~ GI.Pango.Structs.Matrix.ResolveMatrixMethod t GI.Pango.Structs.Matrix.Matrix, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Matrix.Matrix p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.Matrix.Matrix -> p)


module GI.Pango.Structs.MapEntry
newtype MapEntry
MapEntry :: (ManagedPtr MapEntry) -> MapEntry
noMapEntry :: Maybe MapEntry
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.MapEntry.MapEntry
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.MapEntry.MapEntry
instance (info ~ GI.Pango.Structs.MapEntry.ResolveMapEntryMethod t GI.Pango.Structs.MapEntry.MapEntry, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.MapEntry.MapEntry p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.MapEntry.MapEntry -> p)
instance (info ~ GI.Pango.Structs.MapEntry.ResolveMapEntryMethod t GI.Pango.Structs.MapEntry.MapEntry, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.MapEntry.MapEntry p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.MapEntry.MapEntry -> p)


module GI.Pango.Structs.Map
newtype Map
Map :: (ManagedPtr Map) -> Map
noMap :: Maybe Map
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.Map.Map
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.Map.Map
instance (info ~ GI.Pango.Structs.Map.ResolveMapMethod t GI.Pango.Structs.Map.Map, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Map.Map p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.Map.Map -> p)
instance (info ~ GI.Pango.Structs.Map.ResolveMapMethod t GI.Pango.Structs.Map.Map, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Map.Map p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.Map.Map -> p)


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

-- | Construct a <a>LogAttr</a> struct initialized to zero.
newZeroLogAttr :: MonadIO m => m LogAttr
noLogAttr :: Maybe LogAttr
getLogAttrBackspaceDeletesCharacter :: MonadIO m => LogAttr -> m Word32
logAttr_backspaceDeletesCharacter :: AttrLabelProxy "backspaceDeletesCharacter"
setLogAttrBackspaceDeletesCharacter :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsCharBreak :: MonadIO m => LogAttr -> m Word32
logAttr_isCharBreak :: AttrLabelProxy "isCharBreak"
setLogAttrIsCharBreak :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsCursorPosition :: MonadIO m => LogAttr -> m Word32
logAttr_isCursorPosition :: AttrLabelProxy "isCursorPosition"
setLogAttrIsCursorPosition :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsExpandableSpace :: MonadIO m => LogAttr -> m Word32
logAttr_isExpandableSpace :: AttrLabelProxy "isExpandableSpace"
setLogAttrIsExpandableSpace :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsLineBreak :: MonadIO m => LogAttr -> m Word32
logAttr_isLineBreak :: AttrLabelProxy "isLineBreak"
setLogAttrIsLineBreak :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsMandatoryBreak :: MonadIO m => LogAttr -> m Word32
logAttr_isMandatoryBreak :: AttrLabelProxy "isMandatoryBreak"
setLogAttrIsMandatoryBreak :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsSentenceBoundary :: MonadIO m => LogAttr -> m Word32
logAttr_isSentenceBoundary :: AttrLabelProxy "isSentenceBoundary"
setLogAttrIsSentenceBoundary :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsSentenceEnd :: MonadIO m => LogAttr -> m Word32
logAttr_isSentenceEnd :: AttrLabelProxy "isSentenceEnd"
setLogAttrIsSentenceEnd :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsSentenceStart :: MonadIO m => LogAttr -> m Word32
logAttr_isSentenceStart :: AttrLabelProxy "isSentenceStart"
setLogAttrIsSentenceStart :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsWhite :: MonadIO m => LogAttr -> m Word32
logAttr_isWhite :: AttrLabelProxy "isWhite"
setLogAttrIsWhite :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsWordBoundary :: MonadIO m => LogAttr -> m Word32
logAttr_isWordBoundary :: AttrLabelProxy "isWordBoundary"
setLogAttrIsWordBoundary :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsWordEnd :: MonadIO m => LogAttr -> m Word32
logAttr_isWordEnd :: AttrLabelProxy "isWordEnd"
setLogAttrIsWordEnd :: MonadIO m => LogAttr -> Word32 -> m ()
getLogAttrIsWordStart :: MonadIO m => LogAttr -> m Word32
logAttr_isWordStart :: AttrLabelProxy "isWordStart"
setLogAttrIsWordStart :: MonadIO m => LogAttr -> Word32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.LogAttr.LogAttr
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.LogAttr.LogAttr tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsLineBreakFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsMandatoryBreakFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsCharBreakFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsWhiteFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsCursorPositionFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsWordStartFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsWordEndFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsSentenceBoundaryFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsSentenceStartFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsSentenceEndFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrBackspaceDeletesCharacterFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsExpandableSpaceFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LogAttr.LogAttrIsWordBoundaryFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.LogAttr.LogAttr
instance (info ~ GI.Pango.Structs.LogAttr.ResolveLogAttrMethod t GI.Pango.Structs.LogAttr.LogAttr, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.LogAttr.LogAttr p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.LogAttr.LogAttr -> p)
instance (info ~ GI.Pango.Structs.LogAttr.ResolveLogAttrMethod t GI.Pango.Structs.LogAttr.LogAttr, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.LogAttr.LogAttr p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.LogAttr.LogAttr -> p)


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

-- | Construct a <a>GlyphVisAttr</a> struct initialized to zero.
newZeroGlyphVisAttr :: MonadIO m => m GlyphVisAttr
noGlyphVisAttr :: Maybe GlyphVisAttr
getGlyphVisAttrIsClusterStart :: MonadIO m => GlyphVisAttr -> m Word32
glyphVisAttr_isClusterStart :: AttrLabelProxy "isClusterStart"
setGlyphVisAttrIsClusterStart :: MonadIO m => GlyphVisAttr -> Word32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphVisAttr.GlyphVisAttrIsClusterStartFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr
instance (info ~ GI.Pango.Structs.GlyphVisAttr.ResolveGlyphVisAttrMethod t GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr -> p)
instance (info ~ GI.Pango.Structs.GlyphVisAttr.ResolveGlyphVisAttrMethod t GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.GlyphVisAttr.GlyphVisAttr -> p)


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

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

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

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

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

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

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

-- | Moves the iterator to the preceding cluster in the glyph item. See
--   <a>GlyphItemIter</a> for details of cluster orders.
glyphItemIterPrevCluster :: (HasCallStack, MonadIO m) => GlyphItemIter -> m Bool
getGlyphItemIterEndChar :: MonadIO m => GlyphItemIter -> m Int32
glyphItemIter_endChar :: AttrLabelProxy "endChar"
setGlyphItemIterEndChar :: MonadIO m => GlyphItemIter -> Int32 -> m ()
getGlyphItemIterEndGlyph :: MonadIO m => GlyphItemIter -> m Int32
glyphItemIter_endGlyph :: AttrLabelProxy "endGlyph"
setGlyphItemIterEndGlyph :: MonadIO m => GlyphItemIter -> Int32 -> m ()
getGlyphItemIterEndIndex :: MonadIO m => GlyphItemIter -> m Int32
glyphItemIter_endIndex :: AttrLabelProxy "endIndex"
setGlyphItemIterEndIndex :: MonadIO m => GlyphItemIter -> Int32 -> m ()
clearGlyphItemIterGlyphItem :: MonadIO m => GlyphItemIter -> m ()
getGlyphItemIterGlyphItem :: MonadIO m => GlyphItemIter -> m (Maybe GlyphItem)
glyphItemIter_glyphItem :: AttrLabelProxy "glyphItem"
setGlyphItemIterGlyphItem :: MonadIO m => GlyphItemIter -> Ptr GlyphItem -> m ()
getGlyphItemIterStartChar :: MonadIO m => GlyphItemIter -> m Int32
glyphItemIter_startChar :: AttrLabelProxy "startChar"
setGlyphItemIterStartChar :: MonadIO m => GlyphItemIter -> Int32 -> m ()
getGlyphItemIterStartGlyph :: MonadIO m => GlyphItemIter -> m Int32
glyphItemIter_startGlyph :: AttrLabelProxy "startGlyph"
setGlyphItemIterStartGlyph :: MonadIO m => GlyphItemIter -> Int32 -> m ()
getGlyphItemIterStartIndex :: MonadIO m => GlyphItemIter -> m Int32
glyphItemIter_startIndex :: AttrLabelProxy "startIndex"
setGlyphItemIterStartIndex :: MonadIO m => GlyphItemIter -> Int32 -> m ()
clearGlyphItemIterText :: MonadIO m => GlyphItemIter -> m ()
getGlyphItemIterText :: MonadIO m => GlyphItemIter -> m (Maybe Text)
glyphItemIter_text :: AttrLabelProxy "text"
setGlyphItemIterText :: MonadIO m => GlyphItemIter -> CString -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.GlyphItemIter.GlyphItemIter
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphItemIter.GlyphItemIter tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterGlyphItemFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterTextFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterStartGlyphFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterStartIndexFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterStartCharFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterEndGlyphFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterEndIndexFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterEndCharFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.GlyphItemIter.GlyphItemIter
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.GlyphItemIter.GlyphItemIter), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterCopyMethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIter signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterFreeMethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIter signature
instance (signature ~ (GI.Pango.Structs.GlyphItem.GlyphItem -> Data.Text.Internal.Text -> m GHC.Types.Bool), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterInitEndMethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIter signature
instance (signature ~ (GI.Pango.Structs.GlyphItem.GlyphItem -> Data.Text.Internal.Text -> m GHC.Types.Bool), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterInitStartMethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIter signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterNextClusterMethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIter signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIterPrevClusterMethodInfo GI.Pango.Structs.GlyphItemIter.GlyphItemIter signature
instance (info ~ GI.Pango.Structs.GlyphItemIter.ResolveGlyphItemIterMethod t GI.Pango.Structs.GlyphItemIter.GlyphItemIter, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphItemIter.GlyphItemIter p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.GlyphItemIter.GlyphItemIter -> p)
instance (info ~ GI.Pango.Structs.GlyphItemIter.ResolveGlyphItemIterMethod t GI.Pango.Structs.GlyphItemIter.GlyphItemIter, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphItemIter.GlyphItemIter p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.GlyphItemIter.GlyphItemIter -> p)


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

-- | Construct a <a>GlyphGeometry</a> struct initialized to zero.
newZeroGlyphGeometry :: MonadIO m => m GlyphGeometry
noGlyphGeometry :: Maybe GlyphGeometry
getGlyphGeometryWidth :: MonadIO m => GlyphGeometry -> m Int32
glyphGeometry_width :: AttrLabelProxy "width"
setGlyphGeometryWidth :: MonadIO m => GlyphGeometry -> Int32 -> m ()
getGlyphGeometryXOffset :: MonadIO m => GlyphGeometry -> m Int32
glyphGeometry_xOffset :: AttrLabelProxy "xOffset"
setGlyphGeometryXOffset :: MonadIO m => GlyphGeometry -> Int32 -> m ()
getGlyphGeometryYOffset :: MonadIO m => GlyphGeometry -> m Int32
glyphGeometry_yOffset :: AttrLabelProxy "yOffset"
setGlyphGeometryYOffset :: MonadIO m => GlyphGeometry -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.GlyphGeometry.GlyphGeometry
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphGeometry.GlyphGeometry tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphGeometry.GlyphGeometryWidthFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphGeometry.GlyphGeometryXOffsetFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphGeometry.GlyphGeometryYOffsetFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.GlyphGeometry.GlyphGeometry
instance (info ~ GI.Pango.Structs.GlyphGeometry.ResolveGlyphGeometryMethod t GI.Pango.Structs.GlyphGeometry.GlyphGeometry, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphGeometry.GlyphGeometry p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.GlyphGeometry.GlyphGeometry -> p)
instance (info ~ GI.Pango.Structs.GlyphGeometry.ResolveGlyphGeometryMethod t GI.Pango.Structs.GlyphGeometry.GlyphGeometry, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphGeometry.GlyphGeometry p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.GlyphGeometry.GlyphGeometry -> p)


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

-- | Construct a <a>GlyphInfo</a> struct initialized to zero.
newZeroGlyphInfo :: MonadIO m => m GlyphInfo
noGlyphInfo :: Maybe GlyphInfo
getGlyphInfoAttr :: MonadIO m => GlyphInfo -> m GlyphVisAttr
glyphInfo_attr :: AttrLabelProxy "attr"
getGlyphInfoGeometry :: MonadIO m => GlyphInfo -> m GlyphGeometry
glyphInfo_geometry :: AttrLabelProxy "geometry"
getGlyphInfoGlyph :: MonadIO m => GlyphInfo -> m Word32
glyphInfo_glyph :: AttrLabelProxy "glyph"
setGlyphInfoGlyph :: MonadIO m => GlyphInfo -> Word32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.GlyphInfo.GlyphInfo
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphInfo.GlyphInfo tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphInfo.GlyphInfoGlyphFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphInfo.GlyphInfoGeometryFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphInfo.GlyphInfoAttrFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.GlyphInfo.GlyphInfo
instance (info ~ GI.Pango.Structs.GlyphInfo.ResolveGlyphInfoMethod t GI.Pango.Structs.GlyphInfo.GlyphInfo, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphInfo.GlyphInfo p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.GlyphInfo.GlyphInfo -> p)
instance (info ~ GI.Pango.Structs.GlyphInfo.ResolveGlyphInfoMethod t GI.Pango.Structs.GlyphInfo.GlyphInfo, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphInfo.GlyphInfo p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.GlyphInfo.GlyphInfo -> p)


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

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

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

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

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

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

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

-- | Gets the suggested thickness to draw for the strikethrough.
fontMetricsGetStrikethroughThickness :: (HasCallStack, MonadIO m) => FontMetrics -> m Int32
data FontMetricsGetUnderlinePositionMethodInfo

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

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

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

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

-- | Decrease the reference count of a font metrics structure by one. If
--   the result is zero, frees the structure and any associated memory.
fontMetricsUnref :: (HasCallStack, MonadIO m) => FontMetrics -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.FontMetrics.FontMetrics
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.FontMetrics.FontMetrics tag
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.FontMetrics.FontMetrics
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontMetrics.FontMetricsGetApproximateCharWidthMethodInfo GI.Pango.Structs.FontMetrics.FontMetrics signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontMetrics.FontMetricsGetApproximateDigitWidthMethodInfo GI.Pango.Structs.FontMetrics.FontMetrics signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontMetrics.FontMetricsGetAscentMethodInfo GI.Pango.Structs.FontMetrics.FontMetrics signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontMetrics.FontMetricsGetDescentMethodInfo GI.Pango.Structs.FontMetrics.FontMetrics signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontMetrics.FontMetricsGetStrikethroughPositionMethodInfo GI.Pango.Structs.FontMetrics.FontMetrics signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontMetrics.FontMetricsGetStrikethroughThicknessMethodInfo GI.Pango.Structs.FontMetrics.FontMetrics signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontMetrics.FontMetricsGetUnderlinePositionMethodInfo GI.Pango.Structs.FontMetrics.FontMetrics signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontMetrics.FontMetricsGetUnderlineThicknessMethodInfo GI.Pango.Structs.FontMetrics.FontMetrics signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.FontMetrics.FontMetrics), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontMetrics.FontMetricsRefMethodInfo GI.Pango.Structs.FontMetrics.FontMetrics signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontMetrics.FontMetricsUnrefMethodInfo GI.Pango.Structs.FontMetrics.FontMetrics signature
instance (info ~ GI.Pango.Structs.FontMetrics.ResolveFontMetricsMethod t GI.Pango.Structs.FontMetrics.FontMetrics, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.FontMetrics.FontMetrics p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.FontMetrics.FontMetrics -> p)
instance (info ~ GI.Pango.Structs.FontMetrics.ResolveFontMetricsMethod t GI.Pango.Structs.FontMetrics.FontMetrics, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.FontMetrics.FontMetrics p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.FontMetrics.FontMetrics -> p)


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

-- | Construct a <a>EngineInfo</a> struct initialized to zero.
newZeroEngineInfo :: MonadIO m => m EngineInfo
noEngineInfo :: Maybe EngineInfo
clearEngineInfoEngineType :: MonadIO m => EngineInfo -> m ()
engineInfo_engineType :: AttrLabelProxy "engineType"
getEngineInfoEngineType :: MonadIO m => EngineInfo -> m (Maybe Text)
setEngineInfoEngineType :: MonadIO m => EngineInfo -> CString -> m ()
clearEngineInfoId :: MonadIO m => EngineInfo -> m ()
engineInfo_id :: AttrLabelProxy "id"
getEngineInfoId :: MonadIO m => EngineInfo -> m (Maybe Text)
setEngineInfoId :: MonadIO m => EngineInfo -> CString -> m ()
engineInfo_nScripts :: AttrLabelProxy "nScripts"
getEngineInfoNScripts :: MonadIO m => EngineInfo -> m Int32
setEngineInfoNScripts :: MonadIO m => EngineInfo -> Int32 -> m ()
clearEngineInfoRenderType :: MonadIO m => EngineInfo -> m ()
engineInfo_renderType :: AttrLabelProxy "renderType"
getEngineInfoRenderType :: MonadIO m => EngineInfo -> m (Maybe Text)
setEngineInfoRenderType :: MonadIO m => EngineInfo -> CString -> m ()
clearEngineInfoScripts :: MonadIO m => EngineInfo -> m ()
engineInfo_scripts :: AttrLabelProxy "scripts"
getEngineInfoScripts :: MonadIO m => EngineInfo -> m (Maybe EngineScriptInfo)
setEngineInfoScripts :: MonadIO m => EngineInfo -> Ptr EngineScriptInfo -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.EngineInfo.EngineInfo
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.EngineInfo.EngineInfo tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.EngineInfo.EngineInfoIdFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.EngineInfo.EngineInfoEngineTypeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.EngineInfo.EngineInfoRenderTypeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.EngineInfo.EngineInfoScriptsFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.EngineInfo.EngineInfoNScriptsFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.EngineInfo.EngineInfo
instance (info ~ GI.Pango.Structs.EngineInfo.ResolveEngineInfoMethod t GI.Pango.Structs.EngineInfo.EngineInfo, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.EngineInfo.EngineInfo p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.EngineInfo.EngineInfo -> p)
instance (info ~ GI.Pango.Structs.EngineInfo.ResolveEngineInfoMethod t GI.Pango.Structs.EngineInfo.EngineInfo, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.EngineInfo.EngineInfo p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.EngineInfo.EngineInfo -> p)


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

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

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

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

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

-- | Returns a textual specification of <i><tt>color</tt></i> in the
--   hexadecimal form &lt;literal&gt;&amp;num;rrrrggggbbbb&lt;/literal&gt;,
--   where &lt;literal&gt;r&lt;/literal&gt;,
--   &lt;literal&gt;g&lt;/literal&gt; and &lt;literal&gt;b&lt;/literal&gt;
--   are hex digits representing the red, green, and blue components
--   respectively.
colorToString :: (HasCallStack, MonadIO m) => Color -> m Text
color_blue :: AttrLabelProxy "blue"
getColorBlue :: MonadIO m => Color -> m Word16
setColorBlue :: MonadIO m => Color -> Word16 -> m ()
color_green :: AttrLabelProxy "green"
getColorGreen :: MonadIO m => Color -> m Word16
setColorGreen :: MonadIO m => Color -> Word16 -> m ()
color_red :: AttrLabelProxy "red"
getColorRed :: MonadIO m => Color -> m Word16
setColorRed :: MonadIO m => Color -> Word16 -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.Color.Color
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Color.Color tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Color.ColorRedFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Color.ColorGreenFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Color.ColorBlueFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.Color.Color
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.Color.Color), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Color.ColorCopyMethodInfo GI.Pango.Structs.Color.Color signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Color.ColorFreeMethodInfo GI.Pango.Structs.Color.Color signature
instance (signature ~ (Data.Text.Internal.Text -> m GHC.Types.Bool), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Color.ColorParseMethodInfo GI.Pango.Structs.Color.Color signature
instance (signature ~ m Data.Text.Internal.Text, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Color.ColorToStringMethodInfo GI.Pango.Structs.Color.Color signature
instance (info ~ GI.Pango.Structs.Color.ResolveColorMethod t GI.Pango.Structs.Color.Color, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Color.Color p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.Color.Color -> p)
instance (info ~ GI.Pango.Structs.Color.ResolveColorMethod t GI.Pango.Structs.Color.Color, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Color.Color p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.Color.Color -> p)


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

-- | Construct a <a>AttrString</a> struct initialized to zero.
newZeroAttrString :: MonadIO m => m AttrString
noAttrString :: Maybe AttrString
attrString_attr :: AttrLabelProxy "attr"
getAttrStringAttr :: MonadIO m => AttrString -> m Attribute
attrString_value :: AttrLabelProxy "value"
clearAttrStringValue :: MonadIO m => AttrString -> m ()
getAttrStringValue :: MonadIO m => AttrString -> m (Maybe Text)
setAttrStringValue :: MonadIO m => AttrString -> CString -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrString.AttrString
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrString.AttrString tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrString.AttrStringAttrFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrString.AttrStringValueFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrString.AttrString
instance (info ~ GI.Pango.Structs.AttrString.ResolveAttrStringMethod t GI.Pango.Structs.AttrString.AttrString, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrString.AttrString p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrString.AttrString -> p)
instance (info ~ GI.Pango.Structs.AttrString.ResolveAttrStringMethod t GI.Pango.Structs.AttrString.AttrString, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrString.AttrString p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrString.AttrString -> p)


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

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

-- | Create a new font-size attribute in fractional points.
attrSizeNew :: (HasCallStack, MonadIO m) => Int32 -> m Attribute
attrSize_absolute :: AttrLabelProxy "absolute"
getAttrSizeAbsolute :: MonadIO m => AttrSize -> m Word32
setAttrSizeAbsolute :: MonadIO m => AttrSize -> Word32 -> m ()
attrSize_attr :: AttrLabelProxy "attr"
getAttrSizeAttr :: MonadIO m => AttrSize -> m Attribute
attrSize_size :: AttrLabelProxy "size"
getAttrSizeSize :: MonadIO m => AttrSize -> m Int32
setAttrSizeSize :: MonadIO m => AttrSize -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrSize.AttrSize
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrSize.AttrSize tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrSize.AttrSizeAttrFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrSize.AttrSizeSizeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrSize.AttrSizeAbsoluteFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrSize.AttrSize
instance (info ~ GI.Pango.Structs.AttrSize.ResolveAttrSizeMethod t GI.Pango.Structs.AttrSize.AttrSize, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrSize.AttrSize p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrSize.AttrSize -> p)
instance (info ~ GI.Pango.Structs.AttrSize.ResolveAttrSizeMethod t GI.Pango.Structs.AttrSize.AttrSize, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrSize.AttrSize p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrSize.AttrSize -> p)


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

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

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

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

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

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

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

-- | 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.)
glyphItemSplit :: (HasCallStack, MonadIO m) => GlyphItem -> Text -> Int32 -> m GlyphItem
clearGlyphItemGlyphs :: MonadIO m => GlyphItem -> m ()
getGlyphItemGlyphs :: MonadIO m => GlyphItem -> m (Maybe GlyphString)
glyphItem_glyphs :: AttrLabelProxy "glyphs"
setGlyphItemGlyphs :: MonadIO m => GlyphItem -> Ptr GlyphString -> m ()
clearGlyphItemItem :: MonadIO m => GlyphItem -> m ()
getGlyphItemItem :: MonadIO m => GlyphItem -> m (Maybe Item)
glyphItem_item :: AttrLabelProxy "item"
setGlyphItemItem :: MonadIO m => GlyphItem -> Ptr Item -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.GlyphItem.GlyphItem
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphItem.GlyphItem tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphItem.GlyphItemItemFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphItem.GlyphItemGlyphsFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.GlyphItem.GlyphItem
instance (signature ~ (Data.Text.Internal.Text -> GI.Pango.Structs.AttrList.AttrList -> m [GI.Pango.Structs.GlyphItem.GlyphItem]), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItem.GlyphItemApplyAttrsMethodInfo GI.Pango.Structs.GlyphItem.GlyphItem signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.GlyphItem.GlyphItem), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItem.GlyphItemCopyMethodInfo GI.Pango.Structs.GlyphItem.GlyphItem signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItem.GlyphItemFreeMethodInfo GI.Pango.Structs.GlyphItem.GlyphItem signature
instance (signature ~ (Data.Text.Internal.Text -> GHC.Ptr.Ptr GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItem.GlyphItemGetLogicalWidthsMethodInfo GI.Pango.Structs.GlyphItem.GlyphItem signature
instance (signature ~ (Data.Text.Internal.Text -> GHC.Ptr.Ptr (GHC.Ptr.Ptr GI.Pango.Structs.LogAttr.LogAttr) -> GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItem.GlyphItemLetterSpaceMethodInfo GI.Pango.Structs.GlyphItem.GlyphItem signature
instance (signature ~ (Data.Text.Internal.Text -> GHC.Int.Int32 -> m GI.Pango.Structs.GlyphItem.GlyphItem), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphItem.GlyphItemSplitMethodInfo GI.Pango.Structs.GlyphItem.GlyphItem signature
instance (info ~ GI.Pango.Structs.GlyphItem.ResolveGlyphItemMethod t GI.Pango.Structs.GlyphItem.GlyphItem, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphItem.GlyphItem p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.GlyphItem.GlyphItem -> p)
instance (info ~ GI.Pango.Structs.GlyphItem.ResolveGlyphItemMethod t GI.Pango.Structs.GlyphItem.GlyphItem, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphItem.GlyphItem p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.GlyphItem.GlyphItem -> p)


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

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

-- | Create a new language tag attribute.
attrLanguageNew :: (HasCallStack, MonadIO m) => Language -> m Attribute
attrLanguage_attr :: AttrLabelProxy "attr"
getAttrLanguageAttr :: MonadIO m => AttrLanguage -> m Attribute
attrLanguage_value :: AttrLabelProxy "value"
clearAttrLanguageValue :: MonadIO m => AttrLanguage -> m ()
getAttrLanguageValue :: MonadIO m => AttrLanguage -> m (Maybe Language)
setAttrLanguageValue :: MonadIO m => AttrLanguage -> Ptr Language -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrLanguage.AttrLanguage
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrLanguage.AttrLanguage tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrLanguage.AttrLanguageAttrFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrLanguage.AttrLanguageValueFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrLanguage.AttrLanguage
instance (info ~ GI.Pango.Structs.AttrLanguage.ResolveAttrLanguageMethod t GI.Pango.Structs.AttrLanguage.AttrLanguage, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrLanguage.AttrLanguage p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrLanguage.AttrLanguage -> p)
instance (info ~ GI.Pango.Structs.AttrLanguage.ResolveAttrLanguageMethod t GI.Pango.Structs.AttrLanguage.AttrLanguage, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrLanguage.AttrLanguage p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrLanguage.AttrLanguage -> p)


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

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

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

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

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

-- | Get the range of the current segment. Note that the stored return
--   values are signed, not unsigned like the values in <a>Attribute</a>.
--   To deal with this API oversight, stored return values that wouldn't
--   fit into a signed integer are clamped to <tt><i>G_MAXINT</i></tt>.
attrIteratorRange :: (HasCallStack, MonadIO m) => AttrIterator -> m (Int32, Int32)
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrIterator.AttrIterator
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrIterator.AttrIterator
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrIterator.AttrIteratorDestroyMethodInfo GI.Pango.Structs.AttrIterator.AttrIterator signature
instance (signature ~ m [GI.Pango.Structs.Attribute.Attribute], Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrIterator.AttrIteratorGetAttrsMethodInfo GI.Pango.Structs.AttrIterator.AttrIterator signature
instance (signature ~ (GI.Pango.Structs.FontDescription.FontDescription -> GHC.Base.Maybe GI.Pango.Structs.Language.Language -> [GI.Pango.Structs.Attribute.Attribute] -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrIterator.AttrIteratorGetFontMethodInfo GI.Pango.Structs.AttrIterator.AttrIterator signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrIterator.AttrIteratorNextMethodInfo GI.Pango.Structs.AttrIterator.AttrIterator signature
instance (signature ~ m (GHC.Int.Int32, GHC.Int.Int32), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrIterator.AttrIteratorRangeMethodInfo GI.Pango.Structs.AttrIterator.AttrIterator signature
instance (info ~ GI.Pango.Structs.AttrIterator.ResolveAttrIteratorMethod t GI.Pango.Structs.AttrIterator.AttrIterator, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrIterator.AttrIterator p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrIterator.AttrIterator -> p)
instance (info ~ GI.Pango.Structs.AttrIterator.ResolveAttrIteratorMethod t GI.Pango.Structs.AttrIterator.AttrIterator, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrIterator.AttrIterator p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrIterator.AttrIterator -> p)


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

-- | Construct a <a>AttrInt</a> struct initialized to zero.
newZeroAttrInt :: MonadIO m => m AttrInt
noAttrInt :: Maybe AttrInt
attrInt_attr :: AttrLabelProxy "attr"
getAttrIntAttr :: MonadIO m => AttrInt -> m Attribute
attrInt_value :: AttrLabelProxy "value"
getAttrIntValue :: MonadIO m => AttrInt -> m Int32
setAttrIntValue :: MonadIO m => AttrInt -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrInt.AttrInt
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrInt.AttrInt tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrInt.AttrIntAttrFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrInt.AttrIntValueFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrInt.AttrInt
instance (info ~ GI.Pango.Structs.AttrInt.ResolveAttrIntMethod t GI.Pango.Structs.AttrInt.AttrInt, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrInt.AttrInt p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrInt.AttrInt -> p)
instance (info ~ GI.Pango.Structs.AttrInt.ResolveAttrIntMethod t GI.Pango.Structs.AttrInt.AttrInt, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrInt.AttrInt p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrInt.AttrInt -> p)


-- | The <a>AttrFontFeatures</a> structure is used to represent OpenType
--   font features as an attribute.
module GI.Pango.Structs.AttrFontFeatures
newtype AttrFontFeatures
AttrFontFeatures :: (ManagedPtr AttrFontFeatures) -> AttrFontFeatures

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

-- | Create a new font features tag attribute.
attrFontFeaturesNew :: (HasCallStack, MonadIO m) => Text -> m Attribute
attrFontFeatures_attr :: AttrLabelProxy "attr"
getAttrFontFeaturesAttr :: MonadIO m => AttrFontFeatures -> m Attribute
attrFontFeatures_features :: AttrLabelProxy "features"
clearAttrFontFeaturesFeatures :: MonadIO m => AttrFontFeatures -> m ()
getAttrFontFeaturesFeatures :: MonadIO m => AttrFontFeatures -> m (Maybe Text)
setAttrFontFeaturesFeatures :: MonadIO m => AttrFontFeatures -> CString -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrFontFeatures.AttrFontFeaturesAttrFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrFontFeatures.AttrFontFeaturesFeaturesFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures
instance (info ~ GI.Pango.Structs.AttrFontFeatures.ResolveAttrFontFeaturesMethod t GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures -> p)
instance (info ~ GI.Pango.Structs.AttrFontFeatures.ResolveAttrFontFeaturesMethod t GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrFontFeatures.AttrFontFeatures -> p)


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

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

-- | Create a new font description attribute. This attribute allows setting
--   family, style, weight, variant, stretch, and size simultaneously.
attrFontDescNew :: (HasCallStack, MonadIO m) => FontDescription -> m Attribute
attrFontDesc_attr :: AttrLabelProxy "attr"
getAttrFontDescAttr :: MonadIO m => AttrFontDesc -> m Attribute
attrFontDesc_desc :: AttrLabelProxy "desc"
clearAttrFontDescDesc :: MonadIO m => AttrFontDesc -> m ()
getAttrFontDescDesc :: MonadIO m => AttrFontDesc -> m (Maybe FontDescription)
setAttrFontDescDesc :: MonadIO m => AttrFontDesc -> Ptr FontDescription -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrFontDesc.AttrFontDesc
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrFontDesc.AttrFontDesc tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrFontDesc.AttrFontDescAttrFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrFontDesc.AttrFontDescDescFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrFontDesc.AttrFontDesc
instance (info ~ GI.Pango.Structs.AttrFontDesc.ResolveAttrFontDescMethod t GI.Pango.Structs.AttrFontDesc.AttrFontDesc, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrFontDesc.AttrFontDesc p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrFontDesc.AttrFontDesc -> p)
instance (info ~ GI.Pango.Structs.AttrFontDesc.ResolveAttrFontDescMethod t GI.Pango.Structs.AttrFontDesc.AttrFontDesc, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrFontDesc.AttrFontDesc p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrFontDesc.AttrFontDesc -> p)


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

-- | Construct a <a>AttrFloat</a> struct initialized to zero.
newZeroAttrFloat :: MonadIO m => m AttrFloat
noAttrFloat :: Maybe AttrFloat
attrFloat_attr :: AttrLabelProxy "attr"
getAttrFloatAttr :: MonadIO m => AttrFloat -> m Attribute
attrFloat_value :: AttrLabelProxy "value"
getAttrFloatValue :: MonadIO m => AttrFloat -> m Double
setAttrFloatValue :: MonadIO m => AttrFloat -> Double -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrFloat.AttrFloat
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrFloat.AttrFloat tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrFloat.AttrFloatAttrFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrFloat.AttrFloatValueFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrFloat.AttrFloat
instance (info ~ GI.Pango.Structs.AttrFloat.ResolveAttrFloatMethod t GI.Pango.Structs.AttrFloat.AttrFloat, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrFloat.AttrFloat p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrFloat.AttrFloat -> p)
instance (info ~ GI.Pango.Structs.AttrFloat.ResolveAttrFloatMethod t GI.Pango.Structs.AttrFloat.AttrFloat, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrFloat.AttrFloat p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrFloat.AttrFloat -> p)


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

-- | Construct a <a>AttrColor</a> struct initialized to zero.
newZeroAttrColor :: MonadIO m => m AttrColor
noAttrColor :: Maybe AttrColor
attrColor_attr :: AttrLabelProxy "attr"
getAttrColorAttr :: MonadIO m => AttrColor -> m Attribute
attrColor_color :: AttrLabelProxy "color"
getAttrColorColor :: MonadIO m => AttrColor -> m Color
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrColor.AttrColor
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrColor.AttrColor tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrColor.AttrColorAttrFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrColor.AttrColorColorFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrColor.AttrColor
instance (info ~ GI.Pango.Structs.AttrColor.ResolveAttrColorMethod t GI.Pango.Structs.AttrColor.AttrColor, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrColor.AttrColor p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrColor.AttrColor -> p)
instance (info ~ GI.Pango.Structs.AttrColor.ResolveAttrColorMethod t GI.Pango.Structs.AttrColor.AttrColor, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrColor.AttrColor p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrColor.AttrColor -> p)


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

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

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

-- | Initializes <i><tt>attr</tt></i>'s klass to <i><tt>klass</tt></i>,
--   it's start_index to <a>ATTR_INDEX_FROM_TEXT_BEGINNING</a> and
--   end_index to <tt><i>PANGO_ATTR_INDEX_TO_TEXT_END</i></tt> such that
--   the attribute applies to the entire text by default.
attributeInit :: (HasCallStack, MonadIO m) => Attribute -> AttrClass -> m ()
attribute_endIndex :: AttrLabelProxy "endIndex"
getAttributeEndIndex :: MonadIO m => Attribute -> m Word32
setAttributeEndIndex :: MonadIO m => Attribute -> Word32 -> m ()
attribute_klass :: AttrLabelProxy "klass"
clearAttributeKlass :: MonadIO m => Attribute -> m ()
getAttributeKlass :: MonadIO m => Attribute -> m (Maybe AttrClass)
setAttributeKlass :: MonadIO m => Attribute -> Ptr AttrClass -> m ()
attribute_startIndex :: AttrLabelProxy "startIndex"
getAttributeStartIndex :: MonadIO m => Attribute -> m Word32
setAttributeStartIndex :: MonadIO m => Attribute -> Word32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.Attribute.Attribute
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Attribute.AttributeKlassFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Attribute.AttributeStartIndexFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Attribute.AttributeEndIndexFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.Attribute.Attribute
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Attribute.AttributeDestroyMethodInfo GI.Pango.Structs.Attribute.Attribute signature
instance (signature ~ (GI.Pango.Structs.Attribute.Attribute -> m GHC.Types.Bool), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Attribute.AttributeEqualMethodInfo GI.Pango.Structs.Attribute.Attribute signature
instance (signature ~ (GI.Pango.Structs.AttrClass.AttrClass -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Attribute.AttributeInitMethodInfo GI.Pango.Structs.Attribute.Attribute signature
instance (info ~ GI.Pango.Structs.Attribute.ResolveAttributeMethod t GI.Pango.Structs.Attribute.Attribute, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Attribute.Attribute p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.Attribute.Attribute -> p)
instance (info ~ GI.Pango.Structs.Attribute.ResolveAttributeMethod t GI.Pango.Structs.Attribute.Attribute, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Attribute.Attribute p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.Attribute.Attribute -> p)


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

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

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

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

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

-- | Modifies <i><tt>orig</tt></i> to cover only the text after
--   <i><tt>splitIndex</tt></i>, and returns a new item that covers the
--   text before <i><tt>splitIndex</tt></i> that used to be in
--   <i><tt>orig</tt></i>. You can think of <i><tt>splitIndex</tt></i> as
--   the length of the returned item. <i><tt>splitIndex</tt></i> may not be
--   0, and it may not be greater than or equal to the length of
--   <i><tt>orig</tt></i> (that is, there must be at least one byte
--   assigned to each item, you can't create a zero-length item).
--   <i><tt>splitOffset</tt></i> is the length of the first item in chars,
--   and must be provided because the text used to generate the item isn't
--   available, so <a>itemSplit</a> can't count the char length of the
--   split items itself.
itemSplit :: (HasCallStack, MonadIO m) => Item -> Int32 -> Int32 -> m Item
getItemAnalysis :: MonadIO m => Item -> m Analysis
item_analysis :: AttrLabelProxy "analysis"
getItemLength :: MonadIO m => Item -> m Int32
item_length :: AttrLabelProxy "length"
setItemLength :: MonadIO m => Item -> Int32 -> m ()
getItemNumChars :: MonadIO m => Item -> m Int32
item_numChars :: AttrLabelProxy "numChars"
setItemNumChars :: MonadIO m => Item -> Int32 -> m ()
getItemOffset :: MonadIO m => Item -> m Int32
item_offset :: AttrLabelProxy "offset"
setItemOffset :: MonadIO m => Item -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.Item.Item
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Item.Item tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Item.ItemOffsetFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Item.ItemLengthFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Item.ItemNumCharsFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Item.ItemAnalysisFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.Item.Item
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.Item.Item), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Item.ItemCopyMethodInfo GI.Pango.Structs.Item.Item signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Item.ItemFreeMethodInfo GI.Pango.Structs.Item.Item signature
instance (signature ~ (GHC.Int.Int32 -> GHC.Int.Int32 -> m GI.Pango.Structs.Item.Item), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Item.ItemSplitMethodInfo GI.Pango.Structs.Item.Item signature
instance (info ~ GI.Pango.Structs.Item.ResolveItemMethod t GI.Pango.Structs.Item.Item, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Item.Item p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.Item.Item -> p)
instance (info ~ GI.Pango.Structs.Item.ResolveItemMethod t GI.Pango.Structs.Item.Item, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Item.Item p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.Item.Item -> p)


-- | A <a>LayoutIter</a> structure can be used to iterate over the visual
--   extents of a <a>Layout</a>.
--   
--   The <a>LayoutIter</a> structure is opaque, and has no user-visible
--   fields.
module GI.Pango.Structs.LayoutIter
newtype LayoutIter
LayoutIter :: (ManagedPtr LayoutIter) -> LayoutIter
noLayoutIter :: Maybe LayoutIter
data LayoutIterAtLastLineMethodInfo

-- | Determines whether <i><tt>iter</tt></i> is on the last line of the
--   layout.
layoutIterAtLastLine :: (HasCallStack, MonadIO m) => LayoutIter -> m Bool
data LayoutIterCopyMethodInfo

-- | Copies a <a>LayoutIter</a>.
layoutIterCopy :: (HasCallStack, MonadIO m) => LayoutIter -> m (Maybe LayoutIter)
data LayoutIterFreeMethodInfo

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

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

-- | Gets the extents of the current character, in layout coordinates
--   (origin is the top left of the entire layout). Only logical extents
--   can sensibly be obtained for characters; ink extents make sense only
--   down to the level of clusters.
layoutIterGetCharExtents :: (HasCallStack, MonadIO m) => LayoutIter -> m (Rectangle)
data LayoutIterGetClusterExtentsMethodInfo

-- | Gets the extents of the current cluster, in layout coordinates (origin
--   is the top left of the entire layout).
layoutIterGetClusterExtents :: (HasCallStack, MonadIO m) => LayoutIter -> m (Rectangle, Rectangle)
data LayoutIterGetIndexMethodInfo

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

-- | Gets the layout associated with a <a>LayoutIter</a>.
layoutIterGetLayout :: (HasCallStack, MonadIO m) => LayoutIter -> m Layout
data LayoutIterGetLayoutExtentsMethodInfo

-- | Obtains the extents of the <a>Layout</a> being iterated over.
--   <i><tt>inkRect</tt></i> or <i><tt>logicalRect</tt></i> can be
--   <a>Nothing</a> if you aren't interested in them.
layoutIterGetLayoutExtents :: (HasCallStack, MonadIO m) => LayoutIter -> m (Rectangle, Rectangle)
data LayoutIterGetLineMethodInfo

-- | Gets the current line.
--   
--   Use the faster <a>layoutIterGetLineReadonly</a> if you do not plan to
--   modify the contents of the line (glyphs, glyph widths, etc.).
layoutIterGetLine :: (HasCallStack, MonadIO m) => LayoutIter -> m LayoutLine
data LayoutIterGetLineExtentsMethodInfo

-- | Obtains the extents of the current line. <i><tt>inkRect</tt></i> or
--   <i><tt>logicalRect</tt></i> can be <a>Nothing</a> if you aren't
--   interested in them. Extents are in layout coordinates (origin is the
--   top-left corner of the entire <a>Layout</a>). Thus the extents
--   returned by this function will be the same width/height but not at the
--   same x/y as the extents returned from <a>layoutLineGetExtents</a>.
layoutIterGetLineExtents :: (HasCallStack, MonadIO m) => LayoutIter -> m (Rectangle, Rectangle)
data LayoutIterGetLineReadonlyMethodInfo

-- | 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.).
layoutIterGetLineReadonly :: (HasCallStack, MonadIO m) => LayoutIter -> m LayoutLine
data LayoutIterGetLineYrangeMethodInfo

-- | Divides the vertical space in the <a>Layout</a> being iterated over
--   between the lines in the layout, and returns the space belonging to
--   the current line. A line's range includes the line's logical extents,
--   plus half of the spacing above and below the line, if
--   <a>layoutSetSpacing</a> has been called to set layout spacing. The Y
--   positions are in layout coordinates (origin at top left of the entire
--   layout).
layoutIterGetLineYrange :: (HasCallStack, MonadIO m) => LayoutIter -> m (Int32, Int32)
data LayoutIterGetRunMethodInfo

-- | 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)
data LayoutIterGetRunExtentsMethodInfo

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

-- | Gets the current run. When iterating by run, at the end of each line,
--   there's a position with a <a>Nothing</a> run, so this function can
--   return <a>Nothing</a>. The <a>Nothing</a> run at the end of each line
--   ensures that all lines have at least one run, even lines consisting of
--   only a newline.
--   
--   This is a faster alternative to <a>layoutIterGetRun</a>, but the user
--   is not expected to modify the contents of the run (glyphs, glyph
--   widths, etc.).
layoutIterGetRunReadonly :: (HasCallStack, MonadIO m) => LayoutIter -> m (Maybe GlyphItem)
data LayoutIterNextCharMethodInfo

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

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

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

-- | Moves <i><tt>iter</tt></i> forward to the next run in visual order. If
--   <i><tt>iter</tt></i> was already at the end of the layout, returns
--   <a>False</a>.
layoutIterNextRun :: (HasCallStack, MonadIO m) => LayoutIter -> m Bool
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.LayoutIter.LayoutIter
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.LayoutIter.LayoutIter
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterAtLastLineMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.LayoutIter.LayoutIter), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterCopyMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterFreeMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetBaselineMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m GI.Pango.Structs.Rectangle.Rectangle, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetCharExtentsMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetClusterExtentsMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetIndexMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m GI.Pango.Objects.Layout.Layout, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetLayoutMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetLayoutExtentsMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m GI.Pango.Structs.LayoutLine.LayoutLine, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetLineMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetLineExtentsMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m GI.Pango.Structs.LayoutLine.LayoutLine, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetLineReadonlyMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m (GHC.Int.Int32, GHC.Int.Int32), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetLineYrangeMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.GlyphItem.GlyphItem), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetRunMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetRunExtentsMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.GlyphItem.GlyphItem), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterGetRunReadonlyMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterNextCharMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterNextClusterMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterNextLineMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutIter.LayoutIterNextRunMethodInfo GI.Pango.Structs.LayoutIter.LayoutIter signature
instance (info ~ GI.Pango.Structs.LayoutIter.ResolveLayoutIterMethod t GI.Pango.Structs.LayoutIter.LayoutIter, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.LayoutIter.LayoutIter p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.LayoutIter.LayoutIter -> p)
instance (info ~ GI.Pango.Structs.LayoutIter.ResolveLayoutIterMethod t GI.Pango.Structs.LayoutIter.LayoutIter, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.LayoutIter.LayoutIter p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.LayoutIter.LayoutIter -> p)


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

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

-- | 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)
data LayoutLineGetPixelExtentsMethodInfo

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

-- | 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])
data LayoutLineIndexToXMethodInfo

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

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

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

-- | 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)
getLayoutLineIsParagraphStart :: MonadIO m => LayoutLine -> m Word32
layoutLine_isParagraphStart :: AttrLabelProxy "isParagraphStart"
setLayoutLineIsParagraphStart :: MonadIO m => LayoutLine -> Word32 -> m ()
clearLayoutLineLayout :: MonadIO m => LayoutLine -> m ()
getLayoutLineLayout :: MonadIO m => LayoutLine -> m (Maybe Layout)
layoutLine_layout :: AttrLabelProxy "layout"
setLayoutLineLayout :: MonadIO m => LayoutLine -> Ptr Layout -> m ()
getLayoutLineLength :: MonadIO m => LayoutLine -> m Int32
layoutLine_length :: AttrLabelProxy "length"
setLayoutLineLength :: MonadIO m => LayoutLine -> Int32 -> m ()
getLayoutLineResolvedDir :: MonadIO m => LayoutLine -> m Word32
layoutLine_resolvedDir :: AttrLabelProxy "resolvedDir"
setLayoutLineResolvedDir :: MonadIO m => LayoutLine -> Word32 -> m ()
clearLayoutLineRuns :: MonadIO m => LayoutLine -> m ()
getLayoutLineRuns :: MonadIO m => LayoutLine -> m ([Ptr ()])
layoutLine_runs :: AttrLabelProxy "runs"
setLayoutLineRuns :: MonadIO m => LayoutLine -> Ptr (GSList (Ptr ())) -> m ()
getLayoutLineStartIndex :: MonadIO m => LayoutLine -> m Int32
layoutLine_startIndex :: AttrLabelProxy "startIndex"
setLayoutLineStartIndex :: MonadIO m => LayoutLine -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.LayoutLine.LayoutLine
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.LayoutLine.LayoutLine tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LayoutLine.LayoutLineLayoutFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LayoutLine.LayoutLineStartIndexFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LayoutLine.LayoutLineLengthFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LayoutLine.LayoutLineRunsFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LayoutLine.LayoutLineIsParagraphStartFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.LayoutLine.LayoutLineResolvedDirFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.LayoutLine.LayoutLine
instance (signature ~ m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutLine.LayoutLineGetExtentsMethodInfo GI.Pango.Structs.LayoutLine.LayoutLine signature
instance (signature ~ m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutLine.LayoutLineGetPixelExtentsMethodInfo GI.Pango.Structs.LayoutLine.LayoutLine signature
instance (signature ~ (GHC.Int.Int32 -> GHC.Int.Int32 -> m [GHC.Int.Int32]), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutLine.LayoutLineGetXRangesMethodInfo GI.Pango.Structs.LayoutLine.LayoutLine signature
instance (signature ~ (GHC.Int.Int32 -> GHC.Types.Bool -> m GHC.Int.Int32), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutLine.LayoutLineIndexToXMethodInfo GI.Pango.Structs.LayoutLine.LayoutLine signature
instance (signature ~ m GI.Pango.Structs.LayoutLine.LayoutLine, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutLine.LayoutLineRefMethodInfo GI.Pango.Structs.LayoutLine.LayoutLine signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutLine.LayoutLineUnrefMethodInfo GI.Pango.Structs.LayoutLine.LayoutLine signature
instance (signature ~ (GHC.Int.Int32 -> m (GHC.Types.Bool, GHC.Int.Int32, GHC.Int.Int32)), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.LayoutLine.LayoutLineXToIndexMethodInfo GI.Pango.Structs.LayoutLine.LayoutLine signature
instance (info ~ GI.Pango.Structs.LayoutLine.ResolveLayoutLineMethod t GI.Pango.Structs.LayoutLine.LayoutLine, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.LayoutLine.LayoutLine p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.LayoutLine.LayoutLine -> p)
instance (info ~ GI.Pango.Structs.LayoutLine.ResolveLayoutLineMethod t GI.Pango.Structs.LayoutLine.LayoutLine, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.LayoutLine.LayoutLine p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.LayoutLine.LayoutLine -> p)


-- | The <a>FontFace</a> structure is used to represent a group of fonts
--   with the same family, slant, weight, width, but varying sizes.
module GI.Pango.Objects.FontFace
newtype FontFace
FontFace :: (ManagedPtr FontFace) -> FontFace
class GObject o => IsFontFace o
toFontFace :: IsFontFace o => o -> IO FontFace
noFontFace :: Maybe FontFace
data FontFaceDescribeMethodInfo

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

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

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

-- | 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.
fontFaceListSizes :: (HasCallStack, MonadIO m, IsFontFace a) => a -> m ((Maybe [Int32]))
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontFace.FontFace
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.FontFace.FontFace a) => GI.Pango.Objects.FontFace.IsFontFace a
instance GI.Pango.Objects.FontFace.IsFontFace GI.Pango.Objects.FontFace.FontFace
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.FontFace.FontFace
instance (info ~ GI.Pango.Objects.FontFace.ResolveFontFaceMethod t GI.Pango.Objects.FontFace.FontFace, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.FontFace.FontFace p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.FontFace.FontFace -> p)
instance (info ~ GI.Pango.Objects.FontFace.ResolveFontFaceMethod t GI.Pango.Objects.FontFace.FontFace, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.FontFace.FontFace p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.FontFace.FontFace -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.FontFace.FontFace
instance (signature ~ m GI.Pango.Structs.FontDescription.FontDescription, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontFace.IsFontFace a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontFace.FontFaceDescribeMethodInfo a signature
instance (signature ~ m Data.Text.Internal.Text, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontFace.IsFontFace a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontFace.FontFaceGetFaceNameMethodInfo a signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontFace.IsFontFace a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontFace.FontFaceIsSynthesizedMethodInfo a signature
instance (signature ~ m (GHC.Base.Maybe [GHC.Int.Int32]), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontFace.IsFontFace a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontFace.FontFaceListSizesMethodInfo a signature


-- | The <a>FontFamily</a> structure is used to represent a family of
--   related font faces. The faces in a family share a common design, but
--   differ in slant, weight, width and other aspects.
module GI.Pango.Objects.FontFamily
newtype FontFamily
FontFamily :: (ManagedPtr FontFamily) -> FontFamily
class GObject o => IsFontFamily o
toFontFamily :: IsFontFamily o => o -> IO FontFamily
noFontFamily :: Maybe FontFamily
data FontFamilyGetNameMethodInfo

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

-- | 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.
fontFamilyIsMonospace :: (HasCallStack, MonadIO m, IsFontFamily a) => a -> m Bool
data FontFamilyListFacesMethodInfo

-- | Lists the different font faces that make up <i><tt>family</tt></i>.
--   The faces in a family share a common design, but differ in slant,
--   weight, width and other aspects.
fontFamilyListFaces :: (HasCallStack, MonadIO m, IsFontFamily a) => a -> m ([FontFace])
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontFamily.FontFamily
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.FontFamily.FontFamily a) => GI.Pango.Objects.FontFamily.IsFontFamily a
instance GI.Pango.Objects.FontFamily.IsFontFamily GI.Pango.Objects.FontFamily.FontFamily
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.FontFamily.FontFamily
instance (info ~ GI.Pango.Objects.FontFamily.ResolveFontFamilyMethod t GI.Pango.Objects.FontFamily.FontFamily, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.FontFamily.FontFamily p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.FontFamily.FontFamily -> p)
instance (info ~ GI.Pango.Objects.FontFamily.ResolveFontFamilyMethod t GI.Pango.Objects.FontFamily.FontFamily, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.FontFamily.FontFamily p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.FontFamily.FontFamily -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.FontFamily.FontFamily
instance (signature ~ m Data.Text.Internal.Text, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontFamily.IsFontFamily a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontFamily.FontFamilyGetNameMethodInfo a signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontFamily.IsFontFamily a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontFamily.FontFamilyIsMonospaceMethodInfo a signature
instance (signature ~ m [GI.Pango.Objects.FontFace.FontFace], Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontFamily.IsFontFamily a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontFamily.FontFamilyListFacesMethodInfo a signature


-- | The <a>Font</a> structure is used to represent a font in a
--   rendering-system-independent matter. To create an implementation of a
--   <a>Font</a>, the rendering-system specific code should allocate a
--   larger structure that contains a nested <a>Font</a>, fill in the
--   &lt;structfield&gt;klass&lt;/structfield&gt; member of the nested
--   <a>Font</a> with a pointer to a appropriate <a>FontClass</a>, then
--   call <tt><i>pango_font_init()</i></tt> on the structure.
--   
--   The <a>Font</a> structure contains one member which the implementation
--   fills in.
module GI.Pango.Objects.Font
newtype Font
Font :: (ManagedPtr Font) -> Font
class GObject o => IsFont o
toFont :: IsFont o => o -> IO Font
noFont :: Maybe Font
data FontDescribeMethodInfo

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

-- | 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.
fontDescribeWithAbsoluteSize :: (HasCallStack, MonadIO m, IsFont a) => a -> m FontDescription

-- | Frees an array of font descriptions.
fontDescriptionsFree :: (HasCallStack, MonadIO m) => Maybe ([FontDescription]) -> m ()
data FontGetFontMapMethodInfo

-- | Gets the font map for which the font was created.
--   
--   Note that the font maintains a &lt;firstterm&gt;weak&lt;/firstterm&gt;
--   reference to the font map, so if all references to font map are
--   dropped, the font map will be finalized even if there are fonts
--   created with the font map that are still alive. In that case this
--   function will return <a>Nothing</a>. It is the responsibility of the
--   user to ensure that the font map is kept alive. In most uses this is
--   not an issue as a <a>Context</a> holds a reference to the font map.
fontGetFontMap :: (HasCallStack, MonadIO m, IsFont a) => a -> m (Maybe FontMap)
data FontGetGlyphExtentsMethodInfo

-- | Gets the logical and ink extents of a glyph within a font. The
--   coordinate system for each rectangle has its origin at the base line
--   and horizontal origin of the character with increasing coordinates
--   extending to the right and down. The macros
--   <tt><i>PANGO_ASCENT()</i></tt>, <tt><i>PANGO_DESCENT()</i></tt>,
--   <tt><i>PANGO_LBEARING()</i></tt>, and <tt><i>PANGO_RBEARING()</i></tt>
--   can be used to convert from the extents rectangle to more traditional
--   font metrics. The units of the rectangles are in 1/PANGO_SCALE of a
--   device unit.
--   
--   If <i><tt>font</tt></i> is <a>Nothing</a>, this function gracefully
--   sets some sane values in the output variables and returns.
fontGetGlyphExtents :: (HasCallStack, MonadIO m, IsFont a) => a -> Word32 -> m (Rectangle, Rectangle)
data FontGetMetricsMethodInfo

-- | Gets overall metric information for a font. Since the metrics may be
--   substantially different for different scripts, a language tag can be
--   provided to indicate that the metrics should be retrieved that
--   correspond to the script(s) used by that language.
--   
--   If <i><tt>font</tt></i> is <a>Nothing</a>, this function gracefully
--   sets some sane values in the output variables and returns.
fontGetMetrics :: (HasCallStack, MonadIO m, IsFont a) => a -> Maybe (Language) -> m FontMetrics
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Font.Font
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.Font.Font a) => GI.Pango.Objects.Font.IsFont a
instance GI.Pango.Objects.Font.IsFont GI.Pango.Objects.Font.Font
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.Font.Font
instance (info ~ GI.Pango.Objects.Font.ResolveFontMethod t GI.Pango.Objects.Font.Font, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Font.Font p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.Font.Font -> p)
instance (info ~ GI.Pango.Objects.Font.ResolveFontMethod t GI.Pango.Objects.Font.Font, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Font.Font p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.Font.Font -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.Font.Font
instance (signature ~ m GI.Pango.Structs.FontDescription.FontDescription, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Font.IsFont a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Font.FontDescribeMethodInfo a signature
instance (signature ~ m GI.Pango.Structs.FontDescription.FontDescription, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Font.IsFont a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Font.FontDescribeWithAbsoluteSizeMethodInfo a signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Objects.FontMap.FontMap), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Font.IsFont a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Font.FontGetFontMapMethodInfo a signature
instance (signature ~ (GHC.Word.Word32 -> m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Font.IsFont a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Font.FontGetGlyphExtentsMethodInfo a signature
instance (signature ~ (GHC.Base.Maybe GI.Pango.Structs.Language.Language -> m GI.Pango.Structs.FontMetrics.FontMetrics), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Font.IsFont a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Font.FontGetMetricsMethodInfo a signature


-- | <a>FontsetSimple</a> is a implementation of the abstract
--   <a>Fontset</a> base class in terms of an array of fonts, which the
--   creator provides when constructing the <a>FontsetSimple</a>.
module GI.Pango.Objects.FontsetSimple
newtype FontsetSimple
FontsetSimple :: (ManagedPtr FontsetSimple) -> FontsetSimple
class GObject o => IsFontsetSimple o
toFontsetSimple :: IsFontsetSimple o => o -> IO FontsetSimple
noFontsetSimple :: Maybe FontsetSimple
data FontsetSimpleAppendMethodInfo

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

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

-- | Returns the number of fonts in the fontset.
fontsetSimpleSize :: (HasCallStack, MonadIO m, IsFontsetSimple a) => a -> m Int32
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontsetSimple.FontsetSimple
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.FontsetSimple.FontsetSimple a) => GI.Pango.Objects.FontsetSimple.IsFontsetSimple a
instance GI.Pango.Objects.FontsetSimple.IsFontsetSimple GI.Pango.Objects.FontsetSimple.FontsetSimple
instance GI.Pango.Objects.Fontset.IsFontset GI.Pango.Objects.FontsetSimple.FontsetSimple
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.FontsetSimple.FontsetSimple
instance (info ~ GI.Pango.Objects.FontsetSimple.ResolveFontsetSimpleMethod t GI.Pango.Objects.FontsetSimple.FontsetSimple, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.FontsetSimple.FontsetSimple p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.FontsetSimple.FontsetSimple -> p)
instance (info ~ GI.Pango.Objects.FontsetSimple.ResolveFontsetSimpleMethod t GI.Pango.Objects.FontsetSimple.FontsetSimple, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.FontsetSimple.FontsetSimple p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.FontsetSimple.FontsetSimple -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.FontsetSimple.FontsetSimple
instance (signature ~ (b -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontsetSimple.IsFontsetSimple a, GI.Pango.Objects.Font.IsFont b) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontsetSimple.FontsetSimpleAppendMethodInfo a signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontsetSimple.IsFontsetSimple a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontsetSimple.FontsetSimpleSizeMethodInfo a signature


-- | The <a>GlyphString</a> structure is used to store strings of glyphs
--   with geometry and visual attribute information. The storage for the
--   glyph information is owned by the structure which simplifies memory
--   management.
module GI.Pango.Structs.GlyphString
newtype GlyphString
GlyphString :: (ManagedPtr GlyphString) -> GlyphString

-- | Construct a <a>GlyphString</a> struct initialized to zero.
newZeroGlyphString :: MonadIO m => m GlyphString
noGlyphString :: Maybe GlyphString
data GlyphStringCopyMethodInfo

-- | Copy a glyph string and associated storage.
glyphStringCopy :: (HasCallStack, MonadIO m) => GlyphString -> m (Maybe GlyphString)
data GlyphStringExtentsMethodInfo

-- | Compute the logical and ink extents of a glyph string. See the
--   documentation for <a>fontGetGlyphExtents</a> for details about the
--   interpretation of the rectangles.
glyphStringExtents :: (HasCallStack, MonadIO m, IsFont a) => GlyphString -> a -> m (Rectangle, Rectangle)
data GlyphStringExtentsRangeMethodInfo

-- | 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)
data GlyphStringFreeMethodInfo

-- | Free a glyph string and associated storage.
glyphStringFree :: (HasCallStack, MonadIO m) => GlyphString -> m ()
data GlyphStringGetLogicalWidthsMethodInfo

-- | Given a <a>GlyphString</a> resulting from <a>shape</a> and the
--   corresponding text, determine the screen width corresponding to each
--   character. When multiple characters compose a single cluster, the
--   width of the entire cluster is divided equally among the characters.
--   
--   See also <a>glyphItemGetLogicalWidths</a>.
glyphStringGetLogicalWidths :: (HasCallStack, MonadIO m) => GlyphString -> Text -> Int32 -> Int32 -> Ptr Int32 -> m ()
data GlyphStringGetWidthMethodInfo

-- | Computes the logical width of the glyph string as can also be computed
--   using <a>glyphStringExtents</a>. However, since this only computes the
--   width, it's much faster. This is in fact only a convenience function
--   that computes the sum of geometry.width for each glyph in the
--   <i><tt>glyphs</tt></i>.
glyphStringGetWidth :: (HasCallStack, MonadIO m) => GlyphString -> m Int32
data GlyphStringIndexToXMethodInfo

-- | Converts from character position to x position. (X position is
--   measured from the left edge of the run). Character positions are
--   computed by dividing up each cluster into equal portions.
glyphStringIndexToX :: (HasCallStack, MonadIO m) => GlyphString -> Text -> Int32 -> Analysis -> Int32 -> Bool -> m (Int32)

-- | Create a new <a>GlyphString</a>.
glyphStringNew :: (HasCallStack, MonadIO m) => m GlyphString
data GlyphStringSetSizeMethodInfo

-- | Resize a glyph string to the given length.
glyphStringSetSize :: (HasCallStack, MonadIO m) => GlyphString -> Int32 -> m ()
data GlyphStringXToIndexMethodInfo

-- | 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)
getGlyphStringLogClusters :: MonadIO m => GlyphString -> m Int32
glyphString_logClusters :: AttrLabelProxy "logClusters"
setGlyphStringLogClusters :: MonadIO m => GlyphString -> Int32 -> m ()
getGlyphStringNumGlyphs :: MonadIO m => GlyphString -> m Int32
glyphString_numGlyphs :: AttrLabelProxy "numGlyphs"
setGlyphStringNumGlyphs :: MonadIO m => GlyphString -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.GlyphString.GlyphString
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.GlyphString.GlyphString tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphString.GlyphStringNumGlyphsFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.GlyphString.GlyphStringLogClustersFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.GlyphString.GlyphString
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.GlyphString.GlyphString), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphString.GlyphStringCopyMethodInfo GI.Pango.Structs.GlyphString.GlyphString signature
instance (signature ~ (a -> m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Font.IsFont a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphString.GlyphStringExtentsMethodInfo GI.Pango.Structs.GlyphString.GlyphString signature
instance (signature ~ (GHC.Int.Int32 -> GHC.Int.Int32 -> a -> m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Font.IsFont a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphString.GlyphStringExtentsRangeMethodInfo GI.Pango.Structs.GlyphString.GlyphString signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphString.GlyphStringFreeMethodInfo GI.Pango.Structs.GlyphString.GlyphString signature
instance (signature ~ (Data.Text.Internal.Text -> GHC.Int.Int32 -> GHC.Int.Int32 -> GHC.Ptr.Ptr GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphString.GlyphStringGetLogicalWidthsMethodInfo GI.Pango.Structs.GlyphString.GlyphString signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphString.GlyphStringGetWidthMethodInfo GI.Pango.Structs.GlyphString.GlyphString signature
instance (signature ~ (Data.Text.Internal.Text -> GHC.Int.Int32 -> GI.Pango.Structs.Analysis.Analysis -> GHC.Int.Int32 -> GHC.Types.Bool -> m GHC.Int.Int32), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphString.GlyphStringIndexToXMethodInfo GI.Pango.Structs.GlyphString.GlyphString signature
instance (signature ~ (GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphString.GlyphStringSetSizeMethodInfo GI.Pango.Structs.GlyphString.GlyphString signature
instance (signature ~ (Data.Text.Internal.Text -> GHC.Int.Int32 -> GI.Pango.Structs.Analysis.Analysis -> GHC.Int.Int32 -> m (GHC.Int.Int32, GHC.Int.Int32)), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.GlyphString.GlyphStringXToIndexMethodInfo GI.Pango.Structs.GlyphString.GlyphString signature
instance (info ~ GI.Pango.Structs.GlyphString.ResolveGlyphStringMethod t GI.Pango.Structs.GlyphString.GlyphString, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphString.GlyphString p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.GlyphString.GlyphString -> p)
instance (info ~ GI.Pango.Structs.GlyphString.ResolveGlyphStringMethod t GI.Pango.Structs.GlyphString.GlyphString, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.GlyphString.GlyphString p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.GlyphString.GlyphString -> p)


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

-- | Construct a <a>Analysis</a> struct initialized to zero.
newZeroAnalysis :: MonadIO m => m Analysis
noAnalysis :: Maybe Analysis
analysis_extraAttrs :: AttrLabelProxy "extraAttrs"
clearAnalysisExtraAttrs :: MonadIO m => Analysis -> m ()
getAnalysisExtraAttrs :: MonadIO m => Analysis -> m ([Ptr ()])
setAnalysisExtraAttrs :: MonadIO m => Analysis -> Ptr (GSList (Ptr ())) -> m ()
analysis_flags :: AttrLabelProxy "flags"
getAnalysisFlags :: MonadIO m => Analysis -> m Word8
setAnalysisFlags :: MonadIO m => Analysis -> Word8 -> m ()
analysis_font :: AttrLabelProxy "font"
clearAnalysisFont :: MonadIO m => Analysis -> m ()
getAnalysisFont :: MonadIO m => Analysis -> m (Maybe Font)
setAnalysisFont :: MonadIO m => Analysis -> Ptr Font -> m ()
analysis_gravity :: AttrLabelProxy "gravity"
getAnalysisGravity :: MonadIO m => Analysis -> m Word8
setAnalysisGravity :: MonadIO m => Analysis -> Word8 -> m ()
analysis_langEngine :: AttrLabelProxy "langEngine"
clearAnalysisLangEngine :: MonadIO m => Analysis -> m ()
getAnalysisLangEngine :: MonadIO m => Analysis -> m (Maybe EngineLang)
setAnalysisLangEngine :: MonadIO m => Analysis -> Ptr EngineLang -> m ()
analysis_language :: AttrLabelProxy "language"
clearAnalysisLanguage :: MonadIO m => Analysis -> m ()
getAnalysisLanguage :: MonadIO m => Analysis -> m (Maybe Language)
setAnalysisLanguage :: MonadIO m => Analysis -> Ptr Language -> m ()
analysis_level :: AttrLabelProxy "level"
getAnalysisLevel :: MonadIO m => Analysis -> m Word8
setAnalysisLevel :: MonadIO m => Analysis -> Word8 -> m ()
analysis_script :: AttrLabelProxy "script"
getAnalysisScript :: MonadIO m => Analysis -> m Word8
setAnalysisScript :: MonadIO m => Analysis -> Word8 -> m ()
analysis_shapeEngine :: AttrLabelProxy "shapeEngine"
clearAnalysisShapeEngine :: MonadIO m => Analysis -> m ()
getAnalysisShapeEngine :: MonadIO m => Analysis -> m (Maybe EngineShape)
setAnalysisShapeEngine :: MonadIO m => Analysis -> Ptr EngineShape -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.Analysis.Analysis
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.Analysis.Analysis tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Analysis.AnalysisShapeEngineFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Analysis.AnalysisLangEngineFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Analysis.AnalysisFontFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Analysis.AnalysisLevelFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Analysis.AnalysisGravityFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Analysis.AnalysisFlagsFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Analysis.AnalysisScriptFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Analysis.AnalysisLanguageFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.Analysis.AnalysisExtraAttrsFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.Analysis.Analysis
instance (info ~ GI.Pango.Structs.Analysis.ResolveAnalysisMethod t GI.Pango.Structs.Analysis.Analysis, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Analysis.Analysis p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.Analysis.Analysis -> p)
instance (info ~ GI.Pango.Structs.Analysis.ResolveAnalysisMethod t GI.Pango.Structs.Analysis.Analysis, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Analysis.Analysis p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.Analysis.Analysis -> p)


-- | <a>Engine</a> is the base class for all types of language and script
--   specific engines. It has no functionality by itself.
module GI.Pango.Objects.Engine
newtype Engine
Engine :: (ManagedPtr Engine) -> Engine
class GObject o => IsEngine o
toEngine :: IsEngine o => o -> IO Engine
noEngine :: Maybe Engine
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Engine.Engine
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.Engine.Engine a) => GI.Pango.Objects.Engine.IsEngine a
instance GI.Pango.Objects.Engine.IsEngine GI.Pango.Objects.Engine.Engine
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.Engine.Engine
instance (info ~ GI.Pango.Objects.Engine.ResolveEngineMethod t GI.Pango.Objects.Engine.Engine, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Engine.Engine p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.Engine.Engine -> p)
instance (info ~ GI.Pango.Objects.Engine.ResolveEngineMethod t GI.Pango.Objects.Engine.Engine, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Engine.Engine p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.Engine.Engine -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.Engine.Engine


-- | The <a>EngineLang</a> class is implemented by engines that customize
--   the rendering-system independent part of the Pango pipeline for a
--   particular script or language. For instance, a custom
--   <a>EngineLang</a> could be provided for Thai to implement the
--   dictionary-based word boundary lookups needed for that language.
module GI.Pango.Objects.EngineLang
newtype EngineLang
EngineLang :: (ManagedPtr EngineLang) -> EngineLang
class GObject o => IsEngineLang o
toEngineLang :: IsEngineLang o => o -> IO EngineLang
noEngineLang :: Maybe EngineLang
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.EngineLang.EngineLang
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.EngineLang.EngineLang a) => GI.Pango.Objects.EngineLang.IsEngineLang a
instance GI.Pango.Objects.EngineLang.IsEngineLang GI.Pango.Objects.EngineLang.EngineLang
instance GI.Pango.Objects.Engine.IsEngine GI.Pango.Objects.EngineLang.EngineLang
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.EngineLang.EngineLang
instance (info ~ GI.Pango.Objects.EngineLang.ResolveEngineLangMethod t GI.Pango.Objects.EngineLang.EngineLang, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.EngineLang.EngineLang p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.EngineLang.EngineLang -> p)
instance (info ~ GI.Pango.Objects.EngineLang.ResolveEngineLangMethod t GI.Pango.Objects.EngineLang.EngineLang, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.EngineLang.EngineLang p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.EngineLang.EngineLang -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.EngineLang.EngineLang


-- | The <a>EngineShape</a> class is implemented by engines that customize
--   the rendering-system dependent part of the Pango pipeline for a
--   particular script or language. A <a>EngineShape</a> implementation is
--   then specific to both a particular rendering system or group of
--   rendering systems and to a particular script. For instance, there is
--   one <a>EngineShape</a> implementation to handle shaping Arabic for
--   Fontconfig-based backends.
module GI.Pango.Objects.EngineShape
newtype EngineShape
EngineShape :: (ManagedPtr EngineShape) -> EngineShape
class GObject o => IsEngineShape o
toEngineShape :: IsEngineShape o => o -> IO EngineShape
noEngineShape :: Maybe EngineShape
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.EngineShape.EngineShape
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.EngineShape.EngineShape a) => GI.Pango.Objects.EngineShape.IsEngineShape a
instance GI.Pango.Objects.EngineShape.IsEngineShape GI.Pango.Objects.EngineShape.EngineShape
instance GI.Pango.Objects.Engine.IsEngine GI.Pango.Objects.EngineShape.EngineShape
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.EngineShape.EngineShape
instance (info ~ GI.Pango.Objects.EngineShape.ResolveEngineShapeMethod t GI.Pango.Objects.EngineShape.EngineShape, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.EngineShape.EngineShape p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.EngineShape.EngineShape -> p)
instance (info ~ GI.Pango.Objects.EngineShape.ResolveEngineShapeMethod t GI.Pango.Objects.EngineShape.EngineShape, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.EngineShape.EngineShape p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.EngineShape.EngineShape -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.EngineShape.EngineShape


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

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

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

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

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

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

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

-- | 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)
data FontMapLoadFontsetMethodInfo

-- | Load a set of fonts in the fontmap that can be used to render a font
--   matching <i><tt>desc</tt></i>.
fontMapLoadFontset :: (HasCallStack, MonadIO m, IsFontMap a, IsContext b) => a -> b -> FontDescription -> Language -> m (Maybe Fontset)
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.FontMap.FontMap
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.FontMap.FontMap a) => GI.Pango.Objects.FontMap.IsFontMap a
instance GI.Pango.Objects.FontMap.IsFontMap GI.Pango.Objects.FontMap.FontMap
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.FontMap.FontMap
instance (info ~ GI.Pango.Objects.FontMap.ResolveFontMapMethod t GI.Pango.Objects.FontMap.FontMap, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.FontMap.FontMap p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.FontMap.FontMap -> p)
instance (info ~ GI.Pango.Objects.FontMap.ResolveFontMapMethod t GI.Pango.Objects.FontMap.FontMap, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.FontMap.FontMap p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.FontMap.FontMap -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.FontMap.FontMap
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontMap.IsFontMap a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontMap.FontMapChangedMethodInfo a signature
instance (signature ~ m GI.Pango.Objects.Context.Context, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontMap.IsFontMap a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontMap.FontMapCreateContextMethodInfo a signature
instance (signature ~ m GHC.Word.Word32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontMap.IsFontMap a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontMap.FontMapGetSerialMethodInfo a signature
instance (signature ~ m Data.Text.Internal.Text, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontMap.IsFontMap a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontMap.FontMapGetShapeEngineTypeMethodInfo a signature
instance (signature ~ m [GI.Pango.Objects.FontFamily.FontFamily], Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontMap.IsFontMap a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontMap.FontMapListFamiliesMethodInfo a signature
instance (signature ~ (b -> GI.Pango.Structs.FontDescription.FontDescription -> m (GHC.Base.Maybe GI.Pango.Objects.Font.Font)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontMap.IsFontMap a, GI.Pango.Objects.Context.IsContext b) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontMap.FontMapLoadFontMethodInfo a signature
instance (signature ~ (b -> GI.Pango.Structs.FontDescription.FontDescription -> GI.Pango.Structs.Language.Language -> m (GHC.Base.Maybe GI.Pango.Objects.Fontset.Fontset)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.FontMap.IsFontMap a, GI.Pango.Objects.Context.IsContext b) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.FontMap.FontMapLoadFontsetMethodInfo a signature


module GI.Pango.Flags

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

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

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

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

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

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

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

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

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


module GI.Pango.Enums

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

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

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

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

-- | Catch-all for unknown values
AnotherWrapMode :: Int -> WrapMode

-- | An enumeration specifying the weight (boldness) of a font. This is a
--   numerical value ranging from 100 to 1000, but there are some
--   predefined values:
data Weight

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | A normal font.
VariantNormal :: Variant

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

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

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

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

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

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

-- | a single underline should be drawn at a position beneath the ink
--   extents of the text being underlined. This should be used only for
--   underlining single characters, such as for keyboard accelerators.
--   <a>UnderlineSingle</a> should be used for extended portions of text.
UnderlineLow :: Underline

-- | a wavy underline should be drawn below. This underline is typically
--   used to indicate an error such as a possilble mispelling; in some
--   cases a contrasting color may automatically be used. This type of
--   underlining is available since Pango 1.4.
UnderlineError :: Underline

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

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

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

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

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

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

-- | The <a>Script</a> enumeration identifies different writing systems.
--   The values correspond to the names as defined in the Unicode standard.
--   Note that new types may be added in the future. Applications should be
--   ready to handle unknown values. This enumeration is interchangeable
--   with <a>UnicodeScript</a>. See &lt;ulink
--   url="http://www.unicode.org/reports/tr24/"&gt;Unicode Standard Annex
--   <tt><i>24</i></tt>: Script names&lt;/ulink&gt;.
data Script

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

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

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

-- | Arabic
ScriptArabic :: Script

-- | Armenian
ScriptArmenian :: Script

-- | Bengali
ScriptBengali :: Script

-- | Bopomofo
ScriptBopomofo :: Script

-- | Cherokee
ScriptCherokee :: Script

-- | Coptic
ScriptCoptic :: Script

-- | Cyrillic
ScriptCyrillic :: Script

-- | Deseret
ScriptDeseret :: Script

-- | Devanagari
ScriptDevanagari :: Script

-- | Ethiopic
ScriptEthiopic :: Script

-- | Georgian
ScriptGeorgian :: Script

-- | Gothic
ScriptGothic :: Script

-- | Greek
ScriptGreek :: Script

-- | Gujarati
ScriptGujarati :: Script

-- | Gurmukhi
ScriptGurmukhi :: Script

-- | Han
ScriptHan :: Script

-- | Hangul
ScriptHangul :: Script

-- | Hebrew
ScriptHebrew :: Script

-- | Hiragana
ScriptHiragana :: Script

-- | Kannada
ScriptKannada :: Script

-- | Katakana
ScriptKatakana :: Script

-- | Khmer
ScriptKhmer :: Script

-- | Lao
ScriptLao :: Script

-- | Latin
ScriptLatin :: Script

-- | Malayalam
ScriptMalayalam :: Script

-- | Mongolian
ScriptMongolian :: Script

-- | Myanmar
ScriptMyanmar :: Script

-- | Ogham
ScriptOgham :: Script

-- | Old Italic
ScriptOldItalic :: Script

-- | Oriya
ScriptOriya :: Script

-- | Runic
ScriptRunic :: Script

-- | Sinhala
ScriptSinhala :: Script

-- | Syriac
ScriptSyriac :: Script

-- | Tamil
ScriptTamil :: Script

-- | Telugu
ScriptTelugu :: Script

-- | Thaana
ScriptThaana :: Script

-- | Thai
ScriptThai :: Script

-- | Tibetan
ScriptTibetan :: Script

-- | Canadian Aboriginal
ScriptCanadianAboriginal :: Script

-- | Yi
ScriptYi :: Script

-- | Tagalog
ScriptTagalog :: Script

-- | Hanunoo
ScriptHanunoo :: Script

-- | Buhid
ScriptBuhid :: Script

-- | Tagbanwa
ScriptTagbanwa :: Script

-- | Braille
ScriptBraille :: Script

-- | Cypriot
ScriptCypriot :: Script

-- | Limbu
ScriptLimbu :: Script

-- | Osmanya
ScriptOsmanya :: Script

-- | Shavian
ScriptShavian :: Script

-- | Linear B
ScriptLinearB :: Script

-- | Tai Le
ScriptTaiLe :: Script

-- | Ugaritic
ScriptUgaritic :: Script

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

-- | Buginese. Since 1.10
ScriptBuginese :: Script

-- | Glagolitic. Since 1.10
ScriptGlagolitic :: Script

-- | Tifinagh. Since 1.10
ScriptTifinagh :: Script

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

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

-- | Kharoshthi. Since 1.10
ScriptKharoshthi :: Script

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

-- | Balinese. Since 1.14
ScriptBalinese :: Script

-- | Cuneiform. Since 1.14
ScriptCuneiform :: Script

-- | Phoenician. Since 1.14
ScriptPhoenician :: Script

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

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

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

-- | Lepcha. Since 1.20.1
ScriptLepcha :: Script

-- | Rejang. Since 1.20.1
ScriptRejang :: Script

-- | Sundanese. Since 1.20.1
ScriptSundanese :: Script

-- | Saurashtra. Since 1.20.1
ScriptSaurashtra :: Script

-- | Cham. Since 1.20.1
ScriptCham :: Script

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

-- | Vai. Since 1.20.1
ScriptVai :: Script

-- | Carian. Since 1.20.1
ScriptCarian :: Script

-- | Lycian. Since 1.20.1
ScriptLycian :: Script

-- | Lydian. Since 1.20.1
ScriptLydian :: Script

-- | Batak. Since 1.32
ScriptBatak :: Script

-- | Brahmi. Since 1.32
ScriptBrahmi :: Script

-- | Mandaic. Since 1.32
ScriptMandaic :: Script

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | the text itself
RenderPartForeground :: RenderPart

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

-- | underlines
RenderPartUnderline :: RenderPart

-- | strikethrough lines
RenderPartStrikethrough :: RenderPart

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

-- | The <a>GravityHint</a> defines how horizontal scripts should behave in
--   a vertical context. That is, English excerpt in a vertical paragraph
--   for example.
--   
--   See <a>Gravity</a>.
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

-- | The <a>Gravity</a> type represents the orientation of glyphs in a
--   segment of text. This is useful when rendering vertical text layouts.
--   In those situations, the layout is rotated using a non-identity
--   PangoMatrix, and then glyph orientation is controlled using
--   <a>Gravity</a>. Not every value in this enumeration makes sense for
--   every usage of <a>Gravity</a>; for example, <a>GravityAuto</a> only
--   can be passed to <a>contextSetBaseGravity</a> and can only be returned
--   by <a>contextGetBaseGravity</a>.
--   
--   See also: <a>GravityHint</a>
data Gravity

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

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

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

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

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

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

-- | The <a>EllipsizeMode</a> type describes what sort of (if any)
--   ellipsization should be applied to a line of text. In the
--   ellipsization process characters are removed from the text in order to
--   make it fit to a given width and replaced with an ellipsis.
data EllipsizeMode

-- | No ellipsization
EllipsizeModeNone :: EllipsizeMode

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

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

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

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

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

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

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

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

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

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

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

-- | No direction specified
DirectionNeutral :: Direction

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

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

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

-- | The character is represented in a way that may be comprehensible but
--   is not the correct graphical form. For instance, a Hangul character
--   represented as a a sequence of Jamos, or a Latin transliteration of a
--   Cyrillic word.
CoverageLevelFallback :: CoverageLevel

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

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

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

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

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

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

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

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

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

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

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

-- | Pop Directional Format
BidiTypePdf :: BidiType

-- | European Number
BidiTypeEn :: BidiType

-- | European Number Separator
BidiTypeEs :: BidiType

-- | European Number Terminator
BidiTypeEt :: BidiType

-- | Arabic Number
BidiTypeAn :: BidiType

-- | Common Number Separator
BidiTypeCs :: BidiType

-- | Nonspacing Mark
BidiTypeNsm :: BidiType

-- | Boundary Neutral
BidiTypeBn :: BidiType

-- | Paragraph Separator
BidiTypeB :: BidiType

-- | Segment Separator
BidiTypeS :: BidiType

-- | Whitespace
BidiTypeWs :: BidiType

-- | Other Neutrals
BidiTypeOn :: BidiType

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

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

-- | does not happen
AttrTypeInvalid :: AttrType

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


module GI.Pango.Functions

-- | Create a new background alpha attribute.
attrBackgroundAlphaNew :: (HasCallStack, MonadIO m) => Word16 -> m Attribute

-- | Create a new background color attribute.
attrBackgroundNew :: (HasCallStack, MonadIO m) => Word16 -> Word16 -> Word16 -> m Attribute

-- | Create a new font fallback attribute.
--   
--   If fallback is disabled, characters will only be used from the closest
--   matching font on the system. No fallback will be done to other fonts
--   on the system that might contain the characters in the text.
attrFallbackNew :: (HasCallStack, MonadIO m) => Bool -> m Attribute

-- | Create a new font family attribute.
attrFamilyNew :: (HasCallStack, MonadIO m) => Text -> m Attribute

-- | Create a new foreground alpha attribute.
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.
attrGravityHintNew :: (HasCallStack, MonadIO m) => GravityHint -> m Attribute

-- | Create a new gravity attribute.
attrGravityNew :: (HasCallStack, MonadIO m) => Gravity -> m Attribute

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

-- | Create a new baseline displacement attribute.
attrRiseNew :: (HasCallStack, MonadIO m) => Int32 -> m Attribute

-- | Create a new font size scale attribute. The base font for the affected
--   text will have its size multiplied by <i><tt>scaleFactor</tt></i>.
attrScaleNew :: (HasCallStack, MonadIO m) => Double -> m Attribute

-- | Create a new font stretch attribute
attrStretchNew :: (HasCallStack, MonadIO m) => Stretch -> m Attribute

-- | Create a new strikethrough color attribute. This attribute modifies
--   the color of strikethrough lines. If not set, strikethrough lines will
--   use the foreground color.
attrStrikethroughColorNew :: (HasCallStack, MonadIO m) => Word16 -> Word16 -> Word16 -> m Attribute

-- | Create a new strike-through attribute.
attrStrikethroughNew :: (HasCallStack, MonadIO m) => Bool -> m Attribute

-- | Create a new font slant style attribute.
attrStyleNew :: (HasCallStack, MonadIO m) => Style -> m Attribute

-- | Create a new underline color attribute. This attribute modifies the
--   color of underlines. If not set, underlines will use the foreground
--   color.
attrUnderlineColorNew :: (HasCallStack, MonadIO m) => Word16 -> Word16 -> Word16 -> m Attribute

-- | Create a new underline-style attribute.
attrUnderlineNew :: (HasCallStack, MonadIO m) => Underline -> m Attribute

-- | Create a new font variant attribute (normal or small caps)
attrVariantNew :: (HasCallStack, MonadIO m) => Variant -> m Attribute

-- | Create a new font weight attribute.
attrWeightNew :: (HasCallStack, MonadIO m) => Weight -> m Attribute

-- | Determines possible line, word, and character breaks for a string of
--   Unicode text with a single analysis. For most purposes you may want to
--   use <a>getLogAttrs</a>.
break :: (HasCallStack, MonadIO m) => Text -> Int32 -> Analysis -> [LogAttr] -> m ()

-- | Do not use. Does not do anything.

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

-- | Do not use. Does not do anything.

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

-- | This is the default break algorithm, used if no language engine
--   overrides it. Normally you should use <a>break</a> instead. Unlike
--   <a>break</a>, <i><tt>analysis</tt></i> can be <a>Nothing</a>, but only
--   do that if you know what you're doing. If you need an analysis to pass
--   to <a>break</a>, you need to <a>itemize</a>. In most cases however you
--   should simply use <a>getLogAttrs</a>.
defaultBreak :: (HasCallStack, MonadIO m) => Text -> Int32 -> Maybe (Analysis) -> LogAttr -> Int32 -> m ()

-- | Converts extents from Pango units to device units, dividing by the
--   <a>SCALE</a> factor and performing rounding.
--   
--   The <i><tt>inclusive</tt></i> rectangle is converted by flooring the
--   x/y coordinates and extending width/height, such that the final
--   rectangle completely includes the original rectangle.
--   
--   The <i><tt>nearest</tt></i> rectangle is converted by rounding the
--   coordinates of the rectangle to the nearest device unit (pixel).
--   
--   The rule to which argument to use is: if you want the resulting
--   device-space rectangle to completely contain the original rectangle,
--   pass it in as <i><tt>inclusive</tt></i>. If you want two
--   touching-but-not-overlapping rectangles stay
--   touching-but-not-overlapping after rounding to device units, pass them
--   in as <i><tt>nearest</tt></i>.
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.
findBaseDir :: (HasCallStack, MonadIO m) => Text -> Int32 -> m Direction

-- | Locates a paragraph boundary in <i><tt>text</tt></i>. A boundary is
--   caused by delimiter characters, such as a newline, carriage return,
--   carriage return-newline pair, or Unicode paragraph separator
--   character. The index of the run of delimiters is returned in
--   <i><tt>paragraphDelimiterIndex</tt></i>. The index of the start of the
--   paragraph (index after all delimiters) is stored in
--   <i><tt>nextParagraphStart</tt></i>.
--   
--   If no delimiters are found, both
--   <i><tt>paragraphDelimiterIndex</tt></i> and
--   <i><tt>nextParagraphStart</tt></i> are filled with the length of
--   <i><tt>text</tt></i> (an index one off the end).
findParagraphBoundary :: (HasCallStack, MonadIO m) => Text -> Int32 -> m (Int32, Int32)

-- | Returns the name of the "pango" subdirectory of LIBDIR (which is set
--   at compile time).

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

-- | Computes a <a>LogAttr</a> for each character in <i><tt>text</tt></i>.
--   The <i><tt>logAttrs</tt></i> array must have one <a>LogAttr</a> for
--   each position in <i><tt>text</tt></i>; if <i><tt>text</tt></i>
--   contains N characters, it has N+1 positions, including the last
--   position at the end of the text. <i><tt>text</tt></i> should be an
--   entire paragraph; logical attributes can't be computed without context
--   (for example you need to see spaces on either side of a word to know
--   the word is a word).
getLogAttrs :: (HasCallStack, MonadIO m) => Text -> Int32 -> Int32 -> Language -> [LogAttr] -> m ()

-- | If <i><tt>ch</tt></i> has the Unicode mirrored property and there is
--   another Unicode character that typically has a glyph that is the
--   mirror image of <i><tt>ch</tt></i>'s glyph, puts that character in the
--   address pointed to by <i><tt>mirroredCh</tt></i>.
--   
--   Use <a>unicharGetMirrorChar</a> instead; the docs for that function
--   provide full details.
getMirrorChar :: (HasCallStack, MonadIO m) => Char -> Char -> m Bool

-- | Returns the name of the "pango" subdirectory of SYSCONFDIR (which is
--   set at compile time).

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

-- | Checks <i><tt>ch</tt></i> to see if it is a character that should not
--   be normally rendered on the screen. This includes all Unicode
--   characters with "ZERO WIDTH" in their name, as well as
--   &lt;firstterm&gt;bidi&lt;/firstterm&gt; formatting characters, and a
--   few other ones. This is totally different from
--   <a>unicharIszerowidth</a> and is at best misnamed.
isZeroWidth :: (HasCallStack, MonadIO m) => Char -> m Bool

-- | Breaks a piece of text into segments with consistent directional level
--   and shaping engine. Each byte of <i><tt>text</tt></i> will be
--   contained in exactly one of the items in the returned list; the
--   generated list of items will be in logical order (the start offsets of
--   the items are ascending).
--   
--   <i><tt>cachedIter</tt></i> should be an iterator over
--   <i><tt>attrs</tt></i> currently positioned at a range before or
--   containing <i><tt>startIndex</tt></i>; <i><tt>cachedIter</tt></i> will
--   be advanced to the range covering the position just after
--   <i><tt>startIndex</tt></i> + <i><tt>length</tt></i>. (i.e. if
--   itemizing in a loop, just keep passing in the same
--   <i><tt>cachedIter</tt></i>).
itemize :: (HasCallStack, MonadIO m, IsContext a) => a -> Text -> Int32 -> Int32 -> AttrList -> Maybe (AttrIterator) -> m [Item]

-- | Like <a>itemize</a>, but the base direction to use when computing
--   bidirectional levels (see pango_context_set_base_dir ()), is specified
--   explicitly rather than gotten from the <a>Context</a>.
itemizeWithBaseDir :: (HasCallStack, MonadIO m, IsContext a) => a -> Direction -> Text -> Int32 -> Int32 -> AttrList -> Maybe (AttrIterator) -> m [Item]

-- | This will return the bidirectional embedding levels of the input
--   paragraph as defined by the Unicode Bidirectional Algorithm available
--   at:
--   
--   http://www.unicode.org/reports/tr9/
--   
--   If the input base direction is a weak direction, the direction of the
--   characters in the text will determine the final resolved direction.
log2visGetEmbeddingLevels :: (HasCallStack, MonadIO m) => Text -> Int32 -> Direction -> m Word8

-- | Look up all user defined aliases for the alias
--   <i><tt>fontname</tt></i>. The resulting font family names will be
--   stored in <i><tt>families</tt></i>, and the number of families in
--   <i><tt>nFamilies</tt></i>.

-- | <i>Deprecated: (Since version 1.32)This function is not
--   thread-safe.</i>
lookupAliases :: (HasCallStack, MonadIO m) => Text -> m ([Text])

-- | After feeding a pango markup parser some data with
--   <a>markupParseContextParse</a>, use this function to get the list of
--   pango attributes and text out of the markup. This function will not
--   free <i><tt>context</tt></i>, use <a>markupParseContextFree</a> to do
--   so.
markupParserFinish :: (HasCallStack, MonadIO m) => MarkupParseContext -> m (AttrList, Text, Char)

-- | Parses marked-up text (see &lt;link
--   linkend="PangoMarkupFormat"&gt;markup format&lt;/link&gt;) to create a
--   plain-text string and an attribute list.
--   
--   If <i><tt>accelMarker</tt></i> is nonzero, the given character will
--   mark the character following it as an accelerator. For example,
--   <i><tt>accelMarker</tt></i> might be an ampersand or underscore. All
--   characters marked as an accelerator will receive a <a>UnderlineLow</a>
--   attribute, and the first character so marked will be returned in
--   <i><tt>accelChar</tt></i>, when calling <tt><i>finish()</i></tt>. Two
--   <i><tt>accelMarker</tt></i> characters following each other produce a
--   single literal <i><tt>accelMarker</tt></i> character.
--   
--   To feed markup to the parser, use <a>markupParseContextParse</a> on
--   the returned <a>MarkupParseContext</a>. When done with feeding markup
--   to the parser, use <a>markupParserFinish</a> to get the data out of
--   it, and then use <a>markupParseContextFree</a> to free it.
--   
--   This function is designed for applications that read pango markup from
--   streams. To simply parse a string containing pango markup, the simpler
--   <a>parseMarkup</a> API is recommended instead.
markupParserNew :: (HasCallStack, MonadIO m) => Char -> m MarkupParseContext

-- | Do not use. Does not do anything.

-- | <i>Deprecated: (Since version 1.38)</i>
moduleRegister :: (HasCallStack, MonadIO m) => IncludedModule -> m ()

-- | Parses an enum type and stores the result in <i><tt>value</tt></i>.
--   
--   If <i><tt>str</tt></i> does not match the nick name of any of the
--   possible values for the enum and is not an integer, <a>False</a> is
--   returned, a warning is issued if <i><tt>warn</tt></i> is <a>True</a>,
--   and a string representing the list of possible values is stored in
--   <i><tt>possibleValues</tt></i>. The list is slash-separated, eg.
--   "none/start/middle/end". If failed and <i><tt>possibleValues</tt></i>
--   is not <a>Nothing</a>, returned string should be freed using
--   <a>free</a>.

-- | <i>Deprecated: (Since version 1.38)</i>
parseEnum :: (HasCallStack, MonadIO m) => GType -> Maybe (Text) -> Bool -> m (Bool, Int32, Text)

-- | Parses marked-up text (see &lt;link
--   linkend="PangoMarkupFormat"&gt;markup format&lt;/link&gt;) to create a
--   plain-text string and an attribute list.
--   
--   If <i><tt>accelMarker</tt></i> is nonzero, the given character will
--   mark the character following it as an accelerator. For example,
--   <i><tt>accelMarker</tt></i> might be an ampersand or underscore. All
--   characters marked as an accelerator will receive a <a>UnderlineLow</a>
--   attribute, and the first character so marked will be returned in
--   <i><tt>accelChar</tt></i>. Two <i><tt>accelMarker</tt></i> characters
--   following each other produce a single literal
--   <i><tt>accelMarker</tt></i> character.
--   
--   To parse a stream of pango markup incrementally, use
--   <a>markupParserNew</a>.
--   
--   If any error happens, none of the output arguments are touched except
--   for <i><tt>error</tt></i>.
parseMarkup :: (HasCallStack, MonadIO m) => Text -> Int32 -> Char -> m (AttrList, Text, Char)

-- | Quantizes the thickness and position of a line, typically an underline
--   or strikethrough, to whole device pixels, that is integer multiples of
--   <a>SCALE</a>. The purpose of this function is to avoid such lines
--   looking blurry.
--   
--   Care is taken to make sure <i><tt>thickness</tt></i> is at least one
--   pixel when this function returns, but returned
--   <i><tt>position</tt></i> may become zero as a result of rounding.
quantizeLineGeometry :: (HasCallStack, MonadIO m) => Int32 -> Int32 -> m (Int32, Int32)

-- | Reads an entire line from a file into a buffer. Lines may be delimited
--   with '\n', '\r', '\n\r', or '\r\n'. The delimiter is not written into
--   the buffer. Text after a '#' character is treated as a comment and
--   skipped. '\' can be used to escape a # character. '\' proceeding a
--   line delimiter combines adjacent lines. A '\' proceeding any other
--   character is ignored and written into the output buffer unmodified.

-- | <i>Deprecated: (Since version 1.38)</i>
readLine :: (HasCallStack, MonadIO m) => Ptr () -> m (Int32, String)

-- | From a list of items in logical order and the associated directional
--   levels, produce a list in visual order. The original list is
--   unmodified.
reorderItems :: (HasCallStack, MonadIO m) => [Item] -> m [Item]

-- | Scans an integer. Leading white space is skipped.

-- | <i>Deprecated: (Since version 1.38)</i>
scanInt :: (HasCallStack, MonadIO m) => Text -> m (Bool, Text, Int32)

-- | Scans a string into a <a>String</a> buffer. The string may either be a
--   sequence of non-white-space characters, or a quoted string with '"'.
--   Instead a quoted string, '\"' represents a literal quote. Leading
--   white space outside of quotes is skipped.

-- | <i>Deprecated: (Since version 1.38)</i>
scanString :: (HasCallStack, MonadIO m) => Text -> m (Bool, Text, String)

-- | Scans a word into a <a>String</a> buffer. A word consists of [A-Za-z_]
--   followed by zero or more [A-Za-z_0-9] Leading white space is skipped.

-- | <i>Deprecated: (Since version 1.38)</i>
scanWord :: (HasCallStack, MonadIO m) => Text -> m (Bool, Text, String)

-- | Given a segment of text and the corresponding <a>Analysis</a>
--   structure returned from <a>itemize</a>, convert the characters into
--   glyphs. You may also pass in only a substring of the item from
--   <a>itemize</a>.
--   
--   It is recommended that you use <a>shapeFull</a> instead, since that
--   API allows for shaping interaction happening across text item
--   boundaries.
shape :: (HasCallStack, MonadIO m) => Text -> Int32 -> Analysis -> GlyphString -> m ()

-- | Given a segment of text and the corresponding <a>Analysis</a>
--   structure returned from <a>itemize</a>, convert the characters into
--   glyphs. You may also pass in only a substring of the item from
--   <a>itemize</a>.
--   
--   This is similar to <a>shape</a>, except it also can optionally take
--   the full paragraph text as input, which will then be used to perform
--   certain cross-item shaping interactions. If you have access to the
--   broader text of which <i><tt>itemText</tt></i> is part of, provide the
--   broader text as <i><tt>paragraphText</tt></i>. If
--   <i><tt>paragraphText</tt></i> is <a>Nothing</a>, item text is used
--   instead.
shapeFull :: (HasCallStack, MonadIO m) => Text -> Int32 -> Maybe (Text) -> Int32 -> Analysis -> GlyphString -> m ()

-- | Skips 0 or more characters of white space.

-- | <i>Deprecated: (Since version 1.38)</i>
skipSpace :: (HasCallStack, MonadIO m) => Text -> m (Bool, Text)

-- | Splits a <a>SEARCHPATH_SEPARATOR</a>-separated list of files,
--   stripping white space and substituting ~/ with $HOME/.

-- | <i>Deprecated: (Since version 1.38)</i>
splitFileList :: (HasCallStack, MonadIO m) => Text -> m [Text]

-- | Trims leading and trailing whitespace from a string.

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

-- | Determines the inherent direction of a character; either
--   <a>DirectionLtr</a>, <a>DirectionRtl</a>, or <a>DirectionNeutral</a>.
--   
--   This function is useful to categorize characters into left-to-right
--   letters, right-to-left letters, and everything else. If full Unicode
--   bidirectional type of a character is needed, <a>bidiTypeForUnichar</a>
--   can be used instead.
unicharDirection :: (HasCallStack, MonadIO m) => Char -> m Direction

-- | Converts a floating-point number to Pango units: multiplies it by
--   <a>SCALE</a> and rounds to nearest integer.
unitsFromDouble :: (HasCallStack, MonadIO m) => Double -> m Int32

-- | Converts a number in Pango units to floating-point: divides it by
--   <a>SCALE</a>.
unitsToDouble :: (HasCallStack, MonadIO m) => Int32 -> m Double

-- | This is similar to the macro <tt><i>PANGO_VERSION</i></tt> except that
--   it returns the encoded version of Pango available at run-time, as
--   opposed to the version available at compile-time.
--   
--   A version number can be encoded into an integer using
--   <tt><i>PANGO_VERSION_ENCODE()</i></tt>.
version :: (HasCallStack, MonadIO m) => m Int32

-- | Checks that the Pango library in use is compatible with the given
--   version. Generally you would pass in the constants
--   <tt><i>PANGO_VERSION_MAJOR</i></tt>,
--   <tt><i>PANGO_VERSION_MINOR</i></tt>,
--   <tt><i>PANGO_VERSION_MICRO</i></tt> as the three arguments to this
--   function; that produces a check that the library in use at run-time is
--   compatible with the version of Pango the application or module was
--   compiled against.
--   
--   Compatibility is defined by two things: first the version of the
--   running library is newer than the version
--   <i><tt>requiredMajor</tt></i>.required_minor.<i><tt>requiredMicro</tt></i>.
--   Second the running library must be binary compatible with the version
--   <i><tt>requiredMajor</tt></i>.required_minor.<i><tt>requiredMicro</tt></i>
--   (same major version.)
--   
--   For compile-time version checking use
--   <tt><i>PANGO_VERSION_CHECK()</i></tt>.
versionCheck :: (HasCallStack, MonadIO m) => Int32 -> Int32 -> Int32 -> m (Maybe Text)

-- | This is similar to the macro <tt><i>PANGO_VERSION_STRING</i></tt>
--   except that it returns the version of Pango available at run-time, as
--   opposed to the version available at compile-time.
versionString :: (HasCallStack, MonadIO m) => m Text


-- | The <a>Context</a> structure stores global information used to control
--   the itemization process.
module GI.Pango.Objects.Context
newtype Context
Context :: (ManagedPtr Context) -> Context
class GObject o => IsContext o
toContext :: IsContext o => o -> IO Context
noContext :: Maybe Context
data ContextChangedMethodInfo

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

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

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

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

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

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

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

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

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

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

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

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

-- | 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)
data ContextLoadFontsetMethodInfo

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

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

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

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

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

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

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

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

-- | 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.
contextSetMatrix :: (HasCallStack, MonadIO m, IsContext a) => a -> Maybe (Matrix) -> m ()
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Context.Context
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.Context.Context a) => GI.Pango.Objects.Context.IsContext a
instance GI.Pango.Objects.Context.IsContext GI.Pango.Objects.Context.Context
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.Context.Context
instance (info ~ GI.Pango.Objects.Context.ResolveContextMethod t GI.Pango.Objects.Context.Context, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Context.Context p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.Context.Context -> p)
instance (info ~ GI.Pango.Objects.Context.ResolveContextMethod t GI.Pango.Objects.Context.Context, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Context.Context p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.Context.Context -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.Context.Context
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextChangedMethodInfo a signature
instance (signature ~ m GI.Pango.Enums.Direction, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextGetBaseDirMethodInfo a signature
instance (signature ~ m GI.Pango.Enums.Gravity, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextGetBaseGravityMethodInfo a signature
instance (signature ~ m GI.Pango.Structs.FontDescription.FontDescription, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextGetFontDescriptionMethodInfo a signature
instance (signature ~ m GI.Pango.Objects.FontMap.FontMap, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextGetFontMapMethodInfo a signature
instance (signature ~ m GI.Pango.Enums.Gravity, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextGetGravityMethodInfo a signature
instance (signature ~ m GI.Pango.Enums.GravityHint, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextGetGravityHintMethodInfo a signature
instance (signature ~ m GI.Pango.Structs.Language.Language, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextGetLanguageMethodInfo a signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.Matrix.Matrix), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextGetMatrixMethodInfo a signature
instance (signature ~ (GHC.Base.Maybe GI.Pango.Structs.FontDescription.FontDescription -> GHC.Base.Maybe GI.Pango.Structs.Language.Language -> m GI.Pango.Structs.FontMetrics.FontMetrics), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextGetMetricsMethodInfo a signature
instance (signature ~ m GHC.Word.Word32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextGetSerialMethodInfo a signature
instance (signature ~ m [GI.Pango.Objects.FontFamily.FontFamily], Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextListFamiliesMethodInfo a signature
instance (signature ~ (GI.Pango.Structs.FontDescription.FontDescription -> m (GHC.Base.Maybe GI.Pango.Objects.Font.Font)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextLoadFontMethodInfo a signature
instance (signature ~ (GI.Pango.Structs.FontDescription.FontDescription -> GI.Pango.Structs.Language.Language -> m (GHC.Base.Maybe GI.Pango.Objects.Fontset.Fontset)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextLoadFontsetMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.Direction -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextSetBaseDirMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.Gravity -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextSetBaseGravityMethodInfo a signature
instance (signature ~ (GI.Pango.Structs.FontDescription.FontDescription -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextSetFontDescriptionMethodInfo a signature
instance (signature ~ (b -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a, GI.Pango.Objects.FontMap.IsFontMap b) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextSetFontMapMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.GravityHint -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextSetGravityHintMethodInfo a signature
instance (signature ~ (GI.Pango.Structs.Language.Language -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextSetLanguageMethodInfo a signature
instance (signature ~ (GHC.Base.Maybe GI.Pango.Structs.Matrix.Matrix -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Context.IsContext a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Context.ContextSetMatrixMethodInfo a signature


-- | The <a>Layout</a> structure represents an entire paragraph of text. It
--   is initialized with a <a>Context</a>, UTF-8 string and set of
--   attributes for that string. Once that is done, the set of formatted
--   lines can be extracted from the object, the layout can be rendered,
--   and conversion between logical character positions within the layout's
--   text, and the physical position of the resulting glyphs can be made.
--   
--   There are also a number of parameters to adjust the formatting of a
--   <a>Layout</a>, which are illustrated in &lt;xref
--   linkend="parameters"/&gt;. It is possible, as well, to ignore the 2-D
--   setup, and simply treat the results of a <a>Layout</a> as a list of
--   lines.
--   
--   &lt;figure id="parameters"&gt; &lt;title&gt;Adjustable parameters for
--   a PangoLayout&lt;/title&gt; &lt;graphic fileref="layout.gif"
--   format="GIF"&gt;&lt;/graphic&gt; &lt;/figure&gt;
--   
--   The <a>Layout</a> structure is opaque, and has no user-visible fields.
module GI.Pango.Objects.Layout
newtype Layout
Layout :: (ManagedPtr Layout) -> Layout
class GObject o => IsLayout o
toLayout :: IsLayout o => o -> IO Layout
noLayout :: Maybe Layout
data LayoutSetMarkupWithAccelMethodInfo
data LayoutContextChangedMethodInfo

-- | Forces recomputation of any state in the <a>Layout</a> that might
--   depend on the layout's context. This function should be called if you
--   make changes to the context subsequent to creating the layout.
layoutContextChanged :: (HasCallStack, MonadIO m, IsLayout a) => a -> m ()
data LayoutCopyMethodInfo

-- | Does a deep copy-by-value of the <i><tt>src</tt></i> layout. The
--   attribute list, tab array, and text from the original layout are all
--   copied by value.
layoutCopy :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Layout
data LayoutGetAlignmentMethodInfo

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

-- | Gets the attribute list for the layout, if any.
layoutGetAttributes :: (HasCallStack, MonadIO m, IsLayout a) => a -> m AttrList
data LayoutGetAutoDirMethodInfo

-- | Gets whether to calculate the bidirectional base direction for the
--   layout according to the contents of the layout. See
--   <a>layoutSetAutoDir</a>.
layoutGetAutoDir :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
data LayoutGetBaselineMethodInfo

-- | Gets the Y position of baseline of the first line in
--   <i><tt>layout</tt></i>.
layoutGetBaseline :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
data LayoutGetCharacterCountMethodInfo

-- | Returns the number of Unicode characters in the the text of
--   <i><tt>layout</tt></i>.
layoutGetCharacterCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
data LayoutGetContextMethodInfo

-- | Retrieves the <a>Context</a> used for this layout.
layoutGetContext :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Context
data LayoutGetCursorPosMethodInfo

-- | Given an index within a layout, determines the positions that of the
--   strong and weak cursors if the insertion point is at that index. The
--   position of each cursor is stored as a zero-width rectangle. The
--   strong cursor location is the location where characters of the
--   directionality equal to the base direction of the layout are inserted.
--   The weak cursor location is the location where characters of the
--   directionality opposite to the base direction of the layout are
--   inserted.
layoutGetCursorPos :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Rectangle, Rectangle)
data LayoutGetEllipsizeMethodInfo

-- | Gets the type of ellipsization being performed for
--   <i><tt>layout</tt></i>. See <a>layoutSetEllipsize</a>
layoutGetEllipsize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m EllipsizeMode
data LayoutGetExtentsMethodInfo

-- | 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)
data LayoutGetFontDescriptionMethodInfo

-- | Gets the font description for the layout, if any.
layoutGetFontDescription :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Maybe FontDescription)
data LayoutGetHeightMethodInfo

-- | Gets the height of layout used for ellipsization. See
--   <a>layoutSetHeight</a> for details.
layoutGetHeight :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
data LayoutGetIndentMethodInfo

-- | Gets the paragraph indent width in Pango units. A negative value
--   indicates a hanging indentation.
layoutGetIndent :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
data LayoutGetIterMethodInfo

-- | Returns an iterator to iterate over the visual extents of the layout.
layoutGetIter :: (HasCallStack, MonadIO m, IsLayout a) => a -> m LayoutIter
data LayoutGetJustifyMethodInfo

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

-- | Retrieves a particular line from a <a>Layout</a>.
--   
--   Use the faster <a>layoutGetLineReadonly</a> if you do not plan to
--   modify the contents of the line (glyphs, glyph widths, etc.).
layoutGetLine :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Maybe LayoutLine)
data LayoutGetLineCountMethodInfo

-- | Retrieves the count of lines for the <i><tt>layout</tt></i>.
layoutGetLineCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
data LayoutGetLineReadonlyMethodInfo

-- | Retrieves a particular line from a <a>Layout</a>.
--   
--   This is a faster alternative to <a>layoutGetLine</a>, but the user is
--   not expected to modify the contents of the line (glyphs, glyph widths,
--   etc.).
layoutGetLineReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Maybe LayoutLine)
data LayoutGetLinesMethodInfo

-- | 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]
data LayoutGetLinesReadonlyMethodInfo

-- | 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.).
layoutGetLinesReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LayoutLine]
data LayoutGetLogAttrsMethodInfo

-- | 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])
data LayoutGetLogAttrsReadonlyMethodInfo

-- | 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.
layoutGetLogAttrsReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LogAttr]
data LayoutGetPixelExtentsMethodInfo

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

-- | Determines the logical width and height of a <a>Layout</a> in device
--   units. (<a>layoutGetSize</a> returns the width and height scaled by
--   <a>SCALE</a>.) This is simply a convenience function around
--   <a>layoutGetPixelExtents</a>.
layoutGetPixelSize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Int32, Int32)
data LayoutGetSerialMethodInfo

-- | Returns the current serial number of <i><tt>layout</tt></i>. The
--   serial number is initialized to an small number larger than zero when
--   a new layout is created and is increased whenever the layout is
--   changed using any of the setter functions, or the <a>Context</a> it
--   uses has changed. The serial may wrap, but will never have the value
--   0. Since it can wrap, never compare it with "less than", always use
--   "not equals".
--   
--   This can be used to automatically detect changes to a <a>Layout</a>,
--   and is useful for example to decide whether a layout needs redrawing.
--   To force the serial to be increased, use <a>layoutContextChanged</a>.
layoutGetSerial :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Word32
data LayoutGetSingleParagraphModeMethodInfo

-- | Obtains the value set by <a>layoutSetSingleParagraphMode</a>.
layoutGetSingleParagraphMode :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
data LayoutGetSizeMethodInfo

-- | Determines the logical width and height of a <a>Layout</a> in Pango
--   units (device units scaled by <a>SCALE</a>). This is simply a
--   convenience function around <a>layoutGetExtents</a>.
layoutGetSize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Int32, Int32)
data LayoutGetSpacingMethodInfo

-- | Gets the amount of spacing between the lines of the layout.
layoutGetSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
data LayoutGetTabsMethodInfo

-- | Gets the current <a>TabArray</a> used by this layout. If no
--   <a>TabArray</a> has been set, then the default tabs are in use and
--   <a>Nothing</a> is returned. Default tabs are every 8 spaces. The
--   return value should be freed with <a>tabArrayFree</a>.
layoutGetTabs :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Maybe TabArray)
data LayoutGetTextMethodInfo

-- | Gets the text in the layout. The returned text should not be freed or
--   modified.
layoutGetText :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Text
data LayoutGetUnknownGlyphsCountMethodInfo

-- | Counts the number unknown glyphs in <i><tt>layout</tt></i>. That is,
--   zero if glyphs for all characters in the layout text were found, or
--   more than zero otherwise.
--   
--   This function can be used to determine if there are any fonts
--   available to render all characters in a certain string, or when used
--   in combination with <a>AttrTypeFallback</a>, to check if a certain
--   font supports all the characters in the string.
layoutGetUnknownGlyphsCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
data LayoutGetWidthMethodInfo

-- | Gets the width to which the lines of the <a>Layout</a> should wrap.
layoutGetWidth :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
data LayoutGetWrapMethodInfo

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

-- | Converts from byte <i><tt>index_</tt></i> within the
--   <i><tt>layout</tt></i> to line and X position. (X position is measured
--   from the left edge of the line)
layoutIndexToLineX :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> Bool -> m (Int32, Int32)
data LayoutIndexToPosMethodInfo

-- | Converts from an index within a <a>Layout</a> to the onscreen position
--   corresponding to the grapheme at that index, which is represented as
--   rectangle. Note that &lt;literal&gt;pos-&gt;x&lt;/literal&gt; is
--   always the leading edge of the grapheme and &lt;literal&gt;pos-&gt;x +
--   pos-&gt;width&lt;/literal&gt; the trailing edge of the grapheme. If
--   the directionality of the grapheme is right-to-left, then
--   &lt;literal&gt;pos-&gt;width&lt;/literal&gt; will be negative.
layoutIndexToPos :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Rectangle)
data LayoutIsEllipsizedMethodInfo

-- | 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.
layoutIsEllipsized :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
data LayoutIsWrappedMethodInfo

-- | 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.
layoutIsWrapped :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
data LayoutMoveCursorVisuallyMethodInfo

-- | Computes a new cursor position from an old position and a count of
--   positions to move visually. If <i><tt>direction</tt></i> is positive,
--   then the new strong cursor position will be one position to the right
--   of the old cursor position. If <i><tt>direction</tt></i> is negative,
--   then the new strong cursor position will be one position to the left
--   of the old cursor position.
--   
--   In the presence of bidirectional text, the correspondence between
--   logical and visual order will depend on the direction of the current
--   run, and there may be jumps when the cursor is moved off of the end of
--   a run.
--   
--   Motion here is in cursor positions, not in characters, so a single
--   call to <a>layoutMoveCursorVisually</a> may move the cursor over
--   multiple characters when multiple characters combine to form a single
--   grapheme.
layoutMoveCursorVisually :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> Int32 -> Int32 -> Int32 -> m (Int32, Int32)

-- | Create a new <a>Layout</a> object with attributes initialized to
--   default values for a particular <a>Context</a>.
layoutNew :: (HasCallStack, MonadIO m, IsContext a) => a -> m Layout
data LayoutSetAlignmentMethodInfo

-- | Sets the alignment for the layout: how partial lines are positioned
--   within the horizontal space available.
layoutSetAlignment :: (HasCallStack, MonadIO m, IsLayout a) => a -> Alignment -> m ()
data LayoutSetAttributesMethodInfo

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

-- | Sets whether to calculate the bidirectional base direction for the
--   layout according to the contents of the layout; when this flag is on
--   (the default), then paragraphs in <i><tt>layout</tt></i> that begin
--   with strong right-to-left characters (Arabic and Hebrew principally),
--   will have right-to-left layout, paragraphs with letters from other
--   scripts will have left-to-right layout. Paragraphs with only neutral
--   characters get their direction from the surrounding paragraphs.
--   
--   When <a>False</a>, the choice between left-to-right and right-to-left
--   layout is done according to the base direction of the layout's
--   <a>Context</a>. (See <a>contextSetBaseDir</a>).
--   
--   When the auto-computed direction of a paragraph differs from the base
--   direction of the context, the interpretation of <a>AlignmentLeft</a>
--   and <a>AlignmentRight</a> are swapped.
layoutSetAutoDir :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()
data LayoutSetEllipsizeMethodInfo

-- | Sets the type of ellipsization being performed for
--   <i><tt>layout</tt></i>. Depending on the ellipsization mode
--   <i><tt>ellipsize</tt></i> text is removed from the start, middle, or
--   end of text so they fit within the width and height of layout set with
--   <a>layoutSetWidth</a> and <a>layoutSetHeight</a>.
--   
--   If the layout contains characters such as newlines that force it to be
--   layed out in multiple paragraphs, then whether each paragraph is
--   ellipsized separately or the entire layout is ellipsized as a whole
--   depends on the set height of the layout. See <a>layoutSetHeight</a>
--   for details.
layoutSetEllipsize :: (HasCallStack, MonadIO m, IsLayout a) => a -> EllipsizeMode -> m ()
data LayoutSetFontDescriptionMethodInfo

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

-- | Sets the height to which the <a>Layout</a> should be ellipsized at.
--   There are two different behaviors, based on whether
--   <i><tt>height</tt></i> is positive or negative.
--   
--   If <i><tt>height</tt></i> is positive, it will be the maximum height
--   of the layout. Only lines would be shown that would fit, and if there
--   is any text omitted, an ellipsis added. At least one line is included
--   in each paragraph regardless of how small the height value is. A value
--   of zero will render exactly one line for the entire layout.
--   
--   If <i><tt>height</tt></i> is negative, it will be the (negative of)
--   maximum number of lines per paragraph. That is, the total number of
--   lines shown may well be more than this value if the layout contains
--   multiple paragraphs of text. The default value of -1 means that first
--   line of each paragraph is ellipsized. This behvaior may be changed in
--   the future to act per layout instead of per paragraph. File a bug
--   against pango at &lt;ulink
--   url="http://bugzilla.gnome.org/"&gt;http://bugzilla.gnome.org/&lt;/ulink&gt;
--   if your code relies on this behavior.
--   
--   Height setting only has effect if a positive width is set on
--   <i><tt>layout</tt></i> and ellipsization mode of
--   <i><tt>layout</tt></i> is not <a>EllipsizeModeNone</a>. The behavior
--   is undefined if a height other than -1 is set and ellipsization mode
--   is set to <a>EllipsizeModeNone</a>, and may change in the future.
layoutSetHeight :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
data LayoutSetIndentMethodInfo

-- | Sets the width in Pango units to indent each paragraph. A negative
--   value of <i><tt>indent</tt></i> will produce a hanging indentation.
--   That is, the first line will have the full width, and subsequent lines
--   will be indented by the absolute value of <i><tt>indent</tt></i>.
--   
--   The indent setting is ignored if layout alignment is set to
--   <a>AlignmentCenter</a>.
layoutSetIndent :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
data LayoutSetJustifyMethodInfo

-- | Sets whether each complete line should be stretched to fill the entire
--   width of the layout. This stretching is typically done by adding
--   whitespace, but for some scripts (such as Arabic), the justification
--   may be done in more complex ways, like extending the characters.
--   
--   Note that this setting is not implemented and so is ignored in Pango
--   older than 1.18.
layoutSetJustify :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()
data LayoutSetMarkupMethodInfo

-- | Same as <a>layoutSetMarkupWithAccel</a>, but the markup text isn't
--   scanned for accelerators.
layoutSetMarkup :: (HasCallStack, MonadIO m, IsLayout a) => a -> Text -> Int32 -> m ()
data LayoutSetSingleParagraphModeMethodInfo

-- | If <i><tt>setting</tt></i> is <a>True</a>, do not treat newlines and
--   similar characters as paragraph separators; instead, keep all text in
--   a single paragraph, and display a glyph for paragraph separator
--   characters. Used when you want to allow editing of newlines on a
--   single text line.
layoutSetSingleParagraphMode :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()
data LayoutSetSpacingMethodInfo

-- | Sets the amount of spacing in Pango unit between the lines of the
--   layout.
layoutSetSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
data LayoutSetTabsMethodInfo

-- | Sets the tabs to use for <i><tt>layout</tt></i>, overriding the
--   default tabs (by default, tabs are every 8 spaces). If
--   <i><tt>tabs</tt></i> is <a>Nothing</a>, the default tabs are
--   reinstated. <i><tt>tabs</tt></i> is copied into the layout; you must
--   free your copy of <i><tt>tabs</tt></i> yourself.
layoutSetTabs :: (HasCallStack, MonadIO m, IsLayout a) => a -> Maybe (TabArray) -> m ()
data LayoutSetTextMethodInfo

-- | Sets the text of the layout.
--   
--   Note that if you have used <a>layoutSetMarkup</a> or
--   <a>layoutSetMarkupWithAccel</a> on <i><tt>layout</tt></i> before, you
--   may want to call <a>layoutSetAttributes</a> to clear the attributes
--   set on the layout from the markup as this function does not clear
--   attributes.
layoutSetText :: (HasCallStack, MonadIO m, IsLayout a) => a -> Text -> Int32 -> m ()
data LayoutSetWidthMethodInfo

-- | Sets the width to which the lines of the <a>Layout</a> should wrap or
--   ellipsized. The default value is -1: no width set.
layoutSetWidth :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
data LayoutSetWrapMethodInfo

-- | Sets the wrap mode; the wrap mode only has effect if a width is set on
--   the layout with <a>layoutSetWidth</a>. To turn off wrapping, set the
--   width to -1.
layoutSetWrap :: (HasCallStack, MonadIO m, IsLayout a) => a -> WrapMode -> m ()
data LayoutXyToIndexMethodInfo

-- | Converts from X and Y position within a layout to the byte index to
--   the character at that logical position. If the Y position is not
--   inside the layout, the closest position is chosen (the position will
--   be clamped inside the layout). If the X position is not within the
--   layout, then the start or the end of the line is chosen as described
--   for <a>layoutLineXToIndex</a>. If either the X or Y positions were not
--   inside the layout, then the function returns <a>False</a>; on an exact
--   hit, it returns <a>True</a>.
layoutXyToIndex :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> Int32 -> m (Bool, Int32, Int32)
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Layout.Layout
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.Layout.Layout a) => GI.Pango.Objects.Layout.IsLayout a
instance GI.Pango.Objects.Layout.IsLayout GI.Pango.Objects.Layout.Layout
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.Layout.Layout
instance (info ~ GI.Pango.Objects.Layout.ResolveLayoutMethod t GI.Pango.Objects.Layout.Layout, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Layout.Layout p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.Layout.Layout -> p)
instance (info ~ GI.Pango.Objects.Layout.ResolveLayoutMethod t GI.Pango.Objects.Layout.Layout, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Layout.Layout p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.Layout.Layout -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.Layout.Layout
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutContextChangedMethodInfo a signature
instance (signature ~ m GI.Pango.Objects.Layout.Layout, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutCopyMethodInfo a signature
instance (signature ~ m GI.Pango.Enums.Alignment, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetAlignmentMethodInfo a signature
instance (signature ~ m GI.Pango.Structs.AttrList.AttrList, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetAttributesMethodInfo a signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetAutoDirMethodInfo a signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetBaselineMethodInfo a signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetCharacterCountMethodInfo a signature
instance (signature ~ m GI.Pango.Objects.Context.Context, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetContextMethodInfo a signature
instance (signature ~ (GHC.Int.Int32 -> m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetCursorPosMethodInfo a signature
instance (signature ~ m GI.Pango.Enums.EllipsizeMode, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetEllipsizeMethodInfo a signature
instance (signature ~ m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetExtentsMethodInfo a signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.FontDescription.FontDescription), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetFontDescriptionMethodInfo a signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetHeightMethodInfo a signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetIndentMethodInfo a signature
instance (signature ~ m GI.Pango.Structs.LayoutIter.LayoutIter, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetIterMethodInfo a signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetJustifyMethodInfo a signature
instance (signature ~ (GHC.Int.Int32 -> m (GHC.Base.Maybe GI.Pango.Structs.LayoutLine.LayoutLine)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetLineMethodInfo a signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetLineCountMethodInfo a signature
instance (signature ~ (GHC.Int.Int32 -> m (GHC.Base.Maybe GI.Pango.Structs.LayoutLine.LayoutLine)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetLineReadonlyMethodInfo a signature
instance (signature ~ m [GI.Pango.Structs.LayoutLine.LayoutLine], Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetLinesMethodInfo a signature
instance (signature ~ m [GI.Pango.Structs.LayoutLine.LayoutLine], Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetLinesReadonlyMethodInfo a signature
instance (signature ~ m [GI.Pango.Structs.LogAttr.LogAttr], Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetLogAttrsMethodInfo a signature
instance (signature ~ m [GI.Pango.Structs.LogAttr.LogAttr], Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetLogAttrsReadonlyMethodInfo a signature
instance (signature ~ m (GI.Pango.Structs.Rectangle.Rectangle, GI.Pango.Structs.Rectangle.Rectangle), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetPixelExtentsMethodInfo a signature
instance (signature ~ m (GHC.Int.Int32, GHC.Int.Int32), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetPixelSizeMethodInfo a signature
instance (signature ~ m GHC.Word.Word32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetSerialMethodInfo a signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetSingleParagraphModeMethodInfo a signature
instance (signature ~ m (GHC.Int.Int32, GHC.Int.Int32), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetSizeMethodInfo a signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetSpacingMethodInfo a signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.TabArray.TabArray), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetTabsMethodInfo a signature
instance (signature ~ m Data.Text.Internal.Text, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetTextMethodInfo a signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetUnknownGlyphsCountMethodInfo a signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetWidthMethodInfo a signature
instance (signature ~ m GI.Pango.Enums.WrapMode, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutGetWrapMethodInfo a signature
instance (signature ~ (GHC.Int.Int32 -> GHC.Types.Bool -> m (GHC.Int.Int32, GHC.Int.Int32)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutIndexToLineXMethodInfo a signature
instance (signature ~ (GHC.Int.Int32 -> m GI.Pango.Structs.Rectangle.Rectangle), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutIndexToPosMethodInfo a signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutIsEllipsizedMethodInfo a signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutIsWrappedMethodInfo a signature
instance (signature ~ (GHC.Types.Bool -> GHC.Int.Int32 -> GHC.Int.Int32 -> GHC.Int.Int32 -> m (GHC.Int.Int32, GHC.Int.Int32)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutMoveCursorVisuallyMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.Alignment -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetAlignmentMethodInfo a signature
instance (signature ~ (GHC.Base.Maybe GI.Pango.Structs.AttrList.AttrList -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetAttributesMethodInfo a signature
instance (signature ~ (GHC.Types.Bool -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetAutoDirMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.EllipsizeMode -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetEllipsizeMethodInfo a signature
instance (signature ~ (GHC.Base.Maybe GI.Pango.Structs.FontDescription.FontDescription -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetFontDescriptionMethodInfo a signature
instance (signature ~ (GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetHeightMethodInfo a signature
instance (signature ~ (GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetIndentMethodInfo a signature
instance (signature ~ (GHC.Types.Bool -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetJustifyMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetMarkupMethodInfo a signature
instance (p ~ (), o ~ Data.GI.Base.Overloading.MethodResolutionFailed "setMarkupWithAccel" GI.Pango.Objects.Layout.Layout) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetMarkupWithAccelMethodInfo o p
instance (signature ~ (GHC.Types.Bool -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetSingleParagraphModeMethodInfo a signature
instance (signature ~ (GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetSpacingMethodInfo a signature
instance (signature ~ (GHC.Base.Maybe GI.Pango.Structs.TabArray.TabArray -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetTabsMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetTextMethodInfo a signature
instance (signature ~ (GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetWidthMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.WrapMode -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutSetWrapMethodInfo a signature
instance (signature ~ (GHC.Int.Int32 -> GHC.Int.Int32 -> m (GHC.Types.Bool, GHC.Int.Int32, GHC.Int.Int32)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Layout.IsLayout a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Layout.LayoutXyToIndexMethodInfo a signature


-- | <a>Renderer</a> is a base class for objects that are used to render
--   Pango objects such as <a>GlyphString</a> and <a>Layout</a>.
module GI.Pango.Objects.Renderer
newtype Renderer
Renderer :: (ManagedPtr Renderer) -> Renderer
class GObject o => IsRenderer o
toRenderer :: IsRenderer o => o -> IO Renderer
noRenderer :: Maybe Renderer
data RendererActivateMethodInfo

-- | 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.
rendererActivate :: (HasCallStack, MonadIO m, IsRenderer a) => a -> m ()
data RendererDeactivateMethodInfo

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

-- | 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.
rendererDrawErrorUnderline :: (HasCallStack, MonadIO m, IsRenderer a) => a -> Int32 -> Int32 -> Int32 -> Int32 -> m ()
data RendererDrawGlyphMethodInfo

-- | Draws a single glyph with coordinates in device space.
rendererDrawGlyph :: (HasCallStack, MonadIO m, IsRenderer a, IsFont b) => a -> b -> Word32 -> Double -> Double -> m ()
data RendererDrawGlyphItemMethodInfo

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

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

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

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

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

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

-- | Gets the current alpha for the specified part.
rendererGetAlpha :: (HasCallStack, MonadIO m, IsRenderer a) => a -> RenderPart -> m Word16
data RendererGetColorMethodInfo

-- | Gets the current rendering color for the specified part.
rendererGetColor :: (HasCallStack, MonadIO m, IsRenderer a) => a -> RenderPart -> m (Maybe Color)
data RendererGetLayoutMethodInfo

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

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

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

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

-- | 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.
rendererSetAlpha :: (HasCallStack, MonadIO m, IsRenderer a) => a -> RenderPart -> Word16 -> m ()
data RendererSetColorMethodInfo

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

-- | Sets the transformation matrix that will be applied when rendering.
rendererSetMatrix :: (HasCallStack, MonadIO m, IsRenderer a) => a -> Maybe (Matrix) -> m ()
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Renderer.Renderer
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.Renderer.Renderer a) => GI.Pango.Objects.Renderer.IsRenderer a
instance GI.Pango.Objects.Renderer.IsRenderer GI.Pango.Objects.Renderer.Renderer
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.Renderer.Renderer
instance (info ~ GI.Pango.Objects.Renderer.ResolveRendererMethod t GI.Pango.Objects.Renderer.Renderer, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Renderer.Renderer p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.Renderer.Renderer -> p)
instance (info ~ GI.Pango.Objects.Renderer.ResolveRendererMethod t GI.Pango.Objects.Renderer.Renderer, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Renderer.Renderer p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.Renderer.Renderer -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.Renderer.Renderer
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererActivateMethodInfo a signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererDeactivateMethodInfo a signature
instance (signature ~ (GHC.Int.Int32 -> GHC.Int.Int32 -> GHC.Int.Int32 -> GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererDrawErrorUnderlineMethodInfo a signature
instance (signature ~ (b -> GHC.Word.Word32 -> GHC.Types.Double -> GHC.Types.Double -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a, GI.Pango.Objects.Font.IsFont b) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererDrawGlyphMethodInfo a signature
instance (signature ~ (GHC.Base.Maybe Data.Text.Internal.Text -> GI.Pango.Structs.GlyphItem.GlyphItem -> GHC.Int.Int32 -> GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererDrawGlyphItemMethodInfo a signature
instance (signature ~ (b -> GI.Pango.Structs.GlyphString.GlyphString -> GHC.Int.Int32 -> GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a, GI.Pango.Objects.Font.IsFont b) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererDrawGlyphsMethodInfo a signature
instance (signature ~ (b -> GHC.Int.Int32 -> GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a, GI.Pango.Objects.Layout.IsLayout b) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererDrawLayoutMethodInfo a signature
instance (signature ~ (GI.Pango.Structs.LayoutLine.LayoutLine -> GHC.Int.Int32 -> GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererDrawLayoutLineMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.RenderPart -> GHC.Int.Int32 -> GHC.Int.Int32 -> GHC.Int.Int32 -> GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererDrawRectangleMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.RenderPart -> GHC.Types.Double -> GHC.Types.Double -> GHC.Types.Double -> GHC.Types.Double -> GHC.Types.Double -> GHC.Types.Double -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererDrawTrapezoidMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.RenderPart -> m GHC.Word.Word16), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererGetAlphaMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.RenderPart -> m (GHC.Base.Maybe GI.Pango.Structs.Color.Color)), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererGetColorMethodInfo a signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Objects.Layout.Layout), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererGetLayoutMethodInfo a signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.LayoutLine.LayoutLine), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererGetLayoutLineMethodInfo a signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.Matrix.Matrix), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererGetMatrixMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.RenderPart -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererPartChangedMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.RenderPart -> GHC.Word.Word16 -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererSetAlphaMethodInfo a signature
instance (signature ~ (GI.Pango.Enums.RenderPart -> GHC.Base.Maybe GI.Pango.Structs.Color.Color -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererSetColorMethodInfo a signature
instance (signature ~ (GHC.Base.Maybe GI.Pango.Structs.Matrix.Matrix -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Renderer.IsRenderer a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Renderer.RendererSetMatrixMethodInfo a signature


-- | The <a>Coverage</a> structure represents a map from Unicode characters
--   to <a>CoverageLevel</a>. It is an opaque structure with no public
--   fields.
module GI.Pango.Structs.Coverage
newtype Coverage
Coverage :: (ManagedPtr Coverage) -> Coverage
noCoverage :: Maybe Coverage
data CoverageGetMethodInfo

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

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

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

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

-- | Decrease the reference count on the <a>Coverage</a> by one. If the
--   result is zero, free the coverage and all associated memory.
coverageUnref :: (HasCallStack, MonadIO m) => Coverage -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.Coverage.Coverage
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.Coverage.Coverage
instance (signature ~ (GHC.Int.Int32 -> m GI.Pango.Enums.CoverageLevel), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Coverage.CoverageGetMethodInfo GI.Pango.Structs.Coverage.Coverage signature
instance (signature ~ (GI.Pango.Structs.Coverage.Coverage -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Coverage.CoverageMaxMethodInfo GI.Pango.Structs.Coverage.Coverage signature
instance (signature ~ (GHC.Int.Int32 -> GI.Pango.Enums.CoverageLevel -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Coverage.CoverageSetMethodInfo GI.Pango.Structs.Coverage.Coverage signature
instance (signature ~ m Data.ByteString.Internal.ByteString, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Coverage.CoverageToBytesMethodInfo GI.Pango.Structs.Coverage.Coverage signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Coverage.CoverageUnrefMethodInfo GI.Pango.Structs.Coverage.Coverage signature
instance (info ~ GI.Pango.Structs.Coverage.ResolveCoverageMethod t GI.Pango.Structs.Coverage.Coverage, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Coverage.Coverage p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.Coverage.Coverage -> p)
instance (info ~ GI.Pango.Structs.Coverage.ResolveCoverageMethod t GI.Pango.Structs.Coverage.Coverage, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Coverage.Coverage p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.Coverage.Coverage -> p)


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

-- | Construct a <a>EngineScriptInfo</a> struct initialized to zero.
newZeroEngineScriptInfo :: MonadIO m => m EngineScriptInfo
noEngineScriptInfo :: Maybe EngineScriptInfo
clearEngineScriptInfoLangs :: MonadIO m => EngineScriptInfo -> m ()
engineScriptInfo_langs :: AttrLabelProxy "langs"
getEngineScriptInfoLangs :: MonadIO m => EngineScriptInfo -> m (Maybe Text)
setEngineScriptInfoLangs :: MonadIO m => EngineScriptInfo -> CString -> m ()
engineScriptInfo_script :: AttrLabelProxy "script"
getEngineScriptInfoScript :: MonadIO m => EngineScriptInfo -> m Script
setEngineScriptInfoScript :: MonadIO m => EngineScriptInfo -> Script -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.EngineScriptInfo.EngineScriptInfo
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.EngineScriptInfo.EngineScriptInfo tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.EngineScriptInfo.EngineScriptInfoScriptFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.EngineScriptInfo.EngineScriptInfoLangsFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.EngineScriptInfo.EngineScriptInfo
instance (info ~ GI.Pango.Structs.EngineScriptInfo.ResolveEngineScriptInfoMethod t GI.Pango.Structs.EngineScriptInfo.EngineScriptInfo, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.EngineScriptInfo.EngineScriptInfo p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.EngineScriptInfo.EngineScriptInfo -> p)
instance (info ~ GI.Pango.Structs.EngineScriptInfo.ResolveEngineScriptInfoMethod t GI.Pango.Structs.EngineScriptInfo.EngineScriptInfo, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.EngineScriptInfo.EngineScriptInfo p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.EngineScriptInfo.EngineScriptInfo -> p)


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | 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.
fontDescriptionSetAbsoluteSize :: (HasCallStack, MonadIO m) => FontDescription -> Double -> m ()
data FontDescriptionSetFamilyMethodInfo

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

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

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

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

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

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

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

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

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

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

-- | Unsets some of the fields in a <a>FontDescription</a>. The unset
--   fields will get back to their default values.
fontDescriptionUnsetFields :: (HasCallStack, MonadIO m) => FontDescription -> [FontMask] -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.FontDescription.FontDescription
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.FontDescription.FontDescription
instance (signature ~ (GHC.Base.Maybe GI.Pango.Structs.FontDescription.FontDescription -> GI.Pango.Structs.FontDescription.FontDescription -> m GHC.Types.Bool), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionBetterMatchMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.FontDescription.FontDescription), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionCopyMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.FontDescription.FontDescription), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionCopyStaticMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (GI.Pango.Structs.FontDescription.FontDescription -> m GHC.Types.Bool), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionEqualMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionFreeMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m (GHC.Base.Maybe Data.Text.Internal.Text), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionGetFamilyMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m GI.Pango.Enums.Gravity, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionGetGravityMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m [GI.Pango.Flags.FontMask], Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionGetSetFieldsMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionGetSizeMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionGetSizeIsAbsoluteMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m GI.Pango.Enums.Stretch, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionGetStretchMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m GI.Pango.Enums.Style, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionGetStyleMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m GI.Pango.Enums.Variant, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionGetVariantMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m GI.Pango.Enums.Weight, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionGetWeightMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m GHC.Word.Word32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionHashMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (GHC.Base.Maybe GI.Pango.Structs.FontDescription.FontDescription -> GHC.Types.Bool -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionMergeMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (GI.Pango.Structs.FontDescription.FontDescription -> GHC.Types.Bool -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionMergeStaticMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (GHC.Types.Double -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionSetAbsoluteSizeMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (Data.Text.Internal.Text -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionSetFamilyMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (Data.Text.Internal.Text -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionSetFamilyStaticMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (GI.Pango.Enums.Gravity -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionSetGravityMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionSetSizeMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (GI.Pango.Enums.Stretch -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionSetStretchMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (GI.Pango.Enums.Style -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionSetStyleMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (GI.Pango.Enums.Variant -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionSetVariantMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ (GI.Pango.Enums.Weight -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionSetWeightMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m Data.Text.Internal.Text, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionToFilenameMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ m Data.Text.Internal.Text, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionToStringMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (signature ~ ([GI.Pango.Flags.FontMask] -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.FontDescription.FontDescriptionUnsetFieldsMethodInfo GI.Pango.Structs.FontDescription.FontDescription signature
instance (info ~ GI.Pango.Structs.FontDescription.ResolveFontDescriptionMethod t GI.Pango.Structs.FontDescription.FontDescription, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.FontDescription.FontDescription p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.FontDescription.FontDescription -> p)
instance (info ~ GI.Pango.Structs.FontDescription.ResolveFontDescriptionMethod t GI.Pango.Structs.FontDescription.FontDescription, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.FontDescription.FontDescription p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.FontDescription.FontDescription -> p)


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

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

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

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

-- | 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.
languageIncludesScript :: (HasCallStack, MonadIO m) => Language -> Script -> m Bool
data LanguageMatchesMethodInfo

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

-- | Gets the RFC-3066 format string representing the given language tag.
languageToString :: (HasCallStack, MonadIO m) => Language -> m Text
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.Language.Language
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.Language.Language
instance (signature ~ m Data.Text.Internal.Text, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Language.LanguageGetSampleStringMethodInfo GI.Pango.Structs.Language.Language signature
instance (signature ~ (GI.Pango.Enums.Script -> m GHC.Types.Bool), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Language.LanguageIncludesScriptMethodInfo GI.Pango.Structs.Language.Language signature
instance (signature ~ (Data.Text.Internal.Text -> m GHC.Types.Bool), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Language.LanguageMatchesMethodInfo GI.Pango.Structs.Language.Language signature
instance (signature ~ m Data.Text.Internal.Text, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.Language.LanguageToStringMethodInfo GI.Pango.Structs.Language.Language signature
instance (info ~ GI.Pango.Structs.Language.ResolveLanguageMethod t GI.Pango.Structs.Language.Language, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Language.Language p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.Language.Language -> p)
instance (info ~ GI.Pango.Structs.Language.ResolveLanguageMethod t GI.Pango.Structs.Language.Language, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.Language.Language p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.Language.Language -> p)


-- | A <a>ScriptIter</a> is used to iterate through a string and identify
--   ranges in different scripts.
module GI.Pango.Structs.ScriptIter
newtype ScriptIter
ScriptIter :: (ManagedPtr ScriptIter) -> ScriptIter
noScriptIter :: Maybe ScriptIter
data ScriptIterFreeMethodInfo

-- | Frees a <a>ScriptIter</a> created with
--   <tt><i>pango_script_iter_new()</i></tt>.
scriptIterFree :: (HasCallStack, MonadIO m) => ScriptIter -> m ()
data ScriptIterGetRangeMethodInfo

-- | 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)
scriptIterGetRange :: (HasCallStack, MonadIO m) => ScriptIter -> m (Text, Text, Script)
data ScriptIterNextMethodInfo

-- | Advances a <a>ScriptIter</a> to the next range. If
--   <i><tt>iter</tt></i> is already at the end, it is left unchanged and
--   <a>False</a> is returned.
scriptIterNext :: (HasCallStack, MonadIO m) => ScriptIter -> m Bool
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.ScriptIter.ScriptIter
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.ScriptIter.ScriptIter
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.ScriptIter.ScriptIterFreeMethodInfo GI.Pango.Structs.ScriptIter.ScriptIter signature
instance (signature ~ m (Data.Text.Internal.Text, Data.Text.Internal.Text, GI.Pango.Enums.Script), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.ScriptIter.ScriptIterGetRangeMethodInfo GI.Pango.Structs.ScriptIter.ScriptIter signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.ScriptIter.ScriptIterNextMethodInfo GI.Pango.Structs.ScriptIter.ScriptIter signature
instance (info ~ GI.Pango.Structs.ScriptIter.ResolveScriptIterMethod t GI.Pango.Structs.ScriptIter.ScriptIter, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.ScriptIter.ScriptIter p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.ScriptIter.ScriptIter -> p)
instance (info ~ GI.Pango.Structs.ScriptIter.ResolveScriptIterMethod t GI.Pango.Structs.ScriptIter.ScriptIter, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.ScriptIter.ScriptIter p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.ScriptIter.ScriptIter -> p)


-- | A <a>TabArray</a> struct contains an array of tab stops. Each tab stop
--   has an alignment and a position.
module GI.Pango.Structs.TabArray
newtype TabArray
TabArray :: (ManagedPtr TabArray) -> TabArray
noTabArray :: Maybe TabArray
data TabArrayCopyMethodInfo

-- | Copies a <a>TabArray</a>
tabArrayCopy :: (HasCallStack, MonadIO m) => TabArray -> m TabArray
data TabArrayFreeMethodInfo

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

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

-- | Gets the number of tab stops in <i><tt>tabArray</tt></i>.
tabArrayGetSize :: (HasCallStack, MonadIO m) => TabArray -> m Int32
data TabArrayGetTabMethodInfo

-- | Gets the alignment and position of a tab stop.
tabArrayGetTab :: (HasCallStack, MonadIO m) => TabArray -> Int32 -> m (TabAlign, Int32)
data TabArrayGetTabsMethodInfo

-- | If non-<a>Nothing</a>, <i><tt>alignments</tt></i> and
--   <i><tt>locations</tt></i> are filled with allocated arrays of length
--   <a>tabArrayGetSize</a>. You must free the returned array.
tabArrayGetTabs :: (HasCallStack, MonadIO m) => TabArray -> m (TabAlign, Ptr 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
data TabArrayResizeMethodInfo

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

-- | Sets the alignment and location of a tab stop.
--   <i><tt>alignment</tt></i> must always be
--   <tt><i>PANGO_TAB_LEFT</i></tt> in the current implementation.
tabArraySetTab :: (HasCallStack, MonadIO m) => TabArray -> Int32 -> TabAlign -> Int32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.TabArray.TabArray
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.TabArray.TabArray
instance (signature ~ m GI.Pango.Structs.TabArray.TabArray, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.TabArray.TabArrayCopyMethodInfo GI.Pango.Structs.TabArray.TabArray signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.TabArray.TabArrayFreeMethodInfo GI.Pango.Structs.TabArray.TabArray signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.TabArray.TabArrayGetPositionsInPixelsMethodInfo GI.Pango.Structs.TabArray.TabArray signature
instance (signature ~ m GHC.Int.Int32, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.TabArray.TabArrayGetSizeMethodInfo GI.Pango.Structs.TabArray.TabArray signature
instance (signature ~ (GHC.Int.Int32 -> m (GI.Pango.Enums.TabAlign, GHC.Int.Int32)), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.TabArray.TabArrayGetTabMethodInfo GI.Pango.Structs.TabArray.TabArray signature
instance (signature ~ m (GI.Pango.Enums.TabAlign, GHC.Ptr.Ptr GHC.Int.Int32), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.TabArray.TabArrayGetTabsMethodInfo GI.Pango.Structs.TabArray.TabArray signature
instance (signature ~ (GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.TabArray.TabArrayResizeMethodInfo GI.Pango.Structs.TabArray.TabArray signature
instance (signature ~ (GHC.Int.Int32 -> GI.Pango.Enums.TabAlign -> GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.TabArray.TabArraySetTabMethodInfo GI.Pango.Structs.TabArray.TabArray signature
instance (info ~ GI.Pango.Structs.TabArray.ResolveTabArrayMethod t GI.Pango.Structs.TabArray.TabArray, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.TabArray.TabArray p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.TabArray.TabArray -> p)
instance (info ~ GI.Pango.Structs.TabArray.ResolveTabArrayMethod t GI.Pango.Structs.TabArray.TabArray, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.TabArray.TabArray p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.TabArray.TabArray -> p)


module GI.Pango.Constants

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | This flag is used to mark runs that hold ellipsized text, in an
--   ellipsized layout.

-- | Whether the segment should be shifted to center around the baseline.
--   Used in vertical writing directions mostly.


module GI.Pango.Callbacks
type AttrClassDestroyFieldCallback = Attribute -> IO ()
type C_AttrClassDestroyFieldCallback = Ptr Attribute -> IO ()
dynamic_AttrClassDestroyFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_AttrClassDestroyFieldCallback -> Attribute -> m ()
genClosure_AttrClassDestroyFieldCallback :: AttrClassDestroyFieldCallback -> IO Closure
mk_AttrClassDestroyFieldCallback :: C_AttrClassDestroyFieldCallback -> IO (FunPtr C_AttrClassDestroyFieldCallback)
noAttrClassDestroyFieldCallback :: Maybe AttrClassDestroyFieldCallback
wrap_AttrClassDestroyFieldCallback :: Maybe (Ptr (FunPtr C_AttrClassDestroyFieldCallback)) -> AttrClassDestroyFieldCallback -> Ptr Attribute -> IO ()
type AttrClassEqualFieldCallback = Attribute -> Attribute -> IO Bool
type C_AttrClassEqualFieldCallback = Ptr Attribute -> Ptr Attribute -> IO CInt
dynamic_AttrClassEqualFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_AttrClassEqualFieldCallback -> Attribute -> Attribute -> m Bool
genClosure_AttrClassEqualFieldCallback :: AttrClassEqualFieldCallback -> IO Closure
mk_AttrClassEqualFieldCallback :: C_AttrClassEqualFieldCallback -> IO (FunPtr C_AttrClassEqualFieldCallback)
noAttrClassEqualFieldCallback :: Maybe AttrClassEqualFieldCallback
wrap_AttrClassEqualFieldCallback :: Maybe (Ptr (FunPtr C_AttrClassEqualFieldCallback)) -> AttrClassEqualFieldCallback -> Ptr Attribute -> Ptr Attribute -> IO CInt
type AttrDataCopyFunc = IO (Ptr ())
type AttrDataCopyFunc_WithClosures = Ptr () -> IO (Ptr ())
type C_AttrDataCopyFunc = Ptr () -> IO (Ptr ())
drop_closures_AttrDataCopyFunc :: AttrDataCopyFunc -> AttrDataCopyFunc_WithClosures
dynamic_AttrDataCopyFunc :: (HasCallStack, MonadIO m) => FunPtr C_AttrDataCopyFunc -> Ptr () -> m (Ptr ())
genClosure_AttrDataCopyFunc :: AttrDataCopyFunc -> IO Closure
mk_AttrDataCopyFunc :: C_AttrDataCopyFunc -> IO (FunPtr C_AttrDataCopyFunc)
noAttrDataCopyFunc :: Maybe AttrDataCopyFunc
noAttrDataCopyFunc_WithClosures :: Maybe AttrDataCopyFunc_WithClosures
wrap_AttrDataCopyFunc :: Maybe (Ptr (FunPtr C_AttrDataCopyFunc)) -> AttrDataCopyFunc_WithClosures -> Ptr () -> IO (Ptr ())
type AttrFilterFunc = Attribute -> IO Bool
type AttrFilterFunc_WithClosures = Attribute -> Ptr () -> IO Bool
type C_AttrFilterFunc = Ptr Attribute -> Ptr () -> IO CInt
drop_closures_AttrFilterFunc :: AttrFilterFunc -> AttrFilterFunc_WithClosures
dynamic_AttrFilterFunc :: (HasCallStack, MonadIO m) => FunPtr C_AttrFilterFunc -> Attribute -> Ptr () -> m Bool
genClosure_AttrFilterFunc :: AttrFilterFunc -> IO Closure
mk_AttrFilterFunc :: C_AttrFilterFunc -> IO (FunPtr C_AttrFilterFunc)
noAttrFilterFunc :: Maybe AttrFilterFunc
noAttrFilterFunc_WithClosures :: Maybe AttrFilterFunc_WithClosures
wrap_AttrFilterFunc :: Maybe (Ptr (FunPtr C_AttrFilterFunc)) -> AttrFilterFunc_WithClosures -> Ptr Attribute -> Ptr () -> IO CInt
type C_FontsetForeachFunc = Ptr Fontset -> Ptr Font -> Ptr () -> IO CInt
type FontsetForeachFunc = Fontset -> Font -> IO Bool
type FontsetForeachFunc_WithClosures = Fontset -> Font -> Ptr () -> IO Bool
drop_closures_FontsetForeachFunc :: FontsetForeachFunc -> FontsetForeachFunc_WithClosures
dynamic_FontsetForeachFunc :: (HasCallStack, MonadIO m, IsFontset a, IsFont b) => FunPtr C_FontsetForeachFunc -> a -> b -> Ptr () -> m Bool
genClosure_FontsetForeachFunc :: FontsetForeachFunc -> IO Closure
mk_FontsetForeachFunc :: C_FontsetForeachFunc -> IO (FunPtr C_FontsetForeachFunc)
noFontsetForeachFunc :: Maybe FontsetForeachFunc
noFontsetForeachFunc_WithClosures :: Maybe FontsetForeachFunc_WithClosures
wrap_FontsetForeachFunc :: Maybe (Ptr (FunPtr C_FontsetForeachFunc)) -> FontsetForeachFunc_WithClosures -> Ptr Fontset -> Ptr Font -> Ptr () -> IO CInt
type C_IncludedModuleExitFieldCallback = IO ()
type IncludedModuleExitFieldCallback = IO ()
dynamic_IncludedModuleExitFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IncludedModuleExitFieldCallback -> m ()
genClosure_IncludedModuleExitFieldCallback :: IncludedModuleExitFieldCallback -> IO Closure
mk_IncludedModuleExitFieldCallback :: C_IncludedModuleExitFieldCallback -> IO (FunPtr C_IncludedModuleExitFieldCallback)
noIncludedModuleExitFieldCallback :: Maybe IncludedModuleExitFieldCallback
wrap_IncludedModuleExitFieldCallback :: Maybe (Ptr (FunPtr C_IncludedModuleExitFieldCallback)) -> IncludedModuleExitFieldCallback -> IO ()
type C_IncludedModuleInitFieldCallback = Ptr TypeModule -> IO ()
type IncludedModuleInitFieldCallback = TypeModule -> IO ()
dynamic_IncludedModuleInitFieldCallback :: (HasCallStack, MonadIO m, IsTypeModule a) => FunPtr C_IncludedModuleInitFieldCallback -> a -> m ()
genClosure_IncludedModuleInitFieldCallback :: IncludedModuleInitFieldCallback -> IO Closure
mk_IncludedModuleInitFieldCallback :: C_IncludedModuleInitFieldCallback -> IO (FunPtr C_IncludedModuleInitFieldCallback)
noIncludedModuleInitFieldCallback :: Maybe IncludedModuleInitFieldCallback
wrap_IncludedModuleInitFieldCallback :: Maybe (Ptr (FunPtr C_IncludedModuleInitFieldCallback)) -> IncludedModuleInitFieldCallback -> Ptr TypeModule -> IO ()
type C_IncludedModuleListFieldCallback = Ptr EngineInfo -> Int32 -> IO ()
type IncludedModuleListFieldCallback = EngineInfo -> Int32 -> IO ()
dynamic_IncludedModuleListFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IncludedModuleListFieldCallback -> EngineInfo -> Int32 -> m ()
genClosure_IncludedModuleListFieldCallback :: IncludedModuleListFieldCallback -> IO Closure
mk_IncludedModuleListFieldCallback :: C_IncludedModuleListFieldCallback -> IO (FunPtr C_IncludedModuleListFieldCallback)
noIncludedModuleListFieldCallback :: Maybe IncludedModuleListFieldCallback
wrap_IncludedModuleListFieldCallback :: Maybe (Ptr (FunPtr C_IncludedModuleListFieldCallback)) -> IncludedModuleListFieldCallback -> Ptr EngineInfo -> Int32 -> IO ()


-- | A <a>Fontset</a> represents a set of <a>Font</a> to use when rendering
--   text. It is the result of resolving a <a>FontDescription</a> against a
--   particular <a>Context</a>. It has operations for finding the component
--   font for a particular Unicode character, and for finding a composite
--   set of metrics for the entire fontset.
module GI.Pango.Objects.Fontset
newtype Fontset
Fontset :: (ManagedPtr Fontset) -> Fontset
class GObject o => IsFontset o
toFontset :: IsFontset o => o -> IO Fontset
noFontset :: Maybe Fontset
data FontsetForeachMethodInfo

-- | 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.
fontsetForeach :: (HasCallStack, MonadIO m, IsFontset a) => a -> FontsetForeachFunc -> m ()
data FontsetGetFontMethodInfo

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

-- | Get overall metric information for the fonts in the fontset.
fontsetGetMetrics :: (HasCallStack, MonadIO m, IsFontset a) => a -> m FontMetrics
instance Data.GI.Base.BasicTypes.GObject GI.Pango.Objects.Fontset.Fontset
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Pango.Objects.Fontset.Fontset a) => GI.Pango.Objects.Fontset.IsFontset a
instance GI.Pango.Objects.Fontset.IsFontset GI.Pango.Objects.Fontset.Fontset
instance GI.GObject.Objects.Object.IsObject GI.Pango.Objects.Fontset.Fontset
instance (info ~ GI.Pango.Objects.Fontset.ResolveFontsetMethod t GI.Pango.Objects.Fontset.Fontset, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Fontset.Fontset p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Objects.Fontset.Fontset -> p)
instance (info ~ GI.Pango.Objects.Fontset.ResolveFontsetMethod t GI.Pango.Objects.Fontset.Fontset, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Objects.Fontset.Fontset p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Objects.Fontset.Fontset -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Objects.Fontset.Fontset
instance (signature ~ (GI.Pango.Callbacks.FontsetForeachFunc -> m ()), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Fontset.IsFontset a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Fontset.FontsetForeachMethodInfo a signature
instance (signature ~ (GHC.Word.Word32 -> m GI.Pango.Objects.Font.Font), Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Fontset.IsFontset a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Fontset.FontsetGetFontMethodInfo a signature
instance (signature ~ m GI.Pango.Structs.FontMetrics.FontMetrics, Control.Monad.IO.Class.MonadIO m, GI.Pango.Objects.Fontset.IsFontset a) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Objects.Fontset.FontsetGetMetricsMethodInfo a signature


module GI.Pango.Objects


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

-- | Construct a <a>AttrClass</a> struct initialized to zero.
newZeroAttrClass :: MonadIO m => m AttrClass
noAttrClass :: Maybe AttrClass
attrClass_destroy :: AttrLabelProxy "destroy"
clearAttrClassDestroy :: MonadIO m => AttrClass -> m ()
getAttrClassDestroy :: MonadIO m => AttrClass -> m (Maybe AttrClassDestroyFieldCallback)
setAttrClassDestroy :: MonadIO m => AttrClass -> FunPtr C_AttrClassDestroyFieldCallback -> m ()
attrClass_equal :: AttrLabelProxy "equal"
clearAttrClassEqual :: MonadIO m => AttrClass -> m ()
getAttrClassEqual :: MonadIO m => AttrClass -> m (Maybe AttrClassEqualFieldCallback)
setAttrClassEqual :: MonadIO m => AttrClass -> FunPtr C_AttrClassEqualFieldCallback -> m ()
attrClass_type :: AttrLabelProxy "type"
getAttrClassType :: MonadIO m => AttrClass -> m AttrType
setAttrClassType :: MonadIO m => AttrClass -> AttrType -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrClass.AttrClass
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrClass.AttrClass tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrClass.AttrClassTypeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrClass.AttrClassDestroyFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrClass.AttrClassEqualFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrClass.AttrClass
instance (info ~ GI.Pango.Structs.AttrClass.ResolveAttrClassMethod t GI.Pango.Structs.AttrClass.AttrClass, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrClass.AttrClass p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrClass.AttrClass -> p)
instance (info ~ GI.Pango.Structs.AttrClass.ResolveAttrClassMethod t GI.Pango.Structs.AttrClass.AttrClass, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrClass.AttrClass p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrClass.AttrClass -> p)


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

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

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

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

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

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

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

-- | Increase the reference count of the given attribute list by one.
attrListRef :: (HasCallStack, MonadIO m) => AttrList -> m AttrList
data AttrListSpliceMethodInfo

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

-- | Decrease the reference count of the given attribute list by one. If
--   the result is zero, free the attribute list and the attributes it
--   contains.
attrListUnref :: (HasCallStack, MonadIO m) => AttrList -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.Pango.Structs.AttrList.AttrList
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrList.AttrList
instance (signature ~ (GI.Pango.Structs.Attribute.Attribute -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrList.AttrListChangeMethodInfo GI.Pango.Structs.AttrList.AttrList signature
instance (signature ~ m (GHC.Base.Maybe GI.Pango.Structs.AttrList.AttrList), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrList.AttrListCopyMethodInfo GI.Pango.Structs.AttrList.AttrList signature
instance (signature ~ (GI.Pango.Callbacks.AttrFilterFunc -> m (GHC.Base.Maybe GI.Pango.Structs.AttrList.AttrList)), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrList.AttrListFilterMethodInfo GI.Pango.Structs.AttrList.AttrList signature
instance (signature ~ (GI.Pango.Structs.Attribute.Attribute -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrList.AttrListInsertMethodInfo GI.Pango.Structs.AttrList.AttrList signature
instance (signature ~ (GI.Pango.Structs.Attribute.Attribute -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrList.AttrListInsertBeforeMethodInfo GI.Pango.Structs.AttrList.AttrList signature
instance (signature ~ m GI.Pango.Structs.AttrList.AttrList, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrList.AttrListRefMethodInfo GI.Pango.Structs.AttrList.AttrList signature
instance (signature ~ (GI.Pango.Structs.AttrList.AttrList -> GHC.Int.Int32 -> GHC.Int.Int32 -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrList.AttrListSpliceMethodInfo GI.Pango.Structs.AttrList.AttrList signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.Pango.Structs.AttrList.AttrListUnrefMethodInfo GI.Pango.Structs.AttrList.AttrList signature
instance (info ~ GI.Pango.Structs.AttrList.ResolveAttrListMethod t GI.Pango.Structs.AttrList.AttrList, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrList.AttrList p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrList.AttrList -> p)
instance (info ~ GI.Pango.Structs.AttrList.ResolveAttrListMethod t GI.Pango.Structs.AttrList.AttrList, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrList.AttrList p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrList.AttrList -> p)


-- | The <a>AttrShape</a> structure is used to represent attributes which
--   impose shape restrictions.
module GI.Pango.Structs.AttrShape
newtype AttrShape
AttrShape :: (ManagedPtr AttrShape) -> AttrShape

-- | Construct a <a>AttrShape</a> struct initialized to zero.
newZeroAttrShape :: MonadIO m => m AttrShape
noAttrShape :: Maybe AttrShape

-- | Create a new shape attribute. A shape is used to impose a particular
--   ink and logical rectangle on the result of shaping a particular glyph.
--   This might be used, for instance, for embedding a picture or a widget
--   inside a <a>Layout</a>.
attrShapeNew :: (HasCallStack, MonadIO m) => Rectangle -> Rectangle -> m Attribute
attrShape_attr :: AttrLabelProxy "attr"
getAttrShapeAttr :: MonadIO m => AttrShape -> m Attribute
attrShape_copyFunc :: AttrLabelProxy "copyFunc"
clearAttrShapeCopyFunc :: MonadIO m => AttrShape -> m ()
getAttrShapeCopyFunc :: MonadIO m => AttrShape -> m (Maybe AttrDataCopyFunc_WithClosures)
setAttrShapeCopyFunc :: MonadIO m => AttrShape -> FunPtr C_AttrDataCopyFunc -> m ()
attrShape_data :: AttrLabelProxy "data"
clearAttrShapeData :: MonadIO m => AttrShape -> m ()
getAttrShapeData :: MonadIO m => AttrShape -> m (Ptr ())
setAttrShapeData :: MonadIO m => AttrShape -> Ptr () -> m ()
attrShape_destroyFunc :: AttrLabelProxy "destroyFunc"
clearAttrShapeDestroyFunc :: MonadIO m => AttrShape -> m ()
getAttrShapeDestroyFunc :: MonadIO m => AttrShape -> m (Maybe DestroyNotify)
setAttrShapeDestroyFunc :: MonadIO m => AttrShape -> FunPtr C_DestroyNotify -> m ()
attrShape_inkRect :: AttrLabelProxy "inkRect"
getAttrShapeInkRect :: MonadIO m => AttrShape -> m Rectangle
attrShape_logicalRect :: AttrLabelProxy "logicalRect"
getAttrShapeLogicalRect :: MonadIO m => AttrShape -> m Rectangle
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.AttrShape.AttrShape
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.AttrShape.AttrShape tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrShape.AttrShapeAttrFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrShape.AttrShapeInkRectFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrShape.AttrShapeLogicalRectFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrShape.AttrShapeDataFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrShape.AttrShapeCopyFuncFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.AttrShape.AttrShapeDestroyFuncFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.AttrShape.AttrShape
instance (info ~ GI.Pango.Structs.AttrShape.ResolveAttrShapeMethod t GI.Pango.Structs.AttrShape.AttrShape, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrShape.AttrShape p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.AttrShape.AttrShape -> p)
instance (info ~ GI.Pango.Structs.AttrShape.ResolveAttrShapeMethod t GI.Pango.Structs.AttrShape.AttrShape, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.AttrShape.AttrShape p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.AttrShape.AttrShape -> p)


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

-- | Construct a <a>IncludedModule</a> struct initialized to zero.
newZeroIncludedModule :: MonadIO m => m IncludedModule
noIncludedModule :: Maybe IncludedModule
clearIncludedModuleExit :: MonadIO m => IncludedModule -> m ()
getIncludedModuleExit :: MonadIO m => IncludedModule -> m (Maybe IncludedModuleExitFieldCallback)
includedModule_exit :: AttrLabelProxy "exit"
setIncludedModuleExit :: MonadIO m => IncludedModule -> FunPtr C_IncludedModuleExitFieldCallback -> m ()
clearIncludedModuleInit :: MonadIO m => IncludedModule -> m ()
getIncludedModuleInit :: MonadIO m => IncludedModule -> m (Maybe IncludedModuleInitFieldCallback)
includedModule_init :: AttrLabelProxy "init"
setIncludedModuleInit :: MonadIO m => IncludedModule -> FunPtr C_IncludedModuleInitFieldCallback -> m ()
clearIncludedModuleList :: MonadIO m => IncludedModule -> m ()
getIncludedModuleList :: MonadIO m => IncludedModule -> m (Maybe IncludedModuleListFieldCallback)
includedModule_list :: AttrLabelProxy "list"
setIncludedModuleList :: MonadIO m => IncludedModule -> FunPtr C_IncludedModuleListFieldCallback -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Pango.Structs.IncludedModule.IncludedModule
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.Pango.Structs.IncludedModule.IncludedModule tag
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.IncludedModule.IncludedModuleListFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.IncludedModule.IncludedModuleInitFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.Pango.Structs.IncludedModule.IncludedModuleExitFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.Pango.Structs.IncludedModule.IncludedModule
instance (info ~ GI.Pango.Structs.IncludedModule.ResolveIncludedModuleMethod t GI.Pango.Structs.IncludedModule.IncludedModule, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.IncludedModule.IncludedModule p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.Pango.Structs.IncludedModule.IncludedModule -> p)
instance (info ~ GI.Pango.Structs.IncludedModule.ResolveIncludedModuleMethod t GI.Pango.Structs.IncludedModule.IncludedModule, Data.GI.Base.Overloading.MethodInfo info GI.Pango.Structs.IncludedModule.IncludedModule p) => GHC.OverloadedLabels.IsLabel t (GI.Pango.Structs.IncludedModule.IncludedModule -> p)


module GI.Pango.Structs


module GI.Pango

module GI.Pango.PkgInfo
pkgConfigVersions :: [(String, String)]
flags :: [(String, Bool)]