ardupilot-methodic-configurator 2.4.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -42,6 +42,7 @@ from ardupilot_methodic_configurator.frontend_tkinter_base_window import (
     show_warning_popup,
 )
 from ardupilot_methodic_configurator.frontend_tkinter_directory_selection import VehicleDirectorySelectionWidgets
+from ardupilot_methodic_configurator.frontend_tkinter_font import create_scaled_font, get_safe_font_config
 from ardupilot_methodic_configurator.frontend_tkinter_parameter_editor_documentation_frame import DocumentationFrame
 from ardupilot_methodic_configurator.frontend_tkinter_parameter_editor_table import ParameterEditorTable
 from ardupilot_methodic_configurator.frontend_tkinter_progress_window import ProgressWindow
@@ -55,7 +56,7 @@ def show_about_window(root: ttk.Frame, _version: str) -> None:  # pylint: disabl
     # Create a new window for the custom "About" message
     about_window = tk.Toplevel(root)
     about_window.title(_("About"))
-    about_window.geometry("650x320")
+    about_window.geometry("650x340")
 
     main_frame = ttk.Frame(about_window)
     main_frame.pack(expand=True, fill=tk.BOTH)
@@ -79,12 +80,23 @@ def show_about_window(root: ttk.Frame, _version: str) -> None:  # pylint: disabl
     component_editor_var = tk.BooleanVar(value=ProgramSettings.display_usage_popup("component_editor"))
     component_editor_checkbox = ttk.Checkbutton(
         usage_popup_frame,
-        text=_("Component editor window"),
+        text=_("Component editor window introduction"),
         variable=component_editor_var,
         command=lambda: ProgramSettings.set_display_usage_popup("component_editor", component_editor_var.get()),
     )
     component_editor_checkbox.pack(side=tk.TOP, anchor=tk.W)
 
+    component_editor_validation_var = tk.BooleanVar(value=ProgramSettings.display_usage_popup("component_editor_validation"))
+    component_editor_validation_checkbox = ttk.Checkbutton(
+        usage_popup_frame,
+        text=_("Component editor window data validation"),
+        variable=component_editor_validation_var,
+        command=lambda: ProgramSettings.set_display_usage_popup(
+            "component_editor_validation", component_editor_validation_var.get()
+        ),
+    )
+    component_editor_validation_checkbox.pack(side=tk.TOP, anchor=tk.W)
+
     parameter_editor_var = tk.BooleanVar(value=ProgramSettings.display_usage_popup("parameter_editor"))
     parameter_editor_checkbox = ttk.Checkbutton(
         usage_popup_frame,
@@ -313,8 +325,8 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         )
 
         # Create a Scrollable parameter editor table
-        self.parameter_editor_table = ParameterEditorTable(self.main_frame, self.local_filesystem, self)
-        self.repopulate_parameter_table(self.configuration_manager.current_file)
+        self.parameter_editor_table = ParameterEditorTable(self.main_frame, self.configuration_manager, self)
+        self.repopulate_parameter_table()
         self.parameter_editor_table.pack(side="top", fill="both", expand=True)
 
         # Create a frame for the buttons
@@ -429,9 +441,10 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         instructions_text = RichText(
             usage_popup_window.main_frame,
             wrap=tk.WORD,
-            height=10,
+            height=11,
             bd=0,
             background=style.lookup("TLabel", "background"),
+            font=create_scaled_font(get_safe_font_config(), 1.5),
         )
         instructions_text.insert(tk.END, _("1. Read "))
         instructions_text.insert(tk.END, _("all"), "bold")
@@ -466,7 +479,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             usage_popup_window,
             _("How to use the parameter file editor and uploader window"),
             "parameter_editor",
-            "690x300",
+            "690x360",
             instructions_text,
         )
 
@@ -655,7 +668,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             self.at_least_one_changed_parameter_written = False
             self.documentation_frame.refresh_documentation_labels(selected_file)
             self.documentation_frame.update_why_why_now_tooltip(selected_file)
-            self.repopulate_parameter_table(selected_file)
+            self.repopulate_parameter_table()
             self._update_skip_button_state()
 
     def _update_progress_bar_from_file(self, selected_file: str) -> None:
@@ -677,16 +690,14 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         if not redownload:
             self.on_param_file_combobox_change(None, forced=True)  # the initial param read will trigger a table update
 
