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

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_table.py

@@ -53,7 +53,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
 
     def __init__(self, master, local_filesystem: LocalFilesystem, parameter_editor) -> None:  # noqa: ANN001
         super().__init__(master)
-        self.root = master
+        self.main_frame = master
         self.local_filesystem = local_filesystem
         self.parameter_editor = parameter_editor  # the parent window that contains this table
         self.current_file = ""
@@ -295,7 +295,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
             if param.is_readonly
             else "yellow"
             if param.is_calibration
-            else ttk.Style(self.root).lookup("TFrame", "background"),
+            else ttk.Style(self.main_frame).lookup("TFrame", "background"),
         )
 
         tooltip_parameter_name = param.tooltip_new_value
@@ -586,9 +586,9 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
             # Destroy the window
             window.destroy()
             # Issue a FocusIn event on something else than new_value_entry to prevent endless looping
-            self.root.focus_set()
+            self.main_frame.focus_set()
             # Run the Tk event loop once to process the event
-            self.root.update_idletasks()
+            self.main_frame.update_idletasks()
             # Re-bind the FocusIn event to new_value_entry
             event.widget.bind(
                 "<Double-Button-1>",
@@ -613,7 +613,8 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
 
         # Temporarily unbind the FocusIn event to prevent triggering the window again
         event.widget.unbind("<Double-Button-1>")
-        window = tk.Toplevel(self.root)
+        window = tk.Toplevel(self.main_frame.master)
+        window.withdraw()  # Hide the window until it's fully set up
         title = _("Select {param.name} Bitmask Options")
         window.title(title.format(**locals()))
         checkbox_vars = {}
@@ -656,8 +657,11 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
 
         # Make sure the window is visible before disabling the parent window
         window.deiconify()
-        self.root.update_idletasks()
-        window.grab_set()
+
+        # Center the window on the parent window using the utility function
+        BaseWindow.center_window(window, self.main_frame.master)
+
+        window.grab_set()  # Make the window modal, disable the parent window
 
         window.wait_window()  # Wait for the window to be closed
 
@@ -743,7 +747,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
 
     def _on_parameter_add(self, fc_parameters: dict[str, float]) -> None:
         """Handle parameter addition."""
-        add_parameter_window = BaseWindow(self.root)
+        add_parameter_window = BaseWindow(self.main_frame.master)
         add_parameter_window.root.title(_("Add Parameter to ") + self.current_file)
         add_parameter_window.root.geometry("450x300")
 
@@ -779,7 +783,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
             width=28,
         )
         parameter_name_combobox.pack(padx=5, pady=5)
-        BaseWindow.center_window(add_parameter_window.root, self.root)
+        BaseWindow.center_window(add_parameter_window.root, self.main_frame.master)
         parameter_name_combobox.focus()
 
         def custom_selection_handler(event: tk.Event) -> None:

ardupilot_methodic_configurator/frontend_tkinter_progress_window.py

@@ -26,10 +26,22 @@ class ProgressWindow:
     a task. It includes a progress bar and a label to display the progress message.
     """
 
-    def __init__(self, master, title: str, message: str = "", width: int = 300, height: int = 80) -> None:  # noqa: ANN001, pylint: disable=too-many-arguments, too-many-positional-arguments
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        master,  # noqa: ANN001
+        title: str,
+        message: str = "",
+        width: int = 300,
+        height: int = 80,
+        only_show_when_update_progress_called: bool = False,
+    ) -> None:
         self.parent = master
         self.message = message
+        self.only_show_when_update_progress_called = only_show_when_update_progress_called
+        self._shown = False
         self.progress_window = tk.Toplevel(self.parent)
+        # Withdraw immediately to prevent flicker while setting up
+        self.progress_window.withdraw()
         self.progress_window.title(title)
         self.progress_window.geometry(f"{width}x{height}")
 
@@ -44,12 +56,20 @@ class ProgressWindow:
         self.progress_label = ttk.Label(main_frame, text=message.format(0, 0))
         self.progress_label.pack(side=tk.TOP, fill=tk.X, expand=False, pady=(10, 10))
 
-        self.progress_window.lift()
+        if not isinstance(master, tk.Tk):
+            logging_error("ProgressWindow: master is not a tk.Tk instance, window centering will fail")
 
-        # Center the progress window on the parent window
+        if not self.only_show_when_update_progress_called:
+            self.progress_window.deiconify()  # needs to be done before centering, but it does flicker :(
+
+        # Center the progress window on the parent window while still withdrawn
         BaseWindow.center_window(self.progress_window, self.parent)
 
-        self.progress_bar.update()
+        if not self.only_show_when_update_progress_called:
+            # Show the window now that it's properly positioned
+            self.progress_window.lift()
+            self._shown = True
+            self.progress_bar.update()
 
     def update_progress_bar_300_pct(self, percent: int) -> None:
         self.message = _("Please be patient, {:.1f}% of {}% complete")
@@ -65,25 +85,44 @@ class ProgressWindow:
 
         """
         try:
-            if hasattr(self, "progress_window") is False or self.progress_window is None:
+            # Double check that the window still exists before updating
+            if (
+                hasattr(self, "progress_window") is False
+                or self.progress_window is None
+                or not self.progress_window.winfo_exists()
+            ):
                 return
-            self.progress_window.lift()
+
+            if self.only_show_when_update_progress_called and not self._shown:
+                self.progress_window.deiconify()
+                # Re-center the window when it's first shown
+                BaseWindow.center_window(self.progress_window, self.parent)
+                self.progress_window.lift()
+                self._shown = True
+            elif not self.only_show_when_update_progress_called:
+                self.progress_window.lift()
+
+            # Additional safety checks before updating widgets
+            if (
+                hasattr(self, "progress_bar")
+                and self.progress_bar is not None
+                and hasattr(self, "progress_label")
+                and self.progress_label is not None
+            ):
+                self.progress_bar["value"] = current_value
+                self.progress_bar["maximum"] = max_value
+
+                # Update the progress message
+                self.progress_label.config(text=self.message.format(current_value, max_value))
+
+                self.progress_bar.update()
+
+                # Close the progress window when the process is complete
+                if current_value == max_value:
+                    self.progress_window.destroy()
         except tk.TclError as _e:
-            msg = _("Lifting window: {_e}")
+            msg = _("Updating progress widgets: {_e}")
             logging_error(msg.format(**locals()))
-            return
-
-        self.progress_bar["value"] = current_value
-        self.progress_bar["maximum"] = max_value
-
-        # Update the progress message
-        self.progress_label.config(text=self.message.format(current_value, max_value))
-
-        self.progress_bar.update()
-
-        # Close the progress window when the process is complete
-        if current_value == max_value:
-            self.progress_window.destroy()
 
     def destroy(self) -> None:
         self.progress_window.destroy()

ardupilot_methodic_configurator/frontend_tkinter_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()

