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

ardupilot_methodic_configurator/backend_filesystem_vehicle_components.py

@@ -23,9 +23,8 @@ from os import walk as os_walk
 from re import match as re_match
 from typing import Any, Union
 
-from jsonschema import ValidationError, validate, validators
-
 from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.backend_filesystem_json_with_schema import FilesystemJSONWithSchema
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
 from ardupilot_methodic_configurator.data_model_vehicle_components_json_schema import VehicleComponentsJsonSchema
 from ardupilot_methodic_configurator.middleware_template_overview import TemplateOverview
@@ -35,10 +34,9 @@ class VehicleComponents:
     """Load and save vehicle components configurations from a JSON file."""
 
     def __init__(self, save_component_to_system_templates: bool = False) -> None:
-        self.vehicle_components_json_filename = "vehicle_components.json"
-        self.vehicle_components_schema_filename = "vehicle_components_schema.json"
-        self.vehicle_components: Union[None, dict[str, Any]] = None
-        self.schema: Union[None, dict[Any, Any]] = None
+        self.vehicle_components_fs: FilesystemJSONWithSchema = FilesystemJSONWithSchema(
+            "vehicle_components.json", "vehicle_components_schema.json"
+        )
         self.save_component_to_system_templates = save_component_to_system_templates
 
     def load_schema(self) -> dict:
@@ -47,35 +45,7 @@ class VehicleComponents:
 
         :return: The schema as a dictionary
         """
-        if self.schema is not None:
-            return self.schema
-
-        # Determine the location of the schema file
-        schema_path = os_path.join(os_path.dirname(__file__), self.vehicle_components_schema_filename)
-
-        try:
-            with open(schema_path, encoding="utf-8") as file:
-                loaded_schema: dict[Any, Any] = json_load(file)
-
-                # Validate the schema itself against the JSON Schema meta-schema
-                try:
-                    # Get the Draft7Validator class which has the META_SCHEMA property
-                    validator_class = validators.Draft7Validator
-                    meta_schema = validator_class.META_SCHEMA
-
-                    # Validate the loaded schema against the meta-schema
-                    validate(instance=loaded_schema, schema=meta_schema)
-                    logging_debug(_("Schema file '%s' is valid."), schema_path)
-                except Exception as e:  # pylint: disable=broad-exception-caught
-                    logging_error(_("Schema file '%s' is not a valid JSON Schema: %s"), schema_path, str(e))
-
-                self.schema = loaded_schema
-            return self.schema
-        except FileNotFoundError:
-            logging_error(_("Schema file '%s' not found."), schema_path)
-        except JSONDecodeError:
-            logging_error(_("Error decoding JSON schema from file '%s'."), schema_path)
-        return {}
+        return self.vehicle_components_fs.load_schema()
 
     def load_component_templates(self) -> dict[str, list[dict]]:
         """
@@ -285,37 +255,12 @@ class VehicleComponents:
         :param data: The vehicle components data to validate
         :return: A tuple of (is_valid, error_message)
         """
-        schema = self.load_schema()
-        if not schema:
-            return False, _("Could not load validation schema")
-
-        try:
-            validate(instance=data, schema=schema)
-            return True, ""
-        except ValidationError as e:
-            return False, f"{_('Validation error')}: {e.message}"
+        return self.vehicle_components_fs.validate_json_against_schema(data)
 
     def load_vehicle_components_json_data(self, vehicle_dir: str) -> dict[Any, Any]:
-        data: dict[Any, Any] = {}
-        filepath = os_path.join(vehicle_dir, self.vehicle_components_json_filename)
-        try:
-            with open(filepath, encoding="utf-8") as file:
-                data = json_load(file)
+        return self.vehicle_components_fs.load_json_data(vehicle_dir)
 
-            # Validate the loaded data against the schema
-            is_valid, error_message = self.validate_vehicle_components(data)
-            if not is_valid:
-                logging_error(_("Invalid vehicle components file '%s': %s"), filepath, error_message)
-                # We still return the data even if invalid for debugging purposes
-        except FileNotFoundError:
-            # Normal users do not need this information
-            logging_debug(_("File '%s' not found in %s."), self.vehicle_components_json_filename, vehicle_dir)
-        except JSONDecodeError:
-            logging_error(_("Error decoding JSON data from file '%s'."), filepath)
-        self.vehicle_components = data
-        return data
-
-    def save_vehicle_components_json_data(self, data: dict, vehicle_dir: str) -> tuple[bool, str]:  # noqa: PLR0911 # pylint: disable=too-many-return-statements
+    def save_vehicle_components_json_data(self, data: dict, vehicle_dir: str) -> tuple[bool, str]:
         """
         Save the vehicle components data to a JSON file.
 
