X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/299647acac7960652aadb008775429c1f8ea9b8d..db679b8c836e69c111cdc31e62cf92cebe4f938f:/wxPython/demo/Timer.py?ds=sidebyside diff --git a/wxPython/demo/Timer.py b/wxPython/demo/Timer.py index 7f71b1f442..22b7192a2c 100644 --- a/wxPython/demo/Timer.py +++ b/wxPython/demo/Timer.py @@ -1,89 +1,267 @@ -# 11/21/2003 - Jeff Grimmett (grimmtooth@softhome.net) -# -# o Updated for wx namespace -# - import time import wx +import wx.lib.scrolledpanel as sp + +#---------------------------------------------------------------------- + + +header = """\ +This demo shows the various ways that wx.Timers can be used in your code. Just +select one of the buttons in the left column to start a timer in the indicated way, +and watch the log window below for messages printed when the timer event or callback +happens. Clicking the corresponding button on the right will stop that timer. Since +timers are not owned by any other wx object you should hold on to a reference to the +timer until you are completely finished with it. """ + +doc1 = """\ +Binding an event handler to the wx.EVT_TIMER event is the +prefered way to use the wx.Timer class directly. It makes +handling timer events work just like normal window events. You +just need to specify the window that is to receive the event in +the wx.Timer constructor. If that window needs to be able to +receive events from more than one timer then you can optionally +specify an ID for the timer and the event binding. +""" -#--------------------------------------------------------------------------- -## For your convenience; an example of creating your own timer class. -## -## class TestTimer(wxTimer): -## def __init__(self, log = None): -## wxTimer.__init__(self) -## self.log = log -## def Notify(self): -## wxBell() -## if self.log: -## self.log.WriteText('beep!\n') +doc2 = """\ +wx.FutureCall is a convenience class for wx.Timer. You just +specify the timeout in milliseconds and a callable object, along +with any ard or keyword arg you woudl like to be passed to your +callable, and wx.FutureCall takes care of the rest. If you don't +need to get the return value of the callable or to restart the +timer then there is no need to hold a reference to this object. +""" + + +doc3 = """\ +If you derive a class from wx.Timer and give it a Notify method +then it will be called when the timer expires. +""" + -#--------------------------------------------------------------------------- +doc4 = """\ +wx.PyTimer is the old way (a kludge that goes back all the way to +the first version of wxPython) to bind a timer directly to a +callable. You should migrate any code that uses this method to +use EVT_TIMER instead as this may be deprecated in the future. +""" -ID_Start = wx.NewId() -ID_Stop = wx.NewId() -ID_Timer = wx.NewId() -ID_Timer2 = wx.NewId() -class TestTimerWin(wx.Panel): +class TestPanel(sp.ScrolledPanel): def __init__(self, parent, log): - wx.Panel.__init__(self, parent, -1) self.log = log + sp.ScrolledPanel.__init__(self, parent, -1) + + outsideSizer = wx.BoxSizer(wx.VERTICAL) + + text = wx.StaticText(self, -1, "wx.Timer", style=wx.ALIGN_CENTRE) + text.SetFont(wx.Font(24, wx.SWISS, wx.NORMAL, wx.BOLD, False)) + text.SetSize(text.GetBestSize()) + text.SetForegroundColour(wx.BLUE) + outsideSizer.Add(text, 0, wx.EXPAND|wx.ALL, 5) + outsideSizer.Add(wx.StaticText(self, -1, header), 0, wx.ALIGN_CENTER|wx.ALL, 5) + outsideSizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND) + outsideSizer.Add((20,20)) + + + t1b1 = wx.Button(self, -1, "EVT_TIMER") + t1b2 = wx.Button(self, -1, "stop timer") + t1st = wx.StaticText(self, -1, doc1) + t1b2.Disable() + self.Bind(wx.EVT_BUTTON, self.OnTest1Start, t1b1) + self.Bind(wx.EVT_BUTTON, self.OnTest1Stop, t1b2) + + # Bind all EVT_TIMER events to self.OnTest1Timer + self.Bind(wx.EVT_TIMER, self.OnTest1Timer) + + + t2b1 = wx.Button(self, -1, "wx.FutureCall") + t2b2 = wx.Button(self, -1, "stop timer") + t2st = wx.StaticText(self, -1, doc2) + t2b2.Disable() + self.Bind(wx.EVT_BUTTON, self.OnTest2Start, t2b1) + self.Bind(wx.EVT_BUTTON, self.OnTest2Stop, t2b2) + + t3b1 = wx.Button(self, -1, "self.Notify") + t3b2 = wx.Button(self, -1, "stop timer") + t3st = wx.StaticText(self, -1, doc3) + t3b2.Disable() + self.Bind(wx.EVT_BUTTON, self.OnTest3Start, t3b1) + self.Bind(wx.EVT_BUTTON, self.OnTest3Stop, t3b2) + + t4b1 = wx.Button(self, -1, "wx.PyTimer") + t4b2 = wx.Button(self, -1, "stop timer") + t4st = wx.StaticText(self, -1, doc4) + t4b2.Disable() + self.Bind(wx.EVT_BUTTON, self.OnTest4Start, t4b1) + self.Bind(wx.EVT_BUTTON, self.OnTest4Stop, t4b2) + + + self.t1b2 = t1b2 + self.t2b2 = t2b2 + self.t3b2 = t3b2 + self.t4b2 = t4b2 + + fgs = wx.FlexGridSizer(cols=3, hgap=10, vgap=10) + fgs.Add(t1b1) + fgs.Add(t1b2) + fgs.Add(t1st) - wx.StaticText(self, -1, "This is a timer example", (15, 30)) - wx.Button(self, ID_Start, ' Start ', (15, 75), wx.DefaultSize) - wx.Button(self, ID_Stop, ' Stop ', (115, 75), wx.DefaultSize) + fgs.Add(t2b1) + fgs.Add(t2b2) + fgs.Add(t2st) - self.timer = wx.Timer(self, # object to send the event to - ID_Timer) # event id to use + fgs.Add(t3b1) + fgs.Add(t3b2) + fgs.Add(t3st) - self.timer2 = wx.Timer(self, # object to send the event to - ID_Timer2) # event id to use + fgs.Add(t4b1) + fgs.Add(t4b2) + fgs.Add(t4st) + + outsideSizer.Add(fgs, 0, wx.ALIGN_CENTER|wx.ALL, 10) + self.SetSizer(outsideSizer) + self.SetupScrolling() + - self.Bind(wx.EVT_BUTTON, self.OnStart, id=ID_Start) - self.Bind(wx.EVT_BUTTON, self.OnStop, id=ID_Stop) - self.Bind(wx.EVT_TIMER, self.OnTimer, id=ID_Timer) - self.Bind(wx.EVT_TIMER, self.OnTimer2, id=ID_Timer2) + # Test 1 shows how to use a timer to generate EVT_TIMER + # events, by passing self to the wx.Timer constructor. The + # event is bound above to the OnTest1Timer method. + + def OnTest1Start(self, evt): + self.t1 = wx.Timer(self) + self.t1.Start(1000) + self.log.write("EVT_TIMER timer started\n") + self.t1b2.Enable() - def OnStart(self, event): - self.timer.Start(1000) - self.timer2.Start(1500) + def OnTest1Stop(self, evt): + self.t1.Stop() + self.log.write("EVT_TIMER timer stoped\n") + del self.t1 + self.t1b2.Disable() - def OnStop(self, event): - self.timer.Stop() - self.timer2.Stop() + def OnTest1Timer(self, evt): + self.log.write("got EVT_TIMER event\n") + - def OnTimer(self, event): - wx.Bell() - if self.log: - self.log.WriteText('beep!\n') - def OnTimer2(self, event): - wx.Bell() - if self.log: - self.log.WriteText('beep 2!\n') + # Test 2 shows how to use the wx.FutureCall class. + + def OnTest2Start(self, evt): + # Call OnTest2Timer one second in the future, passing some + # optional arbitrary args. There is no need to hold a + # reference to this one, unless we want to manipulate or query + # it later like we do in the two methods below + self.t2 = wx.FutureCall(1000, self.OnTest2Timer, + 'a', 'b', 'c', one=1, two=2) + self.log.write("FutureCall scheduled\n") + self.t2b2.Enable() + + def OnTest2Stop(self, evt): + self.t2.Stop() + self.log.write("FutureCall stopped, last return value was: %s\n" % + repr(self.t2.GetResult())) + del self.t2 + self.t2b2.Disable() + + def OnTest2Timer(self, *args, **kw): + self.log.write("FutureCall called with args=%s, kwargs=%s\n" % (args, kw)) -#--------------------------------------------------------------------------- + # Normally a FutureCall is one-shot, but we can make it + # recurring just by calling Restart. We can even use a + # different timeout or pass differnt args this time. + self.t2.Restart(1500, "restarted") + + # The return value of this function is saved and can be + # retrived later. See OnTest2Stop above. + return "This is my return value" + + + + # Test 3 shows how to use a class derived from wx.Timer. See + # also the NotifyTimer class below. + + def OnTest3Start(self, evt): + self.t3 = NotifyTimer(self.log) + self.t3.Start(1000) + self.log.write("NotifyTimer timer started\n") + self.t3b2.Enable() + + def OnTest3Stop(self, evt): + self.t3.Stop() + self.log.write("NotifyTimer timer stoped\n") + del self.t3 + self.t3b2.Disable() + + + + # Test 4 shows the old way (a kludge that goes back all the + # way to the first version of wxPython) to bind a timer + # directly to a callable. You should migrate any code that + # uses this method to use EVT_TIMER instead as this may be + # deprecated in the future. + def OnTest4Start(self, evt): + self.t4 = wx.PyTimer(self.OnTest4Timer) + self.t4.Start(1000) + self.log.write("wx.PyTimer timer started\n") + self.t4b2.Enable() + + def OnTest4Stop(self, evt): + self.t4.Stop() + self.log.write("wx.PyTimer timer stoped\n") + del self.t4 + self.t4b2.Disable() + + def OnTest4Timer(self): + self.log.write("got wx.PyTimer event\n") + + + +#---------------------------------------------------------------------- + + +# When deriving from wx.Timer you must provide a Notify method +# that will be called when the timer expires. +class NotifyTimer(wx.Timer): + def __init__(self, log): + wx.Timer.__init__(self) + self.log = log + + def Notify(self): + self.log.write("got NotifyTimer event\n") + + + +#---------------------------------------------------------------------- def runTest(frame, nb, log): - win = TestTimerWin(nb, log) + win = TestPanel(nb, log) return win -#--------------------------------------------------------------------------- +#---------------------------------------------------------------------- +overview = """ +

wx.Timer

-overview = """\ -The wxTimer class allows you to execute code at specified intervals from -within the wxPython event loop. Timers can be one-shot or repeating. +The wx.Timer class allows you to execute code at specified intervals +from within the wxPython event loop. Timers can be one-shot or +repeating. This demo shows the principle method of using a timer +(with events) as well as the convenient wx.FutureCall class. Also +there are two other usage patterns shown here that have been preserved +for backwards compatibility. + """ - if __name__ == '__main__': import sys,os import run - run.main(['', os.path.basename(sys.argv[0])]) + run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:]) + + + +