Refactor drawing to use pyglet.shapes and improve macOS support

Replaces low-level pyglet.graphics drawing calls with pyglet.shapes primitives for lines, circles, and rectangles in graphics and widgets modules. Adds platform-specific handling for PyObjC dependencies and pyglet options for better compatibility on macOS, including PyPy support. Updates setup.py to install PyObjC only on CPython/macOS, and improves documentation for macOS and PyPy users.

Author: ulfarsson

README.rst

@@ -21,7 +21,20 @@ Pyperclip requires clipboard tools that might not come pre-installed.
 
    sudo apt-get install xclip
 
-Without them the app still works but pasting won’t.
+Without them the app still works but pasting won't.
+
+Note for macOS
+~~~~~~~~~~~~~~
+
+PyObjC is automatically installed on macOS systems for proper Cocoa/OpenGL integration with pyglet 2.0+. If you encounter OpenGL surface errors, ensure PyObjC is installed:
+
+.. code:: sh
+
+   pip install pyobjc-core pyobjc-framework-Cocoa
+
+This is handled automatically during normal installation.
+
+**PyPy Users**: PyObjC doesn't support PyPy. TilingsGUI automatically configures pyglet to use shadow context disabled mode for PyPy compatibility on macOS.
 
 Known issues
 ------------

setup.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 import os
+import sys
 
 from setuptools import find_packages, setup
 
@@ -16,6 +17,18 @@ def get_version():
     raise ValueError("Version not found in tilingsgui/__init__.py")
 
 
+def get_install_requires():
+    """Get install requirements, including platform-specific dependencies."""
+    base_requires = ["pyperclip>=1.9.0", "pyglet>=2.0.0", "tilings>=2.5.0"]
+
+    # Add macOS-specific dependencies for pyglet Cocoa integration
+    # Only on CPython, not PyPy (PyObjC doesn't support PyPy)
+    if sys.platform == "darwin" and sys.implementation.name == "cpython":
+        base_requires.extend(["pyobjc-core", "pyobjc-framework-Cocoa"])
+
+    return base_requires
+
+
 setup(
     name="tilingsgui",
     version=get_version(),
@@ -31,7 +44,7 @@ def get_version():
     },
     packages=find_packages(exclude=["*.tests", "*.tests.*", "tests.*", "tests"]),
     long_description=read("README.rst"),
