Resizable frameless window with system tray icon

[unigrated-solutions]

I think I have quite a bit of redundant code in an example application I was playing around with. I'm trying to figure out the flow so I can keep a remote client socket connection active while the application is hidden in the system tray. The goal is that the web server that the window is connected to can continue to emit notifications that are displayed on the OS. I went with plyer over pystray for the notifications because I couldn't figure out how get a pystray notification to close automatically after a couple of seconds. Any feedback or insight on the application flow would be greatly appreciated:

# app.py
import threading
import queue
import time
import sys
import os
from pathlib import Path

from PIL import Image
from pystray import Icon, Menu, MenuItem
from plyer import notification

import webview
from window_api import WindowAPI

WINDOW_TITLE = "Remote Native Application"
ALLOW_QUIT = False

message_queue = queue.Queue()
native_window = None
icon = None

# ---------- Window hooks ----------
def prevent_close():
    """Intercept window close unless Exit was requested."""
    print("Window close intercepted." + (" (ALLOW_QUIT)" if ALLOW_QUIT else " Hiding to tray."))
    if ALLOW_QUIT:
        return True
    if native_window:
        native_window.hide()
    return False

def hook_webview_window():
    global native_window
    while native_window is None:
        try:
            if webview.windows:
                native_window = webview.windows[0]
                native_window.events.closing += prevent_close
                
                print(f"Hooked window: {native_window}")
                break
            time.sleep(0.5)
        except Exception as e:
            print(f"Exception during hook: {e}")
            time.sleep(1)

# ---------- Tray actions ----------
def on_open():
    if native_window:
        native_window.show()
        try:
            native_window.restore()
        except Exception:
            pass

def on_exit(_icon):
    global ALLOW_QUIT
    ALLOW_QUIT = True
    try:
        if native_window:
            native_window.destroy()
    finally:
        try:
            _icon.stop()
        except Exception:
            pass

def _on_quit():
    global ALLOW_QUIT, icon
    ALLOW_QUIT = True
    try:
        if icon:
            icon.stop()
    except Exception:
        pass
    try:
        window.destroy()
    except Exception:
        pass
    finally:
        # Linux sometimes hangs here, force exit
        if sys.platform.startswith("linux"):
            os._exit(0)
        
# ---------- Tray setup ----------
def start_tray(message_queue=None):
    global icon
    base_path = Path(getattr(sys, "_MEIPASS", Path(__file__).parent))
    tray_icon_path = base_path / "logo.ico"

    if not tray_icon_path.exists():
        print(f"Tray icon not found: {tray_icon_path}")
        return

    menu = Menu(
        MenuItem("Open", on_open, default=True),
        MenuItem("Exit", on_exit),
    )
    icon = Icon("MyApp", Image.open(tray_icon_path), WINDOW_TITLE, menu)

    if message_queue:
        def poll_messages():
            while True:
                while not message_queue.empty():
                    payload = message_queue.get()

                    msg_type = payload.get("type")
                    msg_text = payload.get("message", "")

                    if msg_type == "notification":
                        try:
                            notification.notify(
                                title="Nicegui Notification",
                                message=msg_text,
                                timeout=3  # seconds
                            )
                            print(f"[TRAY] Notification: {msg_text}")
                        except Exception as e:
                            print(f"[TRAY] Failed to show notification: {e}")
                    else:
                        print(f"[TRAY] Unhandled message type: {msg_type}")
                time.sleep(1)

        threading.Thread(target=poll_messages, daemon=True).start()

    if sys.platform.startswith("linux"):
        icon.run_detached()
    else:
        icon.run()

# ---------- Main ----------
if __name__ == "__main__":

    threading.Thread(target=hook_webview_window, daemon=True).start()
    threading.Thread(target=start_tray, args=(message_queue,), daemon=True).start()

    window = webview.create_window(
        WINDOW_TITLE,
        url="http://localhost:8080",
        width=1200,
        height=800,
        frameless=True,
        easy_drag=False,
        resizable=True,
    )

    api = WindowAPI(window, WINDOW_TITLE, on_quit=_on_quit, message_queue=message_queue)
    window.expose(api.minimize, api.maximize, api.close, api.resize, api.quit, api.set_bounds, api.notify)
    window.events.loaded += api.on_loaded
    webview.start()

# window_api.py
import queue
import json
from maximize import create_maximizer

