fix: adressed copilot

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

Author: OmkarSarkar204

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_table.py

@@ -100,6 +100,8 @@ def __init__(
         self._gui_complexity: str = ""
         self._is_loading: bool = False
         self._add_button_widget: Optional[ttk.Button] = None
+        self._page_scroll_after_id: Optional[str] = None
+        self._page_scroll_destroy_binding_registered: bool = False
 
         style = ttk.Style()
         style.configure("narrow.TButton", padding=0, width=4, border=(0, 0, 0, 0))
@@ -226,7 +228,15 @@ 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:
-        """Initialize scroll load."""
+        """
+        Update the table from a new parameter set and start incremental rendering.
+
+        This method is the entry point used when the table is rebuilt for a
+        fresh ``params`` mapping. It resets the incremental-load state, stores
+        the active GUI complexity, renders the first batch of rows immediately
+        (currently 20 parameters), and then starts the page-scroll/polling
+        mechanism that loads additional chunks as needed.
+        """
         self._params_list = list(params.items())
         self._total_params = len(self._params_list)
         self._current_idx = 0
@@ -291,18 +301,52 @@ def _load_next_chunk(self, chunk_size: int = 15) -> None:
         self.canvas.configure(scrollregion=self.canvas.bbox("all"))
         self._is_loading = False
 
+    def _cancel_page_scroll_after(self) -> None:
+        """Cancel any scheduled page-scroll polling callback."""
+        after_id = getattr(self, "_page_scroll_after_id", None)
+        if not after_id:
+            return
+        try:
+            self.after_cancel(after_id)
+        except tk.TclError:
+            pass
+        finally:
+            self._page_scroll_after_id = None
+
+    def _on_destroy_cancel_page_scroll(self, _event: Optional[tk.Event] = None) -> None:
+        """Stop page-scroll polling when the widget is being destroyed."""
+        self._cancel_page_scroll_after()
+
     def _page_scroll(self) -> None:
         """Load more items when reaching the bottom."""
-        if not self.winfo_exists() or self._current_idx >= self._total_params:
+        self._page_scroll_after_id = None
+
+        # 1. ALWAYS check if the widget exists FIRST before doing Tkinter operations
+        if not self.winfo_exists():
+            self._cancel_page_scroll_after()
+            return
+
+        # 2. Now it is safe to bind events
+        if not getattr(self, "_page_scroll_destroy_binding_registered", False):
+            self.bind("<Destroy>", self._on_destroy_cancel_page_scroll, add="+")
+            self._page_scroll_destroy_binding_registered = True
+
+        # 3. Check if we are done loading
+        if self._current_idx >= self._total_params:
+            self._cancel_page_scroll_after()
             return
 
         try:
             if self.canvas.yview()[1] > 0.85:
                 self._load_next_chunk(chunk_size=15)
         except tk.TclError:
-            pass
+            return
 
-        self.after(150, self._page_scroll)
+        if self.winfo_exists() and self._current_idx < self._total_params:
+            try:
+                self._page_scroll_after_id = self.after(150, self._page_scroll)
+            except tk.TclError:
+                self._page_scroll_after_id = None
 
     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_scroll_frame.py

@@ -88,7 +88,8 @@ def on_mouse_wheel(self, event: tk.Event) -> None:  # cross platform scroll whee
         if not hasattr(self, "canvas") or not self.canvas.winfo_exists():
             return  # The widget was destroyed, ignore the scroll event
         canvas_height = self.canvas.winfo_height()
-        rows_height = self.canvas.bbox("all")[3]
+        bbox = self.canvas.bbox("all")
+        rows_height = bbox[3] if bbox is not None else 0
 
         if rows_height > canvas_height:  # only scroll if the rows overflow the frame
             if platform_system() == "Windows":

ardupilot_methodic_configurator/frontend_tkinter_show.py

@@ -525,7 +525,7 @@ def schedule_show(self, _event: Optional[tk.Event] = None) -> None:
         self.timers["show"] = self.widget.after(TOOLTIP_SHOW_DELAY_MS, self.create_show)
 
     def create_show(self, _event: Optional[tk.Event] = None) -> None:
-        """On macOS, only create the tooltip when the mouse enters the widget."""
+        """Create and show the tooltip when the pointer is still over the widget after the delay."""
         self._cancel_show()
         self._cancel_hide()
 

tests/bdd_frontend_tkinter_show.py

@@ -990,7 +990,7 @@ def test_tooltip_no_position_when_tooltip_none(self, mock_widget) -> None:
 
     def test_tooltip_force_hide_destroys_globally(self, mock_widget, mock_toplevel) -> None:
         """
-        Test tooltip _do_hide withdraws tooltip on non-macOS.
+        Test tooltip force_hide destroys the tooltip globally across all OSs and clears the active tooltip.
 
         GIVEN: Tooltip on non-macOS platform
         WHEN: _do_hide is called
@@ -1074,7 +1074,8 @@ def test_tooltip_with_custom_toplevel_class(self, mock_widget, mock_toplevel) ->
             tooltip.create_show()  # Trigger lazy load
 
         # Assert: Custom class was used
-        custom_toplevel_class.assert_called_once()
+        custom_toplevel_class.assert_called_once_with(mock_widget, bg="#ffffe0")
+        assert tooltip.tooltip == mock_toplevel
 
     def test_tooltip_position_below_false(self, mock_widget, mock_toplevel) -> None:
         """