fix: timer and on-demand load along with fast loading on large parameter table

Signed-off-by: Omkar Sarkar <omkarsarkar24@gmail.com>

Author: OmkarSarkar204

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_table.py

@@ -219,44 +219,82 @@ def _apply_scroll_position(self, scroll_to_bottom: bool) -> None:
         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)
+        """Initialize scroll load."""
+        self._params_list = list(params.items())
+        self._total_params = len(self._params_list)
+        self._current_idx = 0
+        self._gui_complexity = gui_complexity
+        self._is_loading = False
+
+        self._load_next_chunk(chunk_size=20)
+        self._page_scroll()
+
+    def _load_next_chunk(self, chunk_size: int = 15) -> None:
+        """Appends the next batch of widgets to the bottom of the table."""
+        if self._is_loading_chunk or self._lazy_current_index >= self._lazy_total:
+            return
 
-        should_try_to_display_bitmask_parameter_editor_usage = False
-        try:
-            for i, (param_name, param) in enumerate(params.items(), 1):
-                current_param_name = param_name
+        self._is_loading_chunk = True
+        show_upload_column = self._should_show_upload_column(self._lazy_gui_complexity)
+        should_show_bitmask_usage = False
 
-                row_widgets: list[tk.Widget] = self._create_column_widgets(param_name, param, show_upload_column)
-                if self.parameter_editor.should_display_bitmask_parameter_editor_usage(param_name):
-                    should_try_to_display_bitmask_parameter_editor_usage = True
-                self._grid_column_widgets(row_widgets, i, show_upload_column)
+        start_idx = self._lazy_current_index
+        end_idx = min(start_idx + chunk_size, self._lazy_total)
 
-            # Add the "Add" button at the bottom of the table
-            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.parameter_editor.current_file} file")
-            show_tooltip(add_button, tooltip_msg.format(**locals()))
-            add_button.grid(row=len(params) + 2, column=0, sticky="w", padx=0)
+        if hasattr(self, "_add_button_widget") and self._add_button_widget.winfo_exists():
+            self._add_button_widget.destroy()
 
+        try:
+            for i in range(start_idx, end_idx):
+                param_name, param = self._lazy_params_list[i]
+                row_widgets = self._create_column_widgets(param_name, param, show_upload_column)
+                if self.parameter_editor.should_display_bitmask_parameter_editor_usage(param_name):
+                    should_show_bitmask_usage = True
+                self._grid_column_widgets(row_widgets, i + 1, show_upload_column)
         except KeyError as e:
             logging_critical(
                 _("Parameter %s not found in the %s file: %s"),
-                current_param_name,
+                param_name,
                 self.parameter_editor.current_file,
                 e,
                 exc_info=True,
             )
             sys_exit(1)
 
+        self._lazy_current_index = end_idx
+
+        # Fix layout if all items are loaded
+        if self._lazy_current_index >= self._lazy_total:
+            self._add_button_widget = ttk.Button(
+                self.view_port, text=_("Add"), style="narrow.TButton", command=self._on_parameter_add
+            )
+            show_tooltip(
+                self._add_button_widget,
+                _("Add a parameter to the {self.parameter_editor.current_file} file").format(**locals()),
+            )
+            self._add_button_widget.grid(row=self._lazy_total + 2, column=0, sticky="w", pady=(10, 0))
+
+            parent_root = self._get_parent_root()
+            if parent_root and should_show_bitmask_usage and UsagePopupWindow.should_display("bitmask_parameter_editor"):
+                display_bitmask_parameters_editor_usage_popup(parent_root)
+
         self._configure_table_columns(show_upload_column)
