ardupilot-methodic-configurator 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

ardupilot_methodic_configurator/frontend_tkinter_component_template_manager.py

@@ -0,0 +1,196 @@
+"""
+Component template manager for the ArduPilot methodic configurator.
+
+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>, 2025 Francisco Fonseca
+
+SPDX-License-Identifier: GPL-3.0-or-later
+"""
+
+import tkinter as tk
+from collections.abc import Callable as CollectionsCallable
+from tkinter import Menu, messagebox, simpledialog, ttk
+from typing import Any, TypeVar, Union
+
+from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.backend_filesystem_vehicle_components import VehicleComponents
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
+
+T = TypeVar("T")
+
+
+class ComponentTemplateManager:  # pylint: disable=too-many-instance-attributes
+    """Manages component templates for the ArduPilot methodic configurator."""
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        root: Union[tk.Tk, tk.Toplevel],
+        entry_widgets: dict[tuple, Union[ttk.Entry, ttk.Combobox]],
+        get_component_data_callback: CollectionsCallable[[str], dict[str, Any]],
+        update_data_callback: CollectionsCallable[[str, dict[str, Any]], None],
+        derive_template_name_callback: CollectionsCallable[[dict[str, Any]], str],
+        save_component_to_system_templates: bool = False,
+    ) -> None:
+        """
+        Initialize the ComponentTemplateManager.
+
+        Args:
+            root: The root Tkinter window or toplevel widget
+            entry_widgets: Dictionary mapping component paths to entry widgets
+            get_component_data_callback: Callback to get component data
+            update_data_callback: Callback to update data when applying template
+            derive_template_name_callback: Callback to derive an initial template name from component
+            save_component_to_system_templates: Boolean save the component to the system file instead of the user file
+
+        """
+        self.root = root
+        self.entry_widgets = entry_widgets
+        self.buttons: dict[str, ttk.Button] = {}
+        self.current_menu: Union[Menu, None] = None
+        self.template_manager = VehicleComponents(save_component_to_system_templates)
+        self.get_component_data_callback = get_component_data_callback
+        self.update_data_callback = update_data_callback
+        self.derive_template_name_callback = derive_template_name_callback
+
+    def add_template_controls(self, parent_frame: ttk.LabelFrame, component_name: str) -> None:
+        """Add "template dropdown" and "save" buttons for a component."""
+        label_frame = ttk.Frame(parent_frame)
+        label_frame.pack(side=tk.TOP, fill=tk.X)
+
+        label = ttk.Label(label_frame, text=_("Template:"))
+        label.pack(side=tk.LEFT, padx=(5, 5))
+
+        # Create and add the template dropdown button
+        def show_template_for_component() -> None:
+            self.show_template_options(component_name)
+
+        dropdown_button = ttk.Button(label_frame, text="▼", width=2, command=show_template_for_component)
+        show_tooltip(dropdown_button, _("Select a template for this component"))
+        dropdown_button.pack(side=tk.LEFT)
+
+        # Create and add the save template button
+        def save_as_template() -> None:
+            self.save_component_as_template(component_name)
+
+        save_button = ttk.Button(label_frame, text="+", width=2, command=save_as_template)
+        show_tooltip(save_button, _("Save current configuration as template"))
+        save_button.pack(side=tk.LEFT, padx=(5, 0))
+
+        # Store the dropdown button reference
+        self.buttons[component_name] = dropdown_button
+
+    def save_component_as_template(self, component_name: str) -> None:
+        """Save the current component configuration as a template."""
+        component_data = self.get_component_data_callback(component_name)
+        if not component_data:
+            messagebox.showerror(_("Error"), _("No data for component: ") + component_name)
+            return
+
+        initial_template_name = self.derive_initial_template_name(component_data)
+        template_name = simpledialog.askstring(
+            _("Save Template"), _("Enter a name for this template:"), parent=self.root, initialvalue=initial_template_name
+        )
+        if not template_name:
+            return
+
+        templates = self.template_manager.load_component_templates()
+        if component_name not in templates:
+            templates[component_name] = []
+
+        new_template = {"name": template_name, "data": component_data, "is_user_modified": True}
+
+        for i, template in enumerate(templates[component_name]):
+            if template.get("name") == template_name:
+                confirm = messagebox.askyesno(_("Template exists"), _("A template with this name already exists. Overwrite?"))
+                if confirm:
+                    templates[component_name][i] = new_template
+                    self.template_manager.save_component_templates(templates)
+                    messagebox.showinfo(_("Template Saved"), _("Template has been updated"))
+                return
+
+        templates[component_name].append(new_template)
+        self.template_manager.save_component_templates(templates)
+        messagebox.showinfo(_("Template Saved"), _("Template has been saved"))
+
+    def derive_initial_template_name(self, component_data: dict[str, Any]) -> str:
+        """Derive an initial template name from the component data."""
+        return self.derive_template_name_callback(component_data)
+
+    def create_template_dropdown_button(self, parent: ttk.Frame, component_name: str) -> ttk.Button:
+        """Creates a dropdown button for component templates."""
+        button = ttk.Button(parent, text="▼", width=2, command=lambda: self.show_template_options(component_name))
+        show_tooltip(button, _("Select a template for this component"))
+        return button
+
+    def show_template_options(self, component_name: str) -> None:
+        """Shows a dropdown menu with template options for the component."""
+        if isinstance(self.current_menu, Menu):
+            self.current_menu.unpost()
+
+        button = self.buttons.get(component_name)
+        if not button:
+            return
+
+        templates = self.template_manager.load_component_templates()
+        component_templates = templates.get(component_name, [])
+        component_templates = sorted(component_templates, key=lambda x: x.get("name", "").lower())
+
+        menu = Menu(self.root, tearoff=0)
+
+        if component_templates:
+            for template in component_templates:
+                template_name = template.get("name", "Template")
+
+                # Create a command function with proper closure
+                command_function = self._create_template_apply_function(component_name, template)
+
+                menu.add_command(label=template_name, command=command_function)
+        else:
+            menu.add_command(label=_("No component templates available"), state="disabled")
+
+        x = button.winfo_rootx()
+        y = button.winfo_rooty() + button.winfo_height()
+        menu.post(x, y)
+
+        self.current_menu = menu
+
+        def close_menu(_: tk.Event) -> None:
+            if isinstance(self.current_menu, Menu):
+                self.current_menu.unpost()
+                self.current_menu = None
+                self.root.unbind("<Button-1>", close_handler_id)
+
+        close_handler_id = self.root.bind("<Button-1>", close_menu, add="+")
+
+    def _create_template_apply_function(self, component_name: str, template: dict) -> CollectionsCallable[[], None]:
+        """Create a function that will apply a template to a component when called."""
+
+        def apply_function() -> None:
+            self.apply_component_template(component_name, template)
+
+        return apply_function
+
+    def apply_component_template(self, component_name: str, template: dict) -> None:
+        """Apply a template to a component."""
+        if "data" not in template:
+            return
+
+        template_data = template["data"]
+
+        # Call the callback to update the main data structure
+        self.update_data_callback(component_name, template_data)
+
+        for path, entry in self.entry_widgets.items():
+            if len(path) >= 1 and path[0] == component_name:
+                value = template_data
+                try:
+                    for key in path[1:]:
+                        value = value[key]
+                    entry.delete(0, tk.END)
+                    entry.insert(0, str(value))
+                except (KeyError, TypeError):
+                    pass
+
+        template_name = template.get("name", "Template")
+        messagebox.showinfo(_("Template Applied"), _("{} has been applied to {}").format(template_name, component_name))

