ardupilot-methodic-configurator 2.4.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

ardupilot_methodic_configurator/__init__.py

@@ -12,4 +12,4 @@ from ardupilot_methodic_configurator.internationalization import load_translatio
 
 _ = load_translation()
 
-__version__ = "2.4.0"
+__version__ = "2.6.0"

ardupilot_methodic_configurator/backend_filesystem_program_settings.py

@@ -10,7 +10,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
 
 # from sys import exit as sys_exit
 import glob
-import sys
+from importlib.resources import files as importlib_files
 from json import dump as json_dump
 from json import load as json_load
 from logging import debug as logging_debug
@@ -18,6 +18,7 @@ from logging import error as logging_error
 from os import makedirs as os_makedirs
 from os import path as os_path
 from os import sep as os_sep
+from pathlib import Path
 from platform import system as platform_system
 from re import escape as re_escape
 from re import match as re_match
@@ -57,6 +58,7 @@ class ProgramSettings:
             "Format version": 1,
             "display_usage_popup": {
                 "component_editor": True,
+                "component_editor_validation": True,
                 "parameter_editor": True,
             },
             "directory_selection": {
@@ -69,7 +71,7 @@ class ProgramSettings:
             "gui_complexity": "simple",  # simple or normal
             # Motor test settings
             "motor_test": {
-                "duration": 2.5,  # Default test duration in seconds
+                "duration": 2,  # Default test duration in seconds
                 "throttle_pct": 10,  # Default throttle percentage (10%)
             },
         }
@@ -106,13 +108,13 @@ class ProgramSettings:
 
     @staticmethod
     def application_icon_filepath() -> str:
-        script_dir = os_path.dirname(os_path.abspath(__file__))
-        return os_path.join(script_dir, "images", "ArduPilot_icon.png")
+        package_path = importlib_files("ardupilot_methodic_configurator")
+        return str(package_path / "images" / "ArduPilot_icon.png")
 
     @staticmethod
     def application_logo_filepath() -> str:
-        script_dir = os_path.dirname(os_path.abspath(__file__))
-        return os_path.join(script_dir, "images", "ArduPilot_logo.png")
+        package_path = importlib_files("ardupilot_methodic_configurator")
+        return str(package_path / "images" / "ArduPilot_logo.png")
 
     @staticmethod
     def create_new_vehicle_dir(new_vehicle_dir: str) -> str:
@@ -255,15 +257,14 @@ class ProgramSettings:
 
     @staticmethod
     def get_templates_base_dir() -> str:
-        current_script_dir = os_path.dirname(os_path.abspath(__file__))
+        package_path = importlib_files("ardupilot_methodic_configurator")
+        logging_debug("current script directory1: %s", package_path)
         if platform_system() == "Windows":
-            site_directory = ProgramSettings._site_config_dir()
-        else:
-            logging_debug("current script directory: %s", current_script_dir)
-            site_directory = current_script_dir
+            package_path = Path(ProgramSettings._site_config_dir())
+        logging_debug("current script directory2: %s", package_path)
 
-        logging_debug(_("site_directory: %s"), site_directory)
-        return os_path.join(site_directory, "vehicle_templates")
+        logging_debug(_("site_directory: %s"), package_path)
+        return str(package_path / "vehicle_templates")
 
     @staticmethod
     def get_recently_used_dirs() -> tuple[str, str, str]:
@@ -286,7 +287,7 @@ class ProgramSettings:
 
     @staticmethod
     def set_display_usage_popup(ptype: str, value: bool) -> None:
-        if ptype in {"component_editor", "parameter_editor"}:
+        if ptype in {"component_editor", "component_editor_validation", "parameter_editor"}:
             settings = ProgramSettings._get_settings_as_dict()
             settings["display_usage_popup"][ptype] = value
             ProgramSettings._set_settings_from_dict(settings)
