pyglet 2.1.13__py3-none-any.whl → 3.0.dev1__py3-none-any.whl

pyglet/sprite.py

@@ -67,125 +67,37 @@ sprites within batches.
 from __future__ import annotations
 
 import sys
-import warnings
-from typing import TYPE_CHECKING, ClassVar, Literal
+from typing import TYPE_CHECKING
 
 import pyglet
-from pyglet import clock, event, graphics, image
-from pyglet.gl import (
-    GL_BLEND,
-    GL_ONE_MINUS_SRC_ALPHA,
-    GL_SRC_ALPHA,
-    GL_TEXTURE0,
-    GL_TRIANGLES,
-    glActiveTexture,
-    glBindTexture,
-    glBlendFunc,
-    glDisable,
-    glEnable,
-)
-
-_is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
+from pyglet import event, clock
 
 if TYPE_CHECKING:
-    from pyglet.graphics import Batch, Group
-    from pyglet.graphics.shader import ShaderProgram
-    from pyglet.image import AbstractImage, Animation, Texture
-
-vertex_source: str = """#version 150 core
-    in vec3 translate;
-    in vec4 colors;
-    in vec3 tex_coords;
-    in vec2 scale;
-    in vec3 position;
-    in float rotation;
-
-    out vec4 vertex_colors;
-    out vec3 texture_coords;
-
-    uniform WindowBlock
-    {
-        mat4 projection;
-        mat4 view;
-    } window;
-
-    mat4 m_scale = mat4(1.0);
-    mat4 m_rotation = mat4(1.0);
-    mat4 m_translate = mat4(1.0);
-
-    void main()
-    {
-        m_scale[0][0] = scale.x;
-        m_scale[1][1] = scale.y;
-        m_translate[3][0] = translate.x;
-        m_translate[3][1] = translate.y;
-        m_translate[3][2] = translate.z;
-        m_rotation[0][0] =  cos(-radians(rotation)); 
-        m_rotation[0][1] =  sin(-radians(rotation));
-        m_rotation[1][0] = -sin(-radians(rotation));
-        m_rotation[1][1] =  cos(-radians(rotation));
-
-        gl_Position = window.projection * window.view * m_translate * m_rotation * m_scale * vec4(position, 1.0);
-
-        vertex_colors = colors;
-        texture_coords = tex_coords;
-    }
-"""
-
-fragment_source: str = """#version 150 core
-    in vec4 vertex_colors;
-    in vec3 texture_coords;
-    out vec4 final_colors;
-
-    uniform sampler2D sprite_texture;
-
-    void main()
-    {
-        final_colors = texture(sprite_texture, texture_coords.xy) * vertex_colors;
-    }
-"""
-
-fragment_array_source: str = """#version 150 core
-    in vec4 vertex_colors;
-    in vec3 texture_coords;
-    out vec4 final_colors;
-
-    uniform sampler2DArray sprite_texture;
-
-    void main()
-    {
-        final_colors = texture(sprite_texture, texture_coords) * vertex_colors;
-    }
-"""
-
-
-def get_default_shader() -> ShaderProgram:
-    """Create and return the default sprite shader.
+    from typing import ClassVar, Literal
+    from pyglet.graphics.texture import TextureBase
 
-    This method allows the module to be imported without an OpenGL Context.
-    """
-    return pyglet.gl.current_context.create_program((vertex_source, 'vertex'),
-                                                    (fragment_source, 'fragment'))
+from pyglet.graphics import Group, Batch, ShaderProgram, GeometryMode
+from pyglet.enums import BlendFactor
+from pyglet.image.base import Animation
+from pyglet.graphics.texture import TextureArrayRegion
 
 
-def get_default_array_shader() -> ShaderProgram:
-    """Create and return the default array sprite shader.
+if pyglet.options.backend in ("opengl", "gles3"):
+    from pyglet.graphics.api.gl.sprite import get_default_array_shader, get_default_shader
+elif pyglet.options.backend in ("gl2", "gles2"):
+    from pyglet.graphics.api.gl2.sprite import get_default_array_shader, get_default_shader
+elif pyglet.options.backend == "webgl":
+    from pyglet.graphics.api.webgl.sprite import get_default_array_shader, get_default_shader
+elif pyglet.options.backend == "vulkan":
+    from pyglet.graphics.api.vulkan.sprite import get_default_array_shader, get_default_shader, SpriteGroup
 
-    This method allows the module to be imported without an OpenGL Context.
-    """
-    return pyglet.gl.current_context.create_program((vertex_source, 'vertex'),
-                                                    (fragment_array_source, 'fragment'))
+_is_pyglet_doc_run = hasattr(sys, "is_pyglet_doc_run") and sys.is_pyglet_doc_run
 
 
-class SpriteGroup(graphics.Group):
-    """Shared Sprite rendering Group.
+class SpriteGroup(Group):
+    """Shared Sprite rendering Group."""
 
-    The Group defines custom ``__eq__`` and ``__hash__`` methods, and so will
-    be automatically coalesced with other Sprite Groups sharing the same parent
-    Group, Texture and blend parameters.
-    """
-
-    def __init__(self, texture: Texture, blend_src: int, blend_dest: int,
+    def __init__(self, texture: TextureBase, blend_src: BlendFactor, blend_dest: BlendFactor,
                  program: ShaderProgram, parent: Group | None = None) -> None:
         """Create a sprite group.
 
@@ -196,11 +108,9 @@ class SpriteGroup(graphics.Group):
             texture:
                 The (top-level) texture containing the sprite image.
             blend_src:
-                OpenGL blend source mode; for example,
-                ``GL_SRC_ALPHA``.
+                Blend factor source mode; for example: ``SRC_ALPHA``.
             blend_dest:
-                OpenGL blend destination mode; for example,
-                ``GL_ONE_MINUS_SRC_ALPHA``.
+                Blend factor source mode; for example: ``_ONE_MINUS_SRC_ALPHA``.
             program:
                 A custom ShaderProgram.
             parent:
@@ -208,39 +118,9 @@ class SpriteGroup(graphics.Group):
         """
         super().__init__(parent=parent)
         self.texture = texture
-        self.blend_src = blend_src
-        self.blend_dest = blend_dest
-        self.program = program
-
-    def set_state(self) -> None:
-        self.program.use()
-
-        glActiveTexture(GL_TEXTURE0)
-        glBindTexture(self.texture.target, self.texture.id)
-
-        glEnable(GL_BLEND)
-        glBlendFunc(self.blend_src, self.blend_dest)
-
-    def unset_state(self) -> None:
-        glDisable(GL_BLEND)
-        self.program.stop()
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}({self.texture})"
-
-    def __eq__(self, other: SpriteGroup) -> bool:
-        return (other.__class__ is self.__class__ and
-                self.program is other.program and
-                self.parent == other.parent and
-                self.texture.target == other.texture.target and
-                self.texture.id == other.texture.id and
-                self.blend_src == other.blend_src and
-                self.blend_dest == other.blend_dest)
-
-    def __hash__(self) -> int:
-        return hash((self.program, self.parent,
-                     self.texture.id, self.texture.target,
-                     self.blend_src, self.blend_dest))
+        self.set_shader_program(program)
+        self.set_blend(blend_src, blend_dest)
+        self.set_texture(self.texture, 0)
 
 
 class Sprite(event.EventDispatcher):
