AMS-BP 0.4.22__py3-none-any.whl → 0.4.40__py3-none-any.whl

AMS_BP/gui/widgets/experiment_config_widget.py

@@ -1,21 +1,27 @@
 from pathlib import Path
 from typing import List
 
+from PyQt6.QtCore import Qt, QTimer
 from PyQt6.QtWidgets import (
     QComboBox,
     QDoubleSpinBox,
     QFormLayout,
+    QGraphicsOpacityEffect,
     QHBoxLayout,
     QLabel,
     QLineEdit,
     QMessageBox,
     QPushButton,
+    QScrollArea,
+    QSizePolicy,
     QSpinBox,
     QTabWidget,
     QVBoxLayout,
     QWidget,
 )
 
+from ...core.configio.convertconfig import create_experiment_from_config
+
 
 class ExperimentConfigWidget(QWidget):
     def __init__(self):
@@ -25,6 +31,36 @@ class ExperimentConfigWidget(QWidget):
         self.laser_position_widgets = {}
 
         layout = QVBoxLayout()
+        layout.setContentsMargins(10, 10, 10, 10)
+        layout.setSpacing(10)
+        self.setLayout(layout)
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
+        self.scanning_area = QWidget()
+        self.scanning_area_layout = QVBoxLayout()
+        self.scanning_area_layout.setContentsMargins(0, 0, 0, 0)
+        self.scanning_area_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.scanning_area.setLayout(self.scanning_area_layout)
+        layout.addWidget(self.scanning_area)
+        # Setup scanning label
+        self.scanning_label = QLabel("Scanning Confocal Selected")
+        self.scanning_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.scanning_label.setStyleSheet(
+            "color: green; font-weight: bold; font-size: 16px;"
+        )
+        layout.addWidget(self.scanning_label)
+        # Reserve space by always having label active, even if invisible
+        self.opacity_effect = QGraphicsOpacityEffect(self.scanning_label)
+        self.scanning_label.setGraphicsEffect(self.opacity_effect)
+        self.opacity_effect.setOpacity(0.0)  # start invisible but reserved
+
+        # Blinking mode control
+        self._scanning_mode = False
+        self._blinking = False
+        self.blink_timer = QTimer(self)
+        self.blink_timer.setInterval(500)  # ms
+        self.blink_timer.timeout.connect(self._toggle_scanning_label_visibility)
+
         form = QFormLayout()
 
         # Experiment Info
@@ -38,13 +74,20 @@ class ExperimentConfigWidget(QWidget):
         self.type_field.addItems(["time-series", "z-stack"])
         form.addRow("Experiment Type:", self.type_field)
 
-        # Z Position (just one for time-series)
+        # Z Position inputs
         self.z_position_inputs: List[QDoubleSpinBox] = []
 
+        # Scrollable container for z-position inputs
+        self.z_scroll_area = QScrollArea()
+        self.z_scroll_area.setWidgetResizable(True)
+        self.z_scroll_area.setFixedHeight(150)  # Adjust height as needed
+
         self.z_position_container = QWidget()
-        self.z_position_layout = QVBoxLayout()
+        self.z_position_layout = QVBoxLayout(self.z_position_container)
         self.z_position_container.setLayout(self.z_position_layout)
-        form.addRow("Z Position(s):", self.z_position_container)
+
+        self.z_scroll_area.setWidget(self.z_position_container)
+        form.addRow("Z Position(s):", self.z_scroll_area)
 
         self.add_z_button = QPushButton("Add Z-Position")
         self.remove_z_button = QPushButton("Remove Z-Position")
@@ -83,12 +126,30 @@ class ExperimentConfigWidget(QWidget):
         layout.addWidget(QLabel("Active Laser Parameters:"))
         layout.addWidget(self.laser_tabs)
 
+        self.setLayout(layout)
+
         # Validate Button
-        self.validate_button = QPushButton("Validate")
+        self.validate_button = QPushButton("Validate Parameters")
         self.validate_button.clicked.connect(self.validate)
         layout.addWidget(self.validate_button)
 