@@ -323,75 +268,29 @@ class VehicleComponents:
         :param vehicle_dir: The directory to save the file in
         :return: A tuple of (error_occurred, error_message)
         """
-        # Validate before saving
-        # commented out until https://github.com/ArduPilot/MethodicConfigurator/pull/237 gets merged
-        # is_valid, error_message = self.validate_vehicle_components(data)
-        # if not is_valid:
-        #     msg = _("Cannot save invalid vehicle components data: {}").format(error_message)
-        #     logging_error(msg)
-        #     return True, msg
-
-        filepath = os_path.join(vehicle_dir, self.vehicle_components_json_filename)
-        try:
-            with open(filepath, "w", encoding="utf-8", newline="\n") as file:
-                json_dump(data, file, indent=4)
-        except FileNotFoundError:
-            msg = _("Directory '{}' not found").format(vehicle_dir)
-            logging_error(msg)
-            return True, msg
-        except PermissionError:
-            msg = _("Permission denied when writing to file '{}'").format(filepath)
-            logging_error(msg)
-            return True, msg
-        except IsADirectoryError:
-            msg = _("Path '{}' is a directory, not a file").format(filepath)
-            logging_error(msg)
-            return True, msg
-        except OSError as e:
-            msg = _("OS error when writing to file '{}': {}").format(filepath, str(e))
-            logging_error(msg)
-            return True, msg
-        except TypeError as e:
-            msg = _("Type error when serializing data to JSON: {}").format(str(e))
-            logging_error(msg)
-            return True, msg
-        except ValueError as e:
-            msg = _("Value error when serializing data to JSON: {}").format(str(e))
-            logging_error(msg)
-            return True, msg
-        except Exception as e:  # pylint: disable=broad-exception-caught
-            # Still have a fallback for truly unexpected errors
-            msg = _("Unexpected error saving data to file '{}': {}").format(filepath, str(e))
-            logging_error(msg)
-            return True, msg
-
-        return False, ""
+        return self.vehicle_components_fs.save_json_data(data, vehicle_dir)
 
     def get_fc_fw_type_from_vehicle_components_json(self) -> str:
-        if self.vehicle_components and "Components" in self.vehicle_components:
-            components = self.vehicle_components["Components"]
-        else:
-            components = None
+        data = self.vehicle_components_fs.data
+        components = data["Components"] if data and "Components" in data else None
         if components:
             fw_type: str = components.get("Flight Controller", {}).get("Firmware", {}).get("Type", "")
             if fw_type in self.supported_vehicles():
                 return fw_type
-            error_msg = _("Firmware type {fw_type} in {self.vehicle_components_json_filename} is not supported")
-            logging_error(error_msg.format(**locals()))
+            error_msg = _("Firmware type {fw_type} in {filename} is not supported")
+            logging_error(error_msg.format(fw_type=fw_type, filename=self.vehicle_components_fs.json_filename))
         return ""
 
     def get_fc_fw_version_from_vehicle_components_json(self) -> str:
-        if self.vehicle_components and "Components" in self.vehicle_components:
-            components = self.vehicle_components["Components"]
-        else:
-            components = None
+        data = self.vehicle_components_fs.data
+        components = data["Components"] if data and "Components" in data else None
         if components:
             version_str: str = components.get("Flight Controller", {}).get("Firmware", {}).get("Version", "")
             version_str = version_str.lstrip().split(" ")[0] if version_str else ""
             if re_match(r"^\d+\.\d+\.\d+$", version_str):
                 return version_str
-            error_msg = _("FW version string {version_str} on {self.vehicle_components_json_filename} is invalid")
-            logging_error(error_msg.format(**locals()))
+            error_msg = _("FW version string {version_str} on {filename} is invalid")
+            logging_error(error_msg.format(version_str=version_str, filename=self.vehicle_components_fs.json_filename))
         return ""
 
     @staticmethod
@@ -410,7 +309,7 @@ class VehicleComponents:
         :return: A dictionary mapping subdirectory paths to TemplateOverview instances.
         """
         vehicle_components_dict = {}
-        file_to_find = VehicleComponents().vehicle_components_json_filename
+        file_to_find = VehicleComponents().vehicle_components_fs.json_filename
         template_default_dir = ProgramSettings.get_templates_base_dir()
         for root, _dirs, files in os_walk(template_default_dir):
             if file_to_find in files:
@@ -437,8 +336,49 @@ class VehicleComponents:
         Preserves the complete structure of the dictionary including all branches and leaves,
         but sets leaf values to empty values based on their type.
         """
-        if self.vehicle_components is not None:
-            self._recursively_clear_dict(self.vehicle_components)
+        data = self.vehicle_components_fs.data
+        if data is not None:
+            self._recursively_clear_dict(data)
+            default_data = {
+                "RC Receiver": {
+                    "FC Connection": {"Type": "RCin/SBUS", "Protocol": "All"},
+                },
+                "Telemetry": {
+                    "FC Connection": {"Type": "SERIAL1", "Protocol": "MAVLink2"},
+                },
+                "Battery Monitor": {
+                    "FC Connection": {"Type": "Analog", "Protocol": "Analog Voltage and Current"},
+                },
+                "Battery": {
+                    "Specifications": {
+                        "Chemistry": "Lipo",
+                        "Volt per cell max": 4.2,
+                        "Volt per cell low": 3.6,
+                        "Volt per cell crit": 3.55,
+                    },
+                },
+                "ESC": {
+                    "FC Connection": {"Type": "Main Out", "Protocol": "Normal"},
+                },
+                "Motors": {
+                    "Specifications": {"Poles": 14},
+                },
+                "GNSS Receiver": {
+                    "FC Connection": {"Type": "SERIAL3", "Protocol": "AUTO"},
+                },
+            }
+
+            def is_empty(val: Any) -> bool:
+                return val in (None, "", 0, 0.0, {}) or (isinstance(val, dict) and not val)
+
+            def merge_defaults(target: dict, defaults: dict) -> None:
+                for key, value in defaults.items():
+                    if key not in target or is_empty(target[key]):
+                        target[key] = value
+                    elif isinstance(value, dict) and isinstance(target[key], dict):
+                        merge_defaults(target[key], value)
+
+            merge_defaults(data["Components"], default_data)
 
     def _recursively_clear_dict(self, data: Union[dict, list, float, bool, str]) -> None:
         """

ardupilot_methodic_configurator/data_model_vehicle_components_base.py

@@ -242,7 +242,7 @@ class ComponentDataModelBase:
 
         # Handle legacy battery monitor protocol migration for protocols that don't need hardware connections
         # This is a local import to avoid a circular import dependency
