feat(param editor): Only display derived parameters on normal GUI complexity

Author: amilcarlucas

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_table.py

@@ -129,6 +129,8 @@ def repopulate(self, selected_file: str, fc_parameters: dict[str, float], show_o
                 self.parameter_editor.on_skip_click(force_focus_out_event=False)
                 return
         else:
+            # Use all parameters - don't filter by complexity here so they're processed for upload and save
+            # The filtering for display will happen in __update_table
             self.__update_table(self.local_filesystem.file_parameters[selected_file], fc_parameters)
         # Scroll to the top of the parameter table
         self.canvas.yview("moveto", 0)
@@ -179,9 +181,30 @@ def rename_fc_connection(self, selected_file: str) -> None:
 
     def __update_table(self, params: dict[str, Par], fc_parameters: dict[str, float]) -> None:
         current_param_name: str = ""
+        displayed_row_count = 0
         try:
-            for i, (param_name, param) in enumerate(params.items(), 1):
+            for __, (param_name, param) in enumerate(params.items(), 1):
                 current_param_name = param_name
+
+                # Create upload checkbutton variable for all parameters (even if not displayed)
+                # so they can be uploaded to the flight controller
+                self.upload_checkbutton_var[param_name] = tk.BooleanVar(value=bool(fc_parameters))
+
+                # Check if parameter should be displayed based on GUI complexity
+                if self.parameter_editor.gui_complexity == "simple":
+                    # Do not display forced and derived parameters in simple mode
+                    if (
+                        self.current_file in self.local_filesystem.forced_parameters
+                        and param_name in self.local_filesystem.forced_parameters[self.current_file]
+                    ):
+                        continue
+                    if (
+                        self.current_file in self.local_filesystem.derived_parameters
+                        and param_name in self.local_filesystem.derived_parameters[self.current_file]
+                    ):
+                        continue
+
+                displayed_row_count += 1
                 param_metadata = self.local_filesystem.doc_dict.get(param_name, {})
                 param_default = self.local_filesystem.param_default_dict.get(param_name, None)
                 doc_tooltip = param_metadata.get(
@@ -198,21 +221,21 @@ def __update_table(self, params: dict[str, Par], fc_parameters: dict[str, float]
                 # workaround a mypy issue
                 column.append(self.__create_change_reason_entry(param_name, param, column[3]))  # type: ignore[arg-type]
 
-                column[0].grid(row=i, column=0, sticky="w", padx=0)
-                column[1].grid(row=i, column=1, sticky="w", padx=0)
-                column[2].grid(row=i, column=2, sticky="e", padx=0)
-                column[3].grid(row=i, column=3, sticky="e", padx=0)
-                column[4].grid(row=i, column=4, sticky="e", padx=0)
-                column[5].grid(row=i, column=5, sticky="e", padx=0)
-                column[6].grid(row=i, column=6, sticky="ew", padx=(0, 5))
+                column[0].grid(row=displayed_row_count, column=0, sticky="w", padx=0)
+                column[1].grid(row=displayed_row_count, column=1, sticky="w", padx=0)
+                column[2].grid(row=displayed_row_count, column=2, sticky="e", padx=0)
+                column[3].grid(row=displayed_row_count, column=3, sticky="e", padx=0)
+                column[4].grid(row=displayed_row_count, column=4, sticky="e", padx=0)
+                column[5].grid(row=displayed_row_count, column=5, sticky="e", padx=0)
+                column[6].grid(row=displayed_row_count, column=6, sticky="ew", padx=(0, 5))
 
             # Add the "Add" button at the bottom of the table
             add_button = ttk.Button(
                 self.view_port, text=_("Add"), style="narrow.TButton", command=lambda: self.__on_parameter_add(fc_parameters)
             )
             tooltip_msg = _("Add a parameter to the {self.current_file} file")
             show_tooltip(add_button, tooltip_msg.format(**locals()))
-            add_button.grid(row=len(params) + 2, column=0, sticky="w", padx=0)
+            add_button.grid(row=displayed_row_count + 2, column=0, sticky="w", padx=0)
 
         except KeyError as e:
             logging_critical(

tests/test_frontend_tkinter_parameter_editor_table.py

@@ -276,4 +276,82 @@ def test_repopulate_show_only_differences(parameter_editor_table: ParameterEdito
     # assert parameter_editor_table.add_parameter_row.call_count == 2
 
 
+def test_repopulate_filter_by_gui_complexity(
+    parameter_editor_table: ParameterEditorTable, mock_parameter_editor: MagicMock
+) -> None:
+    """Test that forced and derived parameters are calculated but filtered from display in simple mode."""
+    # Setup
+    test_file = "test_file.param"
+    parameter_editor_table.current_file = test_file
+    parameter_editor_table.parameter_editor = mock_parameter_editor
+    mock_parameter_editor.gui_complexity = "simple"  # Set to simple mode
+
+    # Create test parameters
+    parameter_editor_table.local_filesystem.file_parameters = {
+        test_file: {
+            "PARAM1": Par(1.0, "normal parameter"),
+            "PARAM2": Par(2.0, "forced parameter"),
+            "PARAM3": Par(3.0, "derived parameter"),
+        }
+    }
+
+    # Set up forced parameters
+    parameter_editor_table.local_filesystem.forced_parameters = {
+        test_file: {
+            "PARAM2": Par(2.0, "forced parameter"),
+        }
+    }
+
+    # Set up derived parameters
+    parameter_editor_table.local_filesystem.derived_parameters = {
+        test_file: {
+            "PARAM3": Par(3.0, "derived parameter"),
+        }
+    }
+
+    # Setup required metadata
+    parameter_editor_table.local_filesystem.doc_dict = {
+        "PARAM1": {"units": "none"},
+        "PARAM2": {"units": "none"},
+        "PARAM3": {"units": "none"},
+    }
+    parameter_editor_table.local_filesystem.param_default_dict = {
+        "PARAM1": Par(0.0, "default"),
+        "PARAM2": Par(0.0, "default"),
+        "PARAM3": Par(0.0, "default"),
+    }
+
+    fc_parameters = {
+        "PARAM1": 1.0,
+        "PARAM2": 2.0,
+        "PARAM3": 3.0,
+    }
+
+    # Patch the update_table method to check parameters passed to it
+    with patch.object(parameter_editor_table, "_ParameterEditorTable__update_table") as mock_update:
+        parameter_editor_table.repopulate(test_file, fc_parameters, show_only_differences=False)
+
+        # In simple mode, all parameters should be passed to update_table for processing
+        # but the filtering of display happens inside update_table
+        mock_update.assert_called_once()
+        params_dict = mock_update.call_args[0][0]
+        assert len(params_dict) == 3
+        assert "PARAM1" in params_dict
+        assert "PARAM2" in params_dict
+        assert "PARAM3" in params_dict
+
+    # Now test with normal complexity
+    mock_parameter_editor.gui_complexity = "normal"
+    with patch.object(parameter_editor_table, "_ParameterEditorTable__update_table") as mock_update:
+        parameter_editor_table.repopulate(test_file, fc_parameters, show_only_differences=False)
+
+        # In normal mode, all parameters should be passed to update_table
+        mock_update.assert_called_once()
+        params_dict = mock_update.call_args[0][0]
+        assert len(params_dict) == 3
+        assert "PARAM1" in params_dict
+        assert "PARAM2" in params_dict
+        assert "PARAM3" in params_dict
+
+
 # pylint: enable=redefined-outer-name