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

pyglet/window/win32/__init__.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sys
 import unicodedata
-from ctypes.wintypes import DWORD, HICON, HWND, MSG, POINT, RECT, SIZE, UINT
+from ctypes.wintypes import DWORD, HICON, HWND, MSG, POINT, RECT, SIZE, UINT, BOOL, HKEY, LPBYTE
 from functools import lru_cache
 from typing import Callable, Sequence
 
@@ -38,11 +38,10 @@ from ctypes import (
     create_unicode_buffer,
     memmove,
     sizeof,
-    wstring_at,
+    wstring_at, c_ubyte,
 )
 
 import pyglet
-from pyglet.display.win32 import Win32Canvas
 from pyglet.event import EventDispatcher
 from pyglet.libs.win32 import (
     BITMAPV5HEADER,
@@ -56,6 +55,7 @@ from pyglet.libs.win32 import (
     _kernel32,
     _shell32,
     _user32,
+    _advapi32,
 )
 from pyglet.window import (
     BaseWindow,
@@ -91,7 +91,7 @@ _motion_map: dict[tuple[int, bool], int] = {
 
 
 class Win32MouseCursor(MouseCursor):
-    gl_drawable: bool = False
+    api_drawable: bool = False
     hw_drawable: bool = True
 
     def __init__(self, cursor: HCURSOR) -> None:
@@ -106,16 +106,6 @@ Win32EventHandler = _PlatformEventHandler
 ViewEventHandler = _ViewEventHandler
 
 
-# Some events should not be queued, especially those with pointers or structures.
-# Data is only guaranteed to be available for the duration of the initial function call.
-_priority_events = [
-    constants.WM_GETMINMAXINFO,
-    constants.WM_GETDPISCALEDSIZE,
-    constants.WM_DPICHANGED,
-    constants.WM_INPUT,
-]
-
-
 class Win32Window(BaseWindow):
     _window_class = None
     _hwnd = None
@@ -203,13 +193,11 @@ class Win32Window(BaseWindow):
             width = self.screen.width
             height = self.screen.height
         else:
-            if pyglet.options.dpi_scaling in ("scaled", "stretch"):
+            if pyglet.options.dpi_scaling == "stretch":
                 w, h = self.get_requested_size()
                 self._width = int(w * self.scale)
                 self._height = int(h * self.scale)
-
-                if pyglet.options.dpi_scaling == "stretch":
-                    self._mouse_scale = self.scale
+                self._mouse_scale = self.scale
 
             width, height = \
                 self._client_to_window_size(self._width, self._height, self._dpi)
@@ -267,14 +255,31 @@ class Win32Window(BaseWindow):
                 self._view_window_class.lpszClassName,
                 '',
                 constants.WS_CHILD | constants.WS_VISIBLE,
-                0, 0, 0, 0,
+                0,
+                0,
+                0,
+                0,
                 self._hwnd,
                 0,
                 self._view_window_class.hInstance,
-                0)
+                0,
+            )
 
             self._dc = _user32.GetDC(self._view_hwnd)
 
+            if not self._fullscreen and constants.WINDOWS_11_21H2_OR_GREATER:
+                self._update_light_mode(_ShouldSystemUseLightMode())
+
+            # Context must be created after window is created.
+            if pyglet.options.backend and not self._shadow:
+                if "gl" in pyglet.options.backend and not self._wgl_context:
+                    self._assign_config()
+                    self.context.attach(self)
+                    self._wgl_context = self.context._context  # noqa: SLF001
+                else:
+                    self._assign_config()
+                    self.context.attach(self)
+
             # Only allow files being dropped if specified.
             if self._file_drops:
                 # Allows UAC to not block the drop files request if low permissions. All 3 must be set.
@@ -323,16 +328,11 @@ class Win32Window(BaseWindow):
 
         self._update_view_location(self._width, self._height)
 
-        # Context must be created after window is created.
-        if not self._wgl_context:
-            self.canvas = Win32Canvas(self.display, self._view_hwnd, self._dc)
-            self.context.attach(self.canvas)
-            self._wgl_context = self.context._context  # noqa: SLF001
-
-        self.switch_to()
-
         self.set_caption(self._caption)
-        self.set_vsync(self._vsync)
+
+        if pyglet.options.backend and not self._shadow:
+            self.switch_to()
+            self.set_vsync(self._vsync)
 
         if self._visible:
             self.set_visible()
@@ -340,6 +340,10 @@ class Win32Window(BaseWindow):
             self.dispatch_event('_on_internal_resize', self._width, self._height)
             self.dispatch_event('on_expose')
 
+    @property
+    def dc(self):
+        return self._dc
+
     def _update_view_location(self, width: int, height: int) -> None:
         if self._fullscreen:
             x = (self.screen.width - width) // 2
@@ -354,7 +358,7 @@ class Win32Window(BaseWindow):
             super().close()
             return
 
-        self.set_mouse_platform_visible(True)
+        self.set_mouse_cursor_platform_visible(True)
 
         _user32.DestroyWindow(self._hwnd)
         _user32.UnregisterClassW(self._view_window_class.lpszClassName, 0)
@@ -382,8 +386,8 @@ class Win32Window(BaseWindow):
         return bool(self._interval)
 
     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
 
         self._interval = vsync
 
@@ -414,7 +418,8 @@ class Win32Window(BaseWindow):
         if not self._fullscreen and not self._always_dwm and self._dwm_composition_enabled() and self._interval:
             _dwmapi.DwmFlush()
 
-        self.context.flip()
+        if self._context:
+            self._context.flip()
 
     def set_mouse_passthrough(self, state: bool) -> None:
         color_ref = COLORREF()
@@ -437,6 +442,8 @@ class Win32Window(BaseWindow):
         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,
@@ -450,7 +457,7 @@ class Win32Window(BaseWindow):
         return point.x, point.y
 
     def set_size(self, width: int, height: int) -> None:
-        if pyglet.options.dpi_scaling in ("scaled", "stretch"):
+        if pyglet.options.dpi_scaling == "stretch":
             width = int(width * self.scale)
             height = int(height * self.scale)
 
@@ -481,7 +488,7 @@ class Win32Window(BaseWindow):
             _user32.ShowWindow(self._hwnd, constants.SW_HIDE)
             self.dispatch_event('on_hide')
         self._visible = visible
-        self.set_mouse_platform_visible()
+        self.set_mouse_cursor_platform_visible()
 
     def minimize(self) -> None:
         _user32.ShowWindow(self._hwnd, constants.SW_MINIMIZE)
@@ -500,11 +507,11 @@ class Win32Window(BaseWindow):
         self._caption = caption
         _user32.SetWindowTextW(self._hwnd, c_wchar_p(caption))
 
-    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 platform_visible is None:
             platform_visible = (self._mouse_visible and
                                 not self._exclusive_mouse and
-                                (not self._mouse_cursor.gl_drawable or self._mouse_cursor.hw_drawable)) or \
+                                (not self._mouse_cursor.api_drawable or self._mouse_cursor.hw_drawable)) or \
                                (not self._mouse_in_window or
                                 not self._has_focus)
 
