pyglet 2.1.3__py3-none-any.whl → 2.1.4__py3-none-any.whl

pyglet/media/drivers/xaudio2/lib_xaudio2.py

@@ -1,30 +1,47 @@
-import ctypes
-import platform
 import os
-from pyglet.libs.win32.constants import *
-from pyglet.libs.win32.types import *
+import platform
+from ctypes import (
+    HRESULT,
+    POINTER,
+    Structure,
+    c_bool,
+    c_char,
+    c_float,
+    c_int,
+    c_uint32,
+    c_uint64,
+    c_void_p,
+    cdll,
+    windll,
+)
+from ctypes.wintypes import BOOL, BYTE, DWORD, FLOAT, LPCWSTR, UINT, WORD
+
 from pyglet.libs.win32 import com
+from pyglet.libs.win32.constants import WINDOWS_10_ANNIVERSARY_UPDATE_OR_GREATER
+from pyglet.libs.win32.types import c_void
 from pyglet.util import debug_print
 
 _debug = debug_print('debug_media')
 
 
 def load_xaudio2(dll_name):
-    """This will attempt to load a version of XAudio2. Versions supported: 2.9, 2.8.
-       While Windows 8 ships with 2.8 and Windows 10 ships with version 2.9, it is possible to install 2.9 on 8/8.1.
+    """This will attempt to load a version of XAudio2.
+
+    Versions supported: 2.9, 2.8.
+
+    While Windows 8 ships with 2.8 and Windows 10 ships with version 2.9, it is possible to install 2.9 on 8/8.1.
     """
     xaudio2 = dll_name
     # System32 and SysWOW64 folders are opposite perception in Windows x64.
     # System32 = x64 dll's | SysWOW64 = x86 dlls
     # By default ctypes only seems to look in system32 regardless of Python architecture, which has x64 dlls.
-    if platform.architecture()[0] == '32bit':
-        if platform.machine().endswith('64'):  # Machine is 64 bit, Python is 32 bit.
-            xaudio2 = os.path.join(os.environ['WINDIR'], 'SysWOW64', '{}.dll'.format(xaudio2))
+    if platform.architecture()[0] == '32bit' and platform.machine().endswith('64'):  # Machine is 64 bit, Python is 32 bit.
+        xaudio2 = os.path.join(os.environ['WINDIR'], 'SysWOW64', '{}.dll'.format(xaudio2))
 
-    xaudio2_lib = ctypes.windll.LoadLibrary(xaudio2)
+    xaudio2_lib = windll.LoadLibrary(xaudio2)
 
     # Somehow x3d uses different calling structure than the rest of the DLL; Only affects 32 bit? Microsoft...
-    x3d_lib = ctypes.cdll.LoadLibrary(xaudio2)
+    x3d_lib = cdll.LoadLibrary(xaudio2)
     return xaudio2_lib, x3d_lib
 
 
@@ -43,7 +60,7 @@ UINT32 = c_uint32
 FLOAT32 = c_float
 
 
-class XAUDIO2_DEBUG_CONFIGURATION(ctypes.Structure):
+class XAUDIO2_DEBUG_CONFIGURATION(Structure):
     _fields_ = [
         ('TraceMask', UINT32),
         ('BreakMask', UINT32),
@@ -54,7 +71,7 @@ class XAUDIO2_DEBUG_CONFIGURATION(ctypes.Structure):
     ]
 
 
-class XAUDIO2_PERFORMANCE_DATA(ctypes.Structure):
+class XAUDIO2_PERFORMANCE_DATA(Structure):
     _fields_ = [
         ('AudioCyclesSinceLastQuery', c_uint64),
         ('TotalCyclesSinceLastQuery', c_uint64),
@@ -76,14 +93,14 @@ class XAUDIO2_PERFORMANCE_DATA(ctypes.Structure):
         return "XAUDIO2PerformanceData(active_voices={}, total_voices={}, glitches={}, latency={} samples, memory_usage={} bytes)".format(self.ActiveSourceVoiceCount, self.TotalSourceVoiceCount, self.GlitchesSinceEngineStarted, self.CurrentLatencyInSamples, self.MemoryUsageInBytes)
 
 
-class XAUDIO2_VOICE_SENDS(ctypes.Structure):
+class XAUDIO2_VOICE_SENDS(Structure):
     _fields_ = [
         ('SendCount', UINT32),
         ('pSends', c_void_p),
     ]
 
 
-class XAUDIO2_BUFFER(ctypes.Structure):
+class XAUDIO2_BUFFER(Structure):
     _fields_ = [
         ('Flags', UINT32),
         ('AudioBytes', UINT32),
@@ -96,7 +113,7 @@ class XAUDIO2_BUFFER(ctypes.Structure):
         ('pContext', c_void_p),
     ]
 
-class XAUDIO2_VOICE_STATE(ctypes.Structure):
+class XAUDIO2_VOICE_STATE(Structure):
     _fields_ = [
         ('pCurrentBufferContext', c_void_p),
         ('BuffersQueued', UINT32),
@@ -106,7 +123,7 @@ class XAUDIO2_VOICE_STATE(ctypes.Structure):
     def __repr__(self):
         return "XAUDIO2_VOICE_STATE(BuffersQueued={0}, SamplesPlayed={1})".format(self.BuffersQueued, self.SamplesPlayed)
 
-class WAVEFORMATEX(ctypes.Structure):
+class WAVEFORMATEX(Structure):
     _fields_ = [
         ('wFormatTag', WORD),
         ('nChannels', WORD),
@@ -198,13 +215,13 @@ class IXAudio2VoiceCallback(com.Interface):
         ('OnStreamEnd',
          com.VOIDMETHOD()),
         ('OnBufferStart',
-         com.VOIDMETHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD(c_void_p)),
         ('OnBufferEnd',
-         com.VOIDMETHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD(c_void_p)),
         ('OnLoopEnd',
-         com.VOIDMETHOD(ctypes.c_void_p)),
+         com.VOIDMETHOD(c_void_p)),
         ('OnVoiceError',
-         com.VOIDMETHOD(ctypes.c_void_p, HRESULT))
+         com.VOIDMETHOD(c_void_p, HRESULT))
     ]
 
 
@@ -216,7 +233,7 @@ class XAUDIO2_EFFECT_DESCRIPTOR(Structure):
     ]
 
 
-class XAUDIO2_EFFECT_CHAIN(ctypes.Structure):
+class XAUDIO2_EFFECT_CHAIN(Structure):
     _fields_ = [
         ('EffectCount', UINT32),
         ('pEffectDescriptors', POINTER(XAUDIO2_EFFECT_DESCRIPTOR)),
@@ -331,21 +348,21 @@ class IXAudio2EngineCallback(com.Interface):
 
 
 # -------------- 3D Audio Positioning----------
-class X3DAUDIO_DISTANCE_CURVE_POINT(ctypes.Structure):
+class X3DAUDIO_DISTANCE_CURVE_POINT(Structure):
     _fields_ = [
         ('Distance', FLOAT32),
         ('DSPSetting', FLOAT32)
     ]
 
 
-class X3DAUDIO_DISTANCE_CURVE(ctypes.Structure):
+class X3DAUDIO_DISTANCE_CURVE(Structure):
     _fields_ = [
         ('pPoints', POINTER(X3DAUDIO_DISTANCE_CURVE_POINT)),
         ('PointCount', UINT32)
     ]
 
 
-class X3DAUDIO_VECTOR(ctypes.Structure):
+class X3DAUDIO_VECTOR(Structure):
     _fields_ = [
         ('x', c_float),
         ('y', c_float),

pyglet/shapes.py

@@ -814,7 +814,7 @@ class Arc(ShapeBase):
                 The angle of the arc, in degrees. Defaults to 360.0, which is
                 a full circle.
             start_angle:
-                The start angle of the arc, in radians. Defaults to 0.
+                The start angle of the arc, in degrees. Defaults to 0.
             closed:
                 If ``True``, the ends of the arc will be connected with a line.
                 defaults to ``False``.

pyglet/text/document.py

@@ -247,7 +247,7 @@ class AbstractDocument(event.EventDispatcher):
         self._text = ""
         self._elements: list[InlineElement] = []
         if text:
-            self.append_text(text)
+            self.insert_text(0, text)
 
     @property
     def text(self) -> str:
@@ -384,24 +384,6 @@ class AbstractDocument(event.EventDispatcher):
             if element._position >= start:  # noqa: SLF001
                 element._position += len_text  # noqa: SLF001
 
-    def append_text(self, text: str, attributes: dict[str, Any] | None = None) -> None:
-        """Append text into the end of document.
-
-        Dispatches an :py:meth:`~pyglet.text.document.AbstractDocument.on_insert_text` event.
-
-        Args:
-            text:
-                Text to append.
-            attributes:
-                Optional dictionary giving named style attributes of the appended text.
-        """  # noqa: D411, D405, D214, D410
-        start = len(self._text)
-        self._append_text(text, attributes)
-        self.dispatch_event("on_insert_text", start, text)
-
-    def _append_text(self, text: str, attributes: dict[str, Any] | None) -> None:
-        self._text += text
-
     def delete_text(self, start: int, end: int) -> None:
         """Delete text from the document.
 