-    def repopulate_parameter_table(self, selected_file: Union[None, str]) -> None:
-        if not selected_file:
+    def repopulate_parameter_table(self) -> None:
+        if not self.configuration_manager.current_file:
             return  # no file was yet selected, so skip it
         # Re-populate the table with the new parameters
-        self.parameter_editor_table.repopulate(
-            selected_file, self.configuration_manager.fc_parameters, self.show_only_differences.get(), self.gui_complexity
-        )
+        self.parameter_editor_table.repopulate(self.show_only_differences.get(), self.gui_complexity)
 
     def on_show_only_changed_checkbox_change(self) -> None:
-        self.repopulate_parameter_table(self.configuration_manager.current_file)
+        self.repopulate_parameter_table()
 
     def upload_params_that_require_reset(self, selected_params: dict) -> None:
         """
@@ -713,9 +724,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
 
     def on_upload_selected_click(self) -> None:
         self.write_changes_to_intermediate_parameter_file()
-        selected_params = self.parameter_editor_table.get_upload_selected_params(
-            self.configuration_manager.current_file, str(self.gui_complexity)
-        )
+        selected_params = self.parameter_editor_table.get_upload_selected_params(str(self.gui_complexity))
         if selected_params:
             if self.configuration_manager.fc_parameters:
                 self.upload_selected_params(selected_params)

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_table.py

@@ -19,15 +19,18 @@ from tkinter import messagebox, ttk
 from typing import Union
 
 from ardupilot_methodic_configurator import _
-from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
+from ardupilot_methodic_configurator.configuration_manager import (
+    ConfigurationManager,
+    InvalidParameterNameError,
+    OperationNotPossibleError,
+)
 from ardupilot_methodic_configurator.data_model_ardupilot_parameter import (
     ArduPilotParameter,
     BitmaskHelper,
     ParameterOutOfRangeError,
     ParameterUnchangedError,
 )
-from ardupilot_methodic_configurator.data_model_configuration_step import ConfigurationStepProcessor
-from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict
+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_entry_dynamic import EntryWithDynamicalyFilteredListbox
 from ardupilot_methodic_configurator.frontend_tkinter_pair_tuple_combobox import (
@@ -42,7 +45,7 @@ NEW_VALUE_WIDGET_WIDTH = 9
 NEW_VALUE_DIFFERENT_STR = "\u2260" if platform_system() == "Windows" else "!="
 
 
-class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors, too-many-instance-attributes
+class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
     """
     A class to manage and display the parameter editor table within the GUI.
 
