pyglet.text.layout

Render simple text and formatted documents efficiently.

Three layout classes are provided:

TextLayout

The entire document is laid out before it is rendered. The layout will be grouped with other layouts in the same batch (allowing for efficient rendering of multiple layouts).

Any change to the layout or document, and even querying some properties, will cause the entire document to be laid out again.

ScrollableTextLayout

Based on TextLayout().

A separate group is used for layout which crops the contents of the layout to the layout rectangle. Additionally, the contents of the layout can be “scrolled” within that rectangle with the view_x and view_y properties.

IncrementalTextLayout

Based on ScrollableTextLayout.

When the layout or document are modified, only the affected regions are laid out again. This permits efficient interactive editing and styling of text.

Only the visible portion of the layout is actually rendered; as the viewport is scrolled additional sections are rendered and discarded as required. This permits efficient viewing and editing of large documents.

Additionally, this class provides methods for locating the position of a caret in the document, and for displaying interactive text selections.

All three layout classes can be used with either UnformattedDocument or FormattedDocument, and can be either single-line or multiline. The combinations of these options effectively provides 12 different text display possibilities.

Style attributes

The following character style attribute names are recognised by the layout classes. Data types and units are as specified.

Where an attribute is marked “as a distance” the value is assumed to be in pixels if given as an int or float, otherwise a string of the form "0u" is required, where 0 is the distance and u is the unit; one of "px" (pixels), "pt" (points), "pc" (picas), "cm" (centimeters), "mm" (millimeters) or "in" (inches). For example, "14pt" is the distance covering 14 points, which at the default DPI of 96 is 18 pixels.

font_name: Font family name, as given to pyglet.font.load().
font_size: Font size, in points.
weight: String.
italic: Boolean.
underline: 4-tuple of ints in range (0, 255) giving RGBA underline color, or None (default) for no underline.
kerning: Additional space to insert between glyphs, as a distance. Defaults to 0.
baseline: Offset of glyph baseline from line baseline, as a distance. Positive values give a superscript, negative values give a subscript. Defaults to 0.
color: 4-tuple of ints in range (0, 255) giving RGBA text color
background_color: 4-tuple of ints in range (0, 255) giving RGBA text background color; or None for no background fill.

The following paragraph style attribute names are recognised. Note that paragraph styles are handled no differently from character styles by the document: it is the application’s responsibility to set the style over an entire paragraph, otherwise results are undefined.

align: left (default), center or right.
indent: Additional horizontal space to insert before the first glyph of the first line of a paragraph, as a distance.
leading: Additional space to insert between consecutive lines within a paragraph, as a distance. Defaults to 0.
line_spacing: Distance between consecutive baselines in a paragraph, as a distance. Defaults to None, which automatically calculates the tightest line spacing for each line based on the font ascent and descent.
margin_left: Left paragraph margin, as a distance.
margin_right: Right paragraph margin, as a distance.
margin_top: Margin above paragraph, as a distance.
margin_bottom: Margin below paragraph, as a distance. Adjacent margins do not collapse.
tab_stops: List of horizontal tab stops, as distances, measured from the left edge of the text layout. Defaults to the empty list. When the tab stops are exhausted, they implicitly continue at 50 pixel intervals.
wrap: char, word, True (default) or False. The boundaries at which to wrap text to prevent it overflowing a line. With char, the line wraps anywhere in the text; with word or True, the line wraps at appropriate boundaries between words; with False the line does not wrap, and may overflow the layout width.

Other attributes can be used to store additional style information within the document; they will be ignored by the built-in text classes.

class IncrementalTextDecorationGroup

scissor_area: ClassVar[tuple[int, int, int, int]] = (0, 0, 0, 0)

class IncrementalTextLayout

Displayed text suitable for interactive editing and/or scrolling large documents.

Unlike TextLayout() and ScrollableTextLayout, this class generates vertex lists only for lines of text that are visible. As the document is scrolled, vertex lists are deleted and created as appropriate to keep video memory usage to a minimum and improve rendering speed.

Changes to the document are quickly reflected in this layout, as only the affected line(s) are reflowed. Use begin_update() and end_update() to further reduce the amount of processing required.

The layout can also display a text selection (text with a different background color). The Caret class implements a visible text cursor and provides event handlers for scrolling, selecting and editing text in an incremental text layout.

Class Variables:

group_class (ClassVar[type[IncrementalTextLayoutGroup]]) – Default group used to set the state for all glyphs.
decoration_class (ClassVar[type[IncrementalTextDecorationGroup]]) – Default group used to set the state for all decorations including background colors and underlines.

__init__( document: AbstractDocument, x: float = 0, y: float = 0, z: float = 0, width: int = None, height: int = None, anchor_x: AnchorX = 'left', anchor_y: AnchorY = 'bottom', rotation: float = 0, multiline: bool = False, dpi: float | None = None, batch: Batch | None = None, group: Group | None = None, program: ShaderProgram | None = None, wrap_lines: bool = True, ) → None

