PyWebWinUI3 1.0.0b43__tar.gz → 1.0.0b45__tar.gz

{pywebwinui3-1.0.0b43/PyWebWinUI3.egg-info → pywebwinui3-1.0.0b45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyWebWinUI3
-Version: 1.0.0b43
+Version: 1.0.0b45
 Summary: Create modern WinUI3-style desktop UIs in Python effortlessly using PySide6 and QtWebEngine.
 Home-page: https://github.com/Haruna5718/PyWebWinUI3
 Author: Haruna5718

{pywebwinui3-1.0.0b43 → pywebwinui3-1.0.0b45/PyWebWinUI3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyWebWinUI3
-Version: 1.0.0b43
+Version: 1.0.0b45
 Summary: Create modern WinUI3-style desktop UIs in Python effortlessly using PySide6 and QtWebEngine.
 Home-page: https://github.com/Haruna5718/PyWebWinUI3
 Author: Haruna5718

{pywebwinui3-1.0.0b43 → pywebwinui3-1.0.0b45}/PyWebWinUI3.egg-info/SOURCES.txt

@@ -112,17 +112,17 @@ pywebwinui3/web/Pretendard/PretendardVariable.subset.91.woff2
 pywebwinui3/web/Pretendard/Variable-dynamic-subset.min.css
 pywebwinui3/web/_app/env.js
 pywebwinui3/web/_app/version.json
-pywebwinui3/web/_app/immutable/assets/2.BF6evWMx.css
+pywebwinui3/web/_app/immutable/assets/2.QxDX12Lu.css
+pywebwinui3/web/_app/immutable/chunks/BprPI5v6.js
 pywebwinui3/web/_app/immutable/chunks/C5fctQ8t.js
 pywebwinui3/web/_app/immutable/chunks/DuPwkB53.js
 pywebwinui3/web/_app/immutable/chunks/KfJIcf5l.js
-pywebwinui3/web/_app/immutable/chunks/TzBZ48H8.js
 pywebwinui3/web/_app/immutable/chunks/jnH-TXHS.js
 pywebwinui3/web/_app/immutable/chunks/ln01AzD2.js
 pywebwinui3/web/_app/immutable/chunks/oIQI43DZ.js
 pywebwinui3/web/_app/immutable/chunks/wKeSOqcH.js
-pywebwinui3/web/_app/immutable/entry/app.UoyHjfbP.js
-pywebwinui3/web/_app/immutable/entry/start.PpAqhk-4.js
+pywebwinui3/web/_app/immutable/entry/app.76e8hy19.js
+pywebwinui3/web/_app/immutable/entry/start.BDCzTRGD.js
 pywebwinui3/web/_app/immutable/nodes/0.DYoNlsbe.js
-pywebwinui3/web/_app/immutable/nodes/1.DrRW4ELJ.js
-pywebwinui3/web/_app/immutable/nodes/2.D8H1CTiv.js
+pywebwinui3/web/_app/immutable/nodes/1.DJOepXLS.js
+pywebwinui3/web/_app/immutable/nodes/2.aKOPDyc3.js

{pywebwinui3-1.0.0b43 → pywebwinui3-1.0.0b45}/pywebwinui3/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["core", "event", "util", "type"]
 
-__version__ = '1.0.0-beta.43'
+__version__ = '1.0.0-beta.45'

{pywebwinui3-1.0.0b43 → pywebwinui3-1.0.0b45}/pywebwinui3/core.py

@@ -68,6 +68,26 @@ class MainWindow:
 		self.events.accentColorChange += lambda palette: self.values.set("system_accent", palette)
 		self.events.themeChange += lambda theme: self.values.set("system_theme_resolved", theme)
 
+	@staticmethod
+	def _normalize_notice_level(level) -> int:
+		try:
+			return int(level)
+		except (TypeError, ValueError):
+			name = str(getattr(level, "name", level)).split(".")[-1]
+			return int(getattr(Status, name, Status.Critical))
+
+	@classmethod
+	def _normalize_notice_entry(cls, entry) -> list:
+		if not isinstance(entry, (list, tuple)):
+			return [int(Status.Critical), "", str(entry or ""), None]
+
+		level, title, description, item, *_ = [*entry, None, None, None, None]
+		return [cls._normalize_notice_level(level), title or "", description or "", item]
+
+	@classmethod
+	def _normalize_notice_items(cls, items) -> list[list]:
+		return [cls._normalize_notice_entry(entry) for entry in items or []]
+
 	@property
 	def api(self) -> WebviewAPI:
 		if self._api is None:
@@ -118,11 +138,13 @@ class MainWindow:
 
 	def notice(self, level: Status, title: str, description: str, item: dict | None = None):
 		self.values["system_nofication"] = [
-			*self.values["system_nofication"],
-			[level, title, description, item],
+			*self._normalize_notice_items(self.values["system_nofication"]),
+			self._normalize_notice_entry([level, title, description, item]),
 		]
 
 	def init(self) -> dict:
+		if self.values.get("system_nofication"):
+			self.values.set("system_nofication", self._normalize_notice_items(self.values["system_nofication"]), False)
 		return dict(self.values)
 
 	def pin(self, state: bool):

{pywebwinui3-1.0.0b43 → pywebwinui3-1.0.0b45}/pywebwinui3/event.py

@@ -1,22 +1,12 @@
 from __future__ import annotations
 
-import atexit
 import fnmatch
 import logging
-import os
 import traceback
-from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Callable
 
 logger = logging.getLogger("pywebwinui3.eventmanager")
 
-_EVENT_WORKERS = max(4, min(32, (os.cpu_count() or 1) * 4))
-_EVENT_EXECUTOR = ThreadPoolExecutor(
-	max_workers=_EVENT_WORKERS,
-	thread_name_prefix="pywebwinui3-event",
-)
-atexit.register(lambda: _EVENT_EXECUTOR.shutdown(wait=False))
-
 
 def _call_listener(func: Callable[..., Any], args: tuple[Any, ...]):
 	try:
@@ -36,7 +26,7 @@ class Event:
 
 		for func in listeners:
 			try:
-				_EVENT_EXECUTOR.submit(_call_listener, func, args)
+				_call_listener(func, args)
 			except Exception:
 				logger.error(traceback.format_exc())
 
@@ -62,36 +52,49 @@ class Event:
 
 class PathEvent:
 	def __init__(self) -> None:
-		self.items: dict[str, Event] = {}
+		self.exact_items: dict[str, Event] = {}
+		self.pattern_items: dict[str, Event] = {}
+
+	@staticmethod
+	def _is_pattern(target: str) -> bool:
+		return any(char in target for char in "*?[]")
+
+	def _bucket(self, target: str) -> dict[str, Event]:
+		return self.pattern_items if self._is_pattern(target) else self.exact_items
 
 	def set(self, target: str, *args: Any):
-		if not self.items:
+		if not self.exact_items and not self.pattern_items:
 			return
 
-		for key, event in tuple(self.items.items()):
-			if not fnmatch.fnmatch(target, key):
-				continue
+		exact_event = self.exact_items.get(target)
+		if exact_event is not None:
+			try:
+				exact_event.set(target, *args)
+			except Exception:
+				logger.error(traceback.format_exc())
 
+		for key, event in tuple(self.pattern_items.items()):
 			try:
-				event.set(target, *args)
+				if fnmatch.fnmatch(target, key):
+					event.set(target, *args)
 			except Exception:
 				logger.error(traceback.format_exc())
 
 	def __add__(self, item: list):
-		self.items.setdefault(item[0], Event()).__iadd__(item[1])
+		self._bucket(item[0]).setdefault(item[0], Event()).__iadd__(item[1])
 		return self
 
 	def __sub__(self, item: list):
-		self.items.setdefault(item[0], Event()).__isub__(item[1])
+		self._bucket(item[0]).setdefault(item[0], Event()).__isub__(item[1])
 		return self
 
 	def __iadd__(self, item: list):
-		self.items.setdefault(item[0], Event()).__iadd__(item[1])
+		self._bucket(item[0]).setdefault(item[0], Event()).__iadd__(item[1])
 		return self
 
 	def __isub__(self, item: list):
-		self.items.setdefault(item[0], Event()).__isub__(item[1])
+		self._bucket(item[0]).setdefault(item[0], Event()).__isub__(item[1])
 		return self
 
 	def __len__(self) -> int:
-		return len(self.items)
+		return len(self.exact_items) + len(self.pattern_items)

{pywebwinui3-1.0.0b43 → pywebwinui3-1.0.0b45}/pywebwinui3/qt.py

@@ -7,19 +7,110 @@ import os
 import sys
 import threading
 from pathlib import Path
+from ctypes import wintypes
 
 from PySide6.QtCore import QEvent, QObject, QPoint, QRect, Qt, QTimer, QUrl, Signal, Slot
 from PySide6.QtGui import QColor, QCursor, QDesktopServices, QIcon, QKeySequence, QShortcut
 from PySide6.QtWebChannel import QWebChannel
-from PySide6.QtWebEngineCore import QWebEnginePage, QWebEngineSettings
+from PySide6.QtWebEngineCore import QWebEngineContextMenuRequest, QWebEnginePage, QWebEngineSettings
 from PySide6.QtWebEngineWidgets import QWebEngineView
 from PySide6.QtWidgets import QApplication, QMainWindow, QWidget
 import win32api
 import win32con
 import win32gui
+import win32gui_struct
 
 logger = logging.getLogger("pywebwinui3.qt")
 
+_kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+_uxtheme = ctypes.WinDLL("uxtheme", use_last_error=True)
+_get_proc_address = _kernel32.GetProcAddress
+_get_proc_address.restype = ctypes.c_void_p
+_get_proc_address.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+
+
+def _get_ordinal_proc(module, ordinal: int, restype, argtypes):
+	address = _get_proc_address(module._handle, ctypes.c_void_p(ordinal))
+	if not address:
+		return None
+	return ctypes.WINFUNCTYPE(restype, *argtypes)(address)
+
+
+_set_preferred_app_mode = _get_ordinal_proc(_uxtheme, 135, ctypes.c_int, [ctypes.c_int])
+_flush_menu_themes = _get_ordinal_proc(_uxtheme, 136, None, [])
+_allow_dark_mode_for_window = _get_ordinal_proc(_uxtheme, 133, wintypes.BOOL, [wintypes.HWND, wintypes.BOOL])
+
+
+def _merge_chromium_flags(*flags: str):
+	current = os.environ.get("QTWEBENGINE_CHROMIUM_FLAGS", "").strip()
+	parts = [part for part in current.split() if part]
+	for flag in flags:
+		if flag not in parts:
+			parts.append(flag)
+	os.environ["QTWEBENGINE_CHROMIUM_FLAGS"] = " ".join(parts)
+
+
+def _configure_webengine_gpu():
+	_merge_chromium_flags(
+		"--enable-gpu-rasterization",
+		"--enable-zero-copy",
+		"--enable-native-gpu-memory-buffers",
+		"--enable-oop-rasterization",
+		"--ignore-gpu-blocklist",
+	)
+
+
+def _apply_native_menu_theme(dark: bool, hwnd: int | None = None):
+	if _set_preferred_app_mode is not None:
+		_set_preferred_app_mode(2 if dark else 3)
+	if hwnd is not None and _allow_dark_mode_for_window is not None:
+		_allow_dark_mode_for_window(hwnd, bool(dark))
+	if _flush_menu_themes is not None:
+		_flush_menu_themes()
+
+
+def _open_external_url(url: str | QUrl) -> bool:
+	raw = url if isinstance(url, str) else url.toString()
+	if not raw:
+		return False
+
+	parsed = QUrl(raw)
+	if parsed.isValid() and QDesktopServices.openUrl(parsed):
+		return True
+
+	if sys.platform.startswith("win"):
+		try:
+			os.startfile(raw)
+			return True
+		except OSError:
+			logger.debug("Fallback shell open failed for %s", raw, exc_info=True)
+
+	fallback = QUrl.fromUserInput(raw)
+	return fallback.isValid() and QDesktopServices.openUrl(fallback)
+
+
+_ANCHOR_INTERCEPT_SCRIPT = """
+(() => {
+	if (window.__pywebwinui3_external_anchor_hook__) return;
+	window.__pywebwinui3_external_anchor_hook__ = true;
+	document.addEventListener('click', (event) => {
+		const anchor = event.target instanceof Element ? event.target.closest('a[href]') : null;
+		if (!anchor) return;
+		const href = anchor.getAttribute('href') || '';
+		if (!href || href.startsWith('#')) return;
+		if (/^(about|data|file|qrc):/i.test(href)) return;
+		if (!/^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i.test(href)) return;
+		event.preventDefault();
+		event.stopPropagation();
+		if (window.desktop?.api?.openExternal) {
+			window.desktop.api.openExternal(href);
+			return;
+		}
+		window.open(href, anchor.getAttribute('target') || '_blank');
+	}, true);
+})();
+"""
+
 class MARGINS(ctypes.Structure):
 	_fields_ = [
 		("cxLeftWidth", ctypes.c_int),
@@ -42,7 +133,7 @@ class ExternalAwarePage(QWebEnginePage):
 			and navigation_type == QWebEnginePage.NavigationTypeLinkClicked
 			and url.scheme() not in {"about", "data", "file", "qrc"}
 		):
-			QDesktopServices.openUrl(url)
+			_open_external_url(url)
 			return False
 		return super().acceptNavigationRequest(url, navigation_type, is_main_frame)
 
@@ -50,7 +141,7 @@ class ExternalAwarePage(QWebEnginePage):
 		page = QWebEnginePage(self.profile(), self)
 
 		def open_and_cleanup(url):
-			QDesktopServices.openUrl(url)
+			_open_external_url(url)
 			page.deleteLater()
 
 		page.urlChanged.connect(open_and_cleanup)
@@ -60,6 +151,16 @@ class ExternalAwarePage(QWebEnginePage):
 class FramelessWindow(QMainWindow):
 	closed = Signal()
 	page_loaded = Signal(bool)
+	WEB_MENU_BACK = 0x5001
+	WEB_MENU_FORWARD = 0x5002
+	WEB_MENU_RELOAD = 0x5003
+	WEB_MENU_UNDO = 0x5010
+	WEB_MENU_REDO = 0x5011
+	WEB_MENU_CUT = 0x5012
+	WEB_MENU_COPY = 0x5013
+	WEB_MENU_PASTE = 0x5014
+	WEB_MENU_SELECT_ALL = 0x5015
+	WINDOW_MENU_PIN = 0x5020
 
 	EDGE_MAP = {
 		"left": (Qt.LeftEdge, win32con.HTLEFT),
@@ -116,6 +217,12 @@ class FramelessWindow(QMainWindow):
 		settings.setAttribute(QWebEngineSettings.LocalContentCanAccessFileUrls, True)
 		settings.setAttribute(QWebEngineSettings.LocalContentCanAccessRemoteUrls, True)
 		settings.setAttribute(QWebEngineSettings.JavascriptCanAccessClipboard, True)
+		for attribute_name in ("WebGLEnabled", "Accelerated2dCanvasEnabled"):
+			attribute = getattr(QWebEngineSettings, attribute_name, None)
+			if attribute is None and hasattr(QWebEngineSettings, "WebAttribute"):
+				attribute = getattr(QWebEngineSettings.WebAttribute, attribute_name, None)
+			if attribute is not None:
+				settings.setAttribute(attribute, True)
 		if debug:
 			developer_extras = getattr(QWebEngineSettings, "DeveloperExtrasEnabled", None)
 			if developer_extras is None and hasattr(QWebEngineSettings, "WebAttribute"):
@@ -130,6 +237,8 @@ class FramelessWindow(QMainWindow):
 		self.view.setPage(self.page)
 		self.setCentralWidget(self.view)
 		self.view.setMouseTracking(True)
+		self.view.setContextMenuPolicy(Qt.CustomContextMenu)
+		self.view.customContextMenuRequested.connect(self._show_context_menu)
 		self.page.loadFinished.connect(self._handle_load_finished)
 		QApplication.instance().installEventFilter(self)
 		self._sync_view_geometry()
@@ -162,11 +271,27 @@ class FramelessWindow(QMainWindow):
 		if app is not None:
 			app.removeEventFilter(self)
 		self._set_resize_cursor(None)
+		self.hide()
 		if self._debug_tools_view is not None:
 			self._debug_tools_view.close()
-		self.closed.emit()
+		QTimer.singleShot(0, self.closed.emit)
 		super().closeEvent(event)
 
+	def _maximize_native(self):
+		self._ensure_native_frame()
+		win32gui.ShowWindow(self._hwnd(), win32con.SW_MAXIMIZE)
+
+	def _restore_native(self):
+		self._ensure_native_frame()
+		win32gui.ShowWindow(self._hwnd(), win32con.SW_RESTORE)
+
+	def _start_native_move(self):
+		handle = self.windowHandle()
+		if handle is not None and hasattr(handle, "startSystemMove") and handle.startSystemMove():
+			return
+		win32gui.ReleaseCapture()
+		win32api.SendMessage(self._hwnd(), win32con.WM_NCLBUTTONDOWN, win32con.HTCAPTION, 0)
+
 	def _hwnd(self) -> int:
 		return int(self.winId())
 
@@ -224,6 +349,7 @@ class FramelessWindow(QMainWindow):
 			| win32con.SWP_NOACTIVATE
 			| win32con.SWP_FRAMECHANGED,
 		)
+		_apply_native_menu_theme(self._resolved_theme() == "dark", hwnd)
 		self._native_frame_ready = True
 
 	def _refresh_resize_border(self):
@@ -240,6 +366,11 @@ class FramelessWindow(QMainWindow):
 		return QColor("#f3f3f3") if self._resolved_theme() == "light" else QColor("#202020")
 
 	def _apply_window_background(self):
+		dark = self._resolved_theme() == "dark"
+		if self._native_frame_ready:
+			_apply_native_menu_theme(dark, self._hwnd())
+		else:
+			_apply_native_menu_theme(dark)
 		color = self._background_color()
 		self.page.setBackgroundColor(color)
 		self.setStyleSheet(f"background-color: {color.name()};")
@@ -248,6 +379,7 @@ class FramelessWindow(QMainWindow):
 
 	def _handle_load_finished(self, _ok: bool):
 		self._apply_window_background()
+		self.page.runJavaScript(_ANCHOR_INTERCEPT_SCRIPT)
 		self.page_loaded.emit(_ok)
 
 	def _sync_view_geometry(self):
@@ -256,6 +388,76 @@ class FramelessWindow(QMainWindow):
 			self.view.setGeometry(rect)
 		self.view.updateGeometry()
 
+	def _show_context_menu(self, pos: QPoint):
+		request = self.view.lastContextMenuRequest()
+		if request is not None and request.isContentEditable():
+			edit_flags = request.editFlags()
+			self._exec_native_menu(
+				self.view.mapToGlobal(pos),
+				[
+					(self.WEB_MENU_UNDO, "Undo", bool(edit_flags & QWebEngineContextMenuRequest.EditFlag.CanUndo), False, lambda: self.page.triggerAction(QWebEnginePage.WebAction.Undo)),
+					(self.WEB_MENU_REDO, "Redo", bool(edit_flags & QWebEngineContextMenuRequest.EditFlag.CanRedo), False, lambda: self.page.triggerAction(QWebEnginePage.WebAction.Redo)),
+					None,
+					(self.WEB_MENU_CUT, "Cut", bool(edit_flags & QWebEngineContextMenuRequest.EditFlag.CanCut), False, lambda: self.page.triggerAction(QWebEnginePage.WebAction.Cut)),
+					(self.WEB_MENU_COPY, "Copy", bool(edit_flags & QWebEngineContextMenuRequest.EditFlag.CanCopy), False, lambda: self.page.triggerAction(QWebEnginePage.WebAction.Copy)),
+					(self.WEB_MENU_PASTE, "Paste", bool(edit_flags & QWebEngineContextMenuRequest.EditFlag.CanPaste), False, lambda: self.page.triggerAction(QWebEnginePage.WebAction.Paste)),
+					None,
+					(self.WEB_MENU_SELECT_ALL, "Select All", bool(edit_flags & QWebEngineContextMenuRequest.EditFlag.CanSelectAll), False, lambda: self.page.triggerAction(QWebEnginePage.WebAction.SelectAll)),
+				],
+			)
+			return
+
+		self._exec_native_menu(
+			self.view.mapToGlobal(pos),
+			[
+				(self.WEB_MENU_BACK, "Back", self.page.action(QWebEnginePage.WebAction.Back).isEnabled(), False, lambda: self.page.triggerAction(QWebEnginePage.WebAction.Back)),
+				(self.WEB_MENU_FORWARD, "Forward", self.page.action(QWebEnginePage.WebAction.Forward).isEnabled(), False, lambda: self.page.triggerAction(QWebEnginePage.WebAction.Forward)),
+				(self.WEB_MENU_RELOAD, "Reload", True, False, lambda: self.page.triggerAction(QWebEnginePage.WebAction.Reload)),
+			],
+		)
+
+	def _exec_native_menu(self, global_pos: QPoint, items):
+		menu = win32gui.CreatePopupMenu()
+		callbacks = {}
+		try:
+			win32gui.SetMenuInfo(menu, win32gui_struct.PackMENUINFO(dwStyle=win32con.MNS_CHECKORBMP))
+			for item in items:
+				if item is None:
+					win32gui.AppendMenu(menu, win32con.MF_SEPARATOR, 0, "")
+					continue
+
+				command_id, label, enabled, checked, callback, *extra = item
+				bitmap = extra[0] if extra else None
+				flags = win32con.MF_STRING
+				if not enabled:
+					flags |= win32con.MF_GRAYED
+				if checked:
+					flags |= win32con.MF_CHECKED
+				win32gui.AppendMenu(menu, flags, command_id, label)
+				if bitmap is not None:
+					packed, _extras = win32gui_struct.PackMENUITEMINFO(hbmpItem=bitmap)
+					win32gui.SetMenuItemInfo(menu, command_id, False, packed)
+				callbacks[command_id] = callback
+
+			hwnd = self._hwnd()
+			win32gui.SetForegroundWindow(hwnd)
+			command = win32gui.TrackPopupMenu(
+				menu,
+				win32con.TPM_RETURNCMD | win32con.TPM_NONOTIFY | win32con.TPM_RIGHTBUTTON,
+				global_pos.x(),
+				global_pos.y(),
+				0,
+				hwnd,
+				None,
+			)
+			win32gui.PostMessage(hwnd, win32con.WM_NULL, 0, 0)
+
+			callback = callbacks.get(command)
+			if command and callback is not None:
+				callback()
+		finally:
+			win32gui.DestroyMenu(menu)
+
 	def _open_devtools(self):
 		if self._debug_tools_view is None:
 			self._debug_tools_view = QWebEngineView()
@@ -284,8 +486,18 @@ class FramelessWindow(QMainWindow):
 			return watched.window() is self
 		return False
 
+	def _is_native_maximized(self) -> bool:
+		try:
+			return bool(win32gui.IsZoomed(self._hwnd()))
+		except Exception:
+			return self.isMaximized()
+
+	def _is_effectively_maximized(self) -> bool:
+		state = self.windowState()
+		return bool(state & Qt.WindowMaximized) or self._is_native_maximized()
+
 	def _edge_from_pos(self, pos: QPoint, size) -> str | None:
-		if self.isMaximized():
+		if self._is_effectively_maximized():
 			return None
 
 		border = self._resize_border
@@ -405,6 +617,7 @@ class FramelessWindow(QMainWindow):
 			return super().eventFilter(watched, event)
 
 		if self._resize_edge_name is None and not self._belongs_to_window(watched):
+			self._set_resize_cursor(None)
 			return super().eventFilter(watched, event)
 
 		global_pos = event.globalPosition().toPoint()
@@ -466,8 +679,7 @@ class FramelessWindow(QMainWindow):
 	@Slot()
 	def start_window_drag(self):
 		self._ensure_native_frame()
-		win32gui.ReleaseCapture()
-		win32api.SendMessage(self._hwnd(), win32con.WM_NCLBUTTONDOWN, win32con.HTCAPTION, 0)
+		self._start_native_move()
 
 	@Slot(str)
 	def start_window_resize(self, edge_name: str):
@@ -478,18 +690,40 @@ class FramelessWindow(QMainWindow):
 
 	@Slot()
 	def toggle_maximize(self):
-		if self.isMaximized():
-			self.showNormal()
+		if self._is_effectively_maximized():
+			self._restore_native()
 			return
-		self.showMaximized()
+		self._maximize_native()
+
+	@Slot()
+	def show_window_menu(self):
+		pinned = bool(self.api._main.values.get("system_pin"))
+		maximized = self._is_effectively_maximized()
+		self._exec_native_menu(
+			QCursor.pos(),
+			[
+				(self.WINDOW_MENU_PIN, "Pin", True, pinned, lambda: self.api._main.pin(not pinned)),
+				(win32con.SC_MINIMIZE, "Minimize", True, False, self.minimize, win32con.HBMMENU_POPUP_MINIMIZE),
+				(
+					win32con.SC_RESTORE if maximized else win32con.SC_MAXIMIZE,
+					"Restore" if maximized else "Maximize",
+					True,
+					False,
+					self.toggle_maximize,
+					win32con.HBMMENU_POPUP_RESTORE if maximized else win32con.HBMMENU_POPUP_MAXIMIZE,
+				),
+				None,
+				(win32con.SC_CLOSE, "Close", True, False, self.close_window, win32con.HBMMENU_POPUP_CLOSE),
+			],
+		)
 
 	@Slot(int, int)
 	def apply_window_size(self, width: int, height: int):
 		width = max(self.minimumWidth(), int(width))
 		height = max(self.minimumHeight(), int(height))
 
-		if self.isMaximized():
-			self.showNormal()
+		if self._is_effectively_maximized():
+			self._restore_native()
 
 		if self.width() == width and self.height() == height:
 			return
@@ -504,7 +738,7 @@ class FramelessWindow(QMainWindow):
 			return
 
 		self.setMinimumSize(width, height)
-		if not self.isMaximized():
+		if not self._is_effectively_maximized():
 			self.resize(max(self.width(), width), max(self.height(), height))
 
 class WebviewAPI(QObject):
@@ -518,6 +752,7 @@ class WebviewAPI(QObject):
 	start_drag_requested = Signal()
 	start_resize_requested = Signal(str)
 	toggle_maximize_requested = Signal()
+	show_window_menu_requested = Signal()
 
 	def __init__(self, main_window, title: str, icon: str | None):
 		super().__init__()
@@ -544,13 +779,20 @@ class WebviewAPI(QObject):
 			return
 
 		self._debug_mode = debug
+		_configure_webengine_gpu()
 		app = QApplication.instance()
 		if app is None:
+			if hasattr(Qt, "AA_UseDesktopOpenGL"):
+				QApplication.setAttribute(Qt.AA_UseDesktopOpenGL, True)
 			QApplication.setAttribute(Qt.AA_ShareOpenGLContexts, True)
 			app = QApplication(sys.argv)
 			self._owns_app = True
 
 		self._app = app
+		resolved_theme = self._main.values.get("system_theme") or "system"
+		if resolved_theme == "system":
+			resolved_theme = self._main.values.get("system_theme_resolved") or "dark"
+		_apply_native_menu_theme(resolved_theme == "dark")
 
 		icon_path = self._main.resolve_path(self._icon)
 		page_override = os.environ.get("PYWEBWINUI3_PAGE_OVERRIDE")
@@ -567,6 +809,7 @@ class WebviewAPI(QObject):
 		self.start_drag_requested.connect(self._window.start_window_drag)
 		self.start_resize_requested.connect(self._window.start_window_resize)
 		self.toggle_maximize_requested.connect(self._window.toggle_maximize)
+		self.show_window_menu_requested.connect(self._window.show_window_menu)
 
 		self._main.sync_window_size(self._window.width(), self._window.height(), sync=False)
 
@@ -743,9 +986,13 @@ class WebviewAPI(QObject):
 	def toggleMaximize(self):
 		self.toggle_maximize_requested.emit()
 
+	@Slot()
+	def showWindowMenu(self):
+		self.show_window_menu_requested.emit()
+
 	@Slot(str)
 	def openExternal(self, url: str):
-		QDesktopServices.openUrl(QUrl(url))
+		_open_external_url(url)
 
 	@Slot(str, result=str)
 	def resolveResource(self, value: str):

{pywebwinui3-1.0.0b43 → pywebwinui3-1.0.0b45}/pywebwinui3/util.py

@@ -40,6 +40,15 @@ class SyncDict(dict):
 		self.event = event or PathEvent()
 		self.sync = sync
 
+	@staticmethod
+	def _is_same_value(before:Any, after:Any):
+		if before is after:
+			return True
+		try:
+			return before == after
+		except Exception:
+			return False
+
 	def _sync(self, key, before, after, sync):
 		if sync and self.sync:
 			self.sync(key, after)
@@ -47,12 +56,14 @@ class SyncDict(dict):
 
 	def __setitem__(self, key:str, value:Any, sync=True):
 		before = self.get(key, None)
+		if self._is_same_value(before, value):
+			return value
 		super().__setitem__(key, value)
 		self._sync(key, before, value, sync)
+		return value
 
 	def set(self, key:str, value:Any, sync=True):
-		self.__setitem__(key, value, sync)
-		return value
+		return self.__setitem__(key, value, sync)
 	
 	def append(self, key:str, value:Any, sync=True):
 		before = list(self.get(key,[]))