Creates a binding between source_property on source and target_property
on target.
Whenever the source_property is changed the target_property is
updated using the same value. For instance:
g_object_bind_property (action, "active", widget, "sensitive", 0);
Will result in the "sensitive" property of the widget #GObject instance to be updated with the same value of the "active" property of the action #GObject instance.
If flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
if target_property on target changes then the source_property on source
will be updated as well.
The binding will automatically be removed when either the source or the
target instances are finalized. To remove the binding without affecting the
source and the target you can just call g_object_unref() on the returned
#GBinding instance.
Removing the binding by calling g_object_unref() on it must only be done if
the binding, source and target are only used from a single thread and it
is clear that both source and target outlive the binding. Especially it
is not safe to rely on this if the binding, source or target can be
finalized from different threads. Keep another reference to the binding and
use g_binding_unbind() instead to be on the safe side.
A #GObject can have multiple bindings.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
Creates a binding between source_property on source and target_property
on target, allowing you to set the transformation functions to be used by
the binding.
This function is the language bindings friendly version of g_object_bind_property_full(), using #GClosures instead of function pointers.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
a #GClosure wrapping the transformation function from the source to the target, or %NULL to use the default
a #GClosure wrapping the transformation function from the target to the source, or %NULL to use the default
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.
This function is intended for #GObject implementations to re-enforce a [floating][floating-ref] object reference. Doing this is seldom required: all #GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling g_object_ref_sink().
Increases the freeze count on object. If the freeze count is
non-zero, the emission of "notify" signals on object is
stopped. The signals are queued until the freeze count is decreased
to zero. Duplicate notifications are squashed so that at most one
#GObject::notify signal is emitted for each property modified while the
object is frozen.
This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified.
Gets whether to calculate the base direction for the layout according to its contents.
See [methodPango.Layout.set_auto_dir].
Gets the Y position of baseline of the first line in layout.
Given an index within a layout, determines the positions that of the strong and weak cursors if the insertion point is at that index.
This is a variant of [methodPango.Layout.get_cursor_pos] that applies
font metric information about caret slope and offset to the positions
it returns.
the byte index of the cursor
Returns the number of Unicode characters in the
the text of layout.
Given an index within a layout, determines the positions that of the strong and weak cursors if the insertion point is at that index.
The position of each cursor is stored as a zero-width rectangle with the height of the run extents.
The strong cursor location is the location where characters of the directionality equal to the base direction of the layout are inserted. The weak cursor location is the location where characters of the directionality opposite to the base direction of the layout are inserted.
The following example shows text with both a strong and a weak cursor.
The strong cursor has a little arrow pointing to the right, the weak cursor to the left. Typing a 'c' in this situation will insert the character after the 'b', and typing another Hebrew character, like '×’', will insert it at the end.
the byte index of the cursor
Gets a named field from the objects table of associations (see g_object_set_data()).
name of the key for that association
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.
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.
Gets the font description for the layout, if any.
Gets the height of layout used for ellipsization.
See [methodPango.Layout.set_height] for details.
Gets the paragraph indent width in Pango units.
A negative value indicates a hanging indentation.
Returns an iterator to iterate over the visual extents of the layout.
Gets whether each complete line should be stretched to fill the entire width of the layout.
Gets whether the last line should be stretched to fill the entire width of the layout.
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.).
the index of a line, which must be between 0 and pango_layout_get_line_count(layout) - 1, inclusive.
Retrieves the count of lines for the layout.
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.).
the index of a line, which must be between 0 and pango_layout_get_line_count(layout) - 1, inclusive.
Gets the line spacing factor of layout.
See [methodPango.Layout.set_line_spacing].
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.).
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.).
Retrieves an array of logical attributes for each character in
the layout.
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 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.
Computes the logical and ink extents of layout in device units.
This function just calls [methodPango.Layout.get_extents] followed by
two [funcextents_to_pixels] calls, rounding ink_rect and logical_rect
such that the rounded rectangles fully contain the unrounded one (that is,
passes them as first argument to [funcPango.extents_to_pixels]).
Determines the logical width and height of a PangoLayout in device
units.
[methodPango.Layout.get_size] returns the width and height
scaled by %PANGO_SCALE. This is simply a convenience function
around [methodPango.Layout.get_pixel_extents].
Gets a property of an object.
The value can be:
In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling g_value_unset().
Note that g_object_get_property() is really intended for language bindings, g_object_get() is much more convenient for C programming.
the name of the property to get
return location for the property value
This function gets back user data pointers stored via g_object_set_qdata().
A #GQuark, naming the user data pointer
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].
Obtains whether layout is in single paragraph mode.
See [methodPango.Layout.set_single_paragraph_mode].
Determines the logical width and height of a PangoLayout in Pango
units.
This is simply a convenience function around [methodPango.Layout.get_extents].
Gets the amount of spacing between the lines of the layout.
Gets the current PangoTabArray used by this layout.
If no PangoTabArray has been set, then the default tabs are
in use and %NULL is returned. Default tabs are every 8 spaces.
The return value should be freed with [methodPango.TabArray.free].
Gets the text in the layout.
The returned text should not be freed or modified.
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 %PANGO_ATTR_FALLBACK, to check if a certain font supports all the characters in the string.
Gets the width to which the lines of the PangoLayout should wrap.
Gets n_properties properties for an object.
Obtained properties will be set to values. All properties must be valid.
Warnings will be emitted and undefined behaviour may result if invalid
properties are passed in.
the names of each property to get
the values of each property to get
Converts from byte index_ within the layout to line and X position.
The X position is measured from the left edge of the line.
the byte index of a grapheme within the layout
an integer indicating the edge of the grapheme to retrieve the position of. If > 0, the trailing edge of the grapheme, if 0, the leading of the grapheme
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.
byte index within 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.
Checks whether object has a [floating][floating-ref] reference.
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.
Computes a new cursor position from an old position and a direction.
If direction is positive, then the new position will cause the strong
or weak cursor to be displayed one position to right of where it was
with the old cursor position. If direction is negative, it will be
moved to the left.
In the presence of bidirectional text, the correspondence between logical and visual order will depend on the direction of the current run, and there may be jumps when the cursor is moved off of the end of a run.
Motion here is in cursor positions, not in characters, so a single call to this function may move the cursor over multiple characters when multiple characters combine to form a single grapheme.
whether the moving cursor is the strong cursor or the weak cursor. The strong cursor is the cursor corresponding to text insertion in the base direction for the layout.
the byte index of the current cursor position
if 0, the cursor was at the leading edge of the grapheme indicated by old_index, if > 0, the cursor was at the trailing edge.
direction to move cursor. A negative value indicates motion to the left
Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.
Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.
the name of a property installed on the class of object.
Emits a "notify" signal for the property specified by pspec on object.
This function omits the property name lookup, hence it is faster than g_object_notify().
One way to avoid using g_object_notify() from within the class that registered the properties, and using g_object_notify_by_pspec() instead, is to store the GParamSpec used with g_object_class_install_property() inside a static array, e.g.:
enum
{
PROP_0,
PROP_FOO,
PROP_LAST
};
static GParamSpec *properties[PROP_LAST];
static void
my_object_class_init (MyObjectClass *klass)
{
properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
0, 100,
50,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class,
PROP_FOO,
properties[PROP_FOO]);
}
and then notify a change on the "foo" property with:
g_object_notify_by_pspec (self, properties[PROP_FOO]);
the #GParamSpec of a property installed on the class of object.
Increase the reference count of object, and possibly remove the
[floating][floating-ref] reference, if object has a floating reference.
In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one.
Since GLib 2.56, the type of object will be propagated to the return type
under the same conditions as for g_object_ref().
Releases all references to other objects. This can be used to break reference cycles.
This function should only be called from object system implementations.
Serializes the layout for later deserialization via [funcPango.Layout.deserialize].
There are no guarantees about the format of the output across different
versions of Pango and [funcPango.Layout.deserialize] will reject data
that it cannot parse.
The intended use of this function is testing, benchmarking and debugging. The format is not meant as a permanent storage format.
PangoLayoutSerializeFlags
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 %PANGO_ALIGN_LEFT and %PANGO_ALIGN_RIGHT are swapped.
if %TRUE, compute the bidirectional base direction from the layout's contents
Each object carries around a table of associations from strings to pointers. This function lets you set an association.
If the object already had an association with that name, the old association will be destroyed.
Internally, the key is converted to a #GQuark using g_quark_from_string().
This means a copy of key is kept permanently (even after object has been
finalized) — so it is recommended to only use a small, bounded set of values
for key in your program, to avoid the #GQuark storage growing unbounded.
name of the key
data to associate with that key
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.
The default value is %PANGO_ELLIPSIZE_NONE.
See [methodPango.Layout.set_height] for details.
the new ellipsization mode for layout
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.
the new PangoFontDescription to unset the current font description
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 the first line of each paragraph is ellipsized.
This behavior may be changed in the future to act per layout instead of per
paragraph. File a bug against pango at
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 %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.
the desired height of the layout in Pango units if positive, or desired number of lines if negative.
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.
The default value is 0.
the amount by which to indent
Sets whether each complete line should be stretched to fill the entire width of the layout.
Stretching is typically done by adding whitespace, but for some scripts (such as Arabic), the justification may be done in more complex ways, like extending the characters.
Note that this setting is not implemented and so is ignored in Pango older than 1.18.
Note that tabs and justification conflict with each other: Justification will move content away from its tab-aligned positions.
The default value is %FALSE.
Also see [methodPango.Layout.set_justify_last_line].
whether the lines in the layout should be justified
Sets whether the last line should be stretched to fill the entire width of the layout.
This only has an effect if [methodPango.Layout.set_justify] has
been called as well.
The default value is %FALSE.
whether the last line in the layout should be justified
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 (the default), spacing is applied as before.
Note: for semantics that are closer to the CSS line-height
property, see [funcPango.attr_line_height_new].
the new line spacing factor
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.
marked-up text
length of marked-up text in bytes, or -1 if markup is NUL-terminated
Sets the layout text and attribute list from marked-up text.
See Pango Markup).
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.
marked-up text (see Pango Markup)
length of marked-up text in bytes, or -1 if markup is NUL-terminated
marker for accelerators in the text
Sets a property on an object.
the name of the property to set
the value
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.
The default value is %FALSE.
new setting
Sets the amount of spacing in Pango units between the lines of the layout.
When placing lines with spacing, Pango arranges things so that
line2.top = line1.bottom + spacing
The default value is 0.
Note: Since 1.44, Pango is using the line height (as determined
by the font) for placing lines when the line spacing factor is set
to a non-zero value with [methodPango.Layout.set_line_spacing].
In that case, the spacing set with this function is ignored.
Note: for semantics that are closer to the CSS line-height
property, see [funcPango.attr_line_height_new].
the amount of spacing
Sets the tabs to use for layout, overriding the default tabs.
PangoLayout will place content at the next tab position
whenever it meets a Tab character (U+0009).
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.
Note that tabs and justification conflict with each other: Justification will move content away from its tab-aligned positions. The same is true for alignments other than %PANGO_ALIGN_LEFT.
a PangoTabArray
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.
the text
maximum length of text, in bytes. -1 indicates that the string is nul-terminated and the length should be calculated. The text will also be truncated on encountering a nul-termination even when length is positive.
Sets the width to which the lines of the PangoLayout should wrap or
ellipsized.
The default value is -1: no width set.
the desired width in Pango units, or -1 to indicate that no wrapping or ellipsization should be performed.
Remove a specified datum from the object's data associations, without invoking the association's destroy handler.
name of the key
This function gets back user data pointers stored via
g_object_set_qdata() and removes the data from object
without invoking its destroy() function (if any was
set).
Usually, calling this function is only required to update
user data pointers with a destroy notifier, for example:
void
object_add_to_user_list (GObject *object,
const gchar *new_string)
{
// the quark, naming the object data
GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
// retrieve the old string list
GList *list = g_object_steal_qdata (object, quark_string_list);
// prepend new string
list = g_list_prepend (list, g_strdup (new_string));
// this changed 'list', so we need to set it again
g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
}
static void
free_string_list (gpointer data)
{
GList *node, *list = data;
for (node = list; node; node = node->next)
g_free (node->data);
g_list_free (list);
}
Using g_object_get_qdata() in the above example, instead of g_object_steal_qdata() would have left the destroy function set, and thus the partial string list would have been freed upon g_object_set_qdata_full().
A #GQuark, naming the user data pointer
Reverts the effect of a previous call to
g_object_freeze_notify(). The freeze count is decreased on object
and when it reaches zero, queued "notify" signals are emitted.
Duplicate notifications for each property are squashed so that at most one #GObject::notify signal is emitted for each property, in the reverse order in which they have been queued.
It is an error to call this function when the freeze count is zero.
Decreases the reference count of object. When its reference count
drops to 0, the object is finalized (i.e. its memory is freed).
If the pointer to the #GObject may be reused in future (for example, if it is an instance variable of another object), it is recommended to clear the pointer to %NULL rather than retain a dangling pointer to a potentially invalid #GObject instance. Use g_clear_object() for this.
Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.
Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.
This function essentially limits the life time of the closure to
the life time of the object. That is, when the object is finalized,
the closure is invalidated by calling g_closure_invalidate() on
it, in order to prevent invocations of the closure with a finalized
(nonexisting) object. Also, g_object_ref() and g_object_unref() are
added as marshal guards to the closure, to ensure that an extra
reference count is held on object during invocation of the
closure. Usually, this function will be called on closures that
use this object as closure data.
#GClosure to watch
A convenience method to serialize a layout to a file.
It is equivalent to calling [methodPango.Layout.serialize]
followed by [funcGLib.file_set_contents].
See those two functions for details on the arguments.
It is mostly intended for use inside a debugger to quickly dump a layout to a file for later inspection.
PangoLayoutSerializeFlags
the file to save it to
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.
the X offset (in Pango units) from the left edge of the layout
the Y offset (in Pango units) from the top edge of the layout
Loads data previously created via [methodPango.Layout.serialize].
For a discussion of the supported format, see that function.
Note: to verify that the returned layout is identical to
the one that was serialized, you can compare bytes to the
result of serializing the layout again.
a PangoContext
the bytes containing the data
PangoLayoutDeserializeFlags
Find the #GParamSpec with the given name for an
interface. Generally, the interface vtable passed in as g_iface
will be the default vtable from g_type_default_interface_ref(), or,
if you know the interface has already been loaded,
g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
name of a property to look up.
Add a property to an interface; this is only useful for interfaces that are added to GObject-derived types. Adding a property to an interface forces all objects classes with that interface to have a compatible property. The compatible property could be a newly created #GParamSpec, but normally g_object_class_override_property() will be used so that the object class only needs to provide an implementation and inherits the property description, default value, bounds, and so forth from the interface property.
This function is meant to be called from the interface's default
vtable initialization function (the class_init member of
#GTypeInfo.) It must not be called after after class_init has
been called for any object types implementing this interface.
If pspec is a floating reference, it will be consumed.
any interface vtable for the interface, or the default vtable for the interface.
the #GParamSpec for the new property
Lists the properties of an interface.Generally, the interface
vtable passed in as g_iface will be the default vtable from
g_type_default_interface_ref(), or, if you know the interface has
already been loaded, g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
Creates a new instance of a #GObject subtype and sets its properties.
Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values.
the type id of the #GObject subtype to instantiate
an array of #GParameter
A
PangoLayoutstructure 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.
PangoLayoutprovides 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
PangoLayoutis initialized with aPangoContext, 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):The following images demonstrate the effect of alignment and justification on the layout of text:
It is possible, as well, to ignore the 2-D setup, and simply treat the results of a
PangoLayoutas a list of lines.