wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/demo/PropertySheetDialog.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python
+
+import wx
+import wx.adv
+
+import images
+
+#----------------------------------------------------------------------
+
+
+class MyPropSheetDlg(wx.adv.PropertySheetDialog):
+    def __init__(self, parent, bookType):
+        wx.adv.PropertySheetDialog.__init__(self)
+
+        # Setup
+        sheetStyle = bookType | wx.adv.PROPSHEET_SHRINKTOFIT
+        self.SetSheetStyle(sheetStyle)
+        self.SetSheetInnerBorder(0)
+        self.SetSheetOuterBorder(0)
+
+        # Base class' Create() makes the book control, sizers, etc.
+        self.Create(parent, title="Sample App Preferences")
+
+        # Create the stock buttons
+        self.CreateButtons(wx.OK|wx.CANCEL)
+
+        # Add some pages
+        notebook = self.GetBookCtrl()
+        page0 = self.CreateInfoPage(notebook)
+        page1 = self.CreateGeneralSettingsPage(notebook)
+        page2 = self.CreateAestheticSettingsPage(notebook)
+
+        if bookType & (wx.adv.PROPSHEET_BUTTONTOOLBOOK |
+                       wx.adv.PROPSHEET_TOOLBOOK ):
+
+            self.imageList = wx.ImageList(32,32)
+            lb01 = self.imageList.Add(images.LB01.GetBitmap())
+            lb02 = self.imageList.Add(images.LB02.GetBitmap())
+            lb03 = self.imageList.Add(images.LB03.GetBitmap())
+            notebook.SetImageList(self.imageList)
+        else:
+            lb01 = lb02 = lb03 = -1
+
+        notebook.AddPage(page0, "Info", imageId=lb01)
+        notebook.AddPage(page1, "General", imageId=lb02)
+        notebook.AddPage(page2, "Aesthetics", imageId=lb03)
+
+        # Do the layout
+        self.LayoutDialog()
+
+
+    # This and the following method just create some panels to display in the
+    # bookctrl in the dialog.  The actual content of these panels don't
+    # matter much so pay very little attention to them, the point is that any
+    # kind of panels with controls can be used here and the PropertySheetDialog
+    # takes care of the rest.
+    def CreateGeneralSettingsPage(self, parent):
+        panel = wx.Panel(parent)
+
+        topSizer = wx.BoxSizer( wx.VERTICAL )
+        item0 = wx.BoxSizer( wx.VERTICAL )
+
+        itemSizer3 = wx.BoxSizer( wx.HORIZONTAL )
+        checkBox3 = wx.CheckBox(panel, -1, "&Load last project on startup")
+        itemSizer3.Add(checkBox3, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        item0.Add(itemSizer3, 0, wx.EXPAND|wx.ALL, 0)
+
+        autoSaveLabel = "&Auto-save every"
+        minsLabel = "mins"
+
+        itemSizer12 = wx.BoxSizer( wx.HORIZONTAL )
+        checkBox12 = wx.CheckBox(panel, -1, autoSaveLabel)
+
+        spinCtrl12 = wx.SpinCtrl(panel, -1, "", (-1,-1), (40, -1), wx.SP_ARROW_KEYS, 1, 60, 1)
+        itemSizer12.Add(checkBox12, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        itemSizer12.Add(spinCtrl12, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        itemSizer12.Add(wx.StaticText(panel, -1, minsLabel), 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        item0.Add(itemSizer12, 0, wx.EXPAND|wx.ALL, 0)
+
+        itemSizer8 = wx.BoxSizer( wx.HORIZONTAL )
+        checkBox6 = wx.CheckBox(panel, -1, "Show &tooltips")
+        itemSizer8.Add(checkBox6, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        item0.Add(itemSizer8, 0, wx.EXPAND|wx.ALL, 0)
+
+        topSizer.Add( item0, 1, wx.EXPAND|wx.ALIGN_CENTRE|wx.ALL, 5 )
+
+        panel.SetSizer(topSizer)
+        return panel
+
+
+    def CreateAestheticSettingsPage(self, parent):
+        panel = wx.Panel(parent)
+
+        topSizer = wx.BoxSizer( wx.VERTICAL )
+        item0 = wx.BoxSizer( wx.VERTICAL )
+
+        globalOrProjectChoices = [ "&New projects",
+                                   "&This project",
+                                   ]
+
+        projectOrGlobal = wx.RadioBox(panel, -1, "&Apply settings to:",
+                                      choices=globalOrProjectChoices,
+                                      majorDimension=2)
+        item0.Add(projectOrGlobal, 0, wx.EXPAND|wx.ALL, 5)
+        projectOrGlobal.SetSelection(0)
+
+        backgroundStyleChoices = [ "Colour",
+                                   "Image",
+                                   ]
+
+        staticBox3 = wx.StaticBox(panel, -1, "Background style:")
+        styleSizer = wx.StaticBoxSizer( staticBox3, wx.VERTICAL )
+        item0.Add(styleSizer, 0, wx.EXPAND|wx.ALL, 5)
+
+        itemSizer2 = wx.BoxSizer( wx.HORIZONTAL )
+        choice2 = wx.Choice(panel, -1, choices=backgroundStyleChoices)
+
+        itemSizer2.Add(wx.StaticText(panel, -1, "&Window:"), 0,
+                       wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+        itemSizer2.Add(5, 5, 1, wx.ALL, 0)
+        itemSizer2.Add(choice2, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        styleSizer.Add(itemSizer2, 0, wx.EXPAND|wx.ALL, 5)
+
+        staticBox1 = wx.StaticBox(panel, -1, "Tile font size:")
+        itemSizer5 = wx.StaticBoxSizer( staticBox1, wx.HORIZONTAL )
+
+        spinCtrl = wx.SpinCtrl(panel, -1, "", size=(80, -1))
+        itemSizer5.Add(spinCtrl, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL|wx.ALIGN_CENTER_VERTICAL, 5)
+
+        item0.Add(itemSizer5, 0, wx.EXPAND|wx.LEFT|wx.RIGHT, 5)
+
+        topSizer.Add(item0, 1, wx.EXPAND|wx.ALIGN_CENTRE|wx.ALL, 5 )
+        topSizer.AddSpacer(5)
+
+        panel.SetSizer(topSizer)
+        return panel
+
+
+    def CreateInfoPage(self, parent):
+        panel = wx.Panel(parent)
+        statTxt = wx.StaticText(panel, -1, infoText)
+        sizer = wx.BoxSizer()
+        sizer.Add(statTxt, 1, wx.EXPAND|wx.ALL, 15)
+        panel.SetSizer(sizer)
+        return panel
+
+
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        btn1 = wx.Button(self, -1, "Show PropertySheetDialog with Notebook")
+        btn2 = wx.Button(self, -1, "Show PropertySheetDialog with Toolbook")
+        btn3 = wx.Button(self, -1, "Show PropertySheetDialog with ButtonToolbook")
+        btn4 = wx.Button(self, -1, "Show PropertySheetDialog with Listbook")
+
+        self.Bind(wx.EVT_BUTTON, self.OnButton1, btn1)
+        self.Bind(wx.EVT_BUTTON, self.OnButton2, btn2)
+        self.Bind(wx.EVT_BUTTON, self.OnButton3, btn3)
+        self.Bind(wx.EVT_BUTTON, self.OnButton4, btn4)
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(btn1, 0, wx.ALL, 10)
+        sizer.Add(btn2, 0, wx.ALL, 10)
+        sizer.Add(btn3, 0, wx.ALL, 10)
+        sizer.Add(btn4, 0, wx.ALL, 10)
+
+        box = wx.BoxSizer()
+        box.Add(sizer, 0, wx.ALL, 15)
+        self.SetSizer(box)
+
+
+    def ShowPropSheet(self, style):
+        with MyPropSheetDlg(self, style) as dlg:
+            if dlg.ShowModal() == wx.ID_OK:
+                self.log.write('Dialog ended with OK button\n')
+            else:
+                self.log.write('Dialog cancelled\n')
+
+
+    def OnButton1(self, evt):
+        self.ShowPropSheet(wx.adv.PROPSHEET_NOTEBOOK)
+
+
+    def OnButton2(self, evt):
+        self.ShowPropSheet(wx.adv.PROPSHEET_TOOLBOOK)
+
+
+    def OnButton3(self, evt):
+        self.ShowPropSheet(wx.adv.PROPSHEET_BUTTONTOOLBOOK)
+
+
+    def OnButton4(self, evt):
+        self.ShowPropSheet(wx.adv.PROPSHEET_LISTBOOK)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+#----------------------------------------------------------------------
+
+infoText = """\
+A wx.adv.PropertySheetDialog provides a standard framework to show settings or
+preferences for your applications.  You just need to provide panels for each
+'page' to be shown in the dialog and the PropertySheetDialog takes care of
+showing those panels in one of several kinds of book controls, adding buttons,
+etc.
+"""
+
+
+overview = """<html><body>
+<h2><center>PropertySheetDialog</center></h2>
+{}
+</body></html>
+""".format(infoText)
+
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+

wx/demo/PseudoDC.py

@@ -0,0 +1,350 @@
+#!/usr/bin/env python
+
+import wx
+import wx.adv
+import images
+import random
+
+#---------------------------------------------------------------------------
+
+W = 2000
+H = 2000
+SW = 150
+SH = 150
+SHAPE_COUNT = 750
+hitradius = 5
+
+#---------------------------------------------------------------------------
+
+colours = [
+    "BLACK",
+    "BLUE",
+    "BLUE VIOLET",
+    "BROWN",
+    "CYAN",
+    "DARK GREY",
+    "DARK GREEN",
+    "GOLD",
+    "GREY",
+    "GREEN",
+    "MAGENTA",
+    "NAVY",
+    "PINK",
+    "RED",
+    "SKY BLUE",
+    "VIOLET",
+    "YELLOW",
+    ]
+
+
+
+class MyCanvas(wx.ScrolledWindow):
+    def __init__(self, parent, id, log, size = wx.DefaultSize):
+        wx.ScrolledWindow.__init__(self, parent, id, (0, 0), size=size, style=wx.SUNKEN_BORDER)
+
+        self.lines = []
+        self.maxWidth  = W
+        self.maxHeight = H
+        self.x = self.y = 0
+        self.curLine = []
+        self.drawing = False
+
+        self.SetBackgroundColour("WHITE")
+        bmp = images.Test2.GetBitmap()
+        mask = wx.Mask(bmp, wx.BLUE)
+        bmp.SetMask(mask)
+        self.bmp = bmp
+
+        self.SetVirtualSize((self.maxWidth, self.maxHeight))
+        self.SetScrollRate(20,20)
+
+        # create a PseudoDC to record our drawing
+        self.pdc = wx.adv.PseudoDC()
+        self.pen_cache = {}
+        self.brush_cache = {}
+        self.DoDrawing(self.pdc)
+        log.write('Created PseudoDC draw list with %d operations!'%self.pdc.GetLen())
+
+        self.Bind(wx.EVT_PAINT, self.OnPaint)
+        self.Bind(wx.EVT_ERASE_BACKGROUND, lambda x:None)
+        self.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouse)
+
+        # vars for handling mouse clicks
+        self.dragid = -1
+        self.lastpos = (0,0)
+
+    def ConvertEventCoords(self, event):
+        xView, yView = self.GetViewStart()
+        xDelta, yDelta = self.GetScrollPixelsPerUnit()
+        return (event.GetX() + (xView * xDelta),
+            event.GetY() + (yView * yDelta))
+
+    def OffsetRect(self, r):
+        xView, yView = self.GetViewStart()
+        xDelta, yDelta = self.GetScrollPixelsPerUnit()
+        r.Offset(-(xView*xDelta),-(yView*yDelta))
+
+    def OnMouse(self, event):
+        global hitradius
+        if event.LeftDown():
+            x,y = self.ConvertEventCoords(event)
+            #l = self.pdc.FindObjectsByBBox(x, y)
+            l = self.pdc.FindObjects(x, y, hitradius)
+            for id in l:
+                if not self.pdc.GetIdGreyedOut(id):
+                    self.dragid = id
+                    self.lastpos = (event.GetX(),event.GetY())
+                    break
+        elif event.RightDown():
+            x,y = self.ConvertEventCoords(event)
+            #l = self.pdc.FindObjectsByBBox(x, y)
+            l = self.pdc.FindObjects(x, y, hitradius)
+            if l:
+                self.pdc.SetIdGreyedOut(l[0], not self.pdc.GetIdGreyedOut(l[0]))
+                r = self.pdc.GetIdBounds(l[0])
+                r.Inflate(4,4)
+                self.OffsetRect(r)
+                self.RefreshRect(r, False)
+        elif event.Dragging() or event.LeftUp():
+            if self.dragid != -1:
+                x,y = self.lastpos
+                dx = event.GetX() - x
+                dy = event.GetY() - y
+                r = self.pdc.GetIdBounds(self.dragid)
+                self.pdc.TranslateId(self.dragid, dx, dy)
+                r2 = self.pdc.GetIdBounds(self.dragid)
+                r = r.Union(r2)
+                r.Inflate(4,4)
+                self.OffsetRect(r)
+                self.RefreshRect(r, False)
+                self.lastpos = (event.GetX(),event.GetY())
+            if event.LeftUp():
+                self.dragid = -1
+
+    def RandomPen(self):
+        c = random.choice(colours)
+        t = random.randint(1, 4)
+        if (c, t) not in self.pen_cache:
+            self.pen_cache[(c, t)] = wx.Pen(c, t)
+        return self.pen_cache[(c, t)]
+
+
+    def RandomBrush(self):
+        c = random.choice(colours)
+        if c not in self.brush_cache:
+            self.brush_cache[c] = wx.Brush(c)
+
+        return self.brush_cache[c]
+
+    def RandomColor(self):
+        return random.choice(colours)
+
+
+    def OnPaint(self, event):
+        # Create a buffered paint DC.  It will create the real
+        # wx.PaintDC and then blit the bitmap to it when dc is
+        # deleted.
+        dc = wx.BufferedPaintDC(self)
+
+        # we need to clear the dc BEFORE calling PrepareDC
+        bg = wx.Brush(self.GetBackgroundColour())
+        dc.SetBackground(bg)
+        dc.Clear()
+
+        # use PrepareDC to set position correctly
+        self.PrepareDC(dc)
+
+        # create a clipping rect from our position and size
+        # and the Update Region
+        xv, yv = self.GetViewStart()
+        dx, dy = self.GetScrollPixelsPerUnit()
+        x, y   = (xv * dx, yv * dy)
+        rgn = self.GetUpdateRegion()
+        rgn.Offset(x,y)
+        r = rgn.GetBox()
+
+        # Draw the saved drawing operations to the dc using the calculated
+        # clipping rect
+        self.pdc.DrawToDCClipped(dc,r)
+
+
+    def DoDrawing(self, dc):
+        random.seed()
+        self.objids = []
+        self.boundsdict = {}
+        for i in range(SHAPE_COUNT):
+            id = wx.NewIdRef()
+            dc.SetId(id)
+            choice = random.randint(0,8)
+            if choice in (0,1):
+                x = random.randint(0, W)
+                y = random.randint(0, H)
+                pen = self.RandomPen()
+                dc.SetPen(pen)
+                dc.DrawPoint(x,y)
+                r = wx.Rect(x,y,1,1)
+                r.Inflate(pen.GetWidth(),pen.GetWidth())
+                dc.SetIdBounds(id,r)
+            elif choice in (2,3):
+                x1 = random.randint(0, W-SW)
+                y1 = random.randint(0, H-SH)
+                x2 = random.randint(x1, x1+SW)
+                y2 = random.randint(y1, y1+SH)
+                pen = self.RandomPen()
+                dc.SetPen(pen)
+                dc.DrawLine(x1,y1,x2,y2)
+                r = wx.Rect(x1,y1,x2-x1,y2-y1)
+                r.Inflate(pen.GetWidth(),pen.GetWidth())
+                dc.SetIdBounds(id,r)
+            elif choice in (4,5):
+                w = random.randint(10, SW)
+                h = random.randint(10, SH)
+                x = random.randint(0, W - w)
+                y = random.randint(0, H - h)
+                pen = self.RandomPen()
+                dc.SetPen(pen)
+                dc.SetBrush(self.RandomBrush())
+                dc.DrawRectangle(x,y,w,h)
+                r = wx.Rect(x,y,w,h)
+                r.Inflate(pen.GetWidth(),pen.GetWidth())
+                dc.SetIdBounds(id,r)
+                self.objids.append(id)
+            elif choice == 6:
+                Np = 8 # number of characters in text
+                word = []
+                for i in range(Np):
+                    c = chr( random.randint(48, 122) )
+                    word.append( c )
+                word = "".join(word)
+                w,h = self.GetFullTextExtent(word)[0:2]
+                x = random.randint(0, W-w)
+                y = random.randint(0, H-h)
+                dc.SetFont(self.GetFont())
+                dc.SetTextForeground(self.RandomColor())
+                dc.SetTextBackground(self.RandomColor())
+                dc.DrawText(word, x, y)
+                r = wx.Rect(x,y,w,h)
+                r.Inflate(2,2)
+                dc.SetIdBounds(id, r)
+                self.objids.append(id)
+            elif choice == 7:
+                Np = 8 # number of points per polygon
+                poly = []
+                minx = SW
+                miny = SH
+                maxx = 0
+                maxy = 0
+                for i in range(Np):
+                    x = random.randint(0, SW)
+                    y = random.randint(0, SH)
+                    if x < minx: minx = x
+                    if x > maxx: maxx = x
+                    if y < miny: miny = y
+                    if y > maxy: maxy = y
+                    poly.append(wx.Point(x,y))
+                x = random.randint(0, W-SW)
+                y = random.randint(0, H-SH)
+                pen = self.RandomPen()
+                dc.SetPen(pen)
+                dc.SetBrush(self.RandomBrush())
+                dc.DrawPolygon(poly, x,y)
+                r = wx.Rect(minx+x,miny+y,maxx-minx,maxy-miny)
+                r.Inflate(pen.GetWidth(),pen.GetWidth())
+                dc.SetIdBounds(id,r)
+                self.objids.append(id)
+            elif choice == 8:
+                w,h = self.bmp.GetSize()
+                x = random.randint(0, W-w)
+                y = random.randint(0, H-h)
+                dc.DrawBitmap(self.bmp,x,y,True)
+                dc.SetIdBounds(id,wx.Rect(x,y,w,h))
+                self.objids.append(id)
+
+
+class ControlPanel(wx.Panel):
+    def __init__(self, parent, id, pos=wx.DefaultPosition,
+            size=wx.DefaultSize, style = wx.TAB_TRAVERSAL):
+        wx.Panel.__init__(self,parent,id,pos,size,style)
+        lbl = wx.StaticText(self, wx.ID_ANY, "Hit Test Radius: ")
+        lbl2 = wx.StaticText(self, wx.ID_ANY, "Left Click to drag, Right Click to enable/disable")
+        sc = wx.SpinCtrl(self, wx.ID_ANY, "5")
+        sc.SetRange(0,100)
+        global hitradius
+        sc.SetValue(hitradius)
+        self.sc = sc
+        sz = wx.BoxSizer(wx.HORIZONTAL)
+        sz.Add(lbl,0,wx.EXPAND)
+        sz.Add(sc,0)
+        sz.Add(lbl2,0,wx.LEFT,5)
+        sz.Add((10,10),1,wx.EXPAND)
+        self.SetSizerAndFit(sz)
+        sc.Bind(wx.EVT_SPINCTRL,self.OnChange)
+        sc.Bind(wx.EVT_TEXT,self.OnChange)
+
+    def OnChange(self, event):
+        global hitradius
+        hitradius = self.sc.GetValue()
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    pnl = wx.Panel(nb, wx.ID_ANY,size=(200,30))
+    pnl2 = ControlPanel(pnl,wx.ID_ANY)
+    win = MyCanvas(pnl, wx.ID_ANY, log)
+    sz = wx.BoxSizer(wx.VERTICAL)
+    sz.Add(pnl2,0,wx.EXPAND|wx.ALL,5)
+    sz.Add(win,1,wx.EXPAND)
+    pnl.SetSizerAndFit(sz)
+    return pnl
+
+#---------------------------------------------------------------------------
+
+
+
+overview = """
+<html>
+<body>
+<h2>wx.adv.PseudoDC</h2>
+
+The wx.adv.PseudoDC class provides a way to record operations on a DC and then
+play them back later.  The PseudoDC can be passed to a drawing routine as
+if it were a real DC.  All Drawing methods are supported except Blit but
+GetXXX methods are not supported and none of the drawing methods return
+a value. The PseudoDC records the drawing to an operation
+list.  The operations can be played back to a real DC using:<pre>
+DrawToDC(dc)
+</pre>
+The operations can be tagged with an id in order to associate them with a
+specific object.  To do this use:<pre>
+    SetId(id)
+</pre>
+Every operation after this will be associated with that tag id until SetId is called
+again.  The PseudoDC also supports object level clipping.  To enable this use:<pre>
+    SetIdBounds(id,rect)
+</pre>
+for each object that should be clipped.  Then use:<pre>
+    DrawToDCClipped(dc, clippingRect)
+</pre>
+To draw the PseudoDC to a real dc. This is useful for large scrolled windows
+where many objects are off screen.
+
+Objects can be moved around without re-drawing using:<pre>
+    TranslateId(id, dx, dy)
+</pre>
+
+To re-draw an object use:<pre>
+    ClearId(id)
+    SetId(id)
+</pre>
+and then re-draw the object.
+</body>
+</html>
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+

wx/demo/PyColourChooser.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+import wx
+import wx.lib.colourchooser as cc
+
+#---------------------------------------------------------------
+
+class TestColourChooser(wx.Panel):
+    def __init__(self, parent, log):
+        wx.Panel.__init__(self, parent, -1)
+        self.log = log
+
+        chooser = cc.PyColourChooser(self, -1)
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(chooser, 0, wx.ALL, 25)
+
+        self.SetAutoLayout(True)
+        self.SetSizer(sizer)
+
+#---------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestColourChooser(nb, log)
+    return win
+
+#---------------------------------------------------------------
+
+overview = """
+The PyColourChooser component creates a colour chooser window
+that is similar to the Microsoft Windows colour chooser dialog.
+This dialog component is drawn in a panel, and thus can be
+embedded inside any widget (although it cannot be resized).
+This colour chooser may also be substituted for the colour
+chooser on any platform that might have an ugly one :)
+
+How to use it
+------------------------------
+
+The demo (demo/PyColourChooser.py code shows how to display
+a colour chooser and retrieve its options.
+
+Contact and Author Info
+------------------------------
+
+PyColourChooser was written and is maintained by:
+
+    Michael Gilfix <mgilfix@eecs.tufts.edu>
+
+You can find the latest PyColourChooser code at
+http://sourceforge.net/projects/wxcolourchooser/. If you have
+any suggestions or want to submit a patch, please send
+it my way at: mgilfix@eecs.tufts.edu
+"""
+
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])

wx/demo/PyCrust.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+
+import wx.py as  py
+
+#----------------------------------------------------------------------
+
+intro = 'Welcome To PyCrust %s - The Flakiest Python Shell' % py.version.VERSION
+
+def runTest(frame, nb, log):
+    win = py.crust.Crust(nb, intro=intro)
+    return win
+
+#----------------------------------------------------------------------
+
+overview = py.filling.__doc__ + "\n\n" + py.crust.__doc__
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+