ardupilot-methodic-configurator 2.0.5__py3-none-any.whl → 2.1.0__py3-none-any.whl

ardupilot_methodic_configurator/frontend_tkinter_base_window.py

@@ -20,6 +20,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
 
 # https://wiki.tcl-lang.org/page/Changing+Widget+Colors
 
+import io
 import os
 import tkinter as tk
 import tkinter.font as tkfont
@@ -30,7 +31,7 @@ from logging import error as logging_error
 from tkinter import ttk
 from typing import Optional, Union
 
-from PIL import Image, ImageTk
+from PIL import Image
 
 from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
@@ -262,7 +263,7 @@ class BaseWindow:
         y = parent.winfo_y() + (parent_height // 2) - (window_height // 2)
         window.geometry(f"+{x}+{y}")
 
-    def put_image_in_label(
+    def put_image_in_label(  # pylint: disable=too-many-locals
         self,
         parent: ttk.Frame,
         filepath: str,
@@ -320,25 +321,44 @@ class BaseWindow:
                 raise FileNotFoundError(msg)
 
             # Load and validate the image
-            image = Image.open(filepath)
-            if image is None:
-                msg = _("Failed to load image from %s") % filepath
-                raise ValueError(msg)
-
-            # Calculate new dimensions while preserving aspect ratio
-            width, height = image.size
-            if height == 0:
-                msg = _("Image has zero height")
-                raise ValueError(msg)
-
-            aspect_ratio = width / height
-            dpi_scaled_height = int(image_height * self.dpi_scaling_factor)
-
-            # Resize the image
-            resized_image = image.resize((int(dpi_scaled_height * aspect_ratio), dpi_scaled_height), Image.Resampling.LANCZOS)
-
-            # Convert to PhotoImage for Tkinter
-            photo = ImageTk.PhotoImage(resized_image)
+            with Image.open(filepath) as image:
+                if image is None:
+                    msg = _("Failed to load image from %s") % filepath
+                    raise ValueError(msg)
+
+                # Calculate new dimensions while preserving aspect ratio
+                width, height = image.size
+                if height == 0:
+                    msg = _("Image has zero height")
+                    raise ValueError(msg)
+                if width == 0:
+                    msg = _("Image has zero width")
+                    raise ValueError(msg)
+
+                aspect_ratio = width / height
+                dpi_scaled_height = int(image_height * self.dpi_scaling_factor)
+
+                # Ensure minimum dimensions to prevent resize errors
+                dpi_scaled_height = max(dpi_scaled_height, 1)
+
+                calculated_width = int(dpi_scaled_height * aspect_ratio)
+                calculated_width = max(calculated_width, 1)
+
+                # Resize the image
+                resized_image = image.resize((calculated_width, dpi_scaled_height), Image.Resampling.LANCZOS)
+
+                # Convert to PhotoImage for Tkinter using a buffer approach
+                buffer = io.BytesIO()
+                # Ensure the image is in a format that tk.PhotoImage can handle
+                if resized_image.mode not in ("RGB", "RGBA"):
+                    resized_image = resized_image.convert("RGB")
+
+                # Save as PNG to buffer
+                resized_image.save(buffer, format="PNG")
+                buffer.seek(0)
+
+                # Create PhotoImage from buffer
+                photo = tk.PhotoImage(data=buffer.getvalue())
 
             # Create the label with the image
             image_label = ttk.Label(parent, image=photo)

ardupilot_methodic_configurator/frontend_tkinter_directory_selection.py

@@ -21,13 +21,19 @@ from logging import info as logging_info
 from logging import warning as logging_warning
 from sys import exit as sys_exit
 from tkinter import filedialog, messagebox, ttk
+from typing import Union
 
 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_project import VehicleProjectManager
+from ardupilot_methodic_configurator.data_model_vehicle_project_creator import (
+    NewVehicleProjectSettings,
+    VehicleProjectCreationError,
+)
+from ardupilot_methodic_configurator.data_model_vehicle_project_opener import VehicleProjectOpenError
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
-from ardupilot_methodic_configurator.frontend_tkinter_show import show_no_param_files_error, show_tooltip
+from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
 from ardupilot_methodic_configurator.frontend_tkinter_template_overview import TemplateOverviewWindow
 
 
@@ -42,7 +48,7 @@ class DirectorySelectionWidgets:  # pylint: disable=too-many-instance-attributes
 
     def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
         self,
-        parent: BaseWindow,
+        parent: Union[BaseWindow, "VehicleDirectorySelectionWindow"],
         parent_frame: tk.Widget,
         initialdir: str,
         label_text: str,
@@ -94,7 +100,10 @@ class DirectorySelectionWidgets:  # pylint: disable=too-many-instance-attributes
             if isinstance(self.parent.root, tk.Tk):  # this keeps mypy and pyright happy
                 to = TemplateOverviewWindow(self.parent.root, connected_fc_vehicle_type=self.connected_fc_vehicle_type)
                 to.run_app()
-            selected_directory = ProgramSettings.get_recently_used_dirs()[0]
+            if isinstance(self.parent, VehicleDirectorySelectionWindow):
+                selected_directory = self.parent.project_manager.get_recently_used_dirs()[0]
+            else:
+                selected_directory = ""
             logging_info(_("Selected template directory: %s"), selected_directory)
         else:
             title = _("Select {self.label_text}")
@@ -156,9 +165,8 @@ class VehicleDirectorySelectionWidgets(DirectorySelectionWidgets):
 
     def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
         self,
-        parent: BaseWindow,
+        parent: Union[BaseWindow, "VehicleDirectorySelectionWindow"],
         parent_frame: ttk.Widget,
-        local_filesystem: LocalFilesystem,
         initial_dir: str,
         destroy_parent_on_open: bool,
         connected_fc_vehicle_type: str = "",
@@ -183,45 +191,20 @@ class VehicleDirectorySelectionWidgets(DirectorySelectionWidgets):
             is_template_selection=False,
             connected_fc_vehicle_type=connected_fc_vehicle_type,
         )
-        self.local_filesystem = local_filesystem
         self.destroy_parent_on_open = destroy_parent_on_open
 
     def on_select_directory(self) -> bool:
         # Call the base class method to open the directory selection dialog
         if super().on_select_directory():
-            if "vehicle_templates" in self.directory and not self.local_filesystem.allow_editing_template_files:
-                messagebox.showerror(
-                    _("Invalid Vehicle Directory Selected"),
-                    _(
-                        "Please do not edit the files provided 'vehicle_templates' directory\n"
-                        "as those are used as a template for new vehicles"
-                    ),
-                )
-                return False
-            self.local_filesystem.vehicle_dir = self.directory
-
-            if not self.local_filesystem.vehicle_configuration_files_exist(self.directory):
-                _filename = self.local_filesystem.vehicle_components_fs.json_filename
-                error_msg = _("Selected directory must contain files matching \\d\\d_*\\.param and a {_filename} file")
-                messagebox.showerror(_("Invalid Vehicle Directory Selected"), error_msg.format(**locals()))
-                return False
-
             try:
-                self.local_filesystem.re_init(self.directory, self.local_filesystem.vehicle_type)
-            except SystemExit as exp:
-                messagebox.showerror(_("Fatal error reading parameter files"), f"{exp}")
-                raise
-
-            if self.local_filesystem.file_parameters:
-                files = list(self.local_filesystem.file_parameters.keys())
-                if files:
-                    LocalFilesystem.store_recently_used_vehicle_dir(self.directory)
-                    if self.destroy_parent_on_open:
-                        self.parent.root.destroy()
-                    return True
-            # No files were found in the selected directory
-            show_no_param_files_error(self.directory)
-            return True
+                if isinstance(self.parent, VehicleDirectorySelectionWindow):
+                    self.parent.project_manager.open_vehicle_directory(self.directory)
+                if self.destroy_parent_on_open:
+                    self.parent.root.destroy()
+                return True
+            except VehicleProjectOpenError as e:
+                messagebox.showerror(e.title, e.message)
+                return False
         return False
 
 
@@ -237,29 +220,33 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
     """
 
     def __init__(
-        self, local_filesystem: LocalFilesystem, fc_connected: bool = False, connected_fc_vehicle_type: str = ""
+        self, project_manager: VehicleProjectManager, fc_connected: bool = False, connected_fc_vehicle_type: str = ""
     ) -> None:
         super().__init__()
-        self.local_filesystem = local_filesystem
+        self.project_manager = project_manager
         self.connected_fc_vehicle_type = connected_fc_vehicle_type
         self.root.title(
             _("Amilcar Lucas's - ArduPilot methodic configurator ")
             + __version__
             + _(" - Select vehicle configuration directory")
         )
-        self.root.geometry("800x655")  # Set the window size
-        self.blank_component_data = tk.BooleanVar(value=False)
-        self.infer_comp_specs_and_conn_from_fc_params = tk.BooleanVar(value=False)
-        self.use_fc_params = tk.BooleanVar(value=False)
-        self.blank_change_reason = tk.BooleanVar(value=False)
-        self.copy_vehicle_image = tk.BooleanVar(value=False)
-        self.configuration_template: str = ""  # will be set to a string if a template was used
+
+        # Initialize settings variables dynamically from data model
+        self.new_project_settings_vars: dict[str, tk.BooleanVar] = {}
+        self.new_project_settings_widgets: dict[str, ttk.Checkbutton] = {}
+        new_project_settings_metadata = NewVehicleProjectSettings.get_all_settings_metadata(fc_connected)
+        new_project_settings_default_values = NewVehicleProjectSettings.get_default_values()
+        for setting_name in new_project_settings_metadata:
+            default_value = new_project_settings_default_values.get(setting_name, False)
+            self.new_project_settings_vars[setting_name] = tk.BooleanVar(value=default_value)
+
+        # Set dynamic window size based on number of settings
+        nr_new_project_settings = len(new_project_settings_metadata)
+        window_height = 550 + (nr_new_project_settings * 21)
+        self.root.geometry(f"800x{window_height}")  # Set the window size
 
         # Explain why we are here
-        if local_filesystem.vehicle_dir == LocalFilesystem.getcwd():
-            introduction_text = _("No intermediate parameter files found\nin current working directory.")
-        else:
-            introduction_text = _("No intermediate parameter files found\nin the --vehicle-dir specified directory.")
+        introduction_text = self.project_manager.get_introduction_message()
         introduction_label = ttk.Label(
             self.main_frame,
             anchor=tk.CENTER,
@@ -267,11 +254,17 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             text=introduction_text + _("\nChoose one of the following three options:"),
         )
         introduction_label.pack(expand=False, fill=tk.X, padx=6, pady=6)
-        template_dir, new_base_dir, vehicle_dir = LocalFilesystem.get_recently_used_dirs()
+        template_dir, new_base_dir, vehicle_dir = self.project_manager.get_recently_used_dirs()
         logging_debug("template_dir: %s", template_dir)  # this string is intentionally left untranslated
         logging_debug("new_base_dir: %s", new_base_dir)  # this string is intentionally left untranslated
         logging_debug("vehicle_dir: %s", vehicle_dir)  # this string is intentionally left untranslated
-        self.create_option1_widgets(template_dir, new_base_dir, _("MyVehicleName"), fc_connected, connected_fc_vehicle_type)
+        self.create_option1_widgets(
+            template_dir,
+            new_base_dir,
+            self.project_manager.get_default_vehicle_name(),
+            fc_connected,
+            connected_fc_vehicle_type,
+        )
         self.create_option2_widgets(vehicle_dir)
         self.create_option3_widgets(vehicle_dir)
 
@@ -313,76 +306,19 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             connected_fc_vehicle_type=connected_fc_vehicle_type,
         )
         self.template_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
-        blank_component_data_checkbox = ttk.Checkbutton(
-            option1_label_frame,
-            variable=self.blank_component_data,
-            text=_("Blank component data"),
-        )
-        blank_component_data_checkbox.pack(anchor=tk.NW)
-        show_tooltip(
-            blank_component_data_checkbox,
-            _("Create a new blank vehicle configuration, with no component data from the template."),
-        )
-        infer_comp_specs_and_conn_from_fc_params_checkbox = ttk.Checkbutton(
-            option1_label_frame,
-            variable=self.infer_comp_specs_and_conn_from_fc_params,
-            text=_("Infer component specifications and FC connections from FC parameters, not from template files"),
-        )
-        infer_comp_specs_and_conn_from_fc_params_checkbox.pack(anchor=tk.NW)
-        show_tooltip(
-            infer_comp_specs_and_conn_from_fc_params_checkbox,
-            _(
-                "When creating a new vehicle configuration, extract component specifications\n"
-                "and connection information directly from the connected flight controller\n"
-                "instead of using the specifications defined in the template files.\n"
-                "This helps ensure the configuration accurately matches your actual hardware.\n"
-                "But you will not see the information from the correctly configured vehicle template.\n\n"
-            )
-            + _("This option is only available when a flight controller is connected."),
-        )
-        use_fc_params_checkbox = ttk.Checkbutton(
-            option1_label_frame,
-            variable=self.use_fc_params,
-            text=_("Use parameter values from connected FC, not from template files"),
-        )
-        use_fc_params_checkbox.pack(anchor=tk.NW)
-        show_tooltip(
-            use_fc_params_checkbox,
-            _(
-                "Use the parameter values from the connected flight controller instead of the\n"
-                "template files when creating a new vehicle configuration directory from a template.\n"
-                "Only makes sense if your FC has already been correctly configured.\n\n"
+
+        # Create checkboxes dynamically from settings metadata
+        settings_metadata = NewVehicleProjectSettings.get_all_settings_metadata(fc_connected)
+        for setting_name, metadata in settings_metadata.items():
+            checkbox = ttk.Checkbutton(
+                option1_label_frame,
+                variable=self.new_project_settings_vars[setting_name],
+                text=metadata.label,
+                state=tk.NORMAL if metadata.enabled else tk.DISABLED,
             )
-            + _("This option is only available when a flight controller is connected."),
-        )
-        blank_change_reason_checkbox = ttk.Checkbutton(
-            option1_label_frame,
-            variable=self.blank_change_reason,
-            text=_("Blank parameter change reason"),
-        )
-        blank_change_reason_checkbox.pack(anchor=tk.NW)
-        show_tooltip(
-            blank_change_reason_checkbox,
-            _("Do not use the parameters change reason from the template."),
-        )
-        copy_vehicle_image_checkbox = ttk.Checkbutton(
-            option1_label_frame,
-            variable=self.copy_vehicle_image,
-            text=_("Copy vehicle image from template"),
-        )
-        copy_vehicle_image_checkbox.pack(anchor=tk.NW)
-        show_tooltip(
-            copy_vehicle_image_checkbox,
-            _(
-                "Copy the vehicle.jpg image file from the template directory to the new vehicle directory\n"
-                "if it exists. This image helps identify the vehicle configuration."
-            ),
-        )
-        if not fc_connected:
-            self.infer_comp_specs_and_conn_from_fc_params.set(False)
-            infer_comp_specs_and_conn_from_fc_params_checkbox.config(state=tk.DISABLED)
-            self.use_fc_params.set(False)
-            use_fc_params_checkbox.config(state=tk.DISABLED)
+            checkbox.pack(anchor=tk.NW)
+            show_tooltip(checkbox, metadata.tooltip)
+            self.new_project_settings_widgets[setting_name] = checkbox
 
         new_base_dir_edit_tooltip = _("Existing directory where the new vehicle configuration directory will be created")
         new_base_dir_btn_tooltip = _("Select the directory where the new vehicle configuration directory will be created")
@@ -438,7 +374,6 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
         self.connection_selection_widgets = VehicleDirectorySelectionWidgets(
             self,
             option2_label_frame,
-            self.local_filesystem,
             initial_dir,
             destroy_parent_on_open=True,
             connected_fc_vehicle_type=self.connected_fc_vehicle_type,
@@ -465,9 +400,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
         last_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
 
         # Check if there is a last used vehicle configuration directory
-        button_state = (
-            tk.NORMAL if last_vehicle_dir and self.local_filesystem.directory_exists(last_vehicle_dir) else tk.DISABLED
-        )
+        button_state = tk.NORMAL if self.project_manager.can_open_last_vehicle_directory(last_vehicle_dir) else tk.DISABLED
         open_last_vehicle_directory_button = ttk.Button(
             option3_label_frame,
             text=_("Open Last Used Vehicle Configuration Directory"),
@@ -488,86 +421,26 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
         new_base_dir = self.new_base_dir.get_selected_directory()
         new_vehicle_name = self.new_dir.get_selected_directory()
 
-        if template_dir == "":
-            messagebox.showerror(_("Vehicle template directory"), _("Vehicle template directory must not be empty"))
-            return
-        if not LocalFilesystem.directory_exists(template_dir):
-            msg = _("Vehicle template directory {template_dir} does not exist").format(template_dir=template_dir)
-            logging_error(msg)
-            messagebox.showerror(_("Vehicle template directory"), msg)
-            return
-
-        if new_vehicle_name == "":
-            messagebox.showerror(_("New vehicle directory"), _("New vehicle name must not be empty"))
-            return
-        if not LocalFilesystem.valid_directory_name(new_vehicle_name):
-            msg = _("New vehicle name {new_vehicle_name} must not contain invalid characters").format(
-                new_vehicle_name=new_vehicle_name
-            )
-            logging_error(msg)
-            messagebox.showerror(_("New vehicle directory"), msg)
-            return
-        new_vehicle_dir = LocalFilesystem.new_vehicle_dir(new_base_dir, new_vehicle_name)
-
-        error_msg = self.local_filesystem.create_new_vehicle_dir(new_vehicle_dir)
-        if error_msg:
-            messagebox.showerror(_("New vehicle directory"), error_msg)
-            return
-
-        error_msg = self.local_filesystem.copy_template_files_to_new_vehicle_dir(
-            template_dir,
-            new_vehicle_dir,
-            blank_change_reason=self.blank_change_reason.get(),
-            copy_vehicle_image=self.copy_vehicle_image.get(),
-        )
-        if error_msg:
-            messagebox.showerror(_("Copying template files"), error_msg)
-            return
-
-        # Update the local_filesystem with the new vehicle configuration directory
-        self.local_filesystem.vehicle_dir = new_vehicle_dir
+        # Create settings object from GUI state using dynamic settings
+        settings_kwargs = {}
+        for setting_name, var in self.new_project_settings_vars.items():
+            settings_kwargs[setting_name] = var.get()
+        settings = NewVehicleProjectSettings(**settings_kwargs)
 
+        # Create the vehicle project
         try:
-            self.local_filesystem.re_init(new_vehicle_dir, self.local_filesystem.vehicle_type, self.blank_component_data.get())
-        except SystemExit as exp:
-            messagebox.showerror(_("Fatal error reading parameter files"), f"{exp}")
-            raise
-
-        files = list(self.local_filesystem.file_parameters.keys())
-        if files:
-            LocalFilesystem.store_recently_used_template_dirs(template_dir, new_base_dir)
-            LocalFilesystem.store_recently_used_vehicle_dir(new_vehicle_dir)
+            self.project_manager.create_new_vehicle_from_template(template_dir, new_base_dir, new_vehicle_name, settings)
             self.root.destroy()
-        else:
-            show_no_param_files_error(template_dir)
-        self.configuration_template = LocalFilesystem.get_directory_name_from_full_path(template_dir)
+        except VehicleProjectCreationError as e:
+            messagebox.showerror(e.title, e.message)
 
     def open_last_vehicle_directory(self, last_vehicle_dir: str) -> None:
         # Attempt to open the last opened vehicle configuration directory
-        if last_vehicle_dir:
-            # If a last opened directory is found, proceed as if the user had manually selected it
-            self.local_filesystem.vehicle_dir = last_vehicle_dir
-
-            try:
-                self.local_filesystem.re_init(last_vehicle_dir, self.local_filesystem.vehicle_type)
-            except SystemExit as exp:
-                messagebox.showerror(_("Fatal error reading parameter files"), f"{exp}")
-                raise
-
-            if self.local_filesystem.file_parameters:
-                files = list(self.local_filesystem.file_parameters.keys())
-                if files:
-                    self.root.destroy()
-                else:
-                    show_no_param_files_error(last_vehicle_dir)
-            else:
-                show_no_param_files_error(last_vehicle_dir)
-        else:
-            # If no last opened directory is found, display a message to the user
-            messagebox.showerror(
-                _("No Last Vehicle Directory Found"),
-                _("No last opened vehicle configuration directory was found.\nPlease select a directory manually."),
-            )
+        try:
+            self.project_manager.open_last_vehicle_directory(last_vehicle_dir)
+            self.root.destroy()
+        except VehicleProjectOpenError as e:
+            messagebox.showerror(e.title, e.message)
 
 
 def argument_parser() -> Namespace:
@@ -608,13 +481,17 @@ def main() -> None:
         args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files, args.save_component_to_system_templates
     )
 
+    # Create project manager with the local filesystem
+    project_manager = VehicleProjectManager(local_filesystem)
+
     # Get the list of intermediate parameter files files that will be processed sequentially
-    files = list(local_filesystem.file_parameters.keys())
+    files = project_manager.get_file_parameters_list()
 
     if not files:
         logging_error(_("No intermediate parameter files found in %s."), args.vehicle_dir)
-        window = VehicleDirectorySelectionWindow(local_filesystem)
-        window.root.mainloop()
+
+    window = VehicleDirectorySelectionWindow(project_manager)
+    window.root.mainloop()
 
 
 if __name__ == "__main__":

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -213,7 +213,6 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         directory_selection_frame = VehicleDirectorySelectionWidgets(
             self,
             config_subframe,
-            self.local_filesystem,
             self.local_filesystem.vehicle_dir,
             destroy_parent_on_open=False,
             connected_fc_vehicle_type=connected_vehicle_type,

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_table.py

@@ -181,12 +181,13 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
         """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)
+                column: list[tk.Widget] = self._create_column_widgets(param_name, param, show_upload_column, fc_connected)
                 self._grid_column_widgets(column, i, show_upload_column)
 
             # Add the "Add" button at the bottom of the table
@@ -205,7 +206,9 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
 
         self._configure_table_columns(show_upload_column)
 
-    def _create_column_widgets(self, param_name: str, param: ArduPilotParameter, show_upload_column: bool) -> list[tk.Widget]:
+    def _create_column_widgets(
+        self, param_name: str, param: ArduPilotParameter, show_upload_column: bool, fc_connected: 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)
@@ -219,7 +222,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, param.has_fc_value))
+            column.append(self._create_upload_checkbutton(param_name, fc_connected))
 
         column.append(change_reason_widget)