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

pyglet/window/__init__.py

@@ -511,9 +511,21 @@ class BaseWindow(EventDispatcher, metaclass=_WindowMetaclass):
             screen = display.get_default_screen()
 
         if not config:
-            for template_config in [gl.Config(double_buffer=True, depth_size=24, major_version=3, minor_version=3),
-                                    gl.Config(double_buffer=True, depth_size=16, major_version=3, minor_version=3),
-                                    None]:
+            alpha_size = None
+            transparent_fb = False
+            # Override config settings if intention is transparency.
+            if style in ('transparent', 'overlay'):
+                # Ensure the framebuffer is large enough to support transparency.
+                alpha_size = 8
+                transparent_fb = True
+
+            for template_config in [
+                gl.Config(double_buffer=True, depth_size=24, major_version=3, minor_version=3,
+                          alpha_size=alpha_size, transparent_framebuffer=transparent_fb),
+                gl.Config(double_buffer=True, depth_size=16, major_version=3, minor_version=3,
+                          alpha_size=alpha_size, transparent_framebuffer=transparent_fb),
+                None,
+            ]:
                 try:
                     config = screen.get_best_config(template_config)
                     break
@@ -522,10 +534,10 @@ class BaseWindow(EventDispatcher, metaclass=_WindowMetaclass):
             if not config:
                 msg = 'No standard config is available.'
                 raise NoSuchConfigException(msg)
-
-        # Necessary on Windows. More investigation needed:
-        if style in ('transparent', 'overlay'):
-            config.alpha = 8
+        else:
+            if style in ('transparent', 'overlay'):
+                config.alpha_size = 8
+                config.transparent_framebuffer = True
 
         if not config.is_complete():
             config = screen.get_best_config(config)
@@ -649,7 +661,7 @@ class BaseWindow(EventDispatcher, metaclass=_WindowMetaclass):
         """Close the window.
 
         After closing the window, the GL context will be invalid.  The
-        window instance cannot be reused once closed. To re-use windows,
+        window instance cannot be reused once closed. To reuse windows,
         see :py:meth:`.set_visible` instead.
 
         The :py:meth:`pyglet.app.EventLoop.on_window_close` event is
@@ -813,6 +825,21 @@ class BaseWindow(EventDispatcher, metaclass=_WindowMetaclass):
         """
         raise NotImplementedError
 
+    def set_mouse_passthrough(self, state: bool) -> None:
+        """Set whether the operating system will ignore mouse input from this window.
+
+        Behavior may differ across operating systems. This is typically used in window overlays with
+        transparent frame buffers.
+
+        Args:
+            state:
+                ``True`` will allow mouse input to pass through the window to anything behind it. Otherwise, ``False``
+                allows the window to accept focus again.
+
+        .. versionadded:: 2.1.8
+        """
+        raise NotImplementedError
+
     @abstractmethod
     def minimize(self) -> None:
         """Minimize the window."""
@@ -841,16 +868,18 @@ class BaseWindow(EventDispatcher, metaclass=_WindowMetaclass):
             self.dispatch_event('on_close')
 
     def _on_internal_resize(self, width: int, height: int) -> None:
-        gl.glViewport(0, 0, *self.get_framebuffer_size())
+        framebuffer_size = self.get_framebuffer_size()
+        gl.glViewport(0, 0, max(framebuffer_size[0], 1), max(framebuffer_size[1], 1))
         w, h = self.get_size()
-        self.projection = Mat4.orthogonal_projection(0, w, 0, h, -8192, 8192)
+        self.projection = Mat4.orthogonal_projection(0, max(w, 1), 0, max(h, 1), -8192, 8192)
         self.dispatch_event('on_resize', w, h)
 
     def _on_internal_scale(self, scale: float, dpi: int) -> None:
-        gl.glViewport(0, 0, *self.get_framebuffer_size())
+        framebuffer_size = self.get_framebuffer_size()
+        gl.glViewport(0, 0, max(framebuffer_size[0], 1), max(framebuffer_size[1], 1))
         w, h = self.get_size()
-        self.projection = Mat4.orthogonal_projection(0, w, 0, h, -8192, 8192)
-        self._mouse_cursor.scaling = scale
+        self.projection = Mat4.orthogonal_projection(0, max(w, 1), 0, max(h, 1), -8192, 8192)
+        self._mouse_cursor.scaling = self._get_mouse_scale()
         self.dispatch_event('on_scale', scale, dpi)
 
     def on_resize(self, width: int, height: int) -> EVENT_HANDLE_STATE:
@@ -1118,9 +1147,16 @@ class BaseWindow(EventDispatcher, metaclass=_WindowMetaclass):
         if cursor is None:
             cursor = DefaultMouseCursor()
         self._mouse_cursor = cursor