-        parent_root = self._get_parent_root()
-        if (
-            parent_root
-            and should_try_to_display_bitmask_parameter_editor_usage
-            and UsagePopupWindow.should_display("bitmask_parameter_editor")
-        ):
-            display_bitmask_parameters_editor_usage_popup(parent_root)
+        self.view_port.update_idletasks()
+        self.canvas.configure(scrollregion=self.canvas.bbox("all"))
+        self._is_loading_chunk = False
+
+    def _page_scroll(self) -> None:
+        """Load more items when reaching the bottom."""
+        if not self.winfo_exists() or self._lazy_current_index >= self._lazy_total:
+            return
+
+        try:
+            if self.canvas.yview()[1] > 0.85:
+                self._load_next_chunk(chunk_size=15)
+        except tk.TclError:
+            pass
+
+        self.after(150, self._page_scroll)
 
     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."""

ardupilot_methodic_configurator/frontend_tkinter_show.py

@@ -477,33 +477,13 @@ def __init__(  # pylint: disable=too-many-arguments, too-many-positional-argumen
         self.timers: dict[str, Optional[str]] = {}
 
         # Bind the <Enter> and <Leave> events to show and hide the tooltip
-        if platform_system() == "Darwin":
-            # On macOS, defer tooltip creation slightly to avoid flashing while
-            # moving through dense tables and controls.
-            if tag_name and isinstance(self.widget, tk.Text):
-                self.widget.tag_bind(tag_name, "<Enter>", self.schedule_show, "+")
-                self.widget.tag_bind(tag_name, "<Leave>", self.destroy_hide, "+")
-            else:
-                self.widget.bind("<Enter>", self.schedule_show, "+")
-                self.widget.bind("<Leave>", self.destroy_hide, "+")
+        # Defer tooltip creation slightly to avoid flashing while moving through dense tables.
+        if tag_name and isinstance(self.widget, tk.Text):
+            self.widget.tag_bind(tag_name, "<Enter>", self.schedule_show, "+")
+            self.widget.tag_bind(tag_name, "<Leave>", self.destroy_hide, "+")
         else:
-            if tag_name and isinstance(self.widget, tk.Text):
-                self.widget.tag_bind(tag_name, "<Enter>", self.show, "+")
-                self.widget.tag_bind(tag_name, "<Leave>", self.hide, "+")
-            else:
-                self.widget.bind("<Enter>", self.show, "+")
-                self.widget.bind("<Leave>", self.hide, "+")
-            # On non-macOS, create the tooltip immediately and show/hide it on events
-            self.tooltip = cast("tk.Toplevel", self.toplevel_class(widget))
-            self.tooltip.wm_overrideredirect(boolean=True)
-            tooltip_label = ttk.Label(
-                self.tooltip, text=text, background="#ffffe0", relief="solid", borderwidth=1, justify=tk.LEFT
-            )
-            tooltip_label.pack()
-            self.tooltip.withdraw()  # Initially hide the tooltip
-            # Bind to tooltip to prevent hiding when mouse is over it
-            self.tooltip.bind("<Enter>", self._cancel_hide)
-            self.tooltip.bind("<Leave>", self.hide)
+            self.widget.bind("<Enter>", self.schedule_show, "+")
+            self.widget.bind("<Leave>", self.destroy_hide, "+")
 
         self.widget.bind("<Destroy>", self._on_widget_destroy, "+")
 
@@ -517,14 +497,14 @@ def _cancel_timer(self, name: str) -> None:
     def _cancel_show(self) -> None:
         self._cancel_timer("show")
 
-    def show(self, event: Optional[tk.Event] = None) -> None:  # noqa: ARG002 # pylint: disable=unused-argument
-        """On non-macOS, tooltip already exists, show it on events."""
-        self._cancel_hide()
-        self._hide_active_tooltip()
-        if self.tooltip:
-            self.position_tooltip()
-            self.tooltip.deiconify()
-            Tooltip._active_tooltip = self
+    # def show(self, event: Optional[tk.Event] = None) -> None:  # pylint: disable=unused-argument
+    #     """On non-macOS, tooltip already exists, show it on events."""
+    #     self._cancel_hide()
+    #     self._hide_active_tooltip()
+    #     if self.tooltip:
+    #         self.position_tooltip()
+    #         self.tooltip.deiconify()
+    #         Tooltip._active_tooltip = self
 
     def _cancel_hide(self, event: Optional[tk.Event] = None) -> None:  # noqa: ARG002 # pylint: disable=unused-argument
         self._cancel_timer("hide")
@@ -589,7 +569,7 @@ def create_show(self, event: Optional[tk.Event] = None) -> None:  # noqa: ARG002
                 "noActivates",
             )
             self.tooltip.configure(bg="#ffffe0")
-        except AttributeError:  # Catches protected member access error
+        except (AttributeError, tk.TclError):  # Catches protected member access error
             self.tooltip.wm_attributes("-alpha", 1.0)  # Ensure opacity
             self.tooltip.wm_attributes("-topmost", True)  # Keep on top # noqa: FBT003
             self.tooltip.configure(bg="#ffffe0")
@@ -652,30 +632,27 @@ def position_tooltip(self) -> None:
             # Silently ignore - tooltip will be recreated on next hover if needed
             pass
 
-    def hide(self, event: Optional[tk.Event] = None) -> None:  # noqa: ARG002 # pylint: disable=unused-argument
-        """Hide the tooltip after a delay on non-macOS."""
-        self._cancel_hide()
-        self.timers["hide"] = self.widget.after(TOOLTIP_HIDE_DELAY_MS, self._do_hide)
+    # def hide(self, event: Optional[tk.Event] = None) -> None:  # pylint: disable=unused-argument
+    #     """Hide the tooltip after a delay on non-macOS."""
+    #     self._cancel_hide()
+    #     self.timers["hide"] = self.widget.after(TOOLTIP_HIDE_DELAY_MS, self._do_hide)
 
-    def _do_hide(self) -> None:
-        """Actually hide or destroy the tooltip depending on platform."""
-        if self.tooltip:
-            self.tooltip.withdraw()
-        if Tooltip._active_tooltip is self:
-            Tooltip._active_tooltip = None
-        self.timers.pop("hide", None)
+    # def _do_hide(self) -> None:
+    #     """Actually hide or destroy the tooltip depending on platform."""
+    #     if self.tooltip:
+    #         self.tooltip.withdraw()
+    #     if Tooltip._active_tooltip is self:
+    #         Tooltip._active_tooltip = None
+    #     self.timers.pop("hide", None)
 
     def force_hide(self) -> None:
         """Immediately hide or destroy the tooltip, depending on platform."""
         self._cancel_show()
         self._cancel_hide()
         self._cancel_timer("alpha")
         if self.tooltip:
-            if platform_system() == "Darwin":
-                self.tooltip.destroy()
-                self.tooltip = None
-            else:
-                self.tooltip.withdraw()
+            self.tooltip.destroy()
+            self.tooltip = None
         if Tooltip._active_tooltip is self:
             Tooltip._active_tooltip = None