ardupilot-methodic-configurator 2.6.1__py3-none-any.whl → 2.7.1__py3-none-any.whl

ardupilot_methodic_configurator/__init__.py

@@ -1,7 +1,7 @@
 """
 Python package initialization file. Loads translations and declares version information.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -12,4 +12,4 @@ from ardupilot_methodic_configurator.internationalization import load_translatio
 
 _ = load_translation()
 
-__version__ = "2.6.1"
+__version__ = "2.7.1"

ardupilot_methodic_configurator/__main__.py

@@ -11,7 +11,7 @@ Calls five sub-applications in sequence:
   4. Component and connection editor
   5. Parameter editor and uploader
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -19,6 +19,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
 """
 
 import argparse
+import os
 from logging import basicConfig as logging_basicConfig
 from logging import debug as logging_debug
 from logging import error as logging_error
@@ -32,6 +33,7 @@ import argcomplete
 
 from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
+from ardupilot_methodic_configurator.backend_filesystem_freedesktop import FreeDesktop
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.backend_internet import verify_and_open_url
@@ -135,10 +137,13 @@ def connect_to_fc_and_set_vehicle_type(args: argparse.Namespace) -> tuple[Flight
     flight_controller = FlightController(reboot_time=args.reboot_time, baudrate=args.baudrate)
 
     error_str = flight_controller.connect(args.device, log_errors=False)
+
     if error_str:
         if args.device and _("No serial ports found") not in error_str:
             logging_error(error_str)
         conn_sel_window = ConnectionSelectionWindow(flight_controller, error_str, default_baudrate=args.baudrate)
+        # Set up startup notification for the connection selection window
+        FreeDesktop.setup_startup_notification(conn_sel_window.root)  # type: ignore[arg-type]
         conn_sel_window.root.mainloop()
 
     vehicle_type = args.vehicle_type
@@ -209,6 +214,8 @@ def vehicle_directory_selection(state: ApplicationState) -> Union[VehicleProject
             )
         )
     vehicle_dir_window = VehicleProjectOpenerWindow(state.vehicle_project_manager)
+    # Set up startup notification for the vehicle directory selection window
+    FreeDesktop.setup_startup_notification(vehicle_dir_window.root)  # type: ignore[arg-type]
     vehicle_dir_window.root.mainloop()
 
     if state.vehicle_project_manager.reset_fc_parameters_to_their_defaults:
@@ -342,6 +349,9 @@ def component_editor(state: ApplicationState) -> None:
     elif should_open_firmware_documentation(state.flight_controller):
         open_firmware_documentation(state.flight_controller.info.firmware_type)
 
+        # Set up startup notification for the component editor window
+        FreeDesktop.setup_startup_notification(component_editor_window.root)  # type: ignore[arg-type]
+
     # Run the GUI
     component_editor_window.root.mainloop()
 
@@ -497,6 +507,9 @@ def main() -> None:
     """
     args = create_argument_parser().parse_args()
 
+    # Create desktop icon if needed (only on first run in venv)
+    FreeDesktop.create_desktop_icon_if_needed()
+
     state = ApplicationState(args)
 
     setup_logging(state)
@@ -517,6 +530,26 @@ def main() -> None:
     if not files:
         vehicle_directory_selection(state)
 
+    if (
+        state.flight_controller.fc_parameters
+        and state.flight_controller.info.flight_sw_version.startswith("4.6.")
+        and state.local_filesystem.doc_dict
+        and "FSTRATE_ENABLE" in state.local_filesystem.doc_dict
+    ):
+        show_error_message(
+            _("Incompatible parameter definition file detected"),
+            _(
+                "The parameter definition file 'apm.pdef.xml' is incompatible with ArduPilot 4.6.x firmware. "
+                "It appears to be from the master branch. The file will be deleted. "
+                "Please restart the ArduPilot Methodic Configurator."
+            ),
+        )
+        # delete apm.pdef.xml file as it is from master and not from 4.6.x
+        file_path = os.path.join(state.local_filesystem.vehicle_dir, "apm.pdef.xml")
+        if os.path.exists(file_path):
+            os.remove(file_path)
+        sys_exit(1)
+
     # Run component editor workflow
     component_editor(state)
 

ardupilot_methodic_configurator/annotate_params.py

@@ -1,4 +1,4 @@
-#!/usr/bin/python3
+#!/usr/bin/env python3
 # PYTHON_ARGCOMPLETE_OK
 
 """
