matplotlib.backend_bases #

def func(event: Event) -> Any
For the location events (button and key press/release), if the
mouse is over the Axes, the inaxes attribute of the event will
be set to the Axes the event occurs is over, and
additionally, the variables xdata and ydata attributes will
be set to the mouse location in data coordinates. See KeyEvent
and MouseEvent for more info.
If func is a method, this only stores a weak reference to the
method. Thus, the figure does not influence the lifetime of
the associated object. Usually, you want to make sure that the
object is kept alive throughout the lifetime of the figure by
holding a reference to it.
Examples
def on_press(event):
    print('you pressed', event.button, event.xdata, event.ydata)
cid = canvas.mpl_connect('button_press_event', on_press)
Disconnect the callback with id cid.
Examples
cid = canvas.mpl_connect('button_press_event', on_press)
# ... later
canvas.mpl_disconnect(cid)
classmethod new_manager(figure, num)[source]#
Create a new figure manager for figure, using this canvas class.




    

Notes
This method should not be reimplemented in subclasses. If
custom manager creation logic is needed, please reimplement
FigureManager.create_with_canvas.
new_timer(interval=None, callbacks=None)[source]#
Create a new backend-specific subclass of Timer.
This is useful for getting periodic events through the backend's native
event loop. Implemented only for backends with GUIs.
Parameters:
intervalint
Timer interval in milliseconds.
callbackslist[tuple[callable, tuple, dict]]
Sequence of (func, args, kwargs) where func(*args, **kwargs)
will be executed by the timer every interval.
Callbacks which return False or 0 will be removed from the
timer.
print_figure(filename, dpi=None, facecolor=None, edgecolor=None, orientation='portrait', format=None, *, bbox_inches=None, pad_inches=None, bbox_extra_artists=None, backend=None, **kwargs)[source]#
Render the figure to hardcopy. Set the figure patch face and edge
colors. This is useful because some of the GUIs have a gray figure
face color background and you'll probably want to override this on
hardcopy.
Parameters:
filenamestr or path-like or file-like
The file where the figure is saved.
dpifloat, default: rcParams["savefig.dpi"] (default: 'figure')
The dots per inch to save the figure in.
facecolorcolor or 'auto', default: rcParams["savefig.facecolor"] (default: 'auto')
The facecolor of the figure. If 'auto', use the current figure
facecolor.
edgecolorcolor or 'auto', default: rcParams["savefig.edgecolor"] (default: 'auto')
The edgecolor of the figure. If 'auto', use the current figure
edgecolor.
orientation{'landscape', 'portrait'}, default: 'portrait'
Only currently applies to PostScript printing.
formatstr, optional
Force a specific file format. If not given, the format is inferred
from the filename extension, and if that fails from
rcParams["savefig.format"] (default: 'png').
bbox_inches'tight' or Bbox, default: rcParams["savefig.bbox"] (default: None)
Bounding box in inches: only the given portion of the figure is
saved. If 'tight', try to figure out the tight bbox of the figure.
pad_inchesfloat or 'layout', default: rcParams["savefig.pad_inches"] (default: 0.1)
Amount of padding in inches around the figure when bbox_inches is
'tight'. If 'layout' use the padding from the constrained or
compressed layout engine; ignored if one of those engines is not in
bbox_extra_artistslist of Artist, optional
A list of extra artists that will be considered when the
tight bbox is calculated.
backendstr, optional
Use a non-default backend to render the file, e.g. to render a
png file with the "cairo" backend rather than the default "agg",
or a pdf file with the "pgf" backend rather than the default
"pdf". Note that the default backend is normally sufficient. See
The builtin backends for a list of valid backends for each
file format. Custom backends can be referenced as "module://...".
release_mouse(ax)[source]#
Release the mouse grab held by the Axes ax.
Usually called by the widgets. It is ok to call this even if ax
doesn't have the mouse grab currently.
required_interactive_framework = None#
property scroll_pick_id#
set_cursor(cursor)[source]#
Set the current cursor.
This may have no effect if the backend does not display anything.
If required by the backend, this method should trigger an update in
the backend event loop after the cursor is set, as this method may be
called e.g. before a long-running task during which the GUI is not
updated.
Parameters:
cursorCursors
The cursor to display over the canvas. Note: some backends may
change the cursor for the entire window.
start_event_loop(timeout=0)[source]#
Start a blocking event loop.
Such an event loop is used by interactive functions, such as
ginput and waitforbuttonpress, to wait for
events.
The event loop blocks until a callback function triggers
stop_event_loop, or timeout is reached.
If timeout is 0 or negative, never timeout.
Only interactive backends need to reimplement this method and it relies
on flush_events being properly implemented.
Interactive backends should implement this in a more native way.
stop_event_loop()[source]#
Stop the current blocking event loop.
Interactive backends need to reimplement this to match
start_event_loop
supports_blit = False#
switch_backends(FigureCanvasClass)[source]#
[Deprecated] Instantiate an instance of FigureCanvasClass
This is used for backend switching, e.g., to instantiate a
FigureCanvasPS from a FigureCanvasGTK. Note, deep copying is
not done, so any changes to one of the instances (e.g., setting
figure size or line props), will be reflected in the other
Notes
Deprecated since version 3.8.
class matplotlib.backend_bases.FigureManagerBase(canvas, num)[source]#
Bases: object




    