@@ -645,49 +627,21 @@ class FormattedDocument(AbstractDocument):
     def get_element_runs(self) -> _ElementIterator:
         return _ElementIterator(self._elements, len(self._text))
 
-    def _insert_text(self, start: int, text: str, attributes: dict[str, Any] | None) -> None:
+    def _insert_text(self, start: int, text: str, attributes: dict[str, Any]) -> None:
         super()._insert_text(start, text, attributes)
 
         len_text = len(text)
-        if attributes is None:
-            for runs in self._style_runs.values():
-                runs.insert(start, len_text)
-
-        else:
-            for name, runs in self._style_runs.items():
-                if name not in attributes:
-                    runs.insert(start, len_text)
-
-            for attribute, value in attributes.items():
-                try:
-                    runs = self._style_runs[attribute]
-                except KeyError:
-                    runs = self._style_runs[attribute] = runlist.RunList(0, None)
-                    runs.append(len(self.text))
-                    runs.set_run(start, start+len_text, value)
-                else:
-                    runs.insert_run(start, len_text, value)
-
-    def _append_text(self, text: str, attributes: dict[str, Any] | None) -> None:
-        super()._append_text(text, attributes)
-
-        len_text = len(text)
-        if attributes is None:
-            for runs in self._style_runs.values():
-                runs.append(len_text)
-
-        else:
-            for name, runs in self._style_runs.items():
-                if name not in attributes:
-                    runs.append(len_text)
+        for runs in self._style_runs.values():
+            runs.insert(start, len_text)
 
