pyglet 2.1.6__py3-none-any.whl → 2.1.9__py3-none-any.whl

pyglet/gl/xlib.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import warnings
+from _ctypes import _Pointer
 from ctypes import POINTER, byref, c_int, c_uint, cast
 from typing import TYPE_CHECKING, NoReturn
 
@@ -13,6 +14,8 @@ from pyglet.gl import lib
 from pyglet.gl.base import Config, DisplayConfig, Context
 
 from pyglet.display.xlib import XlibCanvas
+from pyglet.libs.x11 import xlib
+from pyglet.libs.x11.xrender import XRenderFindVisualFormat
 
 if TYPE_CHECKING:
     from pyglet.libs.x11.xlib import Display
@@ -52,6 +55,10 @@ class XlibConfig(Config):  # noqa: D101
 
         result = [XlibDisplayConfig(canvas, info, c, self) for c in configs]
 
+        # If we intend to have a transparent framebuffer.
+        if self.transparent_framebuffer:
+            result = [fb_cf for fb_cf in result if fb_cf.transparent]
+
         # Can't free array until all XlibGLConfig's are GC'd.  Too much
         # hassle, live with leak. XXX
         # xlib.XFree(configs)
@@ -102,6 +109,7 @@ class XlibDisplayConfig(DisplayConfig):  # noqa: D101
 
         self.glx_info = info
         self.fbconfig = fbconfig
+        self.transparent = False
 
         for name, attr in self.attribute_ids.items():
             value = c_int()
@@ -110,6 +118,22 @@ class XlibDisplayConfig(DisplayConfig):  # noqa: D101
             if result >= 0:
                 setattr(self, name, value.value)
 
+        # If user intends for a transparent framebuffer, the visual info needs to be
+        # queried for it. Even if a config supports alpha_size 8 and depth_size 32, there is no
+        # guarantee the visual info supports that same configuration.
+        if config.transparent_framebuffer:
+            xvi_ptr = glx.glXGetVisualFromFBConfig(canvas.display._display, self.fbconfig)  # noqa: SLF001
+            if xvi_ptr:
+                self.transparent = self._is_visual_transparent(xvi_ptr.contents.visual)  # noqa: SLF001
+                xlib.XFree(xvi_ptr)
+
+    def _is_visual_transparent(self, visual: _Pointer[xlib.Visual]) -> bool:
+        if not XRenderFindVisualFormat:
+            return False
+
+        xrender_format = XRenderFindVisualFormat(self.canvas.display._display, visual)
+        return xrender_format and xrender_format.contents.direct.alphaMask != 0
+
     def get_visual_info(self) -> glx.XVisualInfo:
         return glx.glXGetVisualFromFBConfig(self.canvas.display._display, self.fbconfig).contents  # noqa: SLF001
 

pyglet/graphics/shader.py

@@ -58,6 +58,7 @@ from pyglet.gl.gl import (
     glUnmapBuffer,
     glUseProgram,
     glVertexAttribDivisor,
+    glVertexAttribIPointer,
     glVertexAttribPointer,
 )
 from pyglet.graphics.vertexbuffer import AttributeBufferObject, BufferObject
@@ -257,6 +258,9 @@ class Attribute:
         self.element_size = sizeof(self.c_type)
         self.stride = count * self.element_size
 
+        self._is_int = gl_type in (gl.GL_INT, gl.GL_SHORT, gl.GL_BYTE, gl.GL_UNSIGNED_INT,
+                                   gl.GL_UNSIGNED_SHORT, gl.GL_UNSIGNED_BYTE) and self.normalize is False
+
     def enable(self) -> None:
         """Enable the attribute."""
         glEnableVertexAttribArray(self.location)
