"""

default_keymap = None

"""

description = None

"""

image = None

"""

def __init__(self, toolmanager, name):

cbook._warn_external(

'The new Tool classes introduced in v1.5 are experimental; their '

'API (including names) will likely change in future versions.')

self._name = name

self._toolmanager = toolmanager

self._figure = None

@property

def figure(self):

return self._figure

@figure.setter

def figure(self, figure):

self.set_figure(figure)

@property

def canvas(self):

if not self._figure:

return None

return self._figure.canvas

@property

def toolmanager(self):

return self._toolmanager

def _make_classic_style_pseudo_toolbar(self):

"""

return SimpleNamespace(canvas=self.canvas)

def set_figure(self, figure):

"""

self._figure = figure

def trigger(self, sender, event, data=None):

"""

pass

@property

def name(self):

"""Tool Id."""

return self._name

def destroy(self):

"""

"""

radio_group = None

"""Attribute to group 'radio' like tools (mutually exclusive).

cursor = None

"""Cursor to use when the tool is active."""

default_toggled = False

"""Default of toggled state."""

def __init__(self, *args, **kwargs):

self._toggled = kwargs.pop('toggled', self.default_toggled)

ToolBase.__init__(self, *args, **kwargs)

def trigger(self, sender, event, data=None):

"""Calls `enable` or `disable` based on `toggled` value."""

if self._toggled:

self.disable(event)

else:

self.enable(event)

self._toggled = not self._toggled

def enable(self, event=None):

"""

pass

def disable(self, event=None):

"""

pass

@property

def toggled(self):

"""State of the toggled tool."""

return self._toggled

def set_figure(self, figure):

toggled = self.toggled

if toggled:

if self.figure:

self.trigger(self, None)

else:

# if no figure the internal state is not changed

# we change it here so next call to trigger will change it back

self._toggled = False

ToolBase.set_figure(self, figure)

if toggled:

if figure:

self.trigger(self, None)

else:

# if there is no figure, trigger won't change the internal

# state we change it back

"""

def __init__(self, *args, **kwargs):

ToolBase.__init__(self, *args, **kwargs)

self._id_drag = None

self._cursor = None

self._default_cursor = cursors.POINTER

self._last_cursor = self._default_cursor

self.toolmanager.toolmanager_connect('tool_added_event',

self._add_tool_cbk)

# process current tools

for tool in self.toolmanager.tools.values():

self._add_tool(tool)

def set_figure(self, figure):

if self._id_drag:

self.canvas.mpl_disconnect(self._id_drag)

ToolBase.set_figure(self, figure)

if figure:

self._id_drag = self.canvas.mpl_connect(

'motion_notify_event', self._set_cursor_cbk)

def _tool_trigger_cbk(self, event):

if event.tool.toggled:

self._cursor = event.tool.cursor

else:

self._cursor = None

self._set_cursor_cbk(event.canvasevent)

def _add_tool(self, tool):

"""Set the cursor when the tool is triggered."""

if getattr(tool, 'cursor', None) is not None:

self.toolmanager.toolmanager_connect('tool_trigger_%s' % tool.name,

self._tool_trigger_cbk)

def _add_tool_cbk(self, event):

"""Process every newly added tool."""

if event.tool is self:

return

self._add_tool(event.tool)

def _set_cursor_cbk(self, event):

if not event:

return

if not getattr(event, 'inaxes', False) or not self._cursor:

if self._last_cursor != self._default_cursor:

self.set_cursor(self._default_cursor)

self._last_cursor = self._default_cursor

elif self._cursor:

cursor = self._cursor

if cursor and self._last_cursor != cursor:

self.set_cursor(cursor)

self._last_cursor = cursor

def set_cursor(self, cursor):

"""