A backend-independent abstraction of a figure container and controller.
The figure manager is used by pyplot to interact with the window in a
backend-independent way. It's an adapter for the real (GUI) framework that
represents the visual figure on screen.
The figure manager is connected to a specific canvas instance, which in turn
is connected to a specific figure instance. To access a figure manager for
a given figure in user code, you typically use fig.canvas.manager.
GUI backends derive from this class to translate common operations such
as show or resize to the GUI-specific code. Non-GUI backends do not
support these operations and can just use the base class.
This following basic operations are accessible:
Window operations
destroy
full_screen_toggle
resize
get_window_title
set_window_title
Key and mouse button press handling
The figure manager sets up default key and mouse button press handling by
hooking up the key_press_handler to the matplotlib event system. This
ensures the same shortcuts and mouse actions across backends.
Other operations
Subclasses will have additional attributes and functions to access
additional functionality. This is of course backend-specific. For example,
most GUI backends have window and toolbar attributes that give
access to the native GUI widgets of the respective framework.
Attributes:
canvasFigureCanvasBase
The backend-specific canvas instance.
numint or str
The figure number.
key_press_handler_idint
The default key handler cid, when using the toolmanager.
To disable the default key press handling use:
figure.canvas.mpl_disconnect(
    figure.canvas.manager.key_press_handler_id)
button_press_handler_idint
The default mouse button handler cid, when using the toolmanager.
To disable the default button press handling use:
figure.canvas.mpl_disconnect(
    figure.canvas.manager.button_press_handler_id)
classmethod create_with_canvas(canvas_class, figure, num)[source]#
Create a manager for a given figure using a specific canvas_class.
Backends should override this method if they have specific needs for
setting up the canvas or the manager.
destroy()[source]#
full_screen_toggle()[source]#
get_window_title()[source]#
Return the title text of the window containing the figure, or None
if there is no window (e.g., a PS backend).
classmethod pyplot_show(*, block=None)[source]#
Show all figures. This method is the implementation of pyplot.show.
To customize the behavior of pyplot.show, interactive backends
should usually override start_main_loop; if more
customized logic is necessary, pyplot_show can
also be overridden.
Parameters:
blockbool, optional
Whether to block by calling start_main_loop. The default,
None, means to block if we are neither in IPython's %pylab mode
nor in interactive mode.
set_window_title(title)[source]#
Set the title text of the window containing the figure.
This has no effect for non-GUI (e.g., PS) backends.
Examples
>>> fig = plt.figure()
>>> fig.canvas.manager.set_window_title('My figure')
show()[source]#
For GUI backends, show the figure window and redraw.
For non-GUI backends, raise an exception, unless running headless (i.e.
on Linux with an unset DISPLAY); this exception is converted to a
warning in Figure.show.
classmethod start_main_loop()[source]#
Start the main event loop.
This method is called by FigureManagerBase.pyplot_show, which is the
implementation of pyplot.show. To customize the behavior of
pyplot.show, interactive backends should usually override
start_main_loop; if more customized logic is
necessary, pyplot_show can also be overridden.
class matplotlib.backend_bases.GraphicsContextBase[source]#
Bases: object
An abstract base class that provides color, line styles, etc.
copy_properties(gc)[source]#
Copy properties from gc to self.
get_alpha()[source]#
Return the alpha value used for blending - not supported on all
backends.
get_antialiased()[source]#
Return whether the object should try to do antialiased rendering.
get_capstyle()[source]#
Return the CapStyle.
get_clip_path()[source]#
Return the clip path in the form (path, transform), where path
is a Path instance, and transform is
an affine transform to apply to the path before clipping.




    

get_clip_rectangle()[source]#
Return the clip rectangle as a Bbox instance.
get_dashes()[source]#
Return the dash style as an (offset, dash-list) pair.
See set_dashes for details.
Default value is (None, None).
get_forced_alpha()[source]#
Return whether the value given by get_alpha() should be used to
override any other alpha-channel values.
get_gid()[source]#
Return the object identifier if one is set, None otherwise.
get_hatch()[source]#
Get the current hatch style.
get_hatch_color()[source]#
Get the hatch color.
get_hatch_linewidth()[source]#
Get the hatch linewidth.
get_hatch_path(density=6.0)[source]#
Return a Path for the current hatch.
get_joinstyle()[source]#
Return the JoinStyle.
get_linewidth()[source]#
Return the line width in points.
get_rgb()[source]#
Return a tuple of three or four floats from 0-1.
get_sketch_params()[source]#
Return the sketch parameters for the artist.
Returns:
tuple or None
A 3-tuple with the following elements:
scale: The amplitude of the wiggle perpendicular to the
source line.
length: The length of the wiggle along the line.
randomness: The scale factor by which the length is
shrunken or expanded.
May return None if no sketch parameters were set.
True: snap vertices to the nearest pixel center
False: leave vertices as-is
None: (auto) If the path contains only rectilinear line segments,
round to the nearest pixel center
set_alpha(alpha)[source]#
Set the alpha value used for blending - not supported on all backends.
If alpha=None (the default), the alpha components of the
foreground and fill colors will be used to set their respective
transparencies (where applicable); otherwise, alpha will override
them.
set_antialiased(b)[source]#
Set whether object should be drawn with antialiased rendering.
set_capstyle(cs)[source]#
Set how to draw endpoints of lines.
Parameters:
csCapStyle or {'butt', 'projecting', 'round'}

dash_offsetfloat
Distance, in points, into the dash pattern at which to
start the pattern. It is usually set to 0.
dash_listarray-like or None
The on-off sequence as points. None specifies a solid line. All
values must otherwise be non-negative (\(\ge 0\)).
set_sketch_params(scale=None, length=None, randomness=None)[source]#
Set the sketch parameters.
Parameters:
scalefloat, optional
The amplitude of the wiggle perpendicular to the source line, in
pixels. If scale is None, or not provided, no sketch filter will
be provided.
lengthfloat, default: 128
The length of the wiggle along the line, in pixels.
randomnessfloat, default: 16
The scale factor by which the length is shrunken or expanded.
True: snap vertices to the nearest pixel center
False: leave vertices as-is
None: (auto) If the path contains only rectilinear line segments,
round to the nearest pixel center
class matplotlib.backend_bases.KeyEvent(name, canvas, key, x=0, y=0, guiEvent=None)[source]#
Bases: LocationEvent
A key event (key press, key release).
A KeyEvent has a number of special attributes in addition to those defined
by the parent Event and LocationEvent classes.
Attributes:
keyNone or str
The key(s) pressed. Could be None, a single case sensitive Unicode
character ("g", "G", "#", etc.), a special key ("control", "shift",
"f1", "up", etc.) or a combination of the above (e.g., "ctrl+alt+g",
"ctrl+alt+G").
Notes
Modifier keys will be prefixed to the pressed key and will be in the order
"ctrl", "alt", "super". The exception to this rule is when the pressed key
is itself a modifier key, therefore "ctrl+alt" and "alt+control" can both
be valid key values.
Examples
def on_key(event):
    print('you pressed', event.key, event.xdata, event.ydata)
cid = fig.canvas.mpl_connect('key_press_event', on_key)
class matplotlib.backend_bases.LocationEvent(name, canvas, x, y, guiEvent=None, *, modifiers=None)[source]#
Bases: Event




    

An event that has a screen location.
A LocationEvent has a number of special attributes in addition to those
defined by the parent Event class.
Attributes:
x, yint or None
Event location in pixels from bottom left of canvas.
inaxesAxes or None
The Axes instance over which the mouse is, if any.
xdata, ydatafloat or None
Data coordinates of the mouse within inaxes, or None if the mouse
is not over an Axes.
modifiersfrozenset
The keyboard modifiers currently being pressed (except for KeyEvent).
class matplotlib.backend_bases.MouseButton(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]#
Bases: IntEnum
BACK = 8[source]#
FORWARD = 9[source]#
LEFT = 1[source]#
MIDDLE = 2[source]#
RIGHT = 3[source]#
class matplotlib.backend_bases.MouseEvent(name, canvas, x, y, button=None, key=None, step=0, dblclick=False, guiEvent=None, *, modifiers=None)[source]#
Bases: LocationEvent
A mouse event ('button_press_event', 'button_release_event', 'scroll_event', 'motion_notify_event').
A MouseEvent has a number of special attributes in addition to those
defined by the parent Event and LocationEvent classes.
Attributes:
buttonNone or MouseButton or {'up', 'down'}
The button pressed. 'up' and 'down' are used for scroll events.
Note that LEFT and RIGHT actually refer to the "primary" and
"secondary" buttons, i.e. if the user inverts their left and right
buttons ("left-handed setting") then the LEFT button will be the one
physically on the right.
If this is unset, name is "scroll_event", and step is nonzero, then
this will be set to "up" or "down" depending on the sign of step.
keyNone or str
The key pressed when the mouse event triggered, e.g. 'shift'.
See KeyEvent.
Warning
This key is currently obtained from the last 'key_press_event' or
'key_release_event' that occurred within the canvas. Thus, if the
last change of keyboard state occurred while the canvas did not have
focus, this attribute will be wrong. On the other hand, the
modifiers attribute should always be correct, but it can only
report on modifier keys.
stepfloat
The number of scroll steps (positive for 'up', negative for 'down').
This applies only to 'scroll_event' and defaults to 0 otherwise.
dblclickbool
Whether the event is a double-click. This applies only to
'button_press_event' and is False otherwise. In particular, it's
not used in 'button_release_event'.
Examples
def on_press(event):
    print('you pressed', event.button, event.xdata, event.ydata)
