Another package name fix

[wxWidgets.git] / wxPython / demo / Threads.py

diff --git a/wxPython/demo/Threads.py b/wxPython/demo/Threads.py
index 015a6f9b7d3095497684aefb0c118ac4d75d50c0..ceb2fdc78b559e81904d670e24ce14840895b505 100644 (file)
--- a/wxPython/demo/Threads.py
+++ b/wxPython/demo/Threads.py
@@ -1,24 +1,15 @@
 
 

-from wxPython.wx import *
+import  random
+import  time
+import  thread

 
 

-import thread
-import time
-from   whrandom import random
+import  wx
+import  wx.lib.newevent

 
 #----------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------
 

-wxEVT_UPDATE_BARGRAPH = 25015
-
-def EVT_UPDATE_BARGRAPH(win, func):
-    win.Connect(-1, -1, wxEVT_UPDATE_BARGRAPH, func)
-
-
-class UpdateBarEvent(wxPyEvent):
-    def __init__(self, barNum, value):
-        wxPyEvent.__init__(self)
-        self.SetEventType(wxEVT_UPDATE_BARGRAPH)
-        self.barNum = barNum
-        self.value = value
+# This creates a new Event class and a EVT binder function
+(UpdateBarEvent, EVT_UPDATE_BARGRAPH) = wx.lib.newevent.NewEvent()

 
 
 #----------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------


@@ -30,27 +21,25 @@ class CalcBarThread:
         self.val = val
 
     def Start(self):
         self.val = val
 
     def Start(self):

-        self.keepGoing = self.running = true
+        self.keepGoing = self.running = True

         thread.start_new_thread(self.Run, ())
 
     def Stop(self):
         thread.start_new_thread(self.Run, ())
 
     def Stop(self):

-        self.keepGoing = false
+        self.keepGoing = False

 
     def IsRunning(self):
         return self.running
 
     def Run(self):
         while self.keepGoing:
 
     def IsRunning(self):
         return self.running
 
     def Run(self):
         while self.keepGoing:

-            evt = UpdateBarEvent(self.barNum, int(self.val))
-            wxPostEvent(self.win, evt)
-            del evt
-
-            sleeptime = (random() * 2) + 0.5
-            #print self.barNum, 'sleeping for', sleeptime
-            time.sleep(sleeptime)
+            evt = UpdateBarEvent(barNum = self.barNum, value = int(self.val))
+            wx.PostEvent(self.win, evt)
+ 
+            sleeptime = (random.random() * 2) + 0.5
+            time.sleep(sleeptime/4)

 
             sleeptime = sleeptime * 5
 
             sleeptime = sleeptime * 5

-            if int(random() * 2):
+            if int(random.random() * 2):

                 self.val = self.val + sleeptime
             else:
                 self.val = self.val - sleeptime
                 self.val = self.val + sleeptime
             else:
                 self.val = self.val - sleeptime


@@ -58,27 +47,27 @@ class CalcBarThread:
             if self.val < 0: self.val = 0
             if self.val > 300: self.val = 300
 
             if self.val < 0: self.val = 0
             if self.val > 300: self.val = 300
 

-        self.running = false
+        self.running = False

 
 #----------------------------------------------------------------------
 
 
 
 #----------------------------------------------------------------------
 
 

-class GraphWindow(wxWindow):
+class GraphWindow(wx.Window):

     def __init__(self, parent, labels):
     def __init__(self, parent, labels):

-        wxWindow.__init__(self, parent, -1)
+        wx.Window.__init__(self, parent, -1)

 
         self.values = []
         for label in labels:
             self.values.append((label, 0))
 
 
         self.values = []
         for label in labels:
             self.values.append((label, 0))
 

-        font = wxFont(12, wxSWISS, wxNORMAL, wxBOLD)
+        font = wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD)

         self.SetFont(font)
 
         self.SetFont(font)
 

-        self.colors = [ wxRED, wxGREEN, wxBLUE, wxCYAN,
+        self.colors = [ wx.RED, wx.GREEN, wx.BLUE, wx.CYAN,

                         "Yellow", "Navy" ]
 
                         "Yellow", "Navy" ]
 

-        EVT_ERASE_BACKGROUND(self, self.OnEraseBackground)
-        EVT_PAINT(self, self.OnPaint)
+        self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
+        self.Bind(wx.EVT_PAINT, self.OnPaint)

 
 
     def SetValue(self, index, value):
 
 
     def SetValue(self, index, value):


