ardupilot-methodic-configurator 2.6.1__py3-none-any.whl → 2.7.1__py3-none-any.whl

ardupilot_methodic_configurator/frontend_tkinter_pair_tuple_combobox.py

@@ -3,7 +3,7 @@
 """
 A combobox GUI with support for complex lists.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+This file is part of ArduPilot Methodic Configurator. https://github.com/ArduPilot/MethodicConfigurator
 
 SPDX-FileCopyrightText: 2024-2025 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
 
@@ -111,6 +111,12 @@ class PairTupleCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
         setup_combobox_mousewheel_handling(self)
 
     def set_entries_tuple(self, list_pair_tuple: list[tuple[str, str]], selected_element: Union[None, str]) -> None:
+        # Clear existing entries before setting new ones
+        self.list_keys.clear()
+        self.list_shows.clear()
+        self.append_entries_tuple(list_pair_tuple, selected_element)
+
+    def append_entries_tuple(self, list_pair_tuple: list[tuple[str, str]], selected_element: Union[None, str]) -> None:
         if isinstance(list_pair_tuple, list):
             for tpl in list_pair_tuple:
                 self.list_keys.append(tpl[0])

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -3,7 +3,7 @@
 """
 Parameter editor GUI.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+This file is part of ArduPilot Methodic Configurator. https://github.com/ArduPilot/MethodicConfigurator
 
 SPDX-FileCopyrightText: 2024-2025 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
 
