feat(stage progress): present non-optional stage progress in simple mode

Author: amilcarlucas

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -150,7 +150,7 @@ def __init__(self, current_file: str, flight_controller: FlightController, local
         self.tempcal_imu_progress_window: ProgressWindow
         self.file_upload_progress_window: ProgressWindow
         self.last_time_asked_to_save: float = 0
-        self.gui_complexity = ProgramSettings.get_setting("gui_complexity")
+        self.gui_complexity = str(ProgramSettings.get_setting("gui_complexity"))
 
         self.root.title(
             _("Amilcar Lucas's - ArduPilot methodic configurator ") + __version__ + _(" - Parameter file editor and uploader")
@@ -177,10 +177,9 @@ def __init__(self, current_file: str, flight_controller: FlightController, local
             last_step_nr = int(last_step_filename[:2]) + 1 if len(last_step_filename) >= 2 else 1
 
             self.stage_progress_bar = StageProgressBar(
-                self.main_frame, self.local_filesystem.configuration_phases, last_step_nr
+                self.main_frame, self.local_filesystem.configuration_phases, last_step_nr, self.gui_complexity
             )
-            if self.gui_complexity != "simple":
-                self.stage_progress_bar.pack(side=tk.TOP, fill="x", expand=False, pady=(2, 2), padx=(4, 4))
+            self.stage_progress_bar.pack(side=tk.TOP, fill="x", expand=False, pady=(2, 2), padx=(4, 4))
 
         # Create a DocumentationFrame object for the Documentation Content
         self.documentation_frame = DocumentationFrame(self.main_frame, self.local_filesystem, self.current_file)
@@ -558,7 +557,9 @@ def __should_copy_fc_values_to_file(self, selected_file: str) -> None:  # pylint
     def __should_jump_to_file(self, selected_file: str) -> str:
         jump_possible = self.local_filesystem.jump_possible(selected_file)
         for dest_file, msg in jump_possible.items():
-            if messagebox.askyesno(_("Skip some steps?"), _(msg) if msg else _("Skip to {dest_file}?").format(**locals())):
+            if self.gui_complexity == "simple" or messagebox.askyesno(
+                _("Skip some steps?"), _(msg) if msg else _("Skip to {dest_file}?").format(**locals())
+            ):
                 self.file_selection_combobox.set(dest_file)
                 return dest_file
         return selected_file
@@ -821,6 +822,23 @@ def on_skip_click(self, _event: Union[None, tk.Event] = None, force_focus_out_ev
             return
         try:
             next_file_index = files.index(self.current_file) + 1
+            # Skip files with mandatory_level == 0
+            while next_file_index < len(files):
+                next_file = files[next_file_index]
+                mandatory_text, _mandatory_url = self.local_filesystem.get_documentation_text_and_url(next_file, "mandatory")
+                # Extract percentage from mandatory_text like "80% mandatory (20% optional)"
+                percentage = 0
+                if mandatory_text:
+                    try:
+                        percentage = int(mandatory_text.split("%")[0])
+                    except (ValueError, IndexError):
+                        percentage = 0
+
+                # If the file has mandatory_level > 0, use it
+                if percentage > 0:
+                    break
+
+                next_file_index += 1
             if next_file_index >= len(files):
                 self.write_summary_files()
                 # Close the application and the connection

ardupilot_methodic_configurator/frontend_tkinter_stage_progress.py

@@ -53,7 +53,9 @@
 class StageProgressBar(ttk.LabelFrame):  # pylint: disable=too-many-ancestors
     """Stage-segmented Configuration sequence progress UI."""
 
-    def __init__(self, master: Union[tk.Widget, tk.Tk], phases: dict[str, dict], total_steps: int, **kwargs) -> None:
+    def __init__(
+        self, master: Union[tk.Widget, tk.Tk], phases: dict[str, dict], total_steps: int, gui_complexity: str, **kwargs
+    ) -> None:
         super().__init__(master, text=_("Configuration sequence progress"), **kwargs)
         self.phases = phases
         self.total_files = total_steps
@@ -63,7 +65,7 @@ def __init__(self, master: Union[tk.Widget, tk.Tk], phases: dict[str, dict], tot
         self.grid_columnconfigure(0, weight=1)
         self.grid_rowconfigure(0, weight=1)
 
-        self.create_phase_frames()
+        self.create_phase_frames(gui_complexity)
         self.bind("<Configure>", self._on_resize)
         show_tooltip(
             self,
@@ -74,27 +76,40 @@ def __init__(self, master: Union[tk.Widget, tk.Tk], phases: dict[str, dict], tot
             position_below=False,
         )
 
-    def create_phase_frames(self) -> None:
+    def create_phase_frames(self, gui_complexity: str) -> None:
         """Create frames for each phase with progress bars and labels."""
         # Get phases with start positions
         active_phases = {k: v for k, v in self.phases.items() if "start" in v}
 
         # Sort phases by start position
         sorted_phases = dict(sorted(active_phases.items(), key=lambda x: x[1]["start"]))
 
-        num_phases = len(sorted_phases)
+        # Add the end information to each phase using the start of the next phase
+        phase_names = list(sorted_phases.keys())
+        for i, phase_name in enumerate(phase_names):
+            if i < len(phase_names) - 1:
+                next_phase_name = phase_names[i + 1]
+                sorted_phases[phase_name]["end"] = sorted_phases[next_phase_name]["start"]
+            else:
+                sorted_phases[phase_name]["end"] = self.total_files
+            sorted_phases[phase_name]["weight"] = max(2, sorted_phases[phase_name]["end"] - sorted_phases[phase_name]["start"])
+
+        # Calculate non-optional phases
+        non_optional_sorted_phases = {name: data for name, data in sorted_phases.items() if not data.get("optional", False)}
+
+        phases_to_display = non_optional_sorted_phases if gui_complexity == "simple" else sorted_phases
 
         # Create container frame that will expand
         container = ttk.Frame(self)
         container.grid(row=0, column=0, sticky="nsew", padx=5, pady=5)
 
         # Configure container columns to expand equally
-        for i in range(num_phases):
-            container.grid_columnconfigure(i, weight=1, uniform="phase")
-
-        for i, (phase_name, phase_data) in enumerate(sorted_phases.items()):
+        for i, (phase_name, phase_data) in enumerate(phases_to_display.items()):
+            container.grid_columnconfigure(
+                i, weight=phase_data["weight"] if gui_complexity == "simple" else 1, uniform="phase"
+            )
             start = phase_data["start"]
-            end = list(sorted_phases.values())[i + 1]["start"] if i < num_phases - 1 else self.total_files
+            end = phase_data["end"]
             self.phase_frames[phase_name] = self._create_phase_frame(container, i, phase_name, phase_data, (start, end))
 
     def _create_phase_frame(  # pylint: disable=too-many-arguments, too-many-positional-arguments
@@ -229,7 +244,7 @@ def main() -> None:
     config_steps = ConfigurationSteps("", "ArduCopter")
     config_steps.re_init("", "ArduCopter")
 
-    progress = StageProgressBar(root, config_steps.configuration_phases, 54)
+    progress = StageProgressBar(root, config_steps.configuration_phases, 54, "normal")
     progress.pack(padx=10, pady=10, fill="both", expand=True)
 
     # Demo update function

tests/test_frontend_tkinter_stage_progress.py

@@ -30,7 +30,7 @@ def setUp(self) -> None:
             "Milestone": {"description": "A milestone without start"},
         }
         self.total_steps = 30
-        self.progress_bar = StageProgressBar(self.root, self.test_phases, self.total_steps)
+        self.progress_bar = StageProgressBar(self.root, self.test_phases, self.total_steps, gui_complexity="normal")
 
     def tearDown(self) -> None:
         """Clean up after tests."""
@@ -137,7 +137,7 @@ def test_label_text_splitting(self) -> None:
             "Very Long Phase Name Example": {"start": 5},  # Long with spaces
         }
 
-        test_progress = StageProgressBar(self.root, test_texts, 10)
+        test_progress = StageProgressBar(self.root, test_texts, 10, "normal")
 
         for phase_name, frame in test_progress.phase_frames.items():
             label = None