ardupilot-methodic-configurator 1.5.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

ardupilot_methodic_configurator/frontend_tkinter_component_editor_base.py

@@ -19,19 +19,16 @@ from logging import getLevelName as logging_getLevelName
 from logging import info as logging_info
 from sys import exit as sys_exit
 from tkinter import messagebox, ttk
-from typing import Optional, Union, cast
+from typing import Any, Optional, Union, cast
 from unittest.mock import patch
 
 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.data_model_vehicle_components import ComponentDataModel
-from ardupilot_methodic_configurator.data_model_vehicle_components_base import (
-    ComponentData,
-    ComponentPath,
-    ComponentValue,
-    ValidationRulePath,
-)
+from ardupilot_methodic_configurator.data_model_vehicle_components_base import ComponentData, ComponentPath, ComponentValue
+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_rich_text import RichText
@@ -67,7 +64,8 @@ def argument_parser() -> Namespace:
 EntryWidget = Union[ttk.Entry, ttk.Combobox]
 
 WINDOW_WIDTH_PIX = 880
-VEICLE_IMAGE_WIDTH_PIX = 100
+VEHICLE_IMAGE_WIDTH_PIX = 100
+VEHICLE_IMAGE_HEIGHT_PIX = 100
 
 
 class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instance-attributes
@@ -108,6 +106,7 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
         self.scroll_frame: ScrollFrame
         self.save_button: ttk.Button
         self.template_manager: ComponentTemplateManager
+        self.complexity_var = tk.StringVar()
 
         # Initialize UI if there's data to work with
         if self._check_data():
@@ -117,8 +116,9 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
     def _create_data_model(self) -> ComponentDataModel:
         """Create the data model. Extracted for better testability."""
         raw_data = self.local_filesystem.load_vehicle_components_json_data(self.local_filesystem.vehicle_dir)
-        component_datatypes = self.local_filesystem.get_all_value_datatypes()
-        return ComponentDataModel(raw_data, component_datatypes)
+        schema = VehicleComponentsJsonSchema(self.local_filesystem.load_schema())
+        component_datatypes = schema.get_all_value_datatypes()
+        return ComponentDataModel(raw_data, component_datatypes, schema)
 
     def _initialize_ui(self) -> None:
         """Initialize the complete UI. Extracted for better testability."""
@@ -153,39 +153,94 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
     def _setup_styles(self) -> None:
         """Configure the styles for UI elements."""
         style = ttk.Style()
-        style.configure("bigger.TLabel", font=("TkDefaultFont", 13))
-        style.configure("comb_input_invalid.TCombobox", fieldbackground="red")
-        style.configure("comb_input_valid.TCombobox", fieldbackground="white")
-        style.configure("entry_input_invalid.TEntry", fieldbackground="red")
-        style.configure("entry_input_valid.TEntry", fieldbackground="white")
-        style.configure("Optional.TLabelframe", borderwidth=2)
-        style.configure("Optional.TLabelframe.Label", foreground="gray")
+        style.configure("bigger.TLabel", font=("TkDefaultFont", 13))  # type: ignore[no-untyped-call]
+        style.configure("comb_input_invalid.TCombobox", fieldbackground="red")  # type: ignore[no-untyped-call]
+        style.configure("comb_input_valid.TCombobox", fieldbackground="white")  # type: ignore[no-untyped-call]
+        style.configure("entry_input_invalid.TEntry", fieldbackground="red")  # type: ignore[no-untyped-call]
+        style.configure("entry_input_valid.TEntry", fieldbackground="white")  # type: ignore[no-untyped-call]
+        style.configure("Optional.TLabelframe", borderwidth=2)  # type: ignore[no-untyped-call]
+        style.configure("Optional.TLabelframe.Label", foreground="gray")  # type: ignore[no-untyped-call]
 
     def _create_intro_frame(self) -> None:
         """Create the introduction frame with explanations and image."""
         intro_frame = ttk.Frame(self.main_frame)
         intro_frame.pack(side=tk.TOP, fill="x", expand=False)
 
