"""

# FIXME: This docstring ends abruptly without...

def __init__(self):

self._owner = None

def __call__(self, o):

'reserve the lock for *o*'

if not self.available(o):

raise ValueError('already locked')

self._owner = o

def release(self, o):

'release the lock'

if not self.available(o):

raise ValueError('you do not own this lock')

self._owner = None

def available(self, o):

'drawing is available to *o*'

return not self.locked() or self.isowner(o)

def isowner(self, o):

'Return True if *o* owns this lock'

return self._owner is o

def locked(self):

'Return True if the lock is currently held by an owner'

"""

drawon = True

"""Widget that is connected to a single :class:`~matplotlib.axes.Axes`.

def __init__(self, ax):

self.ax = ax

self.canvas = ax.figure.canvas

self.cids = []

self.active = True

def connect_event(self, event, callback):

"""Connect callback with an event.

cid = self.canvas.mpl_connect(event, callback)

self.cids.append(cid)

def disconnect_events(self):

"""Disconnect all events created by this widget."""

for c in self.cids:

self.canvas.mpl_disconnect(c)

def ignore(self, event):

"""Return True if event should be ignored.

"""

def __init__(self, ax, label, image=None,

color='0.85', hovercolor='0.95'):

"""

AxesWidget.__init__(self, ax)

if image is not None:

ax.imshow(image)

self.label = ax.text(0.5, 0.5, label,

verticalalignment='center',

horizontalalignment='center',

transform=ax.transAxes)

self.cnt = 0

self.observers = {}

self.connect_event('button_press_event', self._click)

self.connect_event('button_release_event', self._release)

self.connect_event('motion_notify_event', self._motion)

ax.set_navigate(False)

ax.set_axis_bgcolor(color)

ax.set_xticks([])

ax.set_yticks([])

self.color = color

self.hovercolor = hovercolor

self._lastcolor = color

def _click(self, event):

if self.ignore(event):

return

if event.inaxes != self.ax:

return

if not self.eventson:

return

if event.canvas.mouse_grabber != self.ax:

event.canvas.grab_mouse(self.ax)

def _release(self, event):

if self.ignore(event):

return

if event.canvas.mouse_grabber != self.ax:

return

event.canvas.release_mouse(self.ax)

if not self.eventson:

return

if event.inaxes != self.ax:

return

for cid, func in self.observers.iteritems():

func(event)

def _motion(self, event):

if self.ignore(event):

return

if event.inaxes==self.ax:

c = self.hovercolor

else:

c = self.color

if c != self._lastcolor:

self.ax.set_axis_bgcolor(c)

self._lastcolor = c

if self.drawon: self.ax.figure.canvas.draw()

def on_clicked(self, func):

"""

cid = self.cnt

self.observers[cid] = func

self.cnt += 1

return cid

def disconnect(self, cid):

'remove the observer with connection id *cid*'

try: del self.observers[cid]

"""

def __init__(self, ax, label, valmin, valmax, valinit=0.5, valfmt='%1.2f',

closedmin=True, closedmax=True, slidermin=None, slidermax=None,

dragging=True, **kwargs):

"""

AxesWidget.__init__(self, ax)

self.valmin = valmin

self.valmax = valmax

self.val = valinit

self.valinit = valinit

self.poly = ax.axvspan(valmin,valinit,0,1, **kwargs)

self.vline = ax.axvline(valinit,0,1, color='r', lw=1)

self.valfmt=valfmt

ax.set_yticks([])

ax.set_xlim((valmin, valmax))

ax.set_xticks([])

ax.set_navigate(False)

self.connect_event('button_press_event', self._update)

self.connect_event('button_release_event', self._update)

if dragging:

self.connect_event('motion_notify_event', self._update)

self.label = ax.text(-0.02, 0.5, label, transform=ax.transAxes,

verticalalignment='center',

horizontalalignment='right')

self.valtext = ax.text(1.02, 0.5, valfmt%valinit,

transform=ax.transAxes,

verticalalignment='center',

horizontalalignment='left')

self.cnt = 0

self.observers = {}

self.closedmin = closedmin

self.closedmax = closedmax

self.slidermin = slidermin

self.slidermax = slidermax

self.drag_active = False

def _update(self, event):

'update the slider position'

if self.ignore(event):

return

if event.button != 1:

return

if event.name == 'button_press_event' and event.inaxes == self.ax:

self.drag_active = True

event.canvas.grab_mouse(self.ax)

if not self.drag_active:

return

elif ((event.name == 'button_release_event')

or (event.name == 'button_press_event' and event.inaxes != self.ax)):

self.drag_active = False

event.canvas.release_mouse(self.ax)

return

val = event.xdata

if val <= self.valmin:

if not self.closedmin:

return

val = self.valmin

elif val >= self.valmax:

if not self.closedmax:

return

val = self.valmax

if self.slidermin is not None and val <= self.slidermin.val:

if not self.closedmin:

return

val = self.slidermin.val

if self.slidermax is not None and val >= self.slidermax.val:

if not self.closedmax:

return

val = self.slidermax.val

self.set_val(val)

def set_val(self, val):

xy = self.poly.xy

xy[2] = val, 1

xy[3] = val, 0

self.poly.xy = xy

self.valtext.set_text(self.valfmt%val)

if self.drawon: self.ax.figure.canvas.draw()

self.val = val

if not self.eventson: return

for cid, func in self.observers.iteritems():

func(val)

def on_changed(self, func):

"""

cid = self.cnt

self.observers[cid] = func

self.cnt += 1

return cid

def disconnect(self, cid):

'remove the observer with connection id *cid*'

try: del self.observers[cid]

except KeyError: pass

def reset(self):

"reset the slider to the initial value if needed"

if (self.val != self.valinit):

"""

def __init__(self, ax, labels, actives):

"""

AxesWidget.__init__(self, ax)

ax.set_xticks([])

ax.set_yticks([])

ax.set_navigate(False)

if len(labels)>1:

dy = 1./(len(labels)+1)

ys = np.linspace(1-dy, dy, len(labels))

else:

dy = 0.25

ys = [0.5]

cnt = 0

axcolor = ax.get_axis_bgcolor()

self.labels = []

self.lines = []

self.rectangles = []

lineparams = {'color':'k', 'linewidth':1.25, 'transform':ax.transAxes,

'solid_capstyle':'butt'}

for y, label in zip(ys, labels):

t = ax.text(0.25, y, label, transform=ax.transAxes,

horizontalalignment='left',

verticalalignment='center')

w, h = dy/2., dy/2.

x, y = 0.05, y-h/2.

p = Rectangle(xy=(x,y), width=w, height=h,

facecolor=axcolor,

transform=ax.transAxes)

l1 = Line2D([x, x+w], [y+h, y], **lineparams)

l2 = Line2D([x, x+w], [y, y+h], **lineparams)

l1.set_visible(actives[cnt])

l2.set_visible(actives[cnt])

self.labels.append(t)

self.rectangles.append(p)

self.lines.append((l1,l2))

ax.add_patch(p)

ax.add_line(l1)

ax.add_line(l2)

cnt += 1

self.connect_event('button_press_event', self._clicked)

self.cnt = 0

self.observers = {}

def _clicked(self, event):

if self.ignore(event):

return

if event.button !=1 : return

if event.inaxes != self.ax: return

for p,t,lines in zip(self.rectangles, self.labels, self.lines):

if (t.get_window_extent().contains(event.x, event.y) or

p.get_window_extent().contains(event.x, event.y) ):

l1, l2 = lines

l1.set_visible(not l1.get_visible())

l2.set_visible(not l2.get_visible())

thist = t

break

else:

return

if self.drawon: self.ax.figure.canvas.draw()

if not self.eventson: return

for cid, func in self.observers.iteritems():

func(thist.get_text())

def on_clicked(self, func):

"""

cid = self.cnt

self.observers[cid] = func

self.cnt += 1

return cid

def disconnect(self, cid):

'remove the observer with connection id *cid*'

try: del self.observers[cid]

"""

def __init__(self, ax, labels, active=0, activecolor='blue'):

"""

AxesWidget.__init__(self, ax)

self.activecolor = activecolor

ax.set_xticks([])

ax.set_yticks([])

ax.set_navigate(False)

dy = 1./(len(labels)+1)

ys = np.linspace(1-dy, dy, len(labels))

cnt = 0

axcolor = ax.get_axis_bgcolor()

self.labels = []

self.circles = []

for y, label in zip(ys, labels):

t = ax.text(0.25, y, label, transform=ax.transAxes,

horizontalalignment='left',

verticalalignment='center')