@@ -265,10 +145,10 @@ class Sprite(event.EventDispatcher):
     group_class: ClassVar[type[SpriteGroup | Group]] = SpriteGroup
 
     def __init__(self,
-                 img: AbstractImage | Animation,
+                 img: TextureBase | Animation,
                  x: float = 0, y: float = 0, z: float = 0,
-                 blend_src: int = GL_SRC_ALPHA,
-                 blend_dest: int = GL_ONE_MINUS_SRC_ALPHA,
+                 blend_src: BlendFactor = BlendFactor.SRC_ALPHA,
+                 blend_dest: BlendFactor = BlendFactor.ONE_MINUS_SRC_ALPHA,
                  batch: Batch | None = None,
                  group: Group | None = None,
                  subpixel: bool = False,
@@ -308,7 +188,7 @@ class Sprite(event.EventDispatcher):
         self._y = y
         self._z = z
 
-        if isinstance(img, image.Animation):
+        if isinstance(img, Animation):
             self._animation = img
             self._texture = img.frames[0].image.get_texture()
             self._next_dt = img.frames[0].duration
@@ -318,7 +198,7 @@ class Sprite(event.EventDispatcher):
             self._texture = img.get_texture()
 
         if not program:
-            if isinstance(img, image.TextureArrayRegion):
+            if isinstance(img, TextureArrayRegion):
                 program = get_default_array_shader()
             else:
                 program = get_default_shader()
@@ -368,14 +248,14 @@ class Sprite(event.EventDispatcher):
 
         if frame.duration is not None:
             duration = frame.duration - (self._next_dt - dt)
-            duration = min(max(0, duration), frame.duration)
+            duration = min(max(0.0, duration), frame.duration)
             clock.schedule_once(self._animate, duration)
             self._next_dt = duration
         else:
             self.dispatch_event('on_animation_end')
 
     @property
-    def blend_mode(self) -> tuple[int, int]:
+    def blend_mode(self) -> tuple[BlendFactor, BlendFactor]:
         """The current blend mode applied to this sprite.
 
         .. note:: Changing this can be an expensive operation as it involves a group creation and transfer.
@@ -393,7 +273,7 @@ class Sprite(event.EventDispatcher):
 
         self._group = self.get_sprite_group()
         if self._batch is not None:
-            self._batch.migrate(self._vertex_list, GL_TRIANGLES, self._group, self._batch)
+            self._batch.migrate(self._vertex_list, GeometryMode.TRIANGLES, self._group, self._batch)
 
     @property
     def program(self) -> ShaderProgram:
@@ -411,7 +291,7 @@ class Sprite(event.EventDispatcher):
         self._group = self.get_sprite_group()
 
         if (self._batch and
-                self._batch.update_shader(self._vertex_list, GL_TRIANGLES, self._group, program)):
+                self._batch.update_shader(self._vertex_list, GeometryMode.TRIANGLES, self._group, program)):
             # Exit early if changing domain is not needed.
             return
 
@@ -436,7 +316,7 @@ class Sprite(event.EventDispatcher):
             return
 
         if batch is not None and self._batch is not None:
-            self._batch.migrate(self._vertex_list, GL_TRIANGLES, self._group, batch)
+            self._batch.migrate(self._vertex_list, GeometryMode.TRIANGLES, self._group, batch)
             self._batch = batch
         else:
             self._vertex_list.delete()
@@ -460,10 +340,10 @@ class Sprite(event.EventDispatcher):
         self._user_group = group
         self._group = self.get_sprite_group()
         if self._batch is not None:
-            self._batch.migrate(self._vertex_list, GL_TRIANGLES, self._group, self._batch)
+            self._batch.migrate(self._vertex_list, GeometryMode.TRIANGLES, self._group, self._batch)
 
     @property
-    def image(self) -> AbstractImage | Animation:
+    def image(self) -> TextureBase | Animation:
         """The Sprite's Image or Animation to display.
 
         .. note:: Changing this can be an expensive operation if the texture is not part of the same texture or atlas.
@@ -473,12 +353,12 @@ class Sprite(event.EventDispatcher):
         return self._texture
 
     @image.setter
-    def image(self, img: AbstractImage | Animation) -> None:
+    def image(self, img: TextureBase | Animation) -> None:
         if self._animation is not None:
             clock.unschedule(self._animate)
             self._animation = None
 
-        if isinstance(img, image.Animation):
+        if isinstance(img, Animation):
             self._animation = img
             self._frame_index = 0
             self._set_texture(img.frames[0].image.get_texture())
@@ -489,19 +369,20 @@ class Sprite(event.EventDispatcher):
             self._set_texture(img.get_texture())
         self._update_position()
 
-    def _set_texture(self, texture: Texture) -> None:
+    def _set_texture(self, texture: TextureBase) -> None:
         if texture.id is not self._texture.id:
             self._vertex_list.delete()
             self._texture = texture
             self._group = self.get_sprite_group()
             self._create_vertex_list()
+            print("CREATE VERTEX LIST")
         else:
             self._vertex_list.tex_coords[:] = texture.tex_coords
         self._texture = texture
 
     def _create_vertex_list(self) -> None:
         self._vertex_list = self.program.vertex_list_indexed(
-            4, GL_TRIANGLES, [0, 1, 2, 0, 2, 3], self._batch, self._group,
+            4, GeometryMode.TRIANGLES, [0, 1, 2, 0, 2, 3], self._batch, self._group,
             position=('f', self._get_vertices()),
             colors=('Bn', self._rgba * 4),
             translate=('f', (self._x, self._y, self._z) * 4),
@@ -844,9 +725,10 @@ class Sprite(event.EventDispatcher):
         See the module documentation for hints on drawing multiple sprites
         efficiently.
         """
-        self._group.set_state_recursive()
-        self._vertex_list.draw(GL_TRIANGLES)
-        self._group.unset_state_recursive()
+        ctx = pyglet.graphics.api.core.current_context
+        self._group.set_state_recursive(ctx)
+        self._vertex_list.draw(GeometryMode.TRIANGLES)
+        self._group.unset_state_recursive(ctx)
 
     if _is_pyglet_doc_run:
         # Events
@@ -863,3 +745,4 @@ class Sprite(event.EventDispatcher):
 
 
 Sprite.register_event_type('on_animation_end')
+

pyglet/text/__init__.py

@@ -38,12 +38,12 @@ creating scrollable layouts.
 from __future__ import annotations
 
 from abc import abstractmethod
-from enum import Enum
 from os.path import dirname as _dirname
 from os.path import splitext as _splitext
 from typing import TYPE_CHECKING, Any, BinaryIO, Literal
 
 import pyglet
+from pyglet.font import base
 
 from pyglet.text import caret, document, layout  # noqa: F401
 
@@ -79,48 +79,6 @@ class DocumentDecoder:
 SupportedMimeTypes = Literal["text/plain", "text/html", "text/vnd.pyglet-attributed"]
 
 
-class Weight(str, Enum):
-    """An :py:class:`~enum.Enum` of known cross-platform font weight strings.
-
-    Each value is both an :py:class:`~enum.Enum` and a :py:class:`str`.
-    This is not a built-in Python :py:class:`~enum.StrEnum` to ensure
-    compatibility with Python < 3.11.
-
-    .. important:: Fonts will use the closest match if they lack a weight!
-
-    The values of this enum imitate the string names for font weights
-    as used in CSS and the OpenType specification. Numerical font weights
-    are not supported because:
-
-    * Integer font weight support and behavior varies by back-end
-    * Some font renderers do not support or round :py:class:`float` values
-    * Some font renderers lack support for variable-width fonts
-
-    Additional weight strings may be supported by certain font-rendering
-    back-ends. To learn more, please see your platform's API documentation
-    and the following:
-
-    #. `The MDN article on CSS font weights <https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight>`_
-    #. `The OpenType specification <https://learn.microsoft.com/en-us/typography/opentype/spec/os2#usweightclass>`_
-
-    """
-
-    THIN = 'thin'
-    EXTRALIGHT = 'extralight'
-    LIGHT = 'light'
-    NORMAL = 'normal'
-    """The default weight for a font."""
-    MEDIUM = 'medium'
-    SEMIBOLD = 'semibold'
-    BOLD = 'bold'
-    """The default **bold** style for a font."""
-    EXTRABOLD = 'extrabold'
-    ULTRABOLD = 'ultrabold'
-
-    def __str__(self) -> str:
-        return self.value
-
-
 def get_decoder(filename: str | None, mimetype: SupportedMimeTypes | None = None) -> DocumentDecoder:
     """Get a document decoder for the given filename and MIME type.
 
@@ -239,6 +197,7 @@ class DocumentLabel(layout.TextLayout):
             multiline: bool = False, dpi: int | None = None,
             batch: Batch | None = None, group: Group | None = None,
             program: ShaderProgram | None = None,
+            shaping: bool = True,
             init_document: bool = True,
     ) -> None:
         """Create a label for a given document.
@@ -268,13 +227,16 @@ class DocumentLabel(layout.TextLayout):
             batch: Optional graphics batch to add the label to.
             group: Optional graphics group to use.
             program: Optional graphics shader to use. Will affect all glyphs.
+            shaping:
+                If the text should use proper positioning and typography according to the font and global
+                ``pyglet.options.text_shaping`` option. If ``False``, metrics will instead be tied to the glyph sizes.
             init_document:
                 If ``True``, the document will be initialized. If you
                 are passing an already-initialized document, then you can
                 avoid duplicating work by setting this to ``False``.
         """
         super().__init__(document, x, y, z, width, height, anchor_x, anchor_y, rotation,
-                         multiline, dpi, batch, group, program, init_document=init_document)
+                         multiline, dpi, batch, group, program, shaping=shaping, init_document=init_document)
 
     @property
     def text(self) -> str:
@@ -318,17 +280,40 @@ class DocumentLabel(layout.TextLayout):
             self.color = list(map(int, (*self.color[:3], alpha)))
 
     @property
-    def font_name(self) -> str | list[str]:
-        """Font family name.
+    def font_name(self) -> str:
+        """The current font family name.
+
+        The value is read from the beginning of this document.
 
         The font name, as passed to :py:func:`pyglet.font.load`.  A list of names can
         optionally be given: the first matching font will be used.
         """
-        return self.document.get_style("font_name")
+        return self.document.get_font(0).name
 
     @font_name.setter
     def font_name(self, font_name: str | list[str]) -> None:
-        self.document.set_style(0, len(self.document.text), {"font_name": font_name})
+        resolved_font_name = pyglet.font.manager.get_resolved_name(font_name)
+        self.document.set_style(0, len(self.document.text), {"font_name": resolved_font_name})
+
+    @property
+    def font(self) -> base.Font:
+        """The current font object used at the beginning of the text.
+
+        Setting this property will change the font for the entire document.
+
+        .. versionadded:: 3.0
+        """
+        return self.document.get_font(0)
+
+    @font.setter
+    def font(self, font: base.Font) -> None:
+        self.document.set_style(0, len(self.document.text), {
+            "font_name": font.name,
+            "font_size": font.size,
+            "weight": font.weight,
+            "italic": font.style,
+            "stretch": font.stretch,
+        })
 
     @property
     def font_size(self) -> float:
@@ -399,9 +384,10 @@ class Label(DocumentLabel):
             anchor_x: AnchorX = "left", anchor_y: AnchorY = "baseline", rotation: float = 0.0,
             multiline: bool = False, dpi: int | None = None,
             font_name: str | None = None, font_size: float | None = None,
-            weight: str = "normal", italic: bool | str = False, stretch: bool | str = False,
+            weight: str = "normal", style: str = "normal", stretch: str = "normal",
             color: tuple[int, int, int, int] | tuple[int, int, int] = (255, 255, 255, 255),
             align: HorizontalAlign = "left",
+            shaping: bool = True,
             batch: Batch | None = None, group: Group | None = None,
             program: ShaderProgram | None = None,
     ) -> None:
@@ -441,12 +427,13 @@ class Label(DocumentLabel):
             font_size:
                 Font size, in points.
             weight:
-                The 'weight' of the font (boldness). See the :py:class:`~Weight`
+                The 'weight' of the font (boldness). See the :py:class:`~pyglet.enums.Weight`
                 enum for valid cross-platform weight names.
-            italic:
-                Italic font style.
+            style:
+                Italic font style. See the :py:class:`~pyglet.enums.Style` enum for valid cross-platform style names.
             stretch:
-                 Stretch font style.
+                 Stretch font style. See the :py:class:`~pyglet.enums.Stretch` enum for valid cross-platform
+                 style names.
             color:
                 Font color as RGBA or RGB components, each within
                 ``0 <= component <= 255``.
@@ -454,6 +441,9 @@ class Label(DocumentLabel):
                 Horizontal alignment of text on a line, only applies if
                 a width is supplied. One of ``"left"``, ``"center"``
                 or ``"right"``.
+            shaping:
+                If the text should use proper positioning and typography according to the font and global
+                ``pyglet.options.text_shaping`` option. If ``False``, metrics will instead be tied to the glyph sizes.
             batch:
                 Optional graphics batch to add the label to.
             group:
@@ -472,7 +462,7 @@ class Label(DocumentLabel):
             "font_name": font_name,
             "font_size": font_size,
             "weight": weight,
-            "italic": italic,
+            "style": style,
             "stretch": stretch,
             "color": rgba,
             "align": align,

pyglet/text/caret.py

@@ -19,6 +19,7 @@ from typing import TYPE_CHECKING, Any, Pattern
 from pyglet import clock, event
 from pyglet.window import key
 from pyglet.event import EventDispatcher
+from pyglet.graphics import GeometryMode
 
 if TYPE_CHECKING:
     from pyglet.graphics import Batch
@@ -91,7 +92,6 @@ class Caret(EventDispatcher):
             `window` : `~pyglet.window.Window`
                 For the clipboard feature to work, a window object is needed to be passed in to access and set clipboard content.
         """