-        self._mouse_cursor.scaling = self.scale
+        self._mouse_cursor.scaling = self._get_mouse_scale()
         self.set_mouse_platform_visible()
 
+    def _get_mouse_scale(self):
+        """The mouse scale factoring in the DPI.
+
+        On Mac, this is always 1.0.
+        """
+        return self.scale
+
     def set_exclusive_mouse(self, exclusive: bool = True) -> None:
         """Hide the mouse cursor and direct all mouse events to this window.
 
@@ -1687,6 +1723,8 @@ class BaseWindow(EventDispatcher, metaclass=_WindowMetaclass):
             * MOTION_END_OF_FILE
             * MOTION_BACKSPACE
             * MOTION_DELETE
+            * MOTION_COPY
+            * MOTION_PASTE
 
             :event:
             """
@@ -1717,6 +1755,8 @@ class BaseWindow(EventDispatcher, metaclass=_WindowMetaclass):
             * MOTION_PREVIOUS_PAGE
             * MOTION_BEGINNING_OF_FILE
             * MOTION_END_OF_FILE
+            * MOTION_COPY
+            * MOTION_PASTE
 
             :event:
             """

pyglet/window/cocoa/__init__.py

@@ -70,6 +70,11 @@ class CocoaWindow(BaseWindow):
                                       cocoapy.NSClosableWindowMask |
                                       cocoapy.NSUtilityWindowMask,
         BaseWindow.WINDOW_STYLE_BORDERLESS: cocoapy.NSBorderlessWindowMask,
+        BaseWindow.WINDOW_STYLE_TRANSPARENT: cocoapy.NSTitledWindowMask |
+                                         cocoapy.NSClosableWindowMask |
+                                         cocoapy.NSMiniaturizableWindowMask,
+        BaseWindow.WINDOW_STYLE_OVERLAY: cocoapy.NSBorderlessWindowMask,
+
     }
 
     def __init__(self, *args, **kwargs) -> None:  # noqa: ANN002, ANN003
@@ -161,6 +166,17 @@ class CocoaWindow(BaseWindow):
             # Then create a view and set it as our NSWindow's content view.
             self._nsview = PygletView.alloc().initWithFrame_cocoaWindow_(content_rect, self)
             self._nsview.setWantsBestResolutionOpenGLSurface_(True)
+
+        if not self._fullscreen:
+            if self._style in ("transparent", "overlay"):
+                self._nswindow.setOpaque_(False)
+                self._nswindow.setBackgroundColor_(NSColor.clearColor())
+                self._nswindow.setHasShadow_(False)
+
+                if self._style == "overlay":
+                    self.set_mouse_passthrough(True)
+                    self._nswindow.setLevel_(cocoapy.NSStatusWindowLevel)
+
             self._nswindow.setContentView_(self._nsview)
             self._nswindow.makeFirstResponder_(self._nsview)
 
@@ -216,6 +232,17 @@ class CocoaWindow(BaseWindow):
 
         return 1.0
 
+    def _get_mouse_scale(self) -> float:
+        """The mouse scale factoring in the DPI.
+
+        On Mac, this is always 1.0.
+        """
+        return 1.0
+
+    def set_mouse_passthrough(self, state: bool) -> None:
+        with AutoReleasePool():
+            self._nswindow.setIgnoresMouseEvents_(state)
+
     def _set_nice_window_location(self) -> None:
         # Construct a list of all visible windows that aren't us.
         visible_windows = [win for win in pyglet.app.windows if

pyglet/window/mouse.py

@@ -23,7 +23,8 @@ class MouseStateHandler:
         False
 
 
-    Mouse coordinates can be retrieved by using the ``'x'`` and ``'y'`` strings.
+    Mouse coordinates can be retrieved by using the ``'x'`` and ``'y'`` strings
+    or by using ``'mouse_state.x'`` and ``'mouse_state.y`` attributes.
 
     For example::
 
@@ -37,6 +38,12 @@ class MouseStateHandler:
         20
         >>> mouse_state['y']
         50
+        
+        # Or...
+        >>> mouse_state.x
+        20
+        >>> mouse_state.y
+        50
     """
 
     def __init__(self) -> None:  # noqa: D107
@@ -64,6 +71,9 @@ class MouseStateHandler:
 
     def __getitem__(self, key: str) -> int | bool:
         return self.data.get(key, False)
+    
+    def __getattr__(self, item: str) -> int:
+        return self.data[item]
 
 
 def buttons_string(buttons: int) -> str:

pyglet/window/win32/__init__.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sys
 import unicodedata
