fix(frontend_tkinter_show): 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_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,15 +497,6 @@ 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 _cancel_hide(self, event: Optional[tk.Event] = None) -> None:  # noqa: ARG002 # pylint: disable=unused-argument
         self._cancel_timer("hide")
 
@@ -547,14 +518,14 @@ def _hide_active_tooltip(self) -> None:
                 Tooltip._active_tooltip.force_hide()
             Tooltip._active_tooltip = None
 
-    def schedule_show(self, event: Optional[tk.Event] = None) -> None:  # noqa: ARG002 # pylint: disable=unused-argument
+    def schedule_show(self, _event: Optional[tk.Event] = None) -> None:
         """Delay tooltip creation slightly to avoid flicker during pointer movement."""
         self._cancel_hide()
         self._cancel_show()
         self.timers["show"] = self.widget.after(TOOLTIP_SHOW_DELAY_MS, self.create_show)
 
-    def create_show(self, event: Optional[tk.Event] = None) -> None:  # noqa: ARG002 # pylint: disable=unused-argument
-        """On macOS, only create the tooltip when the mouse enters the widget."""
+    def create_show(self, _event: Optional[tk.Event] = None) -> None:
+        """Create and show the tooltip when the pointer is still over the widget after the delay."""
         self._cancel_show()
         self._cancel_hide()
 
@@ -589,7 +560,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 +623,14 @@ 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 _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."""
+        """Immediately destroy the tooltip globally across all OSs."""
         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
 

tests/bdd_frontend_tkinter_show.py

@@ -23,7 +23,6 @@
 import pytest
 
 from ardupilot_methodic_configurator.frontend_tkinter_show import (
-    TOOLTIP_HIDE_DELAY_MS,
     TOOLTIP_SHOW_DELAY_MS,
     MonitorBounds,
     Tooltip,
@@ -747,19 +746,15 @@ def test_tooltip_initialization_non_macos(self, mock_widget: MagicMock, mock_top
         with (
             patch("ardupilot_methodic_configurator.frontend_tkinter_show.platform_system", return_value="Linux"),
             patch("tkinter.Toplevel", return_value=mock_toplevel),
-            patch("tkinter.ttk.Label") as mock_label,
+            patch("tkinter.ttk.Label"),
         ):
             tooltip = Tooltip(mock_widget, "Test text")
 
-            # Check that Toplevel was created
-            assert tooltip.tooltip == mock_toplevel
+            # Check that Toplevel was NOT created yet (Lazy Loading)
+            assert tooltip.tooltip is None
             # Check bindings
-            mock_widget.bind.assert_any_call("<Enter>", tooltip.show, "+")
-            mock_widget.bind.assert_any_call("<Leave>", tooltip.hide, "+")
-            # Check tooltip setup
-            mock_toplevel.wm_overrideredirect.assert_called_with(boolean=True)
-            mock_label.assert_called_once()
-            mock_toplevel.withdraw.assert_called_once()
+            mock_widget.bind.assert_any_call("<Enter>", tooltip.schedule_show, "+")
+            mock_widget.bind.assert_any_call("<Leave>", tooltip.destroy_hide, "+")
 
     def test_tooltip_initialization_macos(self, mock_widget: MagicMock) -> None:
         """
@@ -822,10 +817,10 @@ def test_tooltip_position_tooltip(self, mock_widget, mock_toplevel) -> None:
             ),
         ):
             tooltip = Tooltip(mock_widget, "Test text")
+            mock_widget.winfo_containing.return_value = mock_widget  # Tell the test the mouse is hovering
+            tooltip.create_show()
 
-            tooltip.position_tooltip()
-
-            # Check that geometry was set
+            # Check that geometry was set (create_show did this automatically!)
             mock_toplevel.geometry.assert_called_once()
             # The call should be with calculated position
             call_args = mock_toplevel.geometry.call_args[0][0]