@@ -11,7 +11,6 @@ SPDX-License-Identifier: GPL-3.0-or-later
 """
 
 import sys
-import time
 import tkinter as tk
 from argparse import ArgumentParser, Namespace
 
@@ -19,23 +18,24 @@ from argparse import ArgumentParser, Namespace
 from logging import basicConfig as logging_basicConfig
 from logging import error as logging_error
 from logging import getLevelName as logging_getLevelName
-from logging import info as logging_info
 from logging import warning as logging_warning
 from tkinter import filedialog, messagebox, ttk
-from typing import Literal, Optional, Union
+from typing import Optional, Union
 
 # from logging import critical as logging_critical
 from webbrowser import open as webbrowser_open  # to open the blog post documentation
 
 from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
+from ardupilot_methodic_configurator.backend_filesystem_freedesktop import FreeDesktop
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
-from ardupilot_methodic_configurator.configuration_manager import ConfigurationManager
+from ardupilot_methodic_configurator.configuration_manager import ConfigurationManager, ExperimentChoice
 from ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox import AutoResizeCombobox
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import (
     BaseWindow,
+    ask_retry_cancel_popup,
     ask_yesno_popup,
     show_error_popup,
     show_info_popup,
@@ -156,10 +156,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
     def __init__(self, configuration_manager: ConfigurationManager) -> None:
         super().__init__()
         self.configuration_manager = configuration_manager
-        # Maintain backward compatibility with existing code
-        self.local_filesystem = configuration_manager.filesystem
 
-        self.at_least_one_changed_parameter_written = False
         self.file_selection_combobox: AutoResizeCombobox
         self.show_only_differences: tk.BooleanVar
         self.annotate_params_into_files: tk.BooleanVar
@@ -169,7 +166,6 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         self.tempcal_imu_progress_window: ProgressWindow
         self.file_upload_progress_window: ProgressWindow
         self.skip_button: ttk.Button
-        self.last_time_asked_to_save: float = 0
         self.gui_complexity = str(ProgramSettings.get_setting("gui_complexity"))
 
         self.root.title(
@@ -193,20 +189,15 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
 
         self.__create_conf_widgets(__version__)
 
-        if self.local_filesystem.configuration_phases:
-            # Get the first two characters of the last configuration step filename
-            last_step_filename = next(reversed(self.local_filesystem.file_parameters.keys()))
-            last_step_nr = int(last_step_filename[:2]) + 1 if len(last_step_filename) >= 2 else 1
+        last_step_nr = self.configuration_manager.get_last_configuration_step_number()
+        if last_step_nr is not None:
+            phases = self.configuration_manager.get_sorted_phases_with_end_and_weight(last_step_nr)
 
-            self.stage_progress_bar = StageProgressBar(
-                self.main_frame, self.local_filesystem.configuration_phases, last_step_nr, self.gui_complexity
-            )
+            self.stage_progress_bar = StageProgressBar(self.main_frame, phases, last_step_nr, self.gui_complexity)
             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.configuration_manager.current_file
-        )
+        self.documentation_frame = DocumentationFrame(self.main_frame, self.configuration_manager)
         self.documentation_frame.documentation_frame.pack(side=tk.TOP, fill="x", expand=False, pady=(2, 2), padx=(4, 4))
 
         self.__create_parameter_area_widgets()
@@ -217,6 +208,10 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         # this one should be on top of the previous one hence the longer time
         if UsagePopupWindow.should_display("parameter_editor"):
             self.root.after(100, self.__display_usage_popup_window(self.root))  # type: ignore[arg-type]
+
+        # Set up startup notification for the main application window
+        FreeDesktop.setup_startup_notification(self.root)  # type: ignore[arg-type]
+
         self.root.mainloop()
 
     def __create_conf_widgets(self, version: str) -> None:
@@ -231,7 +226,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         directory_selection_frame = VehicleDirectorySelectionWidgets(
             self,
             config_subframe,
-            self.local_filesystem.vehicle_dir,
+            self.configuration_manager.get_vehicle_directory(),
             destroy_parent_on_open=False,
         )
         if self.gui_complexity != "simple":
@@ -250,7 +245,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         # Create Combobox for intermediate parameter file selection
         self.file_selection_combobox = AutoResizeCombobox(
             file_selection_frame,
-            list(self.local_filesystem.file_parameters.keys()),
+            self.configuration_manager.parameter_files(),
             self.configuration_manager.current_file,
             _(
                 "Select the intermediate parameter file from the list of available"
@@ -326,7 +321,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
 
         # Create a Scrollable parameter editor table
         self.parameter_editor_table = ParameterEditorTable(self.main_frame, self.configuration_manager, self)
-        self.repopulate_parameter_table()
+        self.repopulate_parameter_table(regenerate_from_disk=True)
         self.parameter_editor_table.pack(side="top", fill="both", expand=True)
 
         # Create a frame for the buttons
@@ -354,7 +349,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         annotate_params_checkbox = ttk.Checkbutton(
             checkboxes_frame,
             text=_("Annotate docs into .param files"),
-            state="normal" if self.local_filesystem.doc_dict else "disabled",
+            state="normal" if self.configuration_manager.parameter_documentation_available() else "disabled",
             variable=self.annotate_params_into_files,
             command=lambda: ProgramSettings.set_setting(
                 "annotate_docs_into_param_files", self.annotate_params_into_files.get()
@@ -419,7 +414,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             state=(
                 "normal"
                 if self.gui_complexity != "simple"
-                or self.configuration_manager.is_configuration_step_optional(self.configuration_manager.current_file)
+                or self.configuration_manager.is_configuration_step_optional()
                 or not self.configuration_manager.is_fc_connected
                 else "disabled"
             )
@@ -505,7 +500,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
 
         try:
             # Inject GUI callbacks into business logic workflow
-            success = self.configuration_manager.handle_imu_temperature_calibration_workflow(
+            _success = self.configuration_manager.handle_imu_temperature_calibration_workflow(
                 selected_file,
                 ask_user_confirmation=ask_yesno_popup,
                 select_file=select_file,
@@ -514,47 +509,43 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
                 progress_callback=self.tempcal_imu_progress_window.update_progress_bar_300_pct,
             )
 
-            if success:
-                # Force writing doc annotations to file
-                self.parameter_editor_table.set_at_least_one_param_edited(True)
-
         finally:
             self.tempcal_imu_progress_window.destroy()
 
-    def __handle_dialog_choice(self, result: list, dialog: tk.Toplevel, choice: Optional[bool]) -> None:
+    def __handle_dialog_choice(self, result: list, dialog: tk.Toplevel, choice: ExperimentChoice) -> None:
         result.append(choice)
         dialog.destroy()
 
-    def __should_copy_fc_values_to_file(self, selected_file: str) -> None:  # pylint: disable=too-many-locals
-        should_copy, relevant_fc_params, auto_changed_by = self.configuration_manager.should_copy_fc_values_to_file(
-            selected_file
-        )
-        if should_copy and relevant_fc_params and auto_changed_by:
-            msg = _(
-                "This configuration step requires external changes by: {auto_changed_by}\n\n"
-                "The external tool experiment procedure is described in the tuning guide.\n\n"
-                "Choose an option:\n"
-                "* CLOSE - Close the application and go perform the experiment\n"
-                "* YES - Copy current FC values to {selected_file} (if you've already completed the experiment)\n"
-                "* NO - Continue without copying values (if you haven't performed the experiment yet,"
-                " but know what you are doing)"
-            ).format(auto_changed_by=auto_changed_by, selected_file=selected_file)
-
+    def __should_copy_fc_values_to_file(self, selected_file: str) -> None:
+        def ask_user_choice(title: str, message: str, options: list[str]) -> ExperimentChoice:  # pylint: disable=too-many-locals
+            """GUI callback for asking user choice with custom dialog."""
             # Create custom dialog with Close, Yes, No buttons
             dialog = tk.Toplevel(self.root)
             # Hide dialog initially to prevent flickering
             dialog.withdraw()
             dialog.transient(self.root)
-            dialog.title(_("Update file with values from FC?"))
+            dialog.title(title)
             dialog.resizable(width=False, height=False)
             dialog.protocol("WM_DELETE_WINDOW", dialog.destroy)
 
             # Message text
-            message_label = tk.Label(dialog, text=msg, justify=tk.LEFT, padx=20, pady=10)
+            message_label = tk.Label(dialog, text=message, justify=tk.LEFT, padx=20, pady=10)
             message_label.pack(padx=10, pady=10)
 
+            # Clickable link to tuning guide
+            safe_font_config = get_safe_font_config()
+            link_label = tk.Label(
+                dialog,
+                text=_("Click here to open the Tuning Guide relevant Section"),
+                fg="blue",
+                cursor="hand2",
+                font=(str(safe_font_config["family"]), int(safe_font_config["size"]), "underline"),
+            )
+            link_label.pack(pady=(0, 10))
+            link_label.bind("<Button-1>", lambda _e: self.configuration_manager.open_documentation_in_browser(selected_file))
+
             # Result variable
-            result: list[Optional[Literal[True, False]]] = [None]
+            result: list[ExperimentChoice] = []
 
             # Button frame
             button_frame = tk.Frame(dialog)
@@ -563,25 +554,31 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             # Close button (default)
             close_button = tk.Button(
                 button_frame,
-                text=_("Close"),
+                text=options[0],  # "Close"
                 width=10,
-                command=lambda: self.__handle_dialog_choice(result, dialog, choice=None),
+                command=lambda: self.__handle_dialog_choice(result, dialog, choice="close"),
             )
             close_button.pack(side=tk.LEFT, padx=5)
 
             # Yes button
             yes_button = tk.Button(
-                button_frame, text=_("Yes"), width=10, command=lambda: self.__handle_dialog_choice(result, dialog, choice=True)
+                button_frame,
+                text=options[1],
+                width=10,  # "Yes"
+                command=lambda: self.__handle_dialog_choice(result, dialog, choice=True),
             )
             yes_button.pack(side=tk.LEFT, padx=5)
 
             # No button
             no_button = tk.Button(
-                button_frame, text=_("No"), width=10, command=lambda: self.__handle_dialog_choice(result, dialog, choice=False)
+                button_frame,
+                text=options[2],
+                width=10,  # "No"
+                command=lambda: self.__handle_dialog_choice(result, dialog, choice=False),
             )
             no_button.pack(side=tk.LEFT, padx=5)
 
-            dialog.bind("<Return>", lambda _event: self.__handle_dialog_choice(result, dialog, None))
+            dialog.bind("<Return>", lambda _event: self.__handle_dialog_choice(result, dialog, choice="close"))
 
             # Center the dialog on the parent window
             dialog.deiconify()
@@ -604,25 +601,27 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
 
             # Wait until dialog is closed
             self.root.wait_window(dialog)
-            response = result[-1] if len(result) > 1 else None
+            return result[-1] if result else "close"
 
-            if response is True:  # Yes option
-                params_copied = self.configuration_manager.copy_fc_values_to_file(selected_file, relevant_fc_params)
-                if params_copied:
-                    self.parameter_editor_table.set_at_least_one_param_edited(True)
-            elif response is None:  # Close option
-                sys.exit(0)
-            # If response is False (No option), do nothing and continue
+        result = self.configuration_manager.handle_copy_fc_values_workflow(
+            selected_file,
+            ask_user_choice,
+            show_info_popup,
+        )
+
+        if result == "close":
+            # User chose to close the application
+            sys.exit(0)
 
     def __should_jump_to_file(self, selected_file: str) -> str:
-        jump_options = self.configuration_manager.get_file_jump_options(selected_file)
-        for dest_file, msg in jump_options.items():
-            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
+        dest_file = self.configuration_manager.handle_file_jump_workflow(
+            selected_file,
+            self.gui_complexity,
+            ask_yesno_popup,
+        )
+        if dest_file != selected_file:
+            self.file_selection_combobox.set(dest_file)
+        return dest_file
 
     def __should_download_file_from_url(self, selected_file: str) -> None:
         self.configuration_manager.should_download_file_from_url_workflow(
@@ -657,22 +656,22 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             self.__do_tempcal_imu(selected_file)
             # open the documentation of the next step in the browser,
             # before giving the user the option to close the SW in the __should_copy_fc_values_to_file method
-            self.documentation_frame.open_documentation_in_browser(selected_file)
+            if self.documentation_frame.get_auto_open_documentation_in_browser() or self.gui_complexity == "simple":
+                self.configuration_manager.open_documentation_in_browser(selected_file)
             self.__should_copy_fc_values_to_file(selected_file)
             selected_file = self.__should_jump_to_file(selected_file)
             self.__should_download_file_from_url(selected_file)
             self.__should_upload_file_to_fc(selected_file)
 
-            # Update the current_file attribute to the selected file
+            # current_file might have been changed by jump, so update again
             self.configuration_manager.current_file = selected_file
-            self.at_least_one_changed_parameter_written = False
-            self.documentation_frame.refresh_documentation_labels(selected_file)
-            self.documentation_frame.update_why_why_now_tooltip(selected_file)
-            self.repopulate_parameter_table()
+            self.documentation_frame.refresh_documentation_labels()
+            self.documentation_frame.update_why_why_now_tooltip()
+            self.repopulate_parameter_table(regenerate_from_disk=True)
             self._update_skip_button_state()
 
     def _update_progress_bar_from_file(self, selected_file: str) -> None:
-        if self.local_filesystem.configuration_phases:
+        if self.configuration_manager.configuration_phases():
             try:
                 step_nr = int(selected_file[:2])
                 self.stage_progress_bar.update_progress(step_nr)
@@ -690,41 +689,18 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         if not redownload:
             self.on_param_file_combobox_change(None, forced=True)  # the initial param read will trigger a table update
 
-    def repopulate_parameter_table(self) -> None:
+    def repopulate_parameter_table(self, regenerate_from_disk: bool) -> None:
         if not self.configuration_manager.current_file:
             return  # no file was yet selected, so skip it
         # Re-populate the table with the new parameters
-        self.parameter_editor_table.repopulate(self.show_only_differences.get(), self.gui_complexity)
+        self.parameter_editor_table.repopulate(self.show_only_differences.get(), self.gui_complexity, regenerate_from_disk)
 
     def on_show_only_changed_checkbox_change(self) -> None:
-        self.repopulate_parameter_table()
-
-    def upload_params_that_require_reset(self, selected_params: dict) -> None:
-        """
-        Write only the selected parameters to the flight controller that require a reset.
-
-        After the reset, the other parameters that do not require a reset must still be written to the flight controller.
-        """
-        self.reset_progress_window = ProgressWindow(
-            self.root,
-            _("Resetting Flight Controller"),
-            _("Waiting for {} of {} seconds"),
-            only_show_when_update_progress_called=True,
-        )
-
-        if self.configuration_manager.upload_parameters_that_require_reset_workflow(
-            selected_params,
-            ask_confirmation=ask_yesno_popup,
-            show_error=show_error_popup,
-            progress_callback=self.reset_progress_window.update_progress_bar,
-        ):
-            self.at_least_one_changed_parameter_written = True
-
-        self.reset_progress_window.destroy()  # for the case that we are doing a test and there is no real FC connected
+        self.repopulate_parameter_table(regenerate_from_disk=False)
 
     def on_upload_selected_click(self) -> None:
         self.write_changes_to_intermediate_parameter_file()
-        selected_params = self.parameter_editor_table.get_upload_selected_params(str(self.gui_complexity))
+        selected_params = self.parameter_editor_table.get_upload_selected_params(self.gui_complexity)
         if selected_params:
             if self.configuration_manager.fc_parameters:
                 self.upload_selected_params(selected_params)
@@ -741,41 +717,31 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
 
     # This function can recurse multiple times if there is an upload error
     def upload_selected_params(self, selected_params: dict) -> None:
-        logging_info(
-            _("Uploading %d selected %s parameters to flight controller..."),
-            len(selected_params),
-            self.configuration_manager.current_file,
+        # Create progress windows
+        self.reset_progress_window = ProgressWindow(
+            self.root,
+            _("Resetting Flight Controller"),
+            _("Waiting for {} of {} seconds"),
+            only_show_when_update_progress_called=True,
         )
-
-        self.upload_params_that_require_reset(selected_params)
-
-        # Use ConfigurationManager to handle the business logic
-        nr_changed = self.configuration_manager.upload_selected_parameters_workflow(
-            selected_params, show_error=show_error_popup
+        self.param_download_progress_window = ProgressWindow(
+            self.root,
+            _("Re-downloading FC parameters"),
+            _("Downloaded {} of {} parameters"),
         )
 
-        # Update GUI state if any parameters were changed
-        if nr_changed > 0:
-            self.at_least_one_changed_parameter_written = True
-
-        if self.at_least_one_changed_parameter_written:
-            # Re-download all parameters, in case one of them changed, and validate that all uploads were successful
-            self.download_flight_controller_parameters(redownload=True)
-            param_upload_error = self.configuration_manager.validate_uploaded_parameters(selected_params)
-
-            if param_upload_error:
-                if messagebox.askretrycancel(
-                    _("Parameter upload error"),
-                    _("Failed to upload the following parameters to the flight controller:\n")
-                    + f"{(', ').join(param_upload_error)}",
-                ):
-                    self.upload_selected_params(selected_params)
-            else:
-                logging_info(_("All parameters uploaded to the flight controller successfully"))
-
-            self.configuration_manager.export_fc_params_missing_or_different()
-
-        self.local_filesystem.write_last_uploaded_filename(self.configuration_manager.current_file)
+        try:
+            self.configuration_manager.upload_selected_params_workflow(
+                selected_params,
+                ask_confirmation=ask_yesno_popup,
+                ask_retry_cancel=ask_retry_cancel_popup,
+                show_error=show_error_popup,
+                progress_callback_for_reset=self.reset_progress_window.update_progress_bar,
+                progress_callback_for_download=self.param_download_progress_window.update_progress_bar,
+            )
+        finally:
+            self.reset_progress_window.destroy()
+            self.param_download_progress_window.destroy()
 
     def on_download_last_flight_log_click(self) -> None:
         """Handle the download last flight log button click."""
@@ -811,7 +777,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             skip_button_state = (
                 "normal"
                 if self.gui_complexity != "simple"
-                or self.configuration_manager.is_configuration_step_optional(self.configuration_manager.current_file)
+                or self.configuration_manager.is_configuration_step_optional()
                 or not self.configuration_manager.is_fc_connected
                 else "disabled"
             )
@@ -821,7 +787,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         self.write_changes_to_intermediate_parameter_file()
 
         # Use ConfigurationManager to get the next non-optional file
-        next_file = self.configuration_manager.get_next_non_optional_file(self.configuration_manager.current_file)
+        next_file = self.configuration_manager.get_next_non_optional_file()
 
         if next_file is None:
             # No more files to process, write summary and close
@@ -839,25 +805,10 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         self.on_param_file_combobox_change(None)
 
     def write_changes_to_intermediate_parameter_file(self) -> None:
-        elapsed_since_last_ask = time.time() - self.last_time_asked_to_save
-        # if annotate parameters into files is true, we always need to write to file, because
-        # the parameter metadata might have changed, or not be present in the file.
-        # In that situation, avoid asking multiple times to write the file, by checking the time last asked
-        # But only if self.annotate_params_into_files.get()
-        if self.parameter_editor_table.get_at_least_one_param_edited() or (
-            self.annotate_params_into_files.get() and elapsed_since_last_ask > 1.0
-        ):
-            msg = _("Do you want to write the changes to the {current_filename} file?").format(
-                current_filename=self.configuration_manager.current_file
-            )
-            if messagebox.askyesno(_("One or more parameters have been edited"), msg.format(**locals())):
-                self.local_filesystem.export_to_param(
-                    self.local_filesystem.file_parameters[self.configuration_manager.current_file],
-                    self.configuration_manager.current_file,
-                    annotate_doc=self.annotate_params_into_files.get(),
-                )
-        self.parameter_editor_table.set_at_least_one_param_edited(False)
-        self.last_time_asked_to_save = time.time()
+        self.configuration_manager.handle_write_changes_workflow(
+            self.annotate_params_into_files.get(),
+            ask_yesno_popup,
+        )
 
     def close_connection_and_quit(self) -> None:
         focused_widget = self.parameter_editor_table.view_port.focus_get()

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_documentation_frame.py

@@ -1,7 +1,7 @@
 """
 The documentation frame containing the documentation for the current configuration step.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+This file is part of ArduPilot Methodic Configurator. https://github.com/ArduPilot/MethodicConfigurator
 
 SPDX-FileCopyrightText: 2024-2025 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
 