-        from pyglet import gl
         self._layout = layout
 
         self._custom_batch = batch is not None
@@ -106,9 +106,15 @@ class Caret(EventDispatcher):
 
         colors = r, g, b, self._visible_alpha, r, g, b, self._visible_alpha
 
-        self._list = self._group.program.vertex_list(2, gl.GL_LINES, self._batch, self._group,
-                                                     colors=("Bn", colors),
-                                                     visible=("f", (1, 1)))
+        self._list = self._group.program.vertex_list(2, GeometryMode.LINES, self._batch, self._group,
+                                                        position=('f', (0, 0, 0) * 2),
+                                                        translation=('f', (0, 0, 0) * 2),
+                                                        view_translation=('f', (0, 0, 0) * 2),
+                                                        anchor=('f', (0, 0) * 2),
+                                                        rotation=('f', (0, 0)),
+                                                        visible=('f', (1, 1)),
+                                                        colors=("Bn", colors))
+
         self._ideal_x = None
         self._ideal_line = None
         self._next_attributes = {}
@@ -124,14 +130,13 @@ class Caret(EventDispatcher):
 
     @layout.setter
     def layout(self, layout: IncrementalTextLayout) -> None:
-        if self._layout == layout and self._group == layout.group:
+        if self._layout == layout and self._group == layout.foreground_decoration_group:
             return
 
