PyWebWinUI3 1.2.2__tar.gz → 1.2.4__tar.gz

{pywebwinui3-1.2.2/PyWebWinUI3.egg-info → pywebwinui3-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyWebWinUI3
-Version: 1.2.2
+Version: 1.2.4
 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.2 → pywebwinui3-1.2.4/PyWebWinUI3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyWebWinUI3
-Version: 1.2.2
+Version: 1.2.4
 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.2 → pywebwinui3-1.2.4}/pywebwinui3/__init__.py

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

{pywebwinui3-1.2.2 → pywebwinui3-1.2.4}/pywebwinui3/core.py

@@ -16,7 +16,7 @@ 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
@@ -193,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()
@@ -211,8 +212,12 @@ 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._sync_event = threading.Event()
+		self._sync_thread: threading.Thread | None = None
 		self._ui_server: _UiHttpServer | None = None
 		self._ui_server_thread: threading.Thread | None = None
 		self._ui_origin = ""
@@ -242,7 +247,7 @@ class MainWindow:
 		_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",
@@ -252,16 +257,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 += lambda *_: self._set_window_maximized_state(True)
-		self._window.events.restored += lambda *_: self._set_window_maximized_state(False)
+		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")
 
@@ -288,6 +295,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)
 
@@ -317,11 +327,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:
@@ -341,9 +351,6 @@ 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)
@@ -437,24 +444,151 @@ class MainWindow:
 		try:
 			hwnd = self._window.native.Handle.ToInt64()
 			_apply_menu_theme_support(self.values.get("system_theme"), hwnd)
-			title_bar.hide(hwnd)
-			self._set_window_maximized_state(bool(_user32.IsZoomed(hwnd)), sync=False)
+			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()
+		with self._sync_lock:
+			self._pending_sync.clear()
+		self._sync_event.set()
 		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:
@@ -464,14 +598,39 @@ class MainWindow:
 
 		script = f"window.syncValue({json.dumps(key, ensure_ascii=False)}, {json.dumps(value, ensure_ascii=False)}, false)"
 		try:
-			self._window.evaluate_js(script)
+			self._window.run_js(script)
 		except Exception:
-			with self._sync_lock:
-				self._pending_sync[key] = value
 			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:
+			self._pending_sync[key] = value
+			frontend_ready = self._frontend_ready
+
+		if not frontend_ready:
+			return
+		self._ensure_sync_worker()
+		self._sync_event.set()
+
+	def _ensure_sync_worker(self):
+		if self._sync_thread and self._sync_thread.is_alive():
+			return
+		self._sync_thread = threading.Thread(target=self._sync_loop, daemon=True, name="PyWebWinUI3-Sync")
+		self._sync_thread.start()
+
+	def _sync_loop(self):
+		while True:
+			self._sync_event.wait()
+			while True:
+				with self._sync_lock:
+					if not self._pending_sync:
+						self._sync_event.clear()
+						break
+					pending = tuple(self._pending_sync.items())
+					self._pending_sync.clear()
+
+				for key, value in pending:
+					self._dispatch_sync_value(key, value)
 
 	def _set_window_maximized_state(self, value: bool, *, sync: bool = True):
 		value = bool(value)
@@ -499,12 +658,8 @@ class MainWindow:
 
 		self._frontend_ready = True
 
-		with self._sync_lock:
-			pending_sync = tuple(self._pending_sync.items())
-			self._pending_sync.clear()
-
-		for key, value in pending_sync:
-			self._dispatch_sync_value(key, value)
+		self._ensure_sync_worker()
+		self._sync_event.set()
 
 		if not self._setup_fired:
 			self._setup_fired = True
@@ -518,15 +673,10 @@ 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)
 
@@ -536,17 +686,12 @@ class MainWindow:
 			if native is None:
 				return
 
-			action_type = getattr(importlib.import_module("System"), "Action")
-
 			def _apply():
 				hwnd = int(native.Handle.ToInt64())
 				_user32.ReleaseCapture()
 				_user32.SendMessageW(hwnd, 0x00A1, 2, 0)  # WM_NCLBUTTONDOWN, HTCAPTION
 
-			if native.InvokeRequired:
-				native.BeginInvoke(action_type(_apply))
-			else:
-				_apply()
+			self._invoke_native(native, _apply)
 		except Exception:
 			core_logger.debug("Failed to start system window drag", exc_info=True)
 
@@ -556,18 +701,13 @@ class MainWindow:
 			if native is None:
 				return
 
-			action_type = getattr(importlib.import_module("System"), "Action")
-
 			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)
 
-			if native.InvokeRequired:
-				native.BeginInvoke(action_type(_apply))
-			else:
-				_apply()
+			self._invoke_native(native, _apply)
 		except Exception:
 			core_logger.debug("Failed to toggle window maximize", exc_info=True)
 
@@ -577,8 +717,6 @@ class MainWindow:
 			if native is None:
 				return
 
-			action_type = getattr(importlib.import_module("System"), "Action")
-
 			def _apply():
 				hwnd = int(native.Handle.ToInt64())
 				menu = _user32.GetSystemMenu(hwnd, False)
@@ -604,10 +742,7 @@ class MainWindow:
 					_user32.PostMessageW(hwnd, 0x0112, command, 0)  # WM_SYSCOMMAND
 				_user32.PostMessageW(hwnd, 0x0000, 0, 0)  # WM_NULL
 
-			if native.InvokeRequired:
-				native.BeginInvoke(action_type(_apply))
-			else:
-				_apply()
+			self._invoke_native(native, _apply)
 		except Exception:
 			core_logger.debug("Failed to show window system menu", exc_info=True)
 
@@ -663,6 +798,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,
@@ -673,7 +809,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.2 → pywebwinui3-1.2.4}/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)