-    install_requires=["pyperclip>=1.9.0", "pyglet>=1.5.15,<2.0", "tilings>=2.5.0"],
+    install_requires=get_install_requires(),
     python_requires=">=3.8",
     include_package_data=True,
     classifiers=[

tilingsgui/app.py

@@ -5,10 +5,17 @@
 
 # pylint: disable=abstract-method
 
+import sys
 from typing import ClassVar, Tuple
 
 import pyglet
 
+# Configure pyglet for PyPy compatibility on macOS
+# PyPy doesn't support PyObjC, so we disable shadow context for high-res displays
+if sys.platform == "darwin" and sys.implementation.name == "pypy":
+    pyglet.options["shadow_window"] = False
+
+# pylint: disable=wrong-import-position
 from .files import History, PathManager
 from .graphics import Color
 from .menu import RightMenu, TopMenu
@@ -90,7 +97,7 @@ def _initial_config(self) -> None:
         """Configuration done before starting."""
 
         # Center the window within the os.
-        screen = pyglet.canvas.Display().get_default_screen()
+        screen = pyglet.display.Display().get_default_screen()  # type: ignore
         self.set_location(
             (screen.width - self.width) // 2, (screen.height - self.height) // 2
         )
@@ -100,7 +107,7 @@ def _initial_config(self) -> None:
 
         # Handle clearing the canvas on each draw.
         pyglet.gl.glClearColor(*TilingGui._CLEAR_COLOR)
-        self.push_handlers(on_draw=self.clear)
+        self.push_handlers(on_draw=self.clear)  # pylint: disable=unreachable
 
     def on_resize(self, width: int, height: int) -> bool:
         """Event handler for the window resize event.

tilingsgui/graphics.py

@@ -1,9 +1,9 @@
 """Drawable objects"""
 
-from math import cos, pi, sin
 from typing import ClassVar, List, Tuple
 
 import pyglet
+import pyglet.shapes
 
 from .geometry import Point
 
@@ -32,12 +32,10 @@ def draw_line_segment(
             y2 (float): End y coordinate.
             color (Tuple[float, float, float]): RGB valued color.
         """
-        pyglet.graphics.draw(
-            2,
-            pyglet.gl.GL_LINE_STRIP,
-            (GeoDrawer._VERTEX_MODE, [x1, y1, x2, y2]),
-            (GeoDrawer._COLOR_MODE, color * 2),
-        )
+        # Convert RGB (0-1) to RGBA (0-255) for pyglet.shapes
+        color_255 = (int(color[0] * 255), int(color[1] * 255), int(color[2] * 255), 255)
+        line = pyglet.shapes.Line(x1, y1, x2, y2, color=color_255)
+        line.draw()
 
     @staticmethod
     def draw_circle(x: float, y: float, r: float, color: C3F, splits: int = 30) -> None:
@@ -51,17 +49,11 @@ def draw_circle(x: float, y: float, r: float, color: C3F, splits: int = 30) -> N
             splits (int, optional): How detailed the polygon emulating a circle should
             be. Higher values increase detail.
         """
-        vertices = [x, y]
-        for i in range(splits + 1):
-            ang = 2 * pi * i / splits
-            vertices.append(x + cos(ang) * r)
-            vertices.append(y + sin(ang) * r)
-        pyglet.graphics.draw(
-            splits + 2,
-            pyglet.gl.GL_TRIANGLE_FAN,
-            (GeoDrawer._VERTEX_MODE, vertices),
-            (GeoDrawer._COLOR_MODE, color * (splits + 2)),
-        )
+        # Convert RGB (0-1) to RGBA (0-255) for pyglet.shapes
+        # Note: pyglet.shapes.Circle uses segments parameter for detail level
+        color_255 = (int(color[0] * 255), int(color[1] * 255), int(color[2] * 255), 255)
+        circle = pyglet.shapes.Circle(x, y, r, color=color_255, segments=splits)
+        circle.draw()
 
     @staticmethod
     def draw_point(point: Point, size: float, color: C3F) -> None:
@@ -85,12 +77,10 @@ def draw_rectangle(x: float, y: float, w: float, h: float, color: C3F) -> None:
             h (float): Vertical length.
             color (Tuple[float, float, float]): Fill color.
         """
-        pyglet.graphics.draw(
-            4,
-            pyglet.gl.GL_TRIANGLE_STRIP,
-            (GeoDrawer._VERTEX_MODE, [x, y, x, y + h, x + w, y, x + w, y + h]),
-            (GeoDrawer._COLOR_MODE, color * 4),
-        )
+        # Convert RGB (0-1) to RGBA (0-255) for pyglet.shapes
+        color_255 = (int(color[0] * 255), int(color[1] * 255), int(color[2] * 255), 255)
+        rectangle = pyglet.shapes.Rectangle(x, y, w, h, color=color_255)
+        rectangle.draw()
 
     @staticmethod
     def draw_point_path(pnt_path: List[Point], color: C3F, point_size: float) -> None:
@@ -104,13 +94,18 @@ def draw_point_path(pnt_path: List[Point], color: C3F, point_size: float) -> Non
         n = len(pnt_path)
         if n > 0:
             if n > 1:
-                vertices = [coord for pnt in pnt_path for coord in pnt.coords()]
-                pyglet.graphics.draw(
-                    n,
-                    pyglet.gl.GL_LINE_STRIP,
-                    (GeoDrawer._VERTEX_MODE, vertices),
-                    (GeoDrawer._COLOR_MODE, color * n),
+                # Draw line segments between adjacent points
+                color_255 = (
+                    int(color[0] * 255),
+                    int(color[1] * 255),
+                    int(color[2] * 255),
+                    255,
                 )
+                for i in range(n - 1):
+                    p1, p2 = pnt_path[i], pnt_path[i + 1]
+                    line = pyglet.shapes.Line(p1.x, p1.y, p2.x, p2.y, color=color_255)
+                    line.draw()
+            # Draw points
             for pnt in pnt_path:
                 GeoDrawer.draw_point(pnt, point_size, color)
 

tilingsgui/widgets.py

@@ -32,7 +32,13 @@ def __init__(self, init_text: str, font_size: int, color: RGBA) -> None:
         self._document.set_style(0, 0, {"font_size": font_size, "color": color})
         self._layout: pyglet.text.layout.IncrementalTextLayout = (
             pyglet.text.layout.IncrementalTextLayout(
-                self._document, 0, 0, multiline=False, batch=self._batch
+                self._document,
+                x=0,
+                y=0,
+                width=100,
+                height=20,  # Will be updated in position()
+                multiline=False,
+                batch=self._batch,
             )
         )
         self._caret: pyglet.text.caret.Caret = pyglet.text.caret.Caret(self._layout)
@@ -47,10 +53,10 @@ def position(self, x: float, y: float, w: float, h: float) -> None:
             w (float): The horizontal length of the component.
             h (float): The vertical length of the component.
         """
-        self._layout.x = x + Text._LEFT_PAD
-        self._layout.y = y
-        self._layout.width = w - Text._LEFT_PAD
-        self._layout.height = h
+        self._layout.x = int(x + Text._LEFT_PAD)
+        self._layout.y = int(y)
+        self._layout.width = int(w - Text._LEFT_PAD)
+        self._layout.height = int(h)
 
     def set_focus(self) -> None:
         """Set focus on the input text. This is needed to write to it."""
@@ -118,12 +124,20 @@ def __init__(
             box_color (Tuple[float, float, float]): The rgb color of the box.
         """
         super().__init__(init_text, font_size, text_color)
-        self._vertex_list: pyglet.graphics.vertexdomain.VertexList = self._batch.add(
-            4,
-            pyglet.gl.GL_QUADS,
-            None,
-            ("v2f", [0] * 8),
-            ("c3B", box_color * 4),
+        # Convert RGB (0-1) to RGBA (0-255) for pyglet.shapes
+        box_color_255 = (
+            int(box_color[0] * 255),
+            int(box_color[1] * 255),
+            int(box_color[2] * 255),
+            255,
+        )
+        self._rectangle = pyglet.shapes.Rectangle(
+            x=0,
+            y=0,
+            width=100,
+            height=20,  # Will be updated in position()
+            color=box_color_255,
+            batch=self._batch,
         )
 
     def position(self, x: float, y: float, w: float, h: float) -> None:
@@ -136,8 +150,10 @@ def position(self, x: float, y: float, w: float, h: float) -> None:
             h (float): The vertical length of the component.
         """
         super().position(x, y, w, h)
-        for i, vertex in enumerate((x, y, x + w, y, x + w, y + h, x, y + h)):
-            self._vertex_list.vertices[i] = vertex
+        self._rectangle.x = x
+        self._rectangle.y = y
+        self._rectangle.width = w
+        self._rectangle.height = h
 
     def hit_test(self, x: float, y: float) -> bool:
         """Is the point (x,y) inside the rectangle that the text box forms.
@@ -150,8 +166,8 @@ def hit_test(self, x: float, y: float) -> bool:
             [type]: True iff inside.
         """
         return (
-            self._vertex_list.vertices[0] < x < self._vertex_list.vertices[2]
-            and self._vertex_list.vertices[1] < y < self._vertex_list.vertices[5]
+            self._rectangle.x < x < self._rectangle.x + self._rectangle.width
+            and self._rectangle.y < y < self._rectangle.y + self._rectangle.height
         )