wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/demo/DrawXXXList.py

@@ -0,0 +1,436 @@
+#!/usr/bin/env python
+
+import random
+import time
+
+import wx
+
+#----------------------------------------------------------------------
+
+colours = [
+    "BLACK",
+    "BLUE",
+    "BLUE VIOLET",
+    "BROWN",
+    "CYAN",
+    "DARK GREY",
+    "DARK GREEN",
+    "GOLD",
+    "GREY",
+    "GREEN",
+    "MAGENTA",
+    "NAVY",
+    "PINK",
+    "RED",
+    "SKY BLUE",
+    "VIOLET",
+    "YELLOW",
+    ]
+
+#----------------------------------------------------------------------
+
+def makeRandomPoints(num, w, h):
+    pnts = []
+
+    for i in range(num):
+        x = random.randint(0, w)
+        y = random.randint(0, h)
+        pnts.append( (x,y) )
+
+    return pnts
+
+
+def makeRandomLines(num, w, h):
+    pnts = []
+
+    for i in range(num):
+        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) )
+
+    return pnts
+
+
+def makeRandomRectangles(num, W, H):
+    rects = []
+
+    for i in range(num):
+        w = random.randint(10, int(W/2))
+        h = random.randint(10, int(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 = []
+
+    for i in range(num):
+        c = random.choice(colours)
+        t = random.randint(1, 4)
+
+        if (c, t) not in cache:
+            cache[(c, t)] = wx.Pen(c, t)
+
+        pens.append( cache[(c, t)] )
+
+    return pens
+
+
+def makeRandomBrushes(num, cache):
+    brushes = []
+
+    for i in range(num):
+        c = random.choice(colours)
+
+        if c not in cache:
+            cache[c] = wx.Brush(c)
+
+        brushes.append( cache[c] )
+
+    return brushes
+
+
+def makeRandomColors(num):
+    colors = []
+
+    for i in range(num):
+        c = random.choice(colours)
+        colors.append(wx.Colour(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):
+    start = time.time()
+    dc.SetPen(wx.Pen("BLACK", 4))
+
+    dc.DrawPointList(points)
+    dc.DrawPointList(points, wx.Pen("RED", 2))
+    dc.DrawPointList(points, pens)
+
+    log.write("DrawTime: %s seconds with DrawPointList\n" % (time.time() - start))
+
+
+def TestArrayPoints(dc,log):
+    try:
+        import Numeric
+
+        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)
+        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):
+    start = time.time()
+
+    dc.SetPen(wx.Pen("BLACK", 2))
+    dc.DrawLineList(lines)
+    dc.DrawLineList(lines, wx.Pen("RED", 2))
+    dc.DrawLineList(lines, pens)
+
+    log.write("DrawTime: %s seconds with DrawLineList\n" % (time.time() - start))
+
+
+def TestRectangles(dc,log):
+    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)
+
+    log.write("DrawTime: %s seconds with DrawRectanglesList\n" % (time.time() - start))
+
+
+def TestEllipses(dc,log):
+    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)
+
+    log.write("DrawTime: %s seconds with DrawEllipsesList\n" % (time.time() - start))
+
+
+def TestRectanglesArray(dc,log):
+    try:
+        import Numeric
+        Apoints = Numeric.array(rectangles)
+
+        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)
+
+        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):
+
+    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])
+
+    log.write("DrawTime: %s seconds with Python loop\n" % (time.time() - start))
+
+
+def TestPolygons(dc,log):
+
+    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))
+
+
+
+def TestText(dc,log):
+
+    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))
+
+
+
+
+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
+    if w < 600: w = 600
+    if h < 400: h = 400
+    Init(w, h, 200)
+    win = TestNB(nb, -1, log)
+    return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+
+Some methods have been added to wx.DC to help with optimization of
+drawing routines.  Currently they are:
+
+<pre>
+    DrawPointList(sequence, pens=None)
+</pre>
+    Where sequence is a tuple, list, whatever of 2 element tuples
+    (x, y) and pens is either None, a single pen or a list of pens.
+
+<pre>
+    DrawLineList(sequence, pens=None)
+</pre>
+     Where sequence is a tuple, list, whatever of 4 element tuples
+     (x1,y1, x2,y2) and pens is either None, a single pen or a list
+     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:])
+

