feat(component editor): Implement simple UI complexity combobox

Refresh UI on complexity change
Notes fields are special because they hang differently
Do not display MCU series in simple mode when it has a known value already

Author: amilcarlucas

ardupilot_methodic_configurator/backend_filesystem_program_settings.py

@@ -27,10 +27,11 @@
 
 from ardupilot_methodic_configurator import _
 
-SETTINGS_DEFAULTS: dict[str, Union[int, bool]] = {
+SETTINGS_DEFAULTS: dict[str, Union[int, bool, str]] = {
     "Format version": 1,
     "auto_open_doc_in_browser": True,
     "annotate_docs_into_param_files": False,
+    "gui_complexity": "simple",  # simple or normal
 }
 
 
@@ -247,14 +248,14 @@ def set_display_usage_popup(ptype: str, value: bool) -> None:
             ProgramSettings.__set_settings_from_dict(settings)
 
     @staticmethod
-    def get_setting(setting: str) -> Union[int, bool]:
+    def get_setting(setting: str) -> Union[int, bool, str]:
         if setting in SETTINGS_DEFAULTS:
             setting_default = SETTINGS_DEFAULTS[setting]
             return ProgramSettings.__get_settings_as_dict().get(setting, setting_default)  # type: ignore[no-any-return]
         return False
 
     @staticmethod
-    def set_setting(setting: str, value: Union[int, bool]) -> None:
+    def set_setting(setting: str, value: Union[int, bool, str]) -> None:
         if setting in SETTINGS_DEFAULTS:
             settings, _, _ = ProgramSettings.__get_settings_config()
             settings[setting] = value

ardupilot_methodic_configurator/backend_filesystem_vehicle_components.py

@@ -718,6 +718,58 @@ def _json_type_to_python_type(self, json_type: str) -> type:
 
         return type_mapping.get(json_type, str)  # Default to str if unknown type
 
+    def modify_schema_for_mcu_series(self, is_optional: bool) -> None:
+        """
+        Modify the schema to set x-is-optional property for MCU Series field based on its value.
+
+        Dynamically updates the schema to make the MCU Series field optional
+
+        Args:
+            is_optional: If it should be marked as optional
+
+        """
+        if not self.schema:
+            self.load_schema()
+
+        if not self.schema:  # Still None after loading
+            logging_error(_("Cannot modify schema: Schema could not be loaded"))
+            return
+
+        # Navigate to the MCU Series field in the schema
+        flight_controller_def = self.schema.get("definitions", {}).get("flightController", {})
+        flight_controller_properties = None
+
+        # Check in allOf construct
+        if "allOf" in flight_controller_def:
+            for item in flight_controller_def["allOf"]:
+                if "properties" in item and "Specifications" in item["properties"]:
+                    flight_controller_properties = item
+                    break
+
+        if not flight_controller_properties:
+            logging_error(_("Could not find Specifications in flight controller schema"))
+            return
+
+        specifications = flight_controller_properties["properties"]["Specifications"]
+
+        if "properties" in specifications and "MCU Series" in specifications["properties"]:
+            try:
+                mcu_series_field = specifications["properties"]["MCU Series"]
+
+                if is_optional:
+                    mcu_series_field["x-is-optional"] = True
+                else:
+                    # Remove x-is-optional if it exists
+                    mcu_series_field.pop("x-is-optional", None)
+
+                logging_debug(
+                    _("Modified schema: MCU Series x-is-optional=%s to value=%u"),
+                    mcu_series_field.get("x-is-optional", False),
+                    is_optional,
+                )
+            except Exception as err:  # pylint: disable=broad-exception-caught
+                logging_error(_("Error modifying schema for MCU Series: %s"), str(err))
+
 
 def main() -> None:
     """Main function for standalone execution."""

ardupilot_methodic_configurator/frontend_tkinter_component_editor.py

@@ -62,6 +62,10 @@ class ComponentEditorWindow(ComponentEditorWindowBase):
 
     def __init__(self, version: str, local_filesystem: LocalFilesystem) -> None:
         ComponentEditorWindowBase.__init__(self, version, local_filesystem)
+        # when only read from file and no FC is connected
+        mcu = self.data_model.get_component_value(("Flight Controller", "Specifications", "MCU Series"))
+        if mcu and isinstance(mcu, str):
+            self.set_mcu_series(mcu)
 
     def set_vehicle_type_and_version(self, vehicle_type: str, version: str) -> None:
         """Set the vehicle type and version in the data model."""
@@ -87,6 +91,8 @@ def set_mcu_series(self, mcu: str) -> None:
         # Update UI if widget exists
         if mcu:
             self.set_component_value_and_update_ui(("Flight Controller", "Specifications", "MCU Series"), mcu)
+            if mcu.upper() in ("STM32F4XX", "STM32F7XX", "STM32H7XX"):
+                self.local_filesystem.modify_schema_for_mcu_series(is_optional=True)
 
     def set_vehicle_configuration_template(self, configuration_template: str) -> None:
         """Set the configuration template name in the data."""

ardupilot_methodic_configurator/frontend_tkinter_component_editor_base.py

@@ -24,6 +24,7 @@
 
 from ardupilot_methodic_configurator import _, __version__
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
+from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
 from ardupilot_methodic_configurator.data_model_vehicle_components import ComponentDataModel
 from ardupilot_methodic_configurator.data_model_vehicle_components_base import (
@@ -108,6 +109,7 @@ def __init__(
         self.scroll_frame: ScrollFrame
         self.save_button: ttk.Button
         self.template_manager: ComponentTemplateManager
+        self.complexity_var = tk.StringVar()
 
         # Initialize UI if there's data to work with
         if self._check_data():
@@ -175,11 +177,55 @@ def _add_explanation_text(self, parent: ttk.Frame) -> None:
         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_frame = ttk.Frame(parent)
+        explanation_frame.pack(side=tk.TOP, fill=tk.X, padx=(10, 10), pady=(10, 0))
+
         explanation_label = ttk.Label(
-            parent, text=explanation_text, wraplength=WINDOW_WIDTH_PIX - VEICLE_IMAGE_WIDTH_PIX, justify=tk.LEFT
+            explanation_frame, text=explanation_text, wraplength=WINDOW_WIDTH_PIX - VEICLE_IMAGE_WIDTH_PIX, justify=tk.LEFT
         )
         explanation_label.configure(style="bigger.TLabel")
-        explanation_label.pack(side=tk.LEFT, padx=(10, 10), pady=(10, 0), anchor=tk.NW)
+        explanation_label.pack(side=tk.LEFT, anchor=tk.NW)
+
+        # Add UI complexity combobox
+        complexity_frame = ttk.Frame(explanation_frame)
+        complexity_frame.pack(side=tk.RIGHT, anchor=tk.NE, padx=(0, 10))
+
+        complexity_label = ttk.Label(complexity_frame, text=_("GUI Complexity:"))
+        complexity_label.pack(side=tk.LEFT, padx=(0, 5))
+
+        complexity_setting = ProgramSettings.get_setting("gui_complexity")
+        self.complexity_var.set(str(complexity_setting) if complexity_setting is not None else "simple")
+
+        complexity_combobox = ttk.Combobox(
+            complexity_frame, textvariable=self.complexity_var, values=["simple", "normal"], state="readonly", width=10
+        )
+        complexity_combobox.pack(side=tk.LEFT)
+        complexity_combobox.bind("<<ComboboxSelected>>", self._on_complexity_changed)
+
+        # Add tooltip
+        show_tooltip(
+            complexity_combobox,
+            _(
+                "Select the graphical user interface complexity level:\n"
+                "simple for beginners, only minimal mandatory fields no optional params displayed\n"
+                "normal for everybody else."
+            ),
+        )
+
+    def _on_complexity_changed(self, _event: Optional[tk.Event] = None) -> None:
+        """Handle complexity combobox change."""
+        # Save the complexity setting
+        ProgramSettings.set_setting("gui_complexity", self.complexity_var.get())
+
+        # Clear all widgets from the scroll frame
+        for widget in self.scroll_frame.view_port.winfo_children():
+            widget.destroy()
+
+        # Repopulate the frame with widgets according to the new complexity setting
+        self.populate_frames()
+
+        # Update the UI
+        self.scroll_frame.view_port.update_idletasks()
 
     def _add_vehicle_image(self, parent: ttk.Frame) -> None:
         """Add the vehicle image to the parent frame."""
@@ -293,6 +339,17 @@ def _add_widget(self, parent: tk.Widget, key: str, value: ComponentValue, path:
             path (list): The path to the current key in the JSON data.
 
         """
+        # Skip components that shouldn't be displayed in simple mode
+        if isinstance(value, dict) and not self._should_display_in_simple_mode(key, value, path):
+            return
+
+        # For leaf nodes in simple mode, check if they are optional
+        if not isinstance(value, dict) and self.complexity_var.get() == "simple":
+            current_path = (*path, key)
+            _, is_optional = self.local_filesystem.get_component_property_description(current_path)
+            if is_optional:
+                return
+
         if isinstance(value, dict):  # JSON non-leaf elements, add LabelFrame widget
             self._add_non_leaf_widget(parent, key, value, path)
         else:  # JSON leaf elements, add Entry widget
@@ -399,7 +456,8 @@ def _create_leaf_widget_ui(self, parent: tk.Widget, config: dict) -> None:
 
     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)
+        if self.complexity_var.get() != "simple":
+            self.template_manager.add_template_controls(parent_frame, component_name)
 
     def get_component_data_from_gui(self, component_name: str) -> ComponentData:
         """Extract component data from GUI elements."""
@@ -533,6 +591,66 @@ def create_for_testing(
 
             return instance
 
+    def _should_display_in_simple_mode(self, key: str, value: dict, path: list[str]) -> bool:  # pylint: disable=too-many-branches
+        """
+        Determine if a component should be displayed in simple mode.
+
+        In simple mode, only show components that have at least one non-optional parameter.
+
+        Args:
+            key (str): The component key
+            value (dict): The component value
+            path (list): The path to the component
+
+        Returns:
+            bool: True if the component should be displayed, False otherwise
+
+        """
+        # If not in simple mode, always display the component
+        if self.complexity_var.get() != "simple":
+            return True
+
+        has_non_optional = False
+
+        # Top-level components need special handling
+        if not path and key in self.data_model.get_all_components():
+            # Check if this component has any non-optional parameters
+            for sub_key, sub_value in value.items():
+                if isinstance(sub_value, dict):
+                    # For nested dictionaries, recursively check
+                    if self._should_display_in_simple_mode(sub_key, sub_value, [*path, key]):
+                        return True
+                else:
+                    # For leaf nodes, check if they are optional
+                    current_path = (*path, key, sub_key)
+                    _, is_optional = self.local_filesystem.get_component_property_description(current_path)
+                    if not is_optional:
+                        return True
+            return False
+
+        # For non-top-level components or leaf nodes
+        if isinstance(value, dict):
+            # Check if this component has any non-optional parameters
+            for sub_key, sub_value in value.items():
+                current_path = (*path, key, sub_key)
+                if isinstance(sub_value, dict):
+                    if self._should_display_in_simple_mode(sub_key, sub_value, [*path, key]):
+                        has_non_optional = True
+                        break
+                else:
+                    _, is_optional = self.local_filesystem.get_component_property_description(current_path)
+                    if not is_optional:
+                        has_non_optional = True
+                        break
+        else:
+            # Leaf node - check if it's optional
+            current_path = (*path, key)
+            _, is_optional = self.local_filesystem.get_component_property_description(current_path)
+            if not is_optional:
+                has_non_optional = True
+
+        return has_non_optional
+
 
 if __name__ == "__main__":
     args = argument_parser()

tests/test_backend_filesystem_program_settings.py

@@ -218,3 +218,40 @@ def test_set_setting(self) -> None:
             mock_set_settings.reset_mock()
             ProgramSettings.set_setting("nonexistent_setting", value=True)
             mock_set_settings.assert_not_called()
+
+    def test_get_setting_gui_complexity(self) -> None:
+        """Test getting the GUI complexity setting."""
+        with patch.object(ProgramSettings, "_ProgramSettings__get_settings_as_dict") as mock_get_settings:
+            # Test when setting exists
+            mock_get_settings.return_value = {
+                "Format version": 1,
+                "gui_complexity": "simple",
+            }
+            assert ProgramSettings.get_setting("gui_complexity") == "simple"
+
+            # Test default value when setting doesn't exist
+            mock_get_settings.return_value = {"Format version": 1}
+
+            # We need to mock the SETTINGS_DEFAULTS dictionary for this test
+            with patch(
+                "ardupilot_methodic_configurator.backend_filesystem_program_settings.SETTINGS_DEFAULTS",
+                {"Format version": 1, "gui_complexity": "normal"},
+            ):
+                assert ProgramSettings.get_setting("gui_complexity") == "normal"  # Default from SETTINGS_DEFAULTS
+
+    def test_set_setting_gui_complexity(self) -> None:
+        """Test setting the GUI complexity setting."""
+        with (
+            patch.object(ProgramSettings, "_ProgramSettings__get_settings_config") as mock_get_config,
+            patch.object(ProgramSettings, "_ProgramSettings__set_settings_from_dict") as mock_set_settings,
+        ):
+            mock_get_config.return_value = ({"Format version": 1, "gui_complexity": "normal"}, "pattern", "replacement")
+
+            # Test setting gui_complexity to simple
+            ProgramSettings.set_setting("gui_complexity", value="simple")
+            mock_set_settings.assert_called_with({"Format version": 1, "gui_complexity": "simple"})
+
+            # Test setting gui_complexity back to normal
+            mock_set_settings.reset_mock()
+            ProgramSettings.set_setting("gui_complexity", value="normal")
+            mock_set_settings.assert_called_with({"Format version": 1, "gui_complexity": "normal"})