Add visual workflow guidance with button highlighting

- Add WidgetHighlighter utility for flashing glow effects on widgets/tabs
- Track session recording paths in RecordProtocol
- Highlight Training protocol after 2+ recordings
- Guide user through Training workflow with button highlights
- Auto-select newly created dataset
- Clear session recordings after dataset creation
- Auto-load trained model in Online protocol
- Highlight Select Recordings when switching to Training

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: RaulSimpetru

myogestic/gui/protocols/online.py

@@ -10,6 +10,7 @@
 from PySide6.QtCore import QObject, Signal
 from PySide6.QtWidgets import QFileDialog
 
+from myogestic.gui.widgets.highlighter import WidgetHighlighter
 from myogestic.gui.widgets.logger import LoggerLevel
 from myogestic.gui.widgets.templates.output_system import OutputSystemTemplate
 from myogestic.gui.widgets.templates.visual_interface import VisualInterface
@@ -71,6 +72,7 @@ def __init__(self, main_window: MyoGestic) -> None:
         super().__init__(main_window)
 
         self._main_window = main_window
+        self._highlighter = WidgetHighlighter(self)
 
         self._selected_visual_interface: VisualInterface | None = None
         self._active_visual_interfaces: dict[str, VisualInterface] = {}
@@ -111,6 +113,9 @@ def __init__(self, main_window: MyoGestic) -> None:
 
         self._output_systems__dict: dict[str, OutputSystemTemplate] = {}
 
+        # Pending model path for auto-loading after training
+        self._pending_model_path: str | None = None
+
     def _update_real_time_filter(self) -> None:
         self._model_interface.set_real_time_filter(self.real_time_filter_combo_box.currentText())
 
@@ -132,6 +137,9 @@ def _update_device_configuration(self, is_configured: bool) -> None:
 
         self.online_load_model_push_button.setEnabled(True)
 
+        # Guide user to load a model
+        self._highlighter.highlight(self.online_load_model_push_button)
+
     def online_emg_update(self, data: np.ndarray) -> None:
         try:
             (
@@ -234,9 +242,11 @@ def _toggle_recording(self):
 
             self.recording_start_time = time.time()
             self.online_record_toggle_push_button.setText("Stop Recording")
+            # Green when recording
+            self.online_record_toggle_push_button.setStyleSheet("background-color: #5cb85c; color: white;")
         else:
             self.online_prediction_toggle_push_button.setEnabled(True)
-            
+
             # Disconnect from the primary VI
             if self._selected_visual_interface is not None:
                 self._selected_visual_interface.incoming_message_signal.disconnect(
@@ -245,6 +255,8 @@ def _toggle_recording(self):
                 self._selected_visual_interface.setup_interface_ui.disconnect_custom_signals()
 
             self.online_record_toggle_push_button.setText("Start Recording")
+            # Red when not recording
+            self.online_record_toggle_push_button.setStyleSheet("background-color: #d9534f; color: white;")
 
             self._save_data()
 
@@ -330,6 +342,9 @@ def _load_model(self) -> None:
             LoggerLevel.INFO,
         )
 
+        # Highlight the Start Prediction button to guide user
+        self._highlighter.highlight(self.online_prediction_toggle_push_button)
+
         if len(self.active_monitoring_widgets) != 0:
             self._send_model_information()
 
@@ -359,6 +374,82 @@ def _load_model(self) -> None:
             k: v(self._main_window, self._model_interface.model.is_classifier) for k, v in current_output_map.items()
         }
 
+    def _auto_load_model(self, model_path: str) -> None:
+        """Load a model programmatically without file dialog.
+
+        This is used after training completes to automatically load the newly
+        trained model into the Online protocol.
+
+        Args:
+            model_path: Full path to the model .pkl file
+        """
+        if not model_path:
+            return
+
+        # Stop any flashing on Load Model button since we're auto-loading
+        self._highlighter._stop_widget_flash(self.online_load_model_push_button)
+
+        # Ensure model interface exists (device must be configured)
+        if self._model_interface is None:
+            self._main_window.logger.print(
+                "Cannot auto-load model: device not configured",
+                LoggerLevel.WARNING,
+            )
+            return
+
+        try:
+            self._model_information__dict = self._model_interface.load_model(model_path)
+        except Exception as e:
+            self._main_window.logger.print(
+                f"Error in auto-loading model: {e}", LoggerLevel.ERROR
+            )
+            return
+
+        label = model_path.split("/")[-1].split("_")[-1].split(".")[0]
+
+        self.online_model_label.setText(f"{label} loaded!")
+
+        self.online_commands_group_box.setEnabled(True)
+        self.online_record_toggle_push_button.setEnabled(False)
+
+        self._main_window.logger.print(
+            f"Model auto-loaded. Label: {label}",
+            LoggerLevel.INFO,
+        )
+
+        # Highlight the Start Prediction button to guide user
+        self._highlighter.highlight(self.online_prediction_toggle_push_button)
+
+        if len(self.active_monitoring_widgets) != 0:
+            self._send_model_information()
+
+        # Get active VIs directly from main window to ensure we have current state
+        active_vi_names = set(self._main_window.active_visual_interfaces.keys())
+        trained_vi_name = self._model_information__dict.get("visual_interface")
+
+        if trained_vi_name and active_vi_names and trained_vi_name not in active_vi_names:
+            self._main_window.logger.print(
+                f"Warning: Model was trained with visual interface '{trained_vi_name}' "
+                f"but it is not among the active interfaces: {active_vi_names}.",
+                LoggerLevel.WARNING,
+            )
+
+        # Only instantiate output systems for VIs that are currently active
+        current_output_map = {
+            k: v for k, v in CONFIG_REGISTRY.output_systems_map.items()
+            if k in active_vi_names
+        }
+
+        self._main_window.logger.print(
+            f"Creating output systems for: {list(current_output_map.keys())}",
+            LoggerLevel.INFO,
+        )
+
+        self._output_systems__dict = {
+            k: v(self._main_window, self._model_interface.model.is_classifier)
+            for k, v in current_output_map.items()
+        }
+
     def close_event(self, event) -> None:
         for output_system in self._output_systems__dict.values():
             output_system.close_event(event)
