ardupilot-methodic-configurator 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

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 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
 
@@ -63,34 +61,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
         # These variables are used by the forced_parameters and derived_parameters in configuration_steps_*.json files
         self.variables = local_filesystem.get_eval_variables()
 
-        self.compute_forced_and_derived_parameters()
-
-    def compute_forced_and_derived_parameters(self) -> None:
-        if self.local_filesystem.configuration_steps:
-            for filename, file_info in self.local_filesystem.configuration_steps.items():
-                error_msg = self.local_filesystem.compute_parameters(filename, file_info, "forced", self.variables)
-                if error_msg:
-                    messagebox.showerror(_("Error in forced parameters"), error_msg)
-                else:
-                    self.add_forced_or_derived_parameters(filename, self.local_filesystem.forced_parameters)
-                # error_msg = self.local_filesystem.compute_parameters(filename, file_info, 'derived', self.variables)
-                # if error_msg:
-                #    messagebox.showerror("Error in derived parameters", error_msg)
-
-    def add_forced_or_derived_parameters(
-        self, filename: str, new_parameters: dict[str, dict[str, Par]], fc_parameters: Union[dict[str, float], None] = None
-    ) -> None:
-        """Add forced parameters not yet in the parameter list to the parameter list."""
-        if filename in new_parameters:
-            for param_name, param in new_parameters[filename].items():
-                if filename not in self.local_filesystem.file_parameters:
-                    continue
-                if param_name not in self.local_filesystem.file_parameters[filename] and (
-                    fc_parameters is None or param_name in fc_parameters
-                ):
-                    self.local_filesystem.file_parameters[filename][param_name] = param
-
-    def repopulate(self, selected_file: str, fc_parameters: dict, show_only_differences: bool) -> None:
+    def repopulate(self, selected_file: str, fc_parameters: dict[str, float], show_only_differences: bool) -> None:
         for widget in self.view_port.winfo_children():
             widget.destroy()
         self.current_file = selected_file
@@ -133,8 +104,10 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             if error_msg:
                 messagebox.showerror(_("Error in derived parameters"), error_msg)
             else:
-                # Add derived parameters not yet in the parameter list to the parameter list
-                self.add_forced_or_derived_parameters(selected_file, self.local_filesystem.derived_parameters, fc_parameters)
+                # merge derived parameter values
+                self.local_filesystem.merge_forced_or_derived_parameters(
+                    selected_file, self.local_filesystem.derived_parameters, list(fc_parameters.keys())
+                )
 
             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 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)

ardupilot_methodic_configurator/frontend_tkinter_scroll_frame.py