cid = fig.canvas.mpl_connect('button_press_event', on_press)
class matplotlib.backend_bases.NavigationToolbar2(canvas)[source]#
Bases: object
Base class for the navigation cursor, version 2.
Backends must implement a canvas that handles connections for
'button_press_event' and 'button_release_event'. See
FigureCanvasBase.mpl_connect() for more information.
They must also define
save_figure()
Save the current figure.
draw_rubberband() (optional)
Draw the zoom to rect "rubberband" rectangle.
set_message() (optional)
Display message.
set_history_buttons() (optional)
You can change the history back / forward buttons to indicate disabled / enabled
state.
and override __init__ to set up the toolbar -- without forgetting to
call the base-class init. Typically, __init__ needs to set up toolbar
buttons connected to the home, back, forward, pan, zoom, and
save_figure methods and using standard icons in the "images" subdirectory
of the data path.
That's it, we'll do the rest!
back(*args)[source]#
Move back up the view lim stack.
For convenience of being directly connected as a GUI callback, which
often get passed additional parameters, this method accepts arbitrary
parameters, but does not use them.
configure_subplots(*args)[source]#
drag_pan(event)[source]#
Callback for dragging in pan/zoom mode.




    

drag_zoom(event)[source]#
Callback for dragging in zoom mode.
draw_rubberband(event, x0, y0, x1, y1)[source]#
Draw a rectangle rubberband to indicate zoom limits.
Note that it is not guaranteed that x0 <= x1 and y0 <= y1.
forward(*args)[source]#
Move forward in the view lim stack.
For convenience of being directly connected as a GUI callback, which
often get passed additional parameters, this method accepts arbitrary
parameters, but does not use them.
home(*args)[source]#
Restore the original view.
For convenience of being directly connected as a GUI callback, which
often get passed additional parameters, this method accepts arbitrary
parameters, but does not use them.
mouse_move(event)[source]#
pan(*args)[source]#
Toggle the pan/zoom tool.
Pan with left button, zoom with right.
press_pan(event)[source]#
Callback for mouse button press in pan/zoom mode.
press_zoom(event)[source]#
Callback for mouse button press in zoom to rect mode.
push_current()[source]#
Push the current view limits and position onto the stack.
release_pan(event)[source]#
Callback for mouse button release in pan/zoom mode.
release_zoom(event)[source]#
Callback for mouse button release in zoom to rect mode.
remove_rubberband()[source]#
Remove the rubberband.
save_figure(*args)[source]#
Save the current figure.
set_history_buttons()[source]#
Enable or disable the back/forward button.
set_message(s)[source]#
Display a message on toolbar or in status bar.
toolitems = (('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous view', 'back', 'back'), ('Forward', 'Forward to next view', 'forward', 'forward'), (None, None, None, None), ('Pan', 'Left button pans, Right button zooms\nx/y fixes axis, CTRL fixes aspect', 'move', 'pan'), ('Zoom', 'Zoom to rectangle\nx/y fixes axis', 'zoom_to_rect', 'zoom'), ('Subplots', 'Configure subplots', 'subplots', 'configure_subplots'), (None, None, None, None), ('Save', 'Save the figure', 'filesave', 'save_figure'))#
update()[source]#
Reset the Axes stack.
zoom(*args)[source]#
class matplotlib.backend_bases.PickEvent(name, canvas, mouseevent, artist, guiEvent=None, **kwargs)[source]#
Bases: Event
A pick event.
This event is fired when the user picks a location on the canvas
sufficiently close to an artist that has been made pickable with
Artist.set_picker.
A PickEvent has a number of special attributes in addition to those defined
by the parent Event class.
Attributes:
mouseeventMouseEvent
The mouse event that generated the pick.
artistArtist
The picked artist. Note that artists are not pickable by default
(see Artist.set_picker).
other
Additional attributes may be present depending on the type of the
picked object; e.g., a Line2D pick may define different extra
attributes than a PatchCollection pick.
Examples
Bind a function on_pick() to pick events, that prints the coordinates
of the picked data point:
ax.plot(np.rand(100), 'o', picker=5)  # 5 points tolerance
def on_pick(event):
    line = event.artist
    xdata, ydata = line.get_data()
    ind = event.ind
    print(f'on pick line: {xdata[ind]:.3f}, {ydata[ind]:.3f}')
