wxCheckListBox doesn't require wxUSE_OWNER_DRAWN when using WXUNIVERSAL

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

diff --git a/wxPython/demo/DrawXXXList.py b/wxPython/demo/DrawXXXList.py
index 1783ef76e9a87802fe39b4ebe96e152afca09c66..5086b14c01baeb7b3be2472b046307072e5d6281 100644 (file)
--- a/wxPython/demo/DrawXXXList.py
+++ b/wxPython/demo/DrawXXXList.py
@@ -1,6 +1,8 @@
 
 

-from wxPython.wx import *
-import whrandom, time
+import  random
+import  time
+
+import  wx

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


@@ -28,91 +30,377 @@ colours = [
 
 def makeRandomPoints(num, w, h):
     pnts = []
 
 def makeRandomPoints(num, w, h):
     pnts = []

+

     for i in range(num):
     for i in range(num):

-        x = whrandom.randint(0, w)
-        y = whrandom.randint(0, h)
+        x = random.randint(0, w)
+        y = random.randint(0, h)

         pnts.append( (x,y) )
         pnts.append( (x,y) )

+

     return pnts
 
 
 def makeRandomLines(num, w, h):
     pnts = []
     return pnts
 
 
 def makeRandomLines(num, w, h):
     pnts = []

+

     for i in range(num):
     for i in range(num):

-        x1 = whrandom.randint(0, w)
-        y1 = whrandom.randint(0, h)
-        x2 = whrandom.randint(0, w)
-        y2 = whrandom.randint(0, h)
+        x1 = random.randint(0, w)
+        y1 = random.randint(0, h)
+        x2 = random.randint(0, w)
+        y2 = random.randint(0, h)

         pnts.append( (x1,y1, x2,y2) )
         pnts.append( (x1,y1, x2,y2) )

+

     return pnts
 
 
     return pnts
 
 

+def makeRandomRectangles(num, W, H):
+    rects = []
+
+    for i in range(num):
+        w = random.randint(10, W/2)
+        h = random.randint(10, H/2)
+        x = random.randint(0, W - w)
+        y = random.randint(0, H - h)
+        rects.append( (x, y, w, h) )
+
+    return rects
+
+
+def makeRandomText(num):
+    Np = 8 # number of characters in text
+    text = []
+
+    for i in range(num):
+        word = []
+
+        for i in range(Np):
+            c = chr( random.randint(48, 122) )
+            word.append( c )
+
+        text.append( "".join(word) )
+
+    return text
+
+
+def makeRandomPolygons(num, W, H):
+    Np = 8 # number of points per polygon
+    polys = []
+
+    for i in range(num):
+        poly = []
+
+        for i in range(Np):
+            x = random.randint(0, W)
+            y = random.randint(0, H)
+            poly.append( (x,y) )
+
+        polys.append( poly )
+
+    return polys
+
+

 def makeRandomPens(num, cache):
     pens = []
 def makeRandomPens(num, cache):
     pens = []

+

     for i in range(num):
     for i in range(num):

-        c = whrandom.choice(colours)
-        t = whrandom.randint(1, 4)
+        c = random.choice(colours)
+        t = random.randint(1, 4)
+

         if not cache.has_key( (c, t) ):
         if not cache.has_key( (c, t) ):

-            cache[(c, t)] = wxPen(c, t)
+            cache[(c, t)] = wx.Pen(c, t)
+

         pens.append( cache[(c, t)] )
         pens.append( cache[(c, t)] )

+

     return pens
 
 
     return pens
 
 

-class TestPanel(wxPanel):
-    def __init__(self, parent, size, log):
-        wxPanel.__init__(self, parent, -1, size=size)
-        self.log = log
-        self.SetBackgroundColour(wxWHITE)
+def makeRandomBrushes(num, cache):
+    brushes = []

 
 

-        w = size.width
-        h = size.height
-        pencache = {}
+    for i in range(num):
+        c = random.choice(colours)

 
 

-        # make some lists of random points
-        self.pnts1 = makeRandomPoints(1000, w, h)
-        self.pnts2 = makeRandomPoints(1000, w, h)
-        self.pnts3 = makeRandomPoints(1000, w, h)
-        self.pens1  = makeRandomPens(1000, pencache)
+        if not cache.has_key(c):
+            cache[c] = wx.Brush(c)

 
 

-        # and now some lines
-        self.lines1 = makeRandomLines(500, w, h)
-        self.lines2 = makeRandomLines(500, w, h)
-        self.lines3 = makeRandomLines(500, w, h)
-        self.pens2  = makeRandomPens(500, pencache)
+        brushes.append( cache[c] )

 
 

-        EVT_PAINT(self, self.OnPaint)
+    return brushes

 
 
 
 

-    def OnPaint(self, evt):
-        dc = wxPaintDC(self)
+def makeRandomColors(num):
+    colors = []
+
+    for i in range(num):
+        c = random.choice(colours)
+        colors.append(wx.NamedColour(c))
+    return colors
+
+
+
+pencache = {}
+brushcache = {}
+points = None
+lines = None
+rectangles = None
+polygons = None
+text = None
+pens = None
+brushes = None
+colors1 = None
+colors2 = None
+
+
+def Init(w, h, n):
+    global pencache
+    global brushcache
+    global points
+    global lines
+    global rectangles
+    global polygons
+    global text
+    global pens
+    global brushes
+    global colors1
+    global colors2
+
+    # make some lists of random shapes
+    points = makeRandomPoints(n, w, h)
+
+    try:
+        import Numeric
+        Apoints = Numeric.array(points)
+    except:
+        pass
+
+    lines = makeRandomLines(n, w, h)
+    rectangles = makeRandomRectangles(n, w, h)
+    polygons = makeRandomPolygons(n, w, h)
+    text = makeRandomText(n)
+
+    # make some random pens and brushes
+    pens  = makeRandomPens(n, pencache)
+    brushes = makeRandomBrushes(n, brushcache)
+    # make some random color lists
+    colors1 = makeRandomColors(n)
+    colors2 = makeRandomColors(n)
+
+
+
+def TestPoints(dc,log):
+    dc.BeginDrawing()
+    start = time.time()
+    dc.SetPen(wx.Pen("BLACK", 4))
+
+    dc.DrawPointList(points)
+    dc.DrawPointList(points, wx.Pen("RED", 2))
+    dc.DrawPointList(points, pens)
+
+    dc.EndDrawing()
+    log.write("DrawTime: %s seconds with DrawPointList\n" % (time.time() - start))
+
+
+def TestArrayPoints(dc,log):
+    try:
+        import Numeric
+

         dc.BeginDrawing()
         start = time.time()
         dc.BeginDrawing()
         start = time.time()

+        dc.SetPen(wx.Pen("BLACK", 1))
+
+        for i in range(1):
+            dc.DrawPointList(Apoints)
+
+        #dc.DrawPointList(Apoints, wx.Pen("RED", 2))
+        #dc.DrawPointList(Apoints, pens)
+        dc.EndDrawing()
+        log.write("DrawTime: %s seconds with DrawPointList an Numpy Array\n" % (time.time() - start))
+    except ImportError:
+        log.write("Couldn't import Numeric")
+        pass
+
+
+def TestLines(dc,log):
+    dc.BeginDrawing()
+    start = time.time()
+
+    dc.SetPen(wx.Pen("BLACK", 2))
+    dc.DrawLineList(lines)
+    dc.DrawLineList(lines, wx.Pen("RED", 2))
+    dc.DrawLineList(lines, pens)
+
+    dc.EndDrawing()
+    log.write("DrawTime: %s seconds with DrawLineList\n" % (time.time() - start))
+
+
+def TestRectangles(dc,log):
+    dc.BeginDrawing()
+    start = time.time()
+
+    dc.SetPen( wx.Pen("BLACK",1) )
+    dc.SetBrush( wx.Brush("RED") )
+
+    dc.DrawRectangleList(rectangles)
+    dc.DrawRectangleList(rectangles,pens)
+    dc.DrawRectangleList(rectangles,pens[0],brushes)
+    dc.DrawRectangleList(rectangles,pens,brushes[0])
+    dc.DrawRectangleList(rectangles,None,brushes)
+##    for i in range(10):
+##        #dc.DrawRectangleList(rectangles,pens,brushes)
+##        dc.DrawRectangleList(rectangles)
+
+    dc.EndDrawing()
+    log.write("DrawTime: %s seconds with DrawRectanglesList\n" % (time.time() - start))

 
 

-        dc.SetPen(wxPen("BLACK", 1))
-        dc.DrawPointList(self.pnts1)
-        dc.DrawPointList(self.pnts2, wxPen("RED", 2))
-        dc.DrawPointList(self.pnts3, self.pens1)

 
 

-        dc.SetPen(wxPen("BLACK", 1))
-        dc.DrawLineList(self.lines1)
-        dc.DrawLineList(self.lines2, wxPen("RED", 2))
-        dc.DrawLineList(self.lines3, self.pens2)
+def TestEllipses(dc,log):
+    dc.BeginDrawing()
+    start = time.time()
+
+    dc.SetPen( wx.Pen("BLACK",1) )
+    dc.SetBrush( wx.Brush("RED") )
+
+    dc.DrawEllipseList(rectangles)
+    dc.DrawEllipseList(rectangles,pens)
+    dc.DrawEllipseList(rectangles,pens[0],brushes)
+    dc.DrawEllipseList(rectangles,pens,brushes[0])
+    dc.DrawEllipseList(rectangles,None,brushes)
+    dc.DrawEllipseList(rectangles,pens,brushes)
+
+    dc.EndDrawing()
+    log.write("DrawTime: %s seconds with DrawEllipsesList\n" % (time.time() - start))
+
+
+def TestRectanglesArray(dc,log):
+    try:
+        import Numeric
+        Apoints = Numeric.array(rectangles)
+
+        dc.BeginDrawing()
+        start = time.time()
+        dc.SetPen(wx.Pen("BLACK", 1))
+        dc.DrawRectangleList(rectangles)
+        dc.DrawRectangleList(rectangles,pens)
+        dc.DrawRectangleList(rectangles,pens[0],brushes)
+        dc.DrawRectangleList(rectangles,pens,brushes[0])
+        dc.DrawRectangleList(rectangles,None,brushes)
+##        for i in range(10):
+##            #dc.DrawRectangleList(rectangles,pens,brushes)
+##            dc.DrawRectangleList(rectangles)

 
         dc.EndDrawing()
 
         dc.EndDrawing()

-        self.log.write("DrawTime: %s seconds\n" % (time.time() - start))
-        self.log.write("GetBoundingBox: %s\n" % (dc.GetBoundingBox(), ))
+        log.write("DrawTime: %s seconds with DrawRectangleList and Numpy Array\n" % (time.time() - start))
+    except ImportError:
+        log.write("Couldn't import Numeric")
+        pass
+
+
+def TestRectanglesLoop(dc,log):
+    dc.BeginDrawing()
+
+    start = time.time()
+    dc.DrawRectangleList(rectangles,pens,brushes)
+    log.write("DrawTime: %s seconds with DrawRectanglesList\n" % (time.time() - start))
+
+    start = time.time()
+
+    for i in range(len(rectangles)):
+        dc.SetPen( pens[i] )
+        dc.SetBrush( brushes[i]  )
+        dc.DrawRectangle(rectangles[i][0],rectangles[i][1],rectangles[i][2],rectangles[i][3])
+
+    dc.EndDrawing()
+    log.write("DrawTime: %s seconds with Python loop\n" % (time.time() - start))
+
+
+def TestPolygons(dc,log):
+    dc.BeginDrawing()
+
+    start = time.time()
+    dc.SetPen(wx.Pen("BLACK", 1))
+    dc.DrawPolygonList(polygons)
+    dc.DrawPolygonList(polygons,pens)
+    dc.DrawPolygonList(polygons,pens[0],brushes)
+    dc.DrawPolygonList(polygons,pens,brushes[0])
+    dc.DrawPolygonList(polygons,None,brushes)
+    log.write("DrawTime: %s seconds with DrawPolygonList\n" % (time.time() - start))
+
+    dc.EndDrawing()
+
+
+def TestText(dc,log):
+    dc.BeginDrawing()
+
+    start = time.time()
+
+    # NOTE: you need to set BackgroundMode for the background colors to be used.
+    dc.SetBackgroundMode(wx.SOLID)
+    foreground = colors1
+    background = colors2
+    dc.DrawTextList(text, points, foreground, background)
+
+    log.write("DrawTime: %s seconds with DrawTextList\n" % (time.time() - start))
+
+    dc.EndDrawing()
+
+
+
+class TestNB(wx.Notebook):
+    def __init__(self, parent, id, log):
+        style = wx.NB_BOTTOM
+
+        if wx.Platform == "__WXMAC__":
+            style = 0
+
+        wx.Notebook.__init__(self, parent, id, style=style)
+        self.log = log
+
+        # Initialize our various samples and add them to the notebook.
+        win = DrawPanel(self, TestEllipses, log)
+        self.AddPage(win, 'Ellipses')
+
+        win = DrawPanel(self, TestText, log)
+        self.AddPage(win, 'Text')
+
+        win = DrawPanel(self, TestPolygons, log)
+        self.AddPage(win, 'Polygons')
+
+        win = DrawPanel(self, TestPoints, log)
+        self.AddPage(win, 'Points')
+
+        win = DrawPanel(self, TestLines, log)
+        self.AddPage(win, 'Lines')
+
+        win = DrawPanel(self, TestRectangles, log)
+        self.AddPage(win, 'Rectangles')
+
+# Class used for all the various sample pages; the mechanics are the same
+# for each one with regards to the notebook. The only difference is
+# the function we use to draw on it.
+class DrawPanel(wx.Panel):
+    def __init__(self, parent, drawFun, log):
+        wx.Panel.__init__(self, parent, -1)
+        self.SetBackgroundColour(wx.WHITE)
+
+        self.log = log
+        self.drawFun = drawFun
+        self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+    def OnPaint(self, evt):
+        dc = wx.PaintDC(self)
+        dc.Clear()
+        self.drawFun(dc,self.log)
+

 
 #----------------------------------------------------------------------
 
 def runTest(frame, nb, log):
     w = nb.GetClientSize().width
     h = nb.GetClientSize().height
 
 #----------------------------------------------------------------------
 
 def runTest(frame, nb, log):
     w = nb.GetClientSize().width
     h = nb.GetClientSize().height

-    if w < 300: w = 300
-    if h < 300: h = 300
-    win = wxPanel(nb, -1)
-    tp = TestPanel(win, wxSize(w, h), log)
-    def OnPanelSize(evt, tp=tp):
-        tp.SetSize(evt.GetSize())
-    EVT_SIZE(win, OnPanelSize)
+    if w < 600: w = 600
+    if h < 400: h = 400
+    Init(w, h, 200)
+    win = TestNB(nb, -1, log)

     return win
 
 #----------------------------------------------------------------------
     return win
 
 #----------------------------------------------------------------------


@@ -120,7 +408,7 @@ def runTest(frame, nb, log):
 
 overview = """\
 
 
 overview = """\
 

-Some methods have been added to wxDC to help with optimization of
+Some methods have been added to wx.DC to help with optimization of

 drawing routines.  Currently they are:
 
 <pre>
 drawing routines.  Currently they are:
 
 <pre>


@@ -133,7 +421,33 @@ drawing routines.  Currently they are:
     DrawLineList(sequence, pens=None)
 </pre>
      Where sequence is a tuple, list, whatever of 4 element tuples
     DrawLineList(sequence, pens=None)
 </pre>
      Where sequence is a tuple, list, whatever of 4 element tuples

-     (x1,y1, x2,y2) andd pens is either None, a single pen or a list
+     (x1,y1, x2,y2) and pens is either None, a single pen or a list

      of pens.
 
      of pens.
 

+<pre>
+    DrawRectangleList(rectangles, pens=None, brushes=None)
+</pre>
+
+
+<pre>
+    DrawEllipseList(ellipses, pens=None, brushes=None)
+</pre>
+
+
+<pre>
+    DrawPolygonList(polygons, pens=None, brushes=None)
+</pre>
+
+
+<pre>
+    DrawTextList(textList, coords, foregrounds = None, backgrounds = None)
+</pre>
+

 """
 """

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