PyWebWinUI3 1.2.1__tar.gz → 1.2.3__tar.gz

{pywebwinui3-1.2.1/PyWebWinUI3.egg-info → pywebwinui3-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyWebWinUI3
-Version: 1.2.1
+Version: 1.2.3
 Summary: Create modern WinUI3-style desktop UIs in Python using pywebview and a Svelte frontend.
 Home-page: https://github.com/Haruna5718/PyWebWinUI3
 Author: Haruna5718

{pywebwinui3-1.2.1 → pywebwinui3-1.2.3/PyWebWinUI3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyWebWinUI3
-Version: 1.2.1
+Version: 1.2.3
 Summary: Create modern WinUI3-style desktop UIs in Python using pywebview and a Svelte frontend.
 Home-page: https://github.com/Haruna5718/PyWebWinUI3
 Author: Haruna5718

{pywebwinui3-1.2.1 → pywebwinui3-1.2.3}/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.B-R7-woU.css
+pywebwinui3/web/_app/immutable/assets/2.YxEoeVwz.css
 pywebwinui3/web/_app/immutable/chunks/6pQH9Hkv.js
 pywebwinui3/web/_app/immutable/chunks/B-XLOWlt.js
-pywebwinui3/web/_app/immutable/chunks/CDNCM73h.js
 pywebwinui3/web/_app/immutable/chunks/CGGCsFu4.js
 pywebwinui3/web/_app/immutable/chunks/CW0wlPPy.js
 pywebwinui3/web/_app/immutable/chunks/CZPLFskb.js
 pywebwinui3/web/_app/immutable/chunks/CZuXpvpo.js
+pywebwinui3/web/_app/immutable/chunks/D94BNvJJ.js
 pywebwinui3/web/_app/immutable/chunks/DF1x2LYX.js
-pywebwinui3/web/_app/immutable/entry/app.DZs-LPnH.js
-pywebwinui3/web/_app/immutable/entry/start.BIkwzMz6.js
+pywebwinui3/web/_app/immutable/entry/app.B-Q6XOuJ.js
+pywebwinui3/web/_app/immutable/entry/start.C1-i6FUr.js
 pywebwinui3/web/_app/immutable/nodes/0.C49PHrK2.js
-pywebwinui3/web/_app/immutable/nodes/1.CrcwixmX.js
-pywebwinui3/web/_app/immutable/nodes/2.BX-aQgy_.js
+pywebwinui3/web/_app/immutable/nodes/1.a96iIGzo.js
+pywebwinui3/web/_app/immutable/nodes/2.Ofs4dh3G.js

{pywebwinui3-1.2.1 → pywebwinui3-1.2.3}/pywebwinui3/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["core", "event", "util", "type"]
 
-__version__ = '1.2.1'
+__version__ = '1.2.3'

{pywebwinui3-1.2.1 → pywebwinui3-1.2.3}/pywebwinui3/core.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import ctypes
 import importlib
 import json
 import logging
@@ -12,9 +13,10 @@ from http import HTTPStatus
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from urllib.parse import unquote, urlparse, urlunparse
+from ctypes import wintypes
 
 import webview
-from hPyT import title_bar
+from hPyT import title_bar, window_dwm
 
 from .event import Event, PathEvent
 from .type import Status
@@ -29,6 +31,93 @@ DEFAULT_WINDOW_MIN_WIDTH = 100
 DEFAULT_WINDOW_MIN_HEIGHT = 100
 
 
+class _Point(ctypes.Structure):
+	_fields_ = [
+		("x", ctypes.c_long),
+		("y", ctypes.c_long),
+	]
+
+_user32 = ctypes.WinDLL("user32", use_last_error=True)
+_kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+_uxtheme = ctypes.WinDLL("uxtheme", use_last_error=True)
+
+_kernel32.GetProcAddress.argtypes = [wintypes.HMODULE, wintypes.LPCSTR]
+_kernel32.GetProcAddress.restype = ctypes.c_void_p
+_user32.ReleaseCapture.argtypes = []
+_user32.ReleaseCapture.restype = ctypes.c_bool
+_user32.GetCursorPos.argtypes = [ctypes.POINTER(_Point)]
+_user32.GetCursorPos.restype = ctypes.c_bool
+_user32.GetSystemMenu.argtypes = [ctypes.c_void_p, ctypes.c_bool]
+_user32.GetSystemMenu.restype = ctypes.c_void_p
+_user32.IsZoomed.argtypes = [ctypes.c_void_p]
+_user32.IsZoomed.restype = ctypes.c_bool
+_user32.PostMessageW.argtypes = [ctypes.c_void_p, ctypes.c_uint, ctypes.c_size_t, ctypes.c_ssize_t]
+_user32.PostMessageW.restype = ctypes.c_bool
+_user32.SendMessageW.argtypes = [ctypes.c_void_p, ctypes.c_uint, ctypes.c_size_t, ctypes.c_ssize_t]
+_user32.SendMessageW.restype = ctypes.c_ssize_t
+_user32.SetForegroundWindow.argtypes = [ctypes.c_void_p]
+_user32.SetForegroundWindow.restype = ctypes.c_bool
+_user32.ShowWindow.argtypes = [ctypes.c_void_p, ctypes.c_int]
+_user32.ShowWindow.restype = ctypes.c_bool
+_user32.TrackPopupMenu.argtypes = [
+	ctypes.c_void_p,
+	ctypes.c_uint,
+	ctypes.c_int,
+	ctypes.c_int,
+	ctypes.c_int,
+	ctypes.c_void_p,
+	ctypes.c_void_p,
+]
+_user32.TrackPopupMenu.restype = ctypes.c_uint
+
+
+def _load_ordinal_function(module, ordinal: int, restype, argtypes):
+	address = _kernel32.GetProcAddress(
+		wintypes.HMODULE(module._handle),
+		ctypes.cast(ctypes.c_void_p(ordinal), wintypes.LPCSTR),
+	)
+	if not address:
+		return None
+	function = ctypes.WINFUNCTYPE(restype, *argtypes)(address)
+	function.argtypes = argtypes
+	function.restype = restype
+	return function
+
+
+_allow_dark_mode_for_window = (
+	_load_ordinal_function(_uxtheme, 145, ctypes.c_bool, [ctypes.c_void_p, ctypes.c_bool])
+	or _load_ordinal_function(_uxtheme, 133, ctypes.c_bool, [ctypes.c_void_p, ctypes.c_bool])
+)
+_set_preferred_app_mode = _load_ordinal_function(_uxtheme, 135, ctypes.c_int, [ctypes.c_int])
+_flush_menu_themes = _load_ordinal_function(_uxtheme, 136, None, [])
+
+
+def _apply_menu_theme_support(theme: str | None, hwnd: int | None = None):
+	if _set_preferred_app_mode is None:
+		return False
+	try:
+		normalized = str(theme or "system").casefold()
+		if normalized == "dark":
+			mode = 2  # ForceDark
+			allow_dark = True
+		elif normalized == "light":
+			mode = 3  # ForceLight
+			allow_dark = False
+		else:
+			mode = 1  # AllowDark
+			allow_dark = True
+
+		_set_preferred_app_mode(mode)
+		if hwnd is not None and _allow_dark_mode_for_window is not None:
+			_allow_dark_mode_for_window(hwnd, allow_dark)
+		if _flush_menu_themes is not None:
+			_flush_menu_themes()
+		return True
+	except Exception:
+		core_logger.debug("Failed to apply menu theme support", exc_info=True)
+		return False
+
+
 def _default_ui_origin_host(title: str) -> str:
 	slug = re.sub(r"[^a-z0-9]+", "-", str(title).casefold()).strip("-")
 	if not slug:
@@ -93,6 +182,9 @@ class _JsApi:
 		self.syncValue = main.syncValue
 		self.syncValues = main._sync_values
 		self.pin = main.pin
+		self.startWindowDrag = main.startWindowDrag
+		self.toggleWindowMaximize = main.toggleWindowMaximize
+		self.showWindowSystemMenu = main.showWindowSystemMenu
 		self.minimize = main.minimize
 		self.destroy = main.destroy
 		self.resolveResource = main.resolveResource
@@ -101,6 +193,7 @@ class _JsApi:
 class WindowEvents:
 	def __init__(self) -> None:
 		self.windowReady = Event()
+		self.closing = Event()
 		self.closed = Event()
 		self.accentColorChange = Event()
 		self.valueChange = PathEvent()
@@ -119,6 +212,8 @@ class MainWindow:
 		self._setup_fired = False
 		self._minimum_width = DEFAULT_WINDOW_MIN_WIDTH
 		self._minimum_height = DEFAULT_WINDOW_MIN_HEIGHT
+		self._defer_window_chrome = False
+		self._startup_cloaked = False
 		self._sync_lock = threading.Lock()
 		self._pending_sync: dict[str, object] = {}
 		self._ui_server: _UiHttpServer | None = None
@@ -141,14 +236,16 @@ class MainWindow:
 				"system_settings": None,
 				"system_nofication": [],
 				"system_pin": False,
+				"system_maximized": False,
 			}
 		)
 		self.values.sync = self.queue_sync_value
 		self._start_ui_server()
 		self._configure_webview2_origin_identity()