-        self._add_explanation_text(intro_frame)
+        # Add vehicle image first to the right side
         self._add_vehicle_image(intro_frame)
 
+        # Add explanation text to the left side
+        self._add_explanation_text(intro_frame)
+
     def _add_explanation_text(self, parent: ttk.Frame) -> None:
         """Add explanation text to the parent frame."""
+        explanation_frame = ttk.Frame(parent)
+        explanation_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(10, 10), pady=(10, 0))
+
+        # Add UI complexity combobox
+        complexity_frame = ttk.Frame(explanation_frame)
+        complexity_frame.pack(side=tk.TOP, anchor=tk.NW, padx=(0, 10))
+
+        complexity_label = ttk.Label(complexity_frame, text=_("GUI Complexity:"))
+        complexity_label.pack(side=tk.LEFT, padx=(0, 5))
+
+        complexity_setting = ProgramSettings.get_setting("gui_complexity")
+        self.complexity_var.set(str(complexity_setting) if complexity_setting is not None else "simple")
+
+        complexity_combobox = ttk.Combobox(
+            complexity_frame, textvariable=self.complexity_var, values=["simple", "normal"], state="readonly", width=10
+        )
+        complexity_combobox.pack(side=tk.LEFT)
+        complexity_combobox.bind("<<ComboboxSelected>>", self._on_complexity_changed)
+
+        # Add tooltip
+        show_tooltip(
+            complexity_combobox,
+            _(
+                "Select the graphical user interface complexity level:\n"
+                "simple for beginners, only minimal mandatory fields no optional params displayed\n"
+                "normal for everybody else."
+            ),
+        )
+
         explanation_text = _("Please configure properties of the vehicle components.\n")
         explanation_text += _("Labels for optional properties are displayed in gray text.\n")
         explanation_text += _("Scroll down to ensure that you do not overlook any properties.\n")
 
         explanation_label = ttk.Label(
-            parent, text=explanation_text, wraplength=WINDOW_WIDTH_PIX - VEICLE_IMAGE_WIDTH_PIX, justify=tk.LEFT
+            explanation_frame, text=explanation_text, wraplength=WINDOW_WIDTH_PIX - VEHICLE_IMAGE_WIDTH_PIX, justify=tk.LEFT
         )
         explanation_label.configure(style="bigger.TLabel")
-        explanation_label.pack(side=tk.LEFT, padx=(10, 10), pady=(10, 0), anchor=tk.NW)
+        explanation_label.pack(side=tk.TOP, anchor=tk.NW, pady=self.calculate_scaled_padding_tuple(10, 0))
+
+    def _on_complexity_changed(self, _event: Optional[tk.Event] = None) -> None:
+        """Handle complexity combobox change."""
+        old_gui_complexity = ProgramSettings.get_setting("gui_complexity")
+        new_gui_complexity = self.complexity_var.get()
+        if new_gui_complexity != old_gui_complexity:
+            ProgramSettings.set_setting("gui_complexity", new_gui_complexity)
+            self._refresh_component_display()
+
+    def _refresh_component_display(self) -> None:
+        """Refresh the component display UI."""
+        # Clear all widgets from the scroll frame
+        for widget in self.scroll_frame.view_port.winfo_children():
+            widget.destroy()
+
+        # Clear the entry_widgets dictionary since all widgets have been destroyed
+        self.entry_widgets.clear()
+
+        # Repopulate the frame with widgets according to the new complexity setting
+        self.populate_frames()
+
+        # Update the UI
+        self.scroll_frame.view_port.update_idletasks()
 
     def _add_vehicle_image(self, parent: ttk.Frame) -> None:
         """Add the vehicle image to the parent frame."""
         if self.local_filesystem.vehicle_image_exists():
             image_label = self.put_image_in_label(
-                parent, self.local_filesystem.vehicle_image_filepath(), VEICLE_IMAGE_WIDTH_PIX
+                parent, self.local_filesystem.vehicle_image_filepath(), VEHICLE_IMAGE_HEIGHT_PIX
             )
             image_label.pack(side=tk.RIGHT, anchor=tk.NE, padx=(4, 4), pady=(4, 0))
             show_tooltip(image_label, _("Replace the vehicle.jpg file in the vehicle directory to change the vehicle image."))
