fix: prevent hotkey registration from triggering recording

Author: DavidHruby1

src/main.py

@@ -124,6 +124,7 @@ def __init__(self, startup_mode: bool = False) -> None:
         self._cancel_event = threading.Event()
         self._worker: _WorkerThread | None = None
         self._settings_dlg: SettingsDialog | None = None
+        self._settings_hotkey_capture_paused = False
         self._recording = False
         self._enabled = True
 
@@ -334,6 +335,9 @@ def _on_hotkey_pressed(self) -> None:
         if not self._enabled:
             return
 
+        if self._is_hotkey_capture_active() and not self._recording:
+            return
+
         if self._worker is not None:
             return  # Already processing; ignore.
 
@@ -345,9 +349,27 @@ def _on_hotkey_pressed(self) -> None:
 
     def _on_hotkey_released(self) -> None:
         # Hold mode: release during recording → finalize and process.
+        if self._is_hotkey_capture_active() and not self._recording:
+            return
         if self._recording:
             self._finalize_recording()
 
+    def _is_hotkey_capture_active(self) -> bool:
+        return self._settings_dlg is not None and self._settings_dlg.is_hotkey_capture_active()
+
+    def _on_settings_hotkey_capture_active_changed(self, active: bool) -> None:
+        if active:
+            if self._settings_hotkey_capture_paused or self._recording:
+                return
+            self._hotkey.stop()
+            self._settings_hotkey_capture_paused = True
+            return
+
+        if not self._settings_hotkey_capture_paused:
+            return
+        self._make_listener()
+        self._settings_hotkey_capture_paused = False
+
     # ------------------------------------------------------------------
     # Worker result
     # ------------------------------------------------------------------
@@ -434,22 +456,33 @@ def _open_settings(self) -> None:
             calibrate_fn=self._calibrate,
         )
         self._settings_dlg = dlg
-        result = dlg.exec()
-        if result == SettingsDialog.DialogCode.Accepted:
-            save_config(dlg.get_config())
-        self._settings_dlg = None
+        dlg.hotkey_capture_active_changed.connect(self._on_settings_hotkey_capture_active_changed)
+        dlg.applied.connect(self._sync_settings_from_disk)
+        result = SettingsDialog.DialogCode.Rejected
+        try:
+            result = dlg.exec()
+            if result == SettingsDialog.DialogCode.Accepted:
+                save_config(dlg.get_config())
+        finally:
+            self._settings_dlg = None
 
-        # Always reload from disk — Apply may have written new values,
-        # and the user may have changed fields before Cancel.
-        self._config = load_config()
-        self._restart_hotkey()
-        self._rebuild_menu()
+            # Always reload from disk — Apply may have written new values,
+            # and the user may have changed fields before Cancel.
+            self._sync_settings_from_disk()
 
         if result == SettingsDialog.DialogCode.Accepted:
             log.info("Settings updated from dialog")
         else:
             log.info("Settings dialog closed (cancelled); reloaded from disk")
 
+    def _sync_settings_from_disk(self) -> None:
+        old_hotkey = self._config.hotkey
+        old_mode = self._config.recording_mode
+        self._config = load_config()
+        if self._config.hotkey != old_hotkey or self._config.recording_mode != old_mode:
+            self._restart_hotkey()
+        self._rebuild_menu()
+
     # ------------------------------------------------------------------
     # Shutdown
     # ------------------------------------------------------------------

src/settings_dialog.py

@@ -10,7 +10,7 @@
 import logging
 from typing import Callable
 
