Copyright | Will Thompson Iñaki García Etxebarria and Jonas Platte |
---|---|
License | LGPL-2.1 |
Maintainer | Iñaki García Etxebarria |
Safe Haskell | None |
Language | Haskell2010 |
GI.Pango.Objects.Layout
Contents
- Exported types
- Methods
- contextChanged
- copy
- getAlignment
- getAttributes
- getAutoDir
- getBaseline
- getCharacterCount
- getContext
- getCursorPos
- getDirection
- getEllipsize
- getExtents
- getFontDescription
- getHeight
- getIndent
- getIter
- getJustify
- getLine
- getLineCount
- getLineReadonly
- getLineSpacing
- getLines
- getLinesReadonly
- getLogAttrs
- getLogAttrsReadonly
- getPixelExtents
- getPixelSize
- getSerial
- getSingleParagraphMode
- getSize
- getSpacing
- getTabs
- getText
- getUnknownGlyphsCount
- getWidth
- getWrap
- indexToLineX
- indexToPos
- isEllipsized
- isWrapped
- moveCursorVisually
- new
- setAlignment
- setAttributes
- setAutoDir
- setEllipsize
- setFontDescription
- setHeight
- setIndent
- setJustify
- setLineSpacing
- setMarkup
- setSingleParagraphMode
- setSpacing
- setTabs
- setText
- setWidth
- setWrap
- xyToIndex
Description
A PangoLayout
structure represents an entire paragraph of text.
While complete access to the layout capabilities of Pango is provided
using the detailed interfaces for itemization and shaping, using
that functionality directly involves writing a fairly large amount
of code. PangoLayout
provides a high-level driver for formatting
entire paragraphs of text at once. This includes paragraph-level
functionality such as line breaking, justification, alignment and
ellipsization.
A PangoLayout
is initialized with a PangoContext
, UTF-8 string
and set of attributes for that string. Once that is done, the set of
formatted lines can be extracted from the object, the layout can be
rendered, and conversion between logical character positions within
the layout's text, and the physical position of the resulting glyphs
can be made.
There are a number of parameters to adjust the formatting of a
PangoLayout
. The following image shows adjustable parameters
(on the left) and font metrics (on the right):
It is possible, as well, to ignore the 2-D setup,
and simply treat the results of a PangoLayout
as a list of lines.
Synopsis
- newtype Layout = Layout (ManagedPtr Layout)
- class (GObject o, IsDescendantOf Layout o) => IsLayout o
- toLayout :: (MonadIO m, IsLayout o) => o -> m Layout
- layoutContextChanged :: (HasCallStack, MonadIO m, IsLayout a) => a -> m ()
- layoutCopy :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Layout
- layoutGetAlignment :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Alignment
- layoutGetAttributes :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Maybe AttrList)
- layoutGetAutoDir :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
- layoutGetBaseline :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- layoutGetCharacterCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- layoutGetContext :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Context
- layoutGetCursorPos :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Rectangle, Rectangle)
- layoutGetDirection :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m Direction
- layoutGetEllipsize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m EllipsizeMode
- layoutGetExtents :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Rectangle, Rectangle)
- layoutGetFontDescription :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Maybe FontDescription)
- layoutGetHeight :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- layoutGetIndent :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- layoutGetIter :: (HasCallStack, MonadIO m, IsLayout a) => a -> m LayoutIter
- layoutGetJustify :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
- layoutGetLine :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Maybe LayoutLine)
- layoutGetLineCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- layoutGetLineReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m (Maybe LayoutLine)
- layoutGetLineSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Float
- layoutGetLines :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LayoutLine]
- layoutGetLinesReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LayoutLine]
- layoutGetLogAttrs :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LogAttr]
- layoutGetLogAttrsReadonly :: (HasCallStack, MonadIO m, IsLayout a) => a -> m [LogAttr]
- layoutGetPixelExtents :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Rectangle, Rectangle)
- layoutGetPixelSize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Int32, Int32)
- layoutGetSerial :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Word32
- layoutGetSingleParagraphMode :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
- layoutGetSize :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Int32, Int32)
- layoutGetSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- layoutGetTabs :: (HasCallStack, MonadIO m, IsLayout a) => a -> m (Maybe TabArray)
- layoutGetText :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Text
- layoutGetUnknownGlyphsCount :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- layoutGetWidth :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Int32
- layoutGetWrap :: (HasCallStack, MonadIO m, IsLayout a) => a -> m WrapMode
- layoutIndexToLineX :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> Bool -> m (Int32, Int32)
- layoutIndexToPos :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m Rectangle
- layoutIsEllipsized :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
- layoutIsWrapped :: (HasCallStack, MonadIO m, IsLayout a) => a -> m Bool
- layoutMoveCursorVisually :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> Int32 -> Int32 -> Int32 -> m (Int32, Int32)
- layoutNew :: (HasCallStack, MonadIO m, IsContext a) => a -> m Layout
- layoutSetAlignment :: (HasCallStack, MonadIO m, IsLayout a) => a -> Alignment -> m ()
- layoutSetAttributes :: (HasCallStack, MonadIO m, IsLayout a) => a -> Maybe AttrList -> m ()
- layoutSetAutoDir :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()
- layoutSetEllipsize :: (HasCallStack, MonadIO m, IsLayout a) => a -> EllipsizeMode -> m ()
- layoutSetFontDescription :: (HasCallStack, MonadIO m, IsLayout a) => a -> Maybe FontDescription -> m ()
- layoutSetHeight :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
- layoutSetIndent :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
- layoutSetJustify :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()
- layoutSetLineSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> Float -> m ()
- layoutSetMarkup :: (HasCallStack, MonadIO m, IsLayout a) => a -> Text -> Int32 -> m ()
- layoutSetSingleParagraphMode :: (HasCallStack, MonadIO m, IsLayout a) => a -> Bool -> m ()
- layoutSetSpacing :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
- layoutSetTabs :: (HasCallStack, MonadIO m, IsLayout a) => a -> Maybe TabArray -> m ()
- layoutSetText :: (HasCallStack, MonadIO m, IsLayout a) => a -> Text -> Int32 -> m ()
- layoutSetWidth :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> m ()
- layoutSetWrap :: (HasCallStack, MonadIO m, IsLayout a) => a -> WrapMode -> m ()
- layoutXyToIndex :: (HasCallStack, MonadIO m, IsLayout a) => a -> Int32 -> Int32 -> m (Bool, Int32, Int32)
Exported types
Memory-managed wrapper type.
Instances
Eq Layout Source # | |
GObject Layout Source # | |
Defined in GI.Pango.Objects.Layout | |
ManagedPtrNewtype Layout Source # | |
Defined in GI.Pango.Objects.Layout Methods toManagedPtr :: Layout -> ManagedPtr Layout | |
TypedObject Layout Source # | |
Defined in GI.Pango.Objects.Layout Methods glibType :: IO GType | |
HasParentTypes Layout Source # | |
Defined in GI.Pango.Objects.Layout | |
IsGValue (Maybe Layout) Source # | Convert |
Defined in GI.Pango.Objects.Layout Methods gvalueGType_ :: IO GType gvalueSet_ :: Ptr GValue -> Maybe Layout -> IO () gvalueGet_ :: Ptr GValue -> IO (Maybe Layout) | |
type ParentTypes Layout Source # | |
Defined in GI.Pango.Objects.Layout type ParentTypes Layout = '[Object] |
class (GObject o, IsDescendantOf Layout o) => IsLayout o Source #
Instances
(GObject o, IsDescendantOf Layout o) => IsLayout o Source # | |
Defined in GI.Pango.Objects.Layout |
Methods
Click to display all available methods, including inherited ones
Methods
bindProperty, bindPropertyFull, contextChanged, copy, forceFloating, freezeNotify, getv, indexToLineX, indexToPos, isEllipsized, isFloating, isWrapped, moveCursorVisually, notify, notifyByPspec, ref, refSink, runDispose, stealData, stealQdata, thawNotify, unref, watchClosure, xyToIndex.
Getters
getAlignment, getAttributes, getAutoDir, getBaseline, getCharacterCount, getContext, getCursorPos, getData, getDirection, getEllipsize, getExtents, getFontDescription, getHeight, getIndent, getIter, getJustify, getLine, getLineCount, getLineReadonly, getLineSpacing, getLines, getLinesReadonly, getLogAttrs, getLogAttrsReadonly, getPixelExtents, getPixelSize, getProperty, getQdata, getSerial, getSingleParagraphMode, getSize, getSpacing, getTabs, getText, getUnknownGlyphsCount, getWidth, getWrap.
Setters
setAlignment, setAttributes, setAutoDir, setData, setDataFull, setEllipsize, setFontDescription, setHeight, setIndent, setJustify, setLineSpacing, setMarkup, setMarkupWithAccel, setProperty, setSingleParagraphMode, setSpacing, setTabs, setText, setWidth, setWrap.
contextChanged
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m () |
Forces recomputation of any state in the PangoLayout
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
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Layout | Returns: the newly allocated |
Creates a deep copy-by-value of the layout.
The attribute list, tab array, and text from the original layout are all copied by value.
getAlignment
Arguments
:: (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
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m (Maybe AttrList) | Returns: a |
Gets the attribute list for the layout, if any.
getAutoDir
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Bool | Returns: |
Gets whether to calculate the base direction for the layout according to its contents.
See [methodpango
.Layout.set_auto_dir].
Since: 1.4
getBaseline
Arguments
:: (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
layoutGetCharacterCount Source #
Arguments
:: (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
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Context | Returns: the |
Retrieves the PangoContext
used for this layout.
getCursorPos
Arguments
:: (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.
getDirection
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m Direction | Returns: the text direction at |
Gets the text direction at the given character position in layout
.
Since: 1.46
getEllipsize
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m EllipsizeMode | Returns: the current ellipsization mode for |
Gets the type of ellipsization being performed for layout
.
See [methodpango
.Layout.set_ellipsize].
Use [methodpango
.Layout.is_ellipsized] to query whether any
paragraphs were actually ellipsized.
Since: 1.6
getExtents
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m (Rectangle, Rectangle) |
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
layoutGetFontDescription Source #
Arguments
:: (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
Arguments
:: (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 [methodpango
.Layout.set_height] for details.
Since: 1.20
getIndent
Arguments
:: (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
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m LayoutIter | Returns: the new |
Returns an iterator to iterate over the visual extents of the layout.
getJustify
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Bool | Returns: the justify value |
Gets whether each complete line should be stretched to fill the entire width of the layout.
getLine
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m (Maybe LayoutLine) | Returns: the requested |
Retrieves a particular line from a PangoLayout
.
Use the faster [methodpango
.Layout.get_line_readonly] if you do not
plan to modify the contents of the line (glyphs, glyph widths, etc.).
getLineCount
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Int32 | Returns: the line count |
Retrieves the count of lines for the layout
.
getLineReadonly
layoutGetLineReadonly Source #
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m (Maybe LayoutLine) | Returns: the requested |
Retrieves a particular line from a PangoLayout
.
This is a faster alternative to [methodpango
.Layout.get_line],
but the user is not expected to modify the contents of the line
(glyphs, glyph widths, etc.).
Since: 1.16
getLineSpacing
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Float |
Gets the line spacing factor of layout
.
See [methodpango
.Layout.set_line_spacing].
Since: 1.44
getLines
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m [LayoutLine] | Returns: a |
Returns the lines of the layout
as a list.
Use the faster [methodpango
.Layout.get_lines_readonly] if you do not
plan to modify the contents of the lines (glyphs, glyph widths, etc.).
getLinesReadonly
layoutGetLinesReadonly Source #
Arguments
:: (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 [methodpango
.Layout.get_lines],
but the user is not expected to modify the contents of the lines
(glyphs, glyph widths, etc.).
Since: 1.16
getLogAttrs
Retrieves an array of logical attributes for each character in
the layout
.
getLogAttrsReadonly
layoutGetLogAttrsReadonly Source #
Arguments
:: (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 [methodpango
.Layout.get_log_attrs].
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
layoutGetPixelExtents Source #
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m (Rectangle, Rectangle) |
Computes the logical and ink extents of layout
in device units.
This function just calls [methodpango
.Layout.get_extents] followed by
two [funcextentsToPixels
] calls, rounding inkRect
and logicalRect
such that the rounded rectangles fully contain the unrounded one (that is,
passes them as first argument to [funcpango
.extents_to_pixels]).
getPixelSize
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m (Int32, Int32) |
Determines the logical width and height of a PangoLayout
in device
units.
- method
pango
.Layout.get_size - returns the width and height
scaled by
SCALE
. This is simply a convenience function around [methodpango
.Layout.get_pixel_extents].
getSerial
Arguments
:: (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 PangoContext
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 PangoLayout
,
and is useful for example to decide whether a layout needs redrawing.
To force the serial to be increased, use
[methodpango
.Layout.context_changed].
Since: 1.32.4
getSingleParagraphMode
layoutGetSingleParagraphMode Source #
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Bool | Returns: |
Obtains whether layout
is in single paragraph mode.
See [methodpango
.Layout.set_single_paragraph_mode].
getSize
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m (Int32, Int32) |
Determines the logical width and height of a PangoLayout
in Pango
units.
This is simply a convenience function around [methodpango
.Layout.get_extents].
getSpacing
Arguments
:: (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
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m (Maybe TabArray) | Returns: a copy of the tabs for this layout |
Gets the current PangoTabArray
used by this layout.
If no PangoTabArray
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 [methodpango
.TabArray.free].
getText
Arguments
:: (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
layoutGetUnknownGlyphsCount Source #
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m Int32 | Returns: The number of unknown glyphs in |
Counts the number of unknown glyphs in layout
.
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
Arguments
:: (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 PangoLayout
should wrap.
getWrap
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> m WrapMode | Returns: active wrap mode. |
Gets the wrap mode for the layout.
Use [methodpango
.Layout.is_wrapped] to query whether
any paragraphs were actually wrapped.
indexToLineX
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> Bool |
|
-> m (Int32, Int32) |
Converts from byte index_
within the layout
to line and X position.
The X position is measured from the left edge of the line.
indexToPos
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m Rectangle |
Converts from an index within a PangoLayout
to the onscreen position
corresponding to the grapheme at that index.
The return value is represented as rectangle. Note that pos->x
is
always the leading edge of the grapheme and pos->x + pos->width
the
trailing edge of the grapheme. If the directionality of the grapheme
is right-to-left, then pos->width
will be negative.
isEllipsized
Arguments
:: (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
Arguments
:: (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 #
Arguments
:: (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 [methodpango
.Layout.move_cursor_visually] may move the cursor over
multiple characters when multiple characters combine to form a single
grapheme.
new
Arguments
:: (HasCallStack, MonadIO m, IsContext a) | |
=> a |
|
-> m Layout | Returns: the newly allocated |
Create a new PangoLayout
object with attributes initialized to
default values for a particular PangoContext
.
setAlignment
Arguments
:: (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
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Maybe AttrList |
|
-> m () |
Sets the text attributes for a layout object.
References attrs
, so the caller can unref its reference.
setAutoDir
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Bool |
|
-> m () |
Sets whether to calculate the base direction for the layout according to its contents.
When this flag is on (the default), then paragraphs in 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
PangoContext
. (See [methodpango
.Context.set_base_dir]).
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
Arguments
:: (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
[methodpango
.Layout.set_width] and [methodpango
.Layout.set_height].
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 [methodpango
.Layout.set_height] for details.
Since: 1.6
setFontDescription
layoutSetFontDescription Source #
Arguments
:: (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
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m () |
Sets the height to which the PangoLayout
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 behavior may be changed in the future to act per layout instead of per
paragraph. File a bug against pango at
https://gitlab.gnome.org/gnome/pango
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
Arguments
:: (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
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Bool |
|
-> m () |
Sets whether each complete line should be stretched to fill the entire width of the layout.
Stretching is typically done by adding whitespace, but for some scripts (such as Arabic), the justification may be done in more complex ways, like extending the characters.
Note that this setting is not implemented and so is ignored in Pango older than 1.18.
setLineSpacing
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Float |
|
-> m () |
Sets a factor for line spacing.
Typical values are: 0, 1, 1.5, 2. The default values is 0.
If factor
is non-zero, lines are placed so that
baseline2 = baseline1 + factor * height2
where height2 is the line height of the second line
(as determined by the font(s)). In this case, the spacing
set with [methodpango
.Layout.set_spacing] is ignored.
If factor
is zero, spacing is applied as before.
Since: 1.44
setMarkup
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Text |
|
-> Int32 |
|
-> m () |
Sets the layout text and attribute list from marked-up text.
See Pango Markup).
Replaces the current text and attribute list.
This is the same as [methodpango
.Layout.set_markup_with_accel],
but the markup text isn't scanned for accelerators.
setSingleParagraphMode
layoutSetSingleParagraphMode Source #
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Bool |
|
-> m () |
Sets the single paragraph mode of layout
.
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
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m () |
Sets the amount of spacing in Pango unit between the lines of the layout.
When placing lines with spacing, Pango arranges things so that
line2.top = line1.bottom + spacing
Note: Since 1.44, Pango defaults to using the line height
(as determined by the font) for placing lines. The spacing
set with this function is only taken into account when the
line height factor is set to zero with
[methodpango
.Layout.set_line_spacing].
setTabs
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Maybe TabArray |
|
-> m () |
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
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Text |
|
-> Int32 |
|
-> m () |
Sets the text of the layout.
This function validates text
and renders invalid UTF-8
with a placeholder glyph.
Note that if you have used [methodpango
.Layout.set_markup] or
[methodpango
.Layout.set_markup_with_accel] on layout
before, you
may want to call [methodpango
.Layout.set_attributes] to clear the
attributes set on the layout from the markup as this function does
not clear attributes.
setWidth
Arguments
:: (HasCallStack, MonadIO m, IsLayout a) | |
=> a |
|
-> Int32 |
|
-> m () |
Sets the width to which the lines of the PangoLayout
should wrap or
ellipsized.
The default value is -1: no width set.
setWrap
Arguments
:: (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 [methodpango
.Layout.set_width]. To turn off wrapping,
set the width to -1.
xyToIndex
Arguments
:: (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 [methodpango
.LayoutLine.x_to_index]. If either
the X or Y positions were not inside the layout, then the function returns
False
; on an exact hit, it returns True
.