-        from pyglet.gl import GL_LINES
         self._layout = layout
         batch = self._batch if self._custom_batch else layout.batch
         self._group = layout.foreground_decoration_group
-        self._batch.migrate(self._list, GL_LINES, self._group, batch)
+        self._batch.migrate(self._list, GeometryMode.LINES, self._group, batch)
 
     def delete(self) -> None:
         """Remove the caret from its batch.

pyglet/text/document.py

@@ -14,18 +14,18 @@ example::
     0    5   10   15   20
     The cat sat on the mat.
     +++++++        +++++++    "weight"
-                ++++++      "italic"
+                ++++++      "style"
 
 If this example were to be rendered, "The cat" and "the mat" would have a weight
 set ("bold", "thin", etc.), and "on the" would be in italics.  Note that the second
 "the" is both weighted and italic.
 
 The document styles recorded for this example would be a specific ``"weight"`` over
-ranges (0-7) & (15-22) and ``"italic"`` over range (12-18).  Overlapping styles are
+ranges (0-7) & (15-22) and ``"style"`` over range (12-18).  Overlapping document styles are
 permitted; unlike HTML and other structured markup, the ranges need not be nested.
 
 The document has no knowledge of the semantics of ``"weight"`` names or
-``"italic"``, it stores only the style names.  The pyglet layout classes give
+``"style"`` names, it stores only the document style key names.  The pyglet layout classes give
 meaning to these style names in the way they are rendered; but you are also free
 to invent your own style names (which will be ignored by the layout classes).
 This can be useful to tag areas of interest in a document, or maintain
@@ -71,9 +71,11 @@ The following character style attribute names are recognised by pyglet:
 ``font_size``
     Font size, in points.
 ``weight``
-    String.
-``italic``
-    Boolean.
+    String or :py:class:`~pyglet.enums.Weight`.
+``style``
+    String or :py:class:`~pyglet.enums.Style`.
+``stretch``
+    String or :py:class:`~pyglet.enums.Stretch`.
 ``underline``
     4-tuple of ints in range (0, 255) giving RGBA underline color, or None
     (default) for no underline.
@@ -337,7 +339,7 @@ class AbstractDocument(event.EventDispatcher):
         """Get a style iterator over the `pyglet.font.Font` instances used in the document.
 
         The font instances are created on-demand by inspection of the