@@ -844,9 +839,10 @@ def test_tooltip_show_non_macos(self, mock_widget, mock_toplevel) -> None:
             patch("tkinter.ttk.Label"),
             patch("ardupilot_methodic_configurator.frontend_tkinter_show.platform_system", return_value="Linux"),
         ):
+            mock_widget.winfo_containing.return_value = mock_widget
             tooltip = Tooltip(mock_widget, "Test text")
 
-            tooltip.show()
+            tooltip.create_show()
 
             mock_toplevel.deiconify.assert_called_once()
 
@@ -864,10 +860,12 @@ def test_tooltip_hide(self, mock_widget, mock_toplevel) -> None:
             patch("ardupilot_methodic_configurator.frontend_tkinter_show.platform_system", return_value="Linux"),
         ):
             tooltip = Tooltip(mock_widget, "Test text")
+            tooltip.tooltip = mock_toplevel  # Mock that it was created
+            tooltip.destroy_hide()
 
-            tooltip.hide()
-
-            mock_widget.after.assert_called_once_with(TOOLTIP_HIDE_DELAY_MS, tooltip._do_hide)
+            # As it destroys immediately, check if active_tooltip is cleared
+            assert Tooltip._active_tooltip is None
+            mock_toplevel.destroy.assert_called_once()
 
     def test_tooltip_cancel_hide(self, mock_widget) -> None:
         """
@@ -990,24 +988,27 @@ def test_tooltip_no_position_when_tooltip_none(self, mock_widget) -> None:
 
         # Assert: No exception, no positioning attempted
 
-    def test_tooltip_do_hide_withdraws_on_non_macos(self, mock_widget, mock_toplevel) -> 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
-        THEN: Tooltip is withdrawn
+        GIVEN: Tooltip on any platform
+        WHEN: force_hide is called
+        THEN: Tooltip is destroyed and active tooltip is cleared
         """
         with (
             patch("tkinter.Toplevel", return_value=mock_toplevel),
             patch("tkinter.ttk.Label"),
             patch("ardupilot_methodic_configurator.frontend_tkinter_show.platform_system", return_value="Linux"),
         ):
+            mock_widget.winfo_containing.return_value = mock_widget
             tooltip = Tooltip(mock_widget, "Test text")
+            tooltip.create_show()  # Must create it before we can destroy it
 
-            tooltip._do_hide()
+            tooltip.force_hide()
 
-            mock_toplevel.withdraw.assert_called()
+            mock_toplevel.destroy.assert_called_once()
+            assert tooltip.tooltip is None
 
     def test_tooltip_create_show_avoids_redundant_creation(self, mock_widget, mock_toplevel) -> None:
         """
@@ -1067,10 +1068,13 @@ def test_tooltip_with_custom_toplevel_class(self, mock_widget, mock_toplevel) ->
             patch("ardupilot_methodic_configurator.frontend_tkinter_show.platform_system", return_value="Linux"),
             patch("tkinter.ttk.Label"),
         ):
+            mock_widget.winfo_containing.return_value = mock_widget
             tooltip = Tooltip(mock_widget, "Test text", toplevel_class=custom_toplevel_class)
 
+            tooltip.create_show()  # Trigger lazy load
+
         # Assert: Custom class was used
-        custom_toplevel_class.assert_called_once_with(mock_widget)
+        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:
@@ -1091,9 +1095,10 @@ def test_tooltip_position_below_false(self, mock_widget, mock_toplevel) -> None:
             ),
         ):
             tooltip = Tooltip(mock_widget, "Test text", position_below=False)
-            tooltip.position_tooltip()
+            mock_widget.winfo_containing.return_value = mock_widget  # Tell the test the mouse is hovering
+            tooltip.create_show()
 
-        # Assert: Geometry set (indicates positioning occurred)
+        # Assert: Geometry set
         mock_toplevel.geometry.assert_called_once()
 
     def test_tooltip_create_show_uses_macos_styling(self, mock_widget, mock_toplevel) -> None: