FIX: overhaul backend class management + fix Tk backend

Not clear that the semantics of `FigureManager._active_managers` is correct.
It is currently only non-None when in a blocking show (rather than when letting
the input hook handle things).

Author: tacaswell

mpl_gui/__init__.py

@@ -17,12 +17,12 @@
 from itertools import count
 
 from matplotlib.backend_bases import FigureCanvasBase as _FigureCanvasBase
-from matplotlib.cbook import _setattr_cm
 
 from ._figure import Figure  # noqa: F401
 
 from ._manage_interactive import ion, ioff, is_interactive  # noqa: F401
-from ._manage_backend import select_gui_toolkit, current_backend_module as _cbm
+from ._manage_backend import select_gui_toolkit  # noqa: F401
+from ._manage_backend import current_backend_module as _cbm
 from ._promotion import promote_figure as promote_figure
 from ._creation import figure, subplots, subplot_mosaic  # noqa: F401
 
@@ -70,17 +70,12 @@ def show(figs, *, block=None, timeout=0):
         else:
             managers.append(promote_figure(fig))
 
-    for manager in managers:
-        manager.show()
-        manager.canvas.draw_idle()
-
     if block is None:
         block = not is_interactive()
 
     if block and len(managers):
         if timeout == 0:
-            with _setattr_cm(backend, get_active_managers=lambda: managers):
-                backend.mainloop()
+            backend.show_managers(managers=managers, block=block)
         elif len(managers):
             manager, *_ = managers
             manager.canvas.start_event_loop(timeout=timeout)

mpl_gui/_manage_backend.py

@@ -1,6 +1,7 @@
 import importlib
 import sys
 import logging
+import types
 
 from matplotlib import cbook, rcsetup
 from matplotlib import rcParams, rcParamsDefault
@@ -96,24 +97,48 @@ def select_gui_toolkit(newbackend=None):
 
         mod = importlib.import_module(backend_name)
         if hasattr(mod, "Backend"):
-            backend_mod = mod.Backend
+            orig_class = mod.Backend
+
         else:
-            class backend_mod(matplotlib.backend_bases._Backend):
+
+            class orig_class(matplotlib.backend_bases._Backend):
                 locals().update(vars(mod))
 
                 @classmethod
                 def mainloop(cls):
                     return mod.Show().mainloop()
 
+        class BackendClass(orig_class):
+            @classmethod
+            def show_managers(cls, *, managers, block):
+                if not managers:
+                    return
+                for manager in managers:
+                    manager.show()  # Emits a warning for non-interactive backend
+                    manager.canvas.draw_idle()
+                if cls.mainloop is None:
+                    return
+                if block:
+                    try:
+                        cls.FigureManager._active_managers = managers
+                        cls.mainloop()
+                    finally:
+                        cls.FigureManager._active_managers = None
+
+        if not hasattr(BackendClass.FigureManager, "_active_managers"):
+            BackendClass.FigureManager._active_managers = None
         rc_params_string = newbackend
 
     else:
-        backend_mod = newbackend
-        rc_params_string = f"module://_backend_mod_{id(backend_mod)}"
-        sys.modules[rc_params_string] = backend_mod
+        BackendClass = newbackend
+        mod_name = f"_backend_mod_{id(BackendClass)}"
+        rc_params_string = f"module://{mod_name}"
+        mod = types.ModuleType(mod_name)
+        mod.Backend = BackendClass
+        sys.modules[mod_name] = mod
 
     required_framework = getattr(
-        backend_mod.FigureCanvas, "required_interactive_framework", None
+        BackendClass.FigureCanvas, "required_interactive_framework", None
     )
     if required_framework is not None:
         current_framework = cbook._get_running_interactive_framework()
@@ -129,10 +154,11 @@ def mainloop(cls):
                 )
             )
 
-    _log.debug("Loaded backend %s version %s.", newbackend, backend_mod.backend_version)
+    _log.debug(
+        "Loaded backend %s version %s.", newbackend, BackendClass.backend_version
+    )
 
     rcParams["backend"] = rcParamsDefault["backend"] = rc_params_string