-        ``font_name``, ``font_size``, ``weight`` and ``italic`` style
+        ``font_name``, ``font_size``, ``weight`` and ``style`` document style
         attributes.
 
         Args:
@@ -571,9 +573,9 @@ class UnformattedDocument(AbstractDocument):
         font_name = self.styles.get("font_name")
         font_size = self.styles.get("font_size")
         weight = self.styles.get("weight", "normal")
-        italic = self.styles.get("italic", False)
-        stretch = self.styles.get("stretch", False)
-        return font.load(font_name, font_size, weight=weight, italic=italic, stretch=stretch, dpi=dpi)
+        style = self.styles.get("style", "normal")
+        stretch = self.styles.get("stretch", "normal")
+        return font.load(font_name, font_size, weight=weight, style=style, stretch=stretch, dpi=dpi)
 
     def get_element_runs(self) -> runlist.ConstRunIterator:
         return runlist.ConstRunIterator(len(self._text), None)
@@ -616,7 +618,7 @@ class FormattedDocument(AbstractDocument):
             self.get_style_runs("font_name"),
             self.get_style_runs("font_size"),
             self.get_style_runs("weight"),
-            self.get_style_runs("italic"),
+            self.get_style_runs("style"),
             self.get_style_runs("stretch"),
             dpi)
 
