messageflight 0.2.4__py3-none-any.whl

message_flight/settings_dialog.py

@@ -0,0 +1,266 @@
+"""Modal settings dialog for editing the 9-color plane/banner palette and the flight mode preset."""
+from __future__ import annotations
+
+from typing import Optional
+
+from PyQt6.QtGui import QColor
+from PyQt6.QtWidgets import (
+    QComboBox,
+    QDialog,
+    QDialogButtonBox,
+    QFormLayout,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from message_flight.config import (
+    DEFAULT_THEME,
+    FLIGHT_MODE_NAMES,
+    FLIGHT_MODES,
+    THEMES,
+    VALID_FLY_PATHS,
+    AppConfig,
+)
+from message_flight.i18n import LANGUAGES, language_name, tr
+
+_COLOR_KEYS: tuple[str, ...] = (
+    "plane_color",
+    "wing_color",
+    "accent_color",
+    "decor_color",
+    "banner_color",
+    "text_color",
+    "thruster_outer_color",
+    "thruster_middle_color",
+    "thruster_inner_color",
+)
+
+_PRESET_KEYS: tuple[str, ...] = ("default", "retro", "cyber")
+
+
+class SettingsDialog(QDialog):
+    """A 9-row form for editing the plane color palette, plus 3 flight-mode + 3 color preset buttons.
+
+    The dialog does not mutate the live widget directly; the caller is
+    expected to call :meth:`get_result` after the dialog is accepted
+    and then forward the new colors to ``PlaneBanner.update_colors``.
+    """
+
+    def __init__(self, initial: AppConfig, parent: Optional[QWidget] = None):
+        super().__init__(parent)
+        self._language = initial.language
+        self.setWindowTitle(tr("settings.title", self._language))
+        self.setModal(True)
+
+        self._current_theme_name = initial.theme_name or DEFAULT_THEME
+        self._line_edits: dict[str, QLineEdit] = {}
+        self._swatches: dict[str, QLabel] = {}
+        self._current_flight_mode: str = initial.flight_mode
+        # Copy so external mutations to the AppConfig don't leak in/out.
+        self._current_flight_kwargs: dict = dict(initial.flight_kwargs)
+        self._flight_mode_buttons: dict[str, QPushButton] = {}
+
+        root = QVBoxLayout(self)
+
+        language_row = QHBoxLayout()
+        language_row.addWidget(QLabel(tr("settings.language", self._language)))
+        self._language_combo = QComboBox()
+        for language in LANGUAGES:
+            self._language_combo.addItem(language_name(language), language)
+        current_language_index = self._language_combo.findData(self._language)
+        self._language_combo.setCurrentIndex(max(0, current_language_index))
+        language_row.addWidget(self._language_combo)
+        language_row.addStretch(1)
+        root.addLayout(language_row)
+
+        # Flight-mode row (Task 06) — sits at the TOP, above the color preset row
+        flight_mode_row = QHBoxLayout()
+        flight_mode_row.addWidget(QLabel(tr("settings.flight_mode", self._language)))
+        for mode_name in FLIGHT_MODE_NAMES:
+            btn = QPushButton(mode_name)
+            btn.clicked.connect(
+                lambda _checked=False, name=mode_name: self._apply_flight_mode(name)
+            )
+            self._flight_mode_buttons[mode_name] = btn
+            flight_mode_row.addWidget(btn)
+        flight_mode_row.addStretch(1)
+        root.addLayout(flight_mode_row)
+
+        # Fly-path row
+        path_row = QHBoxLayout()
+        path_row.addWidget(QLabel(tr("settings.fly_path", self._language)))
+        self._path_combo = QComboBox()
+        for p in VALID_FLY_PATHS:
+            self._path_combo.addItem(p)
+        current_path = self._current_flight_kwargs.get("fly_path", "horizontal")
+        self._path_combo.setCurrentText(current_path)
+        self._path_combo.currentTextChanged.connect(self._on_path_changed)
+        path_row.addWidget(self._path_combo)
+        path_row.addStretch(1)
+        root.addLayout(path_row)
+
+        # Preset row
+        preset_row = QHBoxLayout()
+        preset_row.addWidget(QLabel(tr("settings.color_scheme", self._language)))
+        for theme_key in _PRESET_KEYS:
+            btn = QPushButton(tr(f"settings.preset.{theme_key}", self._language))
+            btn.clicked.connect(lambda _checked=False, key=theme_key: self._apply_preset(key))
+            preset_row.addWidget(btn)
+        preset_row.addStretch(1)
+        root.addLayout(preset_row)
+
+        # 9 color rows
+        form = QFormLayout()
+        for key in _COLOR_KEYS:
+            edit = QLineEdit(self)
+            swatch = QLabel(self)
+            swatch.setFixedSize(28, 18)
+            swatch.setFrameShape(QLabel.Shape.StyledPanel)
+
+            current = initial.colors.get(key, THEMES[self._current_theme_name].get(key, "#FFFFFF"))
+            edit.setText(current)
+            self._line_edits[key] = edit
+            self._swatches[key] = swatch
+            edit.textChanged.connect(lambda text, k=key: self._on_text_changed(k, text))
+
+            row_widget = QWidget()
+            row_layout = QHBoxLayout(row_widget)
+            row_layout.setContentsMargins(0, 0, 0, 0)
+            row_layout.addWidget(edit)
+            row_layout.addWidget(swatch)
+            form.addRow(tr(f"settings.color.{key}", self._language), row_widget)
+
+        root.addLayout(form)
+
+        # TTS Provider row
+        provider_row = QHBoxLayout()
+        provider_row.addWidget(QLabel(tr("settings.tts_engine", self._language)))
+        self._provider_combo = QComboBox()
+        for p in ("sapi", "minimax"):
+            self._provider_combo.addItem(p)
+        self._provider_combo.setCurrentText(initial.tts_provider)
+        self._provider_combo.currentTextChanged.connect(self._on_provider_changed)
+        provider_row.addWidget(self._provider_combo)
+        provider_row.addStretch(1)
+        root.addLayout(provider_row)
+
+        # API Key (enabled only for minimax)
+        self._api_key_label = QLabel(tr("settings.minimax_key", self._language))
+        self._api_key_edit = QLineEdit(initial.minimax_subscription_key)
+        self._api_key_edit.setPlaceholderText(tr("settings.minimax_key_placeholder", self._language))
+        form.addRow(self._api_key_label, self._api_key_edit)
+        self._update_api_key_enabled(initial.tts_provider)
+
+        # OK / Cancel
+        self._button_box = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel,
+            parent=self,
+        )
+        self._button_box.accepted.connect(self.accept)
+        self._button_box.rejected.connect(self.reject)
+        root.addWidget(self._button_box)
+
+        # Initial render
+        self._refresh_all_swatches()
+        self._refresh_ok_enabled()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def get_result(self) -> AppConfig:
+        """Return the current dialog state as an :class:`AppConfig`.
+
+        Safe to call only after the dialog has been accepted (or while
+        it is still open and the user is editing). The returned colors
+        are normalized via :meth:`QColor.name` so the values match the
+        ``PlaneBanner.update_colors`` contract.
+        """
+        colors: dict[str, str] = {}
+        for key in self._line_edits:
+            text = self._line_edits[key].text().strip()
+            qc = QColor(text)
+            colors[key] = qc.name() if qc.isValid() else text
+        return AppConfig(
+            theme_name=self._current_theme_name,
+            colors=colors,
+            flight_mode=self._current_flight_mode,
+            flight_kwargs=dict(self._current_flight_kwargs),
+            tts_provider=self._provider_combo.currentText(),
+            minimax_subscription_key=self._api_key_edit.text(),
+            language=self._language_combo.currentData(),
+        )
+
+    # ------------------------------------------------------------------
+    # Internals
+    # ------------------------------------------------------------------
+
+    def _on_text_changed(self, key: str, text: str) -> None:
+        """Live-validate a single field; update its swatch + OK button."""
+        swatch = self._swatches[key]
+        qc = QColor(text)
+        if qc.isValid():
+            swatch.setStyleSheet(f"background-color: {qc.name()};")
+        else:
+            swatch.setStyleSheet("background-color: #888888;")
+        self._refresh_ok_enabled()
+
+    def _refresh_all_swatches(self) -> None:
+        for key, edit in self._line_edits.items():
+            self._on_text_changed(key, edit.text())
+
+    def _refresh_ok_enabled(self) -> None:
+        all_valid = all(
+            QColor(edit.text()).isValid() for edit in self._line_edits.values()
+        )
+        ok_btn = self._button_box.button(QDialogButtonBox.StandardButton.Ok)
+        if ok_btn is not None:
+            ok_btn.setEnabled(all_valid)
+
+    def _apply_preset(self, theme_key: str) -> None:
+        """Fill all 9 QLineEdits with a preset and refresh swatches."""
+        if theme_key not in THEMES:
+            return
+        self._current_theme_name = theme_key
+        for key, value in THEMES[theme_key].items():
+            if key in self._line_edits:
+                self._line_edits[key].setText(value)
+        # _on_text_changed is fired automatically by setText, but the OK
+        # button state must be re-evaluated once at the end.
+        self._refresh_ok_enabled()
+
+    def _on_path_changed(self, text: str) -> None:
+        """Update the fly_path inside the current flight kwargs."""
+        self._current_flight_kwargs["fly_path"] = text
+
+    def _on_provider_changed(self, text: str) -> None:
+        """Enable/disable API Key input based on provider selection."""
+        self._update_api_key_enabled(text)
+
+    def _update_api_key_enabled(self, provider: str) -> None:
+        """API Key is only needed for minimax."""
+        is_minimax = provider == "minimax"
+        self._api_key_label.setEnabled(is_minimax)
+        self._api_key_edit.setEnabled(is_minimax)
+
+    def _apply_flight_mode(self, mode_name: str) -> None:
+        """Switch to a named flight mode preset (flight params only).
+
+        Looks up the preset in :data:`FLIGHT_MODES` and records the
+        mode's flight kwargs in :attr:`_current_flight_kwargs` so a
+        subsequent call to :meth:`get_result` returns a complete
+        :class:`AppConfig`.  Color fields are NOT touched.
+
+        The live :class:`FlightWidget` is NOT updated here — the new
+        flight kwargs take effect on the next application restart (a
+        "重启生效" label next to the mode row makes this clear to the
+        user).
+        """
+        if mode_name not in FLIGHT_MODES:
+            return
+        self._current_flight_mode = mode_name
+        self._current_flight_kwargs = dict(FLIGHT_MODES[mode_name])