@@ -239,7 +294,11 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
         style = ttk.Style()
 
         instructions_text = RichText(
-            usage_popup_window.main_frame, wrap=tk.WORD, height=5, bd=0, background=style.lookup("TLabel", "background")
+            usage_popup_window.main_frame,
+            wrap=tk.WORD,
+            height=5,
+            bd=0,
+            background=style.lookup("TLabel", "background"),  # type: ignore[no-untyped-call]
         )
         instructions_text.insert(tk.END, _("1. Describe the properties of the vehicle components in the window below.\n"))
         instructions_text.insert(tk.END, _("2. Each field has mouse-over tooltips for additional guidance.\n"))
@@ -261,7 +320,29 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
 
     def set_component_value_and_update_ui(self, path: ComponentPath, value: str) -> None:
         """Set a component value and update the UI to reflect it."""
+        self._set_component_value(path, value)
+        self._update_widget_value(path, value)
+
+    def _set_component_value(self, path: ComponentPath, value: str) -> None:
+        """Set component value in data model."""
         self.data_model.set_component_value(path, value)
+
+    def set_vehicle_configuration_template(self, configuration_template: str) -> None:
+        """Set the configuration template name in the data."""
+        self.data_model.set_configuration_template(configuration_template)
+
+    def set_values_from_fc_parameters(self, fc_parameters: dict[str, Any], doc: dict[str, Any]) -> None:
+        """
+        Process flight controller parameters and update the data model.
+
+        This delegates to the data model's process_fc_parameters method to handle
+        all the business logic of processing parameters.
+        """
+        # Delegate to the data model for parameter processing
+        self.data_model.process_fc_parameters(fc_parameters, doc)
+
+    def _update_widget_value(self, path: ComponentPath, value: str) -> None:
+        """Update widget value in UI."""
         if path in self.entry_widgets:
             entry = self.entry_widgets[path]
             entry.delete(0, tk.END)
@@ -273,6 +354,8 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
         components = self.data_model.get_all_components()
         for key, value in components.items():
             self.add_widget(self.scroll_frame.view_port, key, value, [])
+        # Scroll to the top after (re-)populating
+        self.scroll_frame.canvas.yview("moveto", 0)
 
     def add_widget(self, parent: tk.Widget, key: str, value: ComponentValue, path: list[str]) -> None:
         """
@@ -293,31 +376,26 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
             path (list): The path to the current key in the JSON data.
 
         """
+        # Skip components that shouldn't be displayed in simple mode
+        if isinstance(value, dict) and not self.data_model.should_display_in_simple_mode(
+            key, value, path, self.complexity_var.get()
+        ):
+            return
+
+        # For leaf nodes in simple mode, check if they are optional
+        if not isinstance(value, dict) and not self.data_model.should_display_leaf_in_simple_mode(
+            (*path, key), self.complexity_var.get()
+        ):
+            return
+
         if isinstance(value, dict):  # JSON non-leaf elements, add LabelFrame widget
             self._add_non_leaf_widget(parent, key, value, path)
         else:  # JSON leaf elements, add Entry widget
             self._add_leaf_widget(parent, key, value, path)
 
     def _prepare_non_leaf_widget_config(self, key: str, value: dict, path: list[str]) -> dict:
-        """Prepare configuration for non-leaf widget creation. Pure function for easy testing."""
-        is_toplevel = len(path) == 0  # More explicit than checking parent type
-        current_path = (*path, key)
-        description, is_optional = self.local_filesystem.get_component_property_description(current_path)
-        description = _(description) if description else ""
-
-        # Enhance tooltip for optional fields
-        if is_optional and description:
-            description += _("\nThis is optional and can be left blank")
-
-        return {
-            "key": key,
-            "value": value,
-            "path": current_path,
-            "description": description,
-            "is_optional": is_optional,
-            "is_toplevel": is_toplevel,
-            "pady": 5 if is_toplevel else 3,
-        }
+        """Prepare configuration for non-leaf widget creation. Delegates to display logic."""
+        return self.data_model.prepare_non_leaf_widget_config(key, value, path)
 
     def _create_non_leaf_widget_ui(self, parent: tk.Widget, config: dict) -> ttk.LabelFrame:
         """Create the UI elements for a non-leaf widget. Separated for better testability."""
@@ -329,7 +407,7 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
         frame.pack(
             fill=tk.X,
             side=tk.TOP if config["is_toplevel"] else tk.LEFT,
-            pady=config["pady"],
+            pady=5 if config["is_toplevel"] else 3,
             padx=5,
             anchor=tk.NW if config["is_toplevel"] else tk.N,
         )
@@ -360,30 +438,15 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
         self._create_leaf_widget_ui(parent, widget_config)
 
     def _prepare_leaf_widget_config(self, key: str, value: Union[str, float], path: list[str]) -> dict:
-        """Prepare configuration for leaf widget creation. Pure function for easy testing."""
-        component_path = (*path, key)
-        description, is_optional = self.local_filesystem.get_component_property_description(component_path)
-        description = _(description) if description else ""
-
-        # Enhance tooltip for optional fields
-        if is_optional and description:
-            description += _("\nThis is optional and can be left blank")
-
-        return {
-            "key": key,
-            "value": value,
-            "path": component_path,
-            "description": description,
-            "is_optional": is_optional,
-            "label_color": "gray" if is_optional else "black",
-        }
+        """Prepare configuration for leaf widget creation. Delegates to display logic."""
+        return self.data_model.prepare_leaf_widget_config(key, value, path)
 
     def _create_leaf_widget_ui(self, parent: tk.Widget, config: dict) -> None:
         """Create the UI elements for a leaf widget. Separated for better testability."""
         entry_frame = ttk.Frame(parent)
         entry_frame.pack(side=tk.TOP, fill=tk.X, pady=(0, 5))
 
-        label = ttk.Label(entry_frame, text=_(config["key"]), foreground=config["label_color"])
+        label = ttk.Label(entry_frame, text=_(config["key"]), foreground="gray" if config["is_optional"] else "black")
         label.pack(side=tk.LEFT)
 
         entry = self.add_entry_or_combobox(config["value"], entry_frame, config["path"], config["is_optional"])
@@ -399,7 +462,8 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
 
     def _add_template_controls(self, parent_frame: ttk.LabelFrame, component_name: str) -> None:
         """Add template controls for a component."""
-        self.template_manager.add_template_controls(parent_frame, component_name)
+        if self.complexity_var.get() != "simple":
+            self.template_manager.add_template_controls(parent_frame, component_name)
 
     def get_component_data_from_gui(self, component_name: str) -> ComponentData:
         """Extract component data from GUI elements."""
@@ -409,8 +473,53 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
         # Use the data model to extract and process the component data
         return self.data_model.extract_component_data_from_entries(component_name, entry_values)
 
