Copyright | Will Thompson, Iñaki García Etxebarria and Jonas Platte |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria (garetxe@gmail.com) |
Safe Haskell | None |
Language | Haskell2010 |
- Exported types
- Methods
- Unsupported methods
- contextChanged
- copy
- getAlignment
- getAttributes
- getAutoDir
- getBaseline
- getCharacterCount
- getContext
- getCursorPos
- getEllipsize
- getExtents
- getFontDescription
- getHeight
- getIndent
- getIter
- getJustify
- getLine
- getLineCount
- getLineReadonly
- getLines
- getLinesReadonly
- getLogAttrs
- getLogAttrsReadonly
- getPixelExtents
- getPixelSize
- getSerial
- getSingleParagraphMode
- getSpacing
- getTabs
- getText
- getUnknownGlyphsCount
- getWidth
- getWrap
- indexToLineX
- indexToPos
- isEllipsized
- isWrapped
- moveCursorVisually
- new
- setAlignment
- setAttributes
- setAutoDir
- setEllipsize
- setFontDescription
- setHeight
- setIndent
- setJustify
- setMarkup
- setSingleParagraphMode
- setSpacing
- setTabs
- setText
- setWidth
- setWrap
- xyToIndex
The Layout
structure represents an entire paragraph
of text. It is initialized with a Context
, 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 Layout
, which are illustrated in <xref linkend="parameters"/>.
It is possible, as well, to ignore the 2-D setup, and simply
treat the results of a Layout
as a list of lines.
<figure id="parameters"> <title>Adjustable parameters for a PangoLayout</title> <graphic fileref="layout.gif" format="GIF"></graphic> </figure>
The Layout
structure is opaque, and has no user-visible
fields.
- newtype Layout = Layout (ManagedPtr Layout)
- class GObject o => IsLayout o
- toLayout :: IsLayout o => o -> IO Layout
- noLayout :: Maybe Layout
- data LayoutGetSizeMethodInfo
- data LayoutSetMarkupWithAccelMethodInfo
- data LayoutContextChangedMethodInfo
- layoutContextChanged :: (HasCallStack, MonadIO m, IsLayout a) => a -> m ()
- data LayoutCopyMethodInfo
- layoutCopy :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Layout
- data LayoutGetAlignmentMethodInfo
- layoutGetAlignment :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Alignment
- data LayoutGetAttributesMethodInfo
- layoutGetAttributes :: (HasCallStack, MonadIO m, IsLayout a) => a -> m AttrList
- data LayoutGetAutoDirMethodInfo
- layoutGetAutoDir :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
- data LayoutGetBaselineMethodInfo
- layoutGetBaseline :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- data LayoutGetCharacterCountMethodInfo
- layoutGetCharacterCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- data LayoutGetContextMethodInfo
- layoutGetContext :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Context
- data LayoutGetCursorPosMethodInfo
- layoutGetCursorPos :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Rectangle, Rectangle)
- data LayoutGetEllipsizeMethodInfo
- layoutGetEllipsize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m EllipsizeMode
- data LayoutGetExtentsMethodInfo
- layoutGetExtents :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Rectangle, Rectangle)
- data LayoutGetFontDescriptionMethodInfo
- layoutGetFontDescription :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Maybe FontDescription)
- data LayoutGetHeightMethodInfo
- layoutGetHeight :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- data LayoutGetIndentMethodInfo
- layoutGetIndent :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- data LayoutGetIterMethodInfo
- layoutGetIter :: (HasCallStack, MonadIO m, IsLayout a) => a -> m LayoutIter
- data LayoutGetJustifyMethodInfo
- layoutGetJustify :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
- data LayoutGetLineMethodInfo
- layoutGetLine :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Maybe LayoutLine)
- data LayoutGetLineCountMethodInfo
- layoutGetLineCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- data LayoutGetLineReadonlyMethodInfo
- layoutGetLineReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Maybe LayoutLine)
- data LayoutGetLinesMethodInfo
- layoutGetLines :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LayoutLine]
- data LayoutGetLinesReadonlyMethodInfo
- layoutGetLinesReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LayoutLine]
- data LayoutGetLogAttrsMethodInfo
- layoutGetLogAttrs :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LogAttr]
- data LayoutGetLogAttrsReadonlyMethodInfo
- layoutGetLogAttrsReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LogAttr]
- data LayoutGetPixelExtentsMethodInfo
- layoutGetPixelExtents :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Rectangle, Rectangle)
- data LayoutGetPixelSizeMethodInfo
- layoutGetPixelSize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Int32, Int32)
- data LayoutGetSerialMethodInfo
- layoutGetSerial :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Word32
- data LayoutGetSingleParagraphModeMethodInfo
- layoutGetSingleParagraphMode :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
- data LayoutGetSpacingMethodInfo
- layoutGetSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- data LayoutGetTabsMethodInfo
- layoutGetTabs :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Maybe TabArray)
- data LayoutGetTextMethodInfo
- layoutGetText :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Text
- data LayoutGetUnknownGlyphsCountMethodInfo
- layoutGetUnknownGlyphsCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- data LayoutGetWidthMethodInfo
- layoutGetWidth :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- data LayoutGetWrapMethodInfo
- layoutGetWrap :: (HasCallStack, MonadIO m, IsLayout a) => a -> m WrapMode
- data LayoutIndexToLineXMethodInfo
- layoutIndexToLineX :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> Bool -> m (Int32, Int32)
- data LayoutIndexToPosMethodInfo
- layoutIndexToPos :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m Rectangle
- data LayoutIsEllipsizedMethodInfo
- layoutIsEllipsized :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
- data LayoutIsWrappedMethodInfo
- layoutIsWrapped :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
- data LayoutMoveCursorVisuallyMethodInfo
- layoutMoveCursorVisually :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> Int32 -> Int32 -> Int32 -> m (Int32, Int32)
- layoutNew :: (HasCallStack, MonadIO m, IsContext a) => a -> m Layout
- data LayoutSetAlignmentMethodInfo
- layoutSetAlignment :: (HasCallStack, MonadIO m, IsLayout a) => a -> Alignment -> m ()
- data LayoutSetAttributesMethodInfo
- layoutSetAttributes :: (HasCallStack, MonadIO m, IsLayout a) => a -> Maybe AttrList -> m ()
- data LayoutSetAutoDirMethodInfo
- layoutSetAutoDir :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()
- data LayoutSetEllipsizeMethodInfo
- layoutSetEllipsize :: (HasCallStack, MonadIO m, IsLayout a) => a -> EllipsizeMode -> m ()
- data LayoutSetFontDescriptionMethodInfo
- layoutSetFontDescription :: (HasCallStack, MonadIO m, IsLayout a) => a -> Maybe FontDescription -> m ()
- data LayoutSetHeightMethodInfo
- layoutSetHeight :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
- data LayoutSetIndentMethodInfo
- layoutSetIndent :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
- data LayoutSetJustifyMethodInfo
- layoutSetJustify :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()
- data LayoutSetMarkupMethodInfo
- layoutSetMarkup :: (HasCallStack, MonadIO m, IsLayout a) => a -> Text -> Int32 -> m ()
- data LayoutSetSingleParagraphModeMethodInfo
- layoutSetSingleParagraphMode :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()
- data LayoutSetSpacingMethodInfo
- layoutSetSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
- data LayoutSetTabsMethodInfo
- layoutSetTabs :: (HasCallStack, MonadIO m, IsLayout a) => a -> Maybe TabArray -> m ()
- data LayoutSetTextMethodInfo
- layoutSetText :: (HasCallStack, MonadIO m, IsLayout a) => a -> Text -> Int32 -> m ()
- data LayoutSetWidthMethodInfo
- layoutSetWidth :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
- data LayoutSetWrapMethodInfo
- layoutSetWrap :: (HasCallStack, MonadIO m, IsLayout a) => a -> WrapMode -> m ()
- data LayoutXyToIndexMethodInfo
- layoutXyToIndex :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> Int32 -> m (Bool, Int32, Int32)
Exported types
GObject Layout Source # | |
IsObject Layout Source # | |
IsLayout Layout Source # | |
((~) * info (ResolveLayoutMethod t Layout), MethodInfo * info Layout p) => IsLabel t (Layout -> p) Source # | |
((~) * info (ResolveLayoutMethod t Layout), MethodInfo * info Layout p) => IsLabelProxy t (Layout -> p) Source # | |
HasAttributeList * Layout Source # | |
type AttributeList Layout Source # | |
type SignalList Layout Source # | |
Methods
Unsupported methods
data LayoutGetSizeMethodInfo Source #
((~) * p (), (~) * o (MethodResolutionFailed * "getSize" Layout)) => MethodInfo * LayoutGetSizeMethodInfo o p Source # | |
data LayoutSetMarkupWithAccelMethodInfo Source #
((~) * p (), (~) * o (MethodResolutionFailed * "setMarkupWithAccel" Layout)) => MethodInfo * LayoutSetMarkupWithAccelMethodInfo o p Source # | |
contextChanged
data LayoutContextChangedMethodInfo Source #
((~) * signature (m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutContextChangedMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m () |
Forces recomputation of any state in the Layout
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.
copy
data LayoutCopyMethodInfo Source #
((~) * signature (m Layout), MonadIO m, IsLayout a) => MethodInfo * LayoutCopyMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Layout | Returns: the newly allocated |
Does a deep copy-by-value of the src
layout. The attribute list,
tab array, and text from the original layout are all copied by
value.
getAlignment
data LayoutGetAlignmentMethodInfo Source #
((~) * signature (m Alignment), MonadIO m, IsLayout a) => MethodInfo * LayoutGetAlignmentMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Alignment | Returns: the alignment. |
Gets the alignment for the layout: how partial lines are positioned within the horizontal space available.
getAttributes
data LayoutGetAttributesMethodInfo Source #
((~) * signature (m AttrList), MonadIO m, IsLayout a) => MethodInfo * LayoutGetAttributesMethodInfo a signature Source # | |
Gets the attribute list for the layout, if any.
getAutoDir
data LayoutGetAutoDirMethodInfo Source #
((~) * signature (m Bool), MonadIO m, IsLayout a) => MethodInfo * LayoutGetAutoDirMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Bool | Returns: |
Gets whether to calculate the bidirectional base direction
for the layout according to the contents of the layout.
See layoutSetAutoDir
.
Since: 1.4
getBaseline
data LayoutGetBaselineMethodInfo Source #
((~) * signature (m Int32), MonadIO m, IsLayout a) => MethodInfo * LayoutGetBaselineMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Int32 | Returns: baseline of first line, from top of |
Gets the Y position of baseline of the first line in layout
.
Since: 1.22
getCharacterCount
data LayoutGetCharacterCountMethodInfo Source #
((~) * signature (m Int32), MonadIO m, IsLayout a) => MethodInfo * LayoutGetCharacterCountMethodInfo a signature Source # | |
layoutGetCharacterCount Source #
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Int32 | Returns: the number of Unicode characters
in the text of |
Returns the number of Unicode characters in the
the text of layout
.
Since: 1.30
getContext
data LayoutGetContextMethodInfo Source #
((~) * signature (m Context), MonadIO m, IsLayout a) => MethodInfo * LayoutGetContextMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Context | Returns: the |
Retrieves the Context
used for this layout.
getCursorPos
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m (Rectangle, Rectangle) |
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.
getEllipsize
data LayoutGetEllipsizeMethodInfo Source #
((~) * signature (m EllipsizeMode), MonadIO m, IsLayout a) => MethodInfo * LayoutGetEllipsizeMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m EllipsizeMode | Returns: the current ellipsization mode for Use |
Gets the type of ellipsization being performed for layout
.
See layoutSetEllipsize
Since: 1.6
getExtents
data LayoutGetExtentsMethodInfo Source #
((~) * signature (m (Rectangle, Rectangle)), MonadIO m, IsLayout a) => MethodInfo * LayoutGetExtentsMethodInfo a signature Source # | |
Computes the logical and ink extents of layout
. 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.
getFontDescription
data LayoutGetFontDescriptionMethodInfo Source #
((~) * signature (m (Maybe FontDescription)), MonadIO m, IsLayout a) => MethodInfo * LayoutGetFontDescriptionMethodInfo a signature Source # | |
layoutGetFontDescription Source #
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m (Maybe FontDescription) | Returns: a pointer to the layout's font
description, or |
Gets the font description for the layout, if any.
Since: 1.8
getHeight
data LayoutGetHeightMethodInfo Source #
((~) * signature (m Int32), MonadIO m, IsLayout a) => MethodInfo * LayoutGetHeightMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Int32 | Returns: the height, in Pango units if positive, or number of lines if negative. |
Gets the height of layout used for ellipsization. See
layoutSetHeight
for details.
Since: 1.20
getIndent
data LayoutGetIndentMethodInfo Source #
((~) * signature (m Int32), MonadIO m, IsLayout a) => MethodInfo * LayoutGetIndentMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Int32 | Returns: the indent in Pango units. |
Gets the paragraph indent width in Pango units. A negative value indicates a hanging indentation.
getIter
data LayoutGetIterMethodInfo Source #
((~) * signature (m LayoutIter), MonadIO m, IsLayout a) => MethodInfo * LayoutGetIterMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m LayoutIter | Returns: the new |
Returns an iterator to iterate over the visual extents of the layout.
getJustify
data LayoutGetJustifyMethodInfo Source #
((~) * signature (m Bool), MonadIO m, IsLayout a) => MethodInfo * LayoutGetJustifyMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Bool | Returns: the justify. |
Gets whether each complete line should be stretched to fill the entire width of the layout.
getLine
data LayoutGetLineMethodInfo Source #
((~) * signature (Int32 -> m (Maybe LayoutLine)), MonadIO m, IsLayout a) => MethodInfo * LayoutGetLineMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m (Maybe LayoutLine) | Returns: the requested
|
Retrieves a particular line from a Layout
.
Use the faster layoutGetLineReadonly
if you do not plan
to modify the contents of the line (glyphs, glyph widths, etc.).
getLineCount
data LayoutGetLineCountMethodInfo Source #
((~) * signature (m Int32), MonadIO m, IsLayout a) => MethodInfo * LayoutGetLineCountMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Int32 | Returns: the line count. |
Retrieves the count of lines for the layout
.
getLineReadonly
data LayoutGetLineReadonlyMethodInfo Source #
((~) * signature (Int32 -> m (Maybe LayoutLine)), MonadIO m, IsLayout a) => MethodInfo * LayoutGetLineReadonlyMethodInfo a signature Source # | |
layoutGetLineReadonly Source #
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m (Maybe LayoutLine) | Returns: the requested
|
Retrieves a particular line from a Layout
.
This is a faster alternative to layoutGetLine
,
but the user is not expected
to modify the contents of the line (glyphs, glyph widths, etc.).
Since: 1.16
getLines
data LayoutGetLinesMethodInfo Source #
((~) * signature (m [LayoutLine]), MonadIO m, IsLayout a) => MethodInfo * LayoutGetLinesMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m [LayoutLine] | Returns: a |
Returns the lines of the layout
as a list.
Use the faster layoutGetLinesReadonly
if you do not plan
to modify the contents of the lines (glyphs, glyph widths, etc.).
getLinesReadonly
data LayoutGetLinesReadonlyMethodInfo Source #
((~) * signature (m [LayoutLine]), MonadIO m, IsLayout a) => MethodInfo * LayoutGetLinesReadonlyMethodInfo a signature Source # | |
layoutGetLinesReadonly Source #
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m [LayoutLine] | Returns: a |
Returns the lines of the layout
as a list.
This is a faster alternative to layoutGetLines
,
but the user is not expected
to modify the contents of the lines (glyphs, glyph widths, etc.).
Since: 1.16
getLogAttrs
data LayoutGetLogAttrsMethodInfo Source #
((~) * signature (m [LogAttr]), MonadIO m, IsLayout a) => MethodInfo * LayoutGetLogAttrsMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m [LogAttr] |
Retrieves an array of logical attributes for each character in
the layout
.
getLogAttrsReadonly
data LayoutGetLogAttrsReadonlyMethodInfo Source #
((~) * signature (m [LogAttr]), MonadIO m, IsLayout a) => MethodInfo * LayoutGetLogAttrsReadonlyMethodInfo a signature Source # | |
layoutGetLogAttrsReadonly Source #
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m [LogAttr] | Returns: an array of logical attributes |
Retrieves an array of logical attributes for each character in
the layout
.
This is a faster alternative to layoutGetLogAttrs
.
The returned array is part of layout
and must not be modified.
Modifying the layout will invalidate the returned array.
The number of attributes returned in nAttrs
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.
Since: 1.30
getPixelExtents
data LayoutGetPixelExtentsMethodInfo Source #
((~) * signature (m (Rectangle, Rectangle)), MonadIO m, IsLayout a) => MethodInfo * LayoutGetPixelExtentsMethodInfo a signature Source # | |
layoutGetPixelExtents Source #
Computes the logical and ink extents of layout
in device units.
This function just calls layoutGetExtents
followed by
two extentsToPixels
calls, rounding inkRect
and logicalRect
such that the rounded rectangles fully contain the unrounded one (that is,
passes them as first argument to extentsToPixels
).
getPixelSize
data LayoutGetPixelSizeMethodInfo Source #
((~) * signature (m (Int32, Int32)), MonadIO m, IsLayout a) => MethodInfo * LayoutGetPixelSizeMethodInfo a signature Source # | |
Determines the logical width and height of a Layout
in device units. (layoutGetSize
returns the width
and height scaled by SCALE
.) This
is simply a convenience function around
layoutGetPixelExtents
.
getSerial
data LayoutGetSerialMethodInfo Source #
((~) * signature (m Word32), MonadIO m, IsLayout a) => MethodInfo * LayoutGetSerialMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Word32 | Returns: The current serial number of |
Returns the current serial number of layout
. 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 Context
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 Layout
, and
is useful for example to decide whether a layout needs redrawing.
To force the serial to be increased, use layoutContextChanged
.
Since: 1.32.4
getSingleParagraphMode
data LayoutGetSingleParagraphModeMethodInfo Source #
((~) * signature (m Bool), MonadIO m, IsLayout a) => MethodInfo * LayoutGetSingleParagraphModeMethodInfo a signature Source # | |
layoutGetSingleParagraphMode Source #
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Bool | Returns: |
Obtains the value set by layoutSetSingleParagraphMode
.
getSpacing
data LayoutGetSpacingMethodInfo Source #
((~) * signature (m Int32), MonadIO m, IsLayout a) => MethodInfo * LayoutGetSpacingMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Int32 | Returns: the spacing in Pango units. |
Gets the amount of spacing between the lines of the layout.
getTabs
data LayoutGetTabsMethodInfo Source #
((~) * signature (m (Maybe TabArray)), MonadIO m, IsLayout a) => MethodInfo * LayoutGetTabsMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m (Maybe TabArray) | Returns: a copy of the tabs for this layout, or
|
Gets the current TabArray
used by this layout. If no
TabArray
has been set, then the default tabs are in use
and Nothing
is returned. Default tabs are every 8 spaces.
The return value should be freed with tabArrayFree
.
getText
data LayoutGetTextMethodInfo Source #
((~) * signature (m Text), MonadIO m, IsLayout a) => MethodInfo * LayoutGetTextMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Text | Returns: the text in the |
Gets the text in the layout. The returned text should not be freed or modified.
getUnknownGlyphsCount
data LayoutGetUnknownGlyphsCountMethodInfo Source #
((~) * signature (m Int32), MonadIO m, IsLayout a) => MethodInfo * LayoutGetUnknownGlyphsCountMethodInfo a signature Source # | |
layoutGetUnknownGlyphsCount Source #
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Int32 | Returns: The number of unknown glyphs in |
Counts the number unknown glyphs in layout
. 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 AttrTypeFallback
, to check if a
certain font supports all the characters in the string.
Since: 1.16
getWidth
data LayoutGetWidthMethodInfo Source #
((~) * signature (m Int32), MonadIO m, IsLayout a) => MethodInfo * LayoutGetWidthMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Int32 | Returns: the width in Pango units, or -1 if no width set. |
Gets the width to which the lines of the Layout
should wrap.
getWrap
data LayoutGetWrapMethodInfo Source #
((~) * signature (m WrapMode), MonadIO m, IsLayout a) => MethodInfo * LayoutGetWrapMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m WrapMode | Returns: active wrap mode. |
Gets the wrap mode for the layout.
Use layoutIsWrapped
to query whether any paragraphs
were actually wrapped.
indexToLineX
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> Bool |
|
-> m (Int32, Int32) |
Converts from byte index_
within the layout
to line and X position.
(X position is measured from the left edge of the line)
indexToPos
data LayoutIndexToPosMethodInfo Source #
((~) * signature (Int32 -> m Rectangle), MonadIO m, IsLayout a) => MethodInfo * LayoutIndexToPosMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m Rectangle |
Converts from an index within a Layout
to the onscreen position
corresponding to the grapheme at that index, which is represented
as rectangle. Note that <literal>pos->x</literal> is always the leading
edge of the grapheme and <literal>pos->x + pos->width</literal> the trailing
edge of the grapheme. If the directionality of the grapheme is right-to-left,
then <literal>pos->width</literal> will be negative.
isEllipsized
data LayoutIsEllipsizedMethodInfo Source #
((~) * signature (m Bool), MonadIO m, IsLayout a) => MethodInfo * LayoutIsEllipsizedMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Bool | Returns: |
Queries whether the layout had to ellipsize any paragraphs.
This returns True
if the ellipsization mode for layout
is not EllipsizeModeNone
, a positive width is set on layout
,
and there are paragraphs exceeding that width that have to be
ellipsized.
Since: 1.16
isWrapped
data LayoutIsWrappedMethodInfo Source #
((~) * signature (m Bool), MonadIO m, IsLayout a) => MethodInfo * LayoutIsWrappedMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Bool | Returns: |
Queries whether the layout had to wrap any paragraphs.
This returns True
if a positive width is set on layout
,
ellipsization mode of layout
is set to EllipsizeModeNone
,
and there are paragraphs exceeding the layout width that have
to be wrapped.
Since: 1.16
moveCursorVisually
layoutMoveCursorVisually Source #
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Bool |
|
-> Int32 |
|
-> Int32 |
|
-> Int32 |
|
-> m (Int32, Int32) |
Computes a new cursor position from an old position and
a count of positions to move visually. If direction
is positive,
then the new strong cursor position will be one position
to the right of the old cursor position. If direction
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 layoutMoveCursorVisually
may move the
cursor over multiple characters when multiple characters combine
to form a single grapheme.
new
:: (HasCallStack, MonadIO m, IsContext a) | |
=> a |
|
-> m Layout | Returns: the newly allocated |
setAlignment
data LayoutSetAlignmentMethodInfo Source #
((~) * signature (Alignment -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetAlignmentMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Alignment |
|
-> m () |
Sets the alignment for the layout: how partial lines are positioned within the horizontal space available.
setAttributes
data LayoutSetAttributesMethodInfo Source #
((~) * signature (Maybe AttrList -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetAttributesMethodInfo a signature Source # | |
Sets the text attributes for a layout object.
References attrs
, so the caller can unref its reference.
setAutoDir
data LayoutSetAutoDirMethodInfo Source #
((~) * signature (Bool -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetAutoDirMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Bool |
|
-> m () |
Sets whether to calculate the bidirectional base direction
for the layout according to the contents of the layout;
when this flag is on (the default), then paragraphs in
layout
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 False
, the choice between left-to-right and
right-to-left layout is done according to the base direction
of the layout's Context
. (See contextSetBaseDir
).
When the auto-computed direction of a paragraph differs from the
base direction of the context, the interpretation of
AlignmentLeft
and AlignmentRight
are swapped.
Since: 1.4
setEllipsize
data LayoutSetEllipsizeMethodInfo Source #
((~) * signature (EllipsizeMode -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetEllipsizeMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> EllipsizeMode |
|
-> m () |
Sets the type of ellipsization being performed for layout
.
Depending on the ellipsization mode ellipsize
text is
removed from the start, middle, or end of text so they
fit within the width and height of layout set with
layoutSetWidth
and layoutSetHeight
.
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 layoutSetHeight
for details.
Since: 1.6
setFontDescription
data LayoutSetFontDescriptionMethodInfo Source #
((~) * signature (Maybe FontDescription -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetFontDescriptionMethodInfo a signature Source # | |
layoutSetFontDescription Source #
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Maybe FontDescription |
|
-> m () |
Sets the default font description for the layout. If no font description is set on the layout, the font description from the layout's context is used.
setHeight
data LayoutSetHeightMethodInfo Source #
((~) * signature (Int32 -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetHeightMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m () |
Sets the height to which the Layout
should be ellipsized at. There
are two different behaviors, based on whether height
is positive or
negative.
If height
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 height
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 <ulink
url="http://bugzilla.gnome.org/">http://bugzilla.gnome.org/</ulink> if your
code relies on this behavior.
Height setting only has effect if a positive width is set on
layout
and ellipsization mode of layout
is not EllipsizeModeNone
.
The behavior is undefined if a height other than -1 is set and
ellipsization mode is set to EllipsizeModeNone
, and may change in the
future.
Since: 1.20
setIndent
data LayoutSetIndentMethodInfo Source #
((~) * signature (Int32 -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetIndentMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m () |
Sets the width in Pango units to indent each paragraph. A negative value
of indent
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 indent
.
The indent setting is ignored if layout alignment is set to
AlignmentCenter
.
setJustify
data LayoutSetJustifyMethodInfo Source #
((~) * signature (Bool -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetJustifyMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Bool |
|
-> m () |
Sets whether each complete line should be stretched to fill the entire width of the layout. This stretching is typically done by adding whitespace, but for some scripts (such as Arabic), the justification may be done in more complex ways, like extending the characters.
Note that this setting is not implemented and so is ignored in Pango older than 1.18.
setMarkup
data LayoutSetMarkupMethodInfo Source #
((~) * signature (Text -> Int32 -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetMarkupMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Text |
|
-> Int32 |
|
-> m () |
Same as layoutSetMarkupWithAccel
, but
the markup text isn't scanned for accelerators.
setSingleParagraphMode
data LayoutSetSingleParagraphModeMethodInfo Source #
((~) * signature (Bool -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetSingleParagraphModeMethodInfo a signature Source # | |
layoutSetSingleParagraphMode Source #
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Bool |
|
-> m () |
If setting
is True
, 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.
setSpacing
data LayoutSetSpacingMethodInfo Source #
((~) * signature (Int32 -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetSpacingMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m () |
Sets the amount of spacing in Pango unit between the lines of the layout.
setTabs
data LayoutSetTabsMethodInfo Source #
((~) * signature (Maybe TabArray -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetTabsMethodInfo a signature Source # | |
Sets the tabs to use for layout
, overriding the default tabs
(by default, tabs are every 8 spaces). If tabs
is Nothing
, the default
tabs are reinstated. tabs
is copied into the layout; you must
free your copy of tabs
yourself.
setText
data LayoutSetTextMethodInfo Source #
((~) * signature (Text -> Int32 -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetTextMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Text |
|
-> Int32 |
|
-> m () |
Sets the text of the layout.
Note that if you have used
layoutSetMarkup
or layoutSetMarkupWithAccel
on
layout
before, you may want to call layoutSetAttributes
to clear
the attributes set on the layout from the markup as this function does not
clear attributes.
setWidth
data LayoutSetWidthMethodInfo Source #
((~) * signature (Int32 -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetWidthMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m () |
Sets the width to which the lines of the Layout
should wrap or
ellipsized. The default value is -1: no width set.
setWrap
data LayoutSetWrapMethodInfo Source #
((~) * signature (WrapMode -> m ()), MonadIO m, IsLayout a) => MethodInfo * LayoutSetWrapMethodInfo a signature Source # | |
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> WrapMode |
|
-> m () |
Sets the wrap mode; the wrap mode only has effect if a width
is set on the layout with layoutSetWidth
.
To turn off wrapping, set the width to -1.
xyToIndex
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> Int32 |
|
-> m (Bool, Int32, Int32) | Returns: |
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 layoutLineXToIndex
.
If either the X or Y positions were not inside the layout, then the
function returns False
; on an exact hit, it returns True
.