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

pyglet/input/win32/directinput.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import ctypes
 import warnings
 
-from typing import List, Dict, Optional
+from typing import Optional
 
 from pyglet.libs.win32.constants import WM_DEVICECHANGE, DBT_DEVICEARRIVAL, DBT_DEVICEREMOVECOMPLETE, \
     DBT_DEVTYP_DEVICEINTERFACE, DEVICE_NOTIFY_WINDOW_HANDLE
@@ -55,7 +57,7 @@ def _create_control(object_instance):
     elif ctrl_type & dinput.DIDFT_POV:
         control = base.AbsoluteAxis(base.AbsoluteAxis.HAT, 0, 0xffffffff, raw_name)
     else:
-        return
+        return None
 
     control._type = object_instance.dwType
     return control
@@ -124,17 +126,18 @@ class DirectInputDevice(base.Device):
         prop.dwData = 64 * ctypes.sizeof(dinput.DIDATAFORMAT)
         self._device.SetProperty(dinput.DIPROP_BUFFERSIZE, ctypes.byref(prop.diph))
 
-    def open(self, window=None, exclusive=False):
+    def open(self, window: pyglet.window.Window | None=None, exclusive: bool=False) -> None:
         if not self.controls:
             return
 
         if window is None:
-            # Pick any open window, or the shadow window if no windows
-            # have been created yet.
-            window = pyglet.gl._shadow_window
+            # Pick any open window or the shadow window if no windows are available.
             for window in pyglet.app.windows:
                 break
 
+            if not window:
+                window = pyglet.window._shadow_window  # noqa: SLF001
+
         flags = dinput.DISCL_BACKGROUND
         if exclusive:
             flags |= dinput.DISCL_EXCLUSIVE
@@ -215,31 +218,34 @@ class DIDeviceManager(EventDispatcher):
         self.registered = False
         self.window = None
         self._devnotify = None
-        self.devices: List[DirectInputDevice] = []
+        self.devices: list[DirectInputDevice] = []
 
         if self.register_device_events(skip_warning=True):
             self.set_current_devices()
 
-    def set_current_devices(self):
-        """Sets all currently discovered devices in the devices list.
-        Be careful when using this, as this creates new device objects. Should only be called on initialization of
-        the manager and if for some reason the window connection event isn't registered.
+    def set_current_devices(self) -> None:
+        """Sets all currently discovered devices in the device list.
+
+        .. note:: Be careful when using this, as this creates new device objects. Only to be called on the
+        initialization of the manager, and if the window connection event isn't already registered.
         """
         new_devices, _ = self._get_devices()
         self.devices = new_devices
 
-    def register_device_events(self, skip_warning=False, window=None):
+    def register_device_events(self, skip_warning: bool=False, window: pyglet.window.Window | None=None) -> bool:
         """Register the first OS Window to receive events of disconnect and connection of devices.
-        Returns True if events were successfully registered.
+
+        Returns:
+            True if events were successfully registered.
         """
         if not self.registered:
-            # If a specific window is not specified, find one.
-            if not window:
-                # Pick any open window, or the shadow window if no windows have been created yet.
-                window = pyglet.gl._shadow_window
+            # Pick any open window or the shadow window if no windows are available.
+            if window is None:
+                for window in pyglet.app.windows:
+                    break
+
                 if not window:
-                    for window in pyglet.app.windows:
-                        break
+                    window = pyglet.window._shadow_window  # noqa: SLF001
 
             self.window = window
             if self.window is not None:
@@ -255,9 +261,8 @@ class DIDeviceManager(EventDispatcher):
                 self.registered = True
                 self.window.push_handlers(self)
                 return True
-            else:
-                if not skip_warning:
-                    warnings.warn("DirectInput Device Manager requires a window to receive device connection events.")
+            if not skip_warning:
+                warnings.warn("DirectInput Device Manager requires a window to receive device connection events.")
 
         return False
 
@@ -288,12 +293,13 @@ class DIDeviceManager(EventDispatcher):
 
     def _get_devices(self, display=None):
         """Enumerate all the devices on the system.