Create a text layout.

Parameters:

document (AbstractDocument) – Document to display.
x (float) – X coordinate of the label.
y (float) – Y coordinate of the label.
z (float) – Z coordinate of the label.
width (int) – Width of the layout in pixels, or None
height (int) – Height of the layout in pixels, or None
anchor_x (AnchorX) – Anchor point of the X coordinate.
anchor_y (AnchorY) – Anchor point of the Y coordinate.
rotation (float) – The amount to rotate the label in degrees. A positive amount will be a clockwise rotation, negative values will result in counter-clockwise rotation.
multiline (bool) – If False, newline and paragraph characters are ignored, and text is not word-wrapped. If True, text is wrapped only if the wrap_lines is True.
dpi (float | None) – Font resolution; defaults to 96.
batch (Batch | None) – Optional graphics batch to add this layout to.
group (Group | None) – Optional Group to parent all internal Groups that this text layout uses. Note that layouts with the same Groups will be rendered simultaneously in a Batch.
program (ShaderProgram | None) – Optional graphics shader to use. Will affect all glyphs in the layout.
wrap_lines (bool) – If True and multiline is True, the text is word-wrapped using the specified width.
init_document – If True the document will be initialized. If subclassing then you may want to avoid duplicate initializations by changing to False.

delete() → None

Deletes all vertices and boxes associated with the layout.

Return type:: None

ensure_line_visible(line_idx: int) → None

Adjust view_y so that the line with the given index is visible.

Return type:: None

ensure_x_visible(x: float) → None

Adjust view_x so that the given X coordinate is visible.

The X coordinate is given relative to the current view_x.

Return type:: None

get_line_from_point(x: float, y: float) → int

Get the closest line index to a point.

Return type:: int

get_line_from_position(position: int) → int

Get the line index of a character position in the document.

Return type:: int

get_point_from_line(line_idx: int) → tuple[float, float]

Get the X, Y coordinates of a line index.

Return type:: tuple[float, float]

get_point_from_position( position: int, line_idx: int | None = None, ) → tuple[float, float]

Get the X, Y coordinates of a character position in the document.

The position that ends a line has an ambiguous point: it can be either the end of the line, or the beginning of the next line. You may optionally specify a line index to disambiguate the case.

The resulting Y coordinate gives the baseline of the line.

Return type:: tuple[float, float]

get_position_from_line(line_idx: int) → int

Get the first document character position of a given line index.

Return type:: int

get_position_from_point(x: float, y: float) → int

Get the closest document position to a point.

Return type:: int

get_position_on_line(line_idx: int, x: float) → int

Get the closest document position for a given line index and X coordinate.

Return type:: int

on_delete_text(start: int, end: int) → None

Event handler for AbstractDocument.on_delete_text.

The event handler is bound by the text layout; there is no need for applications to interact with this method.

Return type:: None

on_insert_text(start: int, text: str) → None

Event handler for AbstractDocument.on_insert_text.

The event handler is bound by the text layout; there is no need for applications to interact with this method.

Return type:: None

on_layout_update() → None

Some or all of the layout text was reflowed.

Text reflow is caused by document edits or changes to the layout’s size. Changes to the layout’s position or active selection, and certain document edits such as text color, do not cause a reflow.

Handle this event to update the position of a graphical element that depends on the laid out position of a glyph or line.

Event:
Return type:: None

on_style_text( start: int, end: int, attributes: dict[str, Any], ) → None

Event handler for AbstractDocument.on_style_text.

The event handler is bound by the text layout; there is no need for applications to interact with this method.

Return type:: None

set_selection(start: int, end: int) → None

Set the text selection range.

If start equals end no selection will be visible.

Parameters:

start (int) – Starting character position of selection.
end (int) – End of selection, exclusive.

Return type:

None

property anchor_x: Literal['left', 'center', 'right']

Horizontal anchor alignment.

This property determines the meaning of the x coordinate.

The following values are supported:

"left" (default): The X coordinate gives the position of the left edge of the layout.
"center": The X coordinate gives the position of the center of the layout.
"right": The X coordinate gives the position of the right edge of the layout.

For the purposes of calculating the position resulting from this alignment, the width of the layout is taken to be width if multiline is True and wrap_lines is True, otherwise content_width.

property anchor_y: Literal['top', 'bottom', 'center', 'baseline']

Vertical anchor alignment.

This property determines the meaning of the y coordinate.

The following values are supported:

"top": The Y coordinate gives the position of the top edge of the layout.
"center": The Y coordinate gives the position of the center of the layout.
"baseline": The Y coordinate gives the position of the baseline of the first line of text in the layout.
"bottom" (default): The Y coordinate gives the position of the bottom edge of the layout.

For the purposes of calculating the position resulting from this alignment, the height of the layout is taken to be the smallest of height and content_height.