pendify 0.1.3__tar.gz → 0.1.4__tar.gz

{pendify-0.1.3/src/pendify.egg-info → pendify-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pendify
-Version: 0.1.3
+Version: 0.1.4
 Summary: Pairs this PC with a phone account by a QR on a loopback page and sends it two kinds of alerts.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/ElkinDev/PendiFy
@@ -61,6 +61,7 @@ El botón de arriba a la derecha cambia entre el tema claro y el oscuro, y el pr
 
 - Iniciar: el acceso directo `PendiFy`, o `pythonw -m pendify`, que es lo que ejecuta el acceso directo; sin consola, si ya está abierto o no puede iniciarse te lo dice en una ventana. Para verlo en una consola: `python -m pendify`.
 - Detener: pulsa «Salir» en la página del programa; si no la tienes abierta, iniciarlo otra vez la abre. Como último recurso, cierra el proceso `pythonw.exe` en el Administrador de tareas.
+- Icono junto al reloj: un clic en el icono de PendiFy junto al reloj abre un menú para abrir la página, pausar o reanudar los avisos y salir del programa, también con la página y el navegador cerrados.
 - Pausar: «Pausar avisos», en la tarjeta «Este PC» de la página, deja de leer el cliente del juego: no acepta partidas ni avisa a tu teléfono, y la página sigue abierta. «Reanudar avisos» vuelve a leerlo. La pausa no se guarda: cada vez que el programa se inicia, empieza activo.
 - Iniciar con Windows: el interruptor «Iniciar con Windows», en la misma tarjeta, está apagado hasta que lo enciendas. Encendido, el programa empieza solo al iniciar sesión en Windows, solo para tu usuario y sin abrir el navegador ni la página.
 - Actividad: la tarjeta «Actividad» de la página lista lo que el programa hizo desde que empezó: el cliente del juego encontrado y perdido, cada fase, la partida aceptada y el aviso enviado. Guarda las últimas 50 líneas, solo en memoria.
@@ -123,6 +124,7 @@ The button at the top right switches between the light and the dark theme, and t
 
 - Start: the `PendiFy` shortcut, or `pythonw -m pendify`, which is what the shortcut runs; with no console, it tells you in a window when it is already running or cannot start. To see it in a console: `python -m pendify`.
 - Stop: press «Quit» on the program's page; if it is not open, starting the program again opens it. As a last resort, end the `pythonw.exe` process in Task Manager.
+- Icon by the clock: a click on the PendiFy icon by the clock opens a menu that opens the page, pauses or resumes the alerts and quits the program, also with the page and the browser closed.
 - Pause: «Pause alerts», on the page's «This PC» card, stops reading the game client: it accepts no match and sends no alert to your phone, and the page stays open. «Resume alerts» reads it again. The pause is not kept: every start of the program is active again.
 - Start with Windows: the «Start with Windows» switch, on the same card, is off until you turn it on. When it is on, the program starts by itself when you sign in to Windows, for your user only, without opening the browser or the page.
 - Activity: the page's «Activity» card lists what the program did since it started: the game client found and lost, each phase, the match accepted and the alert sent. It keeps the last 50 lines, in memory only.

{pendify-0.1.3 → pendify-0.1.4}/README.md

@@ -45,6 +45,7 @@ El botón de arriba a la derecha cambia entre el tema claro y el oscuro, y el pr
 
 - Iniciar: el acceso directo `PendiFy`, o `pythonw -m pendify`, que es lo que ejecuta el acceso directo; sin consola, si ya está abierto o no puede iniciarse te lo dice en una ventana. Para verlo en una consola: `python -m pendify`.
 - Detener: pulsa «Salir» en la página del programa; si no la tienes abierta, iniciarlo otra vez la abre. Como último recurso, cierra el proceso `pythonw.exe` en el Administrador de tareas.
+- Icono junto al reloj: un clic en el icono de PendiFy junto al reloj abre un menú para abrir la página, pausar o reanudar los avisos y salir del programa, también con la página y el navegador cerrados.
 - Pausar: «Pausar avisos», en la tarjeta «Este PC» de la página, deja de leer el cliente del juego: no acepta partidas ni avisa a tu teléfono, y la página sigue abierta. «Reanudar avisos» vuelve a leerlo. La pausa no se guarda: cada vez que el programa se inicia, empieza activo.
 - Iniciar con Windows: el interruptor «Iniciar con Windows», en la misma tarjeta, está apagado hasta que lo enciendas. Encendido, el programa empieza solo al iniciar sesión en Windows, solo para tu usuario y sin abrir el navegador ni la página.
 - Actividad: la tarjeta «Actividad» de la página lista lo que el programa hizo desde que empezó: el cliente del juego encontrado y perdido, cada fase, la partida aceptada y el aviso enviado. Guarda las últimas 50 líneas, solo en memoria.
@@ -107,6 +108,7 @@ The button at the top right switches between the light and the dark theme, and t
 
 - Start: the `PendiFy` shortcut, or `pythonw -m pendify`, which is what the shortcut runs; with no console, it tells you in a window when it is already running or cannot start. To see it in a console: `python -m pendify`.
 - Stop: press «Quit» on the program's page; if it is not open, starting the program again opens it. As a last resort, end the `pythonw.exe` process in Task Manager.
+- Icon by the clock: a click on the PendiFy icon by the clock opens a menu that opens the page, pauses or resumes the alerts and quits the program, also with the page and the browser closed.
 - Pause: «Pause alerts», on the page's «This PC» card, stops reading the game client: it accepts no match and sends no alert to your phone, and the page stays open. «Resume alerts» reads it again. The pause is not kept: every start of the program is active again.
 - Start with Windows: the «Start with Windows» switch, on the same card, is off until you turn it on. When it is on, the program starts by itself when you sign in to Windows, for your user only, without opening the browser or the page.
 - Activity: the page's «Activity» card lists what the program did since it started: the game client found and lost, each phase, the match accepted and the alert sent. It keeps the last 50 lines, in memory only.

{pendify-0.1.3 → pendify-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pendify"
-version = "0.1.3"
+version = "0.1.4"
 description = "Pairs this PC with a phone account by a QR on a loopback page and sends it two kinds of alerts."
 readme = "README.md"
 license = "MIT"

{pendify-0.1.3 → pendify-0.1.4}/src/pendify/__main__.py

@@ -6,9 +6,10 @@
                                      unless the start fails
     python -m <package> ping <kind>  one alert with the stored pair, one fixed line per answer
 
-The page and the watcher stop together on Ctrl+C, on Ctrl+Break and on the page's quit button, which
-removes the run file and exits 0. One instance per config folder: a second start opens the running page
-and exits 0, and one made while that program is still closing after its quit waits for it to end and starts.
+The page and the watcher stop together on Ctrl+C, on Ctrl+Break, on the page's quit button and on the quit of
+the icon by the clock, which remove the run file and exit 0. One instance per config folder: a second start
+opens the running page and exits 0, and one made while that program is still closing after its quit waits for
+it to end and starts.
 Where no console is attached (a pythonw start), the line a start ends on is also shown in a
 message box. `--data-dir`, `--worker` and `--client-lockfile` are the
 test overrides, loopback only, so a test run reads neither the profile, the Worker nor the client's files.
@@ -24,6 +25,7 @@ from pathlib import Path
 
 from . import alert, client, config, page, pairing, runfile, watcher, worker
 from .autostart import Autostart
+from .tray import Tray
 
 TICK_SECONDS = 1.0
 STOP_SECONDS = 5.0
@@ -41,6 +43,8 @@ CLAIM_FAILED_LINE = "cannot start: the run file cannot be replaced: {path}"
 FOLDER_FAILED_LINE = "cannot start: the config folder cannot be written: {path}"
 _MB_ICONINFORMATION = 0x40
 _MB_SETFOREGROUND = 0x10000
+# The icon by the clock's picture: pendify.ico beside the modules, the file install.ps1 points the shortcuts at.
+ICON_PATH = Path(__file__).with_name("pendify.ico")
 
 
 def _data_dir(value):
@@ -150,7 +154,7 @@ def _ends(line, code, show):
     return code
 
 
-def _serve(args, store, base, timeout, opener, stop, delay, beep, show, clock, sleep, autostart):
+def _serve(args, store, base, timeout, opener, stop, delay, beep, show, clock, sleep, autostart, tray):
     # A quiet start is the system's, at logon: it never opens the browser, and a start that ends well shows no box.
     calm = (lambda line: None) if args.quiet else show
     run = runfile.RunFile(store.path.parent, clock=clock, sleep=sleep)
@@ -192,8 +196,14 @@ def _serve(args, store, base, timeout, opener, stop, delay, beep, show, clock, s
         pairing_page = page.PairingPage(state, watch=watch.snapshot, on_quit=quit_page, on_pause=watch.pause,
                                         on_resume=watch.resume, autostart=autostart, events=watch.events)
         url = pairing_page.start()
+        # The icon by the clock, under --quiet as well: the way to stop a copy the Run key started. Its words are
+        # the page's, in the language the page resolves with no browser to ask: the kept choice, else Spanish.
+        icon = tray(url, on_open=lambda: opener(url), on_pause=watch.pause, on_resume=watch.resume,
+                    on_quit=quit_page, paused=lambda: watch.paused,
+                    words=lambda: page.WORDS[pairing_page.language_of(None)], icon_path=ICON_PATH)
         watching = threading.Thread(target=watch.run, daemon=True)
         try:
+            icon.start()
             run.publish(pairing_page.port)
             print(f"page: {url}", flush=True)
             if not args.quiet and not opener(url):  # a start by a person opens the page, linked or not
@@ -217,6 +227,7 @@ def _serve(args, store, base, timeout, opener, stop, delay, beep, show, clock, s
                 watching.join(STOP_SECONDS)
             alerter.flush(STOP_SECONDS)
             pairing_page.close()
+            icon.close()
     finally:
         run.release()
     return 0
@@ -231,10 +242,11 @@ def _break_as_interrupt():
 
 def main(argv=None, *, opener=webbrowser.open, stop=None, timeout=worker.TIMEOUT_SECONDS, delay=None,
          beep=alert.beep, box=_message_box, autostart=None, console=_console_attached, clock=time.monotonic,
-         sleep=time.sleep):
+         sleep=time.sleep, tray=Tray):
     """`beep`, `box` and `autostart` are the seams of the sound, of the message box and of the start with Windows
     (the per-user Run value when None): a test run passes silent ones and a fake. `console` says whether a printed
-    line reaches anybody; `clock` and `sleep` time the run file's re-reads."""
+    line reaches anybody; `clock` and `sleep` time the run file's re-reads. `tray` makes the icon by the clock, the
+    seam a test run fills with a fake, so no test shows a real icon."""
     args = _arguments(sys.argv[1:] if argv is None else argv)
     store = config.ConfigStore(getattr(args, "data_dir", None) or config.default_base_dir())
     base = getattr(args, "worker", worker.BASE_URL)
@@ -250,7 +262,7 @@ def main(argv=None, *, opener=webbrowser.open, stop=None, timeout=worker.TIMEOUT
         try:
             return _serve(args, store, base, timeout, opener, stop or threading.Event(),
                           delay or watcher.accept_delay, beep, show, clock, sleep,
-                          autostart if autostart is not None else Autostart())
+                          autostart if autostart is not None else Autostart(), tray)
         finally:
             if previous is not None:
                 signal.signal(signal.SIGBREAK, previous)

{pendify-0.1.3 → pendify-0.1.4}/src/pendify/page.py

@@ -119,6 +119,7 @@ WORDS = {
         "this_pc": "Este PC",
         "pause": "Pausar avisos",
         "resume": "Reanudar avisos",
+        "tray_open": "Abrir la página",
         "autostart_label": "Iniciar con Windows",
         "autostart_help": "Al encender el PC el programa empieza solo, sin abrir esta página.",
         "stopped": "El programa se detuvo: ya no vigila el cliente del juego ni envía avisos.",
@@ -200,6 +201,7 @@ WORDS = {
         "this_pc": "This PC",
         "pause": "Pause alerts",
         "resume": "Resume alerts",
+        "tray_open": "Open the page",
         "autostart_label": "Start with Windows",
         "autostart_help": "When the PC turns on, the program starts by itself, without opening this page.",
         "stopped": "The program stopped: it no longer watches the game client or sends alerts.",

pendify-0.1.4/src/pendify/tray.py

@@ -0,0 +1,310 @@
+"""The icon by the clock (lane pftray): an icon in the notification area whose menu opens the page, pauses or
+resumes the alerts and quits the program, so the program can be stopped with the page and the browser closed.
+
+Standard library only: user32, shell32 and kernel32 by ctypes, bound for 64-bit Windows. The icon lives on a thread
+of its own, a daemon, with a hidden top-level tool window (never shown, so no taskbar entry and no Alt+Tab slot,
+yet the shell's TaskbarCreated broadcast reaches it) and its message loop; a left or right click on it shows the menu
+in the page's language of that moment. A Win32 call that fails is said in one fixed stderr line, as the page says a
+failed request, and never raises out of the thread: the program runs without an icon rather than dying under
+pythonw. On a platform other than Windows, start() says so in one line and does nothing.
+"""
+import ctypes
+import os
+import sys
+import threading
+
+TIP = "PendiFy"
+CLASS_NAME = "PendiFyTray"
+THREAD_NAME = "pendify tray"
+CLOSE_SECONDS = 3.0  # how long close() waits for the window to exist, then for the thread to end
+ICON_ID = 1
+
+WM_NULL, WM_DESTROY, WM_CLOSE, WM_CONTEXTMENU = 0x0000, 0x0002, 0x0010, 0x007B
+WM_LBUTTONUP, WM_RBUTTONUP, WM_APP = 0x0202, 0x0205, 0x8000
+CALLBACK_MESSAGE = WM_APP + 1
+CLICKS = (WM_LBUTTONUP, WM_RBUTTONUP, WM_CONTEXTMENU)
+WS_OVERLAPPED, WS_EX_TOOLWINDOW = 0x0, 0x80  # the window's style; a tool window takes no taskbar entry
+NIM_ADD, NIM_DELETE = 0, 2
+NIF_MESSAGE, NIF_ICON, NIF_TIP = 0x1, 0x2, 0x4
+IMAGE_ICON, LR_LOADFROMFILE, LR_DEFAULTSIZE = 1, 0x10, 0x40
+MF_STRING, MF_SEPARATOR = 0x0, 0x800
+TPM_RIGHTBUTTON, TPM_NONOTIFY, TPM_RETURNCMD = 0x2, 0x80, 0x100
+OPEN, PAUSE, RESUME, QUIT = 1, 2, 3, 4  # the menu's commands
+
+FAILED_LINE = " [tray] {call} failed (error {code})"
+BROKE_LINE = " [tray] the icon broke: {kind}"
+HELD_LINE = " [tray] the icon's thread did not end in {seconds:g} seconds: its icon deleted from close"
+EARLY_LINE = " [tray] the icon's thread did not end in {seconds:g} seconds before its window existed"
+OTHER_PLATFORM_LINE = " [tray] no icon by the clock: this platform is not Windows"
+
+# The Win32 types for 64-bit Windows: handles as c_void_p, WPARAM as c_size_t, LPARAM and LRESULT as c_ssize_t.
+HANDLE, UINT, INT, WSTR = ctypes.c_void_p, ctypes.c_uint, ctypes.c_int, ctypes.c_wchar_p
+WPARAM, LPARAM, LRESULT = ctypes.c_size_t, ctypes.c_ssize_t, ctypes.c_ssize_t
+# The window procedure's type, made once: LRESULT (HWND, UINT, WPARAM, LPARAM). WINFUNCTYPE exists on Windows only.
+WNDPROC = getattr(ctypes, "WINFUNCTYPE", ctypes.CFUNCTYPE)(LRESULT, HANDLE, UINT, WPARAM, LPARAM)
+
+
+class POINT(ctypes.Structure):
+    _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)]
+
+
+class MSG(ctypes.Structure):
+    _fields_ = [("hwnd", HANDLE), ("message", UINT), ("wParam", WPARAM), ("lParam", LPARAM), ("time", UINT),
+                ("pt", POINT), ("lPrivate", UINT)]
+
+
+class WNDCLASSW(ctypes.Structure):
+    _fields_ = [("style", UINT), ("lpfnWndProc", WNDPROC), ("cbClsExtra", INT), ("cbWndExtra", INT),
+                ("hInstance", HANDLE), ("hIcon", HANDLE), ("hCursor", HANDLE), ("hbrBackground", HANDLE),
+                ("lpszMenuName", WSTR), ("lpszClassName", WSTR)]
+
+
+class GUID(ctypes.Structure):
+    _fields_ = [("Data1", UINT), ("Data2", ctypes.c_ushort), ("Data3", ctypes.c_ushort),
+                ("Data4", ctypes.c_ubyte * 8)]
+
+
+class NOTIFYICONDATAW(ctypes.Structure):
+    _fields_ = [("cbSize", UINT), ("hWnd", HANDLE), ("uID", UINT), ("uFlags", UINT), ("uCallbackMessage", UINT),
+                ("hIcon", HANDLE), ("szTip", ctypes.c_wchar * 128), ("dwState", UINT), ("dwStateMask", UINT),
+                ("szInfo", ctypes.c_wchar * 256), ("uVersion", UINT), ("szInfoTitle", ctypes.c_wchar * 64),
+                ("dwInfoFlags", UINT), ("guidItem", GUID), ("hBalloonIcon", HANDLE)]
+
+
+class _Win32:
+    """The facade: the Win32 functions the icon calls, each bound with its argtypes and restype, and the last
+    error of the calling thread."""
+
+    def __init__(self):
+        user32, shell32, kernel32 = (ctypes.WinDLL(name, use_last_error=True)
+                                     for name in ("user32", "shell32", "kernel32"))
+        bound = ((kernel32, "GetModuleHandleW", (WSTR,), HANDLE),
+                 (user32, "RegisterClassW", (ctypes.POINTER(WNDCLASSW),), ctypes.c_ushort),
+                 (user32, "UnregisterClassW", (WSTR, HANDLE), INT),
+                 (user32, "CreateWindowExW", (UINT, WSTR, WSTR, UINT, INT, INT, INT, INT, HANDLE, HANDLE, HANDLE,
+                                              HANDLE), HANDLE),
+                 (user32, "DestroyWindow", (HANDLE,), INT),
+                 (user32, "DefWindowProcW", (HANDLE, UINT, WPARAM, LPARAM), LRESULT),
+                 (user32, "GetMessageW", (ctypes.POINTER(MSG), HANDLE, UINT, UINT), INT),
+                 (user32, "TranslateMessage", (ctypes.POINTER(MSG),), INT),
+                 (user32, "DispatchMessageW", (ctypes.POINTER(MSG),), LRESULT),
+                 (user32, "PostMessageW", (HANDLE, UINT, WPARAM, LPARAM), INT),
+                 (user32, "PostQuitMessage", (INT,), None),
+                 (user32, "RegisterWindowMessageW", (WSTR,), UINT),
+                 (user32, "LoadImageW", (HANDLE, WSTR, UINT, INT, INT, UINT), HANDLE),
+                 (user32, "DestroyIcon", (HANDLE,), INT),
+                 (user32, "CreatePopupMenu", (), HANDLE),
+                 (user32, "AppendMenuW", (HANDLE, UINT, WPARAM, WSTR), INT),
+                 (user32, "DestroyMenu", (HANDLE,), INT),
+                 (user32, "GetCursorPos", (ctypes.POINTER(POINT),), INT),
+                 (user32, "SetForegroundWindow", (HANDLE,), INT),
+                 (user32, "TrackPopupMenu", (HANDLE, UINT, INT, INT, INT, HANDLE, HANDLE), INT),
+                 (shell32, "Shell_NotifyIconW", (UINT, ctypes.POINTER(NOTIFYICONDATAW)), INT))
+        for library, name, arguments, result in bound:
+            function = getattr(library, name)
+            function.argtypes, function.restype = arguments, result
+            setattr(self, name, function)
+
+    @staticmethod
+    def last_error():
+        return ctypes.get_last_error()
+
+
+def _windows():
+    return os.name == "nt"
+
+
+def _say(line):
+    """One fixed line on stderr, the page's road for a failure; under pythonw there is no stderr and it goes nowhere."""
+    print(line, file=sys.stderr)
+
+
+class Tray:
+    """The icon by the clock. `paused` answers the watcher's state and `words` the page's table for the language set
+    at that moment; both are read at each click. `win32` is the facade of the Win32 functions, built from ctypes on
+    Windows when None; a test passes a fake."""
+
+    def __init__(self, url, on_open, on_pause, on_resume, on_quit, paused, words, icon_path, win32=None):
+        self.url = url
+        self._on_open, self._on_pause, self._on_resume, self._on_quit = on_open, on_pause, on_resume, on_quit
+        self._paused, self._words, self._icon_path = paused, words, str(icon_path)
+        self._win32 = win32
+        self._wndproc = WNDPROC(self._proc)  # made once and kept here, so the window's procedure is never collected
+        self._thread = None
+        self._ready = threading.Event()  # set once the window exists, or once it cannot
+        self._instance = self._hwnd = self._icon = None
+        self._registered, self._taskbar_created = False, 0
+        self._closing = False  # set by close(): an _open still under way then adds no icon
+
+    def start(self):
+        """The icon on its own thread, a daemon, so a thread held past close() never keeps the process alive."""
+        if self._win32 is None:
+            if not _windows():
+                _say(OTHER_PLATFORM_LINE)
+                return
+            try:
+                self._win32 = _Win32()
+            except (OSError, AttributeError) as failure:
+                _say(BROKE_LINE.format(kind=type(failure).__name__))
+                return
+        self._thread = threading.Thread(target=self._run, name=THREAD_NAME, daemon=True)
+        self._thread.start()
+
+    def close(self):
+        """Posts WM_CLOSE to the window when it exists, then waits a few seconds for the thread. A thread still held
+        then (in TrackPopupMenu's modal loop, say) leaves no dead icon: close deletes it from the calling thread.
+        A thread held before its window existed adds no icon once it goes on, so there is none to delete."""
+        self._closing = True
+        if self._thread is None:
+            return
+        self._ready.wait(CLOSE_SECONDS)
+        hwnd = self._hwnd
+        if hwnd is not None and self._thread.is_alive() and not self._win32.PostMessageW(hwnd, WM_CLOSE, 0, 0):
+            self._failed("PostMessageW")
+        self._thread.join(CLOSE_SECONDS)
+        if self._thread.is_alive():
+            if hwnd is not None:
+                self._notify(NIM_DELETE, hwnd)
+                _say(HELD_LINE.format(seconds=CLOSE_SECONDS))
+            else:
+                _say(EARLY_LINE.format(seconds=CLOSE_SECONDS))
+
+    def _failed(self, call):
+        _say(FAILED_LINE.format(call=call, code=self._win32.last_error()))
+
+    def _run(self):
+        try:
+            if self._open():
+                self._loop()
+        except Exception as failure:  # never out of the thread: the program goes on without its icon
+            _say(BROKE_LINE.format(kind=type(failure).__name__))
+        finally:
+            self._ready.set()
+            self._release()
+
+    def _open(self):
+        """The window class, the hidden top-level tool window, the icon's picture and the TaskbarCreated message;
+        then the icon. False when there is no window to serve."""
+        win32 = self._win32
+        self._instance = win32.GetModuleHandleW(None)
+        if not self._instance:
+            self._failed("GetModuleHandleW")
+        window_class = WNDCLASSW(lpfnWndProc=self._wndproc, hInstance=self._instance, lpszClassName=CLASS_NAME)
+        self._registered = bool(win32.RegisterClassW(window_class))
+        if not self._registered:
+            self._failed("RegisterClassW")
+            return False
+        hwnd = win32.CreateWindowExW(WS_EX_TOOLWINDOW, CLASS_NAME, TIP, WS_OVERLAPPED, 0, 0, 0, 0, None, None,
+                                     self._instance, None)  # top-level, never shown: TaskbarCreated reaches it
+        if not hwnd:
+            self._failed("CreateWindowExW")
+            return False
+        self._hwnd = hwnd
+        self._icon = win32.LoadImageW(None, self._icon_path, IMAGE_ICON, 0, 0, LR_LOADFROMFILE | LR_DEFAULTSIZE)
+        if not self._icon:
+            self._failed("LoadImageW")
+        self._taskbar_created = win32.RegisterWindowMessageW("TaskbarCreated")
+        if not self._taskbar_created:
+            self._failed("RegisterWindowMessageW")
+        if self._closing:  # close() has run: no icon, and _release destroys the window and unregisters the class
+            return False
+        self._notify(NIM_ADD)
+        self._ready.set()
+        return True
+
+    def _loop(self):
+        win32, message = self._win32, MSG()
+        while True:
+            got = win32.GetMessageW(message, None, 0, 0)
+            if got == 0:  # WM_QUIT, posted at WM_DESTROY
+                return
+            if got == -1:
+                self._failed("GetMessageW")
+                return
+            win32.TranslateMessage(message)
+            win32.DispatchMessageW(message)
+
+    def _release(self):
+        """What the thread made, undone as it ends; the window only when its loop ended without WM_CLOSE."""
+        win32 = self._win32
+        if self._hwnd is not None:
+            self._notify(NIM_DELETE)
+            if not win32.DestroyWindow(self._hwnd):
+                self._failed("DestroyWindow")
+            self._hwnd = None
+        if self._icon and not win32.DestroyIcon(self._icon):
+            self._failed("DestroyIcon")
+        self._icon = None
+        if self._registered and not win32.UnregisterClassW(CLASS_NAME, self._instance):
+            self._failed("UnregisterClassW")
+        self._registered = False
+
+    def _notify(self, action, hwnd=None):
+        """The icon added or deleted; `hwnd` names the window when the caller holds it (close, off the thread)."""
+        data = NOTIFYICONDATAW(cbSize=ctypes.sizeof(NOTIFYICONDATAW), hWnd=self._hwnd if hwnd is None else hwnd,
+                               uID=ICON_ID)
+        if action == NIM_ADD:
+            data.uFlags, data.uCallbackMessage = NIF_MESSAGE | NIF_ICON | NIF_TIP, CALLBACK_MESSAGE
+            data.hIcon, data.szTip = self._icon, TIP
+        if not self._win32.Shell_NotifyIconW(action, data):
+            self._failed("Shell_NotifyIconW")
+
+    def _proc(self, hwnd, message, wparam, lparam):
+        try:
+            if message == CALLBACK_MESSAGE:
+                if (lparam & 0xFFFF) in CLICKS:
+                    self._menu(hwnd)
+                return 0
+            if message == WM_CLOSE:
+                self._notify(NIM_DELETE)
+                if not self._win32.DestroyWindow(hwnd):
+                    self._failed("DestroyWindow")
+                return 0
+            if message == WM_DESTROY:
+                self._hwnd = None
+                self._win32.PostQuitMessage(0)
+                return 0
+            if self._taskbar_created and message == self._taskbar_created:  # Explorer restarted: the icon again
+                self._notify(NIM_ADD)
+                return 0
+        except Exception as failure:  # never out of the procedure: the window goes on serving
+            _say(BROKE_LINE.format(kind=type(failure).__name__))
+            return 0
+        return self._win32.DefWindowProcW(hwnd, message, wparam, lparam)
+
+    def _menu(self, hwnd):
+        """The menu at the cursor, in the words and the pause of this moment, then its command. TrackPopupMenu
+        answers 0 when the menu is dismissed, which is no failure."""
+        win32, words = self._win32, self._words()
+        middle = (RESUME, words["resume"]) if self._paused() else (PAUSE, words["pause"])
+        menu = win32.CreatePopupMenu()
+        if not menu:
+            self._failed("CreatePopupMenu")
+            return
+        try:
+            for item in ((OPEN, words["tray_open"]), middle, None, (QUIT, words["quit"])):
+                flags, command, text = (MF_SEPARATOR, 0, None) if item is None else (MF_STRING, *item)
+                if not win32.AppendMenuW(menu, flags, command, text):
+                    self._failed("AppendMenuW")
+            cursor = POINT()
+            if not win32.GetCursorPos(cursor):
+                self._failed("GetCursorPos")
+            if not win32.SetForegroundWindow(hwnd):  # without it the menu stays open on a click elsewhere
+                self._failed("SetForegroundWindow")
+            chosen = win32.TrackPopupMenu(menu, TPM_RETURNCMD | TPM_NONOTIFY | TPM_RIGHTBUTTON, cursor.x, cursor.y,
+                                          0, hwnd, None)
+            if not win32.PostMessageW(hwnd, WM_NULL, 0, 0):  # lets the menu close on a click elsewhere next time
+                self._failed("PostMessageW")
+        finally:
+            if not win32.DestroyMenu(menu):
+                self._failed("DestroyMenu")
+        if chosen == OPEN:
+            self._on_open()
+        elif chosen == PAUSE:
+            self._on_pause()
+        elif chosen == RESUME:
+            self._on_resume()
+        elif chosen == QUIT:
+            self._on_quit()
+            if not win32.PostMessageW(hwnd, WM_CLOSE, 0, 0):
+                self._failed("PostMessageW")

{pendify-0.1.3 → pendify-0.1.4/src/pendify.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pendify
-Version: 0.1.3
+Version: 0.1.4
 Summary: Pairs this PC with a phone account by a QR on a loopback page and sends it two kinds of alerts.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/ElkinDev/PendiFy
@@ -61,6 +61,7 @@ El botón de arriba a la derecha cambia entre el tema claro y el oscuro, y el pr
 
 - Iniciar: el acceso directo `PendiFy`, o `pythonw -m pendify`, que es lo que ejecuta el acceso directo; sin consola, si ya está abierto o no puede iniciarse te lo dice en una ventana. Para verlo en una consola: `python -m pendify`.
 - Detener: pulsa «Salir» en la página del programa; si no la tienes abierta, iniciarlo otra vez la abre. Como último recurso, cierra el proceso `pythonw.exe` en el Administrador de tareas.
+- Icono junto al reloj: un clic en el icono de PendiFy junto al reloj abre un menú para abrir la página, pausar o reanudar los avisos y salir del programa, también con la página y el navegador cerrados.
 - Pausar: «Pausar avisos», en la tarjeta «Este PC» de la página, deja de leer el cliente del juego: no acepta partidas ni avisa a tu teléfono, y la página sigue abierta. «Reanudar avisos» vuelve a leerlo. La pausa no se guarda: cada vez que el programa se inicia, empieza activo.
 - Iniciar con Windows: el interruptor «Iniciar con Windows», en la misma tarjeta, está apagado hasta que lo enciendas. Encendido, el programa empieza solo al iniciar sesión en Windows, solo para tu usuario y sin abrir el navegador ni la página.
 - Actividad: la tarjeta «Actividad» de la página lista lo que el programa hizo desde que empezó: el cliente del juego encontrado y perdido, cada fase, la partida aceptada y el aviso enviado. Guarda las últimas 50 líneas, solo en memoria.
@@ -123,6 +124,7 @@ The button at the top right switches between the light and the dark theme, and t
 
 - Start: the `PendiFy` shortcut, or `pythonw -m pendify`, which is what the shortcut runs; with no console, it tells you in a window when it is already running or cannot start. To see it in a console: `python -m pendify`.
 - Stop: press «Quit» on the program's page; if it is not open, starting the program again opens it. As a last resort, end the `pythonw.exe` process in Task Manager.
+- Icon by the clock: a click on the PendiFy icon by the clock opens a menu that opens the page, pauses or resumes the alerts and quits the program, also with the page and the browser closed.
 - Pause: «Pause alerts», on the page's «This PC» card, stops reading the game client: it accepts no match and sends no alert to your phone, and the page stays open. «Resume alerts» reads it again. The pause is not kept: every start of the program is active again.
 - Start with Windows: the «Start with Windows» switch, on the same card, is off until you turn it on. When it is on, the program starts by itself when you sign in to Windows, for your user only, without opening the browser or the page.
 - Activity: the page's «Activity» card lists what the program did since it started: the game client found and lost, each phase, the match accepted and the alert sent. It keeps the last 50 lines, in memory only.

{pendify-0.1.3 → pendify-0.1.4}/src/pendify.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ src/pendify/pendify.ico
 src/pendify/plate_almena.py
 src/pendify/qr.py
 src/pendify/runfile.py
+src/pendify/tray.py
 src/pendify/watcher.py
 src/pendify/worker.py
 src/pendify.egg-info/PKG-INFO