-        self.setLayout(layout)
+    def set_scanning_mode(self, enabled: bool):
+        self._scanning_mode = enabled
+        if enabled:
+            self.opacity_effect.setOpacity(1.0)
+            self.blink_timer.start()
+        else:
+            self.opacity_effect.setOpacity(0.0)
+            self.blink_timer.stop()
+
+    def _toggle_scanning_label_visibility(self):
+        """Toggles label opacity to create blinking without layout shifting."""
+        if self._scanning_mode:
+            current_opacity = self.opacity_effect.opacity()
+            new_opacity = 0.0 if current_opacity > 0.5 else 1.0
+            self.opacity_effect.setOpacity(new_opacity)
+        else:
+            self.opacity_effect.setOpacity(0.0)
 
     def update_z_position_mode(self, mode: str):
         # Clear existing
@@ -189,6 +250,7 @@ class ExperimentConfigWidget(QWidget):
                 for name in self.laser_position_widgets
             ],
             "xyoffset": [w.value() for w in self.xyoffset],
+            "scanning": self._scanning_mode,
         }
 
         if data["experiment_type"] == "z-stack":
@@ -236,10 +298,12 @@ class ExperimentConfigWidget(QWidget):
         positions = data.get("laser_positions_active", [])
         self.set_active_lasers(laser_names, powers=powers, positions=positions)
 
+        # Scanning Confocal
+        scanning_mode = data.get("scanning", False)
+        self.set_scanning_mode(scanning_mode)
+
     def validate(self) -> bool:
         try:
-            from ...configio.convertconfig import create_experiment_from_config
-
             data = self.get_data()
             config_dict = {"experiment": data}
 

AMS_BP/gui/widgets/flurophore_config_widget.py

@@ -11,12 +11,14 @@ from PyQt6.QtWidgets import (
     QMessageBox,
     QPushButton,
     QScrollArea,
+    QSizePolicy,
     QSpinBox,
     QTabWidget,
     QVBoxLayout,
     QWidget,
 )
 
+from ...core.configio.convertconfig import create_fluorophores_from_config
 from .utility_widgets.scinotation_widget import scientific_input_field
 from .utility_widgets.spectrum_widget import SpectrumEditorDialog
 
@@ -33,6 +35,10 @@ class FluorophoreConfigWidget(QWidget):
 
     def setup_ui(self):
         layout = QVBoxLayout()
