frontengine 1.0.47__tar.gz → 1.0.49__tar.gz

{frontengine-1.0.47 → frontengine-1.0.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: frontengine
-Version: 1.0.47
+Version: 1.0.49
 Summary: FrontEngine is use-define frontview or only use like screen saver
 Author-email: JE-Chen <jechenmailman@gmail.com>
 Project-URL: Homepage, https://github.com/Intergration-Automation-Testing/FrontEngine
@@ -204,6 +204,21 @@ Four things on the **Stream** tab, for playing and for going live:
 
 ---
 
+## Signage, whiteboard and lip-sync
+
+- **Signage mode** (Settings) — rotate through a list of presets on a timer and
+  put the main window away, for a machine left running as a display. The
+  rotation wraps, so it keeps cycling.
+- **Whiteboard** (Presenting tab) — an infinite canvas: drag with the middle
+  button to pan, scroll to zoom, and save what you drew as an image. Strokes
+  live in canvas coordinates, so panning and zooming leaves them where they
+  belong.
+- **Pet lip-sync** — the pet can react to your **microphone** instead of your
+  speakers, so it moves while you talk. Like the speaker reaction this reads
+  only the meter — a number, not sound. Windows only.
+
+---
+
 ## Remote control
 
 From **Settings → Remote control**:

{frontengine-1.0.47 → frontengine-1.0.49}/README.md

@@ -180,6 +180,21 @@ Four things on the **Stream** tab, for playing and for going live:
 
 ---
 
+## Signage, whiteboard and lip-sync
+
+- **Signage mode** (Settings) — rotate through a list of presets on a timer and
+  put the main window away, for a machine left running as a display. The
+  rotation wraps, so it keeps cycling.
+- **Whiteboard** (Presenting tab) — an infinite canvas: drag with the middle
+  button to pan, scroll to zoom, and save what you drew as an image. Strokes
+  live in canvas coordinates, so panning and zooming leaves them where they
+  belong.
+- **Pet lip-sync** — the pet can react to your **microphone** instead of your
+  speakers, so it moves while you talk. Like the speaker reaction this reads
+  only the meter — a number, not sound. Windows only.
+
+---
+
 ## Remote control
 
 From **Settings → Remote control**:

frontengine-1.0.49/frontengine/show/canvas/whiteboard_widget.py

@@ -0,0 +1,243 @@
+"""
+無限畫布白板：可以一直往外畫、拖曳平移、滾輪縮放，最後存成圖片。
+
+和簡報分頁的塗鴉層不同的是，筆畫存的是「畫布座標」而不是螢幕座標，所以平移
+縮放之後線條還在它原本該在的地方——這正是「無限」的意思。
+
+An infinite whiteboard: keep drawing outwards, drag to pan, scroll to zoom, and
+save the result as an image.
+
+Unlike the presenting page's annotation layer, strokes are stored in canvas
+coordinates rather than screen ones, so panning and zooming leaves them where
+they belong - which is what makes it infinite.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from PySide6.QtCore import QPoint, QPointF, QRectF, Qt
+from PySide6.QtGui import QColor, QImage, QPainter, QPen
+
+from frontengine.show.base_widget import BaseWidget
+from frontengine.show.window_helpers import apply_overlay_window_flags
+from frontengine.utils.logging.loggin_instance import front_engine_logger
+
+DEFAULT_COLOR = "#ffd54f"
+DEFAULT_WIDTH = 4
+MIN_ZOOM = 0.2
+MAX_ZOOM = 5.0
+ZOOM_STEP = 1.15
+_SAVE_MARGIN = 24
+
+
+def clamp_zoom(value: Any, fallback: float = 1.0) -> float:
+    """縮放倍率夾在看得清楚又不會迷路的範圍。"""
+    try:
+        return max(MIN_ZOOM, min(MAX_ZOOM, float(value)))
+    except (TypeError, ValueError):
+        return fallback
+
+
+def to_canvas(point: Tuple[float, float], offset: Tuple[float, float], zoom: float) -> Tuple[float, float]:
+    """螢幕座標 -> 畫布座標。"""
+    scale = clamp_zoom(zoom)
+    return ((point[0] - offset[0]) / scale, (point[1] - offset[1]) / scale)
+
+
+def to_screen(point: Tuple[float, float], offset: Tuple[float, float], zoom: float) -> Tuple[float, float]:
+    """畫布座標 -> 螢幕座標。"""
+    scale = clamp_zoom(zoom)
+    return (point[0] * scale + offset[0], point[1] * scale + offset[1])
+
+
+def content_bounds(strokes: List[Dict[str, Any]]) -> Optional[Tuple[float, float, float, float]]:
+    """
+    所有筆畫涵蓋的畫布範圍 (left, top, right, bottom)；沒有筆畫回傳 None。
+    存檔時用它決定要輸出多大，才不會存出一大片空白。
+    The canvas area the strokes cover, or None when there are none. Saving uses
+    it to size the image, so the result is not mostly blank.
+    """
+    points = [point for stroke in strokes for point in stroke.get("points", [])]
+    if not points:
+        return None
+    xs = [point[0] for point in points]
+    ys = [point[1] for point in points]
+    return (min(xs), min(ys), max(xs), max(ys))
+
+
+class WhiteboardWidget(BaseWidget):
+    """
+    無限畫布。筆畫以畫布座標保存，畫的時候才換算成螢幕座標。
+    """
+
+    def __init__(self, color: str = DEFAULT_COLOR, width: int = DEFAULT_WIDTH) -> None:
+        front_engine_logger.info("[WhiteboardWidget] Init")
+        super().__init__()
+        candidate = QColor(color)
+        self.color = candidate if candidate.isValid() else QColor(DEFAULT_COLOR)
+        self.pen_width = max(1, int(width))
+        self.opacity = 1.0
+        self.overlay_lockable = False
+        self.strokes: List[Dict[str, Any]] = []
+        self.zoom = 1.0
+        self.offset = [0.0, 0.0]
+        self._stroke: Optional[Dict[str, Any]] = None
+        self._pan_origin: Optional[QPoint] = None
+        apply_overlay_window_flags(self, show_on_bottom=False, allow_input=True)
+
+    # --- drawing ---------------------------------------------------------
+    def begin_stroke(self, point: QPoint) -> None:
+        """開始一筆。"""
+        self._stroke = {"color": self.color.name(), "width": self.pen_width,
+                        "points": [to_canvas((point.x(), point.y()), self.offset, self.zoom)]}
+
+    def extend_stroke(self, point: QPoint) -> None:
+        if self._stroke is not None:
+            self._stroke["points"].append(to_canvas((point.x(), point.y()), self.offset, self.zoom))
+            self.update()
+
+    def end_stroke(self) -> bool:
+        """
+        收筆。只有一個點的「筆畫」是誤點，丟掉不留。
+        Finish. A one-point stroke is a stray click and is discarded.
+        """
+        stroke, self._stroke = self._stroke, None
+        if stroke is None or len(stroke["points"]) < 2:
+            return False
+        self.strokes.append(stroke)
+        self.update()
+        return True
+
+    def undo(self) -> bool:
+        """收回最後一筆。"""
+        if not self.strokes:
+            return False
+        self.strokes.pop()
+        self.update()
+        return True
+
+    def clear(self) -> None:
+        self.strokes = []
+        self._stroke = None
+        self.update()
+
+    def set_pen(self, color: Optional[str] = None, width: Optional[int] = None) -> None:
+        if color is not None:
+            candidate = QColor(color)
+            if candidate.isValid():
+                self.color = candidate
+        if width is not None:
+            self.pen_width = max(1, int(width))
+
+    # --- navigating ------------------------------------------------------
+    def pan(self, dx: float, dy: float) -> None:
+        """平移畫布。"""
+        self.offset[0] += float(dx)
+        self.offset[1] += float(dy)
+        self.update()
+
+    def zoom_at(self, point: QPoint, factor: float) -> float:
+        """
+        以游標為中心縮放：游標底下的那一點在縮放前後要停在原地，
+        不然放大時畫面會整個跑掉。
+        Zoom around the cursor so whatever is under it stays put; otherwise the
+        view lurches away every time you zoom.
+        """
+        before = to_canvas((point.x(), point.y()), self.offset, self.zoom)
+        self.zoom = clamp_zoom(self.zoom * float(factor))
+        after = to_screen(before, self.offset, self.zoom)
+        self.offset[0] += point.x() - after[0]
+        self.offset[1] += point.y() - after[1]
+        self.update()
+        return self.zoom
+
+    def reset_view(self) -> None:
+        """回到原點與原始比例（筆畫都還在）。"""
+        self.zoom = 1.0
+        self.offset = [0.0, 0.0]
+        self.update()
+
+    # --- events ----------------------------------------------------------
+    def mousePressEvent(self, event) -> None:
+        if event.button() == Qt.MouseButton.LeftButton:
+            self.begin_stroke(event.position().toPoint())
+        elif event.button() == Qt.MouseButton.MiddleButton:
+            self._pan_origin = event.position().toPoint()
+        super().mousePressEvent(event)
+
+    def mouseMoveEvent(self, event) -> None:
+        point = event.position().toPoint()
+        if self._pan_origin is not None:
+            self.pan(point.x() - self._pan_origin.x(), point.y() - self._pan_origin.y())
+            self._pan_origin = point
+        else:
+            self.extend_stroke(point)
+        super().mouseMoveEvent(event)
+
+    def mouseReleaseEvent(self, event) -> None:
+        if event.button() == Qt.MouseButton.MiddleButton:
+            self._pan_origin = None
+        else:
+            self.end_stroke()
+        super().mouseReleaseEvent(event)
+
+    def wheelEvent(self, event) -> None:
+        step = ZOOM_STEP if event.angleDelta().y() > 0 else 1.0 / ZOOM_STEP
+        self.zoom_at(event.position().toPoint(), step)
+
+    # --- output ----------------------------------------------------------
+    def save_image(self, path: str) -> Optional[str]:
+        """
+        把所有筆畫存成一張圖（只涵蓋畫過的範圍）。沒有筆畫就不存，回傳 None。
+        Save the strokes as an image covering only the area drawn on. Nothing
+        drawn means nothing saved.
+        """
+        bounds = content_bounds(self.strokes)
+        if bounds is None:
+            return None
+        left, top, right, bottom = bounds
+        width = int(right - left) + _SAVE_MARGIN * 2
+        height = int(bottom - top) + _SAVE_MARGIN * 2
+        image = QImage(max(1, width), max(1, height), QImage.Format.Format_ARGB32)
+        image.fill(Qt.GlobalColor.transparent)
+        painter = QPainter(image)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+        for stroke in self.strokes:
+            self._paint_stroke(painter, stroke,
+                               offset=(_SAVE_MARGIN - left, _SAVE_MARGIN - top), zoom=1.0)
+        painter.end()
+        target = Path(path)
+        try:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            if not image.save(str(target)):
+                return None
+        except OSError as error:
+            front_engine_logger.warning(f"[WhiteboardWidget] save failed: {error!r}")
+            return None
+        front_engine_logger.info(f"[WhiteboardWidget] saved | {target}")
+        return str(target)
+
+    def _paint_stroke(self, painter: QPainter, stroke: Dict[str, Any],
+                      offset, zoom: float) -> None:
+        points = stroke.get("points", [])
+        if len(points) < 2:
+            return
+        pen = QPen(QColor(stroke.get("color", DEFAULT_COLOR)),
+                   max(1.0, float(stroke.get("width", DEFAULT_WIDTH)) * zoom))
+        pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+        pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
+        painter.setPen(pen)
+        previous = to_screen(points[0], offset, zoom)
+        for point in points[1:]:
+            current = to_screen(point, offset, zoom)
+            painter.drawLine(QPointF(*previous), QPointF(*current))
+            previous = current
+
+    def draw_content(self, painter: QPainter) -> None:
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+        painter.fillRect(QRectF(self.rect()), QColor(0, 0, 0, 120))
+        for stroke in self.strokes:
+            self._paint_stroke(painter, stroke, self.offset, self.zoom)
+        if self._stroke is not None:
+            self._paint_stroke(painter, self._stroke, self.offset, self.zoom)

{frontengine-1.0.47 → frontengine-1.0.49}/frontengine/show/gaming/crosshair_widget.py

@@ -13,10 +13,10 @@ stacks windows and not something to work around.
 """
 from __future__ import annotations
 
-from typing import Tuple
+from typing import Any, Optional, Tuple
 
 from PySide6.QtCore import QPointF, Qt
-from PySide6.QtGui import QColor, QPainter, QPen
+from PySide6.QtGui import QColor, QPainter, QPen, QScreen
 
 from frontengine.show.base_widget import BaseWidget
 from frontengine.utils.logging.loggin_instance import front_engine_logger
@@ -35,13 +35,13 @@ MIN_SIZE = 4
 MAX_SIZE = 200
 
 
-def normalize_style(style) -> str:
+def normalize_style(style: Any) -> str:
     """把準星樣式正規化；不認得的一律當十字。"""
     name = str(style or "").strip().lower()
     return name if name in STYLES else STYLE_CROSS
 
 
-def clamp_size(value, fallback: int = DEFAULT_SIZE) -> int:
+def clamp_size(value: Any, fallback: int = DEFAULT_SIZE) -> int:
     """準星尺寸夾在看得見又不誇張的範圍。"""
     try:
         return max(MIN_SIZE, min(MAX_SIZE, int(value)))
@@ -49,7 +49,7 @@ def clamp_size(value, fallback: int = DEFAULT_SIZE) -> int:
         return fallback
 
 
-def clamp_thickness(value, fallback: int = DEFAULT_THICKNESS) -> int:
+def clamp_thickness(value: Any, fallback: int = DEFAULT_THICKNESS) -> int:
     """線寬夾在 1~12。"""
     try:
         return max(1, min(12, int(value)))
@@ -57,7 +57,7 @@ def clamp_thickness(value, fallback: int = DEFAULT_THICKNESS) -> int:
         return fallback
 
 
-def clamp_gap(value, size: int = DEFAULT_SIZE, fallback: int = DEFAULT_GAP) -> int:
+def clamp_gap(value: Any, size: int = DEFAULT_SIZE, fallback: int = DEFAULT_GAP) -> int:
     """
     中央空隙不能大到把準星吃光，所以上限跟著尺寸走。
     The centre gap cannot swallow the crosshair, so its ceiling follows the size.
@@ -100,7 +100,8 @@ class CrosshairWidget(BaseWidget):
         self.opacity = 1.0
         self.resize(self.size * 2 + 8, self.size * 2 + 8)
 
-    def set_crosshair(self, style=None, color=None, size=None,
+    def set_crosshair(self, style: Optional[str] = None, color: Optional[str] = None,
+                      size: Optional[int] = None,
                       thickness=None, gap=None) -> None:
         """一次改好幾項設定，改完立刻重畫。"""
         if style is not None:
@@ -119,7 +120,7 @@ class CrosshairWidget(BaseWidget):
         self.centre_on_screen()
         self.update()
 
-    def centre_on_screen(self, screen=None) -> None:
+    def centre_on_screen(self, screen: Optional[QScreen] = None) -> None:
         """擺到螢幕正中央（準星要對準的是畫面中心）。"""
         from PySide6.QtGui import QGuiApplication
 

{frontengine-1.0.47 → frontengine-1.0.49}/frontengine/show/teleprompter/teleprompter_widget.py

@@ -12,7 +12,7 @@ and it stops at the last line rather than snapping back to the top mid-read.
 """
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import Any, List, Optional
 
 from PySide6.QtCore import Qt, QTimer
 from PySide6.QtGui import QColor, QFont, QFontMetrics, QPainter, QTransform
@@ -31,7 +31,7 @@ _TICK_MS = 33
 _SIDE_MARGIN = 40
 
 
-def clamp_speed(value, fallback: int = DEFAULT_SPEED) -> int:
+def clamp_speed(value: Any, fallback: int = DEFAULT_SPEED) -> int:
     """捲動速度夾在讀得完又跟得上的範圍。"""
     try:
         return max(MIN_SPEED, min(MAX_SPEED, int(value)))
@@ -39,7 +39,7 @@ def clamp_speed(value, fallback: int = DEFAULT_SPEED) -> int:
         return fallback
 
 
-def clamp_font_size(value, fallback: int = DEFAULT_FONT_SIZE) -> int:
+def clamp_font_size(value: Any, fallback: int = DEFAULT_FONT_SIZE) -> int:
     """字級夾在看得見的範圍。"""
     try:
         return max(MIN_FONT_SIZE, min(MAX_FONT_SIZE, int(value)))

frontengine-1.0.49/frontengine/ui/dialog/signage_dialog.py

@@ -0,0 +1,100 @@
+"""
+看板模式設定：依序輪播一組預設集，適合把機器擺著當展示螢幕。
+
+Signage settings: rotate through a set of presets, for a machine left running
+as a display.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from PySide6.QtWidgets import (
+    QCheckBox, QDialog, QDialogButtonBox, QGridLayout, QLabel, QPlainTextEdit, QSpinBox, QWidget,
+)
+
+from frontengine.user_setting.user_setting_file import user_setting_dict, write_user_setting
+from frontengine.utils.logging.loggin_instance import front_engine_logger
+from frontengine.utils.multi_language.language_wrapper import language_wrapper
+from frontengine.utils.signage.signage_service import (
+    DEFAULT_INTERVAL_MINUTES, MAX_INTERVAL_MINUTES, MIN_INTERVAL_MINUTES, clamp_interval,
+    normalize_playlist,
+)
+
+SETTING_KEY = "signage"
+DEFAULT_SETTINGS: Dict[str, Any] = {
+    "enabled": False, "presets": [], "interval_minutes": DEFAULT_INTERVAL_MINUTES,
+    "hide_window": True,
+}
+
+
+def _t(key: str, fallback: str) -> str:
+    return language_wrapper.language_word_dict.get(key, fallback)
+
+
+def current_settings() -> Dict[str, Any]:
+    """目前的看板設定（缺項目補預設值）。"""
+    stored = user_setting_dict.get(SETTING_KEY)
+    settings = dict(DEFAULT_SETTINGS)
+    if isinstance(stored, dict):
+        settings.update({key: stored[key] for key in DEFAULT_SETTINGS if key in stored})
+    settings["presets"] = normalize_playlist(settings.get("presets"))
+    settings["interval_minutes"] = clamp_interval(settings.get("interval_minutes"))
+    return settings
+
+
+class SignageDialog(QDialog):
+    """設定要輪播哪些預設集、多久換一次。"""
+
+    def __init__(self, parent: Optional[QWidget] = None) -> None:
+        front_engine_logger.info("[SignageDialog] Init")
+        super().__init__(parent)
+        self.setWindowTitle(_t("signage_title", "Signage mode"))
+        settings = current_settings()
+
+        self.enable_checkbox = QCheckBox(_t("signage_enable", "Rotate presets"))
+        self.enable_checkbox.setChecked(bool(settings.get("enabled")))
+        self.presets_label = QLabel(_t("signage_presets_label", "Presets, one per line:"))
+        self.presets_edit = QPlainTextEdit("\n".join(settings.get("presets", [])))
+        self.interval_label = QLabel(_t("signage_interval_label", "Change every (minutes)"))
+        self.interval_spinbox = QSpinBox()
+        self.interval_spinbox.setRange(MIN_INTERVAL_MINUTES, MAX_INTERVAL_MINUTES)
+        self.interval_spinbox.setValue(settings.get("interval_minutes"))
+        self.hide_checkbox = QCheckBox(
+            _t("signage_hide_window", "Hide the main window while rotating"))
+        self.hide_checkbox.setChecked(bool(settings.get("hide_window", True)))
+        self.hint_label = QLabel(
+            _t("signage_hint",
+               "Presets are saved from the Presets menu. The rotation wraps at the end, so a "
+               "machine left running keeps cycling."))
+        self.hint_label.setWordWrap(True)
+
+        self.button_box = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        self.button_box.accepted.connect(self.accept)
+        self.button_box.rejected.connect(self.reject)
+
+        layout = QGridLayout(self)
+        layout.addWidget(self.enable_checkbox, 0, 0, 1, 2)
+        layout.addWidget(self.presets_label, 1, 0, 1, 2)
+        layout.addWidget(self.presets_edit, 2, 0, 1, 2)
+        layout.addWidget(self.interval_label, 3, 0)
+        layout.addWidget(self.interval_spinbox, 3, 1)
+        layout.addWidget(self.hide_checkbox, 4, 0, 1, 2)
+        layout.addWidget(self.hint_label, 5, 0, 1, 2)
+        layout.addWidget(self.button_box, 6, 0, 1, 2)
+
+    def settings(self) -> Dict[str, Any]:
+        """對話框上目前的設定。"""
+        return {
+            "enabled": self.enable_checkbox.isChecked(),
+            "presets": normalize_playlist(self.presets_edit.toPlainText()),
+            "interval_minutes": self.interval_spinbox.value(),
+            "hide_window": self.hide_checkbox.isChecked(),
+        }
+
+    def accept(self) -> None:
+        settings = self.settings()
+        user_setting_dict[SETTING_KEY] = settings
+        write_user_setting()
+        front_engine_logger.info(f"[SignageDialog] saved | {len(settings['presets'])} preset(s)")
+        super().accept()

{frontengine-1.0.47 → frontengine-1.0.49}/frontengine/ui/main_ui.py

@@ -2,7 +2,7 @@ import os
 import sys
 from os import getcwd
 from pathlib import Path
-from typing import Dict, Optional, Type
+from typing import Any, Dict, Optional, Type
 
 from PySide6.QtCore import QByteArray, QTimer, QCoreApplication
 from PySide6.QtGui import QIcon, Qt
@@ -53,6 +53,8 @@ from frontengine.ui.dialog.remote_control_dialog import (
     MIDI_KEY, current_bindings, remote_enabled,
 )
 from frontengine.ui.dialog.screen_privacy_dialog import current_settings as current_privacy_settings
+from frontengine.ui.dialog.signage_dialog import current_settings as current_signage_settings
+from frontengine.utils.signage.signage_service import SignageService
 from frontengine.utils.midi.midi_input import MidiInput, binding_key
 from frontengine.utils.remote.remote_server import RemoteServer
 from frontengine.ui.dialog.smart_pause_dialog import current_rules
@@ -72,6 +74,20 @@ from frontengine.utils.theme_schedule.theme_schedule_service import ThemeSchedul
 FrontEngine_EXTEND_TAB: Dict[str, Type[QWidget]] = {}
 
 
+def tray_can_restore_window(window: Any) -> bool:
+    """
+    系統匣能不能把主視窗叫回來。任何「把主視窗藏起來」的功能都得先問這件事，
+    不然藏掉的就是唯一能把該功能關掉的畫面。
+    Whether the tray can bring the main window back. Anything that hides the
+    window has to ask first: otherwise what it hides is the only screen that
+    can turn that same thing off.
+    """
+    tray = getattr(window, "system_tray", None)
+    return bool(ExtendSystemTray.isSystemTrayAvailable()
+                and getattr(window, "show_system_tray_ray", False)
+                and tray is not None and tray.isVisible())
+
+
 class FrontEngineMainUI(QMainWindow):
     """
     FrontEngine 主視窗
@@ -235,6 +251,13 @@ class FrontEngineMainUI(QMainWindow):
         if user_setting_dict.get(MIDI_KEY):
             self.midi_input.start(user_setting_dict.get("midi_device") or 0)
 
+        # 看板模式：依序輪播預設集，主視窗可以收起來
+        # Signage mode: rotate presets, with the main window out of the way.
+        self.signage_service = SignageService(config_provider=current_signage_settings)
+        self.signage_service.preset_due.connect(lambda name: apply_named_preset(self, name))
+        if current_signage_settings().get("enabled"):
+            self.start_signage()
+
         # 分享畫面時把覆蓋層藏出擷取結果（自己仍看得到）
         # Hide the overlays from the capture while sharing; they stay on screen here.
         self.share_watch_service = ShareWatchService(config_provider=current_privacy_settings)
@@ -312,9 +335,10 @@ class FrontEngineMainUI(QMainWindow):
         """
         sources = (
             (self.screen_care_setting_ui, ("filter_widget_list", "ruler_widget_list",
-                                           "break_overlay_list")),
+                                           "break_overlay_list", "color_vision_widget_list")),
             (self.presentation_setting_ui, ("annotation_widget_list", "cursor_widget_list",
-                                            "keystroke_widget_list", "magnifier_widget_list")),
+                                            "keystroke_widget_list", "magnifier_widget_list",
+                                            "whiteboard_widget_list")),
             (self.focus_setting_ui, ("dim_widget_list", "mask_widget_list")),
         )
         for page, attributes in sources:
@@ -325,6 +349,12 @@ class FrontEngineMainUI(QMainWindow):
         # The wallpaper page keys its widgets by monitor, so hand over the values.
         self.control_center_ui.register_overlay_source(
             lambda: list(self.wallpaper_setting_ui.wallpaper_widgets.values()))
+        self.control_center_ui.register_overlay_source(
+            lambda: getattr(self.web_setting_ui, "dashboard_widgets", []))
+        # 批次關閉之後，沒有覆蓋層在聽就把全域輸入監聽收掉
+        # After a batch close nothing is listening, so drop the global input hook.
+        self.control_center_ui.register_cleanup(
+            self.presentation_setting_ui.release_input_watch)
         for attribute in ("spectrum_widget_list", "monitor_widget_list",
                           "now_playing_widget_list", "note_widget_list"):
             self.control_center_ui.register_overlay_source(
@@ -508,6 +538,34 @@ class FrontEngineMainUI(QMainWindow):
         if action:
             self._handle_hotkey(action)
 
+    def start_signage(self) -> Optional[str]:
+        """開始輪播；設定要求、而且托盤能把視窗叫回來時才收起主視窗。"""
+        first = self.signage_service.start()
+        if first is not None and current_signage_settings().get("hide_window", True):
+            self._hide_for_signage()
+        return first
+
+    def _hide_for_signage(self) -> None:
+        """
+        收起主視窗——但只在系統匣真的能把它叫回來的時候。沒有系統匣就等於
+        把唯一能關掉輪播的畫面藏起來，重開也只會再被藏一次，使用者就只能去
+        手動改設定檔了。
+        Put the main window away - but only when the tray can actually bring it
+        back. Without a tray this would hide the only screen that can turn the
+        rotation off, and restarting just hides it again, leaving the settings
+        file as the only way out.
+        """
+        if tray_can_restore_window(self):
+            self.hide()
+            return
+        front_engine_logger.info(
+            "[FrontEngineMainUI] signage kept the window visible: no tray to restore it from")
+
+    def stop_signage(self) -> None:
+        """停止輪播並把主視窗放回來。"""
+        self.signage_service.stop()
+        self.show()
+
     def _on_sharing_changed(self, sharing: bool, match: str) -> None:
         """
         偵測到會議程式開著／關掉時，自動把覆蓋層藏出擷取結果或放回去。
@@ -573,6 +631,7 @@ class FrontEngineMainUI(QMainWindow):
     # The background services to stop on close, outermost first.
     _CLOSING_SERVICES = (
         "preset_schedule_service", "theme_schedule_service", "usage_service",
+        "signage_service",
         "remote_server", "midi_input", "share_watch_service", "reminder_service",
         "app_profile_service", "smart_pause_service", "hotkey_service",
     )

{frontengine-1.0.47 → frontengine-1.0.49}/frontengine/ui/menu/settings_menu.py

@@ -12,6 +12,7 @@ from frontengine.ui.dialog.hotkey_settings_dialog import HotkeySettingsDialog
 from frontengine.ui.dialog.reminder_dialog import ReminderDialog
 from frontengine.ui.dialog.remote_control_dialog import RemoteControlDialog
 from frontengine.ui.dialog.screen_privacy_dialog import ScreenPrivacyDialog
+from frontengine.ui.dialog.signage_dialog import SignageDialog
 from frontengine.ui.dialog.smart_pause_dialog import SmartPauseDialog
 from frontengine.ui.dialog.usage_report_dialog import UsageReportDialog
 from frontengine.user_setting.user_setting_file import (
@@ -89,6 +90,11 @@ def build_settings_menu(ui: "FrontEngineMainUI") -> None:
     menu.addAction(reminder_action)
     ui.reminder_action = reminder_action
 
+    signage_action = QAction(_t("settings_menu_signage", "Signage mode..."), menu)
+    signage_action.triggered.connect(lambda: _open_signage_dialog(ui))
+    menu.addAction(signage_action)
+    ui.signage_action = signage_action
+
     remote_action = QAction(_t("settings_menu_remote", "Remote control..."), menu)
     remote_action.triggered.connect(lambda: _open_remote_dialog(ui))
     menu.addAction(remote_action)
@@ -127,6 +133,18 @@ def build_settings_menu(ui: "FrontEngineMainUI") -> None:
     menu.addAction(import_action)
 
 
+def _open_signage_dialog(ui: "FrontEngineMainUI") -> None:
+    """開看板設定；按下確定後立刻套用新的輪播狀態。"""
+    front_engine_logger.info("[SettingsMenu] open SignageDialog")
+    dialog = SignageDialog(ui)
+    if dialog.exec() != QDialog.DialogCode.Accepted:
+        return
+    if dialog.settings().get("enabled"):
+        ui.start_signage()
+    else:
+        ui.stop_signage()
+
+
 def _open_remote_dialog(ui: "FrontEngineMainUI") -> None:
     """開遙控設定，並把它接上 MIDI 的「學習」流程。"""
     front_engine_logger.info("[SettingsMenu] open RemoteControlDialog")