@@ -670,21 +672,21 @@ class _ElementIterator(runlist.RunIterator):
 class _FontStyleRunsRangeIterator(runlist.RunIterator):
     # XXX subclass runlist
     def __init__(self, font_names: runlist.RunIterator, font_sizes: runlist.RunIterator, weights: runlist.RunIterator,
-                 italics: runlist.RunIterator, stretch: runlist.RunIterator, dpi: int | None) -> None:
-        self.zip_iter = runlist.ZipRunIterator((font_names, font_sizes, weights, italics, stretch))
+                 italic_styles: runlist.RunIterator, stretch: runlist.RunIterator, dpi: int | None) -> None:
+        self.zip_iter = runlist.ZipRunIterator((font_names, font_sizes, weights, italic_styles, stretch))
         self.dpi = dpi
 
     def ranges(self, start: int, end: int) -> Generator[tuple[int, int, Font], None, None]:
         from pyglet import font
         for start_, end_, styles in self.zip_iter.ranges(start, end):
-            font_name, font_size, weight, italic, stretch = styles
-            ft = font.load(font_name, font_size, weight=weight or "normal", italic=bool(italic), stretch=stretch or False, dpi=self.dpi)
+            font_name, font_size, weight, italic_style, stretch = styles
+            ft = font.load(font_name, font_size, weight=weight, style=italic_style, stretch=stretch, dpi=self.dpi)
             yield start_, end_, ft
 
     def __getitem__(self, index: int) -> Font:
         from pyglet import font
-        font_name, font_size, weight, italic, stretch = self.zip_iter[index]
-        return font.load(font_name, font_size, weight=weight or "normal", italic=bool(italic), stretch=stretch or False, dpi=self.dpi)
+        font_name, font_size, weight, italic_style, stretch = self.zip_iter[index]
+        return font.load(font_name, font_size, weight=weight, style=italic_style, stretch=stretch, dpi=self.dpi)
 
 
 class _NoStyleRangeIterator(runlist.RunIterator):