if cnt==active:

facecolor = activecolor

else:

facecolor = axcolor

p = Circle(xy=(0.15, y), radius=0.05, facecolor=facecolor,

transform=ax.transAxes)

self.labels.append(t)

self.circles.append(p)

ax.add_patch(p)

cnt += 1

self.connect_event('button_press_event', self._clicked)

self.cnt = 0

self.observers = {}

def _clicked(self, event):

if self.ignore(event):

return

if event.button !=1 : return

if event.inaxes != self.ax: return

xy = self.ax.transAxes.inverted().transform_point((event.x, event.y))

pclicked = np.array([xy[0], xy[1]])

def inside(p):

pcirc = np.array([p.center[0], p.center[1]])

return dist(pclicked, pcirc) < p.radius

for p,t in zip(self.circles, self.labels):

if t.get_window_extent().contains(event.x, event.y) or inside(p):

inp = p

thist = t

break

else: return

for p in self.circles:

if p==inp: color = self.activecolor

else: color = self.ax.get_axis_bgcolor()

p.set_facecolor(color)

if self.drawon: self.ax.figure.canvas.draw()

if not self.eventson: return

for cid, func in self.observers.iteritems():

func(thist.get_text())

def on_clicked(self, func):

"""

cid = self.cnt

self.observers[cid] = func

self.cnt += 1

return cid

def disconnect(self, cid):

'remove the observer with connection id *cid*'

try: del self.observers[cid]

"""

def __init__(self, targetfig, toolfig):

"""

# FIXME: The docstring seems to just abruptly end without...

self.targetfig = targetfig

toolfig.subplots_adjust(left=0.2, right=0.9)

class toolbarfmt:

def __init__(self, slider):

self.slider = slider

def __call__(self, x, y):

fmt = '%s=%s'%(self.slider.label.get_text(), self.slider.valfmt)

return fmt%x

self.axleft = toolfig.add_subplot(711)

self.axleft.set_title('Click on slider to adjust subplot param')

self.axleft.set_navigate(False)

self.sliderleft = Slider(self.axleft, 'left', 0, 1, targetfig.subplotpars.left, closedmax=False)

self.sliderleft.on_changed(self.funcleft)

self.axbottom = toolfig.add_subplot(712)

self.axbottom.set_navigate(False)

self.sliderbottom = Slider(self.axbottom, 'bottom', 0, 1, targetfig.subplotpars.bottom, closedmax=False)

self.sliderbottom.on_changed(self.funcbottom)

self.axright = toolfig.add_subplot(713)

self.axright.set_navigate(False)

self.sliderright = Slider(self.axright, 'right', 0, 1, targetfig.subplotpars.right, closedmin=False)

self.sliderright.on_changed(self.funcright)

self.axtop = toolfig.add_subplot(714)

self.axtop.set_navigate(False)

self.slidertop = Slider(self.axtop, 'top', 0, 1, targetfig.subplotpars.top, closedmin=False)

self.slidertop.on_changed(self.functop)

self.axwspace = toolfig.add_subplot(715)

self.axwspace.set_navigate(False)

self.sliderwspace = Slider(self.axwspace, 'wspace', 0, 1, targetfig.subplotpars.wspace, closedmax=False)

self.sliderwspace.on_changed(self.funcwspace)

self.axhspace = toolfig.add_subplot(716)

self.axhspace.set_navigate(False)

self.sliderhspace = Slider(self.axhspace, 'hspace', 0, 1, targetfig.subplotpars.hspace, closedmax=False)

self.sliderhspace.on_changed(self.funchspace)

# constraints

self.sliderleft.slidermax = self.sliderright

self.sliderright.slidermin = self.sliderleft

self.sliderbottom.slidermax = self.slidertop

self.slidertop.slidermin = self.sliderbottom

bax = toolfig.add_axes([0.8, 0.05, 0.15, 0.075])

self.buttonreset = Button(bax, 'Reset')

sliders = (self.sliderleft, self.sliderbottom, self.sliderright,

self.slidertop, self.sliderwspace, self.sliderhspace, )

def func(event):

thisdrawon = self.drawon

self.drawon = False

# store the drawon state of each slider

bs = []

for slider in sliders:

bs.append(slider.drawon)

slider.drawon = False

# reset the slider to the initial position

for slider in sliders:

slider.reset()

# reset drawon

for slider, b in zip(sliders, bs):

slider.drawon = b

# draw the canvas

self.drawon = thisdrawon

if self.drawon:

toolfig.canvas.draw()

self.targetfig.canvas.draw()

# during reset there can be a temporary invalid state

# depending on the order of the reset so we turn off

# validation for the resetting

validate = toolfig.subplotpars.validate

toolfig.subplotpars.validate = False

self.buttonreset.on_clicked(func)

toolfig.subplotpars.validate = validate

def funcleft(self, val):

self.targetfig.subplots_adjust(left=val)

if self.drawon: self.targetfig.canvas.draw()

def funcright(self, val):

self.targetfig.subplots_adjust(right=val)

if self.drawon: self.targetfig.canvas.draw()

def funcbottom(self, val):

self.targetfig.subplots_adjust(bottom=val)

if self.drawon: self.targetfig.canvas.draw()

def functop(self, val):

self.targetfig.subplots_adjust(top=val)

if self.drawon: self.targetfig.canvas.draw()

def funcwspace(self, val):

self.targetfig.subplots_adjust(wspace=val)

if self.drawon: self.targetfig.canvas.draw()

def funchspace(self, val):

self.targetfig.subplots_adjust(hspace=val)

"""