+		_apply_menu_theme_support(self.values.get("system_theme"))
 
 		self._window = webview.create_window(
-			self._current_title(),
+			self.values.get("system_title", self._title),
 			f"{self._ui_origin}/index.html",
 			js_api=self.api,
 			background_color="#202020",
@@ -158,14 +255,18 @@ class MainWindow:
 			min_size=(self._minimum_width, self._minimum_height),
 			on_top=bool(self.values.get("system_pin", False)),
 		)
-		self.show = self._window.show
-		self.restore = self._window.restore
-		self.hide = self._window.hide
-		self.destroy = self._window.destroy
-		self.minimize = self._window.minimize
+		self.show = self._show_window
+		self.restore = self._restore_window
+		self.hide = self._hide_window
+		self.destroy = self._destroy_window
+		self.minimize = self._minimize_window
 		self.api._init(self)
 		self._window.events.before_show += self._before_show
+		self._window.events.closing += self._on_closing
 		self._window.events.closed += self._on_closed
+		self._window.events.maximized += self._on_window_maximized_state
+		self._window.events.restored += self._on_window_restored_state
+		self._window.events.restored += self._on_window_restored
 
 		core_logger.debug("Window created")
 
@@ -192,6 +293,9 @@ class MainWindow:
 	def onSetup(self):
 		return self._event_decorator(self.events.windowReady)
 