-        from ardupilot_methodic_configurator.data_model_vehicle_components_validation import (  # pylint: disable=import-outside-toplevel # noqa: PLC0415
+        from ardupilot_methodic_configurator.data_model_vehicle_components_validation import (  # pylint: disable=import-outside-toplevel, cyclic-import # noqa: PLC0415
             BATT_MONITOR_CONNECTION,
             OTHER_PORTS,
         )

ardupilot_methodic_configurator/frontend_tkinter_base_window.py

@@ -135,7 +135,7 @@ class BaseWindow:
 
         # Create custom styles with DPI-aware font sizes
         bold_font_size = self.calculate_scaled_font_size(8)
-        style.configure("Bold.TLabel", font=("TkDefaultFont", bold_font_size, "bold"))
+        style.configure("Bold.TLabel", font=("TkDefaultFont", bold_font_size, "bold"))  # type: ignore[no-untyped-call]
 
     def _get_dpi_scaling_factor(self) -> float:
         """

ardupilot_methodic_configurator/frontend_tkinter_component_editor_base.py

@@ -153,13 +153,13 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
     def _setup_styles(self) -> None:
         """Configure the styles for UI elements."""
         style = ttk.Style()
-        style.configure("bigger.TLabel", font=("TkDefaultFont", 13))
-        style.configure("comb_input_invalid.TCombobox", fieldbackground="red")
-        style.configure("comb_input_valid.TCombobox", fieldbackground="white")
-        style.configure("entry_input_invalid.TEntry", fieldbackground="red")
-        style.configure("entry_input_valid.TEntry", fieldbackground="white")
-        style.configure("Optional.TLabelframe", borderwidth=2)
-        style.configure("Optional.TLabelframe.Label", foreground="gray")
+        style.configure("bigger.TLabel", font=("TkDefaultFont", 13))  # type: ignore[no-untyped-call]
+        style.configure("comb_input_invalid.TCombobox", fieldbackground="red")  # type: ignore[no-untyped-call]
+        style.configure("comb_input_valid.TCombobox", fieldbackground="white")  # type: ignore[no-untyped-call]
+        style.configure("entry_input_invalid.TEntry", fieldbackground="red")  # type: ignore[no-untyped-call]
+        style.configure("entry_input_valid.TEntry", fieldbackground="white")  # type: ignore[no-untyped-call]
+        style.configure("Optional.TLabelframe", borderwidth=2)  # type: ignore[no-untyped-call]
+        style.configure("Optional.TLabelframe.Label", foreground="gray")  # type: ignore[no-untyped-call]
 
     def _create_intro_frame(self) -> None:
         """Create the introduction frame with explanations and image."""
@@ -294,7 +294,11 @@ class ComponentEditorWindowBase(BaseWindow):  # pylint: disable=too-many-instanc
         style = ttk.Style()
 
         instructions_text = RichText(
-            usage_popup_window.main_frame, wrap=tk.WORD, height=5, bd=0, background=style.lookup("TLabel", "background")
+            usage_popup_window.main_frame,
+            wrap=tk.WORD,
+            height=5,
+            bd=0,
+            background=style.lookup("TLabel", "background"),  # type: ignore[no-untyped-call]
         )
         instructions_text.insert(tk.END, _("1. Describe the properties of the vehicle components in the window below.\n"))
         instructions_text.insert(tk.END, _("2. Each field has mouse-over tooltips for additional guidance.\n"))

ardupilot_methodic_configurator/frontend_tkinter_directory_selection.py

@@ -200,7 +200,7 @@ class VehicleDirectorySelectionWidgets(DirectorySelectionWidgets):
             self.local_filesystem.vehicle_dir = self.directory
 
             if not self.local_filesystem.vehicle_configuration_files_exist(self.directory):
-                _filename = self.local_filesystem.vehicle_components_json_filename
+                _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

ardupilot_methodic_configurator/frontend_tkinter_pair_tuple_combobox.py

@@ -106,7 +106,7 @@ class PairTupleCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
         style = ttk.Style()
         # check if the combobox already has the "postoffset" property
         current_combo_style = combo.cget("style") or "TCombobox"
-        if len(style.lookup(current_combo_style, "postoffset")) > 0:
+        if len(style.lookup(current_combo_style, "postoffset")) > 0:  # type: ignore[no-untyped-call]
             return
         combo_values = combo.cget("values")
         if len(combo_values) == 0:
@@ -124,7 +124,7 @@ class PairTupleCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
         style_name = current_combo_style if unique_name in current_combo_style else f"{unique_name}.{current_combo_style}"
 
         if isinstance(combo, ttk.Combobox):
-            style.configure(style_name, postoffset=(0, 0, width, 0))
+            style.configure(style_name, postoffset=(0, 0, width, 0))  # type: ignore[no-untyped-call]
             combo.configure(style=style_name)
 
 

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -161,13 +161,15 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         self.root.protocol("WM_DELETE_WINDOW", self.close_connection_and_quit)
 
         style = ttk.Style()
-        style.map("readonly.TCombobox", fieldbackground=[("readonly", "white")])
-        style.map("readonly.TCombobox", selectbackground=[("readonly", "white")])
-        style.map("readonly.TCombobox", selectforeground=[("readonly", "black")])
-        style.map("default_v.TCombobox", fieldbackground=[("readonly", "light blue")])
-        style.map("default_v.TCombobox", selectbackground=[("readonly", "light blue")])
-        style.map("default_v.TCombobox", selectforeground=[("readonly", "black")])
-        style.configure("default_v.TEntry", fieldbackground="light blue")
+        style.map("readonly.TCombobox", fieldbackground=[("readonly", "white")])  # type: ignore[no-untyped-call]
+        style.map("readonly.TCombobox", selectbackground=[("readonly", "white")])  # type: ignore[no-untyped-call]
+        style.map("readonly.TCombobox", selectforeground=[("readonly", "black")])  # type: ignore[no-untyped-call]
+        style.map("default_v.TCombobox", fieldbackground=[("readonly", "light blue")])  # type: ignore[no-untyped-call]
+        style.map("default_v.TCombobox", selectbackground=[("readonly", "light blue")])  # type: ignore[no-untyped-call]
+        style.map("default_v.TCombobox", selectforeground=[("readonly", "black")])  # type: ignore[no-untyped-call]
+        style.configure("default_v.TEntry", fieldbackground="light blue")  # type: ignore[no-untyped-call]
+        style.configure("below_limit.TEntry", fieldbackground="orangered")  # type: ignore[no-untyped-call]
+        style.configure("above_limit.TEntry", fieldbackground="red3")  # type: ignore[no-untyped-call]
 
         self.__create_conf_widgets(__version__)
 
@@ -255,7 +257,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
 
     def legend_frame(self, config_subframe: ttk.Frame, font_family: str) -> None:
         style = ttk.Style()
-        style.configure("Legend.TLabelframe", font=(font_family, 9))
+        style.configure("Legend.TLabelframe", font=(font_family, 9))  # type: ignore[no-untyped-call]
         legend_frame = ttk.LabelFrame(config_subframe, text=_("Legend"), style="Legend.TLabelframe")
         legend_left = ttk.Frame(legend_frame)
         legend_left.pack(side=tk.LEFT, anchor=tk.NW)
@@ -269,9 +271,12 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         cal_label = ttk.Label(legend_left, text=_("Calibration param"), background="yellow", font=font)
         show_tooltip(cal_label, _("Calibration parameter - not-reusable, even in similar vehicles"))
         cal_label.pack(side=tk.TOP, anchor=tk.NW)
-        readonly_label = ttk.Label(legend_left, text=_("Read-only param"), background="red", font=font)
+        readonly_label = ttk.Label(legend_left, text=_("Read-only param"), background="purple1", font=font)
         show_tooltip(readonly_label, _("Read-only parameter - not writable nor changeable"))
         readonly_label.pack(side=tk.TOP, anchor=tk.NW)
+        toolow_label = ttk.Label(legend_left, text=_("Below limit"), background="orangered", font=font)
+        show_tooltip(toolow_label, _("Parameter value below the minimum recommended value"))
+        toolow_label.pack(side=tk.TOP, anchor=tk.NW)
         legend_right = ttk.Frame(legend_frame)
         legend_right.pack(side=tk.RIGHT, anchor=tk.NE)
         default_label = ttk.Label(legend_right, text=_("Default value"), background="lightblue", font=font)
@@ -290,6 +295,9 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         )
         ne_label.configure(state="disabled")
         ne_label.pack(side=tk.TOP, anchor=tk.NW)
+        toohigh_label = ttk.Label(legend_right, text=_("Above limit"), background="red3", font=font)
+        show_tooltip(toohigh_label, _("Parameter value above the maximum recommended value"))
+        toohigh_label.pack(side=tk.TOP, anchor=tk.NW)
         legend_frame.pack(side=tk.LEFT, fill="x", expand=False, padx=(2, 2))
 
     def __create_parameter_area_widgets(self) -> None:
@@ -382,7 +390,11 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         style = ttk.Style()
 
         instructions_text = RichText(
-            usage_popup_window.main_frame, wrap=tk.WORD, height=10, bd=0, background=style.lookup("TLabel", "background")
+            usage_popup_window.main_frame,
+            wrap=tk.WORD,
+            height=10,
+            bd=0,
+            background=style.lookup("TLabel", "background"),  # type: ignore[no-untyped-call]
         )
         instructions_text.insert(tk.END, _("1. Read "))
         instructions_text.insert(tk.END, _("all"), "bold")
@@ -604,7 +616,6 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
     def on_param_file_combobox_change(self, _event: Union[None, tk.Event], forced: bool = False) -> None:
         if not self.file_selection_combobox["values"]:
             return
-        self.parameter_editor_table.generate_edit_widgets_focus_out()
         selected_file = self.file_selection_combobox.get()
         self._update_progress_bar_from_file(selected_file)
         if self.current_file != selected_file or forced:
@@ -657,7 +668,9 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         else:
             fc_parameters = {}
         # Re-populate the table with the new parameters
-        self.parameter_editor_table.repopulate(selected_file, fc_parameters, self.show_only_differences.get())
+        self.parameter_editor_table.repopulate(
+            selected_file, fc_parameters, self.show_only_differences.get(), self.gui_complexity
+        )
 
     def on_show_only_changed_checkbox_change(self) -> None:
         self.repopulate_parameter_table(self.current_file)
@@ -737,8 +750,6 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             self.reset_progress_window.destroy()  # for the case that we are doing a test and there is no real FC connected
 
     def on_upload_selected_click(self) -> None:
-        self.parameter_editor_table.generate_edit_widgets_focus_out()
-
         self.write_changes_to_intermediate_parameter_file()
         selected_params = self.parameter_editor_table.get_upload_selected_params(self.current_file, str(self.gui_complexity))
         if selected_params:
@@ -753,7 +764,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             logging_warning(_("No parameter was selected for upload, will not upload any parameter"))
             messagebox.showwarning(_("Will not upload any parameter"), _("No parameter was selected for upload"))
         # Delete the parameter table and create a new one with the next file if available
-        self.on_skip_click(force_focus_out_event=False)
+        self.on_skip_click()
 
     # This function can recurse multiple times if there is an upload error
     def upload_selected_params(self, selected_params: dict) -> None:
@@ -814,9 +825,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
                 logging_info(_("All parameters uploaded to the flight controller successfully"))
         self.local_filesystem.write_last_uploaded_filename(self.current_file)
 
-    def on_skip_click(self, _event: Union[None, tk.Event] = None, force_focus_out_event: bool = True) -> None:
-        if force_focus_out_event:
-            self.parameter_editor_table.generate_edit_widgets_focus_out()
+    def on_skip_click(self, _event: Union[None, tk.Event] = None) -> None:
         self.write_changes_to_intermediate_parameter_file()
         # Find the next filename in the file_parameters dictionary
         files = list(self.local_filesystem.file_parameters.keys())
@@ -954,7 +963,9 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         return should_write_file
 
     def close_connection_and_quit(self) -> None:
-        self.parameter_editor_table.generate_edit_widgets_focus_out()
+        focused_widget = self.parameter_editor_table.view_port.focus_get()
+        if focused_widget is not None:
+            focused_widget.event_generate("<FocusOut>", when="now")  # trigger a sync between GUI and data-model values
         self.write_changes_to_intermediate_parameter_file()
         self.root.quit()  # Then stop the Tkinter event loop