ardupilot-methodic-configurator 2.3.0__py3-none-any.whl → 2.5.0__py3-none-any.whl

ardupilot_methodic_configurator/frontend_tkinter_flightcontroller_info.py

@@ -64,7 +64,7 @@ class FlightControllerInfoWindow(BaseWindow):
 
     def __init__(self, flight_controller: FlightController) -> None:
         super().__init__()
-        self.root.title(_("ArduPilot methodic configurator ") + __version__ + _(" - Flight Controller Info"))
+        self.root.title(_("AMC {version} - Flight Controller Info").format(version=__version__))  # Set the window title
         self.root.geometry("500x420")  # Adjust the window size as needed
 
         self.presenter = FlightControllerInfoPresenter(flight_controller)

ardupilot_methodic_configurator/frontend_tkinter_font.py

@@ -95,7 +95,12 @@ def get_safe_font_config(font_name: str = "TkDefaultFont") -> dict[str, Union[st
             config = font.configure()
             if config and isinstance(config, dict):
                 # Extract only the family and size values, converting to proper types
-                family = str(config.get("family", ""))
+                family_val = config.get("family", "")
+                # Only accept string family names that are not empty
+                family = ""
+                if isinstance(family_val, str) and family_val.strip():
+                    family = family_val.strip()
+
                 size_val = config.get("size")
                 size = 0
                 if size_val is not None:
@@ -103,7 +108,10 @@ def get_safe_font_config(font_name: str = "TkDefaultFont") -> dict[str, Union[st
                         size = int(size_val)
                     except (ValueError, TypeError, OverflowError):
                         size = 0
-                return {"family": family, "size": size}
+
+                # Only return if we have valid values, otherwise fall back to platform defaults
+                if family:  # Family is the key indicator of a valid font configuration
+                    return {"family": family, "size": size}
         except tk.TclError:
             pass
 
@@ -159,4 +167,39 @@ def get_safe_font_size(font_name: str = "TkDefaultFont") -> int:
 
     """
     config = get_safe_font_config(font_name)
-    return int(config.get("size", 0))
+    size_val = config.get("size", 0)
+    try:
+        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]

ardupilot_methodic_configurator/frontend_tkinter_pair_tuple_combobox.py

@@ -100,6 +100,13 @@ class PairTupleCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
         self.set_entries_tuple(list_pair_tuple, selected_element)
         self.bind("<Configure>", self.on_combo_configure, add="+")
 
+        # Add keyboard navigation for up/down arrow keys
+        self.bind("<Up>", self._on_key_up, add="+")
+        self.bind("<Down>", self._on_key_down, add="+")
+
+        # Add focus handling for keyboard events (enable focus reception)
+        self.bind("<FocusIn>", lambda _: None, add="+")
+
         # Apply mouse wheel handling to this combobox instance
         setup_combobox_mousewheel_handling(self)
 
@@ -144,6 +151,64 @@ class PairTupleCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
 
     # SPDX-SnippetEnd
 
+    def _on_key_up(self, _event: tk.Event) -> str:
+        """Handle up arrow key navigation."""
+        if not self.list_keys:
+            return "break"
+
+        try:
+            current_index = self.current()
+            # Move up (decrease index), stop at the beginning
+            if current_index > 0:
+                new_index = current_index - 1
+                self.current(new_index)
+                # Highlight the text to show selection
+                self.selection_range(0, tk.END)
+                # Force the combobox to update visually
+                self.update_idletasks()
+                # Generate a virtual ComboboxSelected event to trigger callbacks
+                self.event_generate("<<ComboboxSelected>>")
+
+        except (ValueError, IndexError):
+            # Current selection not found or invalid, select first item
+            if self.list_keys:
+                self.current(0)
+                self.update_idletasks()
+                self.event_generate("<<ComboboxSelected>>")
+
+        # Prevent the default behavior
+        return "break"
+
+    def _on_key_down(self, _event: tk.Event) -> str:
+        """Handle down arrow key navigation."""
+        if not self.list_keys:
+            return "break"
+
+        try:
+            current_index = self.current()
+            # Move down (increase index), stop at the end
+            if current_index < len(self.list_keys) - 1:
+                new_index = current_index + 1
+                self.current(new_index)
+                # Highlight the text to show selection
+                self.selection_range(0, tk.END)
+                # Force the combobox to update visually
+                self.update_idletasks()
+                # Generate a virtual ComboboxSelected event to trigger callbacks
+                self.event_generate("<<ComboboxSelected>>")
+
+        except (ValueError, IndexError):
+            # Current selection not found or invalid, select first item
+            if self.list_keys:
+                self.current(0)
+                # Highlight the text to show selection
+                self.selection_range(0, tk.END)
+                self.update_idletasks()
+                self.event_generate("<<ComboboxSelected>>")
+
+        # Prevent the default behavior
+        return "break"
+
     # https://stackoverflow.com/questions/39915275/change-width-of-dropdown-listbox-of-a-ttk-combobox
     def on_combo_configure(self, event: tk.Event) -> None:
         combo = event.widget

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -34,8 +34,15 @@ from ardupilot_methodic_configurator.backend_flightcontroller import FlightContr
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
 from ardupilot_methodic_configurator.configuration_manager import ConfigurationManager
 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_base_window import (
+    BaseWindow,
+    ask_yesno_popup,
+    show_error_popup,
+    show_info_popup,
+    show_warning_popup,
+)
 from ardupilot_methodic_configurator.frontend_tkinter_directory_selection import VehicleDirectorySelectionWidgets
+from ardupilot_methodic_configurator.frontend_tkinter_font import create_scaled_font, get_safe_font_config
 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
@@ -49,7 +56,7 @@ def show_about_window(root: ttk.Frame, _version: str) -> None:  # pylint: disabl
     # Create a new window for the custom "About" message
     about_window = tk.Toplevel(root)
     about_window.title(_("About"))
-    about_window.geometry("650x320")
+    about_window.geometry("650x340")
 
     main_frame = ttk.Frame(about_window)
     main_frame.pack(expand=True, fill=tk.BOTH)
@@ -73,12 +80,23 @@ def show_about_window(root: ttk.Frame, _version: str) -> None:  # pylint: disabl
     component_editor_var = tk.BooleanVar(value=ProgramSettings.display_usage_popup("component_editor"))
     component_editor_checkbox = ttk.Checkbutton(
         usage_popup_frame,
-        text=_("Component editor window"),
+        text=_("Component editor window introduction"),
         variable=component_editor_var,
         command=lambda: ProgramSettings.set_display_usage_popup("component_editor", component_editor_var.get()),
     )
     component_editor_checkbox.pack(side=tk.TOP, anchor=tk.W)
 
+    component_editor_validation_var = tk.BooleanVar(value=ProgramSettings.display_usage_popup("component_editor_validation"))
+    component_editor_validation_checkbox = ttk.Checkbutton(
+        usage_popup_frame,
+        text=_("Component editor window data validation"),
+        variable=component_editor_validation_var,
+        command=lambda: ProgramSettings.set_display_usage_popup(
+            "component_editor_validation", component_editor_validation_var.get()
+        ),
+    )
+    component_editor_validation_checkbox.pack(side=tk.TOP, anchor=tk.W)
+
     parameter_editor_var = tk.BooleanVar(value=ProgramSettings.display_usage_popup("parameter_editor"))
     parameter_editor_checkbox = ttk.Checkbutton(
         usage_popup_frame,
@@ -123,21 +141,8 @@ def show_about_window(root: ttk.Frame, _version: str) -> None:  # pylint: disabl
     # Configure the grid to ensure equal spacing and expansion
     main_frame.columnconfigure([0, 1, 2, 3, 4], weight=1)
 
-
-def show_info_popup(title: str, message: str) -> None:
-    messagebox.showinfo(title, message)
-
-
-def show_warning_popup(title: str, message: str) -> None:
-    messagebox.showwarning(title, message)
-
-
-def show_error_popup(title: str, message: str) -> None:
-    messagebox.showerror(title, message)
-
-
-def ask_yesno_popup(title: str, message: str) -> bool:
-    return messagebox.askyesno(title, message)
+    # Center the about window on its parent
+    BaseWindow.center_window(about_window, root.winfo_toplevel())
 
 
 class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-attributes
@@ -223,13 +228,11 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
 
         # Create a new frame inside the config_subframe for the intermediate parameter file directory selection labels
         # and directory selection button
-        connected_vehicle_type = self.configuration_manager.connected_vehicle_type
         directory_selection_frame = VehicleDirectorySelectionWidgets(
             self,
             config_subframe,
             self.local_filesystem.vehicle_dir,
             destroy_parent_on_open=False,
-            connected_fc_vehicle_type=connected_vehicle_type,
         )
         if self.gui_complexity != "simple":
             directory_selection_frame.container_frame.pack(side=tk.LEFT, fill="x", expand=False, padx=(4, 6))
@@ -438,9 +441,10 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         instructions_text = RichText(
             usage_popup_window.main_frame,
             wrap=tk.WORD,
-            height=10,
+            height=11,
             bd=0,
             background=style.lookup("TLabel", "background"),
+            font=create_scaled_font(get_safe_font_config(), 1.5),
         )
         instructions_text.insert(tk.END, _("1. Read "))
         instructions_text.insert(tk.END, _("all"), "bold")
@@ -475,7 +479,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             usage_popup_window,
             _("How to use the parameter file editor and uploader window"),
             "parameter_editor",
-            "690x300",
+            "690x360",
             instructions_text,
         )
 

ardupilot_methodic_configurator/frontend_tkinter_project_creator.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+
+"""
+GUI to create the directory to store the vehicle configuration files.
+
+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 argparse import ArgumentParser, Namespace
+from logging import basicConfig as logging_basicConfig
+from logging import debug as logging_debug
+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 sys import exit as sys_exit
+from tkinter import messagebox, ttk
+
+from ardupilot_methodic_configurator import _, __version__
+from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
+from ardupilot_methodic_configurator.common_arguments import add_common_arguments
+from ardupilot_methodic_configurator.data_model_vehicle_project import VehicleProjectManager
+from ardupilot_methodic_configurator.data_model_vehicle_project_creator import (
+    NewVehicleProjectSettings,
+    VehicleProjectCreationError,
+)
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
+from ardupilot_methodic_configurator.frontend_tkinter_directory_selection import (
+    DirectorySelectionWidgets,
+    PathEntryWidget,
+)
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
+from ardupilot_methodic_configurator.frontend_tkinter_template_overview import TemplateOverviewWindow
+
+
+class VehicleProjectCreatorWindow(BaseWindow):
+    """
+    Window for creating a new vehicle project directory using a template and user-defined settings.
+
+    Dynamically builds the GUI based on available settings, allowing users to select source template,
+    destination directory, and project options. Integrates with VehicleProjectManager for project creation.
+    """
+
+    def __init__(self, project_manager: VehicleProjectManager) -> None:
+        super().__init__()
+        self.project_manager = project_manager
+        self.root.title(
+            _("Amilcar Lucas's - ArduPilot methodic configurator ")
+            + __version__
+            + _(" - Create a new vehicle project directory")
+        )
+
+        fc_connected = project_manager.is_flight_controller_connected()
+
+        # Initialize settings variables dynamically from data model
+        self.new_project_settings_vars: dict[str, tk.BooleanVar] = {}
+        self.new_project_settings_widgets: dict[str, ttk.Checkbutton] = {}
+        new_project_settings_metadata = NewVehicleProjectSettings.get_all_settings_metadata(fc_connected)
+        new_project_settings_default_values = NewVehicleProjectSettings.get_default_values()
+        for setting_name in new_project_settings_metadata:
+            default_value = new_project_settings_default_values.get(setting_name, False)
+            self.new_project_settings_vars[setting_name] = tk.BooleanVar(value=default_value)
+
+        # Set dynamic window size based on number of settings
+        nr_new_project_settings = len(new_project_settings_metadata)
+        window_height = 250 + (nr_new_project_settings * 23)
+        self.root.geometry(f"800x{window_height}")  # Set the window size
+
+        template_dir, new_base_dir, vehicle_dir = self.project_manager.get_recently_used_dirs()
+        logging_debug("template_dir: %s", template_dir)  # this string is intentionally left untranslated
+        logging_debug("new_base_dir: %s", new_base_dir)  # this string is intentionally left untranslated
+        logging_debug("vehicle_dir: %s", vehicle_dir)  # this string is intentionally left untranslated
+        self.create_option1_widgets(
+            template_dir,
+            new_base_dir,
+            self.project_manager.get_default_vehicle_name(),
+            fc_connected,
+            project_manager.get_vehicle_type(),
+        )
+
+        # Bind the close_connection_and_quit function to the window close event
+        self.root.protocol("WM_DELETE_WINDOW", self.close_and_quit)
+
+    def close_and_quit(self) -> None:
+        sys_exit(0)
+
+    def create_option1_widgets(  # pylint: disable=too-many-locals,too-many-arguments,too-many-positional-arguments
+        self,
+        initial_template_dir: str,
+        initial_base_dir: str,
+        initial_new_dir: str,
+        fc_connected: bool,
+        connected_fc_vehicle_type: str,
+    ) -> None:
+        # Option 1 - Create a new vehicle configuration directory based on an existing template
+        option1_label = ttk.Label(text=_("New vehicle"), style="Bold.TLabel")
+        option1_label_frame = ttk.LabelFrame(self.main_frame, labelwidget=option1_label)
+        option1_label_frame.pack(expand=True, fill=tk.X, padx=6, pady=6)
+        template_dir_edit_tooltip = _(
+            "Existing vehicle template directory containing the intermediate\n"
+            "parameter files to be copied to the new vehicle configuration directory"
+        )
+        template_dir_btn_tooltip = _(
+            "Select the existing vehicle template directory containing the intermediate\n"
+            "parameter files to be copied to the new vehicle configuration directory"
+        )
+
+        def template_selection_callback(_widget: "DirectorySelectionWidgets") -> str:
+            # Template selection logic
+            if isinstance(self.root, tk.Tk):  # this keeps mypy and pyright happy
+                to = TemplateOverviewWindow(self.root, connected_fc_vehicle_type=connected_fc_vehicle_type)
+                to.run_app()
+            # Get recently used template directory from project manager
+            template_dir, _nbd, _vd = self.project_manager.get_recently_used_dirs()
+            logging_info(_("Selected template directory: %s"), template_dir)
+            return template_dir
+
+        self.template_dir = DirectorySelectionWidgets(
+            parent=self,
+            parent_frame=option1_label_frame,
+            initialdir=initial_template_dir,
+            label_text=_("Source Template directory:"),
+            autoresize_width=False,
+            dir_tooltip=template_dir_edit_tooltip,
+            button_tooltip=template_dir_btn_tooltip,
+            on_directory_selected_callback=template_selection_callback,
+        )
+        self.template_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
+
+        # Create checkboxes dynamically from settings metadata
+        settings_metadata = NewVehicleProjectSettings.get_all_settings_metadata(fc_connected)
+        for setting_name, metadata in settings_metadata.items():
+            checkbox = ttk.Checkbutton(
+                option1_label_frame,
+                variable=self.new_project_settings_vars[setting_name],
+                text=metadata.label,
+                state=tk.NORMAL if metadata.enabled else tk.DISABLED,
+            )
+            checkbox.pack(anchor=tk.NW)
+            show_tooltip(checkbox, metadata.tooltip)
+            self.new_project_settings_widgets[setting_name] = checkbox
+
+        new_base_dir_edit_tooltip = _("Existing directory where the new vehicle configuration directory will be created")
+        new_base_dir_btn_tooltip = _("Select the directory where the new vehicle configuration directory will be created")
+        self.new_base_dir = DirectorySelectionWidgets(
+            parent=self,
+            parent_frame=option1_label_frame,
+            initialdir=initial_base_dir,
+            label_text=_("Destination base directory:"),
+            autoresize_width=False,
+            dir_tooltip=new_base_dir_edit_tooltip,
+            button_tooltip=new_base_dir_btn_tooltip,
+            on_directory_selected_callback=None,  # Use default file dialog behavior
+        )
+        self.new_base_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
+        new_dir_edit_tooltip = _(
+            "A new vehicle configuration directory with this name will be created at the (destination) base directory"
+        )
+        self.new_dir = PathEntryWidget(
+            option1_label_frame, initial_new_dir, _("Destination new vehicle name:"), new_dir_edit_tooltip
+        )
+        self.new_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
+        create_vehicle_directory_from_template_button = ttk.Button(
+            option1_label_frame,
+            text=_("Create vehicle configuration directory from template"),
+            command=self.create_new_vehicle_from_template,
+        )
+        create_vehicle_directory_from_template_button.pack(expand=False, fill=tk.X, padx=20, pady=5, anchor=tk.CENTER)
+        show_tooltip(
+            create_vehicle_directory_from_template_button,
+            _(
+                "Create a new vehicle configuration directory on the (destination) base directory,\n"
+                "copy the template files from the (source) template directory to it and\n"
+                "load the newly created files into the application"
+            ),
+        )
+
+    def create_new_vehicle_from_template(self) -> None:
+        # Get the selected template directory and new vehicle configuration directory name
+        template_dir = self.template_dir.get_selected_directory()
+        new_base_dir = self.new_base_dir.get_selected_directory()
+        new_vehicle_name = self.new_dir.get_selected_directory()
+
+        # Create settings object from GUI state using dynamic settings
+        settings_kwargs = {}
+        for setting_name, var in self.new_project_settings_vars.items():
+            settings_kwargs[setting_name] = var.get()
+        settings = NewVehicleProjectSettings(**settings_kwargs)
+
+        # Create the vehicle project
+        try:
+            self.project_manager.create_new_vehicle_from_template(template_dir, new_base_dir, new_vehicle_name, settings)
+            self.root.destroy()
+        except VehicleProjectCreationError as e:
+            messagebox.showerror(e.title, e.message)
+
+
+# pylint: disable=duplicate-code
+def argument_parser() -> Namespace:
+    """
+    Set up and parse command-line arguments for development/testing purposes.
+
+    Returns:
+        argparse.Namespace: Parsed arguments.
+
+    """
+    parser = ArgumentParser(
+        description=_(
+            "This main is for testing and development only. "
+            "Usually, the VehicleProjectCreatorWindow is called from another script"
+        )
+    )
+    parser = LocalFilesystem.add_argparse_arguments(parser)
+    return add_common_arguments(parser).parse_args()
+
+
+def main() -> None:
+    args = argument_parser()
+
+    logging_basicConfig(level=logging_getLevelName(args.loglevel), format="%(asctime)s - %(levelname)s - %(message)s")
+
+    logging_warning(
+        _(
+            "This main is for testing and development only, usually the VehicleProjectCreatorWindow is"
+            " called from another script"
+        )
+    )
+
+    local_filesystem = LocalFilesystem(
+        args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files, args.save_component_to_system_templates
+    )
+
+    # Create project manager with the local filesystem
+    project_manager = VehicleProjectManager(local_filesystem)
+
+    # Get the list of intermediate parameter files to be processed
+    files = project_manager.get_file_parameters_list()
+
+    if not files:
+        logging_error(_("No intermediate parameter files found in %s."), args.vehicle_dir)
+
+    window = VehicleProjectCreatorWindow(project_manager)
+    window.root.mainloop()
+
+
+# pylint: enable=duplicate-code
+
+
+if __name__ == "__main__":
+    main()