+        layout.setContentsMargins(10, 10, 10, 10)
+        layout.setSpacing(10)
+        self.setLayout(layout)
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
 
         instructions = QLabel(
             "Configure fluorophores and their respective states and transitions."
@@ -490,8 +496,6 @@ class FluorophoreConfigWidget(QWidget):
 
     def validate(self) -> bool:
         try:
-            from ...configio.convertconfig import create_fluorophores_from_config
-
             data = self.get_data()
             # Try to build fluorophores with the backend logic
 

AMS_BP/gui/widgets/global_config_widget.py

@@ -5,11 +5,14 @@ from PyQt6.QtWidgets import (
     QHBoxLayout,
     QMessageBox,
     QPushButton,
+    QSizePolicy,
     QSpinBox,
     QVBoxLayout,
     QWidget,
 )
 
+from ...core.configio.configmodels import GlobalParameters
+
 
 class GlobalConfigWidget(QWidget):
     def __init__(self):
@@ -18,11 +21,12 @@ class GlobalConfigWidget(QWidget):
 
     def setup_ui(self):
         layout = QVBoxLayout()
+        layout.setContentsMargins(10, 10, 10, 10)
+        layout.setSpacing(10)
+        self.setLayout(layout)
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
         form = QFormLayout()
-        # Validation button
-        self.validate_button = QPushButton("Validate Parameters")
-        self.validate_button.clicked.connect(self.validate)
-        layout.addWidget(self.validate_button)
 
         # Sample plane dimensions
         self.sample_plane_width = QSpinBox()
@@ -71,6 +75,11 @@ class GlobalConfigWidget(QWidget):
 
         self.setLayout(layout)
 
+        # Validation button
+        self.validate_button = QPushButton("Validate Parameters")
+        self.validate_button.clicked.connect(self.validate)
+        layout.addWidget(self.validate_button)
+
     def set_defaults(self):
         """Set default values for the form fields"""
         self.sample_plane_width.setValue(50)  # 1000 μm
@@ -115,8 +124,6 @@ class GlobalConfigWidget(QWidget):
 
     def validate(self) -> bool:
         try:
-            from ...configio.configmodels import GlobalParameters
-
             data = self.get_data()
 
             GlobalParameters(**data)

AMS_BP/gui/widgets/laser_config_widget.py

@@ -8,12 +8,15 @@ from PyQt6.QtWidgets import (
     QLineEdit,
     QMessageBox,
     QPushButton,
+    QSizePolicy,
     QSpinBox,
     QTabWidget,
     QVBoxLayout,
     QWidget,
 )
 
+from ...core.configio.convertconfig import create_lasers_from_config
+
 
 class LaserConfigWidget(QWidget):
     laser_names_updated = pyqtSignal(list)
@@ -22,11 +25,12 @@ class LaserConfigWidget(QWidget):
         super().__init__()
         self.laser_name_widgets = []
         layout = QVBoxLayout()
-        form = QFormLayout()
+        layout.setContentsMargins(10, 10, 10, 10)
+        layout.setSpacing(10)
+        self.setLayout(layout)
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
 
-        self.validate_button = QPushButton("Validate")
-        self.validate_button.clicked.connect(self.validate)
-        layout.addWidget(self.validate_button)
+        form = QFormLayout()
 
         self.num_lasers = QSpinBox()
         self.num_lasers.setRange(1, 10)
@@ -44,6 +48,10 @@ class LaserConfigWidget(QWidget):
         layout.addWidget(self.laser_tabs)
         self.setLayout(layout)
 
+        self.validate_button = QPushButton("Validate Parameters")
+        self.validate_button.clicked.connect(self.validate)
+        layout.addWidget(self.validate_button)
+
     def set_confocal_mode(self, enabled: bool):
         for i in range(self.laser_tabs.count()):
             tab = self.laser_tabs.widget(i)
@@ -75,8 +83,6 @@ class LaserConfigWidget(QWidget):
 
     def validate(self) -> bool:
         try:
-            from ...configio.convertconfig import create_lasers_from_config
-
             data = self.get_data()
             create_lasers_from_config({"lasers": data})
 

AMS_BP/gui/widgets/molecule_config_widget.py

@@ -13,12 +13,16 @@ from PyQt6.QtWidgets import (
     QMessageBox,
     QPushButton,
     QScrollArea,
+    QSizePolicy,
     QSpinBox,
     QTabWidget,
     QVBoxLayout,
     QWidget,
 )
 
+from ...core.configio.configmodels import MoleculeParameters
+from ...core.configio.convertconfig import create_dataclass_schema
+
 
 class MoleculeConfigWidget(QWidget):
     # Signal to notify when molecule count changes
@@ -28,6 +32,11 @@ class MoleculeConfigWidget(QWidget):
         super().__init__()
 
         self.main_layout = QVBoxLayout()
+        self.main_layout.setContentsMargins(10, 10, 10, 10)
+        self.main_layout.setSpacing(10)
+        self.setLayout(self.main_layout)
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
         self.setLayout(self.main_layout)
 
         # Number of molecule types spinner
@@ -41,11 +50,6 @@ class MoleculeConfigWidget(QWidget):
         self.num_types_layout.addWidget(self.num_types_spinner)
         self.num_types_layout.addStretch()
 
-        # Validate button
-        self.validate_button = QPushButton("Validate")
-        self.validate_button.clicked.connect(self.validate)
-        self.num_types_layout.addWidget(self.validate_button)
-
         self.main_layout.addLayout(self.num_types_layout)
 
         # Create tab widget to hold molecule type configs
@@ -56,6 +60,11 @@ class MoleculeConfigWidget(QWidget):
         self.molecule_type_widgets = []
         self.update_molecule_types(1)
 
+        # Add the validate button at the bottom
+        self.validate_button = QPushButton("Validate Parameters")
+        self.validate_button.clicked.connect(self.validate)
+        self.main_layout.addWidget(self.validate_button)
+
     def _on_molecule_count_changed(self, count):
         self.update_molecule_types(count)
         self.molecule_count_changed.emit(count)
@@ -93,8 +102,6 @@ class MoleculeConfigWidget(QWidget):
             data = self.get_data()
 
             # This will validate the schema using the backend logic
-            from ...configio.configmodels import MoleculeParameters
-            from ...configio.convertconfig import create_dataclass_schema
 
             _ = create_dataclass_schema(MoleculeParameters, data)
 
@@ -114,10 +121,6 @@ class MoleculeConfigWidget(QWidget):
         Load molecule configuration from TOML config format.
         """
         try:
-            # Validate format first
-            from ...configio.configmodels import MoleculeParameters
-            from ...configio.convertconfig import create_dataclass_schema
-
             validated = create_dataclass_schema(MoleculeParameters, config)
 
             # Determine number of types

AMS_BP/gui/widgets/utility_widgets/toggleswitch_widget.py

@@ -0,0 +1,60 @@
+from PyQt6.QtCore import QPropertyAnimation, QSize, Qt, pyqtSignal
+from PyQt6.QtGui import QBrush, QColor, QPainter
+from PyQt6.QtWidgets import QWidget
+
+
+class ToggleSwitch(QWidget):
+    toggled = pyqtSignal(bool)
+
+    def __init__(self, parent=None, checked=False):
+        super().__init__(parent)
+        self.setFixedSize(50, 28)
+        self._checked = checked
+        self._circle_position = 2 if not checked else 24
+
+        self.animation = QPropertyAnimation(self, b"")
+        self.animation.setDuration(200)
+
+    def sizeHint(self):
+        return QSize(50, 28)
+
+    def mousePressEvent(self, event):
+        self._checked = not self._checked
+        self.animate_toggle()
+        self.toggled.emit(self._checked)
+        self.update()
+
+    def animate_toggle(self):
+        start = self._circle_position
+        end = 24 if self._checked else 2
+        self.animation.stop()
+        self.animation.setStartValue(start)
+        self.animation.setEndValue(end)
+        self.animation.valueChanged.connect(self.set_circle_position)
+        self.animation.start()
+
+    def set_circle_position(self, val):
+        self._circle_position = val
+        self.update()
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        # NEW: Background indicates *next* theme
+        bg_color = QColor("#dddddd") if self._checked else QColor("#333333")
+        painter.setBrush(QBrush(bg_color))
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.drawRoundedRect(0, 0, self.width(), self.height(), 14, 14)
+
+        # Handle (always green)
+        painter.setBrush(QBrush(QColor("#008000")))
+        painter.drawEllipse(int(self._circle_position), 2, 24, 24)
+
+    def isChecked(self):
+        return self._checked
+
+    def setChecked(self, checked: bool):
+        self._checked = checked
+        self._circle_position = 24 if checked else 2
+        self.update()

AMS_BP/gui/{configuration_window.py → windows/configuration_window.py}

@@ -2,33 +2,35 @@ from pathlib import Path
 
 import tomli
 import tomlkit
+from PyQt6.QtCore import Qt
 from PyQt6.QtWidgets import (
-    QComboBox,
     QDialog,
     QFileDialog,
     QHBoxLayout,
     QLabel,
+    QListWidget,
     QMessageBox,
     QPushButton,
+    QSizePolicy,
     QStackedWidget,
     QTextEdit,
     QVBoxLayout,
     QWidget,
 )
 
+from ..widgets.camera_config_widget import CameraConfigWidget
+from ..widgets.cell_config_widget import CellConfigWidget
+from ..widgets.channel_config_widget import ChannelConfigWidget
+from ..widgets.condensate_config_widget import CondensateConfigWidget
+from ..widgets.experiment_config_widget import ExperimentConfigWidget
+from ..widgets.flurophore_config_widget import FluorophoreConfigWidget
+from ..widgets.general_config_widget import GeneralConfigWidget
+from ..widgets.global_config_widget import GlobalConfigWidget
+from ..widgets.laser_config_widget import LaserConfigWidget
+from ..widgets.molecule_config_widget import MoleculeConfigWidget
+from ..widgets.output_config_widget import OutputConfigWidget
+from ..widgets.psf_config_widget import PSFConfigWidget
 from .help_window import HelpWindow
-from .widgets.camera_config_widget import CameraConfigWidget
-from .widgets.cell_config_widget import CellConfigWidget
-from .widgets.channel_config_widget import ChannelConfigWidget
-from .widgets.condensate_config_widget import CondensateConfigWidget
-from .widgets.experiment_config_widget import ExperimentConfigWidget
-from .widgets.flurophore_config_widget import FluorophoreConfigWidget
-from .widgets.general_config_widget import GeneralConfigWidget
-from .widgets.global_config_widget import GlobalConfigWidget
-from .widgets.laser_config_widget import LaserConfigWidget
-from .widgets.molecule_config_widget import MoleculeConfigWidget
-from .widgets.output_config_widget import OutputConfigWidget
-from .widgets.psf_config_widget import PSFConfigWidget
 
 
 class ConfigEditor(QWidget):
@@ -36,54 +38,63 @@ class ConfigEditor(QWidget):
         super().__init__()
         self.setWindowTitle("Simulation Configuration Editor")
 
-        # Create the main layout for the window
-        layout = QVBoxLayout()
-
-        # Create a horizontal layout for the dropdown and the tab index label
-        dropdown_layout = QHBoxLayout()
-
-        # Add a QLabel for the instruction/title about the dropdown
-        dropdown_title = QLabel(
-            "Use the dropdown below to set the parameters for each tab:"
-        )
-        dropdown_layout.addWidget(dropdown_title)
-
-        # Create a QComboBox (dropdown menu) for selecting tabs
-        self.dropdown = QComboBox()
-        self.dropdown.addItems(
-            [
-                "General",
-                "Global Parameters",
-                "Cell Parameters",
-                "Molecule Parameters",
-                "Condensate Parameters",
-                "Define fluorophores",
-                "Camera Parameters",
-                "PSF Parameters",
-                "Laser Parameters",
-                "Channels Parameters",
-                "Saving Instructions",
-                "Experiment Builder",
-            ]
+        # === Main horizontal layout: [Side Navigation | Content Area] ===
+        main_layout = QHBoxLayout(self)
+
+        # === Sidebar: Section Navigation ===
+        self.nav_list = QListWidget()
+        self.sections = [
+            "General",
+            "Global Parameters",
+            "Cell Parameters",
+            "Molecule Parameters",
+            "Condensate Parameters",
+            "Define fluorophores",
+            "Camera Parameters",
+            "PSF Parameters",
+            "Laser Parameters",
+            "Channels Parameters",
+            "Saving Instructions",
+            "Experiment Builder",
+        ]
+        self.nav_list.addItems(self.sections)
+        self.nav_list.setFixedWidth(220)
+        self.nav_list.setSpacing(4)
+        self.nav_list.setCurrentRow(0)
+        self.nav_list.currentRowChanged.connect(self.on_tab_selected)
+        main_layout.addWidget(self.nav_list)
+
+        # === Right panel layout ===
+        right_panel = QVBoxLayout()
+
+        # Step/breadcrumb label
+        self.step_label = QLabel()
+        self.step_label.setAlignment(Qt.AlignmentFlag.AlignLeft)
+        right_panel.addWidget(self.step_label)
+
+        # === Stack of config widgets ===
+        self.stacked_widget = QStackedWidget()
+        self.stacked_widget.setSizePolicy(
+            QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding
         )
-        self.dropdown.currentIndexChanged.connect(
-            self.on_dropdown_change
-        )  # Connect to the change event
+        right_panel.addWidget(self.stacked_widget)
 
-        # Create a QLabel for displaying the current tab index
-        self.tab_index_label = QLabel("1/10")
+        # === Buttons at the bottom ===
+        self.save_button = QPushButton("Ready to save configuration?")
+        self.save_button.clicked.connect(self.save_config)
+        right_panel.addWidget(self.save_button)
 
-        # Add the dropdown and label to the layout
-        dropdown_layout.addWidget(self.dropdown)
-        dropdown_layout.addWidget(self.tab_index_label)
+        self.preview_button = QPushButton("Preview Configuration TOML")
+        self.preview_button.clicked.connect(self.preview_config)
+        right_panel.addWidget(self.preview_button)
 
-        # Add the dropdown layout to the main layout
-        layout.addLayout(dropdown_layout)
+        self.help_button = QPushButton("Get Help on this section")
+        self.help_button.clicked.connect(self.show_help)
+        right_panel.addWidget(self.help_button)
 
-        # Create a QStackedWidget to hold the content for each "tab"
-        self.stacked_widget = QStackedWidget()
+        main_layout.addLayout(right_panel)
 
-        # Initialize the widgets for each "tab"
+        # === Create tab content widgets ===
         self.general_tab = GeneralConfigWidget()
         self.global_tab = GlobalConfigWidget()
         self.cell_tab = CellConfigWidget()
@@ -97,36 +108,38 @@ class ConfigEditor(QWidget):
         self.detector_tab = CameraConfigWidget()
         self.experiment_tab = ExperimentConfigWidget()
 
-        # connections
-        # PSF -> confocal -> lasers
+        # === Widget interconnections ===
         self.psf_tab.confocal_mode_changed.connect(self.laser_tab.set_confocal_mode)
-        # === Molecule -> Fluorophore & Condensate ===
+        self.psf_tab.confocal_mode_changed.connect(
+            self.experiment_tab.set_scanning_mode
+        )
+
         self.molecule_tab.molecule_count_changed.connect(
             self.fluorophore_tab.set_mfluorophore_count
         )
         self.molecule_tab.molecule_count_changed.connect(
             self.condensate_tab.set_molecule_count
         )
-        # === Fluorophore -> Molecule & Condensate ===
+
         self.fluorophore_tab.mfluorophore_count_changed.connect(
             self.molecule_tab.set_molecule_count
         )
         self.fluorophore_tab.mfluorophore_count_changed.connect(
             self.condensate_tab.set_molecule_count
         )
-        # === Condensate -> Molecule & Fluorophore ===
+
         self.condensate_tab.molecule_count_changed.connect(
             self.molecule_tab.set_molecule_count
         )
         self.condensate_tab.molecule_count_changed.connect(
             self.fluorophore_tab.set_mfluorophore_count
         )
-        # === Laser -> Experiment
+
         self.laser_tab.laser_names_updated.connect(
             self.experiment_tab.set_active_lasers
         )
 
-        # Add each tab's widget to the stacked widget
+        # === Add tab widgets to the stack ===
         self.stacked_widget.addWidget(self.general_tab)
         self.stacked_widget.addWidget(self.global_tab)
         self.stacked_widget.addWidget(self.cell_tab)
@@ -140,27 +153,13 @@ class ConfigEditor(QWidget):
         self.stacked_widget.addWidget(self.output_tab)
         self.stacked_widget.addWidget(self.experiment_tab)
 
-        # Set the stacked widget as the central widget
-        layout.addWidget(self.stacked_widget)
-
-        # Create and add the save and help buttons at the bottom
-        self.save_button = QPushButton("Ready to save configuration?")
-        self.save_button.clicked.connect(self.save_config)
-        layout.addWidget(self.save_button)
-
-        self.preview_button = QPushButton("Preview Configuration TOML")
-        self.preview_button.clicked.connect(self.preview_config)
-        layout.addWidget(self.preview_button)
-
-        self.help_button = QPushButton("Get Help on this section")
-        self.help_button.clicked.connect(self.show_help)
-        layout.addWidget(self.help_button)
-
-        # Set the layout for the main window
-        self.setLayout(layout)
+        # Final layout and window size
+        self.setLayout(main_layout)
+        self.setMinimumSize(1100, 750)
+        self.resize(1250, 850)
 
-        # Set initial display
-        self.on_dropdown_change(0)  # Show the first tab (index 0)
+        # Initial tab display
+        self.on_tab_selected(0)
 
     def set_data(self, config: dict):
         if "Cell_Parameters" in config:
@@ -236,14 +235,12 @@ class ConfigEditor(QWidget):
             doc[key] = val
         return doc
 
-    def on_dropdown_change(self, index):
-        """Change the displayed widget based on the dropdown selection."""
+    def on_tab_selected(self, index: int):
+        """Change the displayed widget and update breadcrumb/step label."""
         self.stacked_widget.setCurrentIndex(index)
-        # Update the tab index label (1-based index)
-        total_tabs = (
-            self.dropdown.count()
-        )  # Corrected way to get the total number of items
-        self.tab_index_label.setText(f"{index + 1}/{total_tabs}")
+        total = self.nav_list.count()
+        current = self.nav_list.item(index).text()
+        self.step_label.setText(f"Step {index + 1}/{total} — {current}")
 
     def validate_all_tabs(self) -> bool:
         return all(