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

ardupilot_methodic_configurator/frontend_tkinter_autoresize_combobox.py

@@ -0,0 +1,66 @@
+"""
+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
+
+from logging import error as logging_error
+from logging import warning as logging_warning
+from tkinter import ttk
+from typing import Union
+
+from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
+
+
+def update_combobox_width(combobox: ttk.Combobox) -> None:
+    # Calculate the maximum width needed for the content
+    values = combobox["values"]
+    max_width = max(len(value) for value in values) if values else 0
+    # Set a minimum width for the combobox
+    min_width = 4  # Adjust this value as needed
+    # Set the width of the combobox to the maximum width, but not less than the minimum width
+    combobox.config(width=max(min_width, max_width))
+
+
+class AutoResizeCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
+    """
+    A custom Combobox widget that automatically resizes based on its content.
+
+    This class extends the ttk.Combobox widget to include functionality for
+    automatically adjusting its width based on the longest entry in its list of
+    values. It also supports displaying a tooltip when hovering over the widget.
+
+    Attributes:
+        master: The parent container in which the Combobox is placed.
+        values: A tuple of strings representing the entries in the Combobox.
+        selected_element: The initially selected element in the Combobox.
+        tooltip: A string representing the tooltip text to display when hovering over the widget.
+
+    """
+
+    def __init__(
+        self, master: ttk.Frame, values: list[str], selected_element: str, tooltip: Union[None, str], *args, **kwargs
+    ) -> None:
+        super().__init__(master, *args, **kwargs)
+        self.set_entries_tuple(values, selected_element, tooltip)
+
+    def set_entries_tuple(self, values: list[str], selected_element: str, tooltip: Union[None, str] = None) -> None:
+        self["values"] = tuple(values)
+        if selected_element:
+            if selected_element in values:
+                self.set(selected_element)
+            else:
+                logging_error(_("param_file combobox selected string '%s' not in list %s"), selected_element, values)
+        elif values:
+            logging_warning(_("No param_file combobox element selected"))
+        if values:
+            update_combobox_width(self)
+        if tooltip:
+            show_tooltip(self, tooltip)

ardupilot_methodic_configurator/frontend_tkinter_base_window.py

@@ -0,0 +1,93 @@
+"""
+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 debug as logging_debug
+# from logging import info as logging_info
+from logging import error as logging_error
+from tkinter import ttk
+from typing import Optional, Union
+
+from PIL import Image, ImageTk
+
+from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
+
+
+class BaseWindow:
+    """
+    A base class for creating windows in the ArduPilot Methodic Configurator application.
+
+    This class provides a foundation for creating windows in the application, including setting up the
+    root window, applying a theme, and configuring the application icon. It also includes methods for
+    creating a progress window and centering a window on its parent.
+    """
+
+    def __init__(self, root_tk: Optional[tk.Tk] = None) -> None:
+        self.root: Union[tk.Toplevel, tk.Tk]
+        if root_tk:
+            self.root = tk.Toplevel(root_tk)
+        else:
+            self.root = tk.Tk()
+            # Set the application icon for the window and all child windows
+            # https://pythonassets.com/posts/window-icon-in-tk-tkinter/
+            self.root.iconphoto(True, tk.PhotoImage(file=LocalFilesystem.application_icon_filepath()))  # noqa: FBT003
+
+        # Set the theme to 'alt'
+        style = ttk.Style()
+        style.theme_use("alt")
+        style.configure("Bold.TLabel", font=("TkDefaultFont", 10, "bold"))
+
+        self.main_frame = ttk.Frame(self.root)
+        self.main_frame.pack(expand=True, fill=tk.BOTH)
+
+    @staticmethod
+    def center_window(window: Union[tk.Toplevel, tk.Tk], parent: Union[tk.Toplevel, tk.Tk]) -> None:
+        """
+        Center a window on its parent window.
+
+        Args:
+            window (tk.Toplevel|tk.Tk): The window to center.
+            parent (tk.Toplevel|tk.Tk): The parent window.
+
+        """
+        window.update_idletasks()
+        parent_width = parent.winfo_width()
+        parent_height = parent.winfo_height()
+        window_width = window.winfo_width()
+        window_height = window.winfo_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}")
+
+    @staticmethod
+    def put_image_in_label(parent: ttk.Frame, filepath: str, image_height: int = 40) -> ttk.Label:
+        # Load the image and scale it down to image_height pixels in height
+        image = Image.open(filepath)
+        width, height = image.size
+        aspect_ratio = width / height
+        new_width = int(image_height * aspect_ratio)
+        resized_image = image.resize((new_width, image_height))
+
+        # Convert the image to a format that can be used by Tkinter
+        try:
+            photo = ImageTk.PhotoImage(resized_image)
+
+            # Create a label with the resized image
+            image_label = ttk.Label(parent, image=photo)
+            # Keep a reference to the image to prevent it from being garbage collected
+            image_label.image = photo  # type: ignore[attr-defined]
+        except TypeError as e:
+            logging_error(_("Error loading %s image from file: %s"), filepath, e)
+            image_label = ttk.Label(parent)
+        return image_label