+    def validate_data_and_highlight_errors_in_red(self) -> str:
+        """Validate all data using the data model."""
+        # Collect all entry values
+        entry_values = {
+            path: entry.get() for path, entry in self.entry_widgets.items() if isinstance(entry, (ttk.Entry, ttk.Combobox))
+        }
+
+        # Use data model for validation
+        is_valid, errors = self.data_model.validate_all_data(entry_values)
+
+        if not is_valid:
+            # Update UI to show invalid states and display errors
+            for path, entry in (
+                (path, entry) for path, entry in self.entry_widgets.items() if isinstance(entry, (ttk.Entry, ttk.Combobox))
+            ):
+                value = entry.get()
+
+                # Check combobox validation
+                if isinstance(entry, ttk.Combobox):
+                    combobox_values = self.data_model.get_combobox_values_for_path(path)
+                    if combobox_values and value not in combobox_values:
+                        entry.configure(style="comb_input_invalid.TCombobox")
+                    else:
+                        entry.configure(style="comb_input_valid.TCombobox")
+                else:
+                    # Check entry validation
+                    error_message, _corr = self.data_model.validate_entry_limits(value, path)
+                    if error_message:
+                        entry.configure(style="entry_input_invalid.TEntry")
+                    else:
+                        entry.configure(style="entry_input_valid.TEntry")
+
+            # Show first few errors
+            error_message = "\n".join(errors[:3])  # Show first 3 errors
+            if len(errors) > 3:
+                error_message += f"\n... and {len(errors) - 3} more errors"
+            show_error_message(_("Validation Errors"), error_message)
+            return _("Validation failed. Please correct the errors before saving.")
+
+        return ""
+
     def validate_and_save_component_json(self) -> None:
         """Validate and save the component JSON data."""
+        error_msg = self.validate_data_and_highlight_errors_in_red()
+        if error_msg:
+            show_error_message(_("Error"), error_msg)
+            return
         if self._confirm_component_properties():
             self.save_component_json()
 
@@ -426,11 +535,17 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
 
     def save_component_json(self) -> None:
         """Save component JSON data to file."""
-        # Use data model to save (which handles validation and data processing)
-        failed, msg = self.data_model.save_to_filesystem(self.local_filesystem)
+        save_result = self._perform_file_save()
+        self._handle_save_result(save_result)
+
+    def _perform_file_save(self) -> tuple[bool, str]:
+        """Perform file save operation."""
+        return self.data_model.save_to_filesystem(self.local_filesystem)
 
-        if failed:
-            show_error_message(_("Error"), _("Failed to save data to file.") + "\n" + msg)
+    def _handle_save_result(self, save_result: tuple[bool, str]) -> None:
+        """Handle save operation result."""
+        if save_result[0]:
+            show_error_message(_("Error"), _("Failed to save data to file.") + "\n" + save_result[1])
         else:
             logging_info(_("Vehicle component data saved successfully."))
 
@@ -454,7 +569,7 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
         self,
         value: Union[str, float],
         entry_frame: ttk.Frame,
-        _path: ValidationRulePath,
+        _path: ComponentPath,
         is_optional: bool = False,  # pylint: disable=unused-argument # noqa: ARG002
     ) -> EntryWidget:
         """Create an entry widget for input values."""
@@ -500,7 +615,7 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
 
         """
         # Import MagicMock at the method level to avoid import issues
-        from unittest.mock import MagicMock  # pylint: disable=import-outside-toplevel
+        from unittest.mock import MagicMock  # pylint: disable=import-outside-toplevel # noqa: PLC0415
 
         if local_filesystem is None:
             # Create a minimal mock filesystem for testing
@@ -508,7 +623,7 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
             local_filesystem.vehicle_dir = "test_vehicle"
             local_filesystem.doc_dict = {}
             local_filesystem.load_vehicle_components_json_data.return_value = {}
-            local_filesystem.get_all_value_datatypes.return_value = {}
+            local_filesystem.load_schema.return_value = {}
 
         # Patch the BaseWindow initialization to avoid Tkinter dependencies
         with patch("ardupilot_methodic_configurator.frontend_tkinter_component_editor_base.BaseWindow.__init__"):
@@ -530,6 +645,7 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
             instance.scroll_frame = MagicMock()
             instance.save_button = MagicMock()
             instance.template_manager = MagicMock()
+            instance.complexity_var = MagicMock()
 
             return instance
 

ardupilot_methodic_configurator/frontend_tkinter_connection_selection.py

@@ -285,8 +285,8 @@ def main() -> None:
     )
     # pylint: enable=duplicate-code
 
-    flight_controller = FlightController(args.reboot_time)  # Initialize your FlightController instance
-    result = flight_controller.connect(device=args.device)  # Connect to the flight controller
+    flight_controller = FlightController(reboot_time=args.reboot_time, baudrate=args.baudrate)
+    result = flight_controller.connect(device=args.device)
     if result:
         logging_warning(result)
         window = ConnectionSelectionWindow(flight_controller, result)

ardupilot_methodic_configurator/frontend_tkinter_directory_selection.py

@@ -30,7 +30,7 @@ from ardupilot_methodic_configurator.frontend_tkinter_show import show_no_param_
 from ardupilot_methodic_configurator.frontend_tkinter_template_overview import TemplateOverviewWindow
 
 
-class DirectorySelectionWidgets:
+class DirectorySelectionWidgets:  # pylint: disable=too-many-instance-attributes
     """
     A class to manage directory selection widgets in the GUI.
 