ardupilot_methodic_configurator/frontend_tkinter_connection_selection.py

@@ -23,13 +23,10 @@ from typing import Union
 from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
-from ardupilot_methodic_configurator.frontend_tkinter_base import (
-    BaseWindow,
-    ProgressWindow,
-    show_no_connection_error,
-    show_tooltip,
-)
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_pair_tuple_combobox import PairTupleCombobox
+from ardupilot_methodic_configurator.frontend_tkinter_progress_window import ProgressWindow
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_no_connection_error, show_tooltip
 
 
 class ConnectionSelectionWidgets:  # pylint: disable=too-many-instance-attributes

ardupilot_methodic_configurator/frontend_tkinter_directory_selection.py

@@ -25,7 +25,8 @@ from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
-from ardupilot_methodic_configurator.frontend_tkinter_base import BaseWindow, show_no_param_files_error, show_tooltip
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_no_param_files_error, show_tooltip
 from ardupilot_methodic_configurator.frontend_tkinter_template_overview import TemplateOverviewWindow
 
 
@@ -87,7 +88,8 @@ class DirectorySelectionWidgets:
 
     def on_select_directory(self) -> bool:
         if self.is_template_selection:
-            TemplateOverviewWindow(self.parent.root)
+            if isinstance(self.parent.root, tk.Tk):  # this keeps mypy and pyright happy
+                TemplateOverviewWindow(self.parent.root)
             selected_directory = ProgramSettings.get_recently_used_dirs()[0]
             logging_info(_("Selected template directory: %s"), selected_directory)
         else:
@@ -553,7 +555,9 @@ def main() -> None:
     )
     # pylint: enable=duplicate-code
 
-    local_filesystem = LocalFilesystem(args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files)
+    local_filesystem = LocalFilesystem(
+        args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files, args.save_component_to_system_templates
+    )
 
     # Get the list of intermediate parameter files files that will be processed sequentially
     files = list(local_filesystem.file_parameters.keys())

ardupilot_methodic_configurator/frontend_tkinter_flightcontroller_info.py

@@ -17,7 +17,8 @@ from tkinter import ttk
 from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.annotate_params import Par
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
-from ardupilot_methodic_configurator.frontend_tkinter_base import BaseWindow, ProgressWindow
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
+from ardupilot_methodic_configurator.frontend_tkinter_progress_window import ProgressWindow
 
 
 class FlightControllerInfoWindow(BaseWindow):

ardupilot_methodic_configurator/frontend_tkinter_pair_tuple_combobox.py

@@ -26,7 +26,8 @@ from typing import Union
 
 from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
-from ardupilot_methodic_configurator.frontend_tkinter_base import get_widget_font_family_and_size, update_combobox_width
+from ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox import update_combobox_width
+from ardupilot_methodic_configurator.frontend_tkinter_rich_text import get_widget_font_family_and_size
 
 # SPDX-SnippetBegin
 # SPDX-License-Identifier: MPL-2.0

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -10,6 +10,7 @@ SPDX-FileCopyrightText: 2024-2025 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
 SPDX-License-Identifier: GPL-3.0-or-later
 """
 
+import sys
 import tkinter as tk
 from argparse import ArgumentParser, Namespace
 
@@ -20,7 +21,7 @@ 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 Union
+from typing import Literal, Union
 
 # from logging import critical as logging_critical
 from webbrowser import open as webbrowser_open  # to open the blog post documentation
@@ -32,19 +33,16 @@ from ardupilot_methodic_configurator.backend_filesystem_program_settings import
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.backend_internet import download_file_from_url
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
-from ardupilot_methodic_configurator.frontend_tkinter_base import (
-    AutoResizeCombobox,
-    BaseWindow,
-    ProgressWindow,
-    RichText,
-    UsagePopupWindow,
-    get_widget_font_family_and_size,
-    show_tooltip,
-)
+from ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox import AutoResizeCombobox
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_directory_selection import VehicleDirectorySelectionWidgets
 from ardupilot_methodic_configurator.frontend_tkinter_parameter_editor_documentation_frame import DocumentationFrame
 from ardupilot_methodic_configurator.frontend_tkinter_parameter_editor_table import ParameterEditorTable
+from ardupilot_methodic_configurator.frontend_tkinter_progress_window import ProgressWindow
+from ardupilot_methodic_configurator.frontend_tkinter_rich_text import RichText, get_widget_font_family_and_size
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
 from ardupilot_methodic_configurator.frontend_tkinter_stage_progress import StageProgressBar
+from ardupilot_methodic_configurator.frontend_tkinter_usage_popup_window import UsagePopupWindow
 from ardupilot_methodic_configurator.tempcal_imu import IMUfit
 
 
@@ -362,7 +360,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         )
 
     @staticmethod
-    def __display_usage_popup_window(parent: tk.Toplevel) -> None:
+    def __display_usage_popup_window(parent: tk.Tk) -> None:
         usage_popup_window = BaseWindow(parent)
         style = ttk.Style()
 
@@ -450,16 +448,78 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
                         raise
                     self.parameter_editor_table.set_at_least_one_param_edited(True)  # force writing doc annotations to file
 
-    def __should_copy_fc_values_to_file(self, selected_file: str) -> None:
+    def __should_copy_fc_values_to_file(self, selected_file: str) -> None:  # pylint: disable=too-many-locals
         auto_changed_by = self.local_filesystem.auto_changed_by(selected_file)
         if auto_changed_by and self.flight_controller.fc_parameters:
             msg = _(
-                "This configuration step should be performed outside this tool by\n"
-                "{auto_changed_by}\n"
-                "and that should have changed the parameters on the FC.\n\n"
-                "Should the FC values now be copied to the {selected_file} file?"
+                "This configuration step requires external changes by: {auto_changed_by}\n\n"
+                "The external tool experiment procedure is described in the tunning 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)"
             )
-            if messagebox.askyesno(_("Update file with values from FC?"), msg.format(**locals())):
+
+            # Create custom dialog with Yes, No, Close buttons
+            dialog = tk.Toplevel(self.root)
+            dialog.transient(self.root)
+            dialog.title(_("Update file with values from FC?"))
+            dialog.resizable(width=False, height=False)
+            dialog.protocol("WM_DELETE_WINDOW", dialog.destroy)
+
+            # Make dialog modal
+            dialog.grab_set()
+
+            # Message text
+            message_label = tk.Label(dialog, text=msg.format(**locals()), justify=tk.LEFT, padx=20, pady=10)
+            message_label.pack(padx=10, pady=10)
+
+            # Result variable
+            result: list[Literal[None, True, False]] = [None]
+
+            # Button frame
+            button_frame = tk.Frame(dialog)
+            button_frame.pack(pady=10)
+
+            # Close button (default)
+            close_button = tk.Button(
+                button_frame, text=_("Close"), width=10, command=lambda: [result.append(None), dialog.destroy()]
+            )
+            close_button.pack(side=tk.LEFT, padx=5)
+
+            # Yes button
+            yes_button = tk.Button(
+                button_frame, text=_("Yes"), width=10, command=lambda: [result.append(True), dialog.destroy()]
+            )
+            yes_button.pack(side=tk.LEFT, padx=5)
+
+            # No button
+            no_button = tk.Button(
+                button_frame, text=_("No"), width=10, command=lambda: [result.append(False), dialog.destroy()]
+            )
+            no_button.pack(side=tk.LEFT, padx=5)
+
+            close_button.focus_set()  # Give the Close button focus
+            dialog.bind("<Return>", lambda _event: [result.append(None), dialog.destroy()])
+
+            # Center the dialog on the parent window
+            dialog.update_idletasks()
+            dialog_width = dialog.winfo_width()
+            dialog_height = dialog.winfo_height()
+            parent_x = self.root.winfo_rootx()
+            parent_y = self.root.winfo_rooty()
+            parent_width = self.root.winfo_width()
+            parent_height = self.root.winfo_height()
+            x = parent_x + (parent_width - dialog_width) // 2
+            y = parent_y + (parent_height - dialog_height) // 2
+            dialog.geometry(f"+{x}+{y}")
+
+            # Wait until dialog is closed
+            self.root.wait_window(dialog)
+            response = result[-1] if len(result) > 1 else None
+
+            if response is True:  # Yes option
                 relevant_fc_params = {
                     key: value
                     for key, value in self.flight_controller.fc_parameters.items()
@@ -468,6 +528,9 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
                 params_copied = self.local_filesystem.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
 
     def __should_jump_to_file(self, selected_file: str) -> str:
         jump_possible = self.local_filesystem.jump_possible(selected_file)
@@ -749,7 +812,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             self.close_connection_and_quit()
 
     def write_changes_to_intermediate_parameter_file(self) -> None:
-        if self.parameter_editor_table.get_at_least_one_param_edited():
+        if self.parameter_editor_table.get_at_least_one_param_edited() or self.annotate_params_into_files.get():
             msg = _("Do you want to write the changes to the {self.current_file} file?")
             if messagebox.askyesno(_("One or more parameters have been edited"), msg.format(**locals())):
                 self.local_filesystem.export_to_param(
@@ -874,5 +937,7 @@ if __name__ == "__main__":
     logging_basicConfig(level=logging_getLevelName(args.loglevel), format="%(asctime)s - %(levelname)s - %(message)s")
 
     fc = FlightController(args.reboot_time)
-    filesystem = LocalFilesystem(args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files)
+    filesystem = LocalFilesystem(
+        args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files, args.save_component_to_system_templates
+    )
     ParameterEditorWindow("04_board_orientation.param", fc, filesystem)

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_documentation_frame.py

@@ -15,7 +15,7 @@ from webbrowser import open as webbrowser_open  # to open the blog post document
 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.frontend_tkinter_base import show_tooltip
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
 
 
 class DocumentationFrame:

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_table.py

@@ -26,15 +26,13 @@ from ardupilot_methodic_configurator.annotate_params import Par
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem, is_within_tolerance
 
 # from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
-# from ardupilot_methodic_configurator.frontend_tkinter_base import AutoResizeCombobox
-from ardupilot_methodic_configurator.frontend_tkinter_base import (
-    BaseWindow,
-    ScrollFrame,
-    get_widget_font_family_and_size,
-    show_tooltip,
-)
+# from ardupilot_methodic_configurator.frontend_tkinter_auto_resize_combobox import AutoResizeCombobox
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_entry_dynamic import EntryWithDynamicalyFilteredListbox
 from ardupilot_methodic_configurator.frontend_tkinter_pair_tuple_combobox import PairTupleCombobox
+from ardupilot_methodic_configurator.frontend_tkinter_rich_text import get_widget_font_family_and_size
+from ardupilot_methodic_configurator.frontend_tkinter_scroll_frame import ScrollFrame
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
 
 NEW_VALUE_WIDGET_WIDTH = 9
 
@@ -105,11 +103,11 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             )
             if error_msg:
                 messagebox.showerror(_("Error in derived parameters"), error_msg)
-            else:
-                # merge derived parameter values
-                self.local_filesystem.merge_forced_or_derived_parameters(
-                    selected_file, self.local_filesystem.derived_parameters, list(fc_parameters.keys())
-                )
+            # merge derived parameter values
+            elif self.local_filesystem.merge_forced_or_derived_parameters(
+                selected_file, self.local_filesystem.derived_parameters, list(fc_parameters.keys())
+            ):
+                self.at_least_one_param_edited = True
 
             self.rename_fc_connection(selected_file)
 

ardupilot_methodic_configurator/frontend_tkinter_progress_window.py

@@ -0,0 +1,89 @@
+"""
+TKinter base classes reused in multiple parts of the code.
+
+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>
+
+SPDX-License-Identifier: GPL-3.0-or-later
+"""
+
+# https://wiki.tcl-lang.org/page/Changing+Widget+Colors
+
+import tkinter as tk
+from logging import error as logging_error
+from tkinter import ttk
+
+from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
+
+
+class ProgressWindow:
+    """
+    A class for creating and managing a progress window in the application.
+
+    This class is responsible for creating a progress window that displays the progress of
+    a task. It includes a progress bar and a label to display the progress message.
+    """
+
+    def __init__(self, master, title: str, message: str = "", width: int = 300, height: int = 80) -> None:  # noqa: ANN001, pylint: disable=too-many-arguments, too-many-positional-arguments
+        self.parent = master
+        self.message = message
+        self.progress_window = tk.Toplevel(self.parent)
+        self.progress_window.title(title)
+        self.progress_window.geometry(f"{width}x{height}")
+
+        main_frame = ttk.Frame(self.progress_window)
+        main_frame.pack(expand=True, fill=tk.BOTH)
+
+        # Create a progress bar
+        self.progress_bar = ttk.Progressbar(main_frame, length=100, mode="determinate")
+        self.progress_bar.pack(side=tk.TOP, fill=tk.X, expand=False, padx=(5, 5), pady=(10, 10))
+
+        # Create a label to display the progress message
+        self.progress_label = ttk.Label(main_frame, text=message.format(0, 0))
+        self.progress_label.pack(side=tk.TOP, fill=tk.X, expand=False, pady=(10, 10))
+
+        self.progress_window.lift()
+
+        # Center the progress window on the parent window
+        BaseWindow.center_window(self.progress_window, self.parent)
+
+        self.progress_bar.update()
+
+    def update_progress_bar_300_pct(self, percent: int) -> None:
+        self.message = _("Please be patient, {:.1f}% of {}% complete")
+        self.update_progress_bar(int(percent / 3), max_value=100)
+
+    def update_progress_bar(self, current_value: int, max_value: int) -> None:
+        """
+        Update the progress bar and the progress message with the current progress.
+
+        Args:
+            current_value (int): The current progress value.
+            max_value (int): The maximum progress value, if 0 uses percentage.
+
+        """
+        try:
+            if hasattr(self, "progress_window") is False or self.progress_window is None:
+                return
+            self.progress_window.lift()
+        except tk.TclError as _e:
+            msg = _("Lifting window: {_e}")
+            logging_error(msg.format(**locals()))
+            return
+
+        self.progress_bar["value"] = current_value
+        self.progress_bar["maximum"] = max_value
+
+        # Update the progress message
+        self.progress_label.config(text=self.message.format(current_value, max_value))
+
+        self.progress_bar.update()
+
+        # Close the progress window when the process is complete
+        if current_value == max_value:
+            self.progress_window.destroy()
+
+    def destroy(self) -> None:
+        self.progress_window.destroy()

ardupilot_methodic_configurator/frontend_tkinter_rich_text.py

@@ -0,0 +1,69 @@
+"""
+TKinter base classes reused in multiple parts of the code.
+
+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>
+
+SPDX-License-Identifier: GPL-3.0-or-later
+"""
+
+# https://wiki.tcl-lang.org/page/Changing+Widget+Colors
+
+import tkinter as tk
+from tkinter import font as tkFont  # noqa: N812
+from tkinter import ttk
+
+
+class RichText(tk.Text):  # pylint: disable=too-many-ancestors
+    """
+    Extends the standard Tkinter Text widget to support rich text formatting.
+
+    This class allows for the customization of text appearance through tags, enabling
+    bold, italic, and heading styles directly within the text widget. It leverages the
+    Tkinter font module to dynamically adjust font properties based on predefined tags.
+
+    Methods:
+        __init__(self, *args, **kwargs): Initializes the RichText widget with optional arguments
+            passed to the superclass constructor. Custom fonts for bold, italic, and heading styles
+            are configured during initialization.
+
+    Tags:
+        bold: Applies a bold font style.
+        italic: Applies an italic font style.
+        h1: Doubles the font size and applies bold styling, suitable for headings.
+
+    Usage:
+        To use this widget, simply replace instances of the standard Tkinter Text widget with
+        RichText in your UI definitions. Apply tags to text segments using the tag_add method
+        and configure the appearance accordingly.
+
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        default_font = tkFont.nametofont(self.cget("font"))
+        default_size = default_font.cget("size")
+
+        bold_font = tkFont.Font(**default_font.configure())  # type: ignore[arg-type]
+        italic_font = tkFont.Font(**default_font.configure())  # type: ignore[arg-type]
+        h1_font = tkFont.Font(**default_font.configure())  # type: ignore[arg-type]
+
+        bold_font.configure(weight="bold")
+        italic_font.configure(slant="italic")
+        h1_font.configure(size=int(default_size * 2), weight="bold")
+
+        self.tag_configure("bold", font=bold_font)
+        self.tag_configure("italic", font=italic_font)
+        self.tag_configure("h1", font=h1_font, spacing3=default_size)
+
+
+def get_widget_font_family_and_size(widget: tk.Widget) -> tuple[str, int]:
+    style = ttk.Style()
+    widget_style = widget.cget("style")  # Get the style used by the widget
+    font_name = style.lookup(widget_style, "font")
+    font_dict = tkFont.nametofont(font_name).config()
+    if font_dict is None:
+        return "Segoe UI", 9
+    return font_dict.get("family", "Segoe UI"), font_dict.get("size", 9)