Functions
pango_layout_copy ()
PangoLayout *
pango_layout_copy (PangoLayout *src);
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.
pango_layout_get_context ()
PangoContext *
pango_layout_get_context (PangoLayout *layout);
Retrieves the PangoContext used for this layout.
Returns
the PangoContext for the layout.
This does not have an additional refcount added, so if you want to
keep a copy of this around, you must reference it yourself.
[transfer none]
pango_layout_context_changed ()
void
pango_layout_context_changed (PangoLayout *layout);
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.
pango_layout_get_serial ()
guint
pango_layout_get_serial (PangoLayout *layout);
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 pango_layout_context_changed().
Returns
The current serial number of layout
.
Since: 1.32.4
pango_layout_get_text ()
const char *
pango_layout_get_text (PangoLayout *layout);
Gets the text in the layout. The returned text should not
be freed or modified.
Returns
the text in the layout
.
pango_layout_get_character_count ()
gint
pango_layout_get_character_count (PangoLayout *layout);
Returns the number of Unicode characters in the
the text of layout
.
Returns
the number of Unicode characters
in the text of layout
Since: 1.30
pango_layout_set_markup_with_accel ()
void
pango_layout_set_markup_with_accel (PangoLayout *layout,
const char *markup,
int length,
gunichar accel_marker,
gunichar *accel_char);
Sets the layout text and attribute list from marked-up text (see
markup format). Replaces
the current text and attribute list.
If accel_marker
is nonzero, the given character will mark the
character following it as an accelerator. For example, accel_marker
might be an ampersand or underscore. All characters marked
as an accelerator will receive a PANGO_UNDERLINE_LOW attribute,
and the first character so marked will be returned in accel_char
.
Two accel_marker
characters following each other produce a single
literal accel_marker
character.
pango_layout_set_attributes ()
void
pango_layout_set_attributes (PangoLayout *layout,
PangoAttrList *attrs);
Sets the text attributes for a layout object.
References attrs
, so the caller can unref its reference.
pango_layout_get_attributes ()
PangoAttrList *
pango_layout_get_attributes (PangoLayout *layout);
Gets the attribute list for the layout, if any.
pango_layout_set_font_description ()
void
pango_layout_set_font_description (PangoLayout *layout,
const PangoFontDescription *desc);
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.
pango_layout_get_font_description ()
const PangoFontDescription *
pango_layout_get_font_description (PangoLayout *layout);
Gets the font description for the layout, if any.
Returns
a pointer to the layout's font
description, or NULL if the font description from the layout's
context is inherited. This value is owned by the layout and must
not be modified or freed.
[nullable]
Since: 1.8
pango_layout_set_width ()
void
pango_layout_set_width (PangoLayout *layout,
int width);
Sets the width to which the lines of the PangoLayout should wrap or
ellipsized. The default value is -1: no width set.
pango_layout_get_width ()
int
pango_layout_get_width (PangoLayout *layout);
Gets the width to which the lines of the PangoLayout should wrap.
Returns
the width in Pango units, or -1 if no width set.
pango_layout_set_height ()
void
pango_layout_set_height (PangoLayout *layout,
int height);
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 behvaior may be changed in the future to act per layout instead of per
paragraph. File a bug against pango at http://bugzilla.gnome.org/ 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 PANGO_ELLIPSIZE_NONE.
The behavior is undefined if a height other than -1 is set and
ellipsization mode is set to PANGO_ELLIPSIZE_NONE, and may change in the
future.
Since: 1.20
pango_layout_get_height ()
int
pango_layout_get_height (PangoLayout *layout);
Gets the height of layout used for ellipsization. See
pango_layout_set_height() for details.
Returns
the height, in Pango units if positive, or
number of lines if negative.
Since: 1.20
pango_layout_set_wrap ()
void
pango_layout_set_wrap (PangoLayout *layout,
PangoWrapMode wrap);
Sets the wrap mode; the wrap mode only has effect if a width
is set on the layout with pango_layout_set_width().
To turn off wrapping, set the width to -1.
pango_layout_is_wrapped ()
gboolean
pango_layout_is_wrapped (PangoLayout *layout);
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 PANGO_ELLIPSIZE_NONE,
and there are paragraphs exceeding the layout width that have
to be wrapped.
Returns
TRUE if any paragraphs had to be wrapped, FALSE
otherwise.
Since: 1.16
pango_layout_set_ellipsize ()
void
pango_layout_set_ellipsize (PangoLayout *layout,
PangoEllipsizeMode ellipsize);
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
pango_layout_set_width() and pango_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 pango_layout_set_height() for details.
Since: 1.6
pango_layout_is_ellipsized ()
gboolean
pango_layout_is_ellipsized (PangoLayout *layout);
Queries whether the layout had to ellipsize any paragraphs.
This returns TRUE if the ellipsization mode for layout
is not PANGO_ELLIPSIZE_NONE, a positive width is set on layout
,
and there are paragraphs exceeding that width that have to be
ellipsized.
Returns
TRUE if any paragraphs had to be ellipsized, FALSE
otherwise.
Since: 1.16
pango_layout_set_indent ()
void
pango_layout_set_indent (PangoLayout *layout,
int indent);
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
PANGO_ALIGN_CENTER.
pango_layout_get_indent ()
int
pango_layout_get_indent (PangoLayout *layout);
Gets the paragraph indent width in Pango units. A negative value
indicates a hanging indentation.
Returns
the indent in Pango units.
pango_layout_get_spacing ()
int
pango_layout_get_spacing (PangoLayout *layout);
Gets the amount of spacing between the lines of the layout.
Returns
the spacing in Pango units.
pango_layout_set_spacing ()
void
pango_layout_set_spacing (PangoLayout *layout,
int spacing);
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 pango_layout_set_line_spacing().
pango_layout_set_line_spacing ()
void
pango_layout_set_line_spacing (PangoLayout *layout,
float factor);
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
pango_layout_set_spacing() is ignored.
If factor
is zero, spacing is applied as
before.
Since: 1.44
pango_layout_set_justify ()
void
pango_layout_set_justify (PangoLayout *layout,
gboolean justify);
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.
pango_layout_get_justify ()
gboolean
pango_layout_get_justify (PangoLayout *layout);
Gets whether each complete line should be stretched to fill the entire
width of the layout.
pango_layout_set_auto_dir ()
void
pango_layout_set_auto_dir (PangoLayout *layout,
gboolean auto_dir);
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 PangoContext. (See pango_context_set_base_dir()).
When the auto-computed direction of a paragraph differs from the
base direction of the context, the interpretation of
PANGO_ALIGN_LEFT and PANGO_ALIGN_RIGHT are swapped.
Since: 1.4
pango_layout_get_auto_dir ()
gboolean
pango_layout_get_auto_dir (PangoLayout *layout);
Gets whether to calculate the bidirectional base direction
for the layout according to the contents of the layout.
See pango_layout_set_auto_dir().
Returns
TRUE if the bidirectional base direction
is computed from the layout's contents, FALSE otherwise.
Since: 1.4
pango_layout_set_alignment ()
void
pango_layout_set_alignment (PangoLayout *layout,
PangoAlignment alignment);
Sets the alignment for the layout: how partial lines are
positioned within the horizontal space available.
pango_layout_get_alignment ()
PangoAlignment
pango_layout_get_alignment (PangoLayout *layout);
Gets the alignment for the layout: how partial lines are
positioned within the horizontal space available.
pango_layout_set_tabs ()
void
pango_layout_set_tabs (PangoLayout *layout,
PangoTabArray *tabs);
Sets the tabs to use for layout
, overriding the default tabs
(by default, tabs are every 8 spaces). If tabs
is NULL, the default
tabs are reinstated. tabs
is copied into the layout; you must
free your copy of tabs
yourself.
pango_layout_set_single_paragraph_mode ()
void
pango_layout_set_single_paragraph_mode
(PangoLayout *layout,
gboolean setting);
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.
pango_layout_get_unknown_glyphs_count ()
int
pango_layout_get_unknown_glyphs_count (PangoLayout *layout);
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 PANGO_ATTR_FALLBACK, to check if a
certain font supports all the characters in the string.
Returns
The number of unknown glyphs in layout
.
Since: 1.16
pango_layout_get_log_attrs ()
void
pango_layout_get_log_attrs (PangoLayout *layout,
PangoLogAttr **attrs,
gint *n_attrs);
Retrieves an array of logical attributes for each character in
the layout
.
pango_layout_get_log_attrs_readonly ()
const PangoLogAttr *
pango_layout_get_log_attrs_readonly (PangoLayout *layout,
gint *n_attrs);
Retrieves an array of logical attributes for each character in
the layout
.
This is a faster alternative to pango_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 n_attrs
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.
Returns
an array of logical attributes.
[array length=n_attrs]
Since: 1.30
pango_layout_index_to_pos ()
void
pango_layout_index_to_pos (PangoLayout *layout,
int index_,
PangoRectangle *pos);
Converts from an index within a PangoLayout to the onscreen position
corresponding to the grapheme at that index, which 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.
pango_layout_index_to_line_x ()
void
pango_layout_index_to_line_x (PangoLayout *layout,
int index_,
gboolean trailing,
int *line,
int *x_pos);
Converts from byte index_
within the layout
to line and X position.
(X position is measured from the left edge of the line)
pango_layout_xy_to_index ()
gboolean
pango_layout_xy_to_index (PangoLayout *layout,
int x,
int y,
int *index_,
int *trailing);
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 pango_layout_line_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.
Returns
TRUE if the coordinates were inside text, FALSE otherwise.
pango_layout_get_cursor_pos ()
void
pango_layout_get_cursor_pos (PangoLayout *layout,
int index_,
PangoRectangle *strong_pos,
PangoRectangle *weak_pos);
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.
pango_layout_move_cursor_visually ()
void
pango_layout_move_cursor_visually (PangoLayout *layout,
gboolean strong,
int old_index,
int old_trailing,
int direction,
int *new_index,
int *new_trailing);
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 pango_layout_move_cursor_visually() may move the
cursor over multiple characters when multiple characters combine
to form a single grapheme.
pango_layout_get_extents ()
void
pango_layout_get_extents (PangoLayout *layout,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
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.
pango_layout_get_baseline ()
int
pango_layout_get_baseline (PangoLayout *layout);
Gets the Y position of baseline of the first line in layout
.
Returns
baseline of first line, from top of layout
.
Since: 1.22
pango_layout_get_line_count ()
int
pango_layout_get_line_count (PangoLayout *layout);
Retrieves the count of lines for the layout
.
pango_layout_get_line_readonly ()
PangoLayoutLine *
pango_layout_get_line_readonly (PangoLayout *layout,
int line);
Retrieves a particular line from a PangoLayout.
This is a faster alternative to pango_layout_get_line(),
but the user is not expected
to modify the contents of the line (glyphs, glyph widths, etc.).
Returns
the requested
PangoLayoutLine, or NULL if the index is out of
range. This layout line can be ref'ed and retained,
but will become invalid if changes are made to the
PangoLayout. No changes should be made to the line.
[transfer none][nullable]
Since: 1.16
pango_layout_get_lines ()
GSList *
pango_layout_get_lines (PangoLayout *layout);
Returns the lines of the layout
as a list.
Use the faster pango_layout_get_lines_readonly() if you do not plan
to modify the contents of the lines (glyphs, glyph widths, etc.).
Returns
a GSList containing
the lines in the layout. This points to internal data of the PangoLayout
and must be used with care. It will become invalid on any change to the layout's
text or properties.
[element-type Pango.LayoutLine][transfer none]
pango_layout_get_lines_readonly ()
GSList *
pango_layout_get_lines_readonly (PangoLayout *layout);
Returns the lines of the layout
as a list.
This is a faster alternative to pango_layout_get_lines(),
but the user is not expected
to modify the contents of the lines (glyphs, glyph widths, etc.).
Returns
a GSList containing
the lines in the layout. This points to internal data of the PangoLayout and
must be used with care. It will become invalid on any change to the layout's
text or properties. No changes should be made to the lines.
[element-type Pango.LayoutLine][transfer none]
Since: 1.16
pango_layout_get_iter ()
PangoLayoutIter *
pango_layout_get_iter (PangoLayout *layout);
Returns an iterator to iterate over the visual extents of the layout.
pango_layout_iter_free ()
void
pango_layout_iter_free (PangoLayoutIter *iter);
Frees an iterator that's no longer in use.
pango_layout_iter_next_run ()
gboolean
pango_layout_iter_next_run (PangoLayoutIter *iter);
Moves iter
forward to the next run in visual order. If iter
was
already at the end of the layout, returns FALSE.
Returns
whether motion was possible.
pango_layout_iter_next_char ()
gboolean
pango_layout_iter_next_char (PangoLayoutIter *iter);
Moves iter
forward to the next character in visual order. If iter
was already at
the end of the layout, returns FALSE.
Returns
whether motion was possible.
pango_layout_iter_next_cluster ()
gboolean
pango_layout_iter_next_cluster (PangoLayoutIter *iter);
Moves iter
forward to the next cluster in visual order. If iter
was already at the end of the layout, returns FALSE.
Returns
whether motion was possible.
pango_layout_iter_next_line ()
gboolean
pango_layout_iter_next_line (PangoLayoutIter *iter);
Moves iter
forward to the start of the next line. If iter
is
already on the last line, returns FALSE.
Returns
whether motion was possible.
pango_layout_iter_at_last_line ()
gboolean
pango_layout_iter_at_last_line (PangoLayoutIter *iter);
Determines whether iter
is on the last line of the layout.
Returns
TRUE if iter
is on the last line.
pango_layout_iter_get_index ()
int
pango_layout_iter_get_index (PangoLayoutIter *iter);
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 NULL run (see pango_layout_iter_get_run()).
Returns
current byte index.
pango_layout_iter_get_baseline ()
int
pango_layout_iter_get_baseline (PangoLayoutIter *iter);
Gets the Y position of the current line's baseline, in layout
coordinates (origin at top left of the entire layout).
Returns
baseline of current line.
pango_layout_iter_get_run ()
PangoLayoutRun *
pango_layout_iter_get_run (PangoLayoutIter *iter);
Gets the current run. When iterating by run, at the end of each
line, there's a position with a NULL run, so this function can return
NULL. The NULL 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 pango_layout_iter_get_run_readonly() if you do not plan
to modify the contents of the run (glyphs, glyph widths, etc.).
Returns
the current run.
[transfer none][nullable]
pango_layout_iter_get_run_readonly ()
PangoLayoutRun *
pango_layout_iter_get_run_readonly (PangoLayoutIter *iter);
Gets the current run. When iterating by run, at the end of each
line, there's a position with a NULL run, so this function can return
NULL. The NULL 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 pango_layout_iter_get_run(),
but the user is not expected
to modify the contents of the run (glyphs, glyph widths, etc.).
Returns
the current run, that
should not be modified.
[transfer none][nullable]
Since: 1.16
pango_layout_iter_get_line_readonly ()
PangoLayoutLine *
pango_layout_iter_get_line_readonly (PangoLayoutIter *iter);
Gets the current line for read-only access.
This is a faster alternative to pango_layout_iter_get_line(),
but the user is not expected
to modify the contents of the line (glyphs, glyph widths, etc.).
Returns
the current line, that should not be
modified.
[transfer none]
Since: 1.16
pango_layout_iter_get_char_extents ()
void
pango_layout_iter_get_char_extents (PangoLayoutIter *iter,
PangoRectangle *logical_rect);
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.
pango_layout_iter_get_cluster_extents ()
void
pango_layout_iter_get_cluster_extents (PangoLayoutIter *iter,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
Gets the extents of the current cluster, in layout coordinates
(origin is the top left of the entire layout).
pango_layout_iter_get_run_extents ()
void
pango_layout_iter_get_run_extents (PangoLayoutIter *iter,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
Gets the extents of the current run in layout coordinates
(origin is the top left of the entire layout).
pango_layout_iter_get_line_yrange ()
void
pango_layout_iter_get_line_yrange (PangoLayoutIter *iter,
int *y0_,
int *y1_);
Divides the vertical space in the PangoLayout 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
pango_layout_set_spacing() has been called to set layout spacing.
The Y positions are in layout coordinates (origin at top left of the
entire layout).
Note: Since 1.44, Pango uses line heights for placing lines,
and there may be gaps between the ranges returned by this
function.
pango_layout_iter_get_line_extents ()
void
pango_layout_iter_get_line_extents (PangoLayoutIter *iter,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
Obtains the extents of the current line. ink_rect
or logical_rect
can be NULL if you aren't interested in them. Extents are in layout
coordinates (origin is the top-left corner of the entire
PangoLayout). 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 pango_layout_line_get_extents().
pango_layout_iter_get_layout_extents ()
void
pango_layout_iter_get_layout_extents (PangoLayoutIter *iter,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
Obtains the extents of the PangoLayout being iterated
over. ink_rect
or logical_rect
can be NULL if you
aren't interested in them.
pango_layout_line_unref ()
void
pango_layout_line_unref (PangoLayoutLine *line);
Decrease the reference count of a PangoLayoutLine by one.
If the result is zero, the line and all associated memory
will be freed.
pango_layout_line_index_to_x ()
void
pango_layout_line_index_to_x (PangoLayoutLine *line,
int index_,
gboolean trailing,
int *x_pos);
Converts an index within a line to a X position.
pango_layout_line_x_to_index ()
gboolean
pango_layout_line_x_to_index (PangoLayoutLine *line,
int x_pos,
int *index_,
int *trailing);
Converts from x offset to the byte index of the corresponding
character within the text of the layout. If x_pos
is outside the line,
index_
and trailing
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 index_
and trailing
. An X position to the
left of the line results in index_
pointing to the (logical) last
grapheme in the line and trailing
being set to the number of characters
in that grapheme. The reverse is true for a left-to-right line.
Returns
FALSE if x_pos
was outside the line, TRUE if inside
pango_layout_line_get_x_ranges ()
void
pango_layout_line_get_x_ranges (PangoLayoutLine *line,
int start_index,
int end_index,
int **ranges,
int *n_ranges);
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.
pango_layout_line_get_height ()
void
pango_layout_line_get_height (PangoLayoutLine *line,
int *height);
Computes the height of the line, ie the distance between
this and the previous lines baseline.
Since: 1.44