@@ -49,12 +49,14 @@ class DirectorySelectionWidgets:
         dir_tooltip: str,
         button_tooltip: str,
         is_template_selection: bool,
+        connected_fc_vehicle_type: str,
     ) -> None:
         self.parent = parent
         self.directory: str = deepcopy(initialdir)
         self.label_text = label_text
         self.autoresize_width = autoresize_width
         self.is_template_selection = is_template_selection
+        self.connected_fc_vehicle_type = connected_fc_vehicle_type
 
         # Create a new frame for the directory selection label and button
         self.container_frame = ttk.Frame(parent_frame)
@@ -89,7 +91,7 @@ class DirectorySelectionWidgets:
     def on_select_directory(self) -> bool:
         if self.is_template_selection:
             if isinstance(self.parent.root, tk.Tk):  # this keeps mypy and pyright happy
-                to = TemplateOverviewWindow(self.parent.root)
+                to = TemplateOverviewWindow(self.parent.root, connected_fc_vehicle_type=self.connected_fc_vehicle_type)
                 to.run_app()
             selected_directory = ProgramSettings.get_recently_used_dirs()[0]
             logging_info(_("Selected template directory: %s"), selected_directory)
@@ -158,6 +160,7 @@ class VehicleDirectorySelectionWidgets(DirectorySelectionWidgets):
         local_filesystem: LocalFilesystem,
         initial_dir: str,
         destroy_parent_on_open: bool,
+        connected_fc_vehicle_type: str = "",
     ) -> None:
         # Call the parent constructor with the necessary arguments
         super().__init__(
@@ -177,6 +180,7 @@ class VehicleDirectorySelectionWidgets(DirectorySelectionWidgets):
             if destroy_parent_on_open
             else "",
             is_template_selection=False,
+            connected_fc_vehicle_type=connected_fc_vehicle_type,
         )
         self.local_filesystem = local_filesystem
         self.destroy_parent_on_open = destroy_parent_on_open
@@ -196,7 +200,7 @@ class VehicleDirectorySelectionWidgets(DirectorySelectionWidgets):
             self.local_filesystem.vehicle_dir = self.directory
 
             if not self.local_filesystem.vehicle_configuration_files_exist(self.directory):
-                _filename = self.local_filesystem.vehicle_components_json_filename
+                _filename = self.local_filesystem.vehicle_components_fs.json_filename
                 error_msg = _("Selected directory must contain files matching \\d\\d_*\\.param and a {_filename} file")
                 messagebox.showerror(_("Invalid Vehicle Directory Selected"), error_msg.format(**locals()))
                 return False