@@ -0,0 +1,116 @@
+"""
+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
+"""
+
+import tkinter as tk
+from platform import system as platform_system
+from tkinter import ttk
+
+# SPDX-SnippetBegin
+# SPDX-License-Identifier: MPL-2.0
+# SPDX-SnippetCopyrightText: 2019 Mark Pointing
+
+
+class ScrollFrame(ttk.Frame):  # pylint: disable=too-many-ancestors
+    """
+    A custom Frame widget that supports scrolling.
+
+    This class extends the ttk.Frame widget to include a canvas and a scrollbar,
+    allowing for scrolling content within the frame. It's useful for creating
+    scrollable areas within your application's GUI.
+    """
+
+    def __init__(self, master) -> None:  # noqa: ANN001
+        super().__init__(master)  # create a frame (self)
+
+        # place canvas on self, copy ttk.background to tk.background
+        self.canvas = tk.Canvas(self, borderwidth=0, background=ttk.Style(master).lookup("TFrame", "background"))
+
+        # place a frame on the canvas, this frame will hold the child widgets
+        self.view_port = ttk.Frame(self.canvas)
+
+        # place a tk.scrollbar on self. ttk.scrollbar will not work here
+        self.vsb = tk.Scrollbar(self, orient="vertical", command=self.canvas.yview)
+        # attach scrollbar action to scroll of canvas
+        self.canvas.configure(yscrollcommand=self.vsb.set)
+
+        self.vsb.pack(side="right", fill="y")  # pack scrollbar to right of self
+        # pack canvas to left of self and expand to fill
+        self.canvas.pack(side="left", fill="both", expand=True)
+        self.canvas_window = self.canvas.create_window(
+            (4, 4),
+            window=self.view_port,  # add view port frame to canvas
+            anchor="nw",
+            tags="self.view_port",
+        )
+
+        # bind an event whenever the size of the view_port frame changes.
+        self.view_port.bind("<Configure>", self.on_frame_configure)
+        # bind an event whenever the size of the canvas frame changes.
+        self.canvas.bind("<Configure>", self.on_canvas_configure)
+
+        # bind wheel events when the cursor enters the control
+        self.view_port.bind("<Enter>", self.on_enter)
+        # unbind wheel events when the cursor leaves the control
+        self.view_port.bind("<Leave>", self.on_leave)
+
+        # perform an initial stretch on render, otherwise the scroll region has a tiny border until the first resize
+        self.on_frame_configure(None)
+
+    def on_frame_configure(self, _event) -> None:  # noqa: ANN001
+        """Reset the scroll region to encompass the inner frame."""
+        # Whenever the size of the frame changes, alter the scroll region respectively.
+        self.canvas.configure(scrollregion=self.canvas.bbox("all"))
+        # Calculate the bounding box for the scroll region, starting from the second row
+        # bbox = self.canvas.bbox("all")
+        # if bbox:
+        #     # Adjust the bounding box to start from the second row
+        #     bbox = (bbox[0], bbox[1] + self.canvas.winfo_reqheight(), bbox[2], bbox[3])
+        #     self.canvas.configure(scrollregion=bbox)
+
+    def on_canvas_configure(self, event: tk.Event) -> None:
+        """Reset the canvas window to encompass inner frame when required."""
+        canvas_width = event.width
+        # Whenever the size of the canvas changes alter the window region respectively.
+        self.canvas.itemconfig(self.canvas_window, width=canvas_width)
+
+    def on_mouse_wheel(self, event: tk.Event) -> None:  # cross platform scroll wheel event
+        canvas_height = self.canvas.winfo_height()
+        rows_height = self.canvas.bbox("all")[3]
+
+        if rows_height > canvas_height:  # only scroll if the rows overflow the frame
+            if platform_system() == "Windows":
+                # Windows: positive delta means scroll up, negative means scroll down
+                self.canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")
+            elif platform_system() == "Darwin":
+                # macOS: similar to Windows but different scaling
+                self.canvas.yview_scroll(int(-1 * event.delta), "units")
+            elif event.num == 4:
+                # Linux: Button-4 means scroll up
+                self.canvas.yview_scroll(-1, "units")
+            elif event.num == 5:
+                # Linux: Button-5 means scroll down
+                self.canvas.yview_scroll(1, "units")
+
+    def on_enter(self, _event: tk.Event) -> None:  # bind wheel events when the cursor enters the control
+        if platform_system() == "Linux":
+            self.canvas.bind_all("<Button-4>", self.on_mouse_wheel)
+            self.canvas.bind_all("<Button-5>", self.on_mouse_wheel)
+        else:
+            self.canvas.bind_all("<MouseWheel>", self.on_mouse_wheel)
+
+    def on_leave(self, _event: tk.Event) -> None:  # unbind wheel events when the cursor leaves the control
+        if platform_system() == "Linux":
+            self.canvas.unbind_all("<Button-4>")
+            self.canvas.unbind_all("<Button-5>")
+        else:
+            self.canvas.unbind_all("<MouseWheel>")
+
+
+# SPDX-SnippetEnd

ardupilot_methodic_configurator/frontend_tkinter_show.py

