prkit 0.1.0__py3-none-any.whl

prkit/overlays.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from PySide6.QtCore import QEasingCurve, QPoint, QPropertyAnimation, QRect, Qt, QTimer
+from PySide6.QtGui import QColor, QCursor, QFont, QGuiApplication, QPainter, QPaintEvent
+from PySide6.QtWidgets import QWidget
+
+from prkit.platform import (
+    configure_overlay_level,
+    keep_window_topmost,
+    make_window_click_through,
+)
+from prkit.settings import KeystrokeSettings, SpotlightSettings
+
+
+class OverlayWindow(QWidget):
+    def __init__(self) -> None:
+        flags = (
+            Qt.WindowType.FramelessWindowHint
+            | Qt.WindowType.Tool
+            | Qt.WindowType.WindowStaysOnTopHint
+            | Qt.WindowType.WindowDoesNotAcceptFocus
+            | Qt.WindowType.WindowTransparentForInput
+        )
+        super().__init__(None, flags)
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
+        self.setAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating)
+        self.setAttribute(Qt.WidgetAttribute.WA_MacAlwaysShowToolWindow)
+        self.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+
+    def showEvent(self, event: object) -> None:
+        super().showEvent(event)  # type: ignore[arg-type]
+        QTimer.singleShot(0, self._configure_native_window)
+
+    def _configure_native_window(self) -> None:
+        make_window_click_through(self)
+        configure_overlay_level(self)
+
+
+class SpotlightOverlay(OverlayWindow):
+    def __init__(self, settings: SpotlightSettings) -> None:
+        super().__init__()
+        self._color = QColor(settings.color)
+        self._opacity = settings.opacity
+        self._diameter = settings.size
+        self.setFixedSize(self._diameter, self._diameter)
+        self._timer = QTimer(self)
+        self._timer.setInterval(16)
+        self._timer.timeout.connect(self._follow_cursor)
+
+    @property
+    def diameter(self) -> int:
+        return self._diameter
+
+    def set_enabled(self, enabled: bool) -> None:
+        if enabled:
+            self._follow_cursor()
+            self.show()
+            self._timer.start()
+        else:
+            self._timer.stop()
+            self.hide()
+
+    def set_appearance(self, color: str, opacity: int, diameter: int) -> None:
+        center = (
+            QPoint(self.x() + self._diameter // 2, self.y() + self._diameter // 2)
+            if self.isVisible()
+            else QCursor.pos()
+        )
+        self._color = QColor(color)
+        self._opacity = opacity
+        self._diameter = diameter
+        self.setFixedSize(diameter, diameter)
+        self.move(center - QPoint(diameter // 2, diameter // 2))
+        self.update()
+
+    def _follow_cursor(self) -> None:
+        position = QCursor.pos()
+        self.move(position.x() - self._diameter // 2, position.y() - self._diameter // 2)
+        keep_window_topmost(self)
+
+    def sync_position(self) -> None:
+        self._follow_cursor()
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        del event
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        color = QColor(self._color)
+        color.setAlphaF(self._opacity / 100)
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(color)
+        painter.drawEllipse(self.rect().adjusted(1, 1, -1, -1))
+
+
+class KeystrokeOverlay(OverlayWindow):
+    DISPLAY_MILLISECONDS = 1200
+    FADE_MILLISECONDS = 250
+
+    def __init__(self, settings: KeystrokeSettings) -> None:
+        super().__init__()
+        self._color = QColor(settings.color)
+        self._opacity = settings.opacity
+        self._text = ""
+        font = QFont()
+        font.setPointSize(24)
+        font.setBold(True)
+        self.setFont(font)
+        self._hide_timer = QTimer(self)
+        self._hide_timer.setSingleShot(True)
+        self._hide_timer.timeout.connect(self._start_fade)
+        self._fade = QPropertyAnimation(self, b"windowOpacity", self)
+        self._fade.setDuration(self.FADE_MILLISECONDS)
+        self._fade.setStartValue(1.0)
+        self._fade.setEndValue(0.0)
+        self._fade.setEasingCurve(QEasingCurve.Type.OutCubic)
+        self._fade.finished.connect(self.hide)
+
+    def set_appearance(self, color: str, opacity: int) -> None:
+        self._color = QColor(color)
+        self._opacity = opacity
+        self.update()
+
+    def show_chord(self, text: str) -> None:
+        self._fade.stop()
+        self._hide_timer.stop()
+        self.setWindowOpacity(1.0)
+        self._text = text
+        metrics = self.fontMetrics()
+        width = max(160, metrics.horizontalAdvance(text) + 64)
+        height = metrics.height() + 36
+        self.setFixedSize(width, height)
+        self._place_on_cursor_screen()
+        self.show()
+        keep_window_topmost(self)
+        self.update()
+
+    def keys_released(self) -> None:
+        if self.isVisible():
+            self._hide_timer.start(self.DISPLAY_MILLISECONDS)
+
+    def hide_now(self) -> None:
+        self._hide_timer.stop()
+        self._fade.stop()
+        self.hide()
+
+    def _place_on_cursor_screen(self) -> None:
+        screen = QGuiApplication.screenAt(QCursor.pos()) or QGuiApplication.primaryScreen()
+        if screen is None:
+            return
+        available = screen.availableGeometry()
+        x = available.x() + (available.width() - self.width()) // 2
+        y = available.bottom() - self.height() - 47
+        self.move(x, y)
+
+    def _start_fade(self) -> None:
+        self._fade.start()
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        del event
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        background = QColor(self._color)
+        background.setAlphaF(self._opacity / 100)
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(background)
+        painter.drawRoundedRect(QRect(self.rect()).adjusted(1, 1, -1, -1), 18, 18)
+        painter.setPen(QColor("white"))
+        painter.setFont(self.font())
+        painter.drawText(self.rect(), Qt.AlignmentFlag.AlignCenter, self._text)

prkit/platform.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import os
+import sys
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from PySide6.QtWidgets import QWidget
+
+
+def is_wayland() -> bool:
+    return (
+        bool(os.environ.get("WAYLAND_DISPLAY"))
+        or os.environ.get("XDG_SESSION_TYPE", "").lower() == "wayland"
+    )
+
+
+def make_window_click_through(widget: QWidget) -> None:
+    """Apply native input transparency in addition to Qt's window flags.
+
+    Every implementation is deliberately best-effort: Qt's own transparent-input
+    hint remains active if the native API is unavailable.
+    """
+    window_id = int(widget.winId())
+    try:
+        if sys.platform == "win32":
+            _make_windows_click_through(window_id)
+        elif sys.platform == "darwin":
+            from PySide6.QtGui import QGuiApplication
+
+            if QGuiApplication.platformName() == "cocoa":
+                _make_macos_click_through(window_id)
+        elif sys.platform.startswith("linux") and not is_wayland():
+            _make_x11_click_through(window_id)
+    except (ImportError, OSError, RuntimeError, AttributeError, TypeError):
+        return
+
+
+def configure_overlay_level(widget: QWidget) -> None:
+    """Keep macOS overlays above apps but below the menu bar and popup menus."""
+    if sys.platform != "darwin":
+        return
+    try:
+        import objc
+        from AppKit import (
+            NSColor,
+            NSFloatingWindowLevel,
+            NSWindowCollectionBehaviorCanJoinAllSpaces,
+            NSWindowCollectionBehaviorFullScreenAuxiliary,
+            NSWindowStyleMaskNonactivatingPanel,
+        )
+        from PySide6.QtGui import QGuiApplication
+
+        if QGuiApplication.platformName() != "cocoa":
+            return
+        native_view = objc.objc_object(c_void_p=int(widget.winId()))
+        native_window = native_view.window()
+        native_window.setLevel_(NSFloatingWindowLevel)
+        native_window.setHidesOnDeactivate_(False)
+        native_window.setHasShadow_(False)
+        native_window.setOpaque_(False)
+        native_window.setBackgroundColor_(NSColor.clearColor())
+        native_window.setStyleMask_(native_window.styleMask() | NSWindowStyleMaskNonactivatingPanel)
+        if native_window.respondsToSelector_("setBecomesKeyOnlyIfNeeded:"):
+            native_window.setBecomesKeyOnlyIfNeeded_(True)
+        native_window.setCollectionBehavior_(
+            NSWindowCollectionBehaviorCanJoinAllSpaces
+            | NSWindowCollectionBehaviorFullScreenAuxiliary
+        )
+    except (ImportError, OSError, RuntimeError, AttributeError, TypeError):
+        return
+
+
+def keep_window_topmost(widget: QWidget) -> None:
+    """Keep an overlay above other topmost Windows such as the taskbar."""
+    if sys.platform != "win32" or not widget.isVisible():
+        return
+    try:
+        import ctypes
+
+        user32 = ctypes.windll.user32
+        hwnd_topmost = -1
+        no_size = 0x0001
+        no_move = 0x0002
+        no_activate = 0x0010
+        no_owner_z_order = 0x0200
+        user32.SetWindowPos(
+            int(widget.winId()),
+            hwnd_topmost,
+            0,
+            0,
+            0,
+            0,
+            no_size | no_move | no_activate | no_owner_z_order,
+        )
+    except (OSError, AttributeError, TypeError):
+        return
+
+
+def _make_windows_click_through(window_id: int) -> None:
+    import ctypes
+
+    user32 = ctypes.windll.user32
+    get_window_long = user32.GetWindowLongPtrW
+    set_window_long = user32.SetWindowLongPtrW
+    index_extended_style = -20
+    transparent = 0x00000020
+    layered = 0x00080000
+    no_activate = 0x08000000
+    tool_window = 0x00000080
+    current = get_window_long(window_id, index_extended_style)
+    set_window_long(
+        window_id,
+        index_extended_style,
+        current | transparent | layered | no_activate | tool_window,
+    )
+    hwnd_topmost = -1
+    no_size = 0x0001
+    no_move = 0x0002
+    no_activate_position = 0x0010
+    no_owner_z_order = 0x0200
+    user32.SetWindowPos(
+        window_id,
+        hwnd_topmost,
+        0,
+        0,
+        0,
+        0,
+        no_size | no_move | no_activate_position | no_owner_z_order,
+    )
+
+
+def _make_macos_click_through(window_id: int) -> None:
+    import objc
+
+    native_view = objc.objc_object(c_void_p=window_id)
+    native_window = native_view.window()
+    native_window.setIgnoresMouseEvents_(True)
+    native_window.setAcceptsMouseMovedEvents_(False)
+
+
+def _make_x11_click_through(window_id: int) -> None:
+    from Xlib import display
+    from Xlib.ext import shape
+
+    connection = display.Display()
+    try:
+        window = connection.create_resource_object("window", window_id)
+        window.shape_rectangles(shape.SO.Set, shape.SK.Input, 0, 0, 0, [])
+        connection.sync()
+    finally:
+        connection.close()

prkit/settings.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+from PySide6.QtCore import QSettings
+from PySide6.QtGui import QColor
+
+MIN_SPOTLIGHT_SIZE = 48
+MAX_SPOTLIGHT_SIZE = 320
+DEFAULT_SPOTLIGHT_SIZE = 96
+
+
+def clamp(value: int, minimum: int, maximum: int) -> int:
+    return max(minimum, min(maximum, value))
+
+
+def valid_color(value: object, fallback: str) -> str:
+    color = QColor(str(value))
+    return color.name().upper() if color.isValid() else fallback
+
+
+@dataclass(slots=True)
+class SpotlightSettings:
+    enabled: bool = False
+    color: str = "#FFD54F"
+    opacity: int = 45
+    size: int = DEFAULT_SPOTLIGHT_SIZE
+
+
+@dataclass(slots=True)
+class KeystrokeSettings:
+    enabled: bool = False
+    color: str = "#202124"
+    opacity: int = 75
+
+
+@dataclass(slots=True)
+class AppSettings:
+    spotlight: SpotlightSettings
+    keystroke: KeystrokeSettings
+
+    @classmethod
+    def defaults(cls) -> AppSettings:
+        return cls(SpotlightSettings(), KeystrokeSettings())
+
+
+class SettingsStoreProtocol(Protocol):
+    def load(self) -> AppSettings: ...
+
+    def save(self, settings: AppSettings) -> None: ...
+
+
+class SettingsStore:
+    def __init__(self, backend: QSettings | None = None) -> None:
+        self._backend = backend or QSettings()
+
+    def load(self) -> AppSettings:
+        defaults = AppSettings.defaults()
+        backend = self._backend
+        spotlight = SpotlightSettings(
+            enabled=backend.value("spotlight/enabled", defaults.spotlight.enabled, type=bool),
+            color=valid_color(
+                backend.value("spotlight/color", defaults.spotlight.color),
+                defaults.spotlight.color,
+            ),
+            opacity=clamp(
+                backend.value("spotlight/opacity", defaults.spotlight.opacity, type=int), 10, 100
+            ),
+            size=clamp(
+                backend.value("spotlight/size", defaults.spotlight.size, type=int),
+                MIN_SPOTLIGHT_SIZE,
+                MAX_SPOTLIGHT_SIZE,
+            ),
+        )
+        keystroke = KeystrokeSettings(
+            enabled=backend.value("keystroke/enabled", defaults.keystroke.enabled, type=bool),
+            color=valid_color(
+                backend.value("keystroke/color", defaults.keystroke.color),
+                defaults.keystroke.color,
+            ),
+            opacity=clamp(
+                backend.value("keystroke/opacity", defaults.keystroke.opacity, type=int),
+                10,
+                100,
+            ),
+        )
+        return AppSettings(spotlight, keystroke)
+
+    def save(self, settings: AppSettings) -> None:
+        values = {
+            "spotlight/enabled": settings.spotlight.enabled,
+            "spotlight/color": settings.spotlight.color,
+            "spotlight/opacity": settings.spotlight.opacity,
+            "spotlight/size": settings.spotlight.size,
+            "keystroke/enabled": settings.keystroke.enabled,
+            "keystroke/color": settings.keystroke.color,
+            "keystroke/opacity": settings.keystroke.opacity,
+        }
+        for key, value in values.items():
+            self._backend.setValue(key, value)
+        self._backend.sync()

prkit/spotlight.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import sys
+from typing import Protocol
+
+from prkit.overlays import SpotlightOverlay
+from prkit.settings import SpotlightSettings
+
+
+class SpotlightBackend(Protocol):
+    @property
+    def diameter(self) -> int: ...
+
+    def set_enabled(self, enabled: bool) -> None: ...
+
+    def set_appearance(self, color: str, opacity: int, diameter: int) -> None: ...
+
+    def sync_position(self) -> None: ...
+
+
+def create_spotlight(settings: SpotlightSettings) -> SpotlightBackend:
+    if sys.platform == "win32":
+        from prkit.windows_cursor import WindowsCursorSpotlight
+
+        return WindowsCursorSpotlight(settings)
+    return SpotlightOverlay(settings)

prkit/tray.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from PySide6.QtCore import QObject, Qt, Signal
+from PySide6.QtGui import QAction, QColor
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QColorDialog,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QMenu,
+    QPushButton,
+    QSlider,
+    QSystemTrayIcon,
+    QVBoxLayout,
+    QWidget,
+    QWidgetAction,
+)
+
+from prkit.icon import tray_icon
+from prkit.platform import is_wayland
+from prkit.settings import (
+    MAX_SPOTLIGHT_SIZE,
+    MIN_SPOTLIGHT_SIZE,
+    AppSettings,
+)
+
+
+class ColorButton(QPushButton):
+    color_changed = Signal(str)
+
+    def __init__(self, color: str, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._color = color
+        self.setFixedSize(42, 24)
+        self.setToolTip("選擇顏色")
+        self.clicked.connect(self._choose_color)
+        self.set_color(color)
+
+    @property
+    def color(self) -> str:
+        return self._color
+
+    def set_color(self, color: str) -> None:
+        self._color = QColor(color).name().upper()
+        self.setStyleSheet(
+            f"QPushButton {{ background: {self._color}; border: 1px solid #777; "
+            "border-radius: 4px; }"
+        )
+
+    def _choose_color(self) -> None:
+        chosen = QColorDialog.getColor(QColor(self._color), self, "選擇顏色")
+        if chosen.isValid():
+            self.set_color(chosen.name())
+            self.color_changed.emit(self._color)
+
+
+class ValueSlider(QWidget):
+    value_changed = Signal(int)
+
+    def __init__(
+        self,
+        minimum: int,
+        maximum: int,
+        value: int,
+        suffix: str,
+        step: int = 1,
+        parent: QWidget | None = None,
+    ) -> None:
+        super().__init__(parent)
+        self._suffix = suffix
+        self.slider = QSlider(Qt.Orientation.Horizontal, self)
+        self.slider.setRange(minimum, maximum)
+        self.slider.setSingleStep(step)
+        self.slider.setPageStep(step)
+        self.slider.setValue(value)
+        self.value_label = QLabel(self)
+        self.value_label.setMinimumWidth(48)
+        self.value_label.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(8)
+        layout.addWidget(self.slider, 1)
+        layout.addWidget(self.value_label)
+        self.slider.valueChanged.connect(self._on_value_changed)
+        self._on_value_changed(value)
+
+    @property
+    def value(self) -> int:
+        return self.slider.value()
+
+    def _on_value_changed(self, value: int) -> None:
+        step = self.slider.singleStep()
+        if step > 1 and value % step:
+            value = round(value / step) * step
+            self.slider.setValue(value)
+            return
+        self.value_label.setText(f"{value}{self._suffix}")
+        self.value_changed.emit(value)
+
+
+class SettingsPanel(QWidget):
+    spotlight_enabled_changed = Signal(bool)
+    spotlight_color_changed = Signal(str)
+    spotlight_opacity_changed = Signal(int)
+    spotlight_size_changed = Signal(int)
+    keystroke_enabled_changed = Signal(bool)
+    keystroke_color_changed = Signal(str)
+    keystroke_opacity_changed = Signal(int)
+
+    def __init__(self, settings: AppSettings, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.setMinimumWidth(310)
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(14, 12, 14, 12)
+        layout.setSpacing(10)
+
+        self.spotlight_enabled = QCheckBox("啟用聚光燈游標")
+        self.spotlight_enabled.setChecked(settings.spotlight.enabled)
+        self.spotlight_color = ColorButton(settings.spotlight.color)
+        self.spotlight_opacity = ValueSlider(10, 100, settings.spotlight.opacity, "%")
+        self.spotlight_size = ValueSlider(
+            MIN_SPOTLIGHT_SIZE,
+            MAX_SPOTLIGHT_SIZE,
+            settings.spotlight.size,
+            " px",
+            8,
+        )
+        layout.addWidget(self._section_title("聚光燈游標"))
+        layout.addWidget(self.spotlight_enabled)
+        layout.addLayout(self._row("顏色", self.spotlight_color))
+        layout.addLayout(self._row("透明度", self.spotlight_opacity))
+        layout.addLayout(self._row("圓圈大小", self.spotlight_size))
+        layout.addWidget(self._separator())
+
+        self.keystroke_enabled = QCheckBox("啟用按鍵顯示")
+        self.keystroke_enabled.setChecked(settings.keystroke.enabled)
+        self.keystroke_color = ColorButton(settings.keystroke.color)
+        self.keystroke_opacity = ValueSlider(10, 100, settings.keystroke.opacity, "%")
+        layout.addWidget(self._section_title("按鍵顯示"))
+        layout.addWidget(self.keystroke_enabled)
+        layout.addLayout(self._row("顏色", self.keystroke_color))
+        layout.addLayout(self._row("透明度", self.keystroke_opacity))
+
+        if is_wayland():
+            warning = QLabel("⚠ Wayland 不保證支援全域按鍵與覆蓋層")
+            warning.setWordWrap(True)
+            warning.setStyleSheet("color: #b26a00; padding-top: 6px")
+            layout.addWidget(warning)
+
+        self.spotlight_enabled.toggled.connect(self.spotlight_enabled_changed)
+        self.spotlight_color.color_changed.connect(self.spotlight_color_changed)
+        self.spotlight_opacity.value_changed.connect(self.spotlight_opacity_changed)
+        self.spotlight_size.value_changed.connect(self.spotlight_size_changed)
+        self.keystroke_enabled.toggled.connect(self.keystroke_enabled_changed)
+        self.keystroke_color.color_changed.connect(self.keystroke_color_changed)
+        self.keystroke_opacity.value_changed.connect(self.keystroke_opacity_changed)
+
+    def set_spotlight_enabled(self, enabled: bool) -> None:
+        self.spotlight_enabled.setChecked(enabled)
+
+    def set_keystroke_enabled(self, enabled: bool) -> None:
+        self.keystroke_enabled.setChecked(enabled)
+
+    @staticmethod
+    def _section_title(text: str) -> QLabel:
+        label = QLabel(text)
+        font = label.font()
+        font.setBold(True)
+        label.setFont(font)
+        return label
+
+    @staticmethod
+    def _separator() -> QFrame:
+        frame = QFrame()
+        frame.setFrameShape(QFrame.Shape.HLine)
+        frame.setFrameShadow(QFrame.Shadow.Sunken)
+        return frame
+
+    @staticmethod
+    def _row(label: str, widget: QWidget) -> QHBoxLayout:
+        layout = QHBoxLayout()
+        layout.setContentsMargins(18, 0, 0, 0)
+        title = QLabel(label)
+        title.setMinimumWidth(62)
+        layout.addWidget(title)
+        layout.addWidget(widget, 1)
+        return layout
+
+
+class TrayController(QObject):
+    exit_requested = Signal()
+
+    def __init__(self, settings: AppSettings, parent: QObject | None = None) -> None:
+        super().__init__(parent)
+        self.panel = SettingsPanel(settings)
+        self.menu = QMenu()
+        panel_action = QWidgetAction(self.menu)
+        panel_action.setDefaultWidget(self.panel)
+        self.menu.addAction(panel_action)
+        self.menu.addSeparator()
+        exit_action = QAction("結束", self.menu)
+        exit_action.triggered.connect(self.exit_requested)
+        self.menu.addAction(exit_action)
+        self.tray = QSystemTrayIcon(tray_icon(), self)
+        self.tray.setToolTip("簡報瑞士刀")
+        self.tray.setContextMenu(self.menu)
+
+    @staticmethod
+    def is_available() -> bool:
+        return QSystemTrayIcon.isSystemTrayAvailable()
+
+    def show(self) -> None:
+        self.tray.show()
+
+    def hide(self) -> None:
+        self.menu.hide()
+        self.tray.hide()
+
+    def notify_warning(self, message: str) -> None:
+        self.tray.showMessage("簡報瑞士刀", message, QSystemTrayIcon.MessageIcon.Warning, 5000)
+
+    def connect_settings(
+        self,
+        *,
+        spotlight_enabled: Callable[[bool], None],
+        spotlight_color: Callable[[str], None],
+        spotlight_opacity: Callable[[int], None],
+        spotlight_size: Callable[[int], None],
+        keystroke_enabled: Callable[[bool], None],
+        keystroke_color: Callable[[str], None],
+        keystroke_opacity: Callable[[int], None],
+    ) -> None:
+        self.panel.spotlight_enabled_changed.connect(spotlight_enabled)
+        self.panel.spotlight_color_changed.connect(spotlight_color)
+        self.panel.spotlight_opacity_changed.connect(spotlight_opacity)
+        self.panel.spotlight_size_changed.connect(spotlight_size)
+        self.panel.keystroke_enabled_changed.connect(keystroke_enabled)
+        self.panel.keystroke_color_changed.connect(keystroke_color)
+        self.panel.keystroke_opacity_changed.connect(keystroke_opacity)