@@ -231,9 +235,12 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
     vehicle configuration directory.
     """
 
-    def __init__(self, local_filesystem: LocalFilesystem, fc_connected: bool = False) -> None:
+    def __init__(
+        self, local_filesystem: LocalFilesystem, fc_connected: bool = False, connected_fc_vehicle_type: str = ""
+    ) -> None:
         super().__init__()
         self.local_filesystem = local_filesystem
+        self.connected_fc_vehicle_type = connected_fc_vehicle_type
         self.root.title(
             _("Amilcar Lucas's - ArduPilot methodic configurator ")
             + __version__
@@ -244,6 +251,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
         self.infer_comp_specs_and_conn_from_fc_params = tk.BooleanVar(value=False)
         self.use_fc_params = tk.BooleanVar(value=False)
         self.blank_change_reason = tk.BooleanVar(value=False)
+        self.copy_vehicle_image = tk.BooleanVar(value=False)
         self.configuration_template: str = ""  # will be set to a string if a template was used
 
         # Explain why we are here
@@ -259,7 +267,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
         )
         introduction_label.pack(expand=False, fill=tk.X, padx=6, pady=6)
         template_dir, new_base_dir, vehicle_dir = LocalFilesystem.get_recently_used_dirs()
-        self.create_option1_widgets(template_dir, new_base_dir, _("MyVehicleName"), fc_connected)
+        self.create_option1_widgets(template_dir, new_base_dir, _("MyVehicleName"), fc_connected, connected_fc_vehicle_type)
         self.create_option2_widgets(vehicle_dir)
         self.create_option3_widgets(vehicle_dir)
 
@@ -269,8 +277,13 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
     def close_and_quit(self) -> None:
         sys_exit(0)
 
-    def create_option1_widgets(  # pylint: disable=too-many-locals
-        self, initial_template_dir: str, initial_base_dir: str, initial_new_dir: str, fc_connected: bool
+    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")
@@ -293,6 +306,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             dir_tooltip=template_dir_edit_tooltip,
             button_tooltip=template_dir_btn_tooltip,
             is_template_selection=True,
+            connected_fc_vehicle_type=connected_fc_vehicle_type,
         )
         self.template_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
         blank_component_data_checkbox = ttk.Checkbutton(
@@ -347,6 +361,19 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             blank_change_reason_checkbox,
             _("Do not use the parameters change reason from the template."),
         )
+        copy_vehicle_image_checkbox = ttk.Checkbutton(
+            option1_label_frame,
+            variable=self.copy_vehicle_image,
+            text=_("Copy vehicle image from template"),
+        )
+        copy_vehicle_image_checkbox.pack(anchor=tk.NW)
+        show_tooltip(
+            copy_vehicle_image_checkbox,
+            _(
+                "Copy the vehicle.jpg image file from the template directory to the new vehicle directory\n"
+                "if it exists. This image helps identify the vehicle configuration."
+            ),
+        )
         if not fc_connected:
             self.infer_comp_specs_and_conn_from_fc_params.set(False)
             infer_comp_specs_and_conn_from_fc_params_checkbox.config(state=tk.DISABLED)
@@ -364,6 +391,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             dir_tooltip=new_base_dir_edit_tooltip,
             button_tooltip=new_base_dir_btn_tooltip,
             is_template_selection=False,
+            connected_fc_vehicle_type="",
         )
         self.new_base_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
         new_dir_edit_tooltip = _(
@@ -404,7 +432,12 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
         )
         option2_label.pack(expand=False, fill=tk.X, padx=6)
         self.connection_selection_widgets = VehicleDirectorySelectionWidgets(
-            self, option2_label_frame, self.local_filesystem, initial_dir, destroy_parent_on_open=True
+            self,
+            option2_label_frame,
+            self.local_filesystem,
+            initial_dir,
+            destroy_parent_on_open=True,
+            connected_fc_vehicle_type=self.connected_fc_vehicle_type,
         )
         self.connection_selection_widgets.container_frame.pack(expand=True, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
 
@@ -423,6 +456,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             dir_tooltip=_("Last used vehicle configuration directory"),
             button_tooltip="",
             is_template_selection=False,
+            connected_fc_vehicle_type="",
         )
         last_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
 
@@ -471,7 +505,10 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             return
 
         error_msg = self.local_filesystem.copy_template_files_to_new_vehicle_dir(
-            template_dir, new_vehicle_dir, self.blank_change_reason.get()
+            template_dir,
+            new_vehicle_dir,
+            blank_change_reason=self.blank_change_reason.get(),
+            copy_vehicle_image=self.copy_vehicle_image.get(),
         )
         if error_msg:
             messagebox.showerror(_("Copying template files"), error_msg)