class WindowAPI:
    def __init__(self, window, title: str, on_quit=None, message_queue: queue.Queue = None):
        self.window = window
        self.title = title
        self.maximizer = create_maximizer(window, title)
        self.on_quit = on_quit
        self.message_queue = message_queue

    def on_loaded(self, win=None):
        """pywebview on_loaded event handler"""
        print("[WEBVIEW] DOM loaded, injecting global CSS/JS")
        self.insert_resize_handles()
    
    def minimize(self):
        self.window.minimize()

    def maximize(self):
        self.maximizer.toggle()

    def restore(self):
        self.window.restore()
        
    def close(self):
        self.window.hide()
    
    def resize(self, width, height, x=None, y=None):
        width, height = int(width), int(height)
        self.window.resize(width, height)

        if x is not None and y is not None:
            self.window.move(int(x), int(y))
        elif x is not None:
            self.window.move(int(x), self.window.y)
        elif y is not None:
            self.window.move(self.window.x, int(y))

    def set_bounds(self, x: int, y: int, width: int, height: int):
        self.window.move(int(x), int(y))
        self.window.resize(int(width), int(height))

    def quit(self):
        if callable(self.on_quit):
            self.on_quit()
        else:
            try:
                self.window.destroy()
            except Exception:
                pass

    def notify(self, payload: dict):
        print(f"[WEBVIEW] Notify requested: {payload}")
        if self.message_queue:
            self.message_queue.put(payload)

    def emit_event(self, name: str, detail: dict | None = None):
        """Emit a CustomEvent into the DOM so the page JS (NiceGUI) can handle it."""
        payload = json.dumps(detail or {})
        js = f'window.dispatchEvent(new CustomEvent("{name}", {{ detail: {payload} }}));'
        try:
            self.window.evaluate_js(js)
        except Exception as e:
            print(f"[WEBVIEW] Failed to emit event {name}: {e}\n")

    # === Injection ===
    def insert_resize_handles(self):
        """Insert CSS + JS into <head> only once."""
        try:
            self.window.evaluate_js("""
                (function(){
                    if (!document.querySelector('.resize-handle-style')) {
                        // CSS
                        const style = document.createElement('style');
                        style.className = 'resize-handle-style';
                        style.textContent = `
                            .resize-handle {
                                position: fixed;
                                background: transparent;
                                z-index: 9999;
                            }
                            .resize-handle.left   { left: 0; top: 0; bottom: 0; width: 6px; cursor: ew-resize; }
                            .resize-handle.right  { right: 0; top: 0; bottom: 0; width: 6px; cursor: ew-resize; }
                            .resize-handle.bottom { left: 0; right: 0; bottom: 0; height: 6px; cursor: ns-resize; }
                        `;
                        document.head.appendChild(style);

                        // JS
                        const script = document.createElement('script');
                        script.className = 'resize-handle-script';
                        script.textContent = `
                            let resizing = false;
                            let resizeDir = null;
                            let startX, startY, startWidth, startHeight, startWinX, startWinY;
                            const MIN_W = 400, MIN_H = 300;

                            function startResize(dir, e) {
                                resizing = true;
                                resizeDir = dir;
                                startX = e.clientX;
                                startY = e.clientY;
                                startWidth = window.innerWidth;
                                startHeight = window.innerHeight;
                                startWinX = window.screenX;
                                startWinY = window.screenY;
                                document.addEventListener('mousemove', doResize);
                                document.addEventListener('mouseup', stopResize);
                            }

                            function doResize(e) {
                                if (!resizing) return;
                                let newW = startWidth, newH = startHeight, newX = startWinX, newY = startWinY;
                                if (resizeDir === 'left') {
                                    const rightEdge = startWinX + startWidth;
                                    newX = e.screenX;
                                    newW = Math.max(MIN_W, rightEdge - newX);
                                    if (newW === MIN_W) newX = rightEdge - MIN_W;
                                } else if (resizeDir === 'right') {
                                    newW = Math.max(MIN_W, startWidth + (e.clientX - startX));
                                } else if (resizeDir === 'bottom') {
                                    newH = Math.max(MIN_H, startHeight + (e.clientY - startY));
                                }
                                if (window.pywebview?.api?.set_bounds) {
                                    window.pywebview.api.set_bounds(newX, newY, newW, newH);
                                }
                            }

                            function stopResize() {
                                resizing = false;
                                document.removeEventListener('mousemove', doResize);
                                document.removeEventListener('mouseup', stopResize);
                            }

                            // Create handles
                            if (!document.querySelector('.resize-handle')) {
                                const left = document.createElement('div');
                                left.className = 'resize-handle left';
                                left.onmousedown = e => startResize('left', e);

                                const right = document.createElement('div');
                                right.className = 'resize-handle right';
                                right.onmousedown = e => startResize('right', e);

                                const bottom = document.createElement('div');
                                bottom.className = 'resize-handle bottom';
                                bottom.onmousedown = e => startResize('bottom', e);

                                document.body.appendChild(left);
                                document.body.appendChild(right);
                                document.body.appendChild(bottom);
                            }

                        `;
                        document.head.appendChild(script);
                    }
                })();
            """)
        except Exception as e:
            print(f"[WEBVIEW] Failed to inject global head: {e}")

Full example at: https://github.com/unigrated-solutions/example-pywebview-nicegui-tray