PyWebWinUI3 1.0.3__py3-none-any.whl → 1.2.0__py3-none-any.whl

pywebwinui3/__init__.py

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

pywebwinui3/core.py

@@ -1,24 +1,101 @@
 from __future__ import annotations
 
-import inspect
+import importlib
+import json
 import logging
+import mimetypes
+import os
+import re
+import sys
+import threading
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
-from typing import TYPE_CHECKING
+from urllib.parse import unquote, urlparse, urlunparse
 
-from .event import Event
+import webview
+from hPyT import title_bar
+
+from .event import Event, PathEvent
 from .type import Status
 from .util import AccentColorWatcher, SyncDict, loadPage
 
 logger = logging.getLogger("pywebwinui3")
-
-from .qt import WebviewAPI
+core_logger = logging.getLogger("pywebwinui3.core")
 
 DEFAULT_WINDOW_WIDTH = 900
 DEFAULT_WINDOW_HEIGHT = 600
 DEFAULT_WINDOW_MIN_WIDTH = 100
 DEFAULT_WINDOW_MIN_HEIGHT = 100
-ABSOLUTE_WINDOW_MIN_WIDTH = 1
-ABSOLUTE_WINDOW_MIN_HEIGHT = 1
+
+
+def _default_ui_origin_host(title: str) -> str:
+	slug = re.sub(r"[^a-z0-9]+", "-", str(title).casefold()).strip("-")
+	if not slug:
+		slug = "app"
+	slug = re.sub(r"-{2,}", "-", slug)[:48].strip("-")
+	if not slug:
+		slug = "app"
+	return f"{slug}.local"
+
+
+class _UiHttpServer(ThreadingHTTPServer):
+	daemon_threads = True
+	allow_reuse_address = True
+
+	def __init__(self, server_address, request_handler_class, main: "MainWindow"):
+		super().__init__(server_address, request_handler_class)
+		self.main = main
+
+
+class _UiRequestHandler(BaseHTTPRequestHandler):
+	server: _UiHttpServer
+
+	def do_GET(self):
+		try:
+			path = self.server.main._resolve_server_path(urlparse(self.path).path)
+			if path is None or not path.is_file():
+				self._send_error("Not found.", HTTPStatus.NOT_FOUND)
+				return
+
+			body = path.read_bytes()
+			content_type = mimetypes.guess_type(path.name)[0] or "application/octet-stream"
+			self.send_response(HTTPStatus.OK)
+			self._send_common_headers(content_type)
+			self.send_header("Content-Length", str(len(body)))
+			self.end_headers()
+			self.wfile.write(body)
+		except Exception:
+			core_logger.debug("Failed to serve UI asset", exc_info=True)
+			self._send_error("Failed to serve UI asset.", HTTPStatus.INTERNAL_SERVER_ERROR)
+
+	def log_message(self, format, *args):
+		return
+
+	def _send_error(self, message: str, status: HTTPStatus):
+		body = message.encode("utf-8")
+		self.send_response(status)
+		self._send_common_headers("text/plain; charset=utf-8")
+		self.send_header("Content-Length", str(len(body)))
+		self.end_headers()
+		self.wfile.write(body)
+
+	def _send_common_headers(self, content_type: str):
+		self.send_header("Content-Type", content_type)
+		self.send_header("Cache-Control", "no-store")
+		self.send_header("Permissions-Policy", "display-capture=*")
+
+
+class _JsApi:
+	def _init(self, main:MainWindow):
+		self.init = main._init_payload
+		self.frontendReady = main._frontend_ready_callback
+		self.syncValue = main.syncValue
+		self.syncValues = main._sync_values
+		self.pin = main.pin
+		self.minimize = main.minimize
+		self.destroy = main.destroy
+		self.resolveResource = main.resolveResource
 
 
 class WindowEvents:
@@ -26,78 +103,97 @@ class WindowEvents:
 		self.windowReady = Event()
 		self.closed = Event()
 		self.accentColorChange = Event()
-		self.themeChange = Event()
-		self.valueChange = Event()
+		self.valueChange = PathEvent()
 
 
 class MainWindow:
 	def __init__(self, title: str, icon: str | None = None):
-		self.rootPath = Path(inspect.currentframe().f_back.f_code.co_filename).parent.resolve()
+		self.rootPath = Path(sys._getframe(1).f_code.co_filename).parent.resolve()
 		self.packagePath = Path(__file__).parent.resolve() / "web"
-		self._title = title
-		self._icon = icon
 
 		self.accent = AccentColorWatcher()
 		self.events = WindowEvents()
-		self.api = WebviewAPI(self, self._title, self._icon)
+		self.api = _JsApi()
+		self._title = title
+		self._frontend_ready = False
+		self._setup_fired = False
+		self._minimum_width = DEFAULT_WINDOW_MIN_WIDTH
+		self._minimum_height = DEFAULT_WINDOW_MIN_HEIGHT
+		self._sync_lock = threading.Lock()
+		self._pending_sync: dict[str, object] = {}
+		self._ui_server: _UiHttpServer | None = None
+		self._ui_server_thread: threading.Thread | None = None
+		self._ui_origin = ""
+		self._ui_bind_host = "127.0.0.1"
+		self._ui_origin_host = getattr(self, "ui_origin_host", _default_ui_origin_host(title))
+		self._resource_roots: list[tuple[str, Path]] = [
+			("root", self.rootPath),
+			("package", self.packagePath),
+		]
 
 		self.values = SyncDict(
 			{
 				"system_title": title,
 				"system_icon": icon,
 				"system_theme": "system",
-				"system_theme_resolved": self.accent.theme,
 				"system_accent": self.accent.palette,
 				"system_pages": None,
 				"system_settings": None,
 				"system_nofication": [],
 				"system_pin": False,
-				"system_window_width": 900,
-				"system_window_height": 600,
 			}
 		)