"""

def __init__(self, *args, **kwargs):

self._id_drag = None

ToolBase.__init__(self, *args, **kwargs)

def set_figure(self, figure):

if self._id_drag:

self.canvas.mpl_disconnect(self._id_drag)

ToolBase.set_figure(self, figure)

if figure:

self._id_drag = self.canvas.mpl_connect(

'motion_notify_event', self.send_message)

def send_message(self, event):

"""Call `matplotlib.backend_managers.ToolManager.message_event`."""

if self.toolmanager.messagelock.locked():

return

message = ' '

if event.inaxes and event.inaxes.get_navigate():

try:

s = event.inaxes.format_coord(event.xdata, event.ydata)

except (ValueError, OverflowError):

pass

else:

artists = [a for a in event.inaxes._mouseover_set

if a.contains(event) and a.get_visible()]

if artists:

a = cbook._topmost_artist(artists)

if a is not event.inaxes.patch:

data = a.get_cursor_data(event)

if data is not None:

data_str = a.format_cursor_data(data)

if data_str is not None:

s = s + ' ' + data_str

message = s

"""Draw and remove a rubberband."""

def trigger(self, sender, event, data):

"""Call `draw_rubberband` or `remove_rubberband` based on data."""

if not self.figure.canvas.widgetlock.available(sender):

return

if data is not None:

self.draw_rubberband(*data)

else:

self.remove_rubberband()

def draw_rubberband(self, *data):

"""

raise NotImplementedError

def remove_rubberband(self):

"""

"""Tool to call the figure manager destroy method."""

description = 'Quit the figure'

default_keymap = mpl.rcParams['keymap.quit']

def trigger(self, sender, event, data=None):

"""Tool to call the figure manager destroy method."""

description = 'Quit all figures'

default_keymap = mpl.rcParams['keymap.quit_all']

def trigger(self, sender, event, data=None):

"""Tool to enable all axes for toolmanager interaction."""

description = 'Enable all axes toolmanager'

default_keymap = mpl.rcParams['keymap.all_axes']

def trigger(self, sender, event, data=None):

"""Tool to enable a specific axes for toolmanager interaction."""

description = 'Enable one axes toolmanager'

default_keymap = (1, 2, 3, 4, 5, 6, 7, 8, 9)

def trigger(self, sender, event, data=None):

"""Tool to toggle the major grids of the figure."""

description = 'Toggle major grids'

default_keymap = mpl.rcParams['keymap.grid']

def trigger(self, sender, event, data=None):

sentinel = str(uuid.uuid4())

# Trigger grid switching by temporarily setting :rc:`keymap.grid`

# to a unique key and sending an appropriate event.

with cbook._setattr_cm(event, key=sentinel), \

mpl.rc_context({'keymap.grid': sentinel}):

"""Tool to toggle the major and minor grids of the figure."""

description = 'Toggle major and minor grids'

default_keymap = mpl.rcParams['keymap.grid_minor']

def trigger(self, sender, event, data=None):

sentinel = str(uuid.uuid4())

# Trigger grid switching by temporarily setting :rc:`keymap.grid_minor`

# to a unique key and sending an appropriate event.

with cbook._setattr_cm(event, key=sentinel), \

mpl.rc_context({'keymap.grid_minor': sentinel}):

"""Tool to toggle full screen."""

description = 'Toggle fullscreen mode'

default_keymap = mpl.rcParams['keymap.fullscreen']

def enable(self, event):

self.figure.canvas.manager.full_screen_toggle()

def disable(self, event):

"""Base Tool to toggle between linear and logarithmic."""

def trigger(self, sender, event, data=None):

if event.inaxes is None:

return

ToolToggleBase.trigger(self, sender, event, data)

def enable(self, event):

self.set_scale(event.inaxes, 'log')

self.figure.canvas.draw_idle()

def disable(self, event):

self.set_scale(event.inaxes, 'linear')

"""Tool to toggle between linear and logarithmic scales on the Y axis."""

description = 'Toggle scale Y axis'

default_keymap = mpl.rcParams['keymap.yscale']

def set_scale(self, ax, scale):

"""Tool to toggle between linear and logarithmic scales on the X axis."""

description = 'Toggle scale X axis'

default_keymap = mpl.rcParams['keymap.xscale']

def set_scale(self, ax, scale):

"""

def __init__(self, *args, **kwargs):

self.views = WeakKeyDictionary()

self.positions = WeakKeyDictionary()

self.home_views = WeakKeyDictionary()

ToolBase.__init__(self, *args, **kwargs)

def add_figure(self, figure):

"""Add the current figure to the stack of views and positions."""

if figure not in self.views:

self.views[figure] = cbook.Stack()

self.positions[figure] = cbook.Stack()

self.home_views[figure] = WeakKeyDictionary()

# Define Home

self.push_current(figure)

# Make sure we add a home view for new axes as they're added

figure.add_axobserver(lambda fig: self.update_home_views(fig))

def clear(self, figure):

"""Reset the axes stack."""

if figure in self.views:

self.views[figure].clear()

self.positions[figure].clear()

self.home_views[figure].clear()

self.update_home_views()

def update_view(self):

"""

views = self.views[self.figure]()

if views is None:

return

pos = self.positions[self.figure]()

if pos is None:

return

home_views = self.home_views[self.figure]

all_axes = self.figure.get_axes()

for a in all_axes:

if a in views:

cur_view = views[a]

else:

cur_view = home_views[a]

a._set_view(cur_view)

if set(all_axes).issubset(pos):

for a in all_axes:

# Restore both the original and modified positions

a._set_position(pos[a][0], 'original')

a._set_position(pos[a][1], 'active')

self.figure.canvas.draw_idle()

def push_current(self, figure=None):

"""

if not figure:

figure = self.figure

views = WeakKeyDictionary()

pos = WeakKeyDictionary()

for a in figure.get_axes():

views[a] = a._get_view()

pos[a] = self._axes_pos(a)

self.views[figure].push(views)

self.positions[figure].push(pos)

def _axes_pos(self, ax):

"""

return (ax.get_position(True).frozen(),

ax.get_position().frozen())

def update_home_views(self, figure=None):

"""

if not figure:

figure = self.figure

for a in figure.get_axes():

if a not in self.home_views[figure]:

self.home_views[figure][a] = a._get_view()

@cbook.deprecated("3.3", alternative="self.figure.canvas.draw_idle()")

def refresh_locators(self):

"""Redraw the canvases, update the locators."""

self._refresh_locators()

# Can be removed once Locator.refresh() is removed, and replaced by an

# inline call to self.figure.canvas.draw_idle().

def _refresh_locators(self):

for a in self.figure.get_axes():

xaxis = getattr(a, 'xaxis', None)

yaxis = getattr(a, 'yaxis', None)

zaxis = getattr(a, 'zaxis', None)

locators = []

if xaxis is not None:

locators.append(xaxis.get_major_locator())

locators.append(xaxis.get_minor_locator())

if yaxis is not None:

locators.append(yaxis.get_major_locator())

locators.append(yaxis.get_minor_locator())

if zaxis is not None:

locators.append(zaxis.get_major_locator())

locators.append(zaxis.get_minor_locator())

for loc in locators:

mpl.ticker._if_refresh_overridden_call_and_emit_deprec(loc)

self.figure.canvas.draw_idle()

def home(self):

"""Recall the first view and position from the stack."""

self.views[self.figure].home()

self.positions[self.figure].home()

def back(self):

"""Back one step in the stack of views and positions."""

self.views[self.figure].back()

self.positions[self.figure].back()

def forward(self):

"""Forward one step in the stack of views and positions."""

self.views[self.figure].forward()

"""Base class for `ToolHome`, `ToolBack` and `ToolForward`."""

_on_trigger = None

def trigger(self, sender, event, data=None):

self.toolmanager.get_tool(_views_positions).add_figure(self.figure)

getattr(self.toolmanager.get_tool(_views_positions),

self._on_trigger)()

"""Restore the original view limits."""

description = 'Reset original view'

image = 'home'

default_keymap = mpl.rcParams['keymap.home']

"""Move back up the view limits stack."""

description = 'Back to previous view'

image = 'back'

default_keymap = mpl.rcParams['keymap.back']

"""Move forward in the view lim stack."""

description = 'Forward to next view'

image = 'forward'

default_keymap = mpl.rcParams['keymap.forward']

"""Base tool for the configuration of subplots."""

description = 'Configure subplots'

"""Base tool for figure saving."""

description = 'Save the figure'

image = 'filesave'

"""Base class for `ToolZoom` and `ToolPan`."""

def __init__(self, *args):

ToolToggleBase.__init__(self, *args)

self._button_pressed = None

self._xypress = None

self._idPress = None

self._idRelease = None

self._idScroll = None

self.base_scale = 2.

self.scrollthresh = .5 # .5 second scroll threshold

self.lastscroll = time.time()-self.scrollthresh

def enable(self, event):

"""Connect press/release events and lock the canvas."""

self.figure.canvas.widgetlock(self)

self._idPress = self.figure.canvas.mpl_connect(

'button_press_event', self._press)

self._idRelease = self.figure.canvas.mpl_connect(

'button_release_event', self._release)

self._idScroll = self.figure.canvas.mpl_connect(

'scroll_event', self.scroll_zoom)

def disable(self, event):

"""Release the canvas and disconnect press/release events."""

self._cancel_action()

self.figure.canvas.widgetlock.release(self)

self.figure.canvas.mpl_disconnect(self._idPress)

self.figure.canvas.mpl_disconnect(self._idRelease)

self.figure.canvas.mpl_disconnect(self._idScroll)

def trigger(self, sender, event, data=None):

self.toolmanager.get_tool(_views_positions).add_figure(self.figure)

ToolToggleBase.trigger(self, sender, event, data)

def scroll_zoom(self, event):

# https://gist.github.com/tacaswell/3144287

if event.inaxes is None:

return

if event.button == 'up':

# deal with zoom in

scl = self.base_scale

elif event.button == 'down':

# deal with zoom out

scl = 1/self.base_scale

else:

# deal with something that should never happen

scl = 1

ax = event.inaxes

ax._set_view_from_bbox([event.x, event.y, scl])

# If last scroll was done within the timing threshold, delete the

# previous view

if (time.time()-self.lastscroll) < self.scrollthresh:

self.toolmanager.get_tool(_views_positions).back()

self.figure.canvas.draw_idle() # force re-draw

self.lastscroll = time.time()

"""A Tool for zooming using a rectangle selector."""

description = 'Zoom to rectangle'

image = 'zoom_to_rect'

default_keymap = mpl.rcParams['keymap.zoom']

cursor = cursors.SELECT_REGION

radio_group = 'default'

def __init__(self, *args):

ZoomPanBase.__init__(self, *args)

self._ids_zoom = []

def _cancel_action(self):

for zoom_id in self._ids_zoom:

self.figure.canvas.mpl_disconnect(zoom_id)

self.toolmanager.trigger_tool('rubberband', self)

self.toolmanager.get_tool(_views_positions)._refresh_locators()

self._xypress = None

self._button_pressed = None

self._ids_zoom = []

return

def _press(self, event):

"""Callback for mouse button presses in zoom-to-rectangle mode."""

# If we're already in the middle of a zoom, pressing another

# button works to "cancel"

if self._ids_zoom:

self._cancel_action()

if event.button == 1:

self._button_pressed = 1

elif event.button == 3:

self._button_pressed = 3

else:

self._cancel_action()

return

x, y = event.x, event.y

self._xypress = []

for i, a in enumerate(self.figure.get_axes()):

if (x is not None and y is not None and a.in_axes(event) and

a.get_navigate() and a.can_zoom()):

self._xypress.append((x, y, a, i, a._get_view()))

id1 = self.figure.canvas.mpl_connect(

'motion_notify_event', self._mouse_move)

id2 = self.figure.canvas.mpl_connect(

'key_press_event', self._switch_on_zoom_mode)

id3 = self.figure.canvas.mpl_connect(

'key_release_event', self._switch_off_zoom_mode)

self._ids_zoom = id1, id2, id3

self._zoom_mode = event.key

def _switch_on_zoom_mode(self, event):

self._zoom_mode = event.key

self._mouse_move(event)

def _switch_off_zoom_mode(self, event):

self._zoom_mode = None

self._mouse_move(event)

def _mouse_move(self, event):

"""Callback for mouse moves in zoom-to-rectangle mode."""

if self._xypress:

x, y = event.x, event.y

lastx, lasty, a, ind, view = self._xypress[0]

(x1, y1), (x2, y2) = np.clip(

[[lastx, lasty], [x, y]], a.bbox.min, a.bbox.max)

if self._zoom_mode == "x":

y1, y2 = a.bbox.intervaly

elif self._zoom_mode == "y":

x1, x2 = a.bbox.intervalx

self.toolmanager.trigger_tool(

'rubberband', self, data=(x1, y1, x2, y2))

def _release(self, event):

"""Callback for mouse button releases in zoom-to-rectangle mode."""

for zoom_id in self._ids_zoom:

self.figure.canvas.mpl_disconnect(zoom_id)

self._ids_zoom = []

if not self._xypress:

self._cancel_action()

return

last_a = []

for cur_xypress in self._xypress:

x, y = event.x, event.y

lastx, lasty, a, _ind, view = cur_xypress

# ignore singular clicks - 5 pixels is a threshold

if abs(x - lastx) < 5 or abs(y - lasty) < 5:

self._cancel_action()

return

# detect twinx, twiny axes and avoid double zooming

twinx, twiny = False, False

if last_a:

for la in last_a:

if a.get_shared_x_axes().joined(a, la):

twinx = True

if a.get_shared_y_axes().joined(a, la):

twiny = True

last_a.append(a)

if self._button_pressed == 1:

direction = 'in'

elif self._button_pressed == 3:

direction = 'out'

else:

continue

a._set_view_from_bbox((lastx, lasty, x, y), direction,

self._zoom_mode, twinx, twiny)

self._zoom_mode = None

self.toolmanager.get_tool(_views_positions).push_current()

"""Pan axes with left mouse, zoom with right."""

default_keymap = mpl.rcParams['keymap.pan']

description = 'Pan axes with left mouse, zoom with right'

image = 'move'

cursor = cursors.MOVE

radio_group = 'default'

def __init__(self, *args):

ZoomPanBase.__init__(self, *args)

self._id_drag = None

def _cancel_action(self):

self._button_pressed = None

self._xypress = []

self.figure.canvas.mpl_disconnect(self._id_drag)

self.toolmanager.messagelock.release(self)

self.toolmanager.get_tool(_views_positions)._refresh_locators()

def _press(self, event):

if event.button == 1:

self._button_pressed = 1

elif event.button == 3:

self._button_pressed = 3

else:

self._cancel_action()

return

x, y = event.x, event.y

self._xypress = []

for i, a in enumerate(self.figure.get_axes()):

if (x is not None and y is not None and a.in_axes(event) and

a.get_navigate() and a.can_pan()):

a.start_pan(x, y, event.button)

self._xypress.append((a, i))

self.toolmanager.messagelock(self)

self._id_drag = self.figure.canvas.mpl_connect(

'motion_notify_event', self._mouse_move)

def _release(self, event):

if self._button_pressed is None:

self._cancel_action()

return

self.figure.canvas.mpl_disconnect(self._id_drag)

self.toolmanager.messagelock.release(self)

for a, _ind in self._xypress:

a.end_pan()

if not self._xypress:

self._cancel_action()

return

self.toolmanager.get_tool(_views_positions).push_current()

self._cancel_action()

def _mouse_move(self, event):

for a, _ind in self._xypress:

# safer to use the recorded button at the _press than current

# button: # multiple button can get pressed during motion...

a.drag_pan(self._button_pressed, event.key, event.x, event.y)

description = 'Print tool list, shortcuts and description'

default_keymap = mpl.rcParams['keymap.help']

image = 'help'

@staticmethod

def format_shortcut(key_sequence):

"""