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

ardupilot_methodic_configurator/frontend_tkinter_flightcontroller_info.py

@@ -17,7 +17,6 @@ from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.data_model_par_dict import ParDict
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
-from ardupilot_methodic_configurator.frontend_tkinter_progress_window import ProgressWindow
 
 
 class FlightControllerInfoPresenter:
@@ -66,7 +65,7 @@ class FlightControllerInfoWindow(BaseWindow):
     def __init__(self, flight_controller: FlightController) -> None:
         super().__init__()
         self.root.title(_("ArduPilot methodic configurator ") + __version__ + _(" - Flight Controller Info"))
-        self.root.geometry("500x350")  # Adjust the window size as needed
+        self.root.geometry("500x420")  # Adjust the window size as needed
 
         self.presenter = FlightControllerInfoPresenter(flight_controller)
 
@@ -81,7 +80,7 @@ class FlightControllerInfoWindow(BaseWindow):
         """Create the flight controller information display."""
         # Create a frame to hold all the labels and text fields
         self.info_frame = ttk.Frame(self.main_frame)
-        self.info_frame.pack(fill=tk.BOTH, padx=20, pady=20)
+        self.info_frame.pack(fill=tk.BOTH, padx=20, pady=(20, 10))
 
         # Dynamically create labels and text fields for each attribute
         info_data = self.presenter.get_info_data()
@@ -90,6 +89,18 @@ class FlightControllerInfoWindow(BaseWindow):
 
         self.info_frame.columnconfigure(1, weight=1)
 
+        # Create progress frame at the bottom
+        self.progress_frame = ttk.Frame(self.main_frame)
+        self.progress_frame.pack(fill=tk.X, padx=20, pady=(10, 20))
+
+        # Create progress bar
+        self.progress_bar = ttk.Progressbar(self.progress_frame, length=100, mode="determinate")
+        self.progress_bar.pack(side=tk.TOP, fill=tk.X, expand=False, pady=(0, 5))
+
+        # Create progress label
+        self.progress_label = ttk.Label(self.progress_frame, text=_("Ready to download parameters..."))
+        self.progress_label.pack(side=tk.TOP, fill=tk.X, expand=False)
+
     def _create_info_row(self, row_nr: int, description: str, attr_value: Union[str, dict[str, str]]) -> None:
         """Create a single row of information display."""
         label = ttk.Label(self.info_frame, text=f"{description}:")
@@ -103,21 +114,58 @@ class FlightControllerInfoWindow(BaseWindow):
         text_field.insert(tk.END, display_value)
         text_field.configure(state="readonly")
 
+    def update_progress_bar(self, current_value: int, max_value: int) -> None:
+        """
+        Update the progress bar and the progress message with the current progress.
+
+        Args:
+            current_value (int): The current progress value.
+            max_value (int): The maximum progress value.
+
+        """
+        try:
+            # Check if progress widgets still exist
+            if not hasattr(self, "progress_bar") or self.progress_bar is None:
+                return
+
+            # Bring the main window to front (similar to original progress_window.lift())
+            self.root.lift()
+        except tk.TclError as _e:
+            msg = _("Lifting window: {_e}")
+            logging.error(msg.format(**locals()))
+            return
+
+        self.progress_bar["value"] = current_value
+        self.progress_bar["maximum"] = max_value
+
+        # Update the progress message
+        progress_message = _("Downloaded {} of {} parameters").format(current_value, max_value)
+        self.progress_label.config(text=progress_message)
+
+        # Update the display
+        self.progress_bar.update()
+        self.root.update_idletasks()
+
+        # Hide progress bar when complete
+        if current_value == max_value:
+            self.progress_frame.pack_forget()
+
     def _download_flight_controller_parameters(self) -> None:
         """Download flight controller parameters with progress feedback."""
-        param_download_progress_window = ProgressWindow(
-            self.root, _("Downloading FC parameters"), _("Downloaded {} of {} parameters")
-        )
+        # Update progress label to show we're starting
+        self.progress_label.config(text=_("Starting parameter download..."))
+        self.root.update_idletasks()
 
         try:
-            self.presenter.download_parameters(param_download_progress_window.update_progress_bar)
+            self.presenter.download_parameters(self.update_progress_bar)
         except Exception as e:  # pylint: disable=broad-exception-caught
             # Log the error
             logging.error("Failed to download parameters: %s", e)
             # Show an error message to the user
             messagebox.showerror(_("Error"), f"{_('Failed to download parameters')}: {e}")
+            # Hide progress bar on error
+            self.progress_frame.pack_forget()
         finally:
-            param_download_progress_window.destroy()  # for the case that '--device test' and there is no real FC connected
             self.root.destroy()
 
     def get_param_default_values(self) -> ParDict:

ardupilot_methodic_configurator/frontend_tkinter_font.py

@@ -0,0 +1,162 @@
+"""
+Safe way to access TKinter font information.
+
+This module provides a robust interface for accessing font information in TKinter
+applications across different platforms. It handles the common issue where named
+fonts like 'TkDefaultFont' may not be available during application startup,
+especially on macOS systems.
+
+The module offers functions to safely retrieve font configurations, families,
+and sizes with appropriate platform-specific fallbacks. This ensures consistent
+text rendering across Windows, macOS, and Linux systems.
+
+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
+import tkinter.font as tkfont
+
+# from logging import debug as logging_debug
+# from logging import info as logging_info
+from platform import system as platform_system
+from typing import Optional, Union
+
+
+def safe_font_nametofont(font_name: str = "TkDefaultFont") -> Optional[tkfont.Font]:
+    """
+    Safely retrieve a named font object with error handling.
+
+    This function attempts to get a TKinter named font while gracefully handling
+    cases where the font is not available, which commonly occurs during application
+    initialization on macOS.
+
+    Args:
+        font_name: The name of the font to retrieve. Defaults to "TkDefaultFont".
+                   Common options include "TkDefaultFont", "TkTextFont",
+                   "TkFixedFont", etc.
+
+    Returns:
+        A tkfont.Font object if the named font exists and can be accessed,
+        None otherwise.
+
+    Example:
+        >>> font = safe_font_nametofont("TkDefaultFont")
+        >>> if font:
+        ...     family = font.actual()["family"]
+        ...     size = font.actual()["size"]
+
+    Note:
+        On macOS, named fonts may not be available immediately when the
+        application starts. This function returns None in such cases, allowing
+        the calling code to use fallback values instead of crashing.
+
+    """
+    try:
+        return tkfont.nametofont(font_name)
+    except tk.TclError:
+        # On macOS and some configurations, named fonts may not be available
+        # Return None to allow calling code to handle the fallback
+        return None
+
+
+def get_safe_font_config(font_name: str = "TkDefaultFont") -> dict[str, Union[str, int]]:
+    """
+    Get a complete font configuration with platform-appropriate fallbacks.
+
+    Retrieves font configuration (family and size) either from the system's
+    named font or from platform-specific defaults if the named font is unavailable.
+
+    Args:
+        font_name: Name of the font to retrieve. Defaults to "TkDefaultFont".
+
+    Returns:
+        Dictionary containing 'family' (str) and 'size' (int) keys with
+        appropriate values for the current platform.
+
+    Example:
+        >>> config = get_safe_font_config()
+        >>> print(f"Font: {config['family']}, Size: {config['size']}")
+        Font: Segoe UI, Size: 9  # On Windows
+
+    Note:
+        This function always returns a valid configuration dictionary.
+        Even if TKinter font queries fail, platform-specific defaults ensure
+        a fallback is always provided.
+
+    """
+    # Try to get TkDefaultFont first
+    font = safe_font_nametofont(font_name)
+    if font:
+        try:
+            config = font.configure()
+            if config and isinstance(config, dict):
+                # Extract only the family and size values, converting to proper types
+                family = str(config.get("family", ""))
+                size_val = config.get("size")
+                size = 0
+                if size_val is not None:
+                    try:
+                        size = int(size_val)
+                    except (ValueError, TypeError, OverflowError):
+                        size = 0
+                return {"family": family, "size": size}
+        except tk.TclError:
+            pass
+
+    # Platform-specific fallbacks
+    if platform_system() == "Windows":
+        return {"family": "Segoe UI", "size": 9}
+    if platform_system() == "Darwin":  # macOS
+        return {"family": "Helvetica", "size": 13}
+    # Linux and others
+    return {"family": "Helvetica", "size": -12}
+
+
+def get_safe_font_family(font_name: str = "TkDefaultFont") -> str:
+    """
+    Retrieve a safe font family name with platform-specific fallbacks.
+
+    Gets the font family either from the system's named font or from a
+    platform-appropriate default if the query fails.
+
+    Args:
+        font_name: Name of the font to retrieve. Defaults to "TkDefaultFont".
+
+    Returns:
+        Name of the font family as a string. Returns empty string if unable
+        to determine a valid font family.
+
+    Note:
+        This function guarantees a string return value. If all attempts to
+        retrieve a font family fail, it returns an empty string rather than None.
+
+    """
+    config = get_safe_font_config(font_name)
+    return str(config.get("family", ""))
+
+
+def get_safe_font_size(font_name: str = "TkDefaultFont") -> int:
+    """
+    Retrieve a safe font size with platform-specific fallbacks.
+
+    Gets the font size either from the system's named font or from a
+    platform-appropriate default if the query fails.
+
+    Args:
+        font_name: Name of the font to retrieve. Defaults to "TkDefaultFont".
+
+    Returns:
+        Font size as an integer. Returns 0 if unable to determine a valid size.
+
+    Note:
+        This function guarantees an integer return value. If the size cannot
+        be determined from the system font, it falls back to platform-specific
+        defaults, ensuring a valid integer is always returned.
+
+    """
+    config = get_safe_font_config(font_name)
+    return int(config.get("size", 0))