-from ctypes.wintypes import HICON, HWND, MSG, POINT, RECT, SIZE, UINT
+from ctypes.wintypes import DWORD, HICON, HWND, MSG, POINT, RECT, SIZE, UINT
 from functools import lru_cache
 from typing import Callable, Sequence
 
@@ -10,6 +10,8 @@ from pyglet import compat_platform
 from pyglet.libs.win32 import constants
 from pyglet.libs.win32.types import (
     BITMAPINFOHEADER,
+    BYTE,
+    COLORREF,
     HCURSOR,
     HRAWINPUT,
     ICONINFO,
@@ -166,15 +168,17 @@ class Win32Window(BaseWindow):
         else:
             styles = {
                 self.WINDOW_STYLE_DEFAULT: (constants.WS_OVERLAPPEDWINDOW, 0),
-                self.WINDOW_STYLE_DIALOG: (constants.WS_OVERLAPPED | constants.WS_CAPTION | constants.WS_SYSMENU,
-                                           constants.WS_EX_DLGMODALFRAME),
-                self.WINDOW_STYLE_TOOL: (constants.WS_OVERLAPPED | constants.WS_CAPTION | constants.WS_SYSMENU,
-                                         constants.WS_EX_TOOLWINDOW),
+                self.WINDOW_STYLE_DIALOG: (
+                    constants.WS_OVERLAPPED | constants.WS_CAPTION | constants.WS_SYSMENU,
+                    constants.WS_EX_DLGMODALFRAME,
+                ),
+                self.WINDOW_STYLE_TOOL: (
+                    constants.WS_OVERLAPPED | constants.WS_CAPTION | constants.WS_SYSMENU,
+                    constants.WS_EX_TOOLWINDOW,
+                ),
                 self.WINDOW_STYLE_BORDERLESS: (constants.WS_POPUP, 0),
-                self.WINDOW_STYLE_TRANSPARENT: (constants.WS_OVERLAPPEDWINDOW,
-                                                constants.WS_EX_LAYERED),
-                self.WINDOW_STYLE_OVERLAY: (constants.WS_POPUP,
-                                            constants.WS_EX_LAYERED | constants.WS_EX_TRANSPARENT),
+                self.WINDOW_STYLE_TRANSPARENT: (constants.WS_OVERLAPPEDWINDOW, constants.WS_EX_LAYERED),
+                self.WINDOW_STYLE_OVERLAY: (constants.WS_POPUP, constants.WS_EX_LAYERED | constants.WS_EX_TRANSPARENT),
             }
             self._ws_style, self._ex_ws_style = styles[self._style]
 
@@ -299,7 +303,7 @@ class Win32Window(BaseWindow):
             _user32.SetWindowPos(self._hwnd, hwnd_after,
                                  self._screen.x, self._screen.y, width, height, constants.SWP_FRAMECHANGED)
         elif self.style == 'transparent' or self.style == 'overlay':
-            _user32.SetLayeredWindowAttributes(self._hwnd, 0, 254, constants.LWA_ALPHA)
+            self._set_transparency()
             if self.style == 'overlay':
                 _user32.SetWindowPos(self._hwnd, constants.HWND_TOPMOST, 0,
                                      0, width, height, constants.SWP_NOMOVE | constants.SWP_NOSIZE)
@@ -382,7 +386,7 @@ class Win32Window(BaseWindow):
     def switch_to(self) -> None:
         self.context.set_current()
 
-    def update_transparency(self) -> None:
+    def _set_transparency(self) -> None:
         region = _gdi32.CreateRectRgn(0, 0, -1, -1)
         bb = DWM_BLURBEHIND()
         bb.dwFlags = constants.DWM_BB_ENABLE | constants.DWM_BB_BLURREGION
@@ -392,17 +396,39 @@ class Win32Window(BaseWindow):
         _dwmapi.DwmEnableBlurBehindWindow(self._hwnd, byref(bb))
         _gdi32.DeleteObject(region)
 
+        _user32.SetLayeredWindowAttributes(self._hwnd, 0, 255, constants.LWA_ALPHA)
+
     def flip(self) -> None:
         self.draw_mouse_cursor()
 
         if not self._fullscreen and (self._always_dwm or self._dwm_composition_enabled()) and self._interval:
             _dwmapi.DwmFlush()
 
-        if self.style in ('overlay', 'transparent'):
-            self.update_transparency()
-
         self.context.flip()
 
+    def set_mouse_passthrough(self, state: bool) -> None:
+        color_ref = COLORREF()
+        alpha = BYTE()
+        flags = DWORD()
+
+        if self._ex_ws_style & constants.WS_EX_LAYERED:
+            _user32.GetLayeredWindowAttributes(self._hwnd, byref(color_ref), byref(alpha), byref(flags))
+
+        if state:
+            self._ex_ws_style |= (constants.WS_EX_TRANSPARENT | constants.WS_EX_LAYERED)
+        else:
+            self._ex_ws_style &= ~constants.WS_EX_TRANSPARENT
+
+            if self._ex_ws_style & constants.WS_EX_LAYERED and not flags.value & constants.LWA_ALPHA:
+                self._ex_ws_style &= ~constants.WS_EX_LAYERED
+
+        _user32.SetWindowLongW(self._hwnd, constants.GWL_EXSTYLE, self._ex_ws_style)
+
+        if state:
+            _user32.SetLayeredWindowAttributes(self._hwnd, color_ref.value, alpha.value, flags.value)
+
+
+
     def set_location(self, x: int, y: int) -> None:
         x, y = self._client_to_window_pos(x, y)
         _user32.SetWindowPos(self._hwnd, 0, x, y, 0, 0,

pyglet/window/xlib/__init__.py

@@ -28,7 +28,7 @@ from functools import lru_cache
 from typing import TYPE_CHECKING, Sequence
 
 import pyglet
-from pyglet.display.xlib import XlibCanvas
+from pyglet.display.xlib import XlibCanvas, XlibScreenXinerama
 from pyglet.event import EventDispatcher
 from pyglet.libs.x11 import cursorfont, xlib
 from pyglet.util import asbytes
@@ -229,8 +229,6 @@ class XlibWindow(BaseWindow):
             root = xlib.XRootWindow(self._x_display, self._x_screen_id)
 
             visual_info = self.config.get_visual_info()
-            if self.style in ('transparent', 'overlay'):
-                xlib.XMatchVisualInfo(self._x_display, self._x_screen_id, 32, xlib.TrueColor, visual_info)
 
             visual = visual_info.visual
             visual_id = xlib.XVisualIDFromVisual(visual)
@@ -303,6 +301,11 @@ class XlibWindow(BaseWindow):
             protocols = (c_ulong * len(protocols))(*protocols)
             xlib.XSetWMProtocols(self._x_display, self._window, protocols, len(protocols))
 
+            # Overlay should allow mouse to pass through and stay on top.
+            if self._style == "overlay":
+                self.set_mouse_passthrough(True)
+                self._set_wm_state("_NET_WM_STATE_ABOVE")
+
             # Create window resize sync counter
             if self._enable_xsync:
                 value = xsync.XSyncValue()
@@ -436,6 +439,16 @@ class XlibWindow(BaseWindow):
         self._applied_mouse_exclusive = None
         self._update_exclusivity()
 
+    def set_mouse_passthrough(self, state: bool) -> None:
+        """Sets the clickable area in the application to an empty region if enabled."""
+        if state:
+            region = xlib.XCreateRegion()
+            xsync.XShapeCombineRegion(self._x_display, self._window, xsync.ShapeInput, 0, 0, region, xsync.ShapeSet)
+            xlib.XDestroyRegion(region)
+        else:
+            # Reset input shape to default
+            xsync.XShapeCombineMask(self._x_display, self._window, xsync.ShapeInput, 0, 0, 0, xsync.ShapeSet)
+
     def _map(self) -> None:
         if self._mapped:
             return
@@ -730,7 +743,10 @@ class XlibWindow(BaseWindow):
                 y = self._height // 2
                 self._mouse_exclusive_client = x, y
                 self.set_mouse_position(x, y)
-            elif self._fullscreen and not self.screen._xinerama:  # noqa: SLF001
+            elif self._fullscreen:  # noqa: SLF001
+                if isinstance(self.screen, XlibScreenXinerama) and self.screen._xinerama:
+                    return
+
                 # Restrict to fullscreen area (prevent viewport scrolling)
                 self.set_mouse_position(0, 0)
                 r = xlib.XGrabPointer(self._x_display, self._view,
@@ -899,8 +915,6 @@ class XlibWindow(BaseWindow):
 
             text = text_bytes.decode('utf-8')
 
-        self._clipboard_str = text
-
         xlib.XFree(data)
         return text
 
@@ -1519,7 +1533,7 @@ class XlibWindow(BaseWindow):
         """Translate mouse button values to match mouse constants.
 
         Given a Xevent.xbutton.button value, convert it to the mouse
-        contants defined in :py:module:`~pyglet.window.mouse`. This
+        contents defined in :py:module:`~pyglet.window.mouse`. This
         means shifting the value, and also skipping over values of
         4~7, which are used for boolean scrolling.
         """

{pyglet-2.1.6.dist-info → pyglet-2.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyglet
-Version: 2.1.6
+Version: 2.1.9
 Summary: pyglet is a cross-platform games and multimedia package.
 Author-email: Alex Holkner & contributors <Alex.Holkner@gmail.com>
 Requires-Python: >=3.8