cid = fig.canvas.mpl_connect('pick_event', on_pick)
class matplotlib.backend_bases.RendererBase[source]#
Bases: object




    

An abstract base class to handle drawing/rendering operations.
The following methods must be implemented in the backend for full
functionality (though just implementing draw_path alone would give a
highly capable backend):
draw_path
draw_image
draw_gouraud_triangles
The following methods should be implemented in the backend for
optimization reasons:
draw_text
draw_markers
draw_path_collection
draw_quad_mesh
close_group(s)[source]#
Close a grouping element with label s.
Only used by the SVG renderer.
draw_gouraud_triangles(gc, triangles_array, colors_array, transform)[source]#
Draw a series of Gouraud triangles.
Parameters:
gcGraphicsContextBase
The graphics context.
triangles_array(N, 3, 2) array-like
Array of N (x, y) points for the triangles.
colors_array(N, 3, 4) array-like
Array of N RGBA colors for each point of the triangles.
transformTransform
An affine transform to apply to the points.
gcGraphicsContextBase
A graphics context with clipping information.
xscalar
The distance in physical units (i.e., dots or pixels) from the left
hand side of the canvas.
yscalar
The distance in physical units (i.e., dots or pixels) from the
bottom side of the canvas.
im(N, M, 4) array of numpy.uint8
An array of RGBA pixels.
transformAffine2DBase
If and only if the concrete backend is written such that
option_scale_image returns True, an affine transformation
(i.e., an Affine2DBase) may be passed to draw_image. The
translation vector of the transformation is given in physical units
(i.e., dots or pixels). Note that the transformation does not
override x and y, and has to be applied before translating
the result by x and y (this can be accomplished by adding x
and y to the translation vector defined by transform).
draw_markers(gc, marker_path, marker_trans, path, trans, rgbFace=None)[source]#
Draw a marker at each of path's vertices (excluding control points).
The base (fallback) implementation makes multiple calls to draw_path.
Backends may want to override this method in order to draw the marker
only once and reuse it multiple times.
Parameters:
gcGraphicsContextBase
The graphics context.
marker_pathPath
The path for the marker.
marker_transTransform
An affine transform applied to the marker.
pathPath
The locations to draw the markers.
transTransform
An affine transform applied to the path.
rgbFacecolor, optional

draw_path_collection(gc, master_transform, paths, all_transforms, offsets, offset_trans, facecolors, edgecolors, linewidths, linestyles, antialiaseds, urls, offset_position)[source]#
Draw a collection of paths.
Each path is first transformed by the corresponding entry
in all_transforms (a list of (3, 3) matrices) and then by
master_transform. They are then translated by the corresponding
entry in offsets, which has been first transformed by offset_trans.
facecolors, edgecolors, linewidths, linestyles, and
antialiased are lists that set the corresponding properties.
offset_position is unused now, but the argument is kept for
backwards compatibility.
The base (fallback) implementation makes multiple calls to draw_path.
Backends may want to override this in order to render each set of
path data only once, and then reference that path multiple times with
the different offsets, colors, styles etc. The generator methods
_iter_collection_raw_paths and _iter_collection are provided to
help with (and standardize) the implementation across backends. It
is highly recommended to use those generators, so that changes to the
behavior of draw_path_collection can be made globally.
draw_quad_mesh(gc, master_transform, meshWidth, meshHeight, coordinates, offsets, offsetTrans, facecolors, antialiased, edgecolors)[source]#
Draw a quadmesh.
The base (fallback) implementation converts the quadmesh to paths and
then calls draw_path_collection.




    