@@ -271,7 +275,10 @@ class Attribute:
                 Pointer offset to the currently bound buffer for this attribute.
 
         """
-        glVertexAttribPointer(self.location, self.count, self.gl_type, self.normalize, self.stride, ptr)
+        if self._is_int:
+            glVertexAttribIPointer(self.location, self.count, self.gl_type, self.stride, ptr)
+        else:
+            glVertexAttribPointer(self.location, self.count, self.gl_type, self.normalize, self.stride, ptr)
 
     def set_divisor(self) -> None:
         glVertexAttribDivisor(self.location, 1)

pyglet/graphics/vertexbuffer.py

@@ -1,6 +1,6 @@
 """OpenGL Buffer Objects.
 
-:py:class:`~BufferObject` and a :py:class:`~BackedBufferObject` are provied.
+:py:class:`~BufferObject` and a :py:class:`~BackedBufferObject` are provided.
 The first is a lightweight abstraction over an OpenGL buffer, as created
 with ``glGenBuffers``. The backed buffer object is similar, but provides a
 full mirror of the data in CPU memory. This allows for delayed uploading of

pyglet/gui/frame.py

@@ -24,7 +24,7 @@ class Frame:
 
         Args:
             window:
-                The SpatialHash will recieve events from this Window.
+                The SpatialHash will receive events from this Window.
                 Appropriate events will be passed on to all added Widgets.
             enable:
                 Whether to enable frame.
@@ -168,7 +168,7 @@ class MovableFrame(Frame):
 
         Args:
             window:
-                The SpatialHash will recieve events from this Window.
+                The SpatialHash will receive events from this Window.
                 Appropriate events will be passed on to all added Widgets.
             enable:
                 Whether to enable frame.

pyglet/gui/widgets.py

@@ -601,7 +601,7 @@ class TextEntry(WidgetBase):
             self._caret.on_text_motion_select(motion)
 
     def on_commit(self, widget: TextEntry, text: str) -> None:
-        """Event: dispatches the current text when commited via Enter/Return key."""
+        """Event: dispatches the current text when committed via Enter/Return key."""
 
 
 TextEntry.register_event_type('on_commit')

pyglet/image/__init__.py

@@ -556,7 +556,7 @@ class ImageData(AbstractImage):
         Note:
              Conversion to another format is done on the CPU, and can be
              somewhat costly for larger images. Consider performing conversion
-             at load time for framerate sensitive applictions.
+             at load time for framerate sensitive applications.
         """
         fmt = fmt or self._desired_format
         pitch = pitch or self._current_pitch
@@ -1201,7 +1201,7 @@ class Texture(AbstractImage):
                            layer: int = 0, access: int = GL_READ_WRITE, fmt: int = GL_RGBA32F):
         """Bind as an ImageTexture for use with a :py:class:`~pyglet.shader.ComputeShaderProgram`.
 
-        .. note:: OpenGL 4.3, or 4.2 with the GL_ARB_compute_shader extention is required.
+        .. note:: OpenGL 4.3, or 4.2 with the GL_ARB_compute_shader extension is required.
         """
         glBindImageTexture(unit, self.id, level, layered, layer, access, fmt)
 
@@ -1211,7 +1211,7 @@ class Texture(AbstractImage):
                fmt: int = GL_RGBA, blank_data: bool = True) -> Texture:
         """Create a Texture
 
-        Create a Texture with the specified dimentions, target and format.
+        Create a Texture with the specified dimensions, target and format.
         On return, the texture will be bound.
 
         Args:

pyglet/image/buffer.py

@@ -1,7 +1,7 @@
 """OpenGL Framebuffer abstractions.
 
 This module provides classes for working with Framebuffers & Renderbuffers
-and their attachments. Attachements can be pyglet Texture objects, which allows
+and their attachments. Attachments can be pyglet Texture objects, which allows
 easily accessing their data, saving to disk, etc. Renderbuffers can be used
 if you don't need to access their data at a later time. For example::
 
@@ -40,7 +40,7 @@ if TYPE_CHECKING:
 
 
 def get_max_color_attachments() -> int:
-    """Get the maximum allow Framebuffer Color attachements."""
+    """Get the maximum allow Framebuffer Color attachments."""
     number = GLint()
     glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, number)
     return number.value
@@ -144,7 +144,7 @@ class Framebuffer:
 
         Unbind should be called to prevent further rendering
         to the framebuffer, or if you wish to access data
-        from its Texture atachments.
+        from its Texture attachments.
         """
         glBindFramebuffer(self.target, 0)
 

