plotruler 0.1.3__py3-none-any.whl

plotruler/settings.py

@@ -0,0 +1,130 @@
+"""Settings dialog for capturing a new global hotkey.
+
+A small modal dialog that lets the user press a key combination and
+records it. The overlay is a frameless custom window, but this dialog is
+a conventional temporary window — it only exists to capture input, then
+closes, so a native widget is appropriate here.
+"""
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QDialog, QLabel, QPushButton, QVBoxLayout
+
+from .hotkey import KeyCombo, qkey_to_vk, qmodifiers_to_names
+
+# Keys that should not be treated as the shortcut by themselves.
+_MODIFIER_KEYS = {
+    Qt.Key.Key_Control,
+    Qt.Key.Key_Shift,
+    Qt.Key.Key_Alt,
+    Qt.Key.Key_Meta,
+    Qt.Key.Key_Super_L,
+    Qt.Key.Key_Super_R,
+    Qt.Key.Key_unknown,
+}
+
+
+class HotkeyDialog(QDialog):
+    """A dialog that captures the next key combination the user presses."""
+
+    def __init__(self, current=None, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Set Global Hotkey")
+        self.setModal(False)
+        self._combo = None
+
+        layout = QVBoxLayout(self)
+        self._prompt = QLabel(
+            "Press a key combination (e.g. Win+Alt+P)\n\n"
+            "include a modifier key plus a letter. "
+            "Esc to cancel."
+        )
+        self._prompt.setWordWrap(True)
+        layout.addWidget(self._prompt)
+
+        self._combo_label = QLabel(self._describe(current))
+        self._combo_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self._combo_label.setStyleSheet(
+            "font-size: 16px; font-weight: bold; padding: 12px;"
+        )
+        layout.addWidget(self._combo_label)
+
+        if current is not None:
+            self._combo = current
+
+        buttons = QVBoxLayout()
+        use_btn = QPushButton("Use This Key")
+        use_btn.clicked.connect(self._use_current)
+        buttons.addWidget(use_btn)
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+        buttons.addWidget(cancel_btn)
+        layout.addLayout(buttons)
+
+    def _describe(self, combo):
+        return combo.text() if combo is not None else "— none —"
+
+    def keyPressEvent(self, event):
+        key = event.key()
+        if key in (Qt.Key.Key_Escape, Qt.Key.Key_Cancel):
+            self.reject()
+            return
+        if key in _MODIFIER_KEYS:
+            # A bare modifier isn't a shortcut; keep waiting.
+            return
+        vk = qkey_to_vk(key)
+        if vk == 0:
+            self._show_hint("That key isn't supported")
+            return
+        modifiers = qmodifiers_to_names(event.modifiers())
+        if not modifiers:
+            self._show_hint("Include a modifier key (Ctrl, Alt, or Win)")
+            return
+        self._combo = KeyCombo(modifiers, self._key_name(key), vk)
+        self._combo_label.setText(self._describe(self._combo))
+
+    def _show_hint(self, text):
+        self._prompt.setText(text)
+        self._prompt.setStyleSheet("color: #c0392b;")
+
+    def _key_name(self, key):
+        """Return a readable name for a Qt key."""
+        # Qt.Key.Key_A .. Key_Z have the same value as their ASCII letter.
+        if 0x41 <= key <= 0x5A:
+            return chr(key)
+        if 0x30 <= key <= 0x39:
+            return chr(key)
+        names = {
+            Qt.Key.Key_Space: "Space",
+            Qt.Key.Key_Tab: "Tab",
+            Qt.Key.Key_Left: "Left",
+            Qt.Key.Key_Right: "Right",
+            Qt.Key.Key_Up: "Up",
+            Qt.Key.Key_Down: "Down",
+            Qt.Key.Key_Home: "Home",
+            Qt.Key.Key_End: "End",
+            Qt.Key.Key_PageUp: "Page Up",
+            Qt.Key.Key_PageDown: "Page Down",
+            Qt.Key.Key_Insert: "Insert",
+            Qt.Key.Key_Delete: "Delete",
+            Qt.Key.Key_F1: "F1",
+            Qt.Key.Key_F2: "F2",
+            Qt.Key.Key_F3: "F3",
+            Qt.Key.Key_F4: "F4",
+            Qt.Key.Key_F5: "F5",
+            Qt.Key.Key_F6: "F6",
+            Qt.Key.Key_F7: "F7",
+            Qt.Key.Key_F8: "F8",
+            Qt.Key.Key_F9: "F9",
+            Qt.Key.Key_F10: "F10",
+            Qt.Key.Key_F11: "F11",
+            Qt.Key.Key_F12: "F12",
+        }
+        return names.get(key, "Key")
+
+    def _use_current(self):
+        if self._combo is not None:
+            self.accept()
+
+    def combo(self):
+        """Return the recorded KeyCombo, or None."""
+        return self._combo

plotruler/storage.py

@@ -0,0 +1,144 @@
+"""Persist a calibration and the window position to disk.
+
+This module is deliberately free of any Qt imports so it stays
+unit-testable and portable, following the same rule as the math core.
+It stores a Calibration (and optional window geometry) as JSON in a
+user config file; the overlay layer decides where that file lives,
+so this module only deals with the data shape.
+
+The config file is a small JSON object:
+
+    {
+        "geometry": [x, y, width, height],
+        "calibration": {
+            "x": {"p1": ..., "v1": ..., "p2": ..., "v2": ..., "log": false},
+            "y": {"p1": ..., "v1": ..., "p2": ..., "v2": ..., "log": false}
+        }
+    }
+"""
+
+import json
+import os
+
+from .core import AxisCalibration, Calibration
+
+
+def calibration_to_dict(calibration):
+    """Return a Calibration as a nested dict."""
+    return {
+        "x": {
+            "p1": calibration.x.p1,
+            "v1": calibration.x.v1,
+            "p2": calibration.x.p2,
+            "v2": calibration.x.v2,
+            "log": calibration.x.log,
+        },
+        "y": {
+            "p1": calibration.y.p1,
+            "v1": calibration.y.v1,
+            "p2": calibration.y.p2,
+            "v2": calibration.y.v2,
+            "log": calibration.y.log,
+        },
+    }
+
+
+def calibration_from_dict(data):
+    """Build a Calibration from a dict, or None if it is malformed.
+
+    A corrupted or truncated file should not crash the app; returning
+    None means the overlay simply starts uncalibrated. The log flag is
+    optional (defaults to linear) so configs written before the log-axis
+    feature still load.
+    """
+    try:
+        x = AxisCalibration(
+            data["x"]["p1"],
+            data["x"]["v1"],
+            data["x"]["p2"],
+            data["x"]["v2"],
+            log=bool(data["x"].get("log", False)),
+        )
+        y = AxisCalibration(
+            data["y"]["p1"],
+            data["y"]["v1"],
+            data["y"]["p2"],
+            data["y"]["v2"],
+            log=bool(data["y"].get("log", False)),
+        )
+    except (KeyError, TypeError, ValueError):
+        return None
+    return Calibration(x, y)
+
+
+def load(path):
+    """Read the config file; returns a dict, or {} if missing/corrupt."""
+    try:
+        with open(path, encoding="utf-8") as handle:
+            data = json.load(handle)
+    except (OSError, ValueError):
+        return {}
+    if not isinstance(data, dict):
+        return {}
+    return data
+
+
+def save(path, geometry=None, calibration=None, hotkey=None, num_format=None):
+    """Write geometry, calibration, hotkey, and/or number format to config.
+
+    Existing values not being updated are preserved, so callers only need
+    to pass the fields they changed. Missing keys just keep their old
+    value; a fresh save with no prior file writes whatever is provided.
+    """
+    data = load(path)
+    if geometry is not None:
+        data["geometry"] = geometry
+    if calibration is not None:
+        data["calibration"] = calibration_to_dict(calibration)
+    if hotkey is not None:
+        data["hotkey"] = hotkey
+    if num_format is not None:
+        data["num_format"] = num_format
+    directory = os.path.dirname(path)
+    if directory:
+        os.makedirs(directory, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as handle:
+        json.dump(data, handle, indent=2)
+
+
+def calibration(path):
+    """Return the saved Calibration, or None."""
+    return calibration_from_dict(load(path).get("calibration"))
+
+
+def hotkey(path):
+    """Return the saved hotkey config dict, or None."""
+    value = load(path).get("hotkey")
+    return value if isinstance(value, dict) else None
+
+
+def num_format(path):
+    """Return the saved readout number format key, or None.
+
+    Falls back to None (the caller uses its default) if the value is
+    missing or not a known format, so a corrupted or older config does
+    not crash the app.
+    """
+    from .format import is_valid
+
+    value = load(path).get("num_format")
+    if isinstance(value, str) and is_valid(value):
+        return value
+    return None
+
+
+def geometry(path):
+    """Return the saved geometry as a list, or None."""
+    value = load(path).get("geometry")
+    if (
+        isinstance(value, list)
+        and len(value) == 4
+        and all(isinstance(v, (int, float)) for v in value)
+    ):
+        return [int(v) for v in value]
+    return None

plotruler/titlebar.py

@@ -0,0 +1,226 @@
+"""The custom title bar of the overlay window.
+
+There is no native title bar on a frameless translucent window, so we
+paint our own: a translucent red strip with the app name and the
+standard window controls (minimize to tray, maximize/restore, close).
+Moving, snapping, and double-click-maximize are handled by the Win32
+hit-test shim, which makes the OS treat this strip as a real caption,
+so Aero Snap and external window tools work. Everything here is drawn
+with QPainter — no native widgets.
+"""
+
+from PySide6.QtCore import QPointF, QRectF, QSizeF, Qt
+from PySide6.QtGui import QColor, QFont, QPainter, QPen
+from PySide6.QtWidgets import QWidget
+
+from . import win_hittest
+
+TITLEBAR_HEIGHT = 32
+_BUTTON_WIDTH = 40
+# The invisible resize hit-zone width, matching the overlay so the top edge
+# and top corners resize the same way the other borders do on non-Windows.
+_RESIZE_ZONE = 14
+_GLYPH = QColor(220, 220, 220)
+_HOVER_BG = QColor(255, 255, 255, 36)
+
+
+class TitleBar(QWidget):
+    """A translucent title strip painted on the overlay."""
+
+    def __init__(self, parent=None, show_close=False):
+        super().__init__(parent)
+        self._min_rect = QRectF()
+        self._max_rect = QRectF()
+        self._close_rect = QRectF()
+        self._hover_button = None
+        self._pressed_button = None
+        # On platforms with no system tray there is no way to summon the
+        # overlay back after hiding, so hiding is a dead end; offer a real
+        # close (quit) button instead. On Windows the tray is the natural
+        # close path and no button is drawn.
+        self.show_close = show_close
+        self.setMouseTracking(True)
+
+    def _layout(self):
+        w = self.width()
+        # Buttons are laid right to left. With a close button present it
+        # takes the rightmost slot; otherwise minimize and maximize fill the
+        # two slots next to the edge, as on Windows.
+        right = w
+        if self.show_close:
+            self._close_rect = QRectF(
+                right - _BUTTON_WIDTH, 0, _BUTTON_WIDTH, self.height()
+            )
+            right -= _BUTTON_WIDTH
+        self._max_rect = QRectF(
+            right - _BUTTON_WIDTH, 0, _BUTTON_WIDTH, self.height()
+        )
+        self._min_rect = QRectF(
+            right - 2 * _BUTTON_WIDTH, 0, _BUTTON_WIDTH, self.height()
+        )
+
+    def is_over_buttons(self, pos):
+        """True when a window-coordinate point hits a control button."""
+        for rect in (self._min_rect, self._max_rect, self._close_rect):
+            if rect.contains(pos):
+                return True
+        return False
+
+    def _button_at(self, pos):
+        for rect, name in (
+            (self._min_rect, "min"),
+            (self._max_rect, "max"),
+            (self._close_rect, "close"),
+        ):
+            if rect.contains(pos):
+                return name
+        return None
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+
+        # Backing strip: translucent dark red so the bar reads clearly
+        # over any graph while the rest of the window stays see-through.
+        painter.fillRect(self.rect(), QColor(45, 10, 10, 220))
+        # A red accent line along the bottom so the bar's edge stays
+        # visible even over a black background.
+        painter.fillRect(
+            0, self.height() - 2, self.width(), 2, QColor(255, 90, 90, 220)
+        )
+
+        # App name.
+        font = QFont()
+        font.setPointSize(9)
+        font.setBold(True)
+        painter.setFont(font)
+        painter.setPen(QColor(235, 235, 235))
+        # Reserve room for the buttons on the right; three when a close
+        # button is shown, two otherwise.
+        button_span = _BUTTON_WIDTH * (3 if self.show_close else 2)
+        painter.drawText(
+            QRectF(10, 0, self.width() - button_span - 20, self.height()),
+            Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft,
+            "PlotRuler",
+        )
+
+        self._draw_minimize(painter)
+        self._draw_maximize(painter)
+        if self.show_close:
+            self._draw_close(painter)
+
+    def _draw_minimize(self, painter):
+        if self._hover_button == "min":
+            painter.fillRect(self._min_rect, _HOVER_BG)
+        painter.setPen(QPen(_GLYPH, 2))
+        y = self._min_rect.center().y()
+        painter.drawLine(
+            QPointF(self._min_rect.x() + 14, y),
+            QPointF(self._min_rect.right() - 14, y),
+        )
+
+    def _draw_maximize(self, painter):
+        if self._hover_button == "max":
+            painter.fillRect(self._max_rect, _HOVER_BG)
+        painter.setPen(QPen(_GLYPH, 2))
+        rect = self._max_rect
+        if self.window().is_maximized():
+            # Restore icon: two overlapping squares.
+            painter.drawRect(QRectF(rect.x() + 9, rect.y() + 13, 14, 14))
+            painter.drawRect(QRectF(rect.x() + 13, rect.y() + 9, 14, 14))
+        else:
+            painter.drawRect(QRectF(rect.x() + 12, rect.y() + 9, 16, 16))
+
+    def _draw_close(self, painter):
+        """Draw an X glyph for the close button."""
+        if self._hover_button == "close":
+            painter.fillRect(self._close_rect, _HOVER_BG)
+        painter.setPen(QPen(_GLYPH, 2))
+        rect = self._close_rect
+        x = rect.center().x()
+        y = rect.center().y()
+        painter.drawLine(QPointF(x - 7, y - 7), QPointF(x + 7, y + 7))
+        painter.drawLine(QPointF(x - 7, y + 7), QPointF(x + 7, y - 7))
+
+    def mousePressEvent(self, event):
+        if event.button() != Qt.MouseButton.LeftButton:
+            return
+        if not win_hittest._IS_WINDOWS:
+            # On X11 there is no WM_NCHITTEST, so a press on an edge zone
+            # resizes and a press on the bar moves the window itself. Ask
+            # Qt to drive the gesture directly.
+            edges = self._resize_edges(event.position())
+            if edges is not None:
+                self.window().windowHandle().startSystemResize(edges)
+                event.accept()
+                return
+            if self._button_at(event.position()) is None:
+                self.window().windowHandle().startSystemMove()
+                event.accept()
+                return
+        # Remember which button was pressed, but do not act yet. Acting on
+        # press would let the button's release fall through to whatever
+        # window is underneath once we quit (see mouseReleaseEvent), which
+        # is how a click on PlotRuler's close button could also close the
+        # app beneath it.
+        self._pressed_button = self._button_at(event.position())
+        event.accept()
+
+    def _resize_edges(self, pos):
+        """Return the Qt.Edges for a top-edge resize at a titlebar point,
+        or None.
+
+        The titlebar covers the top strip, so the top border's resize zones
+        land here rather than in the overlay's mousePressEvent. Top corners
+        combine a vertical edge with a horizontal one; the middle of the bar
+        is a move, handled by the caller as a plain drag.
+        """
+        w = self.width()
+        x, y = pos.x(), pos.y()
+        if y >= _RESIZE_ZONE:
+            return None
+        edges = Qt.Edges()
+        if x < _RESIZE_ZONE:
+            edges |= Qt.Edge.LeftEdge
+        elif x >= w - _RESIZE_ZONE:
+            edges |= Qt.Edge.RightEdge
+        edges |= Qt.Edge.TopEdge
+        return edges
+
+    def mouseReleaseEvent(self, event):
+        if event.button() != Qt.MouseButton.LeftButton:
+            return
+        # Only act if the press began on the same button, so a click that
+        # starts elsewhere and ends here (or vice versa) does not fire.
+        button = self._button_at(event.position())
+        if button != self._pressed_button:
+            self._pressed_button = None
+            event.accept()
+            return
+        self._pressed_button = None
+        event.accept()
+        if button == "min":
+            self.window().minimize_to_tray()
+        elif button == "max":
+            self.window().toggle_maximize()
+        elif button == "close":
+            # On no-tray platforms there is no way back after hiding, so
+            # close really quits rather than depositing a ghost overlay.
+            self.window().quit()
+
+    def mouseMoveEvent(self, event):
+        hover = self._button_at(event.position())
+        if hover != self._hover_button:
+            self._hover_button = hover
+            self.update()
+
+    def leaveEvent(self, event):
+        self._hover_button = None
+        self.update()
+
+    def resizeEvent(self, event):
+        self._layout()
+        super().resizeEvent(event)
+
+    def sizeHint(self):
+        return QSizeF(0, TITLEBAR_HEIGHT).toSize()

plotruler/tray.py

@@ -0,0 +1,179 @@
+"""System tray icon for the resident overlay app.
+
+The overlay is an always-on-top window, but it still needs a home in the
+taskbar tray so it can be summoned and dismissed and quit without being
+visible. This module builds the tray icon (drawn programmatically so no
+image asset is needed) and wires a small context menu: show/hide, start a
+new calibration, and quit.
+"""
+
+from PySide6.QtCore import QObject, QPointF, QRect, QRectF, Qt
+from PySide6.QtGui import (
+    QAction,
+    QActionGroup,
+    QColor,
+    QIcon,
+    QPainter,
+    QPixmap,
+)
+from PySide6.QtWidgets import QMenu, QSystemTrayIcon
+
+from .format import NAMES, OPTIONS
+
+# Accent colors matching the overlay so the tray icon feels consistent.
+# The icon cyan is brighter than the overlay's so the crosshair arms have
+# similar luminance (the amber Y-arm would otherwise outshine it).
+_TRAY_RED_BG = QColor(90, 30, 30)
+_ICON_CYAN = QColor(140, 230, 255)
+_AMBER = QColor(255, 200, 80)
+_LIGHT = QColor(235, 235, 235)
+
+
+def make_icon(size=64):
+    """Build a PlotRuler tray icon.
+
+    A dark rounded tile with a graph-axes L (light) and a crosshair whose
+    two arms are the app's X/Y accent colors. The crosshair is the focal
+    point so the icon still reads as 'measure a point on a graph' at the
+    tiny size Windows tray icons render.
+
+    Everything is drawn on even pixel coordinates with integer rects so
+    the icon downsamples symmetrically: the crosshair sits at the tile's
+    center and each arm is exactly 4px thick, so at 16px the two arms
+    land on the same 1-pixel column/row and stay equally bright.
+
+    `size` is the render canvas in pixels. The layout is tuned for 64px
+    and scaled up proportionally for other sizes (e.g. a high-res icon
+    for the packaged executable).
+    """
+    k = size // 64
+    pixmap = QPixmap(size, size)
+    pixmap.fill(Qt.GlobalColor.transparent)
+
+    painter = QPainter(pixmap)
+    painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+
+    # Dark rounded tile so the light strokes pop on the taskbar tray.
+    painter.setPen(Qt.PenStyle.NoPen)
+    painter.setBrush(_TRAY_RED_BG)
+    painter.drawRoundedRect(QRectF(0, 0, size, size), 14 * k, 14 * k)
+
+    # Graph axes: a light L along the bottom and left. Rects are
+    # integer-aligned and 4px thick, symmetric about their center.
+    painter.setPen(Qt.PenStyle.NoPen)
+    painter.fillRect(QRect(8 * k, 52 * k, 48 * k, 4 * k), _LIGHT)  # x-axis
+    painter.fillRect(QRect(8 * k, 8 * k, 4 * k, 48 * k), _LIGHT)  # y-axis
+
+    # Crosshair arms: identical 4px-thick integer rects. The center is at
+    # 34 (not 32) because the 64->16 downsampler bins the canvas into 4x4
+    # blocks; an arm centered on 32 spans rows 30-33 and straddles two bins,
+    # lighting up two 16px rows. Centering on 34 (= 4*8 + 2) puts each arm
+    # wholly inside one bin, so both arms are single symmetric pixels.
+    thickness = 4 * k
+    half = 10 * k
+    t2 = thickness // 2
+    cx = cy = 34 * k
+    painter.fillRect(
+        QRect(cx - half, cy - t2, half * 2, thickness), _ICON_CYAN
+    )  # X arm (horizontal)
+    painter.fillRect(
+        QRect(cx - t2, cy - half, thickness, half * 2), _AMBER
+    )  # Y arm (vertical)
+
+    # A small light center dot so the crosshair reads as one target.
+    painter.setBrush(_LIGHT)
+    painter.drawEllipse(QPointF(cx, cy), 2.0 * k, 2.0 * k)
+
+    painter.end()
+    return QIcon(pixmap)
+
+
+class TrayIcon(QObject):
+    """Owns the system tray icon and its menu, tied to the overlay window."""
+
+    def __init__(self, window, on_change_hotkey=None, parent=None):
+        super().__init__(parent)
+        self._window = window
+        self._on_change_hotkey = on_change_hotkey
+        self._tray = QSystemTrayIcon(make_icon(), self)
+        self._menu = QMenu()
+
+        self._toggle_action = QAction("Show / Hide", self)
+        self._toggle_action.triggered.connect(self._window.toggle_visibility)
+        self._new_action = QAction("New Calibration", self)
+        self._new_action.triggered.connect(self._start_calibration)
+        self._hotkey_action = QAction("Change Hotkey…", self)
+        self._hotkey_action.triggered.connect(self._change_hotkey)
+        self._quit_action = QAction("Quit", self)
+        self._quit_action.triggered.connect(self._quit)
+
+        self._format_menu = QMenu("Number Format", self._menu)
+        self._format_group = QActionGroup(self._format_menu)
+        self._format_actions = {}
+        for index, fmt in enumerate(OPTIONS):
+            # Number each option the same way the keyboard selects it, so
+            # the menu and the number-key shortcuts always agree.
+            action = QAction(f"{index + 1}. {NAMES[fmt]}", self._format_menu)
+            action.setCheckable(True)
+            action.triggered.connect(
+                lambda _checked, key=fmt: self._choose_format(key)
+            )
+            self._format_group.addAction(action)
+            self._format_actions[fmt] = action
+            self._format_menu.addAction(action)
+        self._format_menu.aboutToShow.connect(self._sync_format_check)
+
+        self._menu.addAction(self._toggle_action)
+        self._menu.addSeparator()
+        self._menu.addAction(self._new_action)
+        self._menu.addAction(self._hotkey_action)
+        self._menu.addSeparator()
+        self._menu.addMenu(self._format_menu)
+        self._menu.addSeparator()
+        self._menu.addAction(self._quit_action)
+
+        self._tray.setContextMenu(self._menu)
+        self._tray.setToolTip("PlotRuler")
+        self._tray.activated.connect(self._on_activated)
+        self._tray.show()
+
+    def _change_hotkey(self):
+        if self._on_change_hotkey is not None:
+            self._on_change_hotkey()
+
+    def _choose_format(self, fmt):
+        """Apply a number format chosen from the tray menu."""
+        self._window.set_num_format(fmt)
+
+    def _sync_format_check(self):
+        """Re-check the menu item matching the overlay's current format.
+
+        The format can change via the number-key shortcuts while the
+        overlay is focused, so the menu must reflect the live selection
+        each time it opens rather than remembering a stale check.
+        """
+        current = getattr(self._window, "_num_format", OPTIONS[0])
+        for fmt, action in self._format_actions.items():
+            action.setChecked(fmt == current)
+
+    def _start_calibration(self):
+        self._window.show()
+        self._window.raise_()
+        self._window.activateWindow()
+        self._window.start_calibration()
+
+    def _on_activated(self, reason):
+        # A single left click on the icon toggles the overlay, matching the
+        # hotkey and the "Show / Hide" menu item.
+        if reason in (
+            QSystemTrayIcon.ActivationReason.Trigger,
+            QSystemTrayIcon.ActivationReason.DoubleClick,
+        ):
+            self._window.toggle_visibility()
+
+    def _quit(self):
+        # QApplication.quit() stops the event loop; the tray icon and window
+        # are then torn down by the application object's destructor.
+        from PySide6.QtWidgets import QApplication
+
+        QApplication.quit()