@@ -402,6 +493,8 @@ def _setup_protocol_ui(self) -> None:
             "Record predictions and ground truth for analysis"
         )
         self.online_record_toggle_push_button.clicked.connect(self._toggle_recording)
+        # Red by default (not recording)
+        self.online_record_toggle_push_button.setStyleSheet("background-color: #d9534f; color: white;")
 
         self.online_prediction_toggle_push_button = self._main_window.ui.onlinePredictionTogglePushButton
         self.online_prediction_toggle_push_button.setToolTip(

myogestic/gui/protocols/protocol.py

@@ -60,6 +60,28 @@ def _protocol_toggled(self, index: int, checked: bool) -> None:
             self._protocol_mode__stacked_widget.setCurrentIndex(index)
             self._current_protocol = self.available_protocols[index]
 
+            # Auto-load pending model when switching to Online protocol
+            if index == 2:  # Online protocol
+                online_protocol = self.available_protocols[2]
+                if (
+                    hasattr(online_protocol, "_pending_model_path")
+                    and online_protocol._pending_model_path
+                ):
+                    online_protocol._auto_load_model(online_protocol._pending_model_path)
+                    online_protocol._pending_model_path = None
+
+            # Highlight Select Recordings button when switching to Training with session recordings
+            if index == 1:  # Training protocol
+                record_protocol = self.available_protocols[0]
+                training_protocol = self.available_protocols[1]
+                if (
+                    hasattr(record_protocol, "_session_recording_paths")
+                    and record_protocol._session_recording_paths
+                ):
+                    training_protocol._highlighter.highlight(
+                        training_protocol.training_create_datasets_select_recordings_push_button
+                    )
+
     def _pass_on_selected_visual_interface(self) -> None:
         for protocol in self.available_protocols:
             protocol._selected_visual_interface = (

myogestic/gui/protocols/record.py

@@ -21,6 +21,7 @@
     QWidget,
 )
 
+from myogestic.gui.widgets.highlighter import WidgetHighlighter
 from myogestic.gui.widgets.logger import LoggerLevel
 from myogestic.gui.widgets.templates.visual_interface import VisualInterface
 from myogestic.utils.constants import RECORDING_DIR_PATH
@@ -82,6 +83,10 @@ class RecordProtocol(QObject):
     def __init__(self, main_window: MyoGestic) -> None:
         super().__init__(main_window)
         self._main_window = main_window
+        self._highlighter = WidgetHighlighter(self)
+
+        # Track recordings made this session for preloading in Training
+        self._session_recording_paths: list[str] = []
 
         self._sampling_frequency: Optional[int] = None
         self._selected_visual_interface: Optional[VisualInterface] = None
@@ -371,14 +376,23 @@ def _accept_recording(self) -> None:
         label = self._review_label_edit.text() or "default"
         biosignal_data, biosignal_timings = self.retrieve_recorded_data()
 
+        saved_path = None
         if self._active_visual_interfaces:
-            self._save_combined_recording(biosignal_data, biosignal_timings, label)
+            saved_path = self._save_combined_recording(biosignal_data, biosignal_timings, label)
         elif self._default_recording_interface is not None:
-            self._save_default_recording(biosignal_data, biosignal_timings, label)
+            saved_path = self._save_default_recording(biosignal_data, biosignal_timings, label)
+
+        # Track recording path for preloading in Training
+        if saved_path:
+            self._session_recording_paths.append(saved_path)
 
         self._reset_all_recording_ui()
         self._main_window.logger.print(f"Recording with label '{label}' accepted!")
 
+        # Guide user to Training protocol after at least 2 recordings
+        if len(self._session_recording_paths) >= 2:
+            self._highlighter.highlight(self._main_window.ui.protocolTrainingRadioButton)
+
     def _reject_recording(self) -> None:
         """Discard recording and reset everything."""
         self._reset_all_recording_ui()
@@ -452,10 +466,12 @@ def _save_combined_recording(
         )
 
         RECORDING_DIR_PATH.mkdir(parents=True, exist_ok=True)
-        with (RECORDING_DIR_PATH / file_name).open("wb") as f:
+        full_path = RECORDING_DIR_PATH / file_name
+        with full_path.open("wb") as f:
             pickle.dump(save_dict, f)
 
         self._main_window.logger.print(f"Recording saved as: {file_name}")
+        return str(full_path)
 
     def _save_default_recording(
         self,
@@ -494,10 +510,12 @@ def _save_default_recording(
         )
 
         RECORDING_DIR_PATH.mkdir(parents=True, exist_ok=True)
-        with (RECORDING_DIR_PATH / file_name).open("wb") as f:
+        full_path = RECORDING_DIR_PATH / file_name
+        with full_path.open("wb") as f:
             pickle.dump(save_dict, f)
 
         self._main_window.logger.print(f"Recording saved as: {file_name}")
+        return str(full_path)
 
     def _reset_all_recording_ui(self) -> None:
         """Reset shared controls and all per-VI UIs."""