@@ -133,7 +133,9 @@ def parse_arguments() -> argparse.Namespace:
     return args
 
 
-def get_xml_data(base_url: str, directory: str, filename: str, vehicle_type: str) -> ET.Element:  # pylint: disable=too-many-locals
+def get_xml_data(  # pylint: disable=too-many-locals, too-many-statements # noqa: PLR0915
+    base_url: str, directory: str, filename: str, vehicle_type: str, fallback_xml_url: Optional[str] = None
+) -> ET.Element:
     """
     Fetches XML data from a local file or a URL.
 
@@ -142,6 +144,7 @@ def get_xml_data(base_url: str, directory: str, filename: str, vehicle_type: str
         directory (str): The directory where the XML file is expected.
         filename (str): The name of the XML file.
         vehicle_type (str): The type of the vehicle.
+        fallback_xml_url (Optional[str]): Fallback URL if the main URL fails.
 
     Returns:
         ET.Element: The root element of the parsed XML data.
@@ -183,19 +186,32 @@ def get_xml_data(base_url: str, directory: str, filename: str, vehicle_type: str
             logging.warning("Unable to fetch XML data: %s", e)
             # Send a GET request to the URL to the fallback (DEV) URL
             try:
-                url = BASE_URL + vehicle_type + "/" + PARAM_DEFINITION_XML_FILE
-                logging.warning("Falling back to the DEV XML file: %s", url)
+                if fallback_xml_url is None:
+                    msg = "No fallback XML URL provided."
+                    raise ValueError(msg) from e
+                url = fallback_xml_url
+                logging.warning("Falling back to the latest stable release XML file: %s", url)
                 response = requests_get(url, timeout=5, proxies=proxies)
                 if response.status_code != 200:
-                    logging.critical("Remote URL: %s", url)
+                    logging.warning("Remote URL: %s", url)
                     msg = f"HTTP status code {response.status_code}"
                     raise requests_exceptions.RequestException(msg)
-            except requests_exceptions.RequestException as exp:
-                logging.critical("Unable to fetch XML data: %s", exp)
-                msg = "Unable to fetch online XML documentation."
-                msg += f"\nDownload it manually from {url} and"
-                msg += f"\nplace it in the {directory} directory"
-                raise SystemExit(msg) from exp
+            except (ValueError, requests_exceptions.RequestException) as ex:
+                logging.warning("Unable to fetch XML data: %s", ex)
+                try:
+                    url = BASE_URL + vehicle_type + "/" + PARAM_DEFINITION_XML_FILE
+                    logging.warning("Falling back to the DEV XML file: %s", url)
+                    response = requests_get(url, timeout=5, proxies=proxies)
+                    if response.status_code != 200:
+                        logging.critical("Remote URL: %s", url)
+                        msg = f"HTTP status code {response.status_code}"
+                        raise requests_exceptions.RequestException(msg)
+                except requests_exceptions.RequestException as exp:
+                    logging.critical("Unable to fetch XML data: %s", exp)
+                    msg = "Unable to fetch online XML documentation."
+                    msg += f"\nDownload it manually from {url} and"
+                    msg += f"\nplace it in the {directory} directory"
+                    raise SystemExit(msg) from exp
         # Get the text content of the response
         xml_data = response.text
         try:
@@ -599,10 +615,29 @@ def get_xml_url(vehicle_type: str, firmware_version: str) -> str:
     return xml_url
 
 
-def parse_parameter_metadata(
-    xml_url: str, xml_dir: str, xml_file: str, vehicle_type: str, max_line_length: int
+def get_fallback_xml_url(vehicle_type: str, firmware_version: str) -> str:
+    vehicle_parm_subdir = {
+        "ArduCopter": "Copter-",
+        "ArduPlane": "Plane-",
+        "Rover": "Rover-",
+        "ArduSub": "Sub-",
+    }
+    try:
+        vehicle_subdir = vehicle_parm_subdir[vehicle_type] + firmware_version[0:3]
+    except KeyError as e:
+        msg = f"Vehicle type '{vehicle_type}' is not supported."
+        raise ValueError(msg) from e
+
+    xml_url = "https://raw.githubusercontent.com/ArduPilot/ParameterRepository/refs/heads/main/"
+    xml_url += vehicle_subdir if firmware_version else vehicle_type
+    xml_url += "/" + PARAM_DEFINITION_XML_FILE
+    return xml_url
+
+
+def parse_parameter_metadata(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+    xml_url: str, xml_dir: str, xml_file: str, vehicle_type: str, max_line_length: int, fallback_xml_url: Optional[str] = None
 ) -> dict[str, Any]:
-    xml_root = get_xml_data(xml_url, xml_dir, xml_file, vehicle_type)
+    xml_root = get_xml_data(xml_url, xml_dir, xml_file, vehicle_type, fallback_xml_url)
     return create_doc_dict(xml_root, vehicle_type, max_line_length)
 
 

ardupilot_methodic_configurator/argparse_check_range.py

@@ -1,7 +1,7 @@
 """
 Check the range of an Argparse parameter.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+This file is part of ArduPilot Methodic Configurator. https://github.com/ArduPilot/MethodicConfigurator
 
 SPDX-FileCopyrightText: 2024 Dmitriy Kovalev
 