@@ -356,20 +357,15 @@ class ProgramSettings:
         """
         # See https://github.com/ArduPilot/ardupilot_wiki/pull/6215
         # Determine the application directory (where images are stored)
-        if getattr(sys, "frozen", False):
-            # Running as compiled executable
-            application_path = os_path.dirname(sys.executable)
-        else:
-            # Running as script
-            application_path = os_path.dirname(os_path.dirname(os_path.abspath(__file__)))
+        package_path = importlib_files("ardupilot_methodic_configurator")
 
-        images_dir = os_path.join(application_path, "ardupilot_methodic_configurator", "images", "motor_diagrams_png")
+        images_dir = package_path / "images" / "motor_diagrams_png"
 
         # Generate PNG filename based on frame configuration
         filename = f"m_{frame_class:02d}_{frame_type:02d}_*.png"
 
         # Search for matching PNG file (since exact naming varies)
-        matching_files = glob.glob(os_path.join(images_dir, filename))
+        matching_files = glob.glob(str(images_dir / filename))
 
         err_msg = (
             ""

ardupilot_methodic_configurator/configuration_manager.py

@@ -22,6 +22,8 @@ from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.backend_internet import download_file_from_url
+from ardupilot_methodic_configurator.data_model_ardupilot_parameter import ArduPilotParameter
+from ardupilot_methodic_configurator.data_model_configuration_step import ConfigurationStepProcessor
 from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict, is_within_tolerance
 from ardupilot_methodic_configurator.tempcal_imu import IMUfit
 
@@ -32,10 +34,19 @@ ShowWarningCallback = Callable[[str, str], None]  # (title, message) -> None
 ShowErrorCallback = Callable[[str, str], None]  # (title, message) -> None
 ShowInfoCallback = Callable[[str, str], None]  # (title, message) -> None
 
+
+class OperationNotPossibleError(Exception):
+    """Raised when an operation cannot be performed due to missing prerequisites or state."""
+
+
+class InvalidParameterNameError(Exception):
+    """Raised when a parameter name is invalid or already exists."""
+
+
 # pylint: disable=too-many-lines
 
 
-class ConfigurationManager:
+class ConfigurationManager:  # pylint: disable=too-many-public-methods
     """
     Manages configuration state, including flight controller and filesystem access.
 
@@ -48,6 +59,11 @@ class ConfigurationManager:
         self.current_file = current_file
         self.flight_controller = flight_controller
         self.filesystem = filesystem
+        self.config_step_processor = ConfigurationStepProcessor(self.filesystem)
+
+        # self.parameters is rebuilt on every repopulate(...) call and only contains the ArduPilotParameter
+        # objects needed for the current table view.
+        self.parameters: dict[str, ArduPilotParameter] = {}
 
     @property
     def connected_vehicle_type(self) -> str:
@@ -77,6 +93,10 @@ class ConfigurationManager:
             else False
         )
 
+    @property
+    def current_file_parameters(self) -> ParDict:
+        return self.filesystem.file_parameters.get(self.current_file, ParDict())
+
     def handle_imu_temperature_calibration_workflow(  # pylint: disable=too-many-arguments, too-many-positional-arguments
         self,
         selected_file: str,
@@ -1038,3 +1058,95 @@ class ConfigurationManager:
             show_info(_("Parameter files zipped"), msg.format(zip_file_path=zip_file_path))
 
         return should_write_file
+
+    def repopulate_configuration_step_parameters(
+        self,
+    ) -> tuple[bool, list[tuple[str, str]], list[tuple[str, str]]]:
+        """
+        Process the configuration step for the current file and update the self.parameters.
+
+        Returns:
+            tuple: (config_step_edited, ui_errors, ui_infos)
+
+        """
+        self.parameters, config_step_edited, ui_errors, ui_infos = self.config_step_processor.process_configuration_step(
+            self.current_file, self.fc_parameters
+        )
+        return config_step_edited, ui_errors, ui_infos
+
+    def get_different_parameters(self) -> dict[str, ArduPilotParameter]:
+        """
+        Get parameters that are different from FC values or missing from FC.
+
+        Returns:
+            Dictionary of parameters that are different from FC
+
+        """
+        return self.config_step_processor.filter_different_parameters(self.parameters)
+
+    def delete_parameter_from_current_file(self, param_name: str) -> None:
+        """
+        Delete a parameter from the current file parameters.
+
+        Args:
+            param_name: The name of the parameter to delete
+
+        """
+        del self.current_file_parameters[param_name]
+        if param_name in self.parameters:
+            del self.parameters[param_name]
+
+    def get_possible_add_param_names(self) -> list[str]:
+        """Return a sorted list of possible parameter names to add, or raise OperationNotPossibleError if not possible."""
+        param_dict = self.filesystem.doc_dict or self.fc_parameters
+        if not param_dict:
+            raise OperationNotPossibleError(
+                _("No apm.pdef.xml file and no FC connected. Not possible autocomplete parameter names.")
+            )
+        possible_add_param_names = [param_name for param_name in param_dict if param_name not in self.current_file_parameters]
+        possible_add_param_names.sort()
+        return possible_add_param_names
+
+    def add_parameter_to_current_file(self, param_name: str) -> bool:
+        """
+        Add a parameter to the current file.
+
+        Returns True if the parameter was added, False if not.
+
+        Raises InvalidParameterNameError or OperationNotPossibleError if not possible.
+        """
+        param_name = param_name.upper()
+        if not param_name:
+            raise InvalidParameterNameError(_("Parameter name can not be empty."))
+
+        if param_name in self.current_file_parameters:
+            raise InvalidParameterNameError(_("Parameter already exists, edit it instead"))
+
+        fc_parameters = self.fc_parameters
+        if fc_parameters:
+            if param_name in fc_parameters:
+                self.current_file_parameters[param_name] = Par(fc_parameters[param_name], "")
+                self.parameters[param_name] = self.config_step_processor.create_ardupilot_parameter(
+                    param_name, self.current_file_parameters[param_name], self.current_file, fc_parameters
+                )
+                return True
+            raise InvalidParameterNameError(_("Parameter name not found in the flight controller."))
+
+        if self.filesystem.doc_dict:
+            if param_name in self.filesystem.doc_dict:
+                self.current_file_parameters[param_name] = Par(
+                    self.filesystem.param_default_dict.get(param_name, Par(0, "")).value, ""
+                )
+                self.parameters[param_name] = self.config_step_processor.create_ardupilot_parameter(
+                    param_name, self.current_file_parameters[param_name], self.current_file, fc_parameters
+                )
+                return True
+            raise InvalidParameterNameError(
+                _("'{param_name}' not found in the apm.pdef.xml file.").format(param_name=param_name)
+            )
+
+        if not fc_parameters and not self.filesystem.doc_dict:
+            raise OperationNotPossibleError(
+                _("Can not add parameter when no FC is connected and no apm.pdef.xml file exists.")
+            )
+        return False

ardupilot_methodic_configurator/data_model_configuration_step.py

@@ -17,7 +17,7 @@ from typing import Any, Optional
 from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.data_model_ardupilot_parameter import ArduPilotParameter
-from ardupilot_methodic_configurator.data_model_par_dict import ParDict
+from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict
 
 
 class ConfigurationStepProcessor:
@@ -38,11 +38,14 @@ class ConfigurationStepProcessor:
         """
         self.local_filesystem = local_filesystem
 
+        # A dictionary that maps variable names to their values
+        # These variables are used by the forced_parameters and derived_parameters in configuration_steps_*.json files
+        self.variables = self.local_filesystem.get_eval_variables()
+
     def process_configuration_step(
         self,
         selected_file: str,
         fc_parameters: dict[str, float],
-        variables: dict,
     ) -> tuple[dict[str, ArduPilotParameter], bool, list[tuple[str, str]], list[tuple[str, str]]]:
         """
         Process a configuration step including parameter computation and domain model creation.
@@ -50,7 +53,6 @@ class ConfigurationStepProcessor:
         Args:
             selected_file: The name of the selected parameter file
             fc_parameters: Dictionary of flight controller parameters
-            variables: Variables dictionary for evaluation
 
         Returns:
             Tuple containing:
@@ -66,6 +68,7 @@ class ConfigurationStepProcessor:
 
         # Process configuration step operations if configuration steps exist
         if self.local_filesystem.configuration_steps and selected_file in self.local_filesystem.configuration_steps:
+            variables = self.variables
             variables["fc_parameters"] = fc_parameters
 
             # Compute derived parameters
@@ -261,3 +264,37 @@ class ConfigurationStepProcessor:
                     renamed_pairs.append((old_name, new_name))
 
         return duplicates, renamed_pairs
+
+    def create_ardupilot_parameter(
+        self,
+        param_name: str,
+        param: Par,
+        selected_file: str,
+        fc_parameters: dict[str, float],
+    ) -> ArduPilotParameter:
+        """
+        Create an ArduPilotParameter domain model object.
+
+        Args:
+            param_name: The name of the parameter
+            param: The parameter object from the file
+            selected_file: The name of the selected parameter file
+            fc_parameters: Dictionary of flight controller parameters
+
+        Returns:
+            ArduPilotParameter: The created domain model parameter
+
+        """
+        # Get parameter metadata and default values
+        metadata = self.local_filesystem.doc_dict.get(param_name, {})
+        default_par = self.local_filesystem.param_default_dict.get(param_name, None)
+
+        # Check if parameter is forced or derived
+        forced_par = self.local_filesystem.forced_parameters.get(selected_file, ParDict()).get(param_name, None)
+        derived_par = self.local_filesystem.derived_parameters.get(selected_file, ParDict()).get(param_name, None)
+
+        # Get FC value if available
+        fc_value = fc_parameters.get(param_name)
+
+        # Create domain model parameter
+        return ArduPilotParameter(param_name, param, metadata, default_par, fc_value, forced_par, derived_par)

ardupilot_methodic_configurator/frontend_tkinter_base_window.py

@@ -281,9 +281,13 @@ class BaseWindow:
         parent_height = parent.winfo_height()
         window_width = window.winfo_width()
         window_height = window.winfo_height()
+        # logging_error(_("Parent position: %d,%d"), parent.winfo_x(), parent.winfo_y())
+        # logging_error(_("Parent size: %dx%d"), parent_width, parent_height)
+        # logging_error(_("Window size: %dx%d"), window_width, window_height)
         x = parent.winfo_x() + (parent_width // 2) - (window_width // 2)
         y = parent.winfo_y() + (parent_height // 2) - (window_height // 2)
         window.geometry(f"+{x}+{y}")
+        window.update()
 
     def put_image_in_label(  # pylint: disable=too-many-locals
         self,

ardupilot_methodic_configurator/frontend_tkinter_component_editor_base.py

@@ -32,10 +32,11 @@ from ardupilot_methodic_configurator.data_model_vehicle_components_base import C
 from ardupilot_methodic_configurator.data_model_vehicle_components_json_schema import VehicleComponentsJsonSchema
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_component_template_manager import ComponentTemplateManager
+from ardupilot_methodic_configurator.frontend_tkinter_font import create_scaled_font, get_safe_font_config
 from ardupilot_methodic_configurator.frontend_tkinter_rich_text import RichText
 from ardupilot_methodic_configurator.frontend_tkinter_scroll_frame import ScrollFrame
 from ardupilot_methodic_configurator.frontend_tkinter_show import show_error_message, show_tooltip
-from ardupilot_methodic_configurator.frontend_tkinter_usage_popup_window import UsagePopupWindow
+from ardupilot_methodic_configurator.frontend_tkinter_usage_popup_window import ConfirmationPopupWindow, UsagePopupWindow
 
 
 def argument_parser() -> Namespace:
@@ -288,7 +289,7 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
         """Check if usage instructions should be displayed."""
         if UsagePopupWindow.should_display("component_editor"):
             # Cast to Tk since we know root is a Tk instance in this context
-            self.root.after(10, lambda: self._display_component_editor_usage_instructions(cast("tk.Tk", self.root)))
+            self.root.after(1, lambda: self._display_component_editor_usage_instructions(cast("tk.Tk", self.root)))
 
     def _display_component_editor_usage_instructions(self, parent: tk.Tk) -> None:
         """Display usage instructions for the component editor."""
@@ -299,9 +300,10 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
         instructions_text = RichText(
             usage_popup_window.main_frame,
             wrap=tk.WORD,
-            height=5,
+            height=6,
             bd=0,
             background=style.lookup("TLabel", "background"),
+            font=create_scaled_font(get_safe_font_config(), 1.2),
         )
         # pylint: enable=duplicate-code
         instructions_text.insert(tk.END, _("1. Describe the properties of the vehicle components in the window below.\n"))
@@ -318,7 +320,7 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
             usage_popup_window,
             _("How to use the component editor window"),
             "component_editor",
-            "690x200",
+            "690x210",
             instructions_text,
         )
 
@@ -526,17 +528,49 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
             return
         if self._confirm_component_properties():
             self.save_component_json()
-        self.root.destroy()
+            self.root.destroy()
 
     def _confirm_component_properties(self) -> bool:
         """Show confirmation dialog for component properties."""
-        confirm_message = _(
-            "ArduPilot Methodic Configurator only operates correctly if all component properties are correct."
-            " ArduPilot parameter values depend on the components used and their connections.\n\n"
-            " Have you used the scrollbar on the right side of the window and "
-            "entered the correct values for all components?"
+        if not ConfirmationPopupWindow.should_display("component_editor_validation"):
+            return True
+
+        # Create a popup window similar to the usage instructions
+        validation_popup_window = BaseWindow(cast("tk.Tk", self.root))
+        style = ttk.Style()
+
+        # Create a 20% larger font
+        font_config = get_safe_font_config()
+        larger_font = create_scaled_font(font_config, 1.2)
+
+        confirmation_text = RichText(
+            validation_popup_window.main_frame,
+            wrap=tk.WORD,
+            height=6,
+            bd=0,
+            background=style.lookup("TLabel", "background"),
+            font=larger_font,
+        )
+        confirmation_text.insert(
+            tk.END,
+            _(
+                "ArduPilot Methodic Configurator only operates correctly if all component properties are correct."
+                " ArduPilot parameter values depend on the components used and their connections.\n\n"
+                " Have you used the scrollbar on the right side of the window and "
+                "entered the correct values for all components?"
+            ),
+        )
+        confirmation_text.config(state=tk.DISABLED)
+
+        # Use ConfirmationPopupWindow.display with yes/no buttons
+        return ConfirmationPopupWindow.display(
+            cast("tk.Tk", self.root),
+            validation_popup_window,
+            _("Confirm that all component properties are correct"),
+            "component_editor_validation",
+            "600x220",
+            confirmation_text,
         )
-        return messagebox.askyesno(_("Confirm that all component properties are correct"), confirm_message)
 
     def save_component_json(self) -> bool:
         """Save component JSON data to file."""

ardupilot_methodic_configurator/frontend_tkinter_font.py

@@ -172,3 +172,34 @@ def get_safe_font_size(font_name: str = "TkDefaultFont") -> int:
         return int(size_val) if size_val is not None else 0
     except (ValueError, TypeError, OverflowError):
         return 0
+
+
+def create_scaled_font(font_config: dict[str, Union[str, int]], scale_factor: float = 1.0) -> tkfont.Font:
+    """
+    Create a tkinter Font object from a font configuration dictionary with optional scaling.
+
+    Takes a font configuration dictionary (as returned by get_safe_font_config) and creates
+    an actual tkinter Font object, optionally scaling the font size by a given factor.
+
+    Args:
+        font_config: Dictionary containing 'family' (str) and 'size' (int) keys.
+                     Typically obtained from get_safe_font_config().
+        scale_factor: Multiplier for the font size. For example, 1.2 creates a font
+                     20% larger than the original. Defaults to 1.0 (no scaling).
+
+    Returns:
+        A tkinter Font object configured with the specified family and scaled size.
+
+    Example:
+        >>> config = get_safe_font_config("TkDefaultFont")
+        >>> larger_font = create_scaled_font(config, 1.2)  # 20% larger
+        >>> smaller_font = create_scaled_font(config, 0.8)  # 20% smaller
+
+    Note:
+        This function modifies the font_config dictionary in-place to scale the size.
+        If you need to preserve the original config, pass a copy.
+
+    """
+    if isinstance(font_config["size"], int):
+        font_config["size"] = int(font_config["size"] * scale_factor)
+    return tkfont.Font(**font_config)  # type: ignore[arg-type]