Non-interactive FigureManager classes are now aliases of FigureManagerBase

The `FigureManagerPdf`, `FigureManagerPS`, and `FigureManagerSVG` classes,

which were previously empty subclasses of `FigureManagerBase` (i.e., not

adding or overriding any attribute or method), are now direct aliases for

`FigureManagerBase`.

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.

# `backend_version` may be overridden by the subclass.

backend_version = "unknown"

# The `FigureCanvas` class must be defined.

FigureCanvas = None

# For interactive backends, the `FigureManager` class must be overridden.

FigureManager = FigureManagerBase

# 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.

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(manager)

@classmethod

def show(cls, block=None):

"""Show all figures.

managers = Gcf.get_all_fig_managers()

if not managers:

return

for manager in managers:

# Emits a warning if the backend is non-interactive.

manager.canvas.figure.show()

if cls.mainloop is None:

return

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 ["backend_version",

"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):

"""

def __call__(self, block=None):

return self.show(block=block)

import importlib

from matplotlib.backend_bases import _Backend

backend_name = (name[9:] if name.startswith("module://")

else "matplotlib.backends.backend_{}".format(name.lower()))

backend_mod = importlib.import_module(backend_name)

# Create a local Backend class whose body corresponds to the contents of

# the backend module. This allows the Backend class to fill in the missing

# methods through inheritance.

Backend = type("Backend", (_Backend,), vars(backend_mod))

_log.debug('backend %s version %s', name, Backend.backend_version)

return (backend_mod,

Backend.new_figure_manager,

Backend.draw_if_interactive,

Backend.show)

FigureManagerPdf = FigureManagerBase

FigureManagerPS = FigureManagerBase