draw_tex(gc, x, y, s, prop, angle, *, mtext=None)[source]#
Draw a TeX instance.
Parameters:
gcGraphicsContextBase
The graphics context.
xfloat
The x location of the text in display coords.
yfloat
The y location of the text baseline in display coords.
sstr
The TeX text string.
propFontProperties
The font properties.
anglefloat
The rotation angle in degrees anti-clockwise.
mtextText
The original text object to be rendered.
draw_text(gc, x, y, s, prop, angle, ismath=False, mtext=None)[source]#
Draw a text instance.
Parameters:
gcGraphicsContextBase
The graphics context.
xfloat
The x location of the text in display coords.
yfloat
The y location of the text baseline in display coords.
sstr
The text string.
propFontProperties
The font properties.
anglefloat
The rotation angle in degrees anti-clockwise.
ismathbool or "TeX"
If True, use mathtext parser. If "TeX", use tex for rendering.
mtextText
The original text object to be rendered.
get_image_magnification()[source]#
Get the factor by which to magnify images passed to draw_image.
Allows a backend to have images at a different resolution to other
artists.
get_texmanager()[source]#
Return the TexManager instance.
get_text_width_height_descent(s, prop, ismath)[source]#
Get the width, height, and descent (offset from the bottom to the baseline), in
display coords, of the string s with FontProperties prop.
Whitespace at the start and the end of s is included in the reported width.
new_gc()[source]#
Return an instance of a GraphicsContextBase.
open_group(s, gid=None)[source]#
Open a grouping element with label s and gid (if set) as id.
Only used by the SVG renderer.
option_image_nocomposite()[source]#
Return whether image composition by Matplotlib should be skipped.
Raster backends should usually return False (letting the C-level
rasterizer take care of image composition); vector backends should
usually return not rcParams["image.composite_image"].
option_scale_image()[source]#
Return whether arbitrary affine transformations in draw_image are
supported (True for most vector backends).
points_to_pixels(points)[source]#
Convert points to display units.
You need to override this function (unless your backend
doesn't have a dpi, e.g., postscript or svg). Some imaging
systems assume some value for pixels per inch:
points to pixels = points * pixels_per_inch/72 * dpi/72
Parameters:
pointsfloat or array-like

Returns:
Points converted to pixels

stop_filter(filter_func)[source]#
Switch back to the original renderer. The contents of the temporary
renderer is processed with the filter_func and is drawn on the
original renderer as an image.
Currently only supported by the agg renderer.
stop_rasterizing()[source]#
Switch back to the vector renderer and draw the contents of the raster
renderer as an image on the vector renderer.
Used by MixedModeRenderer.
class matplotlib.backend_bases.ResizeEvent(name, canvas)[source]#
Bases: Event
An event triggered by a canvas resize.
A ResizeEvent has a number of special attributes in addition to those
defined by the parent Event class.
Attributes:
widthint
Width of the canvas in pixels.
heightint
Height of the canvas in pixels.
class matplotlib.backend_bases.ShowBase[source]#
Bases: _Backend
Simple base class to generate a show() function in backends.
Subclass must override mainloop() method.
class matplotlib.backend_bases.TimerBase(interval=None, callbacks=None)[source]#
Bases: object




    

A base class for providing timer events, useful for things animations.
Backends need to implement a few specific methods in order to use their
own timing mechanisms so that the timer events are integrated into their
event loops.
Subclasses must override the following methods:
_timer_start: Backend-specific code for starting the timer.
_timer_stop: Backend-specific code for stopping the timer.
Subclasses may additionally override the following methods:
_timer_set_single_shot: Code for setting the timer to single shot
operating mode, if supported by the timer object. If not, the Timer
class itself will store the flag and the _on_timer method should be
overridden to support such behavior.
_timer_set_interval: Code for setting the interval on the timer, if
there is a method for doing so on the timer object.
_on_timer: The internal function that any timer object should call,
which will handle the task of running all callbacks that have been set.
Parameters:
intervalint, default: 1000ms
The time between timer events in milliseconds. Will be stored as
timer.interval.
callbackslist[tuple[callable, tuple, dict]]
List of (func, args, kwargs) tuples that will be called upon timer
events. This list is accessible as timer.callbacks and can be
manipulated directly, or the functions add_callback
and remove_callback can be used.
add_callback(func, *args, **kwargs)[source]#
Register func to be called by timer when the event fires. Any
additional arguments provided will be passed to func.
This function returns func, which makes it possible to use it as a
decorator.
property interval#
The time between timer events, in milliseconds.
remove_callback(func, *args, **kwargs)[source]#
Remove func from list of callbacks.
args and kwargs are optional and used to distinguish between copies
of the same function registered to be called with different arguments.
This behavior is deprecated. In the future, *args, **kwargs won't
be considered anymore; to keep a specific callback removable by itself,
pass it to add_callback as a functools.partial object.
property single_shot#
Whether this timer should stop after a single run.
start(interval=<deprecated parameter>)[source]#
Start the timer object.
Parameters:
intervalint, optional
Timer interval in milliseconds; overrides a previously set interval
if provided.
class matplotlib.backend_bases.ToolContainerBase(toolmanager)[source]#
Bases: object
Base class for all tool containers, e.g. toolbars.
Attributes:
toolmanagerToolManager
The tools with which this ToolContainer wants to communicate.
tooltool_like
The tool to add, see ToolManager.get_tool.
groupstr
The name of the group to add this tool to.
positionint, default: -1
The position within the group to place this tool.
add_toolitem(name, group, position, image, description, toggle)[source]#
A hook to add a toolitem to the container.
This hook must be implemented in each backend and contains the
backend-specific code to add an element to the toolbar.
Warning
This is part of the backend implementation and should
not be called by end-users. They should instead call
ToolContainerBase.add_tool.
The callback associated with the button click event
must be exactly self.trigger_tool(name).
Parameters:
namestr
Name of the tool to add, this gets used as the tool's ID and as the
default label of the buttons.
groupstr
Name of the group that this tool belongs to.
positionint
Position of the tool within its group, if -1 it goes at the end.
imagestr
Filename of the image for the button or None.
descriptionstr
Description of the tool, used for the tooltips.
togglebool

True : The button is a toggle (change the pressed/unpressed
state between consecutive clicks).
False : The button is a normal button (returns to unpressed
state after release).
remove_toolitem(name)[source]#
A hook to remove a toolitem from the container.
This hook must be implemented in each backend and contains the
backend-specific code to remove an element from the toolbar; it is
called when ToolManager emits a tool_removed_event.
Because some tools are present only on the ToolManager but not on
the ToolContainer, this method must be a no-op when called on a tool
absent from the container.
Warning
This is part of the backend implementation and should
not be called by end-users. They should instead call
ToolManager.remove_tool.
Parameters:
namestr
Name of the tool to remove.
toggle_toolitem(name, toggled)[source]#
A hook to toggle a toolitem without firing an event.
This hook must be implemented in each backend and contains the
backend-specific code to silently toggle a toolbar element.
Warning
This is part of the backend implementation and should
not be called by end-users. They should instead call
ToolManager.trigger_tool or ToolContainerBase.trigger_tool
(which are equivalent).
Parameters:
namestr
Id of the tool to toggle.
toggledbool
Whether to set this tool as toggled or not.
matplotlib.backend_bases.button_press_handler(event, canvas=None, toolbar=None)[source]#
The default Matplotlib button actions for extra mouse buttons.
Parameters are as for key_press_handler, except that event is a
MouseEvent.




    

matplotlib.backend_bases.get_registered_canvas_class(format)[source]#
Return the registered default canvas for given file format.
Handles deferred import of required backend.
matplotlib.backend_bases.key_press_handler(event, canvas=None, toolbar=None)[source]#
Implement the default Matplotlib key bindings for the canvas and toolbar
described at Navigation keyboard shortcuts.
Parameters:
eventKeyEvent
A key press/release event.
canvasFigureCanvasBase, default: event.canvas
The backend-specific canvas instance. This parameter is kept for
back-compatibility, but, if set, should always be equal to
event.canvas.
toolbarNavigationToolbar2, default: event.canvas.toolbar
The navigation cursor toolbar. This parameter is kept for
back-compatibility, but, if set, should always be equal to
event.canvas.toolbar.
matplotlib.backend_bases.register_backend(format, backend, description=None)[source]#
Register a backend for saving to a given file format.
Parameters:
formatstr
File extension
backendmodule string or canvas class
Backend for handling file output
descriptionstr, default: ""
Description of the file type.
FigureCanvasBase.button_pick_id
FigureCanvasBase.callbacks
FigureCanvasBase.device_pixel_ratio
FigureCanvasBase.draw()
FigureCanvasBase.draw_idle()
FigureCanvasBase.events
FigureCanvasBase.filetypes
FigureCanvasBase.fixed_dpi
FigureCanvasBase.flush_events()
FigureCanvasBase.get_default_filename()
FigureCanvasBase.get_default_filetype()
FigureCanvasBase.get_supported_filetypes()
FigureCanvasBase.get_supported_filetypes_grouped()
FigureCanvasBase.get_width_height()
FigureCanvasBase.grab_mouse()
FigureCanvasBase.inaxes()
FigureCanvasBase.is_saving()
FigureCanvasBase.manager_class
FigureCanvasBase.mpl_connect()
FigureCanvasBase.mpl_disconnect()
FigureCanvasBase.new_manager()
FigureCanvasBase.new_timer()
FigureCanvasBase.print_figure()
FigureCanvasBase.release_mouse()
FigureCanvasBase.required_interactive_framework
FigureCanvasBase.scroll_pick_id
FigureCanvasBase.set_cursor()
FigureCanvasBase.start_event_loop()
FigureCanvasBase.stop_event_loop()
FigureCanvasBase.supports_blit
FigureCanvasBase.switch_backends()
FigureManagerBase

FigureManagerBase.create_with_canvas()
FigureManagerBase.destroy()
FigureManagerBase.full_screen_toggle()
FigureManagerBase.get_window_title()
FigureManagerBase.pyplot_show()
FigureManagerBase.resize()
FigureManagerBase.set_window_title()
FigureManagerBase.show()
FigureManagerBase.start_main_loop()
GraphicsContextBase

GraphicsContextBase.copy_properties()
GraphicsContextBase.get_alpha()
GraphicsContextBase.get_antialiased()
GraphicsContextBase.get_capstyle()
GraphicsContextBase.get_clip_path()
GraphicsContextBase.get_clip_rectangle()
GraphicsContextBase.get_dashes()
GraphicsContextBase.get_forced_alpha()
GraphicsContextBase.get_gid()
GraphicsContextBase.get_hatch()
GraphicsContextBase.get_hatch_color()
GraphicsContextBase.get_hatch_linewidth()
GraphicsContextBase.get_hatch_path()
GraphicsContextBase.get_joinstyle()
GraphicsContextBase.get_linewidth()
GraphicsContextBase.get_rgb()
GraphicsContextBase.get_sketch_params()
GraphicsContextBase.get_snap()
GraphicsContextBase.get_url()
GraphicsContextBase.restore()
GraphicsContextBase.set_alpha()
GraphicsContextBase.set_antialiased()
GraphicsContextBase.set_capstyle()
GraphicsContextBase.set_clip_path()
GraphicsContextBase.set_clip_rectangle()
GraphicsContextBase.set_dashes()
GraphicsContextBase.set_foreground()
GraphicsContextBase.set_gid()
GraphicsContextBase.set_hatch()
GraphicsContextBase.set_hatch_color()
GraphicsContextBase.set_joinstyle()
GraphicsContextBase.set_linewidth()
GraphicsContextBase.set_sketch_params()
GraphicsContextBase.set_snap()
GraphicsContextBase.set_url()
KeyEvent
LocationEvent

LocationEvent.lastevent
MouseButton

MouseButton.BACK
MouseButton.FORWARD
MouseButton.LEFT
MouseButton.MIDDLE
MouseButton.RIGHT
MouseEvent
NavigationToolbar2

NavigationToolbar2.back()
NavigationToolbar2.configure_subplots()
NavigationToolbar2.drag_pan()
NavigationToolbar2.drag_zoom()
NavigationToolbar2.draw_rubberband()
NavigationToolbar2.forward()
NavigationToolbar2.home()
NavigationToolbar2.mouse_move()
NavigationToolbar2.pan()
NavigationToolbar2.press_pan()
NavigationToolbar2.press_zoom()
NavigationToolbar2.push_current()
NavigationToolbar2.release_pan()
NavigationToolbar2.release_zoom()
NavigationToolbar2.remove_rubberband()
NavigationToolbar2.save_figure()
NavigationToolbar2.set_history_buttons()
NavigationToolbar2.set_message()
NavigationToolbar2.toolitems
NavigationToolbar2.update()
NavigationToolbar2.zoom()
NonGuiException
PickEvent
RendererBase

RendererBase.close_group()
RendererBase.draw_gouraud_triangles()
RendererBase.draw_image()
RendererBase.draw_markers()
RendererBase.draw_path()
RendererBase.draw_path_collection()
RendererBase.draw_quad_mesh()
RendererBase.draw_tex()
RendererBase.draw_text()
RendererBase.flipy()
RendererBase.get_canvas_width_height()
RendererBase.get_image_magnification()
RendererBase.get_texmanager()
RendererBase.get_text_width_height_descent()
RendererBase.new_gc()
RendererBase.open_group()
RendererBase.option_image_nocomposite()
RendererBase.option_scale_image()
RendererBase.points_to_pixels()
RendererBase.start_filter()
RendererBase.start_rasterizing()
RendererBase.stop_filter()
RendererBase.stop_rasterizing()
ResizeEvent
ShowBase
TimerBase

TimerBase.add_callback()
TimerBase.interval
TimerBase.remove_callback()
TimerBase.single_shot
TimerBase.start()
TimerBase.stop()
ToolContainerBase

ToolContainerBase.add_tool()
ToolContainerBase.add_toolitem()
ToolContainerBase.remove_toolitem()
ToolContainerBase.set_message()
ToolContainerBase.toggle_toolitem()
ToolContainerBase.trigger_tool()
button_press_handler()
get_registered_canvas_class()
key_press_handler()
register_backend()