@@ -588,7 +595,7 @@ class Win32Window(BaseWindow):
 
         self._exclusive_mouse = exclusive
         self._exclusive_mouse_focus = self._has_focus
-        self.set_mouse_platform_visible(not exclusive)
+        self.set_mouse_cursor_platform_visible(not exclusive)
 
     def set_mouse_position(self, x: int, y: int, absolute: bool = False) -> None:
         if not absolute:
@@ -685,7 +692,7 @@ class Win32Window(BaseWindow):
             _user32.ReleaseDC(None, hdc)
 
             img = img.get_image_data()
-            data = img.get_data(fmt, pitch)
+            data = img.get_bytes(fmt, pitch)
             memmove(dataptr, data, len(data))
 
             mask = _gdi32.CreateBitmap(img.width, img.height, 1, 1, None)
@@ -734,7 +741,7 @@ class Win32Window(BaseWindow):
         _user32.ReleaseDC(None, hdc)
 
         image = image.get_image_data()
-        data = image.get_data(fmt, pitch)
+        data = image.get_bytes(fmt, pitch)
         memmove(dataptr, data, len(data))
 
         mask = _gdi32.CreateBitmap(image.width, image.height, 1, 1, None)
@@ -867,7 +874,7 @@ class Win32Window(BaseWindow):
             event_handler = event_handlers.get(msg)
             result = None
             if event_handler:
-                if self._allow_dispatch_event or not self._enable_event_queue or msg in _priority_events:
+                if self._allow_dispatch_event or not self._enable_event_queue:
                     result = event_handler(msg, wParam, lParam)
                 else:
                     result = 0