ardupilot_methodic_configurator/backend_filesystem.py

@@ -1,7 +1,7 @@
 """
 Filesystem operations.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -38,6 +38,7 @@ from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.annotate_params import (
     PARAM_DEFINITION_XML_FILE,
     format_columns,
+    get_fallback_xml_url,
     get_xml_dir,
     get_xml_url,
     load_default_param_file,
@@ -122,8 +123,11 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
 
         # Read ArduPilot parameter documentation
         xml_url = get_xml_url(vehicle_type, self.fw_version)
+        fallback_xml_url = get_fallback_xml_url(vehicle_type, self.fw_version)
         xml_dir = get_xml_dir(vehicle_dir)
-        self.doc_dict = parse_parameter_metadata(xml_url, xml_dir, PARAM_DEFINITION_XML_FILE, vehicle_type, TOOLTIP_MAX_LENGTH)
+        self.doc_dict = parse_parameter_metadata(
+            xml_url, xml_dir, PARAM_DEFINITION_XML_FILE, vehicle_type, TOOLTIP_MAX_LENGTH, fallback_xml_url
+        )
         self.param_default_dict = load_default_param_file(vehicle_dir)
 
         # Extend parameter documentation metadata if <parameter_file>.pdef.xml exists
@@ -575,7 +579,7 @@ class LocalFilesystem(VehicleComponents, ConfigurationSteps, ProgramSettings):
                 dest = os_path.join(new_vehicle_dir, item)
                 if blank_change_reason and item.endswith(".param"):
                     # Blank the change reason in the template files, strip the comments that start with #
-                    with open(source, encoding="utf-8") as file:
+                    with open(source, encoding="utf-8-sig") as file:
                         lines = file.readlines()
                     with open(dest, "w", encoding="utf-8") as file:
                         file.writelines(line.split("#")[0].strip() + "\n" for line in lines)

ardupilot_methodic_configurator/backend_filesystem_configuration_steps.py

@@ -1,7 +1,7 @@
 """
 Manages configuration steps at the filesystem level.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -10,14 +10,14 @@ SPDX-License-Identifier: GPL-3.0-or-later
 
 from json import JSONDecodeError
 from json import load as json_load
-
-# from sys import exit as sys_exit
-# from logging import debug as logging_debug
 from logging import error as logging_error
 from logging import info as logging_info
 from logging import warning as logging_warning
 from os import path as os_path
+from typing import TypedDict
 
+# from sys import exit as sys_exit
+# from logging import debug as logging_debug
 from jsonschema import validate as json_validate
 from jsonschema.exceptions import ValidationError
 