message_flight/tray_app.py

@@ -0,0 +1,280 @@
+"""System tray icon, context menu, and application lifecycle."""
+import logging
+import random
+import sys
+
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QAction, QColor, QIcon, QPainter, QPainterPath, QPixmap, QPixmapCache
+from PyQt6.QtWidgets import QApplication, QDialog, QMenu, QSystemTrayIcon
+
+from message_flight.autostart import is_auto_start_enabled, set_auto_start
+from message_flight.config import is_dnd_active, load_config, save_config
+from message_flight.demo_notifications import NOTIFICATIONS
+from message_flight.flight_widget import FlightWidget
+from message_flight.i18n import tr
+from message_flight.notification_worker import WINSOK_AVAILABLE, NotificationWorker
+from message_flight.preset_editor import PresetEditorWindow
+from message_flight.settings_dialog import SettingsDialog
+from message_flight.tts_manager import TTSManager
+
+logger = logging.getLogger(__name__)
+
+
+class TrayApplication:
+    def __init__(self) -> None:
+        QApplication.setHighDpiScaleFactorRoundingPolicy(
+            Qt.HighDpiScaleFactorRoundingPolicy.PassThrough
+        )
+        self.app = QApplication(sys.argv)
+        self.app.setQuitOnLastWindowClosed(False)
+        # Limit Qt internal pixmap cache to prevent memory growth over long runs
+        QPixmapCache.setCacheLimit(1024 * 50)  # 50 MB
+
+        # Load persisted color scheme and hand it to the widget
+        self.cfg = load_config()
+        self.language = self.cfg.language
+        self.widget: FlightWidget = FlightWidget(plane_colors=self.cfg.colors, **self.cfg.flight_kwargs)
+
+        self.tts = TTSManager(self.cfg)
+
+        # 系统托盘
+        self.tray_icon = QSystemTrayIcon(self._create_tray_icon(), self.app)
+        self.tray_icon.setToolTip("MessageFlight")
+
+        self.menu = QMenu()
+
+        self.action_show = QAction(tr("tray.show", self.language), self.menu)
+        self.action_show.triggered.connect(self._show_widget)
+        self.menu.addAction(self.action_show)
+
+        self.action_pause = QAction(tr("tray.pause", self.language), self.menu)
+        self.action_pause.setCheckable(True)
+        self.action_pause.triggered.connect(self._toggle_pause)
+        self.menu.addAction(self.action_pause)
+
+        self.action_demo = QAction(tr("tray.demo", self.language), self.menu)
+        self.action_demo.triggered.connect(self._send_demo_notification)
+        self.menu.addAction(self.action_demo)
+
+        # 免打扰模式（manual toggle only; scheduled window is read-only here）
+        self.action_dnd = QAction(tr("tray.dnd", self.language), self.menu)
+        self.action_dnd.setCheckable(True)
+        self.action_dnd.setChecked(self.cfg.dnd_enabled)
+        self.action_dnd.triggered.connect(self._toggle_dnd)
+        self.menu.addAction(self.action_dnd)
+
+        self.action_settings = QAction(tr("tray.settings", self.language), self.menu)
+        self.action_settings.triggered.connect(self._open_settings)
+        self.menu.addAction(self.action_settings)
+
+        self.action_preset_editor = QAction(tr("tray.preset_editor", self.language), self.menu)
+        self.action_preset_editor.triggered.connect(self._open_preset_editor)
+        self.menu.addAction(self.action_preset_editor)
+
+        self.menu.addSeparator()
+
+        # 通知权限状态
+        self.action_notif_status = QAction(tr("tray.notification_status.checking", self.language), self.menu)
+        self.action_notif_status.setEnabled(False)
+        self.menu.addAction(self.action_notif_status)
+
+        self.menu.addSeparator()
+
+        self.action_autostart = QAction(tr("tray.autostart", self.language), self.menu)
+        self.action_autostart.setCheckable(True)
+        self.action_autostart.setChecked(is_auto_start_enabled())
+        self.action_autostart.triggered.connect(self._toggle_autostart)
+        self.menu.addAction(self.action_autostart)
+
+        self.menu.addSeparator()
+
+        self.action_quit = QAction(tr("tray.quit", self.language), self.menu)
+        self.action_quit.triggered.connect(self._quit)
+        self.menu.addAction(self.action_quit)
+
+        self.tray_icon.setContextMenu(self.menu)
+        self.tray_icon.activated.connect(self._on_tray_activated)
+        self.tray_icon.show()
+
+        # 启动通知监听线程
+        self.notifier = None
+        if WINSOK_AVAILABLE:
+            self.notifier = NotificationWorker()
+            self.notifier.notification_received.connect(self._on_real_notification)
+            self.notifier.access_status_changed.connect(self._on_access_status)
+            self.notifier.start()
+        else:
+            self.action_notif_status.setText(tr("tray.notification_status.unavailable", self.language))
+
+    def _create_tray_icon(self) -> QIcon:
+        size = 64
+        pixmap = QPixmap(size, size)
+        pixmap.fill(Qt.GlobalColor.transparent)
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.scale(size / 80, size / 80)
+
+        c = QColor("#FF69B4")
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(c)
+        painter.drawEllipse(10, 18, 45, 22)
+        painter.drawEllipse(48, 19, 14, 20)
+
+        wing = QColor("#FF1493")
+        painter.setBrush(wing)
+        wp = QPainterPath()
+        wp.moveTo(25, 25)
+        wp.lineTo(15, 8)
+        wp.lineTo(35, 8)
+        wp.lineTo(40, 25)
+        wp.closeSubpath()
+        painter.drawPath(wp)
+
+        tp = QPainterPath()
+        tp.moveTo(12, 28)
+        tp.lineTo(2, 18)
+        tp.lineTo(12, 22)
+        tp.closeSubpath()
+        painter.drawPath(tp)
+
+        painter.setBrush(QColor("#FFFFFF"))
+        painter.drawEllipse(52, 24, 6, 6)
+        painter.drawEllipse(38, 24, 5, 5)
+        painter.end()
+        return QIcon(pixmap)
+
+    def _show_widget(self):
+        self.widget.show()
+        self.widget.raise_()
+        self.widget.activateWindow()
+
+    def _refresh_translated_labels(self) -> None:
+        self.action_show.setText(tr("tray.show", self.language))
+        self.action_pause.setText(
+            tr("tray.resume", self.language) if self.action_pause.isChecked() else tr("tray.pause", self.language)
+        )
+        self.action_demo.setText(tr("tray.demo", self.language))
+        self.action_dnd.setText(tr("tray.dnd", self.language))
+        self.action_settings.setText(tr("tray.settings", self.language))
+        self.action_preset_editor.setText(tr("tray.preset_editor", self.language))
+        self.action_autostart.setText(tr("tray.autostart", self.language))
+        self.action_quit.setText(tr("tray.quit", self.language))
+
+    def _toggle_pause(self, checked: bool):
+        self.widget.set_paused(checked)
+        self.action_pause.setText(
+            tr("tray.resume", self.language) if checked else tr("tray.pause", self.language)
+        )
+
+    def _toggle_dnd(self, checked: bool):
+        """Toggle manual Do-Not-Disturb and persist the choice."""
+        self.cfg.dnd_enabled = bool(checked)
+        try:
+            save_config(self.cfg)
+        except Exception as e:
+            logger.warning("Failed to persist DND toggle: %s", e)
+
+    def _toggle_autostart(self, checked: bool):
+        try:
+            set_auto_start(checked)
+        except Exception as e:
+            self.action_autostart.setChecked(not checked)
+            print(f"设置开机自启失败: {e}")
+
+    def _on_tray_activated(self, reason):
+        if reason == QSystemTrayIcon.ActivationReason.DoubleClick:
+            self._show_widget()
+
+    def _on_real_notification(self, app_name: str, text: str):
+        """收到真实系统通知（受 DND 控制；演示通知不受影响）"""
+        if is_dnd_active(self.cfg):
+            logger.info("[DND] Suppressed real notification from %s", app_name)
+            return
+        display = f"[{app_name}] {text}"
+        # 截断过长的文本
+        if len(display) > 80:
+            display = display[:77] + "..."
+        logger.info("[Real Notification] %s", display)
+        self.tts.speak(display)
+        self.widget.enqueue_notification(display)
+        self._show_widget()
+
+    def _on_access_status(self, status: int):
+        """通知权限状态更新"""
+        labels = {
+            0: tr("status.unspecified", self.language),
+            1: tr("status.allowed", self.language),
+            2: tr("status.denied", self.language),
+        }
+        self.action_notif_status.setText(
+            tr(
+                "tray.notification_status",
+                self.language,
+                label=labels.get(status, tr("status.unknown", self.language)),
+                status=status,
+            )
+        )
+
+    def _send_demo_notification(self):
+        """Pick a random demo notification, speak it, and fire it on the widget.
+
+        Demo notifications bypass DND so the user can always test the
+        notification path even when real notifications are silenced.
+        """
+        text = random.choice(NOTIFICATIONS)
+        logger.info("[Demo Notification] %s", text)
+        self.tts.speak(text)
+        self.widget.enqueue_notification(text)
+
+    def _open_settings(self):
+        """Open the settings dialog (color scheme + flight mode). On accept, save config and apply changes."""
+        dlg = SettingsDialog(load_config(), self.menu)
+        if dlg.exec() == QDialog.DialogCode.Accepted:
+            new_cfg = dlg.get_result()
+            save_config(new_cfg)
+            self.cfg = new_cfg
+            self.language = new_cfg.language
+            self._refresh_translated_labels()
+            self.widget.plane.update_colors(**new_cfg.colors)
+            self.widget.set_flight_kwargs(**new_cfg.flight_kwargs)
+            self.tts.update_config(new_cfg)
+
+    def _open_preset_editor(self):
+        cfg = load_config()
+        dlg = PresetEditorWindow(cfg, self.menu)
+        if dlg.exec() == QDialog.DialogCode.Accepted:
+            preset_key, params_json = dlg.get_result()
+            cfg.plane_preset_key = preset_key
+            cfg.plane_preset_params_json = params_json
+            save_config(cfg)
+            self._apply_preset_to_widget(preset_key, params_json)
+
+    def _apply_preset_to_widget(self, preset_key: str, params_json: str) -> None:
+        import dataclasses
+        import json
+
+        from message_flight.plane_presets import get_preset
+        preset = get_preset(preset_key)
+        if params_json:
+            try:
+                data = json.loads(params_json)
+                default = preset.get_default_params()
+                params = dataclasses.replace(
+                    default,
+                    **{k: v for k, v in data.items() if hasattr(default, k)},
+                )
+            except (json.JSONDecodeError, TypeError):
+                params = preset.get_default_params()
+        else:
+            params = preset.get_default_params()
+        self.widget.plane.apply_preset(preset, params)
+
+    def _quit(self):
+        if self.notifier:
+            self.notifier.stop()
+        self.app.quit()
+
+    def run(self):
+        print("MessageFlight started!")
+        print("ESC: 隐藏窗口  |  托盘图标: 右键菜单 / 双击显示")
+        sys.exit(self.app.exec())