-from PySide6.QtCore import Qt, Signal
+from PySide6.QtCore import QCoreApplication, QEvent, Qt, Signal
 from PySide6.QtGui import QKeyEvent, QMouseEvent
 from PySide6.QtWidgets import (
     QCheckBox,
@@ -82,6 +82,9 @@ class SettingsDialog(QDialog):
         ``None`` disables the calibrate button.
     """
 
+    hotkey_capture_active_changed = Signal(bool)
+    applied = Signal()
+
     def __init__(
         self,
         config: AppConfig,
@@ -168,7 +171,7 @@ def _build_general_tab(self) -> None:
         self._hotkey_capture = HotkeyCaptureEdit()
         self._hotkey_capture.captured.connect(self._on_hotkey_captured)
         self._hotkey_capture.cancelled.connect(self._stop_hotkey_recording)
-        self._hotkey_record_btn = QPushButton("Record")
+        self._hotkey_record_btn = QPushButton("Register Hotkey")
         self._hotkey_record_btn.setCheckable(True)
         self._hotkey_record_btn.clicked.connect(self._on_hotkey_record_clicked)
         capture_row = QHBoxLayout()
@@ -224,17 +227,23 @@ def _on_hotkey_preset_chosen(self, index: int) -> None:
             self._set_captured_hotkey(hotkey)
 
     def _start_hotkey_recording(self) -> None:
+        if self._hotkey_capture.is_recording():
+            return
         self._hotkey_record_btn.setChecked(True)
         self._hotkey_record_btn.setText("Cancel")
         self._hotkey_error.setVisible(False)
+        self.hotkey_capture_active_changed.emit(True)
         self._hotkey_capture.start_recording()
 
     def _stop_hotkey_recording(self) -> None:
+        if not self._hotkey_capture.is_recording():
+            return
         self._hotkey_record_btn.setChecked(False)
-        self._hotkey_record_btn.setText("Record")
+        self._hotkey_record_btn.setText("Register Hotkey")
         self._hotkey_capture.stop_recording()
         if self._captured_hotkey is not None:
             self._hotkey_capture.show_hotkey(self._captured_hotkey)
+        self.hotkey_capture_active_changed.emit(False)
 
     def _on_hotkey_record_clicked(self, checked: bool) -> None:
         if checked:
@@ -554,22 +563,36 @@ def _on_reset(self) -> None:
     def _on_apply(self) -> None:
         """Apply: collect and persist without closing."""
         with log_duration(log, "Settings apply"):
+            self._stop_hotkey_recording()
             self._collect()
             if not self._show_validation_issue():
                 return
             if not self._sync_startup_or_warn():
                 return
             save_config(self._working)
+            self.applied.emit()
             log.info("Settings applied")
 
     # ------------------------------------------------------------------
     # Overrides
     # ------------------------------------------------------------------
 
     def accept(self) -> None:
+        self._stop_hotkey_recording()
         self._collect()
         super().accept()
 
+    def reject(self) -> None:
+        self._stop_hotkey_recording()
+        super().reject()
+
+    def done(self, result: int) -> None:
+        self._stop_hotkey_recording()
+        super().done(result)
+
+    def is_hotkey_capture_active(self) -> bool:
+        return self._hotkey_capture.is_recording()
+
     def _show_validation_issue(self) -> bool:
         issue = next(iter(validate_config(self._working)), None)
         if issue is None:
@@ -673,15 +696,23 @@ def is_recording(self) -> bool:
         return self._recording
 
     def start_recording(self) -> None:
+        if self._recording:
+            return
         self._recording = True
-        self.setText("press keys or a mouse button…")
+        self.setText("press the new hotkey…")
         self.setFocus(Qt.OtherFocusReason)
+        app = QCoreApplication.instance()
+        if app is not None:
+            app.installEventFilter(self)
         self.grabKeyboard()
-        self.grabMouse()
 
     def stop_recording(self) -> None:
+        if not self._recording:
+            return
         self._recording = False
-        self.releaseMouse()
+        app = QCoreApplication.instance()
+        if app is not None:
+            app.removeEventFilter(self)
         self.releaseKeyboard()
 
     def show_hotkey(self, hotkey: Hotkey) -> None:
@@ -713,6 +744,16 @@ def mousePressEvent(self, event: QMouseEvent) -> None:
         event.accept()
         self.captured.emit(Hotkey(_mods_from_qt(event.modifiers()), "mouse", code))
 
+    def eventFilter(self, watched, event) -> bool:
+        if not self._recording or event.type() != QEvent.Type.MouseButtonPress:
+            return False
+        code = _mouse_button_to_code(event.button())
+        if code is None:
+            return False
+        event.accept()
+        self.captured.emit(Hotkey(_mods_from_qt(event.modifiers()), "mouse", code))
+        return True
+
 
 def _combo_index(combo: QComboBox, data: str) -> int:
     for i in range(combo.count()):