@@ -0,0 +1,78 @@
+"""
+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 platform import system as platform_system
+from tkinter import messagebox, ttk
+
+from ardupilot_methodic_configurator import _
+
+
+def show_error_message(title: str, message: str) -> None:
+    root = tk.Tk()
+    # Set the theme to 'alt'
+    style = ttk.Style()
+    style.theme_use("alt")
+    root.withdraw()  # Hide the main window
+    messagebox.showerror(title, message)
+    root.destroy()
+
+
+def show_no_param_files_error(_dirname: str) -> None:
+    error_message = _(
+        "No intermediate parameter files found in the selected '{_dirname}' vehicle directory.\n"
+        "Please select and step inside a vehicle directory containing valid ArduPilot intermediate parameter files.\n\n"
+        "Make sure to step inside the directory (double-click) and not just select it."
+    )
+    show_error_message(_("No Parameter Files Found"), error_message.format(**locals()))
+
+
+def show_no_connection_error(_error_string: str) -> None:
+    error_message = _("{_error_string}\n\nPlease connect a flight controller to the PC,\nwait at least 7 seconds and retry.")
+    show_error_message(_("No Connection to the Flight Controller"), error_message.format(**locals()))
+
+
+def show_tooltip(widget: tk.Widget, text: str, position_below: bool = True) -> None:
+    def enter(_event: tk.Event) -> None:
+        # Calculate the position of the tooltip based on the widget's position
+        x = widget.winfo_rootx() + min(widget.winfo_width() // 2, 100)
+        y = widget.winfo_rooty() + (widget.winfo_height() if position_below else -10)
+        tooltip.geometry(f"+{x}+{y}")
+        tooltip.deiconify()
+
+    def leave(_event: tk.Event) -> None:
+        tooltip.withdraw()
+
+    tooltip = tk.Toplevel(widget)
+    if platform_system() == "Darwin":  # macOS
+        try:
+            tooltip.tk.call(
+                "::tk::unsupported::MacWindowStyle",
+                "style",
+                tooltip._w,  # type: ignore[attr-defined] # noqa: SLF001 # pylint: disable=protected-access
+                "help",
+                "noActivates",
+            )
+            tooltip.configure(bg="#ffffe0")
+        except AttributeError:  # Catches protected member access error
+            tooltip.wm_attributes("-alpha", 1.0)  # Ensure opacity
+            tooltip.wm_attributes("-topmost", True)  # Keep on top # noqa: FBT003
+            tooltip.configure(bg="#ffffe0")
+    else:
+        tooltip.wm_overrideredirect(boolean=True)
+    tooltip_label = ttk.Label(tooltip, text=text, background="#ffffe0", relief="solid", borderwidth=1, justify=tk.LEFT)
+    tooltip_label.pack()
+    tooltip.withdraw()  # Initially hide the tooltip
+
+    # Bind the <Enter> and <Leave> events to show and hide the tooltip
+    widget.bind("<Enter>", enter)
+    widget.bind("<Leave>", leave)

ardupilot_methodic_configurator/frontend_tkinter_software_update.py

@@ -13,7 +13,7 @@ from tkinter import ttk
 from typing import Callable, Optional
 
 from ardupilot_methodic_configurator import _, __version__
-from ardupilot_methodic_configurator.frontend_tkinter_base import ScrollFrame
+from ardupilot_methodic_configurator.frontend_tkinter_scroll_frame import ScrollFrame
 
 
 class UpdateDialog:  # pylint: disable=too-many-instance-attributes

ardupilot_methodic_configurator/frontend_tkinter_stage_progress.py

@@ -47,7 +47,7 @@ from typing import Union
 from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.backend_filesystem_configuration_steps import ConfigurationSteps
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
-from ardupilot_methodic_configurator.frontend_tkinter_base import show_tooltip
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
 
 
 class StageProgressBar(ttk.LabelFrame):  # pylint: disable=too-many-ancestors

ardupilot_methodic_configurator/frontend_tkinter_usage_popup_window.py

@@ -0,0 +1,89 @@
+"""
+A reusable usage popup window.
+
+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 debug as logging_debug
+# from logging import info as logging_info
+from platform import system as platform_system
+from tkinter import BooleanVar, ttk
+
+from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
+from ardupilot_methodic_configurator.frontend_tkinter_base import BaseWindow
+from ardupilot_methodic_configurator.frontend_tkinter_rich_text import RichText
+
+
+class UsagePopupWindow:
+    """
+    A class for creating and managing usage popup windows in the application.
+
+    This class extends the BaseWindow class to provide functionality for displaying
+    usage popups with instructions and options to show them again or dismiss.
+    """
+
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def should_display(ptype: str) -> bool:
+        return ProgramSettings.display_usage_popup(ptype)
+
+    @staticmethod
+    def display(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        parent: tk.Toplevel,
+        usage_popup_window: BaseWindow,
+        title: str,
+        ptype: str,
+        geometry: str,
+        instructions_text: RichText,
+    ) -> None:
+        usage_popup_window.root.title(title)
+        usage_popup_window.root.geometry(geometry)
+
+        instructions_text.pack(padx=6, pady=10)
+
+        show_again_var = BooleanVar()
+        show_again_var.set(True)
+
+        def update_show_again() -> None:
+            ProgramSettings.set_display_usage_popup(ptype, show_again_var.get())
+
+        show_again_checkbox = ttk.Checkbutton(
+            usage_popup_window.main_frame,
+            text=_("Show this usage popup again"),
+            variable=show_again_var,
+            command=update_show_again,
+        )
+        show_again_checkbox.pack(pady=(10, 5))
+
+        dismiss_button = ttk.Button(
+            usage_popup_window.main_frame,
+            text=_("Dismiss"),
+            command=lambda: UsagePopupWindow.close(usage_popup_window, parent),
+        )
+        dismiss_button.pack(pady=10)
+
+        BaseWindow.center_window(usage_popup_window.root, parent)
+        usage_popup_window.root.attributes("-topmost", True)  # noqa: FBT003
+
+        if platform_system() == "Windows":
+            parent.attributes("-disabled", True)  # noqa: FBT003  # Disable parent window input
+
+        usage_popup_window.root.protocol("WM_DELETE_WINDOW", lambda: UsagePopupWindow.close(usage_popup_window, parent))
+
+    @staticmethod
+    def close(usage_popup_window: BaseWindow, parent: tk.Toplevel) -> None:
+        usage_popup_window.root.destroy()
+        if platform_system() == "Windows":
+            parent.attributes("-disabled", False)  # noqa: FBT003  # Re-enable the parent window
+        parent.focus_set()