@@ -25,6 +25,26 @@ from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict
 
 
+class PhaseData(TypedDict, total=False):
+    """
+    Type definition for configuration phase data.
+
+    Attributes:
+        start: The starting file number for this phase
+        end: The ending file number for this phase (computed)
+        weight: The weight for UI layout proportions (computed)
+        description: Human-readable description of the phase
+        optional: Whether this phase is optional
+
+    """
+
+    start: int
+    end: int
+    weight: int
+    description: str
+    optional: bool
+
+
 class ConfigurationSteps:
     """
     A class to manage configuration steps for the ArduPilot methodic configurator.
@@ -41,7 +61,7 @@ class ConfigurationSteps:
     def __init__(self, _vehicle_dir: str, vehicle_type: str) -> None:
         self.configuration_steps_filename = "configuration_steps_" + vehicle_type + ".json"
         self.configuration_steps: dict[str, dict] = {}
-        self.configuration_phases: dict[str, dict] = {}
+        self.configuration_phases: dict[str, PhaseData] = {}
         self.forced_parameters: dict[str, ParDict] = {}
         self.derived_parameters: dict[str, ParDict] = {}
         self.log_loaded_file = False
@@ -56,7 +76,7 @@ class ConfigurationSteps:
         json_content = {}
         for i, directory in enumerate(search_directories):
             try:
-                with open(os_path.join(directory, self.configuration_steps_filename), encoding="utf-8") as file:
+                with open(os_path.join(directory, self.configuration_steps_filename), encoding="utf-8-sig") as file:
                     json_content = json_load(file)
                     file_found = True
                     if self.log_loaded_file:
@@ -246,3 +266,30 @@ class ConfigurationSteps:
             text = _("No documentation available for {selected_file} in the {self.configuration_steps_filename} file")
             text = documentation.get(tooltip_key, text.format(**locals()))
         return text
+
+    def get_sorted_phases_with_end_and_weight(self, total_files: int) -> dict[str, PhaseData]:
+        """
+        Get sorted phases with added 'end' and 'weight' information.
+
+        Returns phases sorted by start position, with each phase containing:
+        - 'end': The end file number (start of next phase or total_files)
+        - 'weight': Weight for UI layout (max(2, end - start))
+        """
+        active_phases = {k: v for k, v in self.configuration_phases.items() if "start" in v}
+
+        # Sort phases by start position
+        sorted_phases: dict[str, PhaseData] = dict(sorted(active_phases.items(), key=lambda x: x[1].get("start", 0)))
+
+        # Add the end information to each phase using the start of the next phase
+        phase_names = list(sorted_phases.keys())
+        for i, phase_name in enumerate(phase_names):
+            if i < len(phase_names) - 1:
+                next_phase_name = phase_names[i + 1]
+                sorted_phases[phase_name]["end"] = sorted_phases[next_phase_name].get("start", total_files)
+            else:
+                sorted_phases[phase_name]["end"] = total_files
+            phase_start = sorted_phases[phase_name].get("start", 0)
+            phase_end = sorted_phases[phase_name].get("end", total_files)
+            sorted_phases[phase_name]["weight"] = max(2, phase_end - phase_start)
+
+        return sorted_phases

ardupilot_methodic_configurator/backend_filesystem_freedesktop.py

@@ -0,0 +1,275 @@
+"""
+Handles FreeDesktop.org compliance and desktop integration features.
+
+This includes creating desktop entries for application launchers, managing startup
+notifications according to the FreeDesktop Startup Notification specification,
+and ensuring proper integration with Linux desktop environments.
+
+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 re
+import subprocess
+import tkinter as tk
+from logging import debug as logging_debug
+from logging import error as logging_error
+from os import chmod as os_chmod
+from os import environ as os_environ
+from os import makedirs as os_makedirs
+from os import name as os_name
+from os import path as os_path
+from shutil import which as shutil_which
+from sys import platform as sys_platform
+from typing import Optional, Union
+
+from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
+
+
+class FreeDesktop:
+    """
+    A class responsible for FreeDesktop.org compliance and desktop integration.
+
+    This includes creating desktop entries for application launchers, managing startup
+    notifications according to the FreeDesktop Startup Notification specification,
+    and ensuring proper integration with Linux desktop environments.
+    """
+
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def _is_linux_system() -> bool:
+        """Check if running on a Linux system."""
+        return os_name == "posix" and sys_platform.startswith("linux")
+
+    @staticmethod
+    def _get_desktop_file_path() -> str:
+        """Get the path where the desktop file should be created."""
+        return os_path.expanduser("~/.local/share/applications/ardupilot_methodic_configurator.desktop")
+
+    @staticmethod
+    def _desktop_icon_exists(desktop_file_path: str) -> bool:
+        """Check if the desktop icon already exists."""
+        return os_path.exists(desktop_file_path)
+
+    @staticmethod
+    def _get_virtual_env_path() -> Optional[str]:
+        """Get the virtual environment path from environment variables."""
+        return os_environ.get("VIRTUAL_ENV")
+
+    @staticmethod
+    def _create_desktop_entry_content(venv_path: str, icon_path: str) -> str:
+        """Create the desktop entry file content."""
+        # Try to use python executable directly for better compatibility
+        python_exe = os_path.join(venv_path, "bin", "python")
+        if os_path.exists(python_exe):
+            # Use python executable directly
+            exec_cmd = f"{python_exe} -m ardupilot_methodic_configurator"
+        else:
+            # Fallback to bash -c method
+            bash_path = shutil_which("bash") or "/bin/bash"
+            activate_cmd = f"source {venv_path}/bin/activate && ardupilot_methodic_configurator"
+            exec_cmd = f'{bash_path} -c "{activate_cmd}"'
+
+        return f"""[Desktop Entry]
+Version=1.0
+Name=ArduPilot Methodic Configurator
+Comment=A clear ArduPilot configuration sequence
+Exec={exec_cmd}
+Icon={icon_path}
+Terminal=true
+Type=Application
+Categories=Development;
+Keywords=ardupilot;arducopter;drone;parameters;configuration;scm
+StartupWMClass=ArduPilotMethodicConfigurator
+StartupNotify=true
+"""
+
+    @staticmethod
+    def _ensure_applications_dir_exists(desktop_file_path: str) -> str:
+        """Ensure the applications directory exists and return it."""
+        apps_dir = os_path.dirname(desktop_file_path)
+        os_makedirs(apps_dir, exist_ok=True)
+        return apps_dir
+
+    @staticmethod
+    def _write_desktop_file(desktop_file_path: str, content: str) -> None:
+        """Write the desktop file content to disk."""
+        with open(desktop_file_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+    @staticmethod
+    def _set_desktop_file_permissions(desktop_file_path: str) -> None:
+        """Set appropriate permissions on the desktop file."""
+        os_chmod(desktop_file_path, 0o644)
+
+    @staticmethod
+    def _update_desktop_database(apps_dir: str) -> None:
+        """Update the desktop database if the command is available."""
+        update_desktop_db_cmd = shutil_which("update-desktop-database")
+        if update_desktop_db_cmd:
+            subprocess.run([update_desktop_db_cmd, apps_dir], check=False, capture_output=True)  # noqa: S603
+
+    @staticmethod
+    def create_desktop_icon_if_needed() -> None:
+        """
+        Create a desktop icon for the application if running in a virtual environment and icon doesn't exist.
+
+        This function detects if we're running in a virtual environment and creates a desktop
+        entry that activates the venv and runs the application with the correct icon.
+        """
+        # Only create desktop icon on Linux systems
+        if not FreeDesktop._is_linux_system():
+            return
+
+        # Check if desktop icon already exists
+        desktop_file_path = FreeDesktop._get_desktop_file_path()
+        if FreeDesktop._desktop_icon_exists(desktop_file_path):
+            return
+
+        # Check if we're in a virtual environment
+        venv_path = FreeDesktop._get_virtual_env_path()
+        if not venv_path:
+            return
+
+        # Find the icon path
+        icon_path = ProgramSettings.application_icon_filepath()
+        if not icon_path:
+            return
+
+        # Create the desktop entry content
+        desktop_entry = FreeDesktop._create_desktop_entry_content(venv_path, icon_path)
+
+        # Ensure the applications directory exists
+        apps_dir = FreeDesktop._ensure_applications_dir_exists(desktop_file_path)
+
+        # Write the desktop file
+        try:
+            FreeDesktop._write_desktop_file(desktop_file_path, desktop_entry)
+            FreeDesktop._set_desktop_file_permissions(desktop_file_path)
+            FreeDesktop._update_desktop_database(apps_dir)
+
+        except (OSError, subprocess.SubprocessError):
+            logging_error("Failed to create application launch desktop icon")
+
+    @staticmethod
+    def _get_desktop_startup_id() -> Union[str, None]:
+        """
+        Get the DESKTOP_STARTUP_ID environment variable.
+
+        Returns:
+            The startup ID string if set, None otherwise.
+
+        """
+        return os_environ.get("DESKTOP_STARTUP_ID")
+
+    @staticmethod
+    def _send_startup_notification_complete(startup_id: str) -> None:
+        """
+        Send the startup notification "remove" message to indicate the application has started.
+
+        This implements the freedesktop.org startup notification protocol.
+
+        Args:
+            startup_id: The DESKTOP_STARTUP_ID that was passed to the application
+
+        """
+        if not startup_id:
+            return
+
+        # Validate startup_id to prevent shell injection (should only contain alphanumeric chars, hyphens, underscores)
+        if not re.match(r"^[a-zA-Z0-9_-]+$", startup_id):
+            logging_debug("Invalid startup_id format: %s", startup_id)
+            return
+
+        try:
+            # Find the full path to xdg-startup-notify for security
+            xdg_notify_path = shutil_which("xdg-startup-notify")
+            if xdg_notify_path:
+                # Try to use xdg-startup-notify if available (part of xdg-utils)
+                result = subprocess.run(  # noqa: S603
+                    [xdg_notify_path, "remove", startup_id], capture_output=True, timeout=1.0, check=False
+                )
+                if result.returncode == 0:
+                    logging_debug("Sent startup notification completion for ID: %s", startup_id)
+                else:
+                    logging_debug("xdg-startup-notify failed: %s", result.stderr.decode().strip())
+            else:
+                logging_debug("xdg-startup-notify not found in PATH")
+        except (subprocess.TimeoutExpired, subprocess.SubprocessError, FileNotFoundError):
+            # If xdg-startup-notify is not available or fails, try manual X11 approach
+            FreeDesktop._send_startup_notification_x11(startup_id)
+
+    @staticmethod
+    def _send_startup_notification_x11(startup_id: str) -> None:
+        """
+        Send startup notification completion using direct X11 ClientMessage.
+
+        Args:
+            startup_id: The DESKTOP_STARTUP_ID that was passed to the application
+
+        """
+        if not tk:
+            return
+
+        try:
+            # Create a temporary Tk instance to access X11 if we don't have one yet
+            temp_root = tk.Tk()
+            temp_root.withdraw()  # Hide the window
+
+            # Try to send the message using Tk's send command
+            # Format: "remove: ID=<startup_id>"
+            message = f"remove: ID={startup_id}"
+
+            # Use Tk's send command to broadcast to the root window
+            # This is a bit of a hack, but Tk doesn't expose X11 messaging directly
+            try:
+                temp_root.eval(f"send -async . {{event generate . <<StartupComplete>> -data {{{message}}}}}")
+
+                # Also try to use the X11 atoms if available
+                # _NET_STARTUP_INFO is the atom we need to send
+                temp_root.eval(f"send -async . {{wm command . _NET_STARTUP_INFO {{{message}}}}}")
+
+            except Exception:  # pylint: disable=broad-exception-caught
+                # If all else fails, just log that we tried
+                logging_debug("Could not send X11 startup notification message")
+
+            temp_root.destroy()
+
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logging_debug("Failed to send X11 startup notification: %s", e)
+
+    @staticmethod
+    def setup_startup_notification(main_window: tk.Tk) -> None:
+        """
+        Set up startup notification for the application.
+
+        Checks for DESKTOP_STARTUP_ID and sends the completion message when the window is ready.
+
+        Args:
+            main_window: The main Tkinter window
+
+        """
+        if not FreeDesktop._is_linux_system():
+            return
+        startup_id = FreeDesktop._get_desktop_startup_id() or ""
+        if startup_id:
+            logging_debug("Startup notification ID: %s", startup_id)
+
+            # Send the completion message after the window is mapped
+            def on_map(event: tk.Event) -> None:
+                if event and event.widget == main_window:
+                    FreeDesktop._send_startup_notification_complete(startup_id)
+                    # Remove the binding after first map
+                    main_window.unbind("<Map>", on_map_handler)
+
+            # Bind to the Map event to know when the window is first shown
+            on_map_handler = main_window.bind("<Map>", on_map)
+
+            # Also try to send immediately in case the window is already mapped
+            if main_window.winfo_viewable():
+                FreeDesktop._send_startup_notification_complete(startup_id)

ardupilot_methodic_configurator/backend_filesystem_json_with_schema.py

@@ -1,7 +1,7 @@
 """
 Manages JSON files at the filesystem level.
 
-This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+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>
 
@@ -46,7 +46,7 @@ class FilesystemJSONWithSchema:
         schema_path = os_path.join(os_path.dirname(__file__), self.schema_filename)
 
         try:
-            with open(schema_path, encoding="utf-8") as file:
+            with open(schema_path, encoding="utf-8-sig") as file:
                 loaded_schema: dict[Any, Any] = json_load(file)
 
                 # Validate the schema itself against the JSON Schema meta-schema
@@ -90,7 +90,7 @@ class FilesystemJSONWithSchema:
         data: dict[Any, Any] = {}
         filepath = os_path.join(data_dir, self.json_filename)
         try:
-            with open(filepath, encoding="utf-8") as file:
+            with open(filepath, encoding="utf-8-sig") as file:
                 data = json_load(file)
 
             # Validate the loaded data against the schema