@@ -88,7 +77,7 @@ class GraphWindow(wxWindow):
 
 
     def SetFont(self, font):
 
 
     def SetFont(self, font):

-        wxWindow.SetFont(self, font)
+        wx.Window.SetFont(self, font)

         wmax = hmax = 0
         for label, val in self.values:
             w,h = self.GetTextExtent(label)
         wmax = hmax = 0
         for label, val in self.values:
             w,h = self.GetTextExtent(label)


@@ -104,10 +93,10 @@ class GraphWindow(wxWindow):
 
     def Draw(self, dc, size):
         dc.SetFont(self.GetFont())
 
     def Draw(self, dc, size):
         dc.SetFont(self.GetFont())

-        dc.SetTextForeground(wxBLUE)
-        dc.SetBackground(wxBrush(self.GetBackgroundColour()))
+        dc.SetTextForeground(wx.BLUE)
+        dc.SetBackground(wx.Brush(self.GetBackgroundColour()))

         dc.Clear()
         dc.Clear()

-        dc.SetPen(wxPen(wxBLACK, 3, wxSOLID))
+        dc.SetPen(wx.Pen(wx.BLACK, 3, wx.SOLID))

         dc.DrawLine(self.linePos, 0, self.linePos, size.height-10)
 
         bh = ypos = self.barHeight
         dc.DrawLine(self.linePos, 0, self.linePos, size.height-10)
 
         bh = ypos = self.barHeight


@@ -117,28 +106,18 @@ class GraphWindow(wxWindow):
 
             if val:
                 color = self.colors[ x % len(self.colors) ]
 
             if val:
                 color = self.colors[ x % len(self.colors) ]

-                dc.SetPen(wxPen(color))
-                dc.SetBrush(wxBrush(color))
+                dc.SetPen(wx.Pen(color))
+                dc.SetBrush(wx.Brush(color))

                 dc.DrawRectangle(self.linePos+3, ypos, val, bh)
 
             ypos = ypos + 2*bh
                 dc.DrawRectangle(self.linePos+3, ypos, val, bh)
 
             ypos = ypos + 2*bh

-            if ypos > size.height-10:
+            if ypos > size[1]-10:

                 break
 
 
     def OnPaint(self, evt):
                 break
 
 
     def OnPaint(self, evt):

-        size = self.GetSize()
-        bmp = wxEmptyBitmap(size.width, size.height)
-        dc = wxMemoryDC()
-        dc.SelectObject(bmp)
-        self.Draw(dc, size)
-
-        wdc = wxPaintDC(self)
-        wdc.BeginDrawing()
-        wdc.Blit(0,0, size.width, size.height, dc, 0,0)
-        wdc.EndDrawing()
-
-        dc.SelectObject(wxNullBitmap)
+        dc = wx.BufferedPaintDC(self)
+        self.Draw(dc, self.GetSize())

 
 
     def OnEraseBackground(self, evt):
 
 
     def OnEraseBackground(self, evt):


@@ -149,33 +128,35 @@ class GraphWindow(wxWindow):
 
 #----------------------------------------------------------------------
 
 
 #----------------------------------------------------------------------
 

-class TestFrame(wxFrame):
+class TestFrame(wx.Frame):

     def __init__(self, parent, log):
     def __init__(self, parent, log):

-        wxFrame.__init__(self, parent, -1, "Thread Test", size=(450,300))
+        wx.Frame.__init__(self, parent, -1, "Thread Test", size=(450,300))

         self.log = log
 
         #self.CenterOnParent()
 
         self.log = log
 
         #self.CenterOnParent()
 

-        panel = wxPanel(self, -1)
-        panel.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD))
-        wxStaticText(panel, -1,
+        panel = wx.Panel(self, -1)
+        panel.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
+        wx.StaticText(panel, -1,

                      "This demo shows multiple threads interacting with this\n"
                      "This demo shows multiple threads interacting with this\n"

-                     "window by sending events to it.", wxPoint(5,5))
+                     "window by sending events to it, one thread for each bar.",
+                     (5,5))

         panel.Fit()
 
         self.graph = GraphWindow(self, ['Zero', 'One', 'Two', 'Three', 'Four',
                                         'Five', 'Six', 'Seven'])
         self.graph.SetSize((450, self.graph.GetBestHeight()))
 
         panel.Fit()
 
         self.graph = GraphWindow(self, ['Zero', 'One', 'Two', 'Three', 'Four',
                                         'Five', 'Six', 'Seven'])
         self.graph.SetSize((450, self.graph.GetBestHeight()))
 

-        sizer = wxBoxSizer(wxVERTICAL)
-        sizer.Add(panel, 0, wxEXPAND)
-        sizer.Add(self.graph, 1, wxEXPAND)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(panel, 0, wx.EXPAND)
+        sizer.Add(self.graph, 1, wx.EXPAND)

 
         self.SetSizer(sizer)
 
         self.SetSizer(sizer)

-        self.SetAutoLayout(true)
+        self.SetAutoLayout(True)

         sizer.Fit(self)
 
         sizer.Fit(self)
 

-        EVT_UPDATE_BARGRAPH(self, self.OnUpdate)
+        self.Bind(EVT_UPDATE_BARGRAPH, self.OnUpdate)
+

         self.threads = []
         self.threads.append(CalcBarThread(self, 0, 50))
         self.threads.append(CalcBarThread(self, 1, 75))
         self.threads = []
         self.threads.append(CalcBarThread(self, 0, 50))
         self.threads.append(CalcBarThread(self, 1, 75))


@@ -189,42 +170,64 @@ class TestFrame(wxFrame):
         for t in self.threads:
             t.Start()
 
         for t in self.threads:
             t.Start()
 

-        EVT_CLOSE(self, self.OnCloseWindow)
+        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)

 
 
     def OnUpdate(self, evt):
         self.graph.SetValue(evt.barNum, evt.value)
 
 
     def OnUpdate(self, evt):
         self.graph.SetValue(evt.barNum, evt.value)

-        self.graph.Refresh(false)
+        self.graph.Refresh(False)

 
 
     def OnCloseWindow(self, evt):
 
 
     def OnCloseWindow(self, evt):

-        busy = wxBusyInfo("One moment please, waiting for threads to die...")
-        wxYield()
+        busy = wx.BusyInfo("One moment please, waiting for threads to die...")
+        wx.Yield()
+

         for t in self.threads:
             t.Stop()
         for t in self.threads:
             t.Stop()

+

         running = 1
         running = 1

+

         while running:
             running = 0
         while running:
             running = 0

+

             for t in self.threads:
                 running = running + t.IsRunning()
             for t in self.threads:
                 running = running + t.IsRunning()

+

             time.sleep(0.1)
             time.sleep(0.1)

+

         self.Destroy()
 
 
 
         self.Destroy()
 
 
 

-#----------------------------------------------------------------------
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        b = wx.Button(self, -1, "Show Threads sample", (50,50))
+        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+    def OnButton(self, evt):
+        win = TestFrame(self, self.log)
+        win.Show(True)
+
+
+#---------------------------------------------------------------------------
+

 
 def runTest(frame, nb, log):
 
 def runTest(frame, nb, log):

-    win = TestFrame(frame, log)
-    frame.otherWin = win
-    win.Show(true)
-    return None
+    win = TestPanel(nb, log)
+    return win

 
 #----------------------------------------------------------------------
 
 
 
 
 
 #----------------------------------------------------------------------
 
 
 
 

+

 overview = """\
 The main issue with multi-threaded GUI programming is the thread safty
 of the GUI itself.  On most platforms the GUI is not thread safe and
 overview = """\
 The main issue with multi-threaded GUI programming is the thread safty
 of the GUI itself.  On most platforms the GUI is not thread safe and


@@ -232,15 +235,23 @@ so any cross platform GUI Toolkit and applications written with it
 need to take that into account.
 
 The solution is to only allow interaction with the GUI from a single
 need to take that into account.
 
 The solution is to only allow interaction with the GUI from a single

-thread, but this often severly limits what can be done in an
+thread, but this often severely limits what can be done in an

 application and makes it difficult to use additional threads at all.
 
 Since wxPython already makes extensive use of event handlers, it is a
 logical extension to allow events to be sent to GUI objects from
 application and makes it difficult to use additional threads at all.
 
 Since wxPython already makes extensive use of event handlers, it is a
 logical extension to allow events to be sent to GUI objects from

-alternate threads.  A function called wxPostEvent allows you to do
+alternate threads.  A function called wx.PostEvent allows you to do

 this.  It accepts an event and an event handler (window) and instead
 of sending the event immediately in the current context like
 ProcessEvent does, it processes it later from the context of the GUI
 thread.
 
 """
 this.  It accepts an event and an event handler (window) and instead
 of sending the event immediately in the current context like
 ProcessEvent does, it processes it later from the context of the GUI
 thread.
 
 """

+
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+