+        if attributes is not None:
             for attribute, value in attributes.items():
                 try:
                     runs = self._style_runs[attribute]
                 except KeyError:
                     runs = self._style_runs[attribute] = runlist.RunList(0, None)
-                    runs.append(len(self.text) - len_text)
-                runs.append_run(len_text, value)
+                    runs.insert(0, len(self.text))
+                runs.set_run(start, start + len_text, value)
 
     def _delete_text(self, start: int, end: int) -> None:
         super()._delete_text(start, end)

pyglet/text/formats/attributed.py

@@ -30,6 +30,7 @@ class AttributedTextDecoder(pyglet.text.DocumentDecoder):  # noqa: D101
 
     def __init__(self) -> None:  # noqa: D107
         self.doc = pyglet.text.document.FormattedDocument()
+        self.length = 0
         self.attributes = {}
 
     def decode(self, text: str, location: Location | None = None) -> pyglet.text.document.FormattedDocument:  # noqa: ARG002
@@ -77,5 +78,6 @@ class AttributedTextDecoder(pyglet.text.DocumentDecoder):  # noqa: D101
         return self.doc
 
     def append(self, text: str) -> None:
-        self.doc.append_text(text, self.attributes)
+        self.doc.insert_text(self.length, text, self.attributes)
+        self.length += len(text)
         self.attributes.clear()