-		self.values.sync = self.api.queue_sync_value
+		self.values.sync = self.queue_sync_value
+		self._start_ui_server()
+		self._configure_webview2_origin_identity()
+
+		self._window = webview.create_window(
+			self._current_title(),
+			f"{self._ui_origin}/index.html",
+			js_api=self.api,
+			background_color="#202020",
+			text_select=True,
+			width=DEFAULT_WINDOW_WIDTH,
+			height=DEFAULT_WINDOW_HEIGHT,
+			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.api._init(self)
+		self._window.events.before_show += self._before_show
+		self._window.events.closed += self._on_closed
+
+		core_logger.debug("Window created")
 
 		self.events.accentColorChange = self.accent.event
-		self.events.themeChange = self.accent.theme_event
 		self.events.valueChange = self.values.event
 		self.events.accentColorChange += lambda palette: self.values.set("system_accent", palette)
-		self.events.themeChange += lambda theme: self.values.set("system_theme_resolved", theme)
-
-	def onValueChange(self, key):
-		def decorator(func):
-			self.events.valueChange += (key, func)
-			return func
 
-		return decorator
-
-	def onAccentColorChange(self):
+	def _event_decorator(self, event: Event | PathEvent, value=None):
 		def decorator(func):
-			self.events.accentColorChange += func
+			if value is None:
+				event.__iadd__(func)
+			else:
+				event.__iadd__((value, func))
 			return func
 
 		return decorator
 
-	def onThemeChange(self):
-		def decorator(func):
-			self.events.themeChange += func
-			return func
+	def onValueChange(self, key):
+		return self._event_decorator(self.events.valueChange, key)
 
-		return decorator
+	def onAccentColorChange(self):
+		return self._event_decorator(self.events.accentColorChange)
 
 	def onSetup(self):
-		def decorator(func):
-			self.events.windowReady += func
-			return func
-
-		return decorator
+		return self._event_decorator(self.events.windowReady)
 
 	def onExit(self):
-		def decorator(func):
-			self.events.closed += func
-			return func
-
-		return decorator
+		return self._event_decorator(self.events.closed)
 
 	def notice(self, level: Status, title: str, description: str, item: dict | None = None):
 		self.values["system_nofication"] = [
@@ -105,14 +201,10 @@ class MainWindow:
 			[level, title, description, item],
 		]
 
-	def init(self) -> dict:
-		return dict(self.values)
-
 	def pin(self, state: bool):
 		state = bool(state)
-		self.values.set("system_pin", state, self.api is not None)
-		if self.api is not None:
-			self.api.set_on_top(state)
+		self.values.set("system_pin", state)
+		self.set_on_top(state)
 		return state
 
 	def syncValue(self, key, value):
@@ -151,26 +243,249 @@ class MainWindow:
 
 		return root_candidate.resolve()
 
-	def resolve_resource_url(self, value):
+	def _current_title(self):
+		return self.values.get("system_title", self._title)
+
+	def _entry_path(self) -> Path:
+		entry = (Path(self.packagePath) / "index.html").resolve()
+		if not entry.is_file():
+			raise FileNotFoundError(f"Frontend entry not found: {entry}")
+		return entry
+
+	def _start_ui_server(self):
+		self._ui_server = _UiHttpServer((self._ui_bind_host, 0), _UiRequestHandler, self)
+		self._ui_origin = f"http://{self._ui_origin_host}:{self._ui_server.server_port}"
+		self._ui_server_thread = threading.Thread(target=self._ui_server.serve_forever, daemon=True)
+		self._ui_server_thread.start()
+
+	def _configure_webview2_origin_identity(self):
+		if self._ui_origin_host == self._ui_bind_host:
+			return
+
+		parsed = urlparse(self._ui_origin)
+		if not parsed.scheme or parsed.port is None:
+			return
+
+		required_args = [
+			f'--host-resolver-rules="MAP {self._ui_origin_host} {self._ui_bind_host}"',
+			f"--unsafely-treat-insecure-origin-as-secure={parsed.scheme}://{self._ui_origin_host}:{parsed.port}",
+		]
+		existing = os.environ.get("WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS", "").strip()
+		missing = [arg for arg in required_args if arg not in existing]
+		if missing:
+			os.environ["WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS"] = " ".join(
+				[value for value in [existing, *missing] if value]
+			).strip()
+
+	def _stop_ui_server(self):
+		if self._ui_server is None:
+			return
+		try:
+			self._ui_server.shutdown()
+			self._ui_server.server_close()
+		except Exception:
+			core_logger.debug("Failed to stop UI server", exc_info=True)
+		finally:
+			self._ui_server = None
+			self._ui_server_thread = None
+
+	def _resolve_server_path(self, raw_path: str) -> Path | None:
+		path = unquote(raw_path or "/")
+		if path in {"", "/"}:
+			return self._entry_path()
+
+		for name, base_path in self._resource_roots:
+			if name == "package":
+				continue
+
+			prefix = f"/__{name}__/"
+			if not path.startswith(prefix):
+				continue
+
+			relative = path[len(prefix) :]
+			candidate = (base_path / relative).resolve()
+			try:
+				candidate.relative_to(base_path)
+			except ValueError:
+				return None
+			return candidate
+
+		candidate = (self.packagePath / path.lstrip("/")).resolve()
+		try:
+			candidate.relative_to(self.packagePath)
+		except ValueError:
+			return None
+		return candidate
+
+	def _resource_url(self, path: Path) -> str:
+		path = path.resolve()
+		for name, base_path in self._resource_roots:
+			try:
+				relative = path.relative_to(base_path)
+			except ValueError:
+				continue
+
+			if name == "package":
+				return f"{self._ui_origin}/{relative.as_posix()}"
+			return f"{self._ui_origin}/__{name}__/{relative.as_posix()}"
+
+		raise ValueError(f"Path is outside of registered resource roots: {path}")
+
+	def _before_show(self):
+		try:
+			hwnd = self._window.native.Handle.ToInt64()
+			title_bar.hide(hwnd)
+		except Exception:
+			core_logger.debug("Failed to hide title bar", exc_info=True)
+
+	def _on_closed(self):
+		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:
+				self._window.title = str(value or self._title)
+			except Exception:
+				core_logger.debug("Failed to update window title", exc_info=True)
+
+		script = f"window.syncValue({json.dumps(key, ensure_ascii=False)}, {json.dumps(value, ensure_ascii=False)}, false)"
+		try:
+			self._window.evaluate_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)
+
+	def _init_payload(self):
+		return dict(self.values)
+
+	def _sync_values(self, values: dict[str, object]):
+		if not isinstance(values, dict):
+			return
+
+		for key, value in values.items():
+			self.syncValue(key, value)
+
+	def _frontend_ready_callback(self):
+		if self._frontend_ready:
+			return
+
+		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)
+
+		if not self._setup_fired:
+			self._setup_fired = True
+			self.events.windowReady.set()
+
+	def set_on_top(self, state: bool):
+		state = bool(state)
+		try:
+			native = getattr(self._window, "native", None)
+			if native is None:
+				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()
+		except Exception:
+			core_logger.debug("Failed to set window on top", 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))
+
+		try:
+			if self._window.events.shown.is_set():
+				width = int(self._window.width)
+				height = int(self._window.height)
+		except Exception:
+			core_logger.debug("Failed to read window size", exc_info=True)
+
+		return width, height
+
+	def resolveResource(self, value: str):
 		if not isinstance(value, (str, Path)):
-			return value
+			return ""
 
 		raw_value = str(value).strip()
 		if not raw_value:
-			return value
+			return ""
 
 		lowered = raw_value.lower()
-		if lowered.startswith(("http://", "https://", "file://", "data:", "qrc://", "qrc:", "about:")):
+		if lowered.startswith(("http://", "https://", "file://", "data:", "about:")):
 			return raw_value
 
-		resolved = self.resolve_path(raw_value)
-		if resolved is None or not resolved.exists():
+		parsed = urlparse(raw_value)
+		path_value = parsed.path or raw_value
+		resolved = self.resolve_path(path_value)
+		if resolved is None or not resolved.exists() or not resolved.is_file():
 			return raw_value
 
-		return resolved.as_uri()
-
-	def start(self, debug: bool = False, min_width=900, min_height=600):
-		# if self.api is not None and getattr(self.api, "_window", None) is not None:
-		self.api.set_window_minimum_size(min_width, min_height)
+		resource_url = self._resource_url(resolved)
+		if not parsed.scheme and (parsed.query or parsed.fragment):
+			resource_parts = urlparse(resource_url)
+			resource_url = urlunparse(
+				(
+					resource_parts.scheme,
+					resource_parts.netloc,
+					resource_parts.path,
+					resource_parts.params,
+					parsed.query,
+					parsed.fragment,
+				)
+			)
+
+		return resource_url
+
+	def start(
+		self,
+		debug: bool = False,
+		*,
+		hidden: bool = False,
+		on_top: bool | None = None,
+		width: int | None = None,
+		height: int | None = None,
+		min_width=900,
+		min_height=600,
+	):
 		self.accent.start()
-		self.api.start(debug=debug)
+		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._window.hidden = bool(hidden)
+
+		if width is not None and height is not None:
+			width = max(self._minimum_width, int(width))
+			height = max(self._minimum_height, int(height))
+			self._window.initial_width = width
+			self._window.initial_height = height
+
+		if on_top is not None:
+			self._window.on_top = bool(on_top)
+
+		webview.start(debug=debug, gui="edgechromium")

pywebwinui3/event.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import re
 import fnmatch
 import logging
-import traceback
 from typing import Any, Callable
 
 logger = logging.getLogger("pywebwinui3.eventmanager")
@@ -13,31 +12,31 @@ class Event:
 		self.items: list[Callable[..., Any]] = []
 
 	def set(self, *args: Any):
-		listeners = tuple(self.items)
-		if not listeners:
-			return
-
-		for func in listeners:
+		for func in tuple(self.items):
 			try:
 				func(*args)
 			except Exception:
-				logger.error(traceback.format_exc())
+				logger.exception("Event callback failed")
 
-	def __add__(self, item: Callable[..., Any]):
+	def _add(self, item: Callable[..., Any]):
 		self.items.append(item)
 		return self
 
-	def __sub__(self, item: Callable[..., Any]):
+	def _remove(self, item: Callable[..., Any]):
 		self.items.remove(item)
 		return self
 
+	def __add__(self, item: Callable[..., Any]):
+		return self._add(item)
+
+	def __sub__(self, item: Callable[..., Any]):
+		return self._remove(item)
+
 	def __iadd__(self, item: Callable[..., Any]):
-		self.items.append(item)
-		return self
+		return self._add(item)
 
 	def __isub__(self, item: Callable[..., Any]):
-		self.items.remove(item)
-		return self
+		return self._remove(item)
 
 	def __len__(self) -> int:
 		return len(self.items)
@@ -78,7 +77,7 @@ class PathEvent:
 				if self._compile_pattern(key).match(target):
 					matched_events.append(event)
 			except Exception:
-				logger.error(traceback.format_exc())
+				logger.exception("Pattern match failed")
 
 		result = tuple(matched_events)
 		self._pattern_cache[target] = result
@@ -93,55 +92,42 @@ class PathEvent:
 			try:
 				exact_event.set(target, *args)
 			except Exception:
-				logger.error(traceback.format_exc())
+				logger.exception("Exact path callback failed")
 
 		for event in self._get_pattern_events(target):
 			try:
 				event.set(target, *args)
 			except Exception:
-				logger.error(traceback.format_exc())
+				logger.exception("Pattern path callback failed")
 
-	def __add__(self, item: list):
+	def _modify(self, item: list, remove: bool):
 		target, callback = item[0], item[1]
 		bucket = self._bucket(target)
-		bucket.setdefault(target, Event()).__iadd__(callback)
+		event = bucket.setdefault(target, Event())
 
-		if self._is_pattern(target):
-			self._compiled_patterns.setdefault(target, self._compile_pattern(target))
-			self._clear_pattern_cache()
-
-		return self
-
-	def __sub__(self, item: list):
-		target, callback = item[0], item[1]
-		bucket = self._bucket(target)
-		bucket.setdefault(target, Event()).__isub__(callback)
+		if remove:
+			event -= callback
+		else:
+			event += callback
 
 		if self._is_pattern(target):
+			if not remove:
+				self._compiled_patterns.setdefault(target, self._compile_pattern(target))
 			self._clear_pattern_cache()
 
 		return self
 
-	def __iadd__(self, item: list):
-		target, callback = item[0], item[1]
-		bucket = self._bucket(target)
-		bucket.setdefault(target, Event()).__iadd__(callback)
+	def __add__(self, item: list):
+		return self._modify(item, False)
 
-		if self._is_pattern(target):
-			self._compiled_patterns.setdefault(target, self._compile_pattern(target))
-			self._clear_pattern_cache()
+	def __sub__(self, item: list):
+		return self._modify(item, True)
 
-		return self
+	def __iadd__(self, item: list):
+		return self._modify(item, False)
 
 	def __isub__(self, item: list):
-		target, callback = item[0], item[1]
-		bucket = self._bucket(target)
-		bucket.setdefault(target, Event()).__isub__(callback)
-
-		if self._is_pattern(target):
-			self._clear_pattern_cache()
-
-		return self
+		return self._modify(item, True)
 
 	def __len__(self) -> int:
-		return len(self.exact_items) + len(self.pattern_items)
+		return len(self.exact_items) + len(self.pattern_items)

pywebwinui3/util.py

@@ -1,4 +1,5 @@
 import xml.etree.ElementTree
+from functools import lru_cache
 from typing import Any, Callable
 import winreg
 import logging
@@ -37,6 +38,7 @@ class SyncDict(dict):
 		self.sync = sync
 
 	@staticmethod
+	@lru_cache(maxsize=512)
 	def _parsePath(key:str):
 		if not isinstance(key, str) or "[" not in key:
 			return None
@@ -159,9 +161,7 @@ class SyncDict(dict):
 class AccentColorWatcher:
 	def __init__(self, event:Event=None):
 		self.event = event or Event()
-		self.theme_event = Event()
 		self.palette = self.getSystemAccentColor()
-		self.theme = self.getSystemTheme()
 
 	@staticmethod
 	def getSystemAccentColor():
@@ -172,22 +172,10 @@ class AccentColorWatcher:
 			return DEFAULT_ACCENT_PALETTE.copy()
 		return [f"#{p[i]:02x}{p[i+1]:02x}{p[i+2]:02x}" for i in range(0,len(p),4)]
 
-	@staticmethod
-	def getSystemTheme():
-		try:
-			with winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize") as key:
-				t, _ = winreg.QueryValueEx(key, "AppsUseLightTheme")
-		except OSError:
-			return "dark"
-		return "light" if t else "dark"
-
 	def refresh(self):
 		if self.palette != (color := self.getSystemAccentColor()):
 			self.palette = color
 			self.event.set(self.palette)
-		if self.theme != (theme := self.getSystemTheme()):
-			self.theme = theme
-			self.theme_event.set(self.theme)
 
 	def start(self):
 		self.refresh()