matplotlib
diff --git a/‎lib/matplotlib/backend_bases.py‎
Lines changed: 103 additions & 46 deletions b/‎lib/matplotlib/backend_bases.py‎
Lines changed: 103 additions & 46 deletions
diff --git a/‎lib/matplotlib/backends/backend_agg.py‎
Lines changed: 6 additions & 21 deletions b/‎lib/matplotlib/backends/backend_agg.py‎
Lines changed: 6 additions & 21 deletions
diff --git a/‎lib/matplotlib/backends/backend_cairo.py‎
Lines changed: 10 additions & 6 deletions b/‎lib/matplotlib/backends/backend_cairo.py‎
Lines changed: 10 additions & 6 deletions
diff --git a/‎lib/matplotlib/backends/backend_gdk.py‎
Lines changed: 8 additions & 19 deletions b/‎lib/matplotlib/backends/backend_gdk.py‎
Lines changed: 8 additions & 19 deletions
diff --git a/‎lib/matplotlib/backends/backend_gtk.py‎
Lines changed: 19 additions & 42 deletions b/‎lib/matplotlib/backends/backend_gtk.py‎
Lines changed: 19 additions & 42 deletions
@@ -52,12 +52,11 @@
 import matplotlib.colors as colors
 import matplotlib.transforms as transforms
 import matplotlib.widgets as widgets
-#import matplotlib.path as path
 from matplotlib import rcParams
 from matplotlib import is_interactive
 from matplotlib import get_backend
-from matplotlib._pylab_helpers import Gcf
 from matplotlib import lines
+from matplotlib._pylab_helpers import Gcf
 
 from matplotlib.transforms import Bbox, TransformedBbox, Affine2D
 
@@ -142,60 +141,118 @@ def get_registered_canvas_class(format):
     return backend_class
 
 
-class ShowBase(object):
-    """
-    Simple base class to generate a show() callable in backends.
+class _Backend(object):
+    # A backend can be defined by using the following pattern:
+    #
+    # @_Backend.export
+    # class FooBackend(_Backend):
+    #     # override the attributes and methods documented below.
 
-    Subclass must override mainloop() method.
-    """
-    def __call__(self, block=None):
+    # The following attributes and methods must be overridden by subclasses.
+
+    # The `FigureCanvas` and `FigureManager` classes must be defined.
+    FigureCanvas = None
+    FigureManager = None
+
+    # The following methods must be left as None for non-interactive backends.
+    # For interactive backends, `trigger_manager_draw` should be a function
+    # taking a manager as argument and triggering a canvas draw, and `mainloop`
+    # should be a function taking no argument and starting the backend main
+    # loop.
+    trigger_manager_draw = None
+    mainloop = None
+
+    # The following methods will be automatically defined and exported, but
+    # can be overridden.
+
+    @classmethod
+    def new_figure_manager(cls, num, *args, **kwargs):
+        """Create a new figure manager instance.
+        """
+        # This import needs to happen here due to circular imports.
+        from matplotlib.figure import Figure
+        fig_cls = kwargs.pop('FigureClass', Figure)
+        fig = fig_cls(*args, **kwargs)
+        return cls.new_figure_manager_given_figure(num, fig)
+
+    @classmethod
+    def new_figure_manager_given_figure(cls, num, figure):
+        """Create a new figure manager instance for the given figure.
         """
-        Show all figures.  If *block* is not None, then
-        it is a boolean that overrides all other factors
-        determining whether show blocks by calling mainloop().
-        The other factors are:
-        it does not block if run inside ipython's "%pylab" mode
-        it does not block in interactive mode.
+        canvas = cls.FigureCanvas(figure)
+        manager = cls.FigureManager(canvas, num)
+        return manager
+
+    @classmethod
+    def draw_if_interactive(cls):
+        if cls.trigger_manager_draw is not None and is_interactive():
+            manager = Gcf.get_active()
+            if manager:
+                cls.trigger_manager_draw()
+
+    @classmethod
+    def show(cls, block=None):
+        """Show all figures.
+
+        `show` blocks by calling `mainloop` if *block* is ``True``, or if it
+        is ``None`` and we are neither in IPython's ``%pylab`` mode, nor in
+        `interactive` mode.
         """
+        if cls.mainloop is None:
+            return
         managers = Gcf.get_all_fig_managers()
         if not managers:
             return
-
         for manager in managers:
             manager.show()