wx/demo/DynamicSashWindow.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python
+
+import wx
+import wx.lib.gizmos as gizmos  # Formerly wx.gizmos in Classic
+import wx.stc as stc
+
+#----------------------------------------------------------------------
+# This is an example of the complex view that manages its own scrollbars
+# as described in the overview below.
+
+class TestView(stc.StyledTextCtrl):
+    def __init__(self, parent, ID, log):
+        #super(TestView, self).__init__()  # Test 2-phase
+        #self.Create(parent, ID, style=wx.NO_BORDER)
+        super(TestView, self).__init__(parent, ID, style=wx.NO_BORDER) # or 1-phase
+        self.dyn_sash = parent
+        self.log = log
+        self.SetupScrollBars()
+        self.SetMarginWidth(1,0)
+
+        self.StyleSetFont(stc.STC_STYLE_DEFAULT,
+                          wx.Font(12, wx.FONTFAMILY_MODERN, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL))
+
+        self.Bind(gizmos.EVT_DYNAMIC_SASH_SPLIT, self.OnSplit)
+        self.Bind(gizmos.EVT_DYNAMIC_SASH_UNIFY, self.OnUnify)
+        #self.SetScrollWidth(500)
+
+
+    def SetupScrollBars(self):
+        # hook the scrollbars provided by the wxDynamicSashWindow
+        # to this view
+        v_bar = self.dyn_sash.GetVScrollBar(self)
+        h_bar = self.dyn_sash.GetHScrollBar(self)
+        v_bar.Bind(wx.EVT_SCROLL, self.OnSBScroll)
+        h_bar.Bind(wx.EVT_SCROLL, self.OnSBScroll)
+        v_bar.Bind(wx.EVT_SET_FOCUS, self.OnSBFocus)
+        h_bar.Bind(wx.EVT_SET_FOCUS, self.OnSBFocus)
+
+        # And set the wxStyledText to use these scrollbars instead
+        # of its built-in ones.
+        self.SetVScrollBar(v_bar)
+        self.SetHScrollBar(h_bar)
+
+
+    def OnSplit(self, evt):
+        self.log.write("TestView.OnSplit\n")
+        newview = TestView(self.dyn_sash, -1, self.log)
+        newview.SetDocPointer(self.GetDocPointer())     # use the same document
+        self.SetupScrollBars()
+
+
+    def OnUnify(self, evt):
+        self.log.write("TestView.OnUnify\n")
+        self.SetupScrollBars()
+
+
+    def OnSBScroll(self, evt):
+        # redirect the scroll events from the dyn_sash's scrollbars to the STC
+        self.GetEventHandler().ProcessEvent(evt)
+
+    def OnSBFocus(self, evt):
+        # when the scrollbar gets the focus move it back to the STC
+        self.SetFocus()
+
+
+sampleText="""\
+You can drag the little tabs above the vertical scrollbar, or to the
+left of the horizontal scrollbar to split this view, and you can
+continue splitting the new views as much as you like.  Try it and see.
+
+In this case the views also share the same document so changes in one
+are instantly seen in the others.  This is a feature of the
+StyledTextCtrl that is used for the view class in this sample.
+"""
+
+#----------------------------------------------------------------------
+# This one is simpler, but doesn't do anything with the scrollbars
+# except the default wxDynamicSashWindow behaviour
+
+class SimpleView(wx.Panel):
+    count = 0
+
+    def __init__(self, parent, ID, log):
+        #wx.Panel.__init__(self)                      # 2-phase create
+        #self.Create(parent, ID)
+        super(SimpleView, self).__init__(parent, ID)  # 1-phase
+        self.dyn_sash = parent
+        self.log = log
+        self.SetBackgroundColour("LIGHT BLUE")
+        self.Bind(gizmos.EVT_DYNAMIC_SASH_SPLIT, self.OnSplit)
+        self.Bind(gizmos.EVT_DYNAMIC_SASH_UNIFY, self.OnUnify)
+
+        SimpleView.count += 1
+        st = wx.StaticText(self, label=str(SimpleView.count), pos=(15,15))
+        font = st.GetFont()
+        st.SetFont(font.Bold().Scaled(2.0))
+
+
+    def OnSplit(self, evt):
+        self.log.write("SimpleView.OnSplit\n")
+        newview = SimpleView(self.dyn_sash, -1, self.log)
+        # It's automatically added to the proper place in the sash window
+
+    def OnUnify(self, evt):
+        self.log.write("SimpleView.OnUnify\n")
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+
+    if True:
+        win = gizmos.DynamicSashWindow(nb, -1, style=0
+                                  #| gizmos.DS_MANAGE_SCROLLBARS
+                                  | gizmos.DS_DRAG_CORNER
+                                  )
+
+        view = TestView(win, -1, log)
+        view.SetText(sampleText)
+    else:
+        win = gizmos.DynamicSashWindow(nb, -1)
+        view = SimpleView(win, -1, log)
+    return win
+
+#----------------------------------------------------------------------
+
+overview = """\
+<html><body>
+<h2>DynamicSashWindow</h2>
+<p>
+wxDynamicSashWindow widgets manages the way other widgets are viewed.
+When a wxDynamicSashWindow is first shown, it will contain one child
+view, a viewport for that child, and a pair of scrollbars to allow the
+user to navigate the child view area.  Next to each scrollbar is a small
+tab.  By clicking on either tab and dragging to the appropriate spot, a
+user can split the view area into two smaller views separated by a
+draggable sash.  Later, when the user wishes to reunify the two subviews,
+the user simply drags the sash to the side of the window.
+wxDynamicSashWindow will automatically reparent the appropriate child
+view back up the window hierarchy, and the wxDynamicSashWindow will have
+only one child view once again.
+<p>
+As an application developer, you will simply create a wxDynamicSashWindow
+using either the Create() function or the more complex constructor
+provided below, and then create a view window whose parent is the
+wxDynamicSashWindow.  The child should respond to
+wxDynamicSashSplitEvents -- perhaps with an OnSplit() event handler -- by
+constructing a new view window whose parent is also the
+wxDynamicSashWindow.  That's it!  Now your users can dynamically split
+and reunify the view you provided.
+<p>
+If you wish to handle the scrollbar events for your view, rather than
+allowing wxDynamicSashWindow to do it for you, things are a bit more
+complex.  (You might want to handle scrollbar events yourself, if,
+for instance, you wish to scroll a subwindow of the view you add to
+your wxDynamicSashWindow object, rather than scrolling the whole view.)
+In this case, you will need to construct your wxDynamicSashWindow without
+the wxDS_MANAGE_SCROLLBARS style and  you will need to use the
+GetHScrollBar() and GetVScrollBar() methods to retrieve the scrollbar
+controls and call SetEventHanler() on them to redirect the scrolling
+events whenever your window is reparented by wxDyanmicSashWindow.
+You will need to set the scrollbars' event handler at three times:
+<p>
+<ul>
+<li>  When your view is created
+<li>  When your view receives a wxDynamicSashSplitEvent
+<li>  When your view receives a wxDynamicSashUnifyEvent
+</ul>
+</body></html>
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+

wx/demo/EditableListBox.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+
+import wx
+import wx.adv
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        wx.Panel.__init__(self, parent, -1)
+        self.log = log
+
+        self.elb = wx.adv.EditableListBox(
+                    self, -1, "List of Stuff", (50,50), (250, 250),
+                    style=wx.adv.EL_DEFAULT_STYLE |
+                          #wx.adv.EL_NO_REORDER |
+                          wx.adv.EL_ALLOW_NEW |
+                          wx.adv.EL_ALLOW_EDIT |
+                          wx.adv.EL_ALLOW_DELETE)
+
+        self.elb.SetStrings(["This is a nifty ListBox widget",
+                             "that is editable by the user.",
+                             "",
+                             "Use the buttons above to",
+                             "manipulate items in the list",
+                             "Or to add new ones.",
+                             ])
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """\
+<html>
+<body>
+This class provides a composite control that lets the user easily enter and edit
+a list of strings.
+
+<p><b>Styles supported:</b><p>
+
+<ul>
+<li><b>EL_ALLOW_NEW</b> - Allow user to create new items.
+<li><b>EL_ALLOW_EDIT</b> - Allow user to edit text in the control.
+<li><b>EL_ALLOW_DELETE</b> - Allow user to delete text from the control.
+</ul>
+
+<p><b>Init:</b>
+<pre>
+ EditableListBox(wxWindow *parent, wxWindowID id=-1,
+                 const wxString& label,
+                 const wxPoint& pos = wxDefaultPosition,
+                 const wxSize& size = wxDefaultSize,
+                 long style = EL_ALLOW_NEW | EL_ALLOW_EDIT | EL_ALLOW_DELETE,
+                 const wxString& name = "editableListBox")
+</pre>
+
+<p><b>Methods:</b>
+<ul>
+    <li><b>SetStrings(const wxArrayString& strings)</b> - Set an array of strings
+    into the control. <b>Note</b>: The wxPython method accepts a Python list instead
+    of an array of strings.
+
+    <li><b>void GetStrings(wxArrayString& strings)</b> - Retrieves an array
+    of strings from the control. The wxPython version returns a list of strings.
+
+    <li><b>GetListCtrl()</b> - Retrieves a reference to the actual list control
+    portion of the custom control.
+
+    <li><b>GetDelButton()</b> - Retrieves a reference to the BitmapButton that is used
+    as the 'delete' button in the control.
+
+    <li><b>GetNewButton()</b> - Retrieves a reference to the BitmapButton that is used
+    as the 'new' button in the control.
+
+    <li><b>GetUpButton()</b> - Retrieves a reference to the BitmapButton that is used
+    as the 'up' button in the control.
+
+    <li><b>GetDownButton()</b> - Retrieves a reference to the BitmapButton that is used
+    as the 'down' button in the control.
+
+    <li><b>GetEditButton()</b> - Retrieves a reference to the BitmapButton that is used
+    as the 'edit' button in the control.
+</ul>
+</body>
+</html>
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+