@@ -51,26 +54,21 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
     It uses the ArduPilotParameter domain model to handle parameter operations.
     """
 
-    def __init__(self, master, local_filesystem: LocalFilesystem, parameter_editor) -> None:  # noqa: ANN001
+    def __init__(self, master, configuration_manager: ConfigurationManager, parameter_editor) -> None:  # noqa: ANN001
         super().__init__(master)
         self.main_frame = master
-        self.local_filesystem = local_filesystem
+        self.configuration_manager = configuration_manager
         self.parameter_editor = parameter_editor  # the parent window that contains this table
-        self.current_file = ""
         self.upload_checkbutton_var: dict[str, tk.BooleanVar] = {}
         self.at_least_one_param_edited = False
-        self.parameters: dict[str, ArduPilotParameter] = {}
-        self.config_step_processor = ConfigurationStepProcessor(local_filesystem)
+
         # Track last return values to prevent duplicate event processing
         self._last_return_values: dict[tk.Misc, str] = {}
+        self._pending_scroll_to_bottom = False
 
         style = ttk.Style()
         style.configure("narrow.TButton", padding=0, width=4, border=(0, 0, 0, 0))
 
-        # Prepare a dictionary that maps variable names to their values
-        # These variables are used by the forced_parameters and derived_parameters in configuration_steps_*.json files
-        self.variables = local_filesystem.get_eval_variables()
-
     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.
@@ -130,13 +128,14 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
         return tuple(base_headers), tuple(base_tooltips)
 
     def repopulate(  # pylint: disable=too-many-locals
-        self, selected_file: str, fc_parameters: dict[str, float], show_only_differences: bool, gui_complexity: str
+        self, show_only_differences: bool, gui_complexity: str
     ) -> None:
         for widget in self.view_port.winfo_children():
             widget.destroy()
-        self.current_file = selected_file
         # Clear the last return values tracking dictionary when repopulating
         self._last_return_values.clear()
+        scroll_to_bottom = self._pending_scroll_to_bottom
+        self._pending_scroll_to_bottom = False
 
         # Check if upload column should be shown based on UI complexity
         show_upload_column = self._should_show_upload_column(gui_complexity)
@@ -152,9 +151,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
         self.upload_checkbutton_var = {}
 
         # Process configuration step and create domain model parameters
-        self.parameters, config_step_edited, ui_errors, ui_infos = self.config_step_processor.process_configuration_step(
-            selected_file, fc_parameters, self.variables
-        )
+        (config_step_edited, ui_errors, ui_infos) = self.configuration_manager.repopulate_configuration_step_parameters()
         if config_step_edited:
             self.at_least_one_param_edited = True
 
@@ -165,53 +162,57 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
 
         if show_only_differences:
             # Filter to show only different parameters
-            different_params = self.config_step_processor.filter_different_parameters(self.parameters)
-            self._update_table(different_params, fc_parameters, self.parameter_editor.gui_complexity)
+            different_params = self.configuration_manager.get_different_parameters()
+            self._update_table(different_params, self.parameter_editor.gui_complexity)
             if not different_params:
-                info_msg = _("No different parameters found in {selected_file}. Skipping...").format(**locals())
+                info_msg = _("No different parameters found in {selected_file}. Skipping...").format(
+                    selected_file=self.configuration_manager.current_file
+                )
                 logging_info(info_msg)
                 messagebox.showinfo(_("ArduPilot methodic configurator"), info_msg)
                 self.parameter_editor.on_skip_click()
                 return
         else:
-            self._update_table(self.parameters, fc_parameters, self.parameter_editor.gui_complexity)
-        # Scroll to the top of the parameter table
-        self.canvas.yview("moveto", 0)
+            self._update_table(self.configuration_manager.parameters, self.parameter_editor.gui_complexity)
+        self._apply_scroll_position(scroll_to_bottom)
 
-    def _update_table(
-        self, params: dict[str, ArduPilotParameter], fc_parameters: dict[str, float], gui_complexity: str
-    ) -> None:
+    def _apply_scroll_position(self, scroll_to_bottom: bool) -> None:
+        """Apply the requested scroll position to the canvas."""
+        self.update_idletasks()
+        position = 1.0 if scroll_to_bottom else 0.0
+        self.canvas.yview_moveto(position)
+
+    def _update_table(self, params: dict[str, ArduPilotParameter], gui_complexity: str) -> None:
         """Update the parameter table with the given parameters."""
         current_param_name: str = ""
         show_upload_column = self._should_show_upload_column(gui_complexity)
-        fc_connected = bool(fc_parameters)
 
         try:
             for i, (param_name, param) in enumerate(params.items(), 1):
                 current_param_name = param_name
 
-                column: list[tk.Widget] = self._create_column_widgets(param_name, param, show_upload_column, fc_connected)
+                column: list[tk.Widget] = self._create_column_widgets(param_name, param, 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)
-            )
-            tooltip_msg = _("Add a parameter to the {self.current_file} file")
+            add_button = ttk.Button(self.view_port, text=_("Add"), style="narrow.TButton", command=self._on_parameter_add)
+            tooltip_msg = _("Add a parameter to the {self.configuration_manager.current_file} file")
             show_tooltip(add_button, tooltip_msg.format(**locals()))
             add_button.grid(row=len(params) + 2, column=0, sticky="w", padx=0)
 
         except KeyError as e:
             logging_critical(
-                _("Parameter %s not found in the %s file: %s"), current_param_name, self.current_file, e, exc_info=True
+                _("Parameter %s not found in the %s file: %s"),
+                current_param_name,
+                self.configuration_manager.current_file,
+                e,
+                exc_info=True,
             )
             sys_exit(1)
 
         self._configure_table_columns(show_upload_column)
 
-    def _create_column_widgets(
-        self, param_name: str, param: ArduPilotParameter, show_upload_column: bool, fc_connected: bool
-    ) -> list[tk.Widget]:
+    def _create_column_widgets(self, param_name: str, param: ArduPilotParameter, show_upload_column: bool) -> list[tk.Widget]:
         """Create all column widgets for a parameter row."""
         column: list[tk.Widget] = []
         change_reason_widget = self._create_change_reason_entry(param)
@@ -225,7 +226,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
         column.append(self._create_unit_label(param))
 
         if show_upload_column:
-            column.append(self._create_upload_checkbutton(param_name, fc_connected))
+            column.append(self._create_upload_checkbutton(param_name))
 
         column.append(change_reason_widget)
 
@@ -282,7 +283,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
         delete_button = ttk.Button(
             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")
+        tooltip_msg = _("Delete {param_name} from the {self.configuration_manager.current_file} file")
         show_tooltip(delete_button, tooltip_msg.format(**locals()))
         return delete_button
 
@@ -352,7 +353,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
             # Success: mark edited and update the stored file parameter value
             show_tooltip(change_reason_widget, param.tooltip_change_reason)
             self.at_least_one_param_edited = True
-            self.local_filesystem.file_parameters[self.current_file][param.name].value = new_value
+            self.configuration_manager.current_file_parameters[param.name].value = new_value
             value_is_different.config(text=NEW_VALUE_DIFFERENT_STR if param.is_different_from_fc else " ")
 
         combobox_widget.configure(
@@ -383,8 +384,6 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
         self, param: ArduPilotParameter, change_reason_widget: ttk.Entry, value_is_different: ttk.Label
     ) -> Union[PairTupleCombobox, ttk.Entry]:
         """Create an entry widget for editing the parameter value."""
-        # if param.is_dirty:
-        #    self.at_least_one_param_edited = True
         new_value_entry: Union[PairTupleCombobox, ttk.Entry]
 
         # Check if parameter has values dictionary
@@ -498,7 +497,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
                 self.at_least_one_param_edited = True
                 # Update the corresponding file parameter with the model-returned value
                 # (model returns the canonical numeric/string representation)
-                self.local_filesystem.file_parameters[self.current_file][param.name].value = new_value_result
+                self.configuration_manager.current_file_parameters[param.name].value = new_value_result
                 value_is_different.config(text=NEW_VALUE_DIFFERENT_STR if param.is_different_from_fc else " ")
 
             # Update the displayed value in the Entry or Combobox
@@ -574,7 +573,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
                 show_tooltip(change_reason_widget, param.tooltip_change_reason)
                 self.at_least_one_param_edited = True
                 # Update the corresponding file parameter
-                self.local_filesystem.file_parameters[self.current_file][param.name].value = new_value_result
+                self.configuration_manager.current_file_parameters[param.name].value = new_value_result
                 value_is_different.config(text=NEW_VALUE_DIFFERENT_STR if param.is_different_from_fc else " ")
 
             # Update new_value_entry with the new decimal value
@@ -673,8 +672,9 @@ 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) -> ttk.Checkbutton:
         """Create a checkbutton for upload selection."""
+        fc_connected: bool = self.configuration_manager.is_fc_connected
         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")
@@ -719,7 +719,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
                     )
                     self.at_least_one_param_edited = True
                     # Update the corresponding file parameter comment
-                    self.local_filesystem.file_parameters[self.current_file][param.name].comment = new_comment
+                    self.configuration_manager.current_file_parameters[param.name].comment = new_comment
 
             change_reason_entry.bind("<FocusOut>", _on_change_reason_change)
             change_reason_entry.bind("<Return>", _on_change_reason_change)
@@ -731,48 +731,34 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
     def _on_parameter_delete(self, param_name: str) -> None:
         """Handle parameter deletion."""
         msg = _("Are you sure you want to delete the {param_name} parameter?")
-        if messagebox.askyesno(f"{self.current_file}", msg.format(**locals())):
+        if messagebox.askyesno(f"{self.configuration_manager.current_file}", msg.format(**locals())):
             # Capture current vertical scroll position
             current_scroll_position = self.canvas.yview()[0]
 
             # Delete the parameter
-            del self.local_filesystem.file_parameters[self.current_file][param_name]
-            if param_name in self.parameters:
-                del self.parameters[param_name]
+            self.configuration_manager.delete_parameter_from_current_file(param_name)
             self.at_least_one_param_edited = True
-            self.parameter_editor.repopulate_parameter_table(self.current_file)
+            self.parameter_editor.repopulate_parameter_table()
 
             # 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) -> None:
         """Handle parameter addition."""
         add_parameter_window = BaseWindow(self.main_frame.master)
-        add_parameter_window.root.title(_("Add Parameter to ") + self.current_file)
+        add_parameter_window.root.title(_("Add Parameter to ") + self.configuration_manager.current_file)
         add_parameter_window.root.geometry("450x300")
 
         # Label for instruction
         instruction_label = ttk.Label(add_parameter_window.main_frame, text=_("Enter the parameter name to add:"))
         instruction_label.pack(pady=5)
 
-        param_dict = self.local_filesystem.doc_dict or fc_parameters
-
-        if not param_dict:
-            messagebox.showerror(
-                _("Operation not possible"),
-                _("No apm.pdef.xml file and no FC connected. Not possible autocomplete parameter names."),
-            )
+        try:
+            possible_add_param_names = self.configuration_manager.get_possible_add_param_names()
+        except OperationNotPossibleError as e:
+            messagebox.showerror(_("Operation not possible"), str(e))
             return
 
-        # Remove the parameters that are already displayed in this configuration step
-        possible_add_param_names = [
-            param_name
-            for param_name in param_dict
-            if param_name not in self.local_filesystem.file_parameters[self.current_file]
-        ]
-
-        possible_add_param_names.sort()
-
         # Prompt the user for a parameter name
         parameter_name_combobox = EntryWithDynamicalyFilteredListbox(
             add_parameter_window.main_frame,
@@ -789,7 +775,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)
             param_name = parameter_name_combobox.get().upper()
-            if self._confirm_parameter_addition(param_name, fc_parameters):
+            if self._confirm_parameter_addition(param_name):
                 add_parameter_window.root.destroy()
             else:
                 add_parameter_window.root.focus()
@@ -798,52 +784,36 @@ 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:
-        """Confirm and process parameter addition."""
-        if not param_name:
-            messagebox.showerror(_("Invalid parameter name."), _("Parameter name can not be empty."))
-            return False
-
-        if param_name in self.local_filesystem.file_parameters[self.current_file]:
-            messagebox.showerror(_("Invalid parameter name."), _("Parameter already exists, edit it instead"))
-            return False
-
-        if fc_parameters:
-            if param_name in fc_parameters:
-                self.local_filesystem.file_parameters[self.current_file][param_name] = Par(fc_parameters[param_name], "")
-                self.at_least_one_param_edited = True
-                self.parameter_editor.repopulate_parameter_table(self.current_file)
-                return True
-            messagebox.showerror(_("Invalid parameter name."), _("Parameter name not found in the flight controller."))
-        if self.local_filesystem.doc_dict:
-            if param_name in self.local_filesystem.doc_dict:
-                self.local_filesystem.file_parameters[self.current_file][param_name] = Par(
-                    self.local_filesystem.param_default_dict.get(param_name, Par(0, "")).value, ""
-                )
+    def _confirm_parameter_addition(self, param_name: str) -> bool:
+        """Confirm and process parameter addition using ConfigurationManager."""
+        try:
+            if self.configuration_manager.add_parameter_to_current_file(param_name):
                 self.at_least_one_param_edited = True
-                self.parameter_editor.repopulate_parameter_table(self.current_file)
+                self._pending_scroll_to_bottom = True
+                self.parameter_editor.repopulate_parameter_table()
                 return True
-            error_msg = _("'{param_name}' not found in the apm.pdef.xml file.")
-            messagebox.showerror(_("Invalid parameter name."), error_msg.format(**locals()))
-        if not fc_parameters and not self.local_filesystem.doc_dict:
-            messagebox.showerror(
-                _("Operation not possible"),
-                _("Can not add parameter when no FC is connected and no apm.pdef.xml file exists."),
-            )
+        except InvalidParameterNameError as exc:
+            messagebox.showerror(_("Invalid parameter name."), str(exc))
+            return False
+        except OperationNotPossibleError as exc:
+            messagebox.showerror(_("Operation not possible"), str(exc))
+            return False
         return False
 
-    def get_upload_selected_params(self, current_file: str, gui_complexity: str) -> ParDict:
+    def get_upload_selected_params(self, gui_complexity: str) -> ParDict:
         """Get the parameters selected for upload."""
         # Check if we should show upload column based on GUI complexity
         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]
-
-        selected_params = ParDict()
-        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]
-        return selected_params
+            return self.configuration_manager.current_file_parameters
+
+        return ParDict(
+            {
+                param_name: self.configuration_manager.current_file_parameters[param_name]
+                for param_name, checkbutton_state in self.upload_checkbutton_var.items()
+                if checkbutton_state.get()
+            }
+        )
 
     def get_at_least_one_param_edited(self) -> bool:
         """Get whether at least one parameter has been edited."""