+        if block is None:
+            # Hack: Are we in IPython's pylab mode?
+            from matplotlib import pyplot
+            try:
+                # IPython versions >= 0.10 tack the _needmain attribute onto
+                # pyplot.show, and always set it to False, when in %pylab mode.
+                ipython_pylab = not pyplot.show._needmain
+            except AttributeError:
+                ipython_pylab = False
+            block = not ipython_pylab and not is_interactive()
+            # TODO: The above is a hack to get the WebAgg backend working with
+            # ipython's `%pylab` mode until proper integration is implemented.
+            if get_backend() == "WebAgg":
+                block = True
+        if block:
+            cls.mainloop()
+
+    # This method is the one actually exporting the required methods.
+
+    @staticmethod
+    def export(cls):
+        for name in ["FigureCanvas",
+                     "FigureManager",
+                     "new_figure_manager",
+                     "new_figure_manager_given_figure",
+                     "draw_if_interactive",
+                     "show"]:
+            setattr(sys.modules[cls.__module__], name, getattr(cls, name))
+
+        # For back-compatibility, generate a shim `Show` class.
+
+        class Show(ShowBase):
+            def mainloop(self):
+                return cls.mainloop()
+
+        setattr(sys.modules[cls.__module__], "Show", Show)
+        return cls
+
+
+class ShowBase(_Backend):
+    """
+    Simple base class to generate a show() callable in backends.
 
-        if block is not None:
-            if block:
-                self.mainloop()
-                return
-            else:
-                return
-
-        # Hack: determine at runtime whether we are
-        # inside ipython in pylab mode.
-        from matplotlib import pyplot
-        try:
-            ipython_pylab = not pyplot.show._needmain
-            # IPython versions >= 0.10 tack the _needmain
-            # attribute onto pyplot.show, and always set
-            # it to False, when in %pylab mode.
-            ipython_pylab = ipython_pylab and get_backend() != 'WebAgg'
-            # TODO: The above is a hack to get the WebAgg backend
-            # working with ipython's `%pylab` mode until proper
-            # integration is implemented.
-        except AttributeError:
-            ipython_pylab = False
-
-        # Leave the following as a separate step in case we
-        # want to control this behavior with an rcParam.
-        if ipython_pylab:
-            return
-
-        if not is_interactive() or get_backend() == 'WebAgg':
-            self.mainloop()
+    Subclass must override mainloop() method.
+    """
 
-    def mainloop(self):
-        pass
+    def __call__(self, block=None):
+        return self.show(block=block)
 
 
 class RendererBase(object):
 
@@ -29,8 +29,8 @@
 from collections import OrderedDict
 from math import radians, cos, sin
 from matplotlib import verbose, rcParams, __version__
-from matplotlib.backend_bases import (RendererBase, FigureManagerBase,
-                                      FigureCanvasBase)
+from matplotlib.backend_bases import (
+    _Backend, FigureCanvasBase, FigureManagerBase, RendererBase)
 from matplotlib.cbook import maxdict, restrict_dict
 from matplotlib.figure import Figure
 from matplotlib.font_manager import findfont, get_font
@@ -397,24 +397,6 @@ def post_processing(image, dpi):
                 gc, l + ox, height - b - h + oy, img)
 
 
-def new_figure_manager(num, *args, **kwargs):
-    """
-    Create a new figure manager instance
-    """
-    FigureClass = kwargs.pop('FigureClass', Figure)
-    thisFig = FigureClass(*args, **kwargs)
-    return new_figure_manager_given_figure(num, thisFig)
-
-
-def new_figure_manager_given_figure(num, figure):
-    """
-    Create a new figure manager instance for the given figure.
-    """
-    canvas = FigureCanvasAgg(figure)
-    manager = FigureManagerBase(canvas, num)
-    return manager
-
-
 class FigureCanvasAgg(FigureCanvasBase):
     """
     The canvas the figure renders into.  Calls the draw and print fig
@@ -609,4 +591,7 @@ def print_tif(self, filename_or_obj, *args, **kwargs):
         print_tiff = print_tif
 
 
-FigureCanvas = FigureCanvasAgg
+@_Backend.export
+class _BackendAgg(_Backend):
+    FigureCanvas = FigureCanvasAgg
+    FigureManager = FigureManagerBase
@@ -52,11 +52,12 @@
 del _version_required
 
 from matplotlib.backend_bases import (
-    RendererBase, GraphicsContextBase, FigureManagerBase, FigureCanvasBase)
-from matplotlib.figure       import Figure
-from matplotlib.mathtext     import MathTextParser
-from matplotlib.path         import Path
-from matplotlib.transforms   import Bbox, Affine2D
+    _Backend, FigureCanvasBase, FigureManagerBase, GraphicsContextBase,
+    RendererBase)
+from matplotlib.figure import Figure
+from matplotlib.mathtext import MathTextParser
+from matplotlib.path import Path
+from matplotlib.transforms import Bbox, Affine2D
 from matplotlib.font_manager import ttfFontProperty
 
 
@@ -549,4 +550,7 @@ def _save(self, fo, fmt, **kwargs):
             fo.close()
 
 
-FigureCanvas = FigureCanvasCairo
+@_Backend.export
+class _BackendCairo(_Backend):
+    FigureCanvas = FigureCanvasCairo
+    FigureManager = FigureManagerBase
@@ -24,7 +24,8 @@
 from matplotlib import rcParams
 from matplotlib._pylab_helpers import Gcf
 from matplotlib.backend_bases import (
-    RendererBase, GraphicsContextBase, FigureManagerBase, FigureCanvasBase)
+    _Backend, FigureCanvasBase, FigureManagerBase, GraphicsContextBase,
+    RendererBase)
 from matplotlib.cbook import restrict_dict, warn_deprecated
 from matplotlib.figure import Figure
 from matplotlib.mathtext import MathTextParser
@@ -381,24 +382,6 @@ def set_linewidth(self, w):
             self.gdkGC.line_width = max(1, int(np.round(pixels)))
 
 
-def new_figure_manager(num, *args, **kwargs):
-    """
-    Create a new figure manager instance
-    """
-    FigureClass = kwargs.pop('FigureClass', Figure)
-    thisFig = FigureClass(*args, **kwargs)
-    return new_figure_manager_given_figure(num, thisFig)
-
-
-def new_figure_manager_given_figure(num, figure):
-    """
-    Create a new figure manager instance for the given figure.
-    """
-    canvas  = FigureCanvasGDK(figure)
-    manager = FigureManagerBase(canvas, num)
-    return manager
-
-
 class FigureCanvasGDK (FigureCanvasBase):
     def __init__(self, figure):
         FigureCanvasBase.__init__(self, figure)
@@ -452,3 +435,9 @@ def _print_image(self, filename, format, *args, **kwargs):
             options['quality'] = str(options['quality'])
 
         pixbuf.save(filename, format, options=options)
+
+
+@_Backend.export
+class _BackendGDK(_Backend):
+    FigureCanvas = FigureCanvasGDK
+    FigureManager = FigureManagerBase
@@ -28,15 +28,14 @@
 
 import matplotlib
 from matplotlib._pylab_helpers import Gcf
-from matplotlib.backend_bases import RendererBase, GraphicsContextBase, \
-     FigureManagerBase, FigureCanvasBase, NavigationToolbar2, cursors, TimerBase
-from matplotlib.backend_bases import ShowBase
+from matplotlib.backend_bases import (
+    _Backend, FigureCanvasBase, FigureManagerBase, NavigationToolbar2,
+    TimerBase, cursors)
 
 from matplotlib.backends.backend_gdk import RendererGDK, FigureCanvasGDK
-from matplotlib.cbook import is_writable_file_like
+from matplotlib.cbook import is_writable_file_like, warn_deprecated
 from matplotlib.figure import Figure
 from matplotlib.widgets import SubplotTool
-from matplotlib.cbook import warn_deprecated
 
 from matplotlib import (
     cbook, colors as mcolors, lines, markers, rcParams, verbose)
@@ -63,41 +62,6 @@ def GTK_WIDGET_DRAWABLE(w):
     return flags & gtk.VISIBLE != 0 and flags & gtk.MAPPED != 0
 
 
-def draw_if_interactive():
-    """
-    Is called after every pylab drawing command
-    """
-    if matplotlib.is_interactive():
-        figManager =  Gcf.get_active()
-        if figManager is not None:
-            figManager.canvas.draw_idle()
-
-
-class Show(ShowBase):
-    def mainloop(self):
-        if gtk.main_level() == 0:
-            gtk.main()
-
-show = Show()
-
-def new_figure_manager(num, *args, **kwargs):
-    """
-    Create a new figure manager instance
-    """
-    FigureClass = kwargs.pop('FigureClass', Figure)
-    thisFig = FigureClass(*args, **kwargs)
-    return new_figure_manager_given_figure(num, thisFig)
-
-
-def new_figure_manager_given_figure(num, figure):
-    """
-    Create a new figure manager instance for the given figure.
-    """
-    canvas = FigureCanvasGTK(figure)
-    manager = FigureManagerGTK(canvas, num)
-    return manager
-
-
 class TimerGTK(TimerBase):
     '''
     Subclass of :class:`backend_bases.TimerBase` using GTK for timer events.
@@ -521,6 +485,7 @@ def stop_event_loop(self):
         FigureCanvasBase.stop_event_loop_default(self)
     stop_event_loop.__doc__=FigureCanvasBase.stop_event_loop_default.__doc__
 
+
 class FigureManagerGTK(FigureManagerBase):
     """
     Attributes
@@ -866,6 +831,7 @@ def get_filename_from_user (self):
 
         return filename, self.ext
 
+
 class DialogLineprops(object):
     """
     A GUI dialog for controlling lineprops
@@ -1056,5 +1022,16 @@ def error_msg_gtk(msg, parent=None):
     dialog.destroy()
 
 
-FigureCanvas = FigureCanvasGTK
-FigureManager = FigureManagerGTK
+@_Backend.export
+class _BackendGTK(_Backend):
+    FigureCanvas = FigureCanvasGTK
+    FigureManager = FigureManagerGTK
+
+    @staticmethod
+    def trigger_manager_draw(manager):
+        manager.canvas.draw_idle()
+
+    @staticmethod
+    def mainloop():
+        if gtk.main_level() == 0:
+            gtk.main()