-    _backend_mod = backend_mod
 
     # is IPython imported?
     mod_ipython = sys.modules.get("IPython")
@@ -141,4 +167,7 @@ def mainloop(cls):
         ip = mod_ipython.get_ipython()
         if ip:
             ip.enable_gui(required_framework)
-    return _backend_mod
+
+    # remember to set the global variable
+    _backend_mod = BackendClass
+    return BackendClass

mpl_gui/_patched_backends/tkagg.py

@@ -1,15 +1,65 @@
-from matplotlib.backends.backend_tkagg import _BackendTkAgg
+from contextlib import contextmanager
+
+import matplotlib as mpl
+from matplotlib import _c_internal_utils
+from matplotlib.backends.backend_tkagg import (
+    _BackendTkAgg,
+    FigureManagerTk as _FigureManagerTk,
+)
+
+
+@contextmanager
+def _restore_foreground_window_at_end():
+    foreground = _c_internal_utils.Win32_GetForegroundWindow()
+    try:
+        yield
+    finally:
+        if mpl.rcParams["tk.window_focus"]:
+            _c_internal_utils.Win32_SetForegroundWindow(foreground)
+
+
+class FigureManagerTk(_FigureManagerTk):
+    _active_managers = None
+
+    def show(self):
+        with _restore_foreground_window_at_end():
+            if not self._shown:
+                self.window.protocol("WM_DELETE_WINDOW", self.destroy)
+                self.window.deiconify()
+                self.canvas._tkcanvas.focus_set()
+            else:
+                self.canvas.draw_idle()
+            if mpl.rcParams["figure.raise_window"]:
+                self.canvas.manager.window.attributes("-topmost", 1)
+                self.canvas.manager.window.attributes("-topmost", 0)
+            self._shown = True
+
+    def destroy(self, *args):
+        if self.canvas._idle_draw_id:
+            self.canvas._tkcanvas.after_cancel(self.canvas._idle_draw_id)
+        if self.canvas._event_loop_id:
+            self.canvas._tkcanvas.after_cancel(self.canvas._event_loop_id)
+
+        # NOTE: events need to be flushed before issuing destroy (GH #9956),
+        # however, self.window.update() can break user code. This is the
+        # safest way to achieve a complete draining of the event queue,
+        # but it may require users to update() on their own to execute the
+        # completion in obscure corner cases.
+        def delayed_destroy():
+            self.window.destroy()
+
+            if self._owns_mainloop and not self._active_managers:
+                self.window.quit()
+
+        # "after idle after 0" avoids Tcl error/race (GH #19940)
+        self.window.after_idle(self.window.after, 0, delayed_destroy)
 
 
 @_BackendTkAgg.export
 class _PatchedBackendTkAgg(_BackendTkAgg):
-    @staticmethod
-    def get_active_managers():
-        raise RuntimeError("This method should never actually be called")
-
     @classmethod
     def mainloop(cls):
-        managers = cls.get_active_managers()
+        managers = cls.FigureManager._active_managers
         if managers:
             first_manager = managers[0]
             manager_class = type(first_manager)
@@ -21,5 +71,7 @@ def mainloop(cls):
             finally:
                 manager_class._owns_mainloop = False
 
+    FigureManager = FigureManagerTk
+
 
 Backend = _PatchedBackendTkAgg

mpl_gui/tests/conftest.py

@@ -22,6 +22,8 @@ def start_event_loop(self, timeout=0):
 
 
 class TestManger(FigureManagerBase):
+    _active_managers = None
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.call_info = {}
@@ -47,5 +49,10 @@ class TestingBackend(_Backend):
     def mainloop(cls):
         ...
 
+    @classmethod
+    def show_managers(cls, *, managers, block):
+        for m in managers:
+            m.show()
+
 
 mpl_gui.select_gui_toolkit(TestingBackend)