-        Returns two values: new devices, missing devices"""
+        Returns two values: new devices, missing devices
+        """
         _missing_devices = list(self.devices)
         _new_devices = []
         _xinput_devices = []
 
-        if not pyglet.options["win32_disable_xinput"]:
+        if not pyglet.options.win32_disable_xinput:
             try:
                 from pyglet.input.win32.xinput import get_xinput_guids
                 _xinput_devices = get_xinput_guids()
@@ -359,7 +365,7 @@ class DIControllerManager(ControllerManager):
 
     def __init__(self, display=None):
         self._display = display
-        self._controllers: Dict[DirectInputDevice, base.Controller] = {}
+        self._controllers: dict[DirectInputDevice, base.Controller] = {}
 
         for device in _di_manager.devices:
             self._add_controller(device)
@@ -398,7 +404,7 @@ def get_devices(display=None):
     _devices = []
     _xinput_devices = []
 
-    if not pyglet.options["win32_disable_xinput"]:
+    if not pyglet.options.win32_disable_xinput:
         try:
             from pyglet.input.win32.xinput import get_xinput_guids
             _xinput_devices = get_xinput_guids()
@@ -429,9 +435,8 @@ def _create_controller(device):
     if device._type in (dinput.DI8DEVTYPE_JOYSTICK, dinput.DI8DEVTYPE_1STPERSON, dinput.DI8DEVTYPE_GAMEPAD):
         if mapping is not None:
             return base.Controller(device, mapping)
-        else:
-            warnings.warn(f"Warning: {device} (GUID: {device.get_guid()}) "
-                          f"has no controller mappings. Update the mappings in the Controller DB.")
+        warnings.warn(f"Warning: {device} (GUID: {device.get_guid()}) "
+                      f"has no controller mappings. Update the mappings in the Controller DB.")
 
 
 def _create_joystick(device):

pyglet/input/win32/xinput.py

@@ -6,13 +6,12 @@ from ctypes.wintypes import DWORD, LONG, LPCWSTR, SHORT, ULONG, WORD
 
 import pyglet
 from pyglet.event import EventDispatcher
-from pyglet.input.base import AbsoluteAxis, Button, Controller, ControllerManager, Device
+from pyglet.input.base import AbsoluteAxis, Button, Controller, ControllerManager, Device, Sign
 from pyglet.libs.win32 import _ole32 as ole32
 from pyglet.libs.win32 import _oleaut32 as oleaut32
 from pyglet.libs.win32 import com
 from pyglet.libs.win32.constants import CLSCTX_INPROC_SERVER
 from pyglet.libs.win32.types import BYTE, VARIANT
-from pyglet.math import Vec2
 
 for library_name in ['xinput1_4', 'xinput9_1_0', 'xinput1_3']:
     try:
@@ -360,8 +359,8 @@ controller_api_to_pyglet = {
     XINPUT_GAMEPAD_START: "start",
     XINPUT_GAMEPAD_BACK: "back",
     XINPUT_GAMEPAD_GUIDE: "guide",
-    XINPUT_GAMEPAD_LEFT_THUMB: "leftstick",
-    XINPUT_GAMEPAD_RIGHT_THUMB: "rightstick",
+    XINPUT_GAMEPAD_LEFT_THUMB: "leftthumb",
+    XINPUT_GAMEPAD_RIGHT_THUMB: "rightthumb",
     XINPUT_GAMEPAD_LEFT_SHOULDER: "leftshoulder",
     XINPUT_GAMEPAD_RIGHT_SHOULDER: "rightshoulder",
     XINPUT_GAMEPAD_A: "a",
@@ -396,17 +395,17 @@ class XInputDevice(Device):
             'guide': Button('guide'),
             'leftshoulder': Button('leftshoulder'),
             'rightshoulder': Button('rightshoulder'),
-            'leftstick': Button('leftstick'),
-            'rightstick': Button('rightstick'),
+            'leftthumb': Button('leftthumb'),
+            'rightthumb': Button('rightthumb'),
             'dpup': Button('dpup'),
             'dpdown': Button('dpdown'),
             'dpleft': Button('dpleft'),
             'dpright': Button('dpright'),
 
             'leftx': AbsoluteAxis('leftx', -32768, 32768),
-            'lefty': AbsoluteAxis('lefty', -32768, 32768),
+            'lefty': AbsoluteAxis('lefty', -32768, 32768, inverted=True),
             'rightx': AbsoluteAxis('rightx', -32768, 32768),
-            'righty': AbsoluteAxis('righty', -32768, 32768),
+            'righty': AbsoluteAxis('righty', -32768, 32768, inverted=True),
             'lefttrigger': AbsoluteAxis('lefttrigger', 0, 255),
             'righttrigger': AbsoluteAxis('righttrigger', 0, 255)
         }
@@ -546,68 +545,19 @@ _device_manager = XInputDeviceManager()
 
 class XInputController(Controller):
 
+    device: XInputDevice
+
     def _initialize_controls(self):
 
         for button_name in controller_api_to_pyglet.values():
             control = self.device.controls[button_name]
             self._button_controls.append(control)
-            self._add_button(control, button_name)
+            self._bind_button_control(control, button_name)
 
         for axis_name in "leftx", "lefty", "rightx", "righty", "lefttrigger", "righttrigger":
             control = self.device.controls[axis_name]
             self._axis_controls.append(control)
-            self._add_axis(control, axis_name)
-
-    def _add_axis(self, control, name):
-        tscale = 1.0 / (control.max - control.min)
-        scale = 2.0 / (control.max - control.min)
-        bias = -1.0 - control.min * scale
-
-        if name in ("lefttrigger", "righttrigger"):
-            @control.event
-            def on_change(value):
-                normalized_value = value * tscale
-                setattr(self, name, normalized_value)
-                self.dispatch_event('on_trigger_motion', self, name, normalized_value)
-
-        elif name in ("leftx", "lefty"):
-            @control.event
-            def on_change(value):
-                normalized_value = value * scale + bias
-                setattr(self, name, normalized_value)
-                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.rightanalog = Vec2(self.rightx, self.righty)
-                self.dispatch_event('on_stick_motion', self, "rightstick", self.rightanalog)
-
-    def _add_button(self, control, name):
-
-        if name in ("dpleft", "dpright", "dpup", "dpdown"):
-            @control.event
-            def on_change(value):
-                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.dpad = Vec2(self.dpadx, self.dpady)
-                self.dispatch_event('on_dpad_motion', self, self.dpad)
-        else:
-            @control.event
-            def on_change(value):
-                setattr(self, name, value)
-
-            @control.event
-            def on_press():
-                self.dispatch_event('on_button_press', self, name)
-
-            @control.event
-            def on_release():
-                self.dispatch_event('on_button_release', self, name)
+            self._bind_axis_control(control, axis_name, Sign.DEFAULT)
 
     def rumble_play_weak(self, strength=1.0, duration=0.5):
         self.device.vibration.wRightMotorSpeed = int(max(min(1.0, strength), 0) * 0xFFFF)

pyglet/lib.py

@@ -15,12 +15,12 @@ import ctypes.util
 import pyglet
 from typing import NoReturn, Callable, Any
 
-_debug_lib = pyglet.options['debug_lib']
-_debug_trace = pyglet.options['debug_trace']
+_debug_lib = pyglet.options.debug_lib
+_debug_trace = pyglet.options.debug_trace
 
 _is_pyglet_doc_run = getattr(sys, "is_pyglet_doc_run", False)
 
-if pyglet.options['search_local_libs']:
+if pyglet.options.search_local_libs:
     script_path = pyglet.resource.get_script_home()
     cwd = os.getcwd()
     _local_lib_paths = [script_path, os.path.join(script_path, 'lib'), os.path.join(cwd, 'lib')]

pyglet/libs/__init__.py

@@ -13,7 +13,7 @@ When documenting these modules:
 
 Simple docstrings with minimal formatting are best because:
 
-1. No web doc is built for pyglet.lib
+1. No web doc is built for pyglet.libs
 2. The docstrings will be used to debug complex platform issues
 3. IDEs mangle formatting in any hover tooltips while debugging
 """

pyglet/{gl → libs/darwin}/agl.py

@@ -5,7 +5,7 @@ Do not modify this file.
 """
 
 from ctypes import Structure, POINTER, c_int, c_long, c_ubyte, c_ulong
-from pyglet.gl.lib import link_AGL as _link_function
+from pyglet.graphics.api.gl.lib import link_AGL as _link_function
 
 if not _link_function:
     raise ImportError('AGL framework is not available.')

pyglet/libs/darwin/cocoapy/__init__.py

@@ -30,10 +30,10 @@
 # POSSIBILITY OF SUCH DAMAGE.
 from contextlib import contextmanager
 
-from .runtime import objc, send_message, send_super, AutoReleasePool
+from .runtime import objc, send_message, send_super, AutoReleasePool, ObjCBlock
 from .runtime import get_selector
 from .runtime import ObjCClass, ObjCInstance, ObjCSubclass
 
 from .cocoatypes import *
 from .cocoalibs import *
-
+from .cocoahelpers import *

pyglet/libs/darwin/cocoapy/cocoahelpers.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pyglet.libs.darwin.cocoapy.runtime import ObjCInstance, ObjCClass
+
+NSSet = ObjCClass('NSSet')
+NSNull = ObjCClass('NSNull')
+NSString = ObjCClass("NSString")
+NSData = ObjCClass("NSData")
+NSNumber = ObjCClass("NSNumber")
+NSMutableArray = ObjCClass("NSMutableArray")
+NSArray = ObjCClass("NSArray")
+NSDictionary = ObjCClass("NSDictionary")
+NSMutableDictionary = ObjCClass("NSMutableDictionary")
+
+def pystr_to_ns(value: str):
+    return NSString.stringWithUTF8String_(value.encode("utf-8"))
+
+def pybool_to_ns(value: bool):
+    return NSNumber.numberWithBool_(value)
+
+def pyint_to_ns(value: int):
+    return NSNumber.numberWithInt_(value)
+
+def pyfloat_to_ns(value: float):
+    return NSNumber.numberWithDouble_(value)
+
+def pynone_to_ns(_value):
+    return NSNull.null()
+
+def _iterable_to_mutable_array(value: list | tuple):
+    arr = NSMutableArray.array()
+    for item in value:
+        arr.addObject_(py_to_ns(item))
+    return arr
+
+def pylist_to_ns(value: list) -> NSMutableArray:
+    """Convert Python list to NSMutableArray."""
+    return _iterable_to_mutable_array(value)
+
+def pytuple_to_ns(value: tuple) -> NSArray:
+    """Convert Python tuple to NSArray (immutable)."""
+    mutable = _iterable_to_mutable_array(value)
+    return NSArray.arrayWithArray_(mutable)
+
+def pydict_to_ns(value: dict, mutable: bool=True) -> NSMutableDictionary | NSDictionary:
+    """Convert Python dict to NSMutableDictionary."""
+    d = NSMutableDictionary.dictionary()
+    for k, v in value.items():
+        ns_key = py_to_ns(k)
+        ns_val = py_to_ns(v)
+        d.setObject_forKey_(ns_val, ns_key)
+    if not mutable:
+        return NSDictionary.dictionaryWithDictionary_(d)
+    return d
+
+
+_CONVERTERS = {
+    str:     pystr_to_ns,
+    bool:    pybool_to_ns,
+    int:     pyint_to_ns,
+    float:   pyfloat_to_ns,
+    list:    pylist_to_ns,
+    tuple:   pytuple_to_ns,
+    dict:    pydict_to_ns,
+    type(None): pynone_to_ns,
+}
+
+def py_to_ns(value: Any) -> ObjCInstance:
+    """General Python to NS object converter.
+
+    Should be used whenever interacting with AppKit, Cocoa, or any other NS-related functions.
+    """
+    if isinstance(value, ObjCInstance):
+        return value
+
+    t = type(value)
+    converter = _CONVERTERS.get(t)
+
+    if converter:
+        return converter(value)
+
+    raise TypeError(f"Cannot convert Python type {t} to NS object")
+
+# ===== Converting from NS to Python
+def nsstr_to_py(nsobj: NSString) -> str:
+    return nsobj.UTF8String().decode("utf-8")
+
+
+def nsnum_to_py(nsobj: NSNumber) -> int | float:
+    """Converting from NSNumber
+
+    NSNumber can represent bool, int, or float internally"""
+    t = nsobj.objCType().decode()
+
+    if t == 'c':  # char / BOOL
+        return bool(nsobj.boolValue())
+    elif t in ('i', 'l', 'q', 's'):
+        return int(nsobj.intValue())
+    elif t in ('f', 'd'):
+        return float(nsobj.doubleValue())
+
+    return nsobj.doubleValue()
+
+
+def nsarray_to_py(nsobj: NSArray) -> list:
+    py_list = []
+    for i in range(nsobj.count()):
+        item = nsobj.objectAtIndex_(i)
+        py_list.append(ns_to_py(item))
+    return py_list
+
+
+def nsmutarray_to_py(nsobj: NSMutableArray):
+    return nsarray_to_py(nsobj)
+
+
+def nsdict_to_py(nsobj: NSDictionary):
+    py_dict = {}
+
+    # NSDictionary requires enumerating keys
+    keys = nsobj.allKeys()
+    for i in range(keys.count()):
+        key = keys.objectAtIndex_(i)
+        val = nsobj.objectForKey_(key)
+
+        py_key = ns_to_py(key)
+        py_val = ns_to_py(val)
+
+        py_dict[py_key] = py_val
+
+    return py_dict
+
+
+# NSMutableDictionary handled the same
+def nsmutdict_to_py(nsobj: NSMutableDictionary):
+    return nsdict_to_py(nsobj)
+
+
+def nsset_to_py(nsset) -> set:
+    """Convert NSSet or NSFrozenSet to a Python set."""
+    py = set()
+    enumerator = nsset.objectEnumerator()
+    while True:
+        obj = enumerator.nextObject()
+        if obj is None:
+            break
+        py.add(ns_to_py(obj))
+    return py
+
+def nsnull_to_py(_nsnull):
+    return None
+
+_NS_TO_PY_CONVERTERS = {
+    NSString: nsstr_to_py,
+    NSNumber: nsnum_to_py,
+    NSArray: nsarray_to_py,
+    NSMutableArray: nsmutarray_to_py,
+    NSDictionary: nsdict_to_py,
+    NSMutableDictionary: nsmutdict_to_py,
+    NSNull: nsnull_to_py,
+    NSSet: nsset_to_py,
+}
+
+
+def ns_to_py(nsobj: ObjCInstance):
+    """Convert NS object to Python, recursively."""
+    if nsobj is None:
+        return None
+
+    if not isinstance(nsobj, ObjCInstance):
+        raise Exception(f"{nsobj} Not an ObjCInstance")
+
+    for cls, converter in _NS_TO_PY_CONVERTERS.items():
+        # NS Objects have many different variations of the same type.
+        # For example a string can be NSTaggedPointerString, __NSCFString, NSMutableString, NSString, etc..
+        if nsobj.isKindOfClass_(cls):
+            return converter(nsobj)
+
+    return nsobj

pyglet/libs/darwin/cocoapy/cocoalibs.py

@@ -24,6 +24,7 @@ CFURLRef = c_void_p
 CFStringRef = c_void_p
 CFURLPathStyle = c_int
 CFDataRef = c_void_p
+CTRunRef = c_void_p
 
 cf.CFStringCreateWithCString.restype = c_void_p
 cf.CFStringCreateWithCString.argtypes = [CFAllocatorRef, c_char_p, CFStringEncoding]
@@ -46,6 +47,9 @@ cf.CFStringGetTypeID.argtypes = []
 cf.CFAttributedStringCreate.restype = c_void_p
 cf.CFAttributedStringCreate.argtypes = [CFAllocatorRef, c_void_p, c_void_p]
 
+cf.CFShow.restype = None
+cf.CFShow.argtypes = [c_void_p]
+
 # Core Foundation type to Python type conversion functions
 
 def CFSTR(string: str):
@@ -649,6 +653,18 @@ ct.CTFontCopyFamilyName.argtypes = [c_void_p]
 ct.CTFontCopyFullName.restype = c_void_p
 ct.CTFontCopyFullName.argtypes = [c_void_p]
 
+ct.CTFontCopyPostScriptName.restype = c_void_p
+ct.CTFontCopyPostScriptName.argtypes = [c_void_p]
+
+ct.CTFontCreateUIFontForLanguage.restype = c_void_p
+ct.CTFontCreateUIFontForLanguage.argtypes = [c_uint32, c_double, c_void_p]
+
+ct.CTFontCreateCopyWithSymbolicTraits.restype = c_void_p
+ct.CTFontCreateCopyWithSymbolicTraits.argtypes = [c_void_p, CGFloat, c_void_p, c_uint32, c_uint32]
+
+ct.CTFontCreateCopyWithAttributes.restype = c_void_p
+ct.CTFontCreateCopyWithAttributes.argtypes = [c_void_p, c_double, c_void_p, c_void_p]
+
 ct.CTFontCreateWithFontDescriptor.restype = c_void_p
 ct.CTFontCreateWithFontDescriptor.argtypes = [c_void_p, CGFloat, c_void_p]
 