pyglet/text/formats/plaintext.py

@@ -13,5 +13,5 @@ if TYPE_CHECKING:
 class PlainTextDecoder(pyglet.text.DocumentDecoder):  # noqa: D101
     def decode(self, text: str, location: Location | None=None) -> UnformattedDocument:  # noqa: ARG002
         document = pyglet.text.document.UnformattedDocument()
-        document.append_text(text)
+        document.insert_text(0, text)
         return document

pyglet/text/formats/structured.py

@@ -315,7 +315,7 @@ class StructuredTextDecoder(pyglet.text.DocumentDecoder):  # noqa: D101
                 break
 
     def add_text(self, text: str) -> None:
-        self.document.append_text(text, self.next_style)
+        self.document.insert_text(self.len_text, text, self.next_style)
         self.next_style.clear()
         self.len_text += len(text)
 

pyglet/text/layout/base.py

@@ -33,6 +33,7 @@ from pyglet.gl import (
 )
 from pyglet.graphics import Group
 from pyglet.text import runlist
+from pyglet.font.base import GlyphPosition
 
 if TYPE_CHECKING:
     from pyglet.customtypes import AnchorX, AnchorY, ContentVAlign, HorizontalAlign
@@ -102,7 +103,7 @@ layout_fragment_source = """#version 330 core
 
     void main()
     {
-        final_colors = vec4(text_colors.rgb, texture(text, texture_coords).a * text_colors.a);
+        final_colors = texture(text, texture_coords) * text_colors;
         if (scissor == true) {
             if (vert_position.x < scissor_area[0]) discard;                     // left
             if (vert_position.y < scissor_area[1]) discard;                     // bottom
@@ -410,25 +411,26 @@ class _AbstractBox(ABC):
 class _GlyphBox(_AbstractBox):
     owner: Texture
     font: Font
-    glyphs: list[tuple[int, Glyph]]
+    glyphs: list[tuple[int, Glyph, GlyphPosition]]
     advance: int
     vertex_lists: list[_LayoutVertexList]
 
-    def __init__(self, owner: Texture, font: Font, glyphs: list[tuple[int, Glyph]], advance: int) -> None:
+    def __init__(self, owner: Texture, font: Font, glyphs: list[tuple[int, Glyph, GlyphPosition]], advance: int) -> None:
         """Create a run of glyphs sharing the same texture.
 
-        :Parameters:
-            `owner` : `pyglet.image.Texture`
+        Args:
+            owner:
                 Texture of all glyphs in this run.
-            `font` : `pyglet.font.base.Font`
+            font:
                 Font of all glyphs in this run.
-            `glyphs` : list of (int, `pyglet.font.base.Glyph`)
+            glyphs:
                 Pairs of ``(kern, glyph)``, where ``kern`` gives horizontal
                 displacement of the glyph in pixels (typically 0).
-            `advance` : int
+            advance:
                 Width of glyph run; must correspond to the sum of advances
                 and kerns in the glyph list.