ardupilot_methodic_configurator/frontend_tkinter_project_opener.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+
+"""
+GUI to select 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 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_opener import VehicleProjectOpenError
+from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
+from ardupilot_methodic_configurator.frontend_tkinter_directory_selection import (
+    DirectorySelectionWidgets,
+    VehicleDirectorySelectionWidgets,
+)
+from ardupilot_methodic_configurator.frontend_tkinter_project_creator import VehicleProjectCreatorWindow
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
+
+
+class VehicleProjectOpenerWindow(BaseWindow):
+    """
+    A window for selecting a vehicle directory with intermediate parameter files.
+
+    This class extends the BaseWindow class to provide a graphical user interface
+    for selecting a vehicle directory that contains intermediate parameter files
+    for ArduPilot. It allows the user to choose between creating a new vehicle
+    configuration directory based on an existing template or using an existing
+    vehicle configuration directory.
+    """
+
+    # pylint: disable=duplicate-code
+    def __init__(self, project_manager: VehicleProjectManager) -> None:
+        super().__init__()
+        self.project_manager = project_manager
+        self.root.title(
+            _("Amilcar Lucas's - ArduPilot methodic configurator ")
+            + __version__
+            + _(" - Select vehicle configuration directory")
+        )
+
+        self.root.geometry("600x450")  # Set the window size
+
+        # Explain why we are here
+        introduction_text = self.project_manager.get_introduction_message()
+        introduction_label = ttk.Label(
+            self.main_frame,
+            anchor=tk.CENTER,
+            justify=tk.CENTER,
+            text=introduction_text + _("\nChoose one of the following three options:"),
+        )
+        introduction_label.pack(expand=False, fill=tk.X, padx=6, pady=6)
+        _template_dir, _new_base_dir, vehicle_dir = self.project_manager.get_recently_used_dirs()
+        logging_debug("vehicle_dir: %s", vehicle_dir)  # this string is intentionally left untranslated
+        self.create_option1_widgets()
+        self.create_option2_widgets(vehicle_dir)
+        self.create_option3_widgets(vehicle_dir)
+
+        # 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(self) -> 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)
+
+        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"),
+        )
+
+    # pylint: enable=duplicate-code
+
+    def create_option2_widgets(self, initial_dir: str) -> None:
+        # Option 2 - Use an existing vehicle configuration directory
+        option2_label = ttk.Label(text=_("Open vehicle"), style="Bold.TLabel")
+        option2_label_frame = ttk.LabelFrame(self.main_frame, labelwidget=option2_label)
+        option2_label_frame.pack(expand=True, fill=tk.X, padx=6, pady=6)
+        option2_label = ttk.Label(
+            option2_label_frame,
+            anchor=tk.CENTER,
+            justify=tk.CENTER,
+            text=_(
+                "Use an existing vehicle configuration directory with\n"
+                "intermediate parameter files, apm.pdef.xml and vehicle_components.json"
+            ),
+        )
+        option2_label.pack(expand=False, fill=tk.X, padx=6)
+
+        def on_vehicle_directory_selected(directory: str) -> None:
+            self.project_manager.open_vehicle_directory(directory)
+
+        self.connection_selection_widgets = VehicleDirectorySelectionWidgets(
+            self,
+            option2_label_frame,
+            initial_dir,
+            destroy_parent_on_open=True,
+            on_select_directory_callback=on_vehicle_directory_selected,
+        )
+        self.connection_selection_widgets.container_frame.pack(expand=True, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
+
+    def create_option3_widgets(self, last_vehicle_dir: str) -> None:
+        # Option 3 - Open the last used vehicle configuration directory
+        option3_label = ttk.Label(text=_("Re-Open vehicle"), style="Bold.TLabel")
+        option3_label_frame = ttk.LabelFrame(self.main_frame, labelwidget=option3_label)
+        option3_label_frame.pack(expand=True, fill=tk.X, padx=6, pady=6)
+
+        last_dir = DirectorySelectionWidgets(
+            parent=self,
+            parent_frame=option3_label_frame,
+            initialdir=last_vehicle_dir or "",
+            label_text=_("Last used vehicle configuration directory:"),
+            autoresize_width=False,
+            dir_tooltip=_("Last used vehicle configuration directory"),
+            button_tooltip="",
+            on_directory_selected_callback=None,  # Use default file dialog behavior
+        )
+        last_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
+
+        # Check if there is a last used vehicle configuration directory
+        button_state = tk.NORMAL if self.project_manager.can_open_last_vehicle_directory(last_vehicle_dir) else tk.DISABLED
+        open_last_vehicle_directory_button = ttk.Button(
+            option3_label_frame,
+            text=_("Open Last Used Vehicle Configuration Directory"),
+            command=lambda last_vehicle_dir=last_vehicle_dir: self.open_last_vehicle_directory(  # type: ignore[misc]
+                last_vehicle_dir
+            ),
+            state=button_state,
+        )
+        open_last_vehicle_directory_button.pack(expand=False, fill=tk.X, padx=20, pady=5, anchor=tk.CENTER)
+        show_tooltip(
+            open_last_vehicle_directory_button,
+            _("Directly open the last used vehicle configuration directory for configuring and tuning the vehicle"),
+        )
+
+    def create_new_vehicle_from_template(self) -> None:
+        # close this window and open a VehicleProjectCreatorWindow instance
+        self.root.destroy()
+        VehicleProjectCreatorWindow(self.project_manager)
+
+    def open_last_vehicle_directory(self, last_vehicle_dir: str) -> None:
+        # Attempt to open the last opened vehicle configuration directory
+        try:
+            self.project_manager.open_last_vehicle_directory(last_vehicle_dir)
+            self.root.destroy()
+        except VehicleProjectOpenError as e:
+            messagebox.showerror(e.title, e.message)
+
+
+# pylint: disable=duplicate-code
+def argument_parser() -> Namespace:
+    """
+    Parses command-line arguments for the script.
+
+    This function sets up an argument parser to handle the command-line arguments for the script.
+
+    Returns:
+    argparse.Namespace: An object containing the parsed arguments.
+
+    """
+    parser = ArgumentParser(
+        description=_(
+            "This main is for testing and development only. "
+            "Usually, the VehicleProjectOpenerWindow 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 VehicleProjectOpenerWindow 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 files that will be processed sequentially
+    files = project_manager.get_file_parameters_list()
+
+    if not files:
+        logging_error(_("No intermediate parameter files found in %s."), args.vehicle_dir)
+
+    window = VehicleProjectOpenerWindow(project_manager)
+    window.root.mainloop()
+
+
+# pylint: enable=duplicate-code
+
+
+if __name__ == "__main__":
+    main()