+	def onClosing(self):
+		return self._event_decorator(self.events.closing)
+
 	def onExit(self):
 		return self._event_decorator(self.events.closed)
 
@@ -208,6 +312,8 @@ class MainWindow:
 		return state
 
 	def syncValue(self, key, value):
+		if key == "system_theme":
+			_apply_menu_theme_support(value, self._window_handle())
 		return self.values.set(key, value, False)
 
 	def addSettings(self, pageFile: str | Path | None = None, pageData: dict | None = None):
@@ -219,11 +325,11 @@ class MainWindow:
 	def addPage(self, pageFile: str | Path | None = None, pageData: dict | None = None):
 		if pageFile and not pageData:
 			pageData = loadPage(pageFile)
-		logger.debug("Page added: %s", pageData["attr"]["path"])
-		self.values["system_pages"] = {
-			**(self.values["system_pages"] or {}),
-			pageData["attr"]["path"]: pageData,
-		}
+		page_path = str(pageData["attr"]["path"])
+		logger.debug("Page added: %s", page_path)
+		if self.values["system_pages"] is None:
+			self.values["system_pages"] = {}
+		self.values.set(f"system_pages[{json.dumps(page_path, ensure_ascii=False)}]", pageData)
 
 	def resolve_path(self, value: str | Path | None) -> Path | None:
 		if value is None:
@@ -243,8 +349,14 @@ class MainWindow:
 
 		return root_candidate.resolve()
 
-	def _current_title(self):
-		return self.values.get("system_title", self._title)
+	def _window_handle(self) -> int | None:
+		try:
+			native = getattr(self._window, "native", None)
+			if native is None:
+				return None
+			return int(native.Handle.ToInt64())
+		except Exception:
+			return None
 
 	def _entry_path(self) -> Path:
 		entry = (Path(self.packagePath) / "index.html").resolve()
@@ -329,23 +441,149 @@ class MainWindow:
 	def _before_show(self):
 		try:
 			hwnd = self._window.native.Handle.ToInt64()
-			title_bar.hide(hwnd)
+			_apply_menu_theme_support(self.values.get("system_theme"), hwnd)
+			if self._defer_window_chrome:
+				window_dwm.toggle_cloak(hwnd, True)
+				self._startup_cloaked = True
+			else:
+				title_bar.hide(hwnd)
+				self._set_window_maximized_state(bool(_user32.IsZoomed(hwnd)), sync=False)
 		except Exception:
 			core_logger.debug("Failed to hide title bar", exc_info=True)
 
+	def _invoke_native(self, native, callback):
+		action_type = getattr(importlib.import_module("System"), "Action")
+		if native.InvokeRequired:
+			native.BeginInvoke(action_type(callback))
+		else:
+			callback()
+
+	def _invoke_native_sync(self, native, callback):
+		action_type = getattr(importlib.import_module("System"), "Action")
+		if native.InvokeRequired:
+			native.Invoke(action_type(callback))
+		else:
+			callback()
+
+	def _invoke_native_later(self, native, callback, delay: float):
+		timer = threading.Timer(delay, lambda: self._invoke_native(native, callback))
+		timer.daemon = True
+		timer.start()
+
+	def _on_window_maximized_state(self, *_):
+		self._set_window_maximized_state(True)
+
+	def _on_window_restored_state(self, *_):
+		self._set_window_maximized_state(False)
+
+	def _on_window_restored(self):
+		self._ensure_window_chrome()
+		self._refresh_client_layout()
+
+	def _ensure_window_chrome(self, delay: float = 0.08):
+		if not self._defer_window_chrome:
+			return
+
+		self._defer_window_chrome = False
+		native = getattr(self._window, "native", None)
+		if native is None:
+			return
+
+		def _apply():
+			try:
+				hwnd = int(native.Handle.ToInt64())
+				_apply_menu_theme_support(self.values.get("system_theme"), hwnd)
+				if self._startup_cloaked:
+					window_dwm.toggle_cloak(hwnd, False)
+					self._startup_cloaked = False
+				try:
+					title_bar.unhide(hwnd)
+				except Exception:
+					pass
+				title_bar.hide(hwnd)
+				self._set_window_maximized_state(bool(_user32.IsZoomed(hwnd)), sync=False)
+			except Exception:
+				core_logger.debug("Failed to ensure window chrome", exc_info=True)
+
+		self._invoke_native_later(native, _apply, delay)
+
+	def _refresh_client_layout(self, delay: float = 0.08):
+		native = getattr(self._window, "native", None)
+		if native is None:
+			return
+
+		forms = importlib.import_module("System.Windows.Forms")
+
+		def _apply():
+			try:
+				native.SuspendLayout()
+				webview_control = getattr(native, "webview", None)
+				if webview_control is not None:
+					webview_control.Dock = forms.DockStyle.Fill
+					webview_control.Bounds = native.ClientRectangle
+					webview_control.BringToFront()
+					webview_control.Invalidate()
+					webview_control.Update()
+				native.PerformLayout()
+				native.Invalidate(True)
+				native.Refresh()
+			except Exception:
+				core_logger.debug("Failed to refresh client layout", exc_info=True)
+			finally:
+				try:
+					native.ResumeLayout(True)
+				except Exception:
+					pass
+
+		self._invoke_native_later(native, _apply, delay)
+
+	def _show_window(self):
+		native = getattr(self._window, "native", None)
+		if native is None:
+			self._window.show()
+		else:
+			self._invoke_native_sync(native, self._window.show)
+		self._ensure_window_chrome()
+		self._refresh_client_layout()
+
+	def _restore_window(self):
+		native = getattr(self._window, "native", None)
+		if native is None:
+			self._window.restore()
+		else:
+			self._invoke_native_sync(native, self._window.restore)
+		self._ensure_window_chrome()
+		self._refresh_client_layout()
+
+	def _hide_window(self):
+		native = getattr(self._window, "native", None)
+		if native is None:
+			self._window.hide()
+			return
+		self._invoke_native_sync(native, self._window.hide)
+
+	def _destroy_window(self):
+		native = getattr(self._window, "native", None)
+		if native is None:
+			self._window.destroy()
+			return
+		self._invoke_native_sync(native, self._window.destroy)
+
+	def _minimize_window(self):
+		native = getattr(self._window, "native", None)
+		if native is None:
+			self._window.minimize()
+			return
+		self._invoke_native_sync(native, self._window.minimize)
+
+	def _on_closing(self, *_):
+		return not self.events.closing.set()
+
 	def _on_closed(self):
 		self.accent.stop()
 		self._stop_ui_server()
 		self.events.closed.set()
 
-	def _dispatch_or_defer_sync(self, key: str, value):
-		with self._sync_lock:
-			if not self._frontend_ready:
-				self._pending_sync[key] = value
-				return
-
-		self._dispatch_sync_value(key, value)
-
 	def _dispatch_sync_value(self, key: str, value):
 		if key == "system_title":
 			try:
@@ -362,7 +600,22 @@ class MainWindow:
 			core_logger.debug("Failed to sync value %s", key, exc_info=True)
 
 	def queue_sync_value(self, key: str, value):
-		self._dispatch_or_defer_sync(key, value)
+		with self._sync_lock:
+			if not self._frontend_ready:
+				self._pending_sync[key] = value
+				return
+
+		self._dispatch_sync_value(key, value)
+
+	def _set_window_maximized_state(self, value: bool, *, sync: bool = True):
+		value = bool(value)
+		if self.values.get("system_maximized") == value:
+			return
+		self.values.set("system_maximized", value, False)
+		if sync:
+			timer = threading.Timer(0.01, lambda: self.queue_sync_value("system_maximized", value))
+			timer.daemon = True
+			timer.start()
 
 	def _init_payload(self):
 		return dict(self.values)
@@ -399,18 +652,79 @@ class MainWindow:
 				self._window.on_top = state
 				return
 
-			action_type = getattr(importlib.import_module("System"), "Action")
-
 			def _apply():
 				self._window.on_top = state
 
-			if native.InvokeRequired:
-				native.BeginInvoke(action_type(_apply))
-			else:
-				_apply()
+			self._invoke_native(native, _apply)
 		except Exception:
 			core_logger.debug("Failed to set window on top", exc_info=True)
 
+	def startWindowDrag(self):
+		try:
+			native = getattr(self._window, "native", None)
+			if native is None:
+				return
+
+			def _apply():
+				hwnd = int(native.Handle.ToInt64())
+				_user32.ReleaseCapture()
+				_user32.SendMessageW(hwnd, 0x00A1, 2, 0)  # WM_NCLBUTTONDOWN, HTCAPTION
+
+			self._invoke_native(native, _apply)
+		except Exception:
+			core_logger.debug("Failed to start system window drag", exc_info=True)
+
+	def toggleWindowMaximize(self):
+		try:
+			native = getattr(self._window, "native", None)
+			if native is None:
+				return
+
+			def _apply():
+				hwnd = int(native.Handle.ToInt64())
+				is_zoomed = bool(_user32.IsZoomed(hwnd))
+				command = 9 if is_zoomed else 3  # SW_RESTORE / SW_MAXIMIZE
+				_user32.ShowWindow(hwnd, command)
+
+			self._invoke_native(native, _apply)
+		except Exception:
+			core_logger.debug("Failed to toggle window maximize", exc_info=True)
+
+	def showWindowSystemMenu(self):
+		try:
+			native = getattr(self._window, "native", None)
+			if native is None:
+				return
+
+			def _apply():
+				hwnd = int(native.Handle.ToInt64())
+				menu = _user32.GetSystemMenu(hwnd, False)
+				if not menu:
+					return
+				_apply_menu_theme_support(self.values.get("system_theme"), hwnd)
+
+				cursor = _Point()
+				if not _user32.GetCursorPos(ctypes.byref(cursor)):
+					return
+
+				_user32.SetForegroundWindow(hwnd)
+				command = _user32.TrackPopupMenu(
+					menu,
+					0x0100 | 0x0002,  # TPM_RETURNCMD | TPM_RIGHTBUTTON
+					cursor.x,
+					cursor.y,
+					0,
+					hwnd,
+					None,
+				)
+				if command:
+					_user32.PostMessageW(hwnd, 0x0112, command, 0)  # WM_SYSCOMMAND
+				_user32.PostMessageW(hwnd, 0x0000, 0, 0)  # WM_NULL
+
+			self._invoke_native(native, _apply)
+		except Exception:
+			core_logger.debug("Failed to show window system menu", exc_info=True)
+
 	def get_window_size(self) -> tuple[int, int]:
 		width = int(getattr(self._window, "initial_width", DEFAULT_WINDOW_WIDTH))
 		height = int(getattr(self._window, "initial_height", DEFAULT_WINDOW_HEIGHT))
@@ -463,6 +777,7 @@ class MainWindow:
 		debug: bool = False,
 		*,
 		hidden: bool = False,
+		minimized: bool = False,
 		on_top: bool | None = None,
 		width: int | None = None,
 		height: int | None = None,
@@ -473,7 +788,9 @@ class MainWindow:
 		self._minimum_width = max(1, int(min_width))
 		self._minimum_height = max(1, int(min_height))
 		self._window.min_size = (self._minimum_width, self._minimum_height)
+		self._defer_window_chrome = bool(hidden or minimized)
 		self._window.hidden = bool(hidden)
+		self._window.minimized = bool(minimized and not hidden)
 
 		if width is not None and height is not None:
 			width = max(self._minimum_width, int(width))

{pywebwinui3-1.2.1 → pywebwinui3-1.2.3}/pywebwinui3/event.py

@@ -12,11 +12,13 @@ class Event:
 		self.items: list[Callable[..., Any]] = []
 
 	def set(self, *args: Any):
+		result = False
 		for func in tuple(self.items):
 			try:
-				func(*args)
+				result = bool(func(*args)) or result
 			except Exception:
 				logger.exception("Event callback failed")
+		return result
 
 	def _add(self, item: Callable[..., Any]):
 		self.items.append(item)