-
+            offsets:
+                A list of all position transformations done to each glyph.
         """
         super().__init__(font.ascent, font.descent, advance, len(glyphs))
         assert owner
@@ -446,7 +448,7 @@ class _GlyphBox(_AbstractBox):
               rotation: float, visible: bool, anchor_x: float, anchor_y: float, context: _LayoutContext) -> None:
         # Creates the initial attributes and vertex lists of the glyphs.
         # line_x/line_y are calculated when lines shift. To prevent having to destroy and recalculate the layout
-        # everytime we move this layout, we bake those into the vertices. This way the translate can be moved directly.
+        # everytime it moves, they are merged into the vertices. This way the translation can be moved directly.
         assert self.glyphs
         assert not self.vertex_lists
         try:
@@ -463,17 +465,19 @@ class _GlyphBox(_AbstractBox):
         for start, end, baseline_ in context.baseline_iter.ranges(i, i + n_glyphs):
             baseline = layout._parse_distance(baseline_)  # noqa: SLF001
             assert len(self.glyphs[start - i:end - i]) == end - start
-            for kern, glyph in self.glyphs[start - i:end - i]:
+            for (kern, glyph, glyph_pos) in self.glyphs[start - i:end - i]:
                 x1 += kern
                 v0, v1, v2, v3 = glyph.vertices
-                v0 += x1
-                v2 += x1
-                v1 += line_y + baseline
-                v3 += line_y + baseline
+                v0 += x1 + glyph_pos.x_offset
+                v2 += x1 + glyph_pos.x_offset
+                v1 += line_y + baseline + glyph_pos.y_offset
+                v3 += line_y + baseline + glyph_pos.y_offset
                 vertices.extend(map(round, [v0, v1, 0, v2, v1, 0, v2, v3, 0, v0, v3, 0]))
                 t = glyph.tex_coords
                 tex_coords.extend(t)
-                x1 += glyph.advance
+                x1 += glyph.advance + glyph_pos.x_advance
+                v1 += glyph_pos.y_advance
+                v3 += glyph_pos.y_advance
 
         # Text color
         colors = []
@@ -519,8 +523,8 @@ class _GlyphBox(_AbstractBox):
         for start, end, decoration in context.decoration_iter.ranges(i, i + n_glyphs):
             bg, underline = decoration
             x2 = x1
-            for kern, glyph in self.glyphs[start - i:end - i]:
-                x2 += glyph.advance + kern
+            for (kern, glyph, glyph_pos) in self.glyphs[start - i:end - i]:
+                x2 += glyph.advance + kern + glyph_pos.x_advance
 
             if bg is not None:
                 if len(bg) != 4:
@@ -619,19 +623,19 @@ class _GlyphBox(_AbstractBox):
 
     def get_point_in_box(self, position: int) -> int:
         x = 0
-        for (kern, glyph) in self.glyphs:
+        for (kern, glyph, offset) in self.glyphs:
             if position == 0:
                 break
             position -= 1
-            x += glyph.advance + kern
+            x += glyph.advance + kern + offset.x_advance
         return x
 
     def get_position_in_box(self, x: float) -> int:
         position = 0
         last_glyph_x = 0
-        for kern, glyph in self.glyphs:
+        for (kern, glyph, offset) in self.glyphs:
             last_glyph_x += kern
-            if last_glyph_x + glyph.advance // 2 > x:
+            if last_glyph_x + glyph.advance + offset.x_advance // 2 > x:
                 return position
             position += 1
             last_glyph_x += glyph.advance
@@ -813,6 +817,9 @@ class TextDecorationGroup(Group):
         self.program.stop()
 
 
+# Just have one object for empty positions in layout. It won't be modified.
+_empty_pos = GlyphPosition(0, 0, 0, 0)
+
 class TextLayout:
     """Lay out and display documents.
 
@@ -978,11 +985,6 @@ class TextLayout:
         self.group_cache.clear()
         self._update()
 