pyglet/input/base.py

@@ -71,7 +71,7 @@ class Device:
         Args:
             window:
                 Optional window to associate with the device.  The behaviour
-                of this parameter is device and operating system dependant.
+                of this parameter is device and operating system dependent.
                 It can usually be omitted for most devices.
             exclusive:
                 If ``True`` the device will be opened exclusively so that no
@@ -103,7 +103,7 @@ class Device:
         string. This is generated from the hardware identifiers,
         and is in the same format as was popularized by SDL2.
         GUIDs differ between platforms, but are generally 32
-        hexidecimal characters.
+        hexadecimal characters.
         """
         raise NotImplementedError('abstract')
 
@@ -506,7 +506,7 @@ class Controller(EventDispatcher):
     """
 
     def __init__(self, device: Device, mapping: dict):
-        """Create a Controller instace mapped to a Device.
+        """Create a Controller instance mapped to a Device.
 
         .. versionadded:: 2.0
         """
@@ -520,6 +520,7 @@ class Controller(EventDispatcher):
         #: The unique guid for this Device
         self.guid: str = mapping.get('guid')
 
+        # Pollable
         self.a: bool = False
         self.b: bool = False
         self.x: bool = False
@@ -534,6 +535,10 @@ class Controller(EventDispatcher):
 
         self.lefttrigger: float = 0.0
         self.righttrigger: float = 0.0
+        self.dpad: Vec2 = Vec2()
+        self.leftanalog: Vec2 = Vec2()
+        self.rightanalog: Vec2 = Vec2()
+
         self.leftx: float = 0.0
         self.lefty: float = 0.0
         self.rightx: float = 0.0
@@ -575,7 +580,7 @@ class Controller(EventDispatcher):
             A string, currently one of "PS", "XB", or "GENERIC".
         """
         product_id = None
-        # TODO: add more checks for vender hardware ids.
+        # TODO: add more checks for vendor hardware ids.
 
         # Windows
         if self.name == 'XINPUTCONTROLLER':
@@ -617,12 +622,14 @@ class Controller(EventDispatcher):
             @control.event
             def on_change(value):
                 self.dpady = round(value * scale + bias) * sign    # normalized
+                self.dpad = Vec2(self.dpadx, self.dpady)
                 self.dispatch_event('on_dpad_motion', self, Vec2(self.dpadx, self.dpady))
 
         elif axis_name in ("dpleft", "dpright"):
             @control.event
             def on_change(value):
                 self.dpadx = round(value * scale + bias) * sign     # normalized
+                self.dpad = Vec2(self.dpadx, self.dpady)
                 self.dispatch_event('on_dpad_motion', self, Vec2(self.dpadx, self.dpady))
 
         elif axis_name in ("lefttrigger", "righttrigger"):
@@ -637,14 +644,16 @@ class Controller(EventDispatcher):
             def on_change(value):
                 normalized_value = value * scale + bias
                 setattr(self, axis_name, normalized_value)
-                self.dispatch_event('on_stick_motion', self, "leftstick", Vec2(self.leftx, -self.lefty))
+                self.left_analog = Vec2(self.leftx, -self.lefty)
+                self.dispatch_event('on_stick_motion', self, "leftstick", self.left_analog)
 
         elif axis_name in ("rightx", "righty"):
             @control.event
             def on_change(value):
                 normalized_value = value * scale + bias
                 setattr(self, axis_name, normalized_value)
-                self.dispatch_event('on_stick_motion', self, "rightstick", Vec2(self.rightx, -self.righty))
+                self.right_analog = Vec2(self.rightx, -self.righty)
+                self.dispatch_event('on_stick_motion', self, "rightstick", self.right_analog)
 
     def _bind_button_control(self, relation: Relation, control: Button, button_name: str) -> None:
         if button_name in ("dpleft", "dpright", "dpup", "dpdown"):
@@ -655,7 +664,8 @@ class Controller(EventDispatcher):
             def on_change(value):
                 target, bias = defaults[button_name]
                 setattr(self, target, bias * value)
-                self.dispatch_event('on_dpad_motion', self, Vec2(self.dpadx, self.dpady))
+                self.dpad = Vec2(self.dpadx, self.dpady)
+                self.dispatch_event('on_dpad_motion', self, self.dpad)
         else:
             @control.event
             def on_change(value):
@@ -672,7 +682,7 @@ class Controller(EventDispatcher):
     def _bind_dedicated_hat(self, relation: Relation, control: AbsoluteAxis) -> None:
         # 8-directional hat encoded as a single control (Windows/Mac)
         _vecs = (Vec2(0.0, 1.0), Vec2(1.0, 1.0), Vec2(1.0, 0.0), Vec2(1.0, -1.0),       # n, ne, e, se
-                  Vec2(0.0, -1.0), Vec2(-1.0, -1.0), Vec2(-1.0, 0.0), Vec2(-1.0, 1.0))   # s, sw, w, nw
+                 Vec2(0.0, -1.0), Vec2(-1.0, -1.0), Vec2(-1.0, 0.0), Vec2(-1.0, 1.0))   # s, sw, w, nw
         _input_map = {key: val for key, val in zip(range(int(control.min), int(control.max + 1)), _vecs)}
 
         # For some Directinput devices:
@@ -681,7 +691,7 @@ class Controller(EventDispatcher):
         @control.event
         def on_change(value):
             vector = _input_map.get(value // _scale, Vec2(0.0, 0.0))
-            self.dpadx, self.dpady = vector
+            self.dpad = vector
             self.dispatch_event('on_dpad_motion', self, vector)
 
     def _initialize_controls(self) -> None:
@@ -730,8 +740,8 @@ class Controller(EventDispatcher):
 
                         self._bind_axis_control(relation, control, dpname)
 
-            except IndexError:
-                warnings.warn(f"Could not map '{relation}' to '{name}'")
+            except (IndexError, AttributeError, KeyError):
+                warnings.warn(f"Could not map physical Control '{relation}' to '{name}'")
                 continue
 
     def open(self, window: None | BaseWindow = None, exclusive: bool = False) -> None:
@@ -1096,7 +1106,7 @@ class ControllerManager(EventDispatcher):
 
     def on_connect(self, controller) -> Controller:
         """A Controller has been connected. If this is
-        a previously dissconnected Controller that is
+        a previously disconnected Controller that is
         being re-connected, the same Controller instance
         will be returned.
         """

pyglet/input/linux/evdev.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import time
 import ctypes
+import select
 import warnings
 import threading
 
@@ -11,6 +12,7 @@ from ctypes import c_int16 as _s16
 from ctypes import c_uint32 as _u32
 from ctypes import c_int32 as _s32
 from ctypes import c_int64 as _s64
+from ctypes import c_byte as _c_byte
 
 import pyglet
 
@@ -31,6 +33,24 @@ except ImportError:
         return c.read(fd, buffers, 3072)
 
 
+KeyMaxArray = _c_byte * ((KEY_MAX // 8) + 1)
+
+
+class EvdevButton(Button):
+    event_type: int
+    event_code: int
+
+
+class EvdevAbsoluteAxis(AbsoluteAxis):
+    event_type: int
+    event_code: int
+
+
+class EvdevRelativeAxis(RelativeAxis):
+    event_type: int
+    event_code: int
+
+
 # Structures from /linux/blob/master/include/uapi/linux/input.h
 
 class Timeval(ctypes.Structure):
@@ -158,11 +178,13 @@ class FFEvent(ctypes.Structure):
     )
 
 
+# Helper "macros" for file io:
 EVIOCGVERSION = _IOR('E', 0x01, ctypes.c_int)
 EVIOCGID = _IOR('E', 0x02, InputID)
 EVIOCGNAME = _IOR_str('E', 0x06)
 EVIOCGPHYS = _IOR_str('E', 0x07)
 EVIOCGUNIQ = _IOR_str('E', 0x08)
+EVIOCGKEY = _IOR_len('E', 0x18)
 EVIOCSFF = _IOW('E', 0x80, FFEvent)
 
 
@@ -170,9 +192,14 @@ def EVIOCGBIT(fileno, ev, buffer):
     return _IOR_len('E', 0x20 + ev)(fileno, buffer)
 
 
-def EVIOCGABS(fileno, abs):
-    buffer = InputABSInfo()
-    return _IOR_len('E', 0x40 + abs)(fileno, buffer)
+def EVIOCGABS(fileno, ev, buffer=InputABSInfo()):
+    print("absbuffer instance:", buffer)
+    return _IOR_len('E', 0x40 + ev)(fileno, buffer)
+
+
+def get_key_state(fileno, event_code, buffer=KeyMaxArray()):
+    buffer = EVIOCGKEY(fileno, buffer)
+    return bool(buffer[event_code // 8] & (1 << (event_code % 8)))
 
 
 def get_set_bits(bytestring):
@@ -217,18 +244,16 @@ def _create_control(fileno, event_type, event_code):
         value = absinfo.value
         minimum = absinfo.minimum
         maximum = absinfo.maximum
-        control = AbsoluteAxis(name, minimum, maximum, raw_name)
+        control = EvdevAbsoluteAxis(name, minimum, maximum, raw_name, inverted=name == 'hat_y')
         control.value = value
-        if name == 'hat_y':
-            control.inverted = True
     elif event_type == EV_REL:
         raw_name = rel_raw_names.get(event_code, f'EV_REL({event_code:x})')
         name = _rel_names.get(event_code)
-        control = RelativeAxis(name, raw_name)
+        control = EvdevRelativeAxis(name, raw_name)
     elif event_type == EV_KEY:
         raw_name = key_raw_names.get(event_code, f'EV_KEY({event_code:x})')
         name = None
-        control = Button(name, raw_name)
+        control = EvdevButton(name, raw_name)
     else:
         return None
     control.event_type = event_type
@@ -248,7 +273,8 @@ event_types = {
 
 
 class EvdevDevice(XlibSelectDevice, Device):
-    _fileno = None
+    _fileno: int | None
+    _poll: "select.poll | None"
 
     def __init__(self, display, filename):
         self._filename = filename
@@ -301,11 +327,14 @@ class EvdevDevice(XlibSelectDevice, Device):
                         self.control_map[(event_type, event_code)] = control
                         self.controls.append(control)
 
-        self.controls.sort(key=lambda c: c.event_code)
+        self.controls.sort(key=lambda ctrl: ctrl.event_code)
         os.close(fileno)
 
+        self._poll = select.poll()
         self._event_size = ctypes.sizeof(InputEvent)
         self._event_buffer = (InputEvent * 64)()
+        self._syn_dropped = False
+        self._event_queue = []
 
         super().__init__(display, name)
 
@@ -321,6 +350,7 @@ class EvdevDevice(XlibSelectDevice, Device):
     def open(self, window=None, exclusive=False):
         try:
             self._fileno = os.open(self._filename, os.O_RDWR | os.O_NONBLOCK)
+            self._poll.register(self._fileno, select.POLLIN | select.POLLPRI)
         except OSError as e:
             raise DeviceOpenException(e)
 
@@ -333,6 +363,9 @@ class EvdevDevice(XlibSelectDevice, Device):
         if not self._fileno:
             return
 
+        if self._poll:
+            self._poll.unregister(self._fileno)
+
         pyglet.app.platform_event_loop.select_devices.remove(self)
         os.close(self._fileno)
         self._fileno = None
@@ -340,6 +373,20 @@ class EvdevDevice(XlibSelectDevice, Device):
     def get_controls(self):
         return self.controls
 
+    def _resync_control_state(self):
+        """Manually resync all Control state.
+
+        This method queries and resets the state of each Control using the appropriate
+        ioctl calls. If this causes the Control value to change, the associated events
+        will be dispatched. This is a somewhat expensive operation, but it is necessary
+        to perform in some cases (such as when a SYN_DROPPED event is received).
+        """
+        for control in self.control_map.values():
+            if isinstance(control, EvdevButton):
+                control.value = get_key_state(self._fileno, control.event_code)
+            if isinstance(control, EvdevAbsoluteAxis):
+                control.value = EVIOCGABS(self._fileno, control.event_code).value
+
     # Force Feedback methods
 
     def ff_upload_effect(self, structure):
@@ -351,25 +398,51 @@ class EvdevDevice(XlibSelectDevice, Device):
         return self._fileno
 
     def poll(self):
-        return False
+        return True if self._poll.poll(0) else False
 
     def select(self):
-        if not self._fileno:
-            return
-
+        """When the file descriptor is ready, read and process InputEvents.
+
+        This method has the following behavior:
+        - Read and queue all incoming input events.
+        - When a SYN_REPORT event is received, dispatch all queued events.
+        - If a SYN_DROPPED event is received, set a flag. When the next
+          SYN_REPORT event appears, drop all queued events & manually resync
+          all Control state.
+        """
         try:
             bytes_read = _readv(self._fileno, self._event_buffer)
+            n_events = bytes_read // self._event_size
         except OSError:
             self.close()
             return
 
-        n_events = bytes_read // self._event_size
-
         for event in self._event_buffer[:n_events]:
-            try:
-                self.control_map[(event.type, event.code)].value = event.value
-            except KeyError:
-                pass
+
+            # Mark the current chain of events as invalid and continue:
+            if (event.type, event.code) == (EV_SYN, SYN_DROPPED):
+                self._syn_dropped = True
+                continue
+
+            # Dispatch queued events when SYN_REPORT comes in:
+            if (event.type, event.code) == (EV_SYN, SYN_REPORT):
+
+                # Unless a SYN_DROPPED event has been received,
+                # in which case discard all queued events and resync:
+                if self._syn_dropped:
+                    self._event_queue.clear()
+                    self._syn_dropped = False
+                    self._resync_control_state()
+
+                # Dispatch all queued events, then clear the queue:
+                for queued_event in self._event_queue:
+                    if control := self.control_map.get((queued_event.type, queued_event.code)):
+                        control.value = queued_event.value
+                self._event_queue.clear()
+
+            # This is not a SYN_REPORT or SYN_DROPPED event, so it is probably
+            # an input event. Queue it until the next SYN_REPORT event comes in:
+            self._event_queue.append(event)
 
 
 class FFController(Controller):
@@ -471,7 +544,7 @@ class EvdevControllerManager(ControllerManager, XlibSelectDevice):
         if controller := self._controllers.get(name, _create_controller(device)):
             self._controllers[name] = controller
             # Dispatch event in main thread:
-            pyglet.app.platform_event_loop.post_event(self, 'on_connect', controller)
+            self.post_event('on_connect', controller)
 
     def select(self):
         """Triggered whenever the devices_file changes."""
@@ -551,8 +624,8 @@ def _detect_controller_mapping(device):
                 ABS_Z: 'lefttrigger', ABS_RZ: 'righttrigger',
                 ABS_X: 'leftx', ABS_Y: 'lefty', ABS_RX: 'rightx', ABS_RY: 'righty'}
 
-    button_controls = [control for control in device.controls if isinstance(control, Button)]
-    axis_controls = [control for control in device.controls if isinstance(control, AbsoluteAxis)]
+    button_controls = [control for control in device.controls if isinstance(control, EvdevButton)]
+    axis_controls = [control for control in device.controls if isinstance(control, EvdevAbsoluteAxis)]
     hat_controls = [control for control in device.controls if control.name in ('hat_x', 'hat_y')]
 
     for i, control in enumerate(button_controls):

pyglet/input/linux/evdev_constants.py

@@ -1,4 +1,4 @@
-"""Event constants from /usr/include/linux/input.h """
+"""Event constants from /usr/include/linux/input-event-codes.h"""
 
 EV_SYN = 0x00
 EV_KEY = 0x01
@@ -17,6 +17,7 @@ EV_MAX = 0x1f
 
 SYN_REPORT = 0
 SYN_CONFIG = 1
+SYN_DROPPED = 3
 
 # Keys and buttons
 

pyglet/input/win32/xinput.py

@@ -575,14 +575,16 @@ class XInputController(Controller):
             def on_change(value):
                 normalized_value = value * scale + bias
                 setattr(self, name, normalized_value)
-                self.dispatch_event('on_stick_motion', self, "leftstick", Vec2(self.leftx, self.lefty))
+                self.leftanalog = Vec2(self.leftx, self.lefty)
+                self.dispatch_event('on_stick_motion', self, "leftstick", self.leftanalog)
 
         elif name in ("rightx", "righty"):
             @control.event
             def on_change(value):
                 normalized_value = value * scale + bias
                 setattr(self, name, normalized_value)
-                self.dispatch_event('on_stick_motion', self, "rightstick", Vec2(self.rightx, self.righty))
+                self.rightanalog = Vec2(self.rightx, self.righty)
+                self.dispatch_event('on_stick_motion', self, "rightstick", self.rightanalog)
 
     def _add_button(self, control, name):
 
@@ -592,7 +594,8 @@ class XInputController(Controller):
                 target, bias = {'dpleft': ('dpadx', -1.0), 'dpright': ('dpadx', 1.0),
                                 'dpdown': ('dpady', -1.0), 'dpup': ('dpady', 1.0)}[name]
                 setattr(self, target, bias * value)
-                self.dispatch_event('on_dpad_motion', self, Vec2(self.dpadx, self.dpady))
+                self.dpad = Vec2(self.dpadx, self.dpady)
+                self.dispatch_event('on_dpad_motion', self, self.dpad)
         else:
             @control.event
             def on_change(value):

pyglet/libs/darwin/cocoapy/cocoalibs.py

@@ -232,6 +232,8 @@ NSDeviceSize = c_void_p.in_dll(appkit, 'NSDeviceSize')
 NSDeviceResolution = c_void_p.in_dll(appkit, 'NSDeviceResolution')
 NSDragOperationGeneric = 4
 
+NSStatusWindowLevel = 25
+
 
 # /System/Library/Frameworks/AppKit.framework/Headers/NSEvent.h
 NSAnyEventMask = 0xFFFFFFFF     # NSUIntegerMax
@@ -336,7 +338,7 @@ NSOpenGLProfileVersion3_2Core = 0x3200    # choose an OpenGL 3.2 Core Implementa
 NSOpenGLProfileVersion4_1Core = 0x4100    # choose an OpenGL 4.1 Core Implementation
 
 NSOpenGLCPSwapInterval        = 222
-
+NSOpenGLCPSurfaceOpacity      = 236
 
 # /System/Library/Frameworks/ApplicationServices.framework/Frameworks/...
 #     CoreGraphics.framework/Headers/CGImage.h

pyglet/libs/ioctl.py

@@ -41,7 +41,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from ctypes import Structure, c_int, c_uint
     from typing import Callable, Union
-    c_data = Union[type[Structure], c_int, c_uint]
+    c_data = type[Structure] | type[c_int] | type[c_uint]
 
 
 _IOC_NRBITS = 8
@@ -64,7 +64,7 @@ _IOC_READ = 2
 # 'code' instead of 'type' to indicate the ioctl "magic number" ('H', 'E', etc.).
 
 
-def _IOC(io_dir: _IOC_NONE | _IOC_READ | _IOC_WRITE, code: int, nr: int, size: int) -> int:
+def _IOC(io_dir: Union[_IOC_NONE, _IOC_READ, _IOC_WRITE], code: int, nr: int, size: int) -> int:
     return (io_dir << _IOC_DIRSHIFT) | (code << _IOC_TYPESHIFT) | (nr << _IOC_NRSHIFT) | (size << _IOC_SIZESHIFT)