| | |
- Cursors
- Event
-
- DrawEvent
- LocationEvent
-
- KeyEvent
- MouseEvent
- PickEvent
- ResizeEvent
- FigureCanvasBase
- FigureManagerBase
- GraphicsContextBase
- NavigationToolbar2
- RendererBase
class Cursors |
| |
# cursors
|
| |
Data and other attributes defined here:
- HAND = 0
- MOVE = 3
- POINTER = 1
- SELECT_REGION = 2
|
class DrawEvent(Event) |
| |
An event triggered by a draw operation on the canvas
Attributes are
name
canvas
renderer - the Renderer instance
|
| |
Methods defined here:
- __init__(self, name, canvas, renderer)
|
class Event |
| |
A matplotlib event. Attach additional attributes as defined in
FigureCanvas.connect. The following attributes are defined and
shown with their default values
name # the event name
canvas # the FigureCanvas instance generating the event
|
| |
Methods defined here:
- __init__(self, name, canvas, guiEvent=None)
|
class FigureCanvasBase |
| |
The canvas the figure renders into.
Public attribute
figure - A Figure instance
|
| |
Methods defined here:
- __init__(self, figure)
- blit(self, bbox=None)
- blit the canvas in bbox (default entire canvas)
- button_press_event(self, x, y, button, guiEvent=None)
- Backend derived classes should call this function on any mouse
button press. x,y are the canvas coords: 0,0 is lower, left.
button and key are as defined in MouseEvent
- button_release_event(self, x, y, button, guiEvent=None)
- Backend derived classes should call this function on any mouse
button release. x,y are the canvas coords: 0,0 is lower, left.
button and key are as defined in MouseEvent
- draw(self, *args, **kwargs)
- Render the figure
- draw_cursor(self, event)
- Draw a cursor in the event.axes if inaxes is not None. Use
native GUI drawing for efficiency if possible
- draw_event(self, renderer)
- draw_idle(self, *args, **kwargs)
- draw only if idle; defaults to draw but backends can overrride
- flush_events(self)
- Flush the GUI events for the figure. Implemented only for
backends with GUIs.
- get_default_filetype(self)
- get_supported_filetypes(self)
- get_supported_filetypes_grouped(self)
- get_width_height(self)
- return the figure width and height in points or pixels
(depending on the backend), truncated to integers
- key_press_event(self, key, guiEvent=None)
- key_release_event(self, key, guiEvent=None)
- motion_notify_event(self, x, y, guiEvent=None)
- Backend derived classes should call this function on any
motion-notify-event. x,y are the canvas coords: 0,0 is lower, left.
button and key are as defined in MouseEvent
- mpl_connect(self, s, func)
- Connect event with string s to func. The signature of func is
def func(event)
where event is a MplEvent. The following events are recognized
'resize_event',
'draw_event',
'key_press_event',
'key_release_event',
'button_press_event',
'button_release_event',
'scroll_event',
'motion_notify_event',
'pick_event',
For the three events above, if the mouse is over the axes,
the variable event.inaxes will be set to the axes it is over,
and additionally, the variables event.xdata and event.ydata
will be defined. This is the mouse location in data coords.
See backend_bases.MplEvent.
return value is a connection id that can be used with
mpl_disconnect
- mpl_disconnect(self, cid)
- disconnect callback id cid
- onHilite(self, ev)
- Mouse event processor which highlights the artists
under the cursor. Connect this to the motion_notify_event
using canvas.mpl_connect('motion_notify_event',canvas.onHilite)
- onRemove(self, ev)
- Mouse event processor which removes the top artist
under the cursor. Connect this to the mouse_press_event
using canvas.mpl_connect('mouse_press_event',canvas.onRemove)
- pick(self, mouseevent)
- pick_event(self, mouseevent, artist, **kwargs)
- This method will be called by artists who are picked and will
fire off PickEvent callbacks registered listeners
- print_bmp = print_raw(self, *args, **kwargs)
- print_emf(self, *args, **kwargs)
- print_eps(self, *args, **kwargs)
- print_figure(self, filename, dpi=None, facecolor='w', edgecolor='w', orientation='portrait', format=None, **kwargs)
- 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.
filename - can also be a file object on image backends
orientation - only currently applies to PostScript printing.
dpi - the dots per inch to save the figure in; if None, use savefig.dpi
facecolor - the facecolor of the figure
edgecolor - the edgecolor of the figure
orientation - 'landscape' | 'portrait' (not supported on all backends)
format - when set, forcibly set the file format to save to
- print_pdf(self, *args, **kwargs)
- print_png(self, *args, **kwargs)
- print_ps(self, *args, **kwargs)
- print_raw(self, *args, **kwargs)
- print_rgb = print_raw(self, *args, **kwargs)
- print_svg(self, *args, **kwargs)
- print_svgz(self, *args, **kwargs)
- resize(self, w, h)
- set the canvas size in pixels
- resize_event(self)
- scroll_event(self, x, y, button, guiEvent=None)
- Backend derived classes should call this function on any
scroll wheel event. x,y are the canvas coords: 0,0 is lower,
left. button and key are as defined in MouseEvent
- set_window_title(self, title)
- Set the title text of the window containing the figure. Note that
this has no effect if there is no window (eg, a PS backend).
- switch_backends(self, FigureCanvasClass)
- instantiate an instance of FigureCanvasClass
This is used for backend switching, eg, to instantiate a
FigureCanvasPS from a FigureCanvasGTK. Note, deep copying is
not done, so any changes to one of the instances (eg, setting
figure size or line props), will be reflected in the other
Data and other attributes defined here:
- events = ('resize_event', 'draw_event', 'key_press_event', 'key_release_event', 'button_press_event', 'button_release_event', 'scroll_event', 'motion_notify_event', 'pick_event')
- filetypes = {'emf': 'Enhanced Metafile', 'eps': 'Encapsulated Postscript', 'pdf': 'Portable Document Format', 'png': 'Portable Network Graphics', 'ps': 'Postscript', 'raw': 'Raw RGBA bitmap', 'rgba': 'Raw RGBA bitmap', 'svg': 'Scalable Vector Graphics', 'svgz': 'Scalable Vector Graphics'}
|
class FigureManagerBase |
| |
Helper class for matlab mode, wraps everything up into a neat bundle
Public attibutes
canvas - A FigureCanvas instance
num - The figure number
|
| |
Methods defined here:
- __init__(self, canvas, num)
- destroy(self)
- full_screen_toggle(self)
- key_press(self, event)
- resize(self, w, h)
- For gui backends: resize window in pixels
- set_window_title(self, title)
- Set the title text of the window containing the figure. Note that
this has no effect if there is no window (eg, a PS backend).
- show_popup(self, msg)
- Display message in a popup -- GUI only
|
class GraphicsContextBase |
| |
An abstract base class that provides color, line styles, etc...
|
| |
Methods defined here:
- __init__(self)
- copy_properties(self, gc)
- Copy properties from gc to self
- get_alpha(self)
- Return the alpha value used for blending - not supported on
all backends
- get_antialiased(self)
- Return true if the object should try to do antialiased rendering
- get_capstyle(self)
- Return the capstyle as a string in ('butt', 'round', 'projecting')
- get_clip_path(self)
- Return the clip path in the form (path, transform), where path
is a path.Path instance, and transform as an affine transform
to apply to the path before clipping.
- get_clip_rectangle(self)
- Return the clip rectangle as a Bbox instance
- get_dashes(self)
- Return the dash information as an offset dashlist tuple The
dash list is a even size list that gives the ink on, ink off
in pixels. See p107 of to postscript BLUEBOOK for more info
Default value is None
- get_hatch(self)
- Gets the current hatch style
- get_joinstyle(self)
- Return the line join style as one of ('miter', 'round', 'bevel')
- get_linestyle(self, style)
- Return the linestyle: one of ('solid', 'dashed', 'dashdot',
'dotted').
- get_linewidth(self)
- Return the line width in points as a scalar
- get_rgb(self)
- returns a tuple of three floats from 0-1. color can be a
matlab format string, a html hex color string, or a rgb tuple
- set_alpha(self, alpha)
- Set the alpha value used for blending - not supported on
all backends
- set_antialiased(self, b)
- True if object should be drawn with antialiased rendering
- set_capstyle(self, cs)
- Set the capstyle as a string in ('butt', 'round', 'projecting')
- set_clip_path(self, path)
- Set the clip path and transformation. Path should be a
transforms.TransformedPath instance.
- set_clip_rectangle(self, rectangle)
- Set the clip rectangle with sequence (left, bottom, width, height)
- set_dashes(self, dash_offset, dash_list)
- Set the dash style for the gc.
dash_offset is the offset (usually 0).
dash_list specifies the on-off sequence as points
(None, None) specifies a solid line
- set_foreground(self, fg, isRGB=False)
- Set the foreground color. fg can be a matlab format string, a
html hex color string, an rgb unit tuple, or a float between 0
and 1. In the latter case, grayscale is used.
The GraphicsContext converts colors to rgb internally. If you
know the color is rgb already, you can set isRGB to True to
avoid the performace hit of the conversion
- set_graylevel(self, frac)
- Set the foreground color to be a gray level with frac frac
- set_hatch(self, hatch)
- Sets the hatch style for filling
- set_joinstyle(self, js)
- Set the join style to be one of ('miter', 'round', 'bevel')
- set_linestyle(self, style)
- Set the linestyle to be one of ('solid', 'dashed', 'dashdot',
'dotted').
- set_linewidth(self, w)
- Set the linewidth in points
Data and other attributes defined here:
- dashd = {'dashdot': (0, (3.0, 5.0, 1.0, 5.0)), 'dashed': (0, (6.0, 6.0)), 'dotted': (0, (1.0, 3.0)), 'solid': (None, None)}
|
class KeyEvent(LocationEvent) |
| |
A key event (key press, key release).
Attach additional attributes as defined in
FigureCanvas.connect.
The following attributes are defined and shown with their default
values
x = None # x position - pixels from left of canvas
y = None # y position - pixels from bottom of canvas
key = None # the key pressed: None, chr(range(255), shift, win, or control
inaxes = None # the Axes instance if mouse us over axes
xdata = None # x coord of mouse in data coords
ydata = None # y coord of mouse in data coords
This interface may change slightly when better support for
modifier keys is included
|
| |
- Method resolution order:
- KeyEvent
- LocationEvent
- Event
Methods defined here:
- __init__(self, name, canvas, key, x=0, y=0, guiEvent=None)
Data and other attributes inherited from LocationEvent:
- button = None
- inaxes = None
- x = None
- xdata = None
- y = None
- ydata = None
|
class LocationEvent(Event) |
| |
A event that has a screen location
The following additional attributes are defined and shown with
their default values
x = None # x position - pixels from left of canvas
y = None # y position - pixels from bottom of canvas
inaxes = None # the Axes instance if mouse us over axes
xdata = None # x coord of mouse in data coords
ydata = None # y coord of mouse in data coords
|
| |
Methods defined here:
- __init__(self, name, canvas, x, y, guiEvent=None)
- x, y in figure coords, 0,0 = bottom, left
button pressed None, 1, 2, 3
Data and other attributes defined here:
- button = None
- inaxes = None
- x = None
- xdata = None
- y = None
- ydata = None
|
class MouseEvent(LocationEvent) |
| |
A mouse event (button_press_event, button_release_event, scroll_event,
motion_notify_event).
The following attributes are defined and shown with their default
values
x = None # x position - pixels from left of canvas
y = None # y position - pixels from bottom of canvas
button = None # button pressed None, 1, 2, 3, 'up', 'down'
(up and down are used for scroll events)
key = None # the key pressed: None, chr(range(255), shift, win, or control
inaxes = None # the Axes instance if mouse us over axes
xdata = None # x coord of mouse in data coords
ydata = None # y coord of mouse in data coords
|
| |
- Method resolution order:
- MouseEvent
- LocationEvent
- Event
Methods defined here:
- __init__(self, name, canvas, x, y, button=None, key=None, guiEvent=None)
- x, y in figure coords, 0,0 = bottom, left
button pressed None, 1, 2, 3
Data and other attributes defined here:
- button = None
- inaxes = None
- x = None
- xdata = None
- y = None
- ydata = None
|
class NavigationToolbar2 |
| |
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
FigureCanvas.connect for more information
They must also define
* save_figure - save the current figure
* set_cursor - if you want the pointer icon to change
* _init_toolbar - create your toolbar widget
* draw_rubberband (optional) : draw the zoom to rect
"rubberband" rectangle
* press : (optional) whenever a mouse button is pressed, you'll be
notified with the event
* release : (optional) whenever a mouse button is released,
you'll be notified with the event
* dynamic_update (optional) dynamically update the window while
navigating
* set_message (optional) - display message
* set_history_buttons (optional) - you can change the history
back / forward buttons to indicate disabled / enabled state.
That's it, we'll do the rest!
|
| |
Methods defined here:
- __init__(self, canvas)
- back(self, *args)
- move back up the view lim stack
- drag_pan(self, event)
- the drag callback in pan/zoom mode
- draw(self)
- redraw the canvases, update the locators
- draw_rubberband(self, event, x0, y0, x1, y1)
- draw a rectangle rubberband to indicate zoom limits
- dynamic_update(self)
- forward(self, *args)
- move forward in the view lim stack
- home(self, *args)
- restore the original view
- mouse_move(self, event)
- pan(self, *args)
- Activate the pan/zoom tool. pan with left button, zoom with right
- press(self, event)
- this will be called whenver a mouse button is pressed
- press_pan(self, event)
- the press mouse button in pan/zoom mode callback
- press_zoom(self, event)
- the press mouse button in zoom to rect mode callback
- push_current(self)
- push the current view limits and position onto the stack
- release(self, event)
- this will be called whenever mouse button is released
- release_pan(self, event)
- the release mouse button callback in pan/zoom mode
- release_zoom(self, event)
- the release mouse button callback in zoom to rect mode
- save_figure(self, *args)
- save the current figure
- set_cursor(self, cursor)
- Set the current cursor to one of the backend_bases.Cursors
enums values
- set_history_buttons(self)
- enable or disable back/forward button
- set_message(self, s)
- display a message on toolbar or in status bar
- update(self)
- reset the axes stack
- zoom(self, *args)
- activate zoom to rect mode
|
class PickEvent(Event) |
| |
a pick event, fired when the user picks a location on the canvas
sufficiently close to an artist.
Attrs: all the Event attrs plus
mouseevent : the MouseEvent that generated the pick
artist : the artist picked
extra class dependent attrs -- eg a Line2D pick may define
different extra attributes than a PatchCollection pick event
|
| |
Methods defined here:
- __init__(self, name, canvas, mouseevent, artist, guiEvent=None, **kwargs)
|
class RendererBase |
| |
An abstract base class to handle drawing/rendering operations.
The following methods *must* be implemented in the backend:
draw_path
draw_image
draw_text
get_text_width_height_descent
The following methods *should* be implemented in the backend for
optimization reasons:
draw_markers
draw_path_collection
draw_quad_mesh
|
| |
Methods defined here:
- __init__(self)
- close_group(self, s)
- close a grouping element with label s
Is only currently used by backend_svg
- draw_image(self, x, y, im, bbox, clippath=None, clippath_trans=None)
- Draw the Image instance into the current axes; x is the
distance in pixels from the left hand side of the canvas. y is
the distance from the origin. That is, if origin is upper, y
is the distance from top. If origin is lower, y is the
distance from bottom
bbox is a matplotlib.transforms.BBox instance for clipping, or
None
- draw_markers(self, gc, marker_path, marker_trans, path, trans, rgbFace=None)
- Draws a marker at each of the vertices in path. This includes
all vertices, including control points on curves. To avoid
that behavior, those vertices should be removed before calling
this function.
marker_trans is an affine transform applied to the marker.
trans is an affine transform applied to the path.
This provides a fallback implementation of draw_markers that
makes multiple calls to draw_path. Some backends may want to
override this method in order to draw the marker only once and
reuse it multiple times.
- draw_path(self, gc, path, transform, rgbFace=None)
- Draws a Path instance using the given affine transform.
- draw_path_collection(self, master_transform, cliprect, clippath, clippath_trans, paths, all_transforms, offsets, offsetTrans, facecolors, edgecolors, linewidths, linestyles, antialiaseds)
- Draws a collection of paths, selecting drawing properties from
the lists facecolors, edgecolors, linewidths, linestyles and
antialiaseds. offsets is a list of offsets to apply to each
of the paths. The offsets in offsets are first transformed by
offsetTrans before being applied.
This provides a fallback implementation of
draw_path_collection that makes multiple calls to draw_path.
Some 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(self, master_transform, cliprect, clippath, clippath_trans, meshWidth, meshHeight, coordinates, offsets, offsetTrans, facecolors, antialiased, showedges)
- This provides a fallback implementation of draw_quad_mesh that
generates paths and then calls draw_path_collection.
- draw_tex(self, gc, x, y, s, prop, angle, ismath='TeX!')
- draw_text(self, gc, x, y, s, prop, angle, ismath=False)
- Draw the text.Text instance s at x,y (display coords) with font
properties instance prop at angle in degrees, using GraphicsContext gc
**backend implementers note**
When you are trying to determine if you have gotten your bounding box
right (which is what enables the text layout/alignment to work
properly), it helps to change the line in text.py
if 0: bbox_artist(self, renderer)
to if 1, and then the actual bounding box will be blotted along with
your text.
- flipy(self)
- return true if y small numbers are top for renderer
Is used for drawing text (text.py) and images (image.py) only
- get_canvas_width_height(self)
- return the canvas width and height in display coords
- get_image_magnification(self)
- 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(self)
- get_text_width_height_descent(self, s, prop, ismath)
- get the width and height, and the offset from the bottom to the
baseline (descent), in display coords of the string s with
FontPropertry prop
- new_gc(self)
- Return an instance of a GraphicsContextBase
- open_group(self, s)
- open a grouping element with label s
Is only currently used by backend_svg
- option_image_nocomposite(self)
- overwrite this method for renderers that do not necessarily
want to rescale and composite raster images. (like SVG)
- points_to_pixels(self, points)
- Convert points to display units
points - a float or a numpy array of float
return points converted to pixels
You need to override this function (unless your backend doesn't have a
dpi, eg, postscript or svg).
Some imaging systems assume some value for pixels per inch.
points to pixels = points * pixels_per_inch/72.0 * dpi/72.0
- start_rasterizing(self)
- stop_rasterizing(self)
- strip_math(self, s)
|
class ResizeEvent(Event) |
| |
An event triggered by a canvas resize
Attributes are
name
canvas
width # width of the canvas in pixels
height # height of the canvas in pixels
|
| |
Methods defined here:
- __init__(self, name, canvas)
| |