-    @property
-    def dpi(self) -> float:
-        """Get DPI used by this layout."""
-        return self._dpi
-
     @property
     def document(self) -> AbstractDocument:
         """Document to display.
@@ -1370,17 +1372,12 @@ class TextLayout:
         self._update()
 
     @property
-    def dpi(self):
-        """Get DPI used by this layout.
-
-            Read-only.
-
-            :type: float
-        """
+    def dpi(self) -> float:
+        """Get DPI used by this layout."""
         return self._dpi
 
     @dpi.setter
-    def dpi(self, value):
+    def dpi(self, value: float) -> None:
         self._dpi = value
         self._update()
 
@@ -1438,9 +1435,10 @@ class TextLayout:
 
     def _get_lines(self) -> list[_Line]:
         len_text = len(self._document.text)
-        glyphs = self._get_glyphs()
-        owner_runs = self._get_owner_runs(glyphs)
-        lines = [line for line in self._flow_glyphs(glyphs, owner_runs, 0, len_text)]
+        glyphs, offsets = self._get_glyphs()
+        owner_runs = runlist.RunList(len_text, None)
+        self._get_owner_runs(owner_runs, glyphs, 0, len_text)
+        lines = list(self._flow_glyphs(glyphs, offsets, owner_runs, 0, len_text))
         self._content_width = 0
         self._line_count = len(lines)
         self._flow_lines(lines, 0, self._line_count)
@@ -1620,8 +1618,9 @@ class TextLayout:
         else:
             self._init_document()
 
-    def _get_glyphs(self) -> list[_InlineElementBox | Glyph]:
+    def _get_glyphs(self) -> tuple[list[_InlineElementBox | Glyph], list[tuple[int, int]]]:
         glyphs = []
+        offsets = []
         runs = runlist.ZipRunIterator((
             self._document.get_font_runs(dpi=self._dpi),
             self._document.get_element_runs()))
@@ -1629,28 +1628,33 @@ class TextLayout:
         for start, end, (font, element) in runs.ranges(0, len(text)):
             if element:
                 glyphs.append(_InlineElementBox(element))
+                offsets.append(_empty_pos)
             else:
-                glyphs.extend(font.get_glyphs(text[start:end]))
-        return glyphs
+                char_glyphs, char_offsets = font.get_glyphs(text[start:end])
+                glyphs.extend(char_glyphs)
+                offsets.extend(char_offsets)
+
+        return glyphs, offsets
 
-    def _get_owner_runs(self, glyphs: list[_InlineElementBox | Glyph]) -> runlist.RunList:
-        owner = glyphs[0].owner
-        run_start = 0
-        owner_runs = runlist.RunList(0, owner)
+    def _get_owner_runs(self, owner_runs: runlist.RunList, glyphs: list[_InlineElementBox | Glyph], start: int,
+                        end: int) -> None:
+        owner = glyphs[start].owner
+        run_start = start
 
-        for i, glyph in enumerate(glyphs):
+        # TODO avoid glyph slice on non-incremental
+        for i, glyph in enumerate(glyphs[start:end]):
             if owner != glyph.owner:
-                owner_runs.append_run(i-run_start, owner)
+                owner_runs.set_run(run_start, i + start, owner)
                 owner = glyph.owner
-                run_start = i
-        owner_runs.append_run(len(glyphs)-run_start, owner)
-        return owner_runs
+                run_start = i + start
+        owner_runs.set_run(run_start, end, owner)
 
-    def _flow_glyphs_wrap(self, glyphs: list[_InlineElementBox | Glyph], owner_runs: runlist.RunList, start: int,
+    def _flow_glyphs_wrap(self, glyphs: list[_InlineElementBox | Glyph],
+                          offsets: list[GlyphPosition],
+                          owner_runs: runlist.RunList, start: int,
                           end: int) -> Iterator[_Line]:
         # Word-wrap styled text into lines of fixed width.
         # Fits glyphs in range start to end into Lines which are then yielded.
-
         owner_iterator = owner_runs.get_run_iterator().ranges(start, end)
 
         font_iterator = self._document.get_font_runs(dpi=self._dpi)
@@ -1721,7 +1725,7 @@ class TextLayout:
             # Iterate over glyphs in this owner run.  `text` is the
             # corresponding character data for the glyph, and is used to find
             # whitespace and newlines.
-            for (text, glyph) in zip(self.document.text[start:end], glyphs[start:end]):
+            for (text, glyph, offset) in zip(self.document.text[start:end], glyphs[start:end], offsets[start:end]):
                 if nokern:
                     kern = 0
                     nokern = False
@@ -1747,15 +1751,15 @@ class TextLayout:
                             tab_stop = (((x + line.margin_left) // tab) + 1) * tab
                         kern = int(tab_stop - x - line.margin_left - glyph.advance)
 
-                    owner_accum.append((kern, glyph))
+                    owner_accum.append((kern, glyph, offset))
                     owner_accum_commit.extend(owner_accum)
-                    owner_accum_commit_width += owner_accum_width + glyph.advance + kern
-                    eol_ws += glyph.advance + kern
+                    owner_accum_commit_width += owner_accum_width + glyph.advance + kern + offset.x_advance
+                    eol_ws += glyph.advance + kern + offset.x_advance
 
                     owner_accum = []
                     owner_accum_width = 0
 
-                    x += glyph.advance + kern
+                    x += glyph.advance + kern + offset.x_advance
                     index += 1
 
                     # The index at which the next line will begin (the
@@ -1765,7 +1769,7 @@ class TextLayout:
                 else:
                     new_paragraph = text in "\n\u2029"
                     new_line = (text == "\u2028") or new_paragraph
-                    if (wrap and self._wrap_lines and x + kern + glyph.advance >= width) or new_line:
+                    if (wrap and self._wrap_lines and x + kern + glyph.advance + offset.x_advance >= width) or new_line:
                         # Either the pending runs have overflowed the allowed
                         # line width or a newline was encountered.  Either
                         # way, the current line must be flushed.
@@ -1827,11 +1831,11 @@ class TextLayout:
                             # Remove kern from first glyph of line
                             if run_accum and hasattr(run_accum, "glyphs") and run_accum.glyphs:
                                 k, g = run_accum[0].glyphs[0]
-                                run_accum[0].glyphs[0] = (0, g)
+                                run_accum[0].glyphs[0] = (0, g, _empty_pos)
                                 run_accum_width -= k
                             elif owner_accum:
-                                k, g = owner_accum[0]
-                                owner_accum[0] = (0, g)
+                                k, g, _ = owner_accum[0]
+                                owner_accum[0] = (0, g, _empty_pos)
                                 owner_accum_width -= k
                             else:
                                 nokern = True
@@ -1843,8 +1847,8 @@ class TextLayout:
                     if isinstance(glyph, _AbstractBox):
                         # Glyph is already in a box. XXX Ignore kern?
                         run_accum.append(glyph)
-                        run_accum_width += glyph.advance
-                        x += glyph.advance
+                        run_accum_width += glyph.advance + offset.x_advance
+                        x += glyph.advance + offset.x_advance
                     elif new_paragraph:
                         # New paragraph started, update wrap style
                         wrap = wrap_iterator[next_start]
@@ -1854,9 +1858,9 @@ class TextLayout:
                     elif not new_line:
                         # If the glyph was any non-whitespace, non-newline
                         # character, add it to the pending run.
-                        owner_accum.append((kern, glyph))
-                        owner_accum_width += glyph.advance + kern
-                        x += glyph.advance + kern
+                        owner_accum.append((kern, glyph, offset))
+                        owner_accum_width += glyph.advance + kern + offset.x_advance
+                        x += glyph.advance + kern + offset.x_advance
                     index += 1
                     eol_ws = 0
 
@@ -1882,7 +1886,9 @@ class TextLayout:
 
         yield line
 
-    def _flow_glyphs_single_line(self, glyphs: list[_InlineElementBox | Glyph], owner_runs: runlist.RunList,
+    def _flow_glyphs_single_line(self, glyphs: list[_InlineElementBox | Glyph],
+                                 offsets: list[GlyphPosition],
+                                 owner_runs: runlist.RunList,
                                  start: int, end: int) -> Iterator[_Line]:
         owner_iterator = owner_runs.get_run_iterator().ranges(start, end)
         font_iterator = self.document.get_font_runs(dpi=self._dpi)
@@ -1905,9 +1911,11 @@ class TextLayout:
             owner_glyphs = []
             for kern_start, kern_end, kern in kern_iterator.ranges(start, end):
                 gs = glyphs[kern_start:kern_end]
+                os = offsets[kern_start:kern_end]
                 width += sum([g.advance for g in gs])
                 width += kern * (kern_end - kern_start)
-                owner_glyphs.extend(zip([kern] * (kern_end - kern_start), gs))
+                width += sum([o.x_advance for o in os])
+                owner_glyphs.extend(zip([kern] * (kern_end - kern_start), gs, os))
             if owner is None:
                 # Assume glyphs are already boxes.
                 for kern, glyph in owner_glyphs: