matplotlib-devel Mailing List for matplotlib

On Wed, Feb 06, 2008 at 01:21:30AM +0100, Gael Varoquaux wrote:
> On Tue, Feb 05, 2008 at 07:16:59PM -0500, Paul Kienzle wrote:
> > I'll look around some more and see if I can find the sleep until next
> > event function in wx.
> 
> Yeah, sleep, I need more of that. Or maybe you can find wx.coffee ?

Sleep not found, despite half the night trying.   

What follows three experiments I tried, but now I'm out of ideas.  The
last thing to do would be to follow your suggestion and move the busy 
loop from ginput to CanvasBase and let the individual backends override 
with a better solution if available.

	- Paul

Attempted solutions for modal wx event processing:

1. Run a private event loop with a timer every 0.1s to see if the user
has done selecting.  This works, but it doesn't like it if the window
is closed before completion. I didn't test for it, but super-fast
clicking should let the user sometimes select an extra point, so not
a great solution.

    def event_loop(self, done=lambda:False, timeout=0):
        'run the eventloop until done or timeout'
        print "Running private event loop"
        loop = wx.EventLoop()
        
        # stop after timeout period
        def donewaiting(*args,**kw):
            print "Done waiting"
            loop.Exit()
        if timeout > 0:
            print "Starting timer"
            outtimer = wx.Timer(self, id=MODAL_TIMEOUT_TIMER)
            outtimer.Start(timeout*1000, oneShot=True)
            self.Bind(wx.EVT_TIMER, donewaiting, outtimer)

        # check if done every 0.1 s
        def checkdone(*args,**kw):
            if done(): loop.Exit()
        steptimer = wx.Timer(self, id=MODAL_STEP_TIMER)
        steptimer.Start(100, oneShot=False)
        self.Bind(wx.EVT_TIMER, checkdone, steptimer)
    
        loop.Run()
        steptimer.Stop()
        return

2. What seems like it should work is to use an event handler which
checks after processing each event whether or not this completes
the condition and so we can exit the loop.  However, ProcessEvent 
never seems to be called.  Reading elsewhere I see that ProcessEvent 
is not a virtual function in wx, so presumably we can't override
it in a subclass of wx.EvtHandler.


        # Redirect input events to new handler
        class ModalHandler(wx.EvtHandler):
            def ProcessEvent(self, evt):
                print "Processing event"
                if done(): loop.Exit()
                return False # True if processed
        print "Pushing handler"
        handler = ModalHandler()
        self.PushEventHandler(handler)
        print "enabled",handler.GetEvtHandlerEnabled()
        print "handler->next",handler.GetNextHandler()
        print "self->previous",self.GetPreviousHandler()
        loop.Run()
        self.PopEventHandler(False)
        print "Done!"

3. Revising two somewhat, I send all events for the canvas through
my own event handler.  To make sure I see each one I bind each window
event to my own dispatcher as well as to the underlying window.  I
then use this handler rather than self in the canvas __init__.

This fails because either the window handler is not called or it
is called twice, depending on whether PushEventHandler and ProcessEvent
are called.  It also fails if the window is closed unexpectedly.

class ModalHandler(wx.EvtHandler):
    def __init__(self, window):
        print "Creating handler"
        wx.EvtHandler.__init__(self)
        self.done = lambda:False
        window.PushEventHandler(self)
        self.window = window
        self.timer = wx.Timer()
        self.Bind(wx.EVT_TIMER, self.OnTimeout, self.timer)
        self.loop = wx.EventLoop()
    def _dispatch(self, evt):
        """Ick! ProcessEvent is not virtual, so we can't override directly!"""
        #print "Processing event"
        self.window.ProcessEvent(evt)
        if self.done(): self.loop.Exit()
        print "Returning event"
        return True
    def EndModal(self):
        """Force the loop to exit"""
        self.done = lambda:True
    def Bind(self,evt,action,*args,**kw):
        # Force all events through ProcessEvent.  This is the first binding.
        # ProcessEvent will dispatch the event to the window itself, so be
        # sure to tell the window what to do with the event.  This is the
        # second binding.
        if wx.VERSION_STRING >= '2.5':  # Event handlers 2.5
            print "Binding 2.5"
            wx.EvtHandler.Bind(self.window,evt,action,*args,**kw)
            wx.EvtHandler.Bind(self,evt,self._dispatch)
        else:
            print "Binding 2.4"
            evt(self,self.ProcessEvent)
            evt(self.window,*args,**kw)
    def OnTimeout(self):
        print "timeout"
        self.loop.Exit()
    def RunLoop(self, done=lambda:False, timeout=0):
        print "Running loop"
        self.done = done
        if timeout > 0: self.timer.Start(timeout, oneShot=True)
        try:
            self.loop.Run()
        finally:
            self.timer.Stop()
            self.done = lambda:False

On Tue, Feb 05, 2008 at 07:16:59PM -0500, Paul Kienzle wrote:
> How about giving flush_events() an until=condition and timeout=n keywords 
> so that flush_events becomes:

>         if timeout > 0: set timer event which triggers out_of_time
> 	while get next event:
>            process event
>            if out_of_time or until(): break

I'd say this is exactly the way to do it. The problem is that under GTK
is seems fairly easy to do, under Tk it seems feasible, but under Qt and
under Wx I have no clue how to do this. We can always fallback to
busy-waiting for these toolkits.

This indeed seems to be the way to go. Maybe I would empty the event
stack when the "until()" condition is met, before returning to the
caller, and thus blocking again.

> I'll look around some more and see if I can find the sleep until next
> event function in wx.

Yeah, sleep, I need more of that. Or maybe you can find wx.coffee ?

Cheers,

Gaël

On Wed, Feb 06, 2008 at 12:38:32AM +0100, Gael Varoquaux wrote:
> On Tue, Feb 05, 2008 at 06:30:53PM -0500, Paul Kienzle wrote:
> > Setting the timeout to 0.01s for the busy loop in ginput seems excessive.
> > Since it is waiting for human interaction, generally 0.1 seconds is good
> > enough.
> 
> I had gone for that originally, but it looked quite ugly when moving the
> window around. This busy waiting is quite ugly, but I have found a way of
> avoid it. IMHO it should be done in the toolkit's event loop, but it
> seems that trying to do it this would add gobbles of code for little
> gain.

How about giving flush_events() an until=condition and timeout=n keywords 
so that flush_events becomes:

        if timeout > 0: set timer event which triggers out_of_time
	while get next event:
           process event
           if out_of_time or until(): break

Looking through wx I don't see how to "get next event", my choices being
run all events (MainLoop) or run pending events.  I do see an "exit main
loop" function, so for wx at least one could redirect the event handler 
for the window and run all the events, exiting the main loop when done,
but that seems ugly.  I'll look around some more and see if I can find
the sleep until next event function in wx.

 	- Paul