ardupilot_methodic_configurator/frontend_tkinter_component_editor.py

@@ -20,18 +20,18 @@ from logging import error as logging_error
 from logging import getLevelName as logging_getLevelName
 from math import log2
 from tkinter import ttk
-from typing import Any, Callable, Union
+from typing import Any, Callable, Optional, Union
 
 from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.backend_filesystem_vehicle_components import VehicleComponents
 from ardupilot_methodic_configurator.battery_cell_voltages import BatteryCell
 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_base import show_error_message
 from ardupilot_methodic_configurator.frontend_tkinter_component_editor_base import ComponentEditorWindowBase
 
+# from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_error_message
+
 
 def argument_parser() -> Namespace:
     """
@@ -508,8 +508,8 @@ class ComponentEditorWindow(ComponentEditorWindowBase):
                 protocol_combobox.set(protocols[0] if protocols else "")
             protocol_combobox.update_idletasks()  # re-draw the combobox ASAP
 
-    def add_entry_or_combobox(
-        self, value: float, entry_frame: ttk.Frame, path: tuple[str, str, str]
+    def add_entry_or_combobox(  # pylint: disable=too-many-locals
+        self, value: float, entry_frame: ttk.Frame, path: tuple[str, str, str], is_optional: bool = False
     ) -> Union[ttk.Entry, ttk.Combobox]:
         # Default values for comboboxes in case the apm.pdef.xml metadata is not available
         fallbacks: dict[str, tuple[str, ...]] = {
@@ -555,11 +555,43 @@ class ComponentEditorWindow(ComponentEditorWindowBase):
             ("Battery", "Specifications", "Chemistry"): BatteryCell.chemistries(),
         }
         combobox_values: Union[tuple[str, ...], None] = combobox_dict.get(path)
+
+        # Determine foreground color based on is_optional flag
+        fg_color = "gray" if is_optional else "black"
+
         if combobox_values:
-            cb = ttk.Combobox(entry_frame, values=combobox_values)
+            cb = ttk.Combobox(entry_frame, values=combobox_values, foreground=fg_color)
             cb.bind("<FocusOut>", lambda event, path=path: self.validate_combobox(event, path))  # type: ignore[misc]
             cb.bind("<KeyRelease>", lambda event, path=path: self.validate_combobox(event, path))  # type: ignore[misc]
 
+            # Prevent mouse wheel from changing value when dropdown is not open
+            def handle_mousewheel(_event: tk.Event, widget: tk.Widget = cb) -> Optional[str]:
+                # Check if dropdown is open by examining the combobox's state
+                if not hasattr(widget, "_dropdown_open") or not widget._dropdown_open:  # pylint: disable=protected-access,line-too-long # noqa: SLF001 # pyright: ignore[reportAttributeAccessIssue]
+                    return "break"  # Prevent default behavior
+                return None  # Allow default behavior when dropdown is open
+
+            # Set flag when dropdown opens or closes
+            def dropdown_opened(_event: tk.Event, widget: tk.Widget = cb) -> None:
+                widget._dropdown_open = True  # type: ignore[attr-defined] # pylint: disable=protected-access # noqa: SLF001
+
+            def dropdown_closed(_event: tk.Event, widget: tk.Widget = cb) -> None:
+                widget._dropdown_open = False  # type: ignore[attr-defined] # pylint: disable=protected-access # noqa: SLF001
+
+            # Initialize the flag
+            cb._dropdown_open = False  # type: ignore[attr-defined] # pylint: disable=protected-access # noqa: SLF001
+
+            # Bind to events for dropdown opening and closing
+            cb.bind("<<ComboboxDropdown>>", dropdown_opened)
+            cb.bind(
+                "<FocusOut>",
+                lambda e, p=path: (dropdown_closed(e), self.validate_combobox(e, p)),  # type: ignore[misc, func-returns-value]
+            )
+            # Bind mouse wheel events
+            cb.bind("<MouseWheel>", handle_mousewheel)  # Windows mouse wheel
+            cb.bind("<Button-4>", handle_mousewheel)  # Linux mouse wheel up
+            cb.bind("<Button-5>", handle_mousewheel)  # Linux mouse wheel down
+
             if path == ("ESC", "FC Connection", "Type"):  # immediate update of ESC Protocol upon ESC Type selection
                 cb.bind(
                     "<<ComboboxSelected>>",
@@ -569,7 +601,7 @@ class ComponentEditorWindow(ComponentEditorWindowBase):
             cb.set(value)
             return cb
 
-        entry = ttk.Entry(entry_frame)
+        entry = ttk.Entry(entry_frame, foreground=fg_color)
         validate_function = self.get_validate_function(entry, path)
         if validate_function:
             entry.bind("<FocusOut>", validate_function)
@@ -783,12 +815,26 @@ class ComponentEditorWindow(ComponentEditorWindowBase):
 
         return not (invalid_values or duplicated_connections)
 
+    def derive_initial_template_name(self, component_data: dict[str, Any]) -> str:
+        """Derive an initial template name from the component data."""
+        initial_template_name: str = ""
+        product_data = component_data.get("Product")
+        if product_data:
+            manufacturer = product_data.get("Manufacturer", "")
+            model = product_data.get("Model", "")
+            initial_template_name = manufacturer + " " + model
+        return initial_template_name
+
 
+# pylint: disable=duplicate-code
 if __name__ == "__main__":
     args = argument_parser()
 
     logging_basicConfig(level=logging_getLevelName(args.loglevel), format="%(asctime)s - %(levelname)s - %(message)s")
 
-    filesystem = LocalFilesystem(args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files)
+    filesystem = LocalFilesystem(
+        args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files, args.save_component_to_system_templates
+    )
     app = ComponentEditorWindow(__version__, filesystem)
     app.root.mainloop()
+# pylint: enable=duplicate-code

ardupilot_methodic_configurator/frontend_tkinter_component_editor_base.py

@@ -19,19 +19,17 @@ 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 Union
+from typing import Any, Union
 
 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.frontend_tkinter_base import (
-    BaseWindow,
-    RichText,
-    ScrollFrame,
-    UsagePopupWindow,
-    show_error_message,
-    show_tooltip,
-)
+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
+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
 
 
 def argument_parser() -> Namespace:
@@ -87,15 +85,17 @@ class ComponentEditorWindowBase(BaseWindow):
         intro_frame.pack(side=tk.TOP, fill="x", expand=False)
 
         style = ttk.Style()
-        style.configure("bigger.TLabel", font=("TkDefaultFont", 14))
+        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")
 
-        explanation_text = _("Please configure all vehicle component properties in this window.\n")
-        explanation_text += _("Scroll down and make sure you do not miss a property.\n")
-        explanation_text += _("Saving the result will write to the vehicle_components.json file.")
+        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(intro_frame, text=explanation_text, wraplength=800, justify=tk.LEFT)
         explanation_label.configure(style="bigger.TLabel")
         explanation_label.pack(side=tk.LEFT, padx=(10, 10), pady=(10, 0), anchor=tk.NW)
@@ -119,25 +119,41 @@ class ComponentEditorWindowBase(BaseWindow):
         self.save_button = ttk.Button(
             save_frame, text=_("Save data and start configuration"), command=self.validate_and_save_component_json
         )
-        show_tooltip(self.save_button, _("Save component data and start parameter value configuration and tuning."))
+        show_tooltip(
+            self.save_button,
+            _("Save component data to the vehicle_components.json file\nand start parameter value configuration and tuning."),
+        )
         self.save_button.pack(pady=7)
         if UsagePopupWindow.should_display("component_editor"):
             self.root.after(10, self.__display_component_editor_usage_instructions(self.root))  # type: ignore[arg-type]
 
+        def update_data_callback(comp_name: str, template_data: dict) -> None:
+            self.data["Components"][comp_name] = template_data
+
+        self.template_manager = ComponentTemplateManager(
+            self.root,
+            self.entry_widgets,
+            self.get_component_data_from_gui,
+            update_data_callback,
+            self.derive_initial_template_name,
+            local_filesystem.save_component_to_system_templates,
+        )
+
     @staticmethod
-    def __display_component_editor_usage_instructions(parent: tk.Toplevel) -> None:
+    def __display_component_editor_usage_instructions(parent: tk.Tk) -> None:
         usage_popup_window = BaseWindow(parent)
         style = ttk.Style()
 
         instructions_text = RichText(
             usage_popup_window.main_frame, wrap=tk.WORD, height=5, bd=0, background=style.lookup("TLabel", "background")
         )
-        instructions_text.insert(tk.END, _("1. Describe all vehicle component properties in the window below\n"))
-        instructions_text.insert(tk.END, _("2. Scroll all the way down and make sure to edit all properties\n"))
-        instructions_text.insert(tk.END, _("3. Do not be lazy, collect the required information and enter it\n"))
-        instructions_text.insert(tk.END, _("4. Press the "))
+        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"))
+        instructions_text.insert(tk.END, _("3. Optional fields are marked with gray text and can be left blank.\n"))
+        instructions_text.insert(tk.END, _("4. Scroll to the bottom of the window to ensure all properties are edited.\n"))
+        instructions_text.insert(tk.END, _("5. Press the "))
         instructions_text.insert(tk.END, _("Save data and start configuration"), "italic")
-        instructions_text.insert(tk.END, _(" only after all information is correct"))
+        instructions_text.insert(tk.END, _(" button only after verifying that all information is correct.\n"))
         instructions_text.config(state=tk.DISABLED)
 
         UsagePopupWindow.display(
@@ -167,41 +183,124 @@ class ComponentEditorWindowBase(BaseWindow):
         """Populates the ScrollFrame with widgets based on the JSON data."""
         if "Components" in self.data:
             for key, value in self.data["Components"].items():
-                self.__add_widget(self.scroll_frame.view_port, key, value, [])
+                self._add_widget(self.scroll_frame.view_port, key, value, [])
 
-    def __add_widget(self, parent: tk.Widget, key: str, value: dict, path: list) -> None:
+    def _add_widget(self, parent: tk.Widget, key: str, value: Union[dict, float], path: list) -> None:
         """
         Adds a widget to the parent widget with the given key and value.
 
         Args:
             parent (tkinter.Widget): The parent widget to which the LabelFrame/Entry will be added.
             key (str): The key for the LabelFrame/Entry.
-            value (dict): The value associated with the key.
+            value (dict|float): The value associated with the key.
             path (list): The path to the current key in the JSON data.
 
         """
         if isinstance(value, dict):  # JSON non-leaf elements, add LabelFrame widget
-            frame = ttk.LabelFrame(parent, text=_(key))
-            is_toplevel = parent == self.scroll_frame.view_port
-            pady = 5 if is_toplevel else 3
-            frame.pack(
-                fill=tk.X, side=tk.TOP if is_toplevel else tk.LEFT, pady=pady, padx=5, anchor=tk.NW if is_toplevel else tk.N
-            )
-            for sub_key, sub_value in value.items():
-                # recursively add child elements
-                self.__add_widget(frame, sub_key, sub_value, [*path, key])
+            self.__add_non_leaf_widget(parent, key, value, path)
         else:  # JSON leaf elements, add Entry widget
-            entry_frame = ttk.Frame(parent)
-            entry_frame.pack(side=tk.TOP, fill=tk.X, pady=(0, 5))
+            self.__add_leaf_widget(parent, key, value, path)
+
+    def __add_non_leaf_widget(self, parent: tk.Widget, key: str, value: dict, path: list) -> None:
+        is_toplevel = parent == self.scroll_frame.view_port
+        pady = 5 if is_toplevel else 3
+
+        current_path = (*path, key)
+        description, is_optional = self.local_filesystem.get_component_property_description(current_path)
+
+        if is_optional:
+            frame = ttk.LabelFrame(parent, text=_(key), style="Optional.TLabelframe")
+        else:
+            frame = ttk.LabelFrame(parent, text=_(key))
+
+        frame.pack(
+            fill=tk.X, side=tk.TOP if is_toplevel else tk.LEFT, pady=pady, padx=5, anchor=tk.NW if is_toplevel else tk.N
+        )
+
+        # Enhance tooltip for optional fields
+        if is_optional and description:
+            description += _("\nThis is optional and can be left blank")
+
+        # Add tooltip based on schema description
+        if description:
+            show_tooltip(frame, _(description), position_below=False)
+
+        if is_toplevel and key in self.data.get("Components", {}):
+            self._add_template_controls(frame, key)
+
+        for sub_key, sub_value in value.items():
+            # recursively add child elements
+            self._add_widget(frame, sub_key, sub_value, [*path, key])
+
+    def __add_leaf_widget(self, parent: tk.Widget, key: str, value: float, path: list) -> None:
+        entry_frame = ttk.Frame(parent)
+        entry_frame.pack(side=tk.TOP, fill=tk.X, pady=(0, 5))
 
-            label = ttk.Label(entry_frame, text=_(key))
-            label.pack(side=tk.LEFT)
+        description, is_optional = self.local_filesystem.get_component_property_description((*path, key))
 
-            entry = self.add_entry_or_combobox(value, entry_frame, (*path, key))
-            entry.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=(0, 5))
+        label = ttk.Label(entry_frame, text=_(key), foreground="gray" if is_optional else "black")
 
-            # Store the entry widget in the entry_widgets dictionary for later retrieval
-            self.entry_widgets[(*path, key)] = entry
+        label.pack(side=tk.LEFT)
+
+        entry = self.add_entry_or_combobox(value, entry_frame, (*path, key), is_optional)
+        entry.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=(0, 5))
+
+        # Store the entry widget in the entry_widgets dictionary for later retrieval
+        self.entry_widgets[(*path, key)] = entry
+
+        # Enhance tooltip for optional fields
+        if is_optional and description:
+            description += _("\nThis is optional and can be left blank")
+
+        # Add tooltip based on schema description
+        if description:
+            show_tooltip(label, _(description))
+            show_tooltip(entry, _(description))
+
+    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)
+
+    def derive_initial_template_name(self, component_data: dict[str, Any]) -> str:  # pylint: disable=unused-argument # noqa: ARG002
+        """
+        Derive an initial template name from the component data.
+
+        This is a basic implementation that can be overridden in derived classes
+        to provide more specific template naming logic.
+        """
+        return ""
+
+    def get_component_data_from_gui(self, component_name: str) -> dict[str, Any]:
+        """Save the current component configuration as a template."""
+        # Get fresh component data from the GUI elements instead of stored data
+        component_data: dict[str, Any] = {}
+
+        # Find all entry widgets belonging to this component and extract their values
+        for path, entry in self.entry_widgets.items():
+            if len(path) >= 1 and path[0] == component_name:
+                # Get the current value from the entry widget
+                value: Union[str, int, float] = entry.get()
+
+                # Try to convert to appropriate type (int, float, or string)
+                if path[-1] != "Version":
+                    try:
+                        value = int(value)
+                    except ValueError:
+                        try:
+                            value = float(value)
+                        except ValueError:
+                            value = str(value).strip()
+
+                # Create nested structure by navigating through the path
+                current_level = component_data
+                for key in path[1:-1]:  # Skip component_name and the last key
+                    if key not in current_level:
+                        current_level[key] = {}
+                    current_level = current_level[key]
+
+                # Set the value at the final level
+                current_level[path[-1]] = value
+        return component_data
 
     def validate_and_save_component_json(self) -> None:
         """Saves the edited JSON data back to the file."""
@@ -263,7 +362,11 @@ class ComponentEditorWindowBase(BaseWindow):
 
     # This function will be overwritten in child classes
     def add_entry_or_combobox(
-        self, value: float, entry_frame: ttk.Frame, _path: tuple[str, str, str]
+        self,
+        value: float,
+        entry_frame: ttk.Frame,
+        _path: tuple[str, str, str],
+        is_optional: bool = False,  # pylint: disable=unused-argument # noqa: ARG002
     ) -> Union[ttk.Entry, ttk.Combobox]:
         entry = ttk.Entry(entry_frame)
         entry.insert(0, str(value))
@@ -287,6 +390,8 @@ if __name__ == "__main__":
 
     logging_basicConfig(level=logging_getLevelName(args.loglevel), format="%(asctime)s - %(levelname)s - %(message)s")
 
-    filesystem = LocalFilesystem(args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files)
+    filesystem = LocalFilesystem(
+        args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files, args.save_component_to_system_templates
+    )
     app = ComponentEditorWindowBase(__version__, filesystem)
     app.root.mainloop()