@@ -1070,7 +1077,7 @@ class Win32Window(BaseWindow):
             # to determine when to recreate the tracking structure after
             # re-entering (to track the next WM_MOUSELEAVE).
             self._mouse_in_window = True
-            self.set_mouse_platform_visible()
+            self.set_mouse_cursor_platform_visible()
             self.dispatch_event('on_mouse_enter', x / self._mouse_scale, y / self._mouse_scale)
             self._tracking = True
             track = TRACKMOUSEEVENT()
@@ -1119,7 +1126,7 @@ class Win32Window(BaseWindow):
         y = self._height - point.y
         self._tracking = False
         self._mouse_in_window = False
-        self.set_mouse_platform_visible()
+        self.set_mouse_cursor_platform_visible()
         self.dispatch_event('on_mouse_leave', x / self._mouse_scale, y / self._mouse_scale)
         return 0
 
@@ -1382,7 +1389,7 @@ class Win32Window(BaseWindow):
 
     @Win32EventHandler(constants.WM_GETDPISCALEDSIZE)
     def _event_dpi_scaled_size(self, msg: int, wParam: int, lParam: int) -> int | None:
-        if pyglet.options.dpi_scaling in ("scaled", "stretch"):
+        if pyglet.options.dpi_scaling == "stretch":
             return None
 
         size = cast(lParam, POINTER(SIZE)).contents
@@ -1416,7 +1423,7 @@ class Win32Window(BaseWindow):
         self._dpi = x_dpi
 
         if not self._fullscreen and \
-                (pyglet.options.dpi_scaling != "real" or constants.WINDOWS_10_CREATORS_UPDATE_OR_GREATER):
+                (pyglet.options.dpi_scaling != "stretch" or constants.WINDOWS_10_CREATORS_UPDATE_OR_GREATER):
             suggested_rect = cast(lParam, POINTER(RECT)).contents
 
             x = suggested_rect.left
@@ -1434,6 +1441,54 @@ class Win32Window(BaseWindow):
         self.dispatch_event('_on_internal_scale', scale, x_dpi)
         return 1
 
-
+    @Win32EventHandler(constants.WM_SETTINGCHANGE)
+    def _event_setting_change(self, msg: int, wParam: int, lParam: int) -> int:
+        if wParam == 0 and lParam != 0 and constants.WINDOWS_11_21H2_OR_GREATER:
+            ptr = cast(lParam, c_wchar_p)
+            if ptr.value == 'ImmersiveColorSet':
+                self._update_light_mode(_ShouldSystemUseLightMode())
+
+    def _update_light_mode(self, is_light_mode: bool) -> None:
+        value = BOOL(not is_light_mode)
+
+        _dwmapi.DwmSetWindowAttribute(self._hwnd, constants.DWMWA_USE_IMMERSIVE_DARK_MODE, byref(value), sizeof(value))
+
+def _ShouldSystemUseLightMode() -> bool:
+    """With Windows 11 there is no stable API to get the current light mode.
+
+    uxtheme.dll does have hidden functions that seemingly work. However, there are many reports it's not stable across
+    versions. The functions (138, which should be `ShouldAppsUseDarkMode`) are also not publicly exposed.
+
+    This was documented over 4 years ago here: https://github.com/microsoft/WindowsAppSDK/issues/41
+
+    With no solution from Microsoft, we have to rely on checking the registry key associated with this.
+    """
+    subkey = r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize"
+    value_name = "AppsUseLightTheme"
+    hkey = HKEY()
+
+    if _advapi32.RegOpenKeyExW(constants.HKEY_CURRENT_USER, subkey, 0, constants.KEY_READ, byref(hkey)) != 0:
+        return True
+
+    data_type = DWORD()
+    data_value = (c_ubyte * 4)()  # DWORD = 4 bytes
+    data_size = DWORD(sizeof(data_value))
+
+    try:
+        result = _advapi32.RegQueryValueExW(
+            hkey,
+            value_name,
+            None,
+            byref(data_type),
+            cast(data_value, LPBYTE),
+            byref(data_size),
+        )
+        if result == 0 and data_type.value == constants.REG_DWORD:
+            value = int.from_bytes(bytes(data_value), "little")
+            return bool(value)
+    finally:
+        _advapi32.RegCloseKey(hkey)
+
+    return True
 
 __all__ = ['Win32EventHandler', 'Win32Window']