ardupilot-methodic-configurator 1.4.8__py3-none-any.whl → 2.0.0__py3-none-any.whl

ardupilot_methodic_configurator/frontend_tkinter_show.py

@@ -28,6 +28,16 @@ def show_error_message(title: str, message: str) -> None:
     root.destroy()
 
 
+def show_warning_message(title: str, message: str) -> None:
+    root = tk.Tk()
+    # Set the theme to 'alt'
+    style = ttk.Style()
+    style.theme_use("alt")
+    root.withdraw()  # Hide the main window
+    messagebox.showwarning(title, message)
+    root.destroy()
+
+
 def show_no_param_files_error(_dirname: str) -> None:
     error_message = _(
         "No intermediate parameter files found in the selected '{_dirname}' vehicle directory.\n"

ardupilot_methodic_configurator/frontend_tkinter_stage_progress.py

@@ -53,7 +53,9 @@ from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
 class StageProgressBar(ttk.LabelFrame):  # pylint: disable=too-many-ancestors
     """Stage-segmented Configuration sequence progress UI."""
 
-    def __init__(self, master: Union[tk.Widget, tk.Tk], phases: dict[str, dict], total_steps: int, **kwargs) -> None:
+    def __init__(
+        self, master: Union[tk.Widget, tk.Tk], phases: dict[str, dict], total_steps: int, gui_complexity: str, **kwargs
+    ) -> None:
         super().__init__(master, text=_("Configuration sequence progress"), **kwargs)
         self.phases = phases
         self.total_files = total_steps
@@ -63,7 +65,7 @@ class StageProgressBar(ttk.LabelFrame):  # pylint: disable=too-many-ancestors
         self.grid_columnconfigure(0, weight=1)
         self.grid_rowconfigure(0, weight=1)
 
-        self.create_phase_frames()
+        self.create_phase_frames(gui_complexity)
         self.bind("<Configure>", self._on_resize)
         show_tooltip(
             self,
@@ -74,7 +76,7 @@ class StageProgressBar(ttk.LabelFrame):  # pylint: disable=too-many-ancestors
             position_below=False,
         )
 
-    def create_phase_frames(self) -> None:
+    def create_phase_frames(self, gui_complexity: str) -> None:
         """Create frames for each phase with progress bars and labels."""
         # Get phases with start positions
         active_phases = {k: v for k, v in self.phases.items() if "start" in v}
@@ -82,19 +84,32 @@ class StageProgressBar(ttk.LabelFrame):  # pylint: disable=too-many-ancestors
         # Sort phases by start position
         sorted_phases = dict(sorted(active_phases.items(), key=lambda x: x[1]["start"]))
 
-        num_phases = len(sorted_phases)
+        # 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]["start"]
+            else:
+                sorted_phases[phase_name]["end"] = self.total_files
+            sorted_phases[phase_name]["weight"] = max(2, sorted_phases[phase_name]["end"] - sorted_phases[phase_name]["start"])
+
+        # Calculate non-optional phases
+        non_optional_sorted_phases = {name: data for name, data in sorted_phases.items() if not data.get("optional", False)}
+
+        phases_to_display = non_optional_sorted_phases if gui_complexity == "simple" else sorted_phases
 
         # Create container frame that will expand
         container = ttk.Frame(self)
         container.grid(row=0, column=0, sticky="nsew", padx=5, pady=5)
 
         # Configure container columns to expand equally
-        for i in range(num_phases):
-            container.grid_columnconfigure(i, weight=1, uniform="phase")
-
-        for i, (phase_name, phase_data) in enumerate(sorted_phases.items()):
+        for i, (phase_name, phase_data) in enumerate(phases_to_display.items()):
+            container.grid_columnconfigure(
+                i, weight=phase_data["weight"] if gui_complexity == "simple" else 1, uniform="phase"
+            )
             start = phase_data["start"]
-            end = list(sorted_phases.values())[i + 1]["start"] if i < num_phases - 1 else self.total_files
+            end = phase_data["end"]
             self.phase_frames[phase_name] = self._create_phase_frame(container, i, phase_name, phase_data, (start, end))
 
     def _create_phase_frame(  # pylint: disable=too-many-arguments, too-many-positional-arguments
@@ -229,7 +244,7 @@ def main() -> None:
     config_steps = ConfigurationSteps("", "ArduCopter")
     config_steps.re_init("", "ArduCopter")
 
-    progress = StageProgressBar(root, config_steps.configuration_phases, 54)
+    progress = StageProgressBar(root, config_steps.configuration_phases, 54, "normal")
     progress.pack(padx=10, pady=10, fill="both", expand=True)
 
     # Demo update function

ardupilot_methodic_configurator/frontend_tkinter_template_overview.py

@@ -17,7 +17,7 @@ from logging import getLevelName as logging_getLevelName
 from logging import info as logging_info
 from tkinter import font as tkfont
 from tkinter import ttk
-from typing import Optional
+from typing import Optional, Protocol
 
 from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
@@ -26,6 +26,30 @@ from ardupilot_methodic_configurator.common_arguments import add_common_argument
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.middleware_template_overview import TemplateOverview
 
+
+class VehicleComponentsProviderProtocol(Protocol):
+    """Minimal protocol for vehicle components provider - only methods used by TemplateOverviewWindow."""
+
+    @staticmethod
+    def get_vehicle_components_overviews() -> dict[str, TemplateOverview]:
+        """Get vehicle components overviews."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+    @staticmethod
+    def get_vehicle_image_filepath(relative_template_path: str) -> str:
+        """Get vehicle image filepath."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+
+class ProgramSettingsProviderProtocol(Protocol):  # pylint: disable=too-few-public-methods
+    """Minimal protocol for program settings provider - only methods used by TemplateOverviewWindow."""
+
+    @staticmethod
+    def store_template_dir(relative_template_dir: str) -> None:
+        """Store template directory."""
+        ...  # pylint: disable=unnecessary-ellipsis
+
+
 IMAGE_HEIGHT_PX = 100
 
 
@@ -39,40 +63,95 @@ class TemplateOverviewWindow(BaseWindow):
     manner, making it easier for users to navigate and select the desired template for configuration.
 
     Attributes:
-        window (tk.Tk|None): The root Tkinter window object for the GUI.
         sort_column (str): The column currently being used for sorting
         tree (ttk.Treeview): The treeview widget displaying templates
         image_label (ttk.Label): Label for displaying vehicle images
+        top_frame (ttk.Frame): Top frame containing instructions and image
+        vehicle_components_provider: Provider for vehicle components data
+        program_settings_provider: Provider for program settings operations
 
     """
 
-    def __init__(self, parent: Optional[tk.Tk] = None) -> None:
+    def __init__(
+        self,
+        parent: Optional[tk.Tk] = None,
+        vehicle_components_provider: Optional[VehicleComponentsProviderProtocol] = None,
+        program_settings_provider: Optional[ProgramSettingsProviderProtocol] = None,
+        connected_fc_vehicle_type: Optional[str] = None,
+    ) -> None:
         """
         Initialize the TemplateOverviewWindow.
 
         Args:
             parent: Optional parent Tk window
+            vehicle_components_provider: Optional provider for vehicle components (for dependency injection)
+            program_settings_provider: Optional provider for program settings (for dependency injection)
+            connected_fc_vehicle_type: Optional firmware type of connected flight controller for filtering templates
 
         """
         super().__init__(parent)
+
+        # Dependency injection for better testability
+        self.vehicle_components_provider: VehicleComponentsProviderProtocol = vehicle_components_provider or VehicleComponents
+        self.program_settings_provider: ProgramSettingsProviderProtocol = program_settings_provider or ProgramSettings
+
+        self.image_label: ttk.Label
+        # Initialize sorting state
+        self.sort_column: str = ""
+
+        # Initialize UI configuration
+        self._configure_window()
+        self._initialize_ui_components()
+        self._setup_layout()
+        self._configure_treeview(connected_fc_vehicle_type or "")
+        self._bind_events()
+
+    def _configure_window(self) -> None:
+        """Configure the main window properties."""
         title = _("Amilcar Lucas's - ArduPilot methodic configurator {} - Template Overview and selection")
         self.root.title(title.format(__version__))
-        self.root.geometry("1200x600")
 
-        self.top_frame = ttk.Frame(self.main_frame, height=IMAGE_HEIGHT_PX)
-        self.top_frame.pack(side=tk.TOP, fill="x", expand=False)
+        # Scale window geometry for HiDPI displays
+        scaled_width = int(1200 * self.dpi_scaling_factor)
+        scaled_height = int(600 * self.dpi_scaling_factor)
+        self.root.geometry(f"{scaled_width}x{scaled_height}")
+
+    def _initialize_ui_components(self) -> None:
+        """Initialize UI components with proper scaling."""
+        # Initialize frames
+        self.top_frame = ttk.Frame(self.main_frame, height=int(IMAGE_HEIGHT_PX * self.dpi_scaling_factor))
+
+        # Initialize instruction label
+        instruction_text = self._get_instruction_text()
+        scaled_font_size = self.calculate_scaled_font_size(12)
+        self.instruction_label = ttk.Label(self.top_frame, text=instruction_text, font=("Arial", scaled_font_size))
+
+        # Initialize image label
+        self.image_label = ttk.Label(self.top_frame)
+
+        # Initialize treeview
+        columns = TemplateOverview.columns()
+        self.tree = ttk.Treeview(self.main_frame, columns=columns, show="headings")
 
+    def _get_instruction_text(self) -> str:
+        """Get the instruction text for the user interface."""
         instruction_text = _("Please double-click the template below that most resembles your own vehicle components")
         instruction_text += _("\nit does not need to exactly match your vehicle's components.")
-        instruction_label = ttk.Label(self.top_frame, text=instruction_text, font=("Arial", 12))
-        instruction_label.pack(side=tk.LEFT, pady=(10, 20))
+        return instruction_text
 
-        self.image_label = ttk.Label(self.top_frame)
-        self.image_label.pack(side=tk.RIGHT, anchor=tk.NE, padx=(20, 20), pady=IMAGE_HEIGHT_PX / 2)
+    def _setup_layout(self) -> None:
+        """Setup the layout of UI components."""
+        # Pack top frame
+        self.top_frame.pack(side=tk.TOP, fill="x", expand=False)
 
-        self.sort_column: str = ""
-        self._setup_treeview()
-        self._bind_events()
+        # Pack instruction label
+        scaled_pady = self.calculate_scaled_padding_tuple(10, 20)
+        self.instruction_label.pack(side=tk.LEFT, pady=scaled_pady)
+
+        # Pack image label
+        scaled_padx = self.calculate_scaled_padding_tuple(20, 20)
+        scaled_pady_value = int(IMAGE_HEIGHT_PX * self.dpi_scaling_factor / 2)
+        self.image_label.pack(side=tk.RIGHT, anchor=tk.NE, padx=scaled_padx, pady=scaled_pady_value)
 
     def run_app(self) -> None:
         """Run the TemplateOverviewWindow application."""
@@ -86,8 +165,16 @@ class TemplateOverviewWindow(BaseWindow):
         elif isinstance(self.root, tk.Tk):
             self.root.mainloop()
 
-    def _setup_treeview(self) -> None:
-        """Set up the treeview with columns and styling."""
+    def _configure_treeview(self, connected_fc_vehicle_type: str) -> None:
+        """Configure the treeview with styling and data."""
+        self._setup_treeview_style()
+        self._setup_treeview_columns()
+        self._populate_treeview(connected_fc_vehicle_type)
+        self._adjust_treeview_column_widths()
+        self.tree.pack(fill=tk.BOTH, expand=True)
+
+    def _setup_treeview_style(self) -> None:
+        """Setup treeview styling with DPI scaling."""
         style = ttk.Style(self.root)
         # Add padding to Treeview heading style
         style.layout(
@@ -114,40 +201,55 @@ class TemplateOverviewWindow(BaseWindow):
                 ),
             ],
         )
-        style.configure("Treeview.Heading", padding=[2, 2, 2, 18], justify="center")
-
-        # Define the columns for the Treeview
-        columns = TemplateOverview.columns()
-        self.tree = ttk.Treeview(self.main_frame, columns=columns, show="headings")
-        for col in columns:
+        # Scale padding for HiDPI displays
+        scaled_padding = [
+            self.calculate_scaled_padding(2),
+            self.calculate_scaled_padding(2),
+            self.calculate_scaled_padding(2),
+            self.calculate_scaled_padding(18),
+        ]
+        style.configure("Treeview.Heading", padding=scaled_padding, justify="center")
+
+    def _setup_treeview_columns(self) -> None:
+        """Setup treeview column headers."""
+        for col in self.tree["columns"]:
             self.tree.heading(col, text=col)
 
-        self._populate_treeview()
-        self._adjust_treeview_column_widths()
-        self.tree.pack(fill=tk.BOTH, expand=True)
+    def _populate_treeview(self, connected_fc_vehicle_type: str) -> None:
+        """
+        Populate the treeview with data from vehicle components.
 
-    def _populate_treeview(self) -> None:
-        """Populate the treeview with data from vehicle components."""
-        for key, template_overview in VehicleComponents.get_vehicle_components_overviews().items():
+        Args:
+            connected_fc_vehicle_type: Optional firmware type to filter templates by
+
+        """
+        for key, template_overview in self.vehicle_components_provider.get_vehicle_components_overviews().items():
             attribute_names = template_overview.attributes()
             values = (key, *(getattr(template_overview, attr, "") for attr in attribute_names))
+            if connected_fc_vehicle_type and not key.startswith(connected_fc_vehicle_type):
+                continue
             self.tree.insert("", "end", text=key, values=values)
 
     def _adjust_treeview_column_widths(self) -> None:
         """Adjusts the column widths of the Treeview to fit the contents of each column."""
         for col in self.tree["columns"]:
             max_width = 0
+            # Create a font object that matches the Treeview's font and scale for HiDPI
+            tree_font = tkfont.Font()
             for subtitle in col.title().split("\n"):
-                max_width = max(max_width, tkfont.Font().measure(subtitle))
+                scaled_width = int(tree_font.measure(subtitle) * self.dpi_scaling_factor)
+                max_width = max(max_width, scaled_width)
 
             # Iterate over all rows and update the max_width if a wider entry is found
             for item in self.tree.get_children():
                 item_text = self.tree.item(item, "values")[self.tree["columns"].index(col)]
-                text_width = tkfont.Font().measure(item_text)
-                max_width = max(max_width, text_width)
+                scaled_text_width = int(tree_font.measure(item_text) * self.dpi_scaling_factor)
+                max_width = max(max_width, scaled_text_width)
 
             # Update the column's width property to accommodate the largest text width
-            self.tree.column(col, width=int(max_width * 0.6 + 10))
+            # Scale the padding and multiplication factor for HiDPI
+            scaled_padding = int(10 * self.dpi_scaling_factor)
+            self.tree.column(col, width=int(max_width * 0.6 + scaled_padding))
 
     def _bind_events(self) -> None:
         """Bind events to the treeview."""
@@ -187,7 +289,7 @@ class TemplateOverviewWindow(BaseWindow):
             template_path: The path to store
 
         """
-        ProgramSettings.store_template_dir(template_path)
+        self.program_settings_provider.store_template_dir(template_path)
 
     def _on_row_double_click(self, event: tk.Event) -> None:
         """Handle row double-click event."""
@@ -231,12 +333,15 @@ class TemplateOverviewWindow(BaseWindow):
             vehicle_image_filepath = self.get_vehicle_image_filepath(template_path)
             self.image_label = self.put_image_in_label(self.top_frame, vehicle_image_filepath, IMAGE_HEIGHT_PX)
         except FileNotFoundError:
+            scaled_padding = int(((IMAGE_HEIGHT_PX / 2) - 5.5) * self.dpi_scaling_factor)
             self.image_label = ttk.Label(
                 self.top_frame,
-                text=_("No 'vehicle.jpg' image file in the vehicle directory."),
-                padding=IMAGE_HEIGHT_PX / 2 - 8,
+                text=_("No 'vehicle.jpg' image file in the vehicle template directory."),
+                padding=scaled_padding,
             )
-        self.image_label.pack(side=tk.RIGHT, anchor=tk.NE, padx=(4, 0), pady=(0, 0))
+        # Scale padding for HiDPI displays
+        scaled_padx = (int(4 * self.dpi_scaling_factor), 0)
+        self.image_label.pack(side=tk.RIGHT, anchor=tk.NE, padx=scaled_padx, pady=(0, 0))
 
     def get_vehicle_image_filepath(self, template_path: str) -> str:
         """
@@ -254,7 +359,7 @@ class TemplateOverviewWindow(BaseWindow):
             FileNotFoundError: If the image file doesn't exist
 
         """
-        return VehicleComponents.get_vehicle_image_filepath(template_path)
+        return self.vehicle_components_provider.get_vehicle_image_filepath(template_path)
 
 
 def argument_parser() -> argparse.Namespace: