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

pyglet/window/xlib/__init__.py

@@ -23,14 +23,16 @@ from ctypes import (
     pointer,
     sizeof,
     string_at,
+    c_float,
 )
 from functools import lru_cache
 from typing import TYPE_CHECKING, Sequence
 
 import pyglet
-from pyglet.display.xlib import XlibCanvas, XlibScreenXinerama
+from pyglet.display.xlib import XlibScreenXinerama
 from pyglet.event import EventDispatcher
-from pyglet.libs.x11 import cursorfont, xlib
+from pyglet.libs.linux.x11 import cursorfont, xlib
+from pyglet.libs.linux.x11.xrender import XRenderFindVisualFormat
 from pyglet.util import asbytes
 from pyglet.window import (
     BaseWindow,
@@ -46,17 +48,18 @@ from pyglet.window import (
 )
 
 if TYPE_CHECKING:
+    from pyglet.config.gl.x11 import XlibGLSurfaceConfig
+    from pyglet.libs.linux.x11.xlib import Visual
     from _ctypes import _Pointer
-    from pyglet.gl.xlib import XlibDisplayConfig
 
 try:
-    from pyglet.libs.x11 import xsync
+    from pyglet.libs.linux.x11 import xsync
 
     _have_xsync = True
 except ImportError:
     _have_xsync = False
 
-_debug = pyglet.options['debug_x11']
+_debug = pyglet.options.debug_x11
 
 
 class mwmhints_t(Structure):
@@ -111,7 +114,7 @@ class XlibException(WindowException):
 
 
 class XlibMouseCursor(MouseCursor):
-    gl_drawable: bool = False
+    api_drawable: bool = False
     hw_drawable: bool = True
 
     def __init__(self, cursor: xlib.Cursor) -> None:
@@ -124,7 +127,7 @@ ViewEventHandler = _ViewEventHandler
 
 
 class XlibWindow(BaseWindow):
-    config: XlibDisplayConfig
+    config: XlibGLSurfaceConfig
     _x_display: xlib.Display | None = None  # X display connection
     _x_screen_id: int | None = None  # X screen index
     _x_ic: xlib.XIC | None = None  # X input context
@@ -191,7 +194,7 @@ class XlibWindow(BaseWindow):
             self.context.detach()
             xlib.XDestroyWindow(self._x_display, self._window)
             del self.display._window_map[self._window]  # noqa: SLF001
-            del self.display._window_map[self._view]  # noqa: SLF001
+            del self.display._window_map[self._x_window]  # noqa: SLF001
             self._window = None
             self._mapped = False
 
@@ -224,23 +227,36 @@ class XlibWindow(BaseWindow):
         self._x_display = self.display._display  # noqa: SLF001
         self._x_screen_id = self.display.x_screen
 
+        self._is_transparent = False
+
         # Create X window if not already existing.
         if not self._window:
             root = xlib.XRootWindow(self._x_display, self._x_screen_id)
 
-            visual_info = self.config.get_visual_info()
+            # In OpenGL, it requires you to query GLX for the visual info.
+            if pyglet.options.backend is not None and not self._shadow:
+                if "gl" in pyglet.options.backend:
+                    self._assign_config()
 
-            visual = visual_info.visual
-            visual_id = xlib.XVisualIDFromVisual(visual)
-            default_visual = xlib.XDefaultVisual(self._x_display, self._x_screen_id)
-            default_visual_id = xlib.XVisualIDFromVisual(default_visual)
-            window_attributes = xlib.XSetWindowAttributes()
-            if visual_id != default_visual_id:
-                window_attributes.colormap = xlib.XCreateColormap(self._x_display, root,
-                                                                  visual, xlib.AllocNone)
+                    visual_info = self.config.get_visual_info()
+
+                    visual = visual_info.visual
+                    depth = visual_info.depth
+
+                # Vulkan just uses the default visual ID
+                elif pyglet.options.backend == "vulkan":
+                    visual = xlib.XDefaultVisual(self._x_display, self._x_screen_id)
+                    depth = xlib.XDefaultDepth(self._x_display, self._x_screen_id)
+                else:
+                    msg = f"{pyglet.options.backend} Backend not supported."
+                    raise Exception(msg)
             else:
-                window_attributes.colormap = xlib.XDefaultColormap(self._x_display,
-                                                                   self._x_screen_id)
+                visual = xlib.XDefaultVisual(self._x_display, self._x_screen_id)
+                depth = xlib.XDefaultDepth(self._x_display, self._x_screen_id)
+
+            window_attributes = xlib.XSetWindowAttributes()
+            window_attributes.colormap = xlib.XCreateColormap(self._x_display, root,
+                                                              visual, xlib.AllocNone)
             window_attributes.bit_gravity = xlib.StaticGravity
 
             # Issue 287: Compiz on Intel/Mesa doesn't draw window decoration
@@ -264,36 +280,42 @@ class XlibWindow(BaseWindow):
             else:
                 width, height = self._width, self._height
                 self._view_x = self._view_y = 0
-                if pyglet.options.dpi_scaling in ("scaled", "stretch"):
+                if pyglet.options.dpi_scaling == "stretch":
                     w, h = self.get_requested_size()
                     self._width = width = int(w * self.scale)
                     self._height = height = int(h * self.scale)
 
             self._window = xlib.XCreateWindow(self._x_display, root,
-                                              0, 0, width, height, 0, visual_info.depth,
+                                              0, 0, width, height, 0, depth,
                                               xlib.InputOutput, visual, mask,
                                               byref(window_attributes))
-            self._view = xlib.XCreateWindow(self._x_display,
-                                            self._window, self._view_x, self._view_y,
-                                            self._width, self._height, 0, visual_info.depth,
-                                            xlib.InputOutput, visual, mask,
-                                            byref(window_attributes))
-            xlib.XMapWindow(self._x_display, self._view)
-            xlib.XSelectInput(self._x_display, self._view, self._default_event_mask)
+            self._x_window = xlib.XCreateWindow(self._x_display,
+                                                self._window, self._view_x, self._view_y,
+                                                self._width, self._height, 0, depth,
+                                                xlib.InputOutput, visual, mask,
+                                                byref(window_attributes))
+            xlib.XMapWindow(self._x_display, self._x_window)
+            xlib.XSelectInput(self._x_display, self._x_window, self._default_event_mask)
 
             self.display._window_map[self._window] = self.dispatch_platform_event  # noqa: SLF001
-            self.display._window_map[self._view] = self.dispatch_platform_event_view
+            self.display._window_map[self._x_window] = self.dispatch_platform_event_view  # noqa: SLF001
 
-            self.canvas = XlibCanvas(self.display, self._view)
+            # Vulkan surface needs to be created after the window. Possibly move surface creation to context.attach.
+            if pyglet.options.backend == "vulkan" and not self._shadow:
+                self._assign_config()
 
-            self.context.attach(self.canvas)
-            self.context.set_vsync(self._vsync)  # XXX ?
+            if self.context:
+                self.context.attach(self)
+                self.context.set_vsync(self._vsync)  # XXX ?VulkanWindowConfig
 
-            self._enable_xsync = self.display._enable_xsync and self.config.double_buffer
+                self._enable_xsync = self.display._enable_xsync and self.config.double_buffer
+            else:
+                self._enable_xsync = False
 
             # Set supported protocols
             protocols = list()
             protocols.append(xlib.XInternAtom(self._x_display, asbytes('WM_DELETE_WINDOW'), False))
+
             if self._enable_xsync:
                 protocols.append(xlib.XInternAtom(self._x_display,
                                                   asbytes('_NET_WM_SYNC_REQUEST'),
@@ -310,14 +332,19 @@ class XlibWindow(BaseWindow):
             if self._enable_xsync:
                 value = xsync.XSyncValue()
                 self._sync_counter = xlib.XID(xsync.XSyncCreateCounter(self._x_display, value))
-                atom = xlib.XInternAtom(self._x_display,
-                                        asbytes('_NET_WM_SYNC_REQUEST_COUNTER'), False)
+                atom = xlib.XInternAtom(self._x_display, asbytes('_NET_WM_SYNC_REQUEST_COUNTER'), False)
                 ptr = pointer(self._sync_counter)
 
-                xlib.XChangeProperty(self._x_display, self._window,
-                                     atom, XA_CARDINAL, 32,
-                                     xlib.PropModeReplace,
-                                     cast(ptr, POINTER(c_ubyte)), 1)
+                xlib.XChangeProperty(
+                    self._x_display,
+                    self._window,
+                    atom,
+                    XA_CARDINAL,
+                    32,
+                    xlib.PropModeReplace,
+                    cast(ptr, POINTER(c_ubyte)),
+                    1,
+                )
 
             # Atoms required for Xdnd
             self._create_xdnd_atoms(self._x_display)
@@ -435,10 +462,17 @@ class XlibWindow(BaseWindow):
         if self._visible:
             self.set_visible(True)
 
-        self.set_mouse_platform_visible()
+        self.set_mouse_cursor_platform_visible()
         self._applied_mouse_exclusive = None
         self._update_exclusivity()
 
+    def _is_visual_transparent(self, visual: _Pointer[Visual]) -> bool:
+        if not XRenderFindVisualFormat:
+            return False
+
+        xrender_format = XRenderFindVisualFormat(self._x_display, visual)
+        return xrender_format and xrender_format.contents.direct.alphaMask != 0
+
     def set_mouse_passthrough(self, state: bool) -> None:
         """Sets the clickable area in the application to an empty region if enabled."""
         if state:
@@ -509,13 +543,14 @@ class XlibWindow(BaseWindow):
         if not self._window:
             return
 
-        self.context.destroy()
+        if self.context:
+            self.context.destroy()
         self._unmap()
         if self._window:
             xlib.XDestroyWindow(self._x_display, self._window)
 
         del self.display._window_map[self._window]  # noqa: SLF001
-        del self.display._window_map[self._view]
+        del self.display._window_map[self._x_window]
         self._window = None
 
         self._view_event_handlers.clear()
@@ -531,18 +566,22 @@ class XlibWindow(BaseWindow):
         if self.context:
             self.context.set_current()
 
+    def before_draw(self) -> None:
+        if self.context:
+            self.context.before_draw()
+
     def flip(self):
         self.draw_mouse_cursor()
 
-        # TODO canvas.flip?
+        # TODO window.flip?
         if self.context:
             self.context.flip()
 
         self._sync_resize()
 
     def set_vsync(self, vsync: bool) -> None:
-        if pyglet.options['vsync'] is not None:
-            vsync = pyglet.options['vsync']
+        if pyglet.options.vsync is not None:
+            vsync = pyglet.options.vsync
 
         super().set_vsync(vsync)
         self.context.set_vsync(vsync)
@@ -582,7 +621,7 @@ class XlibWindow(BaseWindow):
         self.dispatch_event('_on_internal_resize', width, height)
 
     def _update_view_size(self) -> None:
-        xlib.XResizeWindow(self._x_display, self._view, self._width, self._height)
+        xlib.XResizeWindow(self._x_display, self._x_window, self._width, self._height)
 
     def set_location(self, x: int, y: int) -> None:
         if self._is_reparented():
@@ -669,7 +708,7 @@ class XlibWindow(BaseWindow):
         width = texture.width
         height = texture.height
 
-        alpha_luma_bytes = texture.get_image_data().get_data('AL', -width * 2)
+        alpha_luma_bytes = texture.get_image_data().get_bytes('AL', -width * 2)
         mask_data = self._downsample_1bit(alpha_luma_bytes[0::2])
         bmp_data = self._downsample_1bit(alpha_luma_bytes[1::2])
 
@@ -687,11 +726,11 @@ class XlibWindow(BaseWindow):
 
         return cursor
 
-    def set_mouse_platform_visible(self, platform_visible: bool | None = None) -> None:
+    def set_mouse_cursor_platform_visible(self, platform_visible: bool | None = None) -> None:
         if not self._window:
             return
         if platform_visible is None:
-            platform_visible = self._mouse_visible and not self._mouse_cursor.gl_drawable
+            platform_visible = self._mouse_visible and not self._mouse_cursor.api_drawable
 
         if platform_visible is False:
             # Hide pointer by creating an empty cursor:
@@ -726,7 +765,7 @@ class XlibWindow(BaseWindow):
 
         if mouse_exclusive != self._applied_mouse_exclusive:
             if mouse_exclusive:
-                self.set_mouse_platform_visible(False)
+                self.set_mouse_cursor_platform_visible(False)
 
                 # Restrict to client area
                 xlib.XGrabPointer(self._x_display, self._window,
@@ -743,28 +782,28 @@ class XlibWindow(BaseWindow):
                 y = self._height // 2
                 self._mouse_exclusive_client = x, y
                 self.set_mouse_position(x, y)
-            elif self._fullscreen:  # noqa: SLF001
+            elif self._fullscreen:
                 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,
+                r = xlib.XGrabPointer(self._x_display, self._x_window,
                                       True, 0,
                                       xlib.GrabModeAsync,
                                       xlib.GrabModeAsync,
-                                      self._view,
+                                      self._x_window,
                                       0,
                                       xlib.CurrentTime)
                 if r:
                     # Failed to grab, try again later
                     self._applied_mouse_exclusive = None
                     return
-                self.set_mouse_platform_visible()
+                self.set_mouse_cursor_platform_visible()
             else:
                 # Unclip
                 xlib.XUngrabPointer(self._x_display, xlib.CurrentTime)
-                self.set_mouse_platform_visible()
+                self.set_mouse_cursor_platform_visible()
 
             self._applied_mouse_exclusive = mouse_exclusive
 
@@ -845,7 +884,7 @@ class XlibWindow(BaseWindow):
             pitch = -(image.width * len(fmt))
             s = c_buffer(sizeof(c_ulong) * 2)
             memmove(s, cast((c_ulong * 2)(image.width, image.height), POINTER(c_ubyte)), len(s))
-            data += s.raw + image.get_data(fmt, pitch)
+            data += s.raw + image.get_bytes(fmt, pitch)
         buffer = (c_ubyte * len(data))()
         memmove(buffer, data, len(data))
         atom = xlib.XInternAtom(self._x_display, asbytes('_NET_WM_ICON'), False)
@@ -960,7 +999,7 @@ class XlibWindow(BaseWindow):
         name_atom = xlib.XInternAtom(self._x_display, asbytes(name), False)
         atoms = [xlib.XInternAtom(self._x_display, asbytes(value), False) for value in values]
         atom_type = xlib.XInternAtom(self._x_display, asbytes('ATOM'), False)
-        if len(atoms):
+        if atoms:
             atoms_ar = (xlib.Atom * len(atoms))(*atoms)
             xlib.XChangeProperty(self._x_display, self._window,
                                  name_atom, atom_type, 32, mode,
@@ -975,7 +1014,7 @@ class XlibWindow(BaseWindow):
         net_wm_state = xlib.XInternAtom(self._x_display, asbytes('_NET_WM_STATE'), False)
         atoms = [xlib.XInternAtom(self._x_display, asbytes(state), False) for state in states]
         atom_type = xlib.XInternAtom(self._x_display, asbytes('ATOM'), False)
-        if len(atoms):
+        if atoms:
             atoms_ar = (xlib.Atom * len(atoms))(*atoms)
             xlib.XChangeProperty(self._x_display, self._window,
                                  net_wm_state, atom_type, 32, xlib.PropModePrepend,
@@ -1008,7 +1047,7 @@ class XlibWindow(BaseWindow):
         # Cache these in case window is closed from an event handler
         _x_display = self._x_display
         _window = self._window
-        _view = self._view
+        _x_window = self._x_window
 
         # Check for the events specific to this window
         while xlib.XCheckWindowEvent(_x_display, _window, 0x1ffffff, byref(e)):
@@ -1020,7 +1059,7 @@ class XlibWindow(BaseWindow):
             self.dispatch_platform_event(e)
 
         # Check for the events specific to this view
-        while xlib.XCheckWindowEvent(_x_display, _view, 0x1ffffff, byref(e)):
+        while xlib.XCheckWindowEvent(_x_display, _x_window, 0x1ffffff, byref(e)):
             # Key events are filtered by the xlib window event
             # handler so they get a shot at the prefiltered event.
             if e.xany.type not in (xlib.KeyPress, xlib.KeyRelease):
@@ -1059,7 +1098,7 @@ class XlibWindow(BaseWindow):
             event_handler(e)
 
     @staticmethod
-    @lru_cache()
+    @lru_cache
     def _translate_modifiers(state: int) -> int:
         modifiers = 0
         if state & xlib.ShiftMask:
@@ -1205,10 +1244,9 @@ class XlibWindow(BaseWindow):
                     for auto_event in reversed(saved):
                         xlib.XPutBackEvent(self._x_display, byref(auto_event))
                     return
-                else:
-                    # Key code of press did not match, therefore no repeating
-                    # is going on, stop searching.
-                    break
+                # Key code of press did not match, therefore no repeating
+                # is going on, stop searching.
+                break
             # Whoops, put the events back, it's for real.
             for auto_event in reversed(saved):
                 xlib.XPutBackEvent(self._x_display, byref(auto_event))
@@ -1528,7 +1566,7 @@ class XlibWindow(BaseWindow):
             self._current_sync_valid = False
 
     @staticmethod
-    @lru_cache()
+    @lru_cache
     def _translate_button(value: int) -> int:
         """Translate mouse button values to match mouse constants.
 

{pyglet-2.1.13.dist-info → pyglet-3.0.dev1.dist-info}/METADATA

@@ -1,11 +1,10 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: pyglet
-Version: 2.1.13
+Version: 3.0.dev1
 Summary: pyglet is a cross-platform games and multimedia package.
 Author-email: Alex Holkner & contributors <Alex.Holkner@gmail.com>
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Project-URL: Home, https://pyglet.org
 
 [![pypi](https://badge.fury.io/py/pyglet.svg)](https://pypi.python.org/pypi/pyglet) [![rtd](https://readthedocs.org/projects/pyglet/badge/?version=latest)](https://pyglet.readthedocs.io) [![PyTest](https://github.com/pyglet/pyglet/actions/workflows/unittests.yml/badge.svg)](https://github.com/pyglet/pyglet/actions/workflows/unittests.yml)