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

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_table.py

@@ -15,7 +15,7 @@ import tkinter as tk
 from logging import critical as logging_critical
 from logging import debug as logging_debug
 from logging import info as logging_info
-from math import nan
+from math import isfinite, isnan, nan
 from platform import system as platform_system
 from sys import exit as sys_exit
 from tkinter import messagebox, ttk
@@ -37,6 +37,9 @@ from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
 NEW_VALUE_WIDGET_WIDTH = 9
 
 
+# pylint: disable=too-many-lines
+
+
 class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
     """
     A class to manage and display the parameter editor table within the GUI.
@@ -61,20 +64,40 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
         # These variables are used by the forced_parameters and derived_parameters in configuration_steps_*.json files
         self.variables = local_filesystem.get_eval_variables()
 
-    def repopulate(self, selected_file: str, fc_parameters: dict[str, float], show_only_differences: bool) -> None:
-        for widget in self.view_port.winfo_children():
-            widget.destroy()
-        self.current_file = selected_file
+    def _should_show_upload_column(self, gui_complexity: Union[str, None] = None) -> bool:
+        """
+        Determine if the upload column should be shown based on UI complexity.
+
+        Args:
+            gui_complexity: UI complexity level. If None, uses self.parameter_editor.gui_complexity
+
+        Returns:
+            True if upload column should be shown, False otherwise
+
+        """
+        if gui_complexity is None:
+            gui_complexity = self.parameter_editor.gui_complexity
+        return gui_complexity != "simple"
+
+    def _create_headers_and_tooltips(self, show_upload_column: bool) -> tuple[tuple[str, ...], tuple[str, ...]]:
+        """Create table headers and tooltips dynamically based on UI complexity."""
+        base_headers = [
+            _("-/+"),
+            _("Parameter"),
+            _("Current Value"),
+            _("New Value"),
+            _("Unit"),
+        ]
 
-        # Create labels for table headers
-        headers = (_("-/+"), _("Parameter"), _("Current Value"), _("New Value"), _("Unit"), _("Upload"), _("Change Reason"))
-        tooltips = (
+        base_tooltips = [
             _("Delete or add a parameter"),
             _("Parameter name must be ^[A-Z][A-Z_0-9]* and most 16 characters long"),
             _("Current value on the flight controller "),
             _("New value from the above selected intermediate parameter file"),
             _("Parameter Unit"),
-            _("When selected, upload the new value to the flight controller"),
+        ]
+
+        change_reason_tooltip = (
             _("Reason why respective parameter changed.")
             + "\n\n"
             + _("Documenting change reasons is crucial because it:")
@@ -85,9 +108,29 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             + "\n"
             + _(" * Enables validation or suggestions from team members or AI tools")
             + "\n"
-            + _(" * Preserves your reasoning for future reference or troubleshooting"),
+            + _(" * Preserves your reasoning for future reference or troubleshooting")
         )
 
+        if show_upload_column:
+            base_headers.append(_("Upload"))
+            base_tooltips.append(_("When selected, upload the new value to the flight controller"))
+
+        base_headers.append(_("Change Reason"))
+        base_tooltips.append(change_reason_tooltip)
+
+        return tuple(base_headers), tuple(base_tooltips)
+
+    def repopulate(self, selected_file: str, fc_parameters: dict[str, float], show_only_differences: bool) -> None:
+        for widget in self.view_port.winfo_children():
+            widget.destroy()
+        self.current_file = selected_file
+
+        # Check if upload column should be shown based on UI complexity
+        show_upload_column = self._should_show_upload_column()
+
+        # Create labels for table headers
+        headers, tooltips = self._create_headers_and_tooltips(show_upload_column)
+
         for i, header in enumerate(headers):
             label = ttk.Label(self.view_port, text=header)
             label.grid(row=0, column=i, sticky="ew")  # Use sticky="ew" to make the label stretch horizontally
@@ -121,7 +164,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
                     param_name in fc_parameters and not is_within_tolerance(fc_parameters[param_name], float(file_value.value))
                 )
             }
-            self.__update_table(different_params, fc_parameters)
+            self._update_table(different_params, fc_parameters, self.parameter_editor.gui_complexity)
             if not different_params:
                 info_msg = _("No different parameters found in {selected_file}. Skipping...").format(**locals())
                 logging_info(info_msg)
@@ -129,7 +172,11 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
                 self.parameter_editor.on_skip_click(force_focus_out_event=False)
                 return
         else:
-            self.__update_table(self.local_filesystem.file_parameters[selected_file], fc_parameters)
+            self._update_table(
+                self.local_filesystem.file_parameters[selected_file],
+                fc_parameters,
+                self.parameter_editor.gui_complexity,
+            )
         # Scroll to the top of the parameter table
         self.canvas.yview("moveto", 0)
 
@@ -177,8 +224,10 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
                     # will ask the user to save changes before switching to another file
                     self.at_least_one_param_edited = True
 
-    def __update_table(self, params: dict[str, Par], fc_parameters: dict[str, float]) -> None:
+    def _update_table(self, params: dict[str, Par], fc_parameters: dict[str, float], gui_complexity: str) -> None:  # pylint: disable=too-many-locals
         current_param_name: str = ""
+        show_upload_column = self._should_show_upload_column(gui_complexity)
+
         try:
             for i, (param_name, param) in enumerate(params.items(), 1):
                 current_param_name = param_name
@@ -188,27 +237,15 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
                     "doc_tooltip", _("No documentation available in apm.pdef.xml for this parameter")
                 )
 
-                column: list[tk.Widget] = []
-                column.append(self.__create_delete_button(param_name))
-                column.append(self.__create_parameter_name(param_name, param_metadata, doc_tooltip))
-                column.append(self.__create_flightcontroller_value(fc_parameters, param_name, param_default, doc_tooltip))
-                column.append(self.__create_new_value_entry(param_name, param, param_metadata, param_default, doc_tooltip))
-                column.append(self.__create_unit_label(param_metadata))
-                column.append(self.__create_upload_checkbutton(param_name, bool(fc_parameters)))
-                # 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: list[tk.Widget] = self._create_column_widgets(
+                    param_name, param, param_metadata, param_default, doc_tooltip, fc_parameters, show_upload_column
+                )
+
+                self._grid_column_widgets(column, i, show_upload_column)
 
             # 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)
+                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()))
@@ -220,24 +257,87 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             )
             sys_exit(1)
 
-        # Configure the table_frame to stretch columns
+        self._configure_table_columns(show_upload_column)
+
+    def _create_column_widgets(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        param_name: str,
+        param: Par,
+        param_metadata: dict[str, Any],
+        param_default: Union[None, Par],
+        doc_tooltip: str,
+        fc_parameters: dict[str, float],
+        show_upload_column: bool,
+    ) -> list[tk.Widget]:
+        """Create all column widgets for a parameter row."""
+        column: list[tk.Widget] = []
+        column.append(self._create_delete_button(param_name))
+        column.append(self._create_parameter_name(param_name, param_metadata, doc_tooltip))
+        column.append(self._create_flightcontroller_value(fc_parameters, param_name, param_default, doc_tooltip))
+        column.append(self._create_new_value_entry(param_name, param, param_metadata, param_default, doc_tooltip))
+        column.append(self._create_unit_label(param_metadata))
+
+        if show_upload_column:
+            column.append(self._create_upload_checkbutton(param_name, bool(fc_parameters)))
+
+        # workaround a mypy issue
+        column.append(self._create_change_reason_entry(param_name, param, column[3]))  # type: ignore[arg-type]
+
+        return column
+
+    def _grid_column_widgets(self, column: list[tk.Widget], row: int, show_upload_column: bool) -> None:
+        """Grid all column widgets for a parameter row."""
+        column[0].grid(row=row, column=0, sticky="w", padx=0)
+        column[1].grid(row=row, column=1, sticky="w", padx=0)
+        column[2].grid(row=row, column=2, sticky="e", padx=0)
+        column[3].grid(row=row, column=3, sticky="e", padx=0)
+        column[4].grid(row=row, column=4, sticky="e", padx=0)
+
+        if show_upload_column:
+            column[5].grid(row=row, column=5, sticky="e", padx=0)
+
+        change_reason_column = self._get_change_reason_column_index(show_upload_column)
+        column[change_reason_column].grid(row=row, column=change_reason_column, sticky="ew", padx=(0, 5))
+
+    def _get_change_reason_column_index(self, show_upload_column: bool) -> int:
+        """
+        Get the column index for the change reason entry.
+
+        Args:
+            show_upload_column: Whether the upload column is shown
+
+        Returns:
+            Column index for change reason entry
+
+        """
+        # Base columns: Delete, Parameter, Current Value, New Value, Unit
+        base_column_count = 5
+        if show_upload_column:
+            return base_column_count + 1  # Upload column + Change Reason
+        return base_column_count  # Change Reason directly after Unit
+
+    def _configure_table_columns(self, show_upload_column: bool) -> None:
+        """Configure table column weights and sizes."""
         self.view_port.columnconfigure(0, weight=0)  # Delete and Add buttons
         self.view_port.columnconfigure(1, weight=0, minsize=120)  # Parameter name
         self.view_port.columnconfigure(2, weight=0)  # Current Value
         self.view_port.columnconfigure(3, weight=0)  # New Value
         self.view_port.columnconfigure(4, weight=0)  # Units
-        self.view_port.columnconfigure(5, weight=0)  # Upload to FC
-        self.view_port.columnconfigure(6, weight=1)  # Change Reason
 
-    def __create_delete_button(self, param_name: str) -> ttk.Button:
+        if show_upload_column:
+            self.view_port.columnconfigure(5, weight=0)  # Upload to FC
+
+        self.view_port.columnconfigure(self._get_change_reason_column_index(show_upload_column), weight=1)  # Change Reason
+
+    def _create_delete_button(self, param_name: str) -> ttk.Button:
         delete_button = ttk.Button(
-            self.view_port, text=_("Del"), style="narrow.TButton", command=lambda: self.__on_parameter_delete(param_name)
+            self.view_port, text=_("Del"), style="narrow.TButton", command=lambda: self._on_parameter_delete(param_name)
         )
         tooltip_msg = _("Delete {param_name} from the {self.current_file} file")
         show_tooltip(delete_button, tooltip_msg.format(**locals()))
         return delete_button
 
-    def __create_parameter_name(self, param_name: str, param_metadata: dict[str, Any], doc_tooltip: str) -> ttk.Label:
+    def _create_parameter_name(self, param_name: str, param_metadata: dict[str, Any], doc_tooltip: str) -> ttk.Label:
         is_calibration = param_metadata.get("Calibration", False)
         is_readonly = param_metadata.get("ReadOnly", False)
         parameter_label = ttk.Label(
@@ -253,7 +353,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             show_tooltip(parameter_label, doc_tooltip)
         return parameter_label
 
-    def __create_flightcontroller_value(
+    def _create_flightcontroller_value(
         self, fc_parameters: dict[str, float], param_name: str, param_default: Union[None, Par], doc_tooltip: str
     ) -> ttk.Label:
         if param_name in fc_parameters:
@@ -266,11 +366,15 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
                 flightcontroller_value = ttk.Label(self.view_port, text=value_str)
         else:
             flightcontroller_value = ttk.Label(self.view_port, text=_("N/A"), background="orange")
-        if doc_tooltip:
-            show_tooltip(flightcontroller_value, doc_tooltip)
+
+        # Use numerically sorted tooltip for Current Value column if available
+        param_metadata = self.local_filesystem.doc_dict.get(param_name, {})
+        sorted_tooltip = param_metadata.get("doc_tooltip_sorted_numerically", doc_tooltip)
+        if sorted_tooltip:
+            show_tooltip(flightcontroller_value, sorted_tooltip)
         return flightcontroller_value
 
-    def __update_combobox_style_on_selection(
+    def _update_combobox_style_on_selection(
         self, combobox_widget: PairTupleCombobox, param_default: Union[None, Par], event: tk.Event
     ) -> None:
         try:
@@ -285,18 +389,23 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             logging_info(msg.format(**locals()))
 
     @staticmethod
-    def __update_new_value_entry_text(new_value_entry: ttk.Entry, value: float, param_default: Union[None, Par]) -> None:
+    def _update_new_value_entry_text(
+        new_value_entry: Union[ttk.Entry, tk.Entry], value: float, param_default: Union[None, Par]
+    ) -> None:
         if isinstance(new_value_entry, PairTupleCombobox):
             return
         new_value_entry.delete(0, tk.END)
         value_str = format(value, ".6f").rstrip("0").rstrip(".")
         new_value_entry.insert(0, value_str)
         if param_default is not None and is_within_tolerance(value, param_default.value):
-            new_value_entry.configure(style="default_v.TEntry")
-        else:
+            # Only ttk.Entry widgets support style configuration
+            if isinstance(new_value_entry, ttk.Entry):
+                new_value_entry.configure(style="default_v.TEntry")
+        # Only ttk.Entry widgets support style configuration
+        elif isinstance(new_value_entry, ttk.Entry):
             new_value_entry.configure(style="TEntry")
 
-    def __create_new_value_entry(  # pylint: disable=too-many-arguments, too-many-positional-arguments, too-many-locals
+    def _create_new_value_entry(  # pylint: disable=too-many-arguments,too-many-positional-arguments,too-many-locals,too-many-statements # noqa: PLR0915
         self,
         param_name: str,
         param: Par,
@@ -305,23 +414,16 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
         doc_tooltip: str,
     ) -> Union[PairTupleCombobox, ttk.Entry]:
         is_bitmask = param_metadata and "Bitmask" in param_metadata
-        present_as_forced = False
-        present_as_derived = False
-        if (
-            self.current_file in self.local_filesystem.forced_parameters
-            and param_name in self.local_filesystem.forced_parameters[self.current_file]
-        ):
-            present_as_forced = True
-            new_value = self.local_filesystem.forced_parameters[self.current_file][param_name].value
-            if (is_bitmask and param.value != new_value) or not is_within_tolerance(param.value, new_value):
-                param.value = new_value
-                self.at_least_one_param_edited = True
-        if (
-            self.current_file in self.local_filesystem.derived_parameters
-            and param_name in self.local_filesystem.derived_parameters[self.current_file]
-        ):
-            present_as_derived = True
-            new_value = self.local_filesystem.derived_parameters[self.current_file][param_name].value
+        is_forced_or_derived, param_type = self._is_forced_or_derived_parameter(param_name)
+        present_as_forced = param_type == "forced"
+        present_as_derived = param_type == "derived"
+
+        if is_forced_or_derived:
+            if param_type == "forced":
+                new_value = self.local_filesystem.forced_parameters[self.current_file][param_name].value
+            else:  # param_type == "derived"
+                new_value = self.local_filesystem.derived_parameters[self.current_file][param_name].value
+
             if (is_bitmask and param.value != new_value) or not is_within_tolerance(param.value, new_value):
                 param.value = new_value
                 self.at_least_one_param_edited = True
@@ -354,12 +456,12 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             new_value_entry.config(state="readonly", width=NEW_VALUE_WIDGET_WIDTH, font=(font_family, font_size))
             new_value_entry.bind(  # type: ignore[call-overload] # workaround a mypy issue
                 "<<ComboboxSelected>>",
-                lambda event: self.__update_combobox_style_on_selection(new_value_entry, param_default, event),
+                lambda event: self._update_combobox_style_on_selection(new_value_entry, param_default, event),
                 "+",
             )
         else:
             new_value_entry = ttk.Entry(self.view_port, width=NEW_VALUE_WIDGET_WIDTH + 1, justify=tk.RIGHT)
-            ParameterEditorTable.__update_new_value_entry_text(new_value_entry, param.value, param_default)
+            ParameterEditorTable._update_new_value_entry_text(new_value_entry, param.value, param_default)
             bitmask_dict = param_metadata.get("Bitmask") if param_metadata else None
         try:
             old_value = self.local_filesystem.file_parameters[self.current_file][param_name].value
@@ -393,12 +495,12 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
         elif bitmask_dict:
             new_value_entry.bind(
                 "<Double-Button>",
-                lambda event: self.__open_bitmask_selection_window(event, param_name, bitmask_dict, old_value),
+                lambda event: self._open_bitmask_selection_window(event, param_name, bitmask_dict, old_value),
             )
             # pylint: disable=line-too-long
             new_value_entry.bind(
                 "<FocusOut>",
-                lambda event, current_file=self.current_file, param_name=param_name: self.__on_parameter_value_change(  # type: ignore[misc]
+                lambda event, current_file=self.current_file, param_name=param_name: self._on_parameter_value_change(  # type: ignore[misc]
                     event, current_file, param_name
                 ),
             )
@@ -407,7 +509,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             # pylint: disable=line-too-long
             new_value_entry.bind(
                 "<FocusOut>",
-                lambda event, current_file=self.current_file, param_name=param_name: self.__on_parameter_value_change(  # type: ignore[misc]
+                lambda event, current_file=self.current_file, param_name=param_name: self._on_parameter_value_change(  # type: ignore[misc]
                     event, current_file, param_name
                 ),
             )
@@ -416,15 +518,18 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             show_tooltip(new_value_entry, doc_tooltip)
         return new_value_entry
 
-    def __open_bitmask_selection_window(self, event: tk.Event, param_name: str, bitmask_dict: dict, old_value: float) -> None:  # pylint: disable=too-many-locals
+    def _open_bitmask_selection_window(self, event: tk.Event, param_name: str, bitmask_dict: dict, old_value: float) -> None:  # pylint: disable=too-many-locals
         def on_close() -> None:
             checked_keys = [key for key, var in checkbox_vars.items() if var.get()]
             # Convert checked keys back to a decimal value
             new_decimal_value = sum(1 << key for key in checked_keys)
             # Update new_value_entry with the new decimal value
-            ParameterEditorTable.__update_new_value_entry_text(
-                event.widget, new_decimal_value, self.local_filesystem.param_default_dict.get(param_name, None)
-            )
+            # For bitmask windows, event.widget should always be ttk.Entry (not PairTupleCombobox)
+            # since bitmasks are only created for Entry widgets, not Comboboxes
+            if isinstance(event.widget, ttk.Entry):
+                ParameterEditorTable._update_new_value_entry_text(
+                    event.widget, new_decimal_value, self.local_filesystem.param_default_dict.get(param_name, None)
+                )
             self.at_least_one_param_edited = (old_value != new_decimal_value) or self.at_least_one_param_edited
             self.local_filesystem.file_parameters[self.current_file][param_name].value = new_decimal_value
             # Destroy the window
@@ -436,7 +541,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             # Re-bind the FocusIn event to new_value_entry
             event.widget.bind(
                 "<Double-Button>",
-                lambda event: self.__open_bitmask_selection_window(event, param_name, bitmask_dict, old_value),
+                lambda event: self._open_bitmask_selection_window(event, param_name, bitmask_dict, old_value),
             )
 
         def is_widget_visible(widget: Union[tk.Misc, None]) -> bool:
@@ -466,7 +571,19 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
         main_frame.pack(expand=True, fill=tk.BOTH)
 
         # Convert current_value to a set of checked keys
-        current_value = int(event.widget.get())
+        widget = event.widget
+        # Bitmask windows are only opened for ttk.Entry widgets, not PairTupleCombobox
+        # since comboboxes have predefined values and don't use bitmasks
+        if not isinstance(widget, ttk.Entry):
+            return
+
+        current_value_str = widget.get() or "0"
+
+        try:
+            current_value = int(current_value_str)
+        except ValueError:
+            current_value = 0
+
         checked_keys = {key for key, _value in bitmask_dict.items() if (current_value >> key) & 1}
 
         for i, (key, value) in enumerate(bitmask_dict.items()):
@@ -492,7 +609,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
 
         window.wait_window()  # Wait for the window to be closed
 
-    def __create_unit_label(self, param_metadata: dict[str, Union[float, str]]) -> ttk.Label:
+    def _create_unit_label(self, param_metadata: dict[str, Union[float, str]]) -> ttk.Label:
         unit_label = ttk.Label(self.view_port, text=param_metadata.get("unit", ""))
         unit_tooltip = str(
             param_metadata.get("unit_tooltip", _("No documentation available in apm.pdef.xml for this parameter"))
@@ -501,7 +618,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             show_tooltip(unit_label, unit_tooltip)
         return unit_label
 
-    def __create_upload_checkbutton(self, param_name: str, fc_connected: bool) -> ttk.Checkbutton:
+    def _create_upload_checkbutton(self, param_name: str, fc_connected: bool) -> ttk.Checkbutton:
         self.upload_checkbutton_var[param_name] = tk.BooleanVar(value=fc_connected)
         upload_checkbutton = ttk.Checkbutton(self.view_port, variable=self.upload_checkbutton_var[param_name])
         upload_checkbutton.configure(state="normal" if fc_connected else "disabled")
@@ -509,26 +626,24 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
         show_tooltip(upload_checkbutton, msg.format(**locals()))
         return upload_checkbutton
 
-    def __create_change_reason_entry(
+    def _create_change_reason_entry(
         self, param_name: str, param: Par, new_value_entry: Union[ttk.Entry, PairTupleCombobox]
     ) -> ttk.Entry:
-        present_as_forced = False
+        is_forced_or_derived, param_type = self._is_forced_or_derived_parameter(param_name)
+        present_as_forced = is_forced_or_derived
+
         if (
-            self.current_file in self.local_filesystem.forced_parameters
-            and param_name in self.local_filesystem.forced_parameters[self.current_file]
+            param_type == "forced"
+            and param.comment != self.local_filesystem.forced_parameters[self.current_file][param_name].comment
         ):
-            present_as_forced = True
-            if param.comment != self.local_filesystem.forced_parameters[self.current_file][param_name].comment:
-                param.comment = self.local_filesystem.forced_parameters[self.current_file][param_name].comment
-                self.at_least_one_param_edited = True
-        if (
-            self.current_file in self.local_filesystem.derived_parameters
-            and param_name in self.local_filesystem.derived_parameters[self.current_file]
+            param.comment = self.local_filesystem.forced_parameters[self.current_file][param_name].comment
+            self.at_least_one_param_edited = True
+        elif (
+            param_type == "derived"
+            and param.comment != self.local_filesystem.derived_parameters[self.current_file][param_name].comment
         ):
-            present_as_forced = True
-            if param.comment != self.local_filesystem.derived_parameters[self.current_file][param_name].comment:
-                param.comment = self.local_filesystem.derived_parameters[self.current_file][param_name].comment
-                self.at_least_one_param_edited = True
+            param.comment = self.local_filesystem.derived_parameters[self.current_file][param_name].comment
+            self.at_least_one_param_edited = True
 
         change_reason_entry = ttk.Entry(self.view_port, background="white")
         change_reason_entry.insert(0, "" if param.comment is None else param.comment)
@@ -538,7 +653,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             # pylint: disable=line-too-long
             change_reason_entry.bind(
                 "<FocusOut>",
-                lambda event, current_file=self.current_file, param_name=param_name: self.__on_parameter_change_reason_change(  # type: ignore[misc]
+                lambda event, current_file=self.current_file, param_name=param_name: self._on_parameter_change_reason_change(  # type: ignore[misc]
                     event, current_file, param_name
                 ),
             )
@@ -548,7 +663,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
         show_tooltip(change_reason_entry, msg.format(**locals()))
         return change_reason_entry
 
-    def __on_parameter_delete(self, param_name: str) -> None:
+    def _on_parameter_delete(self, param_name: str) -> None:
         msg = _("Are you sure you want to delete the {param_name} parameter?")
         if messagebox.askyesno(f"{self.current_file}", msg.format(**locals())):
             # Capture current vertical scroll position
@@ -562,7 +677,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             # Restore the scroll position
             self.canvas.yview_moveto(current_scroll_position)
 
-    def __on_parameter_add(self, fc_parameters: dict[str, float]) -> None:
+    def _on_parameter_add(self, fc_parameters: dict[str, float]) -> None:
         add_parameter_window = BaseWindow(self.root)
         add_parameter_window.root.title(_("Add Parameter to ") + self.current_file)
         add_parameter_window.root.geometry("450x300")
@@ -604,7 +719,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
 
         def custom_selection_handler(event: tk.Event) -> None:
             parameter_name_combobox.update_entry_from_listbox(event)
-            if self.__confirm_parameter_addition(parameter_name_combobox.get().upper(), fc_parameters):
+            if self._confirm_parameter_addition(parameter_name_combobox.get().upper(), fc_parameters):
                 add_parameter_window.root.destroy()
             else:
                 add_parameter_window.root.focus()
@@ -613,7 +728,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
         parameter_name_combobox.bind("<Return>", custom_selection_handler)
         parameter_name_combobox.bind("<<ComboboxSelected>>", custom_selection_handler)
 
-    def __confirm_parameter_addition(self, param_name: str, fc_parameters: dict[str, float]) -> bool:
+    def _confirm_parameter_addition(self, param_name: str, fc_parameters: dict[str, float]) -> bool:
         if not param_name:
             messagebox.showerror(_("Invalid parameter name."), _("Parameter name can not be empty."))
             return False
@@ -644,80 +759,224 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
             )
         return False
 
-    def __on_parameter_value_change(self, event: tk.Event, current_file: str, param_name: str) -> None:
+    def _on_parameter_value_change(self, event: tk.Event, current_file: str, param_name: str) -> None:
         # Get the new value from the Entry widget
-        new_value = event.widget.get_selected_key() if isinstance(event.widget, PairTupleCombobox) else event.widget.get()
+        widget = event.widget
+        if isinstance(widget, PairTupleCombobox):
+            new_value = widget.get_selected_key()
+        elif isinstance(widget, (ttk.Entry, tk.Entry)):  # it is a ttk.Entry. The tk.Entry check is just defensive programming
+            new_value = widget.get()
+        else:
+            return  # Unknown widget type
+
         try:
             old_value = self.local_filesystem.file_parameters[current_file][param_name].value
         except KeyError as e:
             logging_critical(_("Parameter %s not found in the %s file: %s"), param_name, current_file, e, exc_info=True)
             sys_exit(1)
-        valid: bool = True
-        changed: bool = False
-        p: float = nan
-        # Check if the input is a valid float
+
+        # Handle None or empty values
+        if new_value is None:
+            new_value = ""
+
+        # Validate the new value format
+        is_valid, p = self._validate_parameter_value_format(str(new_value), param_name)
+        if not is_valid:
+            # Revert to the previous (valid) value
+            p = old_value
+
+        # Validate the parameter bounds
+        if not self._validate_parameter_bounds(p, param_name):
+            # Revert to the previous (valid) value
+            p = old_value
+
+        # Check if the value has changed
+        changed = self._check_parameter_value_changed(old_value, p)
+
+        # Update the parameter change state
+        self._update_parameter_change_state(changed=changed, param_name=param_name)
+
+        # Update the params dictionary with the new value
+        self.local_filesystem.file_parameters[current_file][param_name].value = p
+
+        # Update the displayed value in the Entry or Combobox
+        if isinstance(
+            event.widget, (ttk.Entry, tk.Entry)
+        ):  # it is a ttk.Entry. The tk.Entry check is just defensive programming
+            self._update_new_value_entry_text(event.widget, p, self.local_filesystem.param_default_dict.get(param_name, None))
+        elif isinstance(event.widget, PairTupleCombobox):
+            # For PairTupleCombobox, update the style based on whether it matches default value
+            param_default = self.local_filesystem.param_default_dict.get(param_name, None)
+            self._update_combobox_style_on_selection(event.widget, param_default, event)
+
+        # Update the tooltip for the change reason entry
+        self._update_change_reason_entry_tooltip(param_name, p)
+
+    def _validate_parameter_value_format(self, value_str: str, param_name: str) -> tuple[bool, float]:
+        """
+        Validate that the parameter value is a valid float.
+
+        Args:
+            value_str: String value to validate
+            param_name: Parameter name for error messages
+
+        Returns:
+            Tuple of (is_valid, parsed_value). If invalid, parsed_value is nan.
+
+        """
         try:
-            p = float(new_value)  # type: ignore[arg-type] # workaround a mypy bug
-            changed = not is_within_tolerance(old_value, p)
-            param_metadata = self.local_filesystem.doc_dict.get(param_name, {})
-            p_min = param_metadata.get("min", None)
-            p_max = param_metadata.get("max", None)
-            if changed:
-                if p_min and p < p_min:
-                    msg = _("The value for {param_name} {p} should be greater than {p_min}\n")
-                    if not messagebox.askyesno(
-                        _("Out-of-bounds Value"), msg.format(**locals()) + _("Use out-of-bounds value?"), icon="warning"
-                    ):
-                        valid = False
-                if p_max and p > p_max:
-                    msg = _("The value for {param_name} {p} should be smaller than {p_max}\n")
-                    if not messagebox.askyesno(
-                        _("Out-of-bounds Value"), msg.format(**locals()) + _("Use out-of-bounds value?"), icon="warning"
-                    ):
-                        valid = False
+            parsed_value = float(value_str)
+            # Reject infinity and NaN values
+            if not isfinite(parsed_value) or isnan(parsed_value):
+                error_msg = _("The value for {param_name} must be a finite number.")
+                messagebox.showerror(_("Invalid Value"), error_msg.format(param_name=param_name))
+                return False, nan
+            return True, parsed_value
         except ValueError:
-            # Optionally, you can handle the invalid value here, for example, by showing an error message
             error_msg = _("The value for {param_name} must be a valid float.")
-            messagebox.showerror(_("Invalid Value"), error_msg.format(**locals()))
-            valid = False
-        if valid:
-            if changed and not self.at_least_one_param_edited:
-                logging_debug(_("Parameter %s changed, will later ask if change(s) should be saved to file."), param_name)
-            self.at_least_one_param_edited = changed or self.at_least_one_param_edited
-            # Update the params dictionary with the new value
-            self.local_filesystem.file_parameters[current_file][param_name].value = p
-        else:
-            # Revert to the previous (valid) value
-            p = old_value
-        self.__update_new_value_entry_text(event.widget, p, self.local_filesystem.param_default_dict.get(param_name, None))
-        self.__update_change_reason_entry_tooltip(param_name, p)
+            messagebox.showerror(_("Invalid Value"), error_msg.format(param_name=param_name))
+            return False, nan
 
-    def __update_change_reason_entry_tooltip(self, param_name: str, param_value: float) -> None:
-        """Update the tooltip on the change reason entry with the current parameter value."""
-        value_str = format(param_value, ".6f").rstrip("0").rstrip(".")
+    def _validate_parameter_bounds(self, value: float, param_name: str) -> bool:
+        """
+        Validate parameter value against min/max bounds.
+
+        Args:
+            value: Parameter value to validate
+            param_name: Parameter name for error messages
+
+        Returns:
+            True if value is valid or user accepts out-of-bounds value
+
+        """
+        p_min, p_max = self._get_parameter_validation_bounds(param_name)
+
+        if p_min is not None and value < p_min:
+            msg = _("The value for {param_name} {p} should be greater than {p_min}\n")
+            if not messagebox.askyesno(
+                _("Out-of-bounds Value"),
+                msg.format(param_name=param_name, p=value, p_min=p_min) + _("Use out-of-bounds value?"),
+                icon="warning",
+            ):
+                return False
+
+        if p_max is not None and value > p_max:
+            msg = _("The value for {param_name} {p} should be smaller than {p_max}\n")
+            if not messagebox.askyesno(
+                _("Out-of-bounds Value"),
+                msg.format(param_name=param_name, p=value, p_max=p_max) + _("Use out-of-bounds value?"),
+                icon="warning",
+            ):
+                return False
+
+        return True
+
+    def _get_parameter_validation_bounds(self, param_name: str) -> tuple[Union[float, None], Union[float, None]]:
+        """
+        Get the validation bounds for a parameter.
+
+        Args:
+            param_name: Name of the parameter to get bounds for
+
+        Returns:
+            Tuple of (min_value, max_value) or (None, None) if no bounds available
+
+        """
+        param_metadata = self.local_filesystem.doc_dict.get(param_name, {})
+        return param_metadata.get("min", None), param_metadata.get("max", None)
+
+    def _check_parameter_value_changed(self, old_value: float, new_value: float) -> bool:
+        """
+        Check if parameter value has changed within tolerance.
+
+        Args:
+            old_value: Original parameter value
+            new_value: New parameter value
+
+        Returns:
+            True if value has changed beyond tolerance
+
+        """
+        return not is_within_tolerance(old_value, new_value)
+
+    def _update_parameter_change_state(self, changed: bool, param_name: str) -> None:
+        """
+        Update the parameter change state and log if needed.
+
+        Args:
+            changed: Whether the parameter has changed
+            param_name: Name of the parameter that changed
+
+        """
+        if changed and not self.at_least_one_param_edited:
+            logging_debug(_("Parameter %s changed, will later ask if change(s) should be saved to file."), param_name)
+        self.at_least_one_param_edited = changed or self.at_least_one_param_edited
+
+    def _find_change_reason_widget_by_parameter(self, param_name: str) -> Union[ttk.Entry, None]:
+        """
+        Find the change reason entry widget for a specific parameter.
+
+        Args:
+            param_name: Name of the parameter to find change reason widget for
+
+        Returns:
+            The change reason entry widget, or None if not found
+
+        """
+        show_upload_column = self._should_show_upload_column()
+        change_reason_column = self._get_change_reason_column_index(show_upload_column)
 
         # Find the change reason entry widget for this parameter
         for widget in self.view_port.winfo_children():
-            if isinstance(widget, ttk.Entry) and widget.grid_info().get("column", 0) == 6:
+            try:
+                widget_column = widget.grid_info().get("column", 0)
+            except tk.TclError:
+                # Widget not properly gridded, skip it
+                continue
+
+            if isinstance(widget, ttk.Entry) and widget_column == change_reason_column:
                 # Get the parameter label in the same row
-                row = widget.grid_info().get("row")
+                try:
+                    row = widget.grid_info().get("row")
+                except tk.TclError:
+                    continue
+
                 for param_widget in self.view_port.winfo_children():
+                    try:
+                        param_column = param_widget.grid_info().get("column", 0)
+                        param_row = param_widget.grid_info().get("row")
+                    except tk.TclError:
+                        continue
+
                     if (
                         isinstance(param_widget, ttk.Label)
-                        and param_widget.grid_info().get("column", 0) == 1
-                        and param_widget.grid_info().get("row") == row
+                        and param_column == 1
+                        and param_row == row
                         and param_widget.cget("text").strip() == param_name
                     ):
-                        # Found the matching change reason entry, update its tooltip
-                        msg = _("Reason why {param_name} should change to {value_str}")
-                        show_tooltip(widget, msg.format(**locals()))
-                        return
+                        return widget
+        return None
 
-        logging_debug(_("Could not find change reason entry widget for parameter %s (%s)"), param_name, value_str)
+    def _update_change_reason_entry_tooltip(self, param_name: str, param_value: float) -> None:
+        """Update the tooltip on the change reason entry with the current parameter value."""
+        value_str = format(param_value, ".6f").rstrip("0").rstrip(".")
+
+        # Use the helper method to find the change reason widget
+        change_reason_widget = self._find_change_reason_widget_by_parameter(param_name)
+        if change_reason_widget:
+            msg = _("Reason why {param_name} should change to {value_str}")
+            show_tooltip(change_reason_widget, msg.format(param_name=param_name, value_str=value_str))
+        else:
+            logging_debug(_("Could not find change reason entry widget for parameter %s (%s)"), param_name, value_str)
 
-    def __on_parameter_change_reason_change(self, event: tk.Event, current_file: str, param_name: str) -> None:
+    def _on_parameter_change_reason_change(self, event: tk.Event, current_file: str, param_name: str) -> None:
         # Get the new value from the Entry widget
-        new_value = event.widget.get()
+        widget = event.widget
+        if not isinstance(
+            widget, (ttk.Entry, tk.Entry)
+        ):  # it is a ttk.Entry. The tk.Entry check is just defensive programming
+            return
+        new_value = widget.get()
         try:
             changed = new_value != self.local_filesystem.file_parameters[current_file][param_name].comment and not (
                 new_value == "" and self.local_filesystem.file_parameters[current_file][param_name].comment is None
@@ -738,8 +997,13 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
         # Update the params dictionary with the new value
         self.local_filesystem.file_parameters[current_file][param_name].comment = new_value
 
-    def get_upload_selected_params(self, current_file: str) -> dict[str, Par]:
+    def get_upload_selected_params(self, current_file: str, gui_complexity: str) -> dict[str, Par]:
         selected_params = {}
+
+        if not self._should_show_upload_column(gui_complexity):
+            # all parameters are selected for upload in simple mode
+            return self.local_filesystem.file_parameters[current_file]
+
         for param_name, checkbutton_state in self.upload_checkbutton_var.items():
             if checkbutton_state.get():
                 selected_params[param_name] = self.local_filesystem.file_parameters[current_file][param_name]
@@ -756,3 +1020,28 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
 
     def set_at_least_one_param_edited(self, value: bool) -> None:
         self.at_least_one_param_edited = value
+
+    def _is_forced_or_derived_parameter(self, param_name: str) -> tuple[bool, str]:
+        """
+        Check if a parameter is forced or derived and return the appropriate type.
+
+        Args:
+            param_name: Name of the parameter to check
+
+        Returns:
+            Tuple of (is_forced_or_derived, parameter_type) where parameter_type is 'forced', 'derived', or ''
+
+        """
+        if (
+            self.current_file in self.local_filesystem.forced_parameters
+            and param_name in self.local_filesystem.forced_parameters[self.current_file]
+        ):
+            return True, "forced"
+
+        if (
+            self.current_file in self.local_filesystem.derived_parameters
+            and param_name in self.local_filesystem.derived_parameters[self.current_file]
+        ):
+            return True, "derived"
+
+        return False, ""