@@ -11,11 +11,11 @@ SPDX-License-Identifier: GPL-3.0-or-later
 import tkinter as tk
 from platform import system as platform_system
 from tkinter import ttk
-from webbrowser import open as webbrowser_open  # to open the blog post documentation
+from webbrowser import open as webbrowser_open  # to open the web documentation
 
 from ardupilot_methodic_configurator import _
-from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
+from ardupilot_methodic_configurator.configuration_manager import ConfigurationManager
 from ardupilot_methodic_configurator.frontend_tkinter_rich_text import get_widget_font_family_and_size
 from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
 
@@ -49,16 +49,16 @@ class DocumentationFrame:
         ),
     )
 
-    def __init__(self, root: tk.Widget, local_filesystem: LocalFilesystem, current_file: str) -> None:
+    def __init__(self, root: tk.Widget, configuration_manager: ConfigurationManager) -> None:
         self.root = root
-        self.local_filesystem = local_filesystem
+        self.configuration_manager = configuration_manager
         self.documentation_frame: ttk.LabelFrame
         self.documentation_labels: dict[str, ttk.Label] = {}
         self.mandatory_level: ttk.Progressbar
         self.auto_open_var = tk.BooleanVar(value=bool(ProgramSettings.get_setting("auto_open_doc_in_browser")))
-        self._create_documentation_frame(current_file)
+        self._create_documentation_frame()
 
-    def _create_documentation_frame(self, current_file: str) -> None:
+    def _create_documentation_frame(self) -> None:
         self.documentation_frame = ttk.LabelFrame(self.root, text=_("Documentation"))
 
         # Create a grid structure within the documentation_frame
@@ -86,8 +86,8 @@ class DocumentationFrame:
         documentation_grid.columnconfigure(1, weight=1)
 
         # Dynamically update the documentation text and URL links
-        self.refresh_documentation_labels(current_file)
-        self.update_why_why_now_tooltip(current_file)
+        self.refresh_documentation_labels()
+        self.update_why_why_now_tooltip()
 
     def _create_bottom_row(self, documentation_grid: ttk.Frame, row: int) -> None:
         bottom_frame = ttk.Frame(documentation_grid)
@@ -111,52 +111,28 @@ class DocumentationFrame:
         )
         auto_open_checkbox.pack(side=tk.LEFT, expand=False)
 
-    def update_why_why_now_tooltip(self, current_file: str) -> None:
-        why_tooltip_text = self.local_filesystem.get_seq_tooltip_text(current_file, "why")
-        why_now_tooltip_text = self.local_filesystem.get_seq_tooltip_text(current_file, "why_now")
-        tooltip_text = ""
-        if why_tooltip_text:
-            tooltip_text += _("Why: ") + _(why_tooltip_text) + "\n"
-        if why_now_tooltip_text:
-            tooltip_text += _("Why now: ") + _(why_now_tooltip_text)
+    def update_why_why_now_tooltip(self) -> None:
+        tooltip_text = self.configuration_manager.get_why_why_now_tooltip()
         if tooltip_text:
             show_tooltip(self.documentation_frame, tooltip_text, position_below=False)
 
-    def open_documentation_in_browser(self, current_file: str) -> None:
-        _blog_text, blog_url = self.local_filesystem.get_documentation_text_and_url(current_file, "blog")
-        _wiki_text, wiki_url = self.local_filesystem.get_documentation_text_and_url(current_file, "wiki")
-        _external_tool_text, external_tool_url = self.local_filesystem.get_documentation_text_and_url(
-            current_file, "external_tool"
-        )
+    def get_auto_open_documentation_in_browser(self) -> bool:
+        return self.auto_open_var.get()
 
-        if self.auto_open_var.get() or ProgramSettings.get_setting("gui_complexity") == "simple":
-            if wiki_url:
-                webbrowser_open(url=wiki_url, new=0, autoraise=False)
-            if external_tool_url:
-                webbrowser_open(url=external_tool_url, new=0, autoraise=False)
-            if blog_url:
-                webbrowser_open(url=blog_url, new=0, autoraise=True)
-
-    def refresh_documentation_labels(self, current_file: str) -> None:
-        if current_file:
-            title = _("{current_file} Documentation")
-            frame_title = title.format(**locals())
-        else:
-            frame_title = _("Documentation")
+    def refresh_documentation_labels(self) -> None:
+        frame_title = self.configuration_manager.get_documentation_frame_title()
         self.documentation_frame.config(text=frame_title)
 