def __init__(self, ax, useblit=False, **lineprops):

"""

# TODO: Is the GTKAgg limitation still true?

AxesWidget.__init__(self, ax)

self.connect_event('motion_notify_event', self.onmove)

self.connect_event('draw_event', self.clear)

self.visible = True

self.horizOn = True

self.vertOn = True

self.useblit = useblit

if useblit:

lineprops['animated'] = True

self.lineh = ax.axhline(ax.get_ybound()[0], visible=False, **lineprops)

self.linev = ax.axvline(ax.get_xbound()[0], visible=False, **lineprops)

self.background = None

self.needclear = False

def clear(self, event):

'clear the cursor'

if self.ignore(event):

return

if self.useblit:

self.background = self.canvas.copy_from_bbox(self.ax.bbox)

self.linev.set_visible(False)

self.lineh.set_visible(False)

def onmove(self, event):

'on mouse motion draw the cursor if visible'

if self.ignore(event):

return

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

return

if event.inaxes != self.ax:

self.linev.set_visible(False)

self.lineh.set_visible(False)

if self.needclear:

self.canvas.draw()

self.needclear = False

return

self.needclear = True

if not self.visible: return

self.linev.set_xdata((event.xdata, event.xdata))

self.lineh.set_ydata((event.ydata, event.ydata))

self.linev.set_visible(self.visible and self.vertOn)

self.lineh.set_visible(self.visible and self.horizOn)

self._update()

def _update(self):

if self.useblit:

if self.background is not None:

self.canvas.restore_region(self.background)

self.ax.draw_artist(self.linev)

self.ax.draw_artist(self.lineh)

self.canvas.blit(self.ax.bbox)

else:

self.canvas.draw_idle()

"""

def __init__(self, canvas, axes, useblit=True, **lineprops):

self.canvas = canvas

self.axes = axes

xmin, xmax = axes[-1].get_xlim()

xmid = 0.5*(xmin+xmax)

if useblit:

lineprops['animated'] = True

self.lines = [ax.axvline(xmid, visible=False, **lineprops)

for ax in axes]

self.visible = True

self.useblit = useblit

self.background = None

self.needclear = False

self.canvas.mpl_connect('motion_notify_event', self.onmove)

self.canvas.mpl_connect('draw_event', self.clear)

def clear(self, event):

'clear the cursor'

if self.useblit:

self.background = self.canvas.copy_from_bbox(

self.canvas.figure.bbox)

for line in self.lines:

line.set_visible(False)

def onmove(self, event):

if event.inaxes is None:

return

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

return

self.needclear = True

if not self.visible:

return

for line in self.lines:

line.set_xdata((event.xdata, event.xdata))

line.set_visible(self.visible)

self._update()

def _update(self):

if self.useblit:

if self.background is not None:

self.canvas.restore_region(self.background)

for ax, line in zip(self.axes, self.lines):

ax.draw_artist(line)

self.canvas.blit(self.canvas.figure.bbox)

else:

"""

def __init__(self, ax, onselect, direction, minspan=None, useblit=False,

rectprops=None, onmove_callback=None):

"""

AxesWidget.__init__(self, ax)