@@ -667,6 +683,21 @@ ct.CTFontDescriptorCreateMatchingFontDescriptor.argtypes = [c_void_p, c_void_p]
 ct.CTFontCopyTraits.restype = c_void_p
 ct.CTFontCopyTraits.argtypes = [c_void_p]
 
+ct.CTLineGetGlyphRuns.restype = c_void_p  # CFArrayRef
+ct.CTLineGetGlyphRuns.argtypes = [c_void_p]  # CTLineRef
+
+ct.CTRunGetGlyphCount.restype = CFIndex
+ct.CTRunGetGlyphCount.argtypes = [CTRunRef]
+
+ct.CTRunGetGlyphs.restype = None
+ct.CTRunGetGlyphs.argtypes = [CTRunRef, CFRange, POINTER(CGGlyph)]
+
+ct.CTRunGetPositions.restype = None
+ct.CTRunGetPositions.argtypes = [CTRunRef, CFRange, POINTER(CGPoint)]
+
+ct.CTRunGetAttributes.restype = c_void_p
+ct.CTRunGetAttributes.argtypes = [CTRunRef]
+
 kCTFontURLAttribute = c_void_p.in_dll(ct, 'kCTFontURLAttribute')
 
 ######################################################################

pyglet/libs/darwin/cocoapy/cocoatypes.py

@@ -46,6 +46,10 @@ NSZoneEncoding = b'{_NSZone=}'
 # from /System/Library/Frameworks/Foundation.framework/Headers/NSGeometry.h
 class NSPoint(Structure):
     _fields_ = [ ("x", CGFloat), ("y", CGFloat) ]
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(x={self.x}, y={self.y})"
+
 CGPoint = NSPoint
 
 class NSSize(Structure):
@@ -83,3 +87,26 @@ NSZeroPoint = NSPoint(0,0)
 
 CFTypeID = c_ulong
 CFNumberType = c_uint32
+
+_dispose_helper_cb = CFUNCTYPE(c_void_p, c_void_p)
+_copy_helper_cb = CFUNCTYPE(c_void_p, c_void_p, c_void_p)
+
+class Block_descriptor_1(Structure):
+    _fields_ = [
+        ("reserved", c_ulong),
+        ("Block_size", c_ulong),
+        ("copy_helper", _copy_helper_cb),  # Optional
+        ("dispose_helper", _dispose_helper_cb),  # Optional
+        ("signature", c_char_p),
+    ]
+
+
+class Block_literal_1(Structure):
+    _fields_ = [
+        ("isa", c_void_p),  # address to ConcreteStack/ConcreteGlobal
+        ("flags", c_int),
+        ("reserved", c_int),
+        ("invoke", c_void_p),  # Invoke function
+        ("descriptor", Block_descriptor_1),
+    ]
+