-        blog_text, blog_url = self.local_filesystem.get_documentation_text_and_url(current_file, "blog")
+        blog_text, blog_url = self.configuration_manager.get_documentation_text_and_url("blog")
         self._refresh_documentation_label(self.BLOG_LABEL, _(blog_text) if blog_text else "", blog_url)
-        wiki_text, wiki_url = self.local_filesystem.get_documentation_text_and_url(current_file, "wiki")
+        wiki_text, wiki_url = self.configuration_manager.get_documentation_text_and_url("wiki")
         self._refresh_documentation_label(self.WIKI_LABEL, _(wiki_text) if wiki_text else "", wiki_url)
-        external_tool_text, external_tool_url = self.local_filesystem.get_documentation_text_and_url(
-            current_file, "external_tool"
-        )
+        external_tool_text, external_tool_url = self.configuration_manager.get_documentation_text_and_url("external_tool")
         self._refresh_documentation_label(
             self.EXTERNAL_TOOL_LABEL, _(external_tool_text) if external_tool_text else "", external_tool_url
         )
-        mandatory_text, _mandatory_url = self.local_filesystem.get_documentation_text_and_url(current_file, "mandatory")
-        self._refresh_mandatory_level(current_file, mandatory_text)
+        mandatory_text, _mandatory_url = self.configuration_manager.get_documentation_text_and_url("mandatory")
+        self._refresh_mandatory_level(mandatory_text)
 
     def _refresh_documentation_label(self, label_key: str, text: str, url: str, url_expected: bool = True) -> None:
         label = self.documentation_labels[label_key]
@@ -175,17 +151,7 @@ class DocumentationFrame:
             if url_expected:
                 show_tooltip(label, _("Documentation URL not available"))
 
-    def _refresh_mandatory_level(self, current_file: str, text: str) -> None:
-        _used_indirectly_by_the_tooltip = current_file
-        try:
-            # Extract up to 3 digits from the start of the mandatory text
-            percentage = int("".join([c for c in text[:3] if c.isdigit()]))
-            if 0 <= percentage <= 100:
-                self.mandatory_level.config(value=percentage)
-                tooltip = _("This configuration step ({current_file} intermediate parameter file) is {percentage}% mandatory")
-            else:
-                raise ValueError
-        except ValueError:
-            self.mandatory_level.config(value=0)
-            tooltip = _("Mandatory level not available for this configuration step ({current_file})")
-        show_tooltip(self.mandatory_level, tooltip.format(**locals()))
+    def _refresh_mandatory_level(self, text: str) -> None:
+        percentage, tooltip = self.configuration_manager.parse_mandatory_level_percentage(text)
+        self.mandatory_level.config(value=percentage)
+        show_tooltip(self.mandatory_level, tooltip)