matplotlib-devel Mailing List for matplotlib

When using unitized data any call to 'set_xlim' or 'set_ylim' will reset any user specified labels or tickers for a given axis and
replace it with the values specified via the unitized data 'axisinfo'
See the following for an example:
###########################################
from basic_units import cm, inch
from pylab import figure, show
import numpy
cms = cm *numpy.arange(0, 10, 2)
fig = figure()
ax1 = fig.add_subplot(2,2,1)
ax1.plot(cms, cms)
ax2 = fig.add_subplot(2,2,2)
ax2.plot(cms, cms, xunits=cm, yunits=inch)
ax3 = fig.add_subplot(2,2,3)
ax3.plot(cms, cms, xunits=inch, yunits=cm)
ax3.set_xlabel( "My Label" )
ax3.set_xlim(3, 6) # scalars are interpreted in current units
# Since we call set_xlim with unitized data, the label will be reset.
ax4 = fig.add_subplot(2,2,4)
ax4.plot(cms, cms, xunits=inch, yunits=inch)
ax4.set_xlabel( "My Label" )
ax4.set_xlim(3*cm, 6*cm) # cm are converted to inches
show()
###########################################
--James Evans

On Fri, Feb 08, 2008 at 08:15:20AM +0100, Gael Varoquaux wrote:
> On Thu, Feb 07, 2008 at 11:31:11AM -0500, Paul Kienzle wrote:
> > There are two ways to do this in wx. 
> 
> > One is to use eventloop.Dispatch() which waits until the next available
> > event:
> 
> > [...]
> 
> > The other is to trigger a loop.Exit() from the click callback. 
> 
> > [...]
> 
> Very nice. I am impressed. We need to find a way of doing the same in
> other toolkits. Way can however change the function call flush_event to
> give it an "until" callback (and maybe rename it to
> "wait_interactively"), and move the busy waiting code in the
> backend-dependant part of the code. That way we can remove it backend
> after backend.
Having played with both "flush_until" and "start/stop" I have to say I
prefer the start/stop interface. It removes the need for users to share
a 'done' variable between the callback and the caller and the need to 
create a dummy lambda:done function. Also, it is a better match to
the semantics of wx/gtk/qt (see below).
I don't like the names start_event_loop/stop_event_loop, but couldn't 
think of anything better. How about: gui_wait/end_wait?
 - Paul
-----
Proposed generic implementation based on flush_event and sleep, to be
put into CanvasBase:
 def gui_wait(self, timeout=0):
 """Run the event loop."""
 if timeout == 0: timeout = npy.inf
 timestep = 0.01
 counter = 0
 self._waiting = True
 while self._waiting and counter*timestep < timeout:
 self.flush_events()
 time.sleep(timestep)
 counter += 1
 def end_wait(self):
 """Stop the event loop."""
 self._waiting = False
Suggested implementation for backend_gtk (untested!!!):
 def gui_wait(self, timeout=0):
 """Run the gtk event loop."""
 # TODO: call self.end_wait() on window close
 self._waiting = True
 if timeout > 0:
 timer = gtk.gobject.timeout_add(timeout,self._onTimer)
 gtk.main()
 self._waiting = False
 gobject.source_remove(timer)
 def _onTimer(self):
 self.end_wait()
 return False
 def end_wait(self):
 """Stop the gtk event loop."""
 if self._waiting: gtk.main_quit()

On Thu, Feb 07, 2008 at 11:31:11AM -0500, Paul Kienzle wrote:
> There are two ways to do this in wx. 
> One is to use eventloop.Dispatch() which waits until the next available
> event:
> [...]
> The other is to trigger a loop.Exit() from the click callback. 
> [...]
Very nice. I am impressed. We need to find a way of doing the same in
other toolkits. Way can however change the function call flush_event to
give it an "until" callback (and maybe rename it to
"wait_interactively"), and move the busy waiting code in the
backend-dependant part of the code. That way we can remove it backend
after backend.
I can contribute a bit to this refactoring, but give me a couple of weeks
before.
Cheers,
Gaël