wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/demo/ListCtrl_virtual.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+
+import wx
+import images
+
+#----------------------------------------------------------------------
+
+class TestVirtualList(wx.ListCtrl):
+    def __init__(self, parent, log):
+        wx.ListCtrl.__init__(
+            self, parent, -1,
+            style=wx.LC_REPORT|wx.LC_VIRTUAL|wx.LC_HRULES|wx.LC_VRULES
+            )
+
+        self.log = log
+
+        self.il = wx.ImageList(16, 16)
+        self.idx1 = self.il.Add(images.Smiles.GetBitmap())
+        empty = self.makeBlank()
+        self.idx2 = self.il.Add(empty)
+        self.SetImageList(self.il, wx.IMAGE_LIST_SMALL)
+
+
+        self.InsertColumn(0, "First")
+        self.InsertColumn(1, "Second")
+        self.InsertColumn(2, "Third")
+        self.SetColumnWidth(0, 175)
+        self.SetColumnWidth(1, 175)
+        self.SetColumnWidth(2, 175)
+
+        self.SetItemCount(1000000)
+
+        self.attr1 = wx.ItemAttr()
+        self.attr1.SetBackgroundColour("yellow")
+
+        self.attr2 = wx.ItemAttr()
+        self.attr2.SetBackgroundColour("light blue")
+
+        self.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnItemSelected)
+        self.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnItemActivated)
+        self.Bind(wx.EVT_LIST_ITEM_DESELECTED, self.OnItemDeselected)
+
+
+    def makeBlank(self):
+        empty = wx.Bitmap(16,16,32)
+        dc = wx.MemoryDC(empty)
+        dc.SetBackground(wx.Brush((0,0,0,0)))
+        dc.Clear()
+        del dc
+        empty.SetMaskColour((0,0,0))
+        return empty
+
+    def OnItemSelected(self, event):
+        self.currentItem = event.Index
+        self.log.WriteText('OnItemSelected: "%s", "%s", "%s", "%s"\n' %
+                           (self.currentItem,
+                            self.GetItemText(self.currentItem),
+                            self.getColumnText(self.currentItem, 1),
+                            self.getColumnText(self.currentItem, 2)))
+
+    def OnItemActivated(self, event):
+        self.currentItem = event.Index
+        self.log.WriteText("OnItemActivated: %s\nTopItem: %s\n" %
+                           (self.GetItemText(self.currentItem), self.GetTopItem()))
+
+    def getColumnText(self, index, col):
+        item = self.GetItem(index, col)
+        return item.GetText()
+
+    def OnItemDeselected(self, evt):
+        self.log.WriteText("OnItemDeselected: %s" % evt.Index)
+
+
+    #-----------------------------------------------------------------
+    # These methods are callbacks for implementing the "virtualness"
+    # of the list...  Normally you would determine the text,
+    # attributes and/or image based on values from some external data
+    # source, but for this demo we'll just calculate them
+    def OnGetItemText(self, item, col):
+        return "Item %d, column %d" % (item, col)
+
+    def OnGetItemImage(self, item):
+        if item % 3 == 0:
+            return self.idx1
+        else:
+            return self.idx2
+
+    def OnGetItemAttr(self, item):
+        if item % 3 == 1:
+            return self.attr1
+        elif item % 3 == 2:
+            return self.attr2
+        else:
+            return None
+
+
+class TestVirtualListPanel(wx.Panel):
+    def __init__(self, parent, log):
+        wx.Panel.__init__(self, parent, -1, style=wx.WANTS_CHARS)
+
+        self.log = log
+        sizer = wx.BoxSizer(wx.VERTICAL)
+
+        if wx.Platform == "__WXMAC__" and \
+               hasattr(wx.GetApp().GetTopWindow(), "LoadDemo"):
+            self.useNative = wx.CheckBox(self, -1, "Use native listctrl")
+            self.useNative.SetValue(
+                not wx.SystemOptions.GetOptionInt("mac.listctrl.always_use_generic") )
+            self.Bind(wx.EVT_CHECKBOX, self.OnUseNative, self.useNative)
+            sizer.Add(self.useNative, 0, wx.ALL | wx.ALIGN_RIGHT, 4)
+
+        self.list = TestVirtualList(self, self.log)
+        sizer.Add(self.list, 1, wx.EXPAND)
+
+        self.SetSizer(sizer)
+        self.SetAutoLayout(True)
+
+    def OnUseNative(self, event):
+        wx.SystemOptions.SetOptionInt("mac.listctrl.always_use_generic", not event.IsChecked())
+        wx.GetApp().GetTopWindow().LoadDemo("ListCtrl_virtual")
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestVirtualListPanel(nb, log)
+    return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+This example demonstrates the ListCtrl's Virtual List features. A Virtual list
+can contain any number of cells, but data is not loaded into the control itself.
+It is loaded on demand via virtual methods <code>OnGetItemText(), OnGetItemImage()</code>,
+and <code>OnGetItemAttr()</code>. This greatly reduces the amount of memory required
+without limiting what can be done with the list control itself.
+"""
+
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+

wx/demo/Listbook.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+
+import wx
+
+import ColorPanel
+import images
+
+colourList = [ "Aquamarine", "Black", "Blue", "Blue Violet", "Brown", "Cadet Blue",
+               "Coral", "Cornflower Blue", "Cyan", "Dark Grey", "Dark Green",
+               "Dark Olive Green",
+               ]
+
+#----------------------------------------------------------------------------
+
+class TestLB(wx.Listbook):
+    def __init__(self, parent, id, log):
+        wx.Listbook.__init__(self, parent, id, style=
+                            wx.BK_DEFAULT
+                            #wx.BK_TOP
+                            #wx.BK_BOTTOM
+                            #wx.BK_LEFT
+                            #wx.BK_RIGHT
+                            )
+        self.log = log
+
+        # make an image list using the LBXX images
+        il = wx.ImageList(32, 32)
+        for x in range(12):
+            obj = getattr(images, 'LB%02d' % (x+1))
+            bmp = obj.GetBitmap()
+            il.Add(bmp)
+        self.AssignImageList(il)
+
+        # Now make a bunch of panels for the list book
+        first = True
+        imID = 0
+        for colour in colourList:
+            win = self.makeColorPanel(colour)
+            self.AddPage(win, colour, imageId=imID)
+            imID += 1
+            if imID == il.GetImageCount(): imID = 0
+            if first:
+                st = wx.StaticText(win.win, -1,
+                          "You can put nearly any type of window here,\n"
+                          "and the list can be on any side of the Listbook",
+                          wx.Point(10, 10))
+                first = False
+
+        self.Bind(wx.EVT_LISTBOOK_PAGE_CHANGED, self.OnPageChanged)
+        self.Bind(wx.EVT_LISTBOOK_PAGE_CHANGING, self.OnPageChanging)
+
+
+    def makeColorPanel(self, color):
+        p = wx.Panel(self, -1)
+        win = ColorPanel.ColoredPanel(p, color)
+        p.win = win
+        def OnCPSize(evt, win=win):
+            win.SetPosition((0,0))
+            win.SetSize(evt.GetSize())
+        p.Bind(wx.EVT_SIZE, OnCPSize)
+        return p
+
+
+    def OnPageChanged(self, event):
+        old = event.GetOldSelection()
+        new = event.GetSelection()
+        sel = self.GetSelection()
+        self.log.write('OnPageChanged,  old:%d, new:%d, sel:%d\n' % (old, new, sel))
+        event.Skip()
+
+    def OnPageChanging(self, event):
+        old = event.GetOldSelection()
+        new = event.GetSelection()
+        sel = self.GetSelection()
+        self.log.write('OnPageChanging, old:%d, new:%d, sel:%d\n' % (old, new, sel))
+        event.Skip()
+
+#----------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    testWin = TestLB(nb, -1, log)
+    return testWin
+
+#----------------------------------------------------------------------------
+
+
+overview = """\
+<html><body>
+<h2>wx.Listbook</h2>
+<p>
+This class is a control similar to a notebook control, but with a
+wx.ListCtrl instead of a set of tabs.
+
+"""
+
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
+

wx/demo/MDIDemo.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+
+import wx
+
+# Importing ScrolledWindow demo to make use of the MyCanvas
+# class defined within.
+import ScrolledWindow
+import images
+
+SHOW_BACKGROUND = 1
+
+#----------------------------------------------------------------------
+ID_New  = wx.NewIdRef()
+ID_Exit = wx.NewIdRef()
+#----------------------------------------------------------------------
+
+class MyParentFrame(wx.MDIParentFrame):
+    def __init__(self):
+        wx.MDIParentFrame.__init__(self, None, -1, "MDI Parent", size=(600,400))
+
+        self.winCount = 0
+        menu = wx.Menu()
+        menu.Append(ID_New, "&New Window")
+        menu.AppendSeparator()
+        menu.Append(ID_Exit, "E&xit")
+
+        menubar = wx.MenuBar()
+        menubar.Append(menu, "&File")
+        self.SetMenuBar(menubar)
+
+        self.CreateStatusBar()
+
+        self.Bind(wx.EVT_MENU, self.OnNewWindow, id=ID_New)
+        self.Bind(wx.EVT_MENU, self.OnExit, id=ID_Exit)
+
+        if SHOW_BACKGROUND:
+            self.bg_bmp = images.GridBG.GetBitmap()
+            self.GetClientWindow().Bind(
+                wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground
+                )
+
+
+    def OnExit(self, evt):
+        self.Close(True)
+
+    def OnNewWindow(self, evt):
+        self.winCount = self.winCount + 1
+        win = wx.MDIChildFrame(self, -1, "Child Window: %d" % self.winCount)
+        canvas = ScrolledWindow.MyCanvas(win)
+        win.Show(True)
+
+    def OnEraseBackground(self, evt):
+        dc = evt.GetDC()
+
+        # tile the background bitmap
+        try:
+            sz = self.GetClientSize()
+        except RuntimeError:#closing demo
+            return
+        w = self.bg_bmp.GetWidth()
+        h = self.bg_bmp.GetHeight()
+        x = 0
+
+        while x < sz.width:
+            y = 0
+
+            while y < sz.height:
+                dc.DrawBitmap(self.bg_bmp, x, y)
+                y = y + h
+
+            x = x + w
+
+
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+    class MyApp(wx.App):
+        def OnInit(self):
+            frame = MyParentFrame()
+            frame.Show(True)
+            self.SetTopWindow(frame)
+            return True
+
+    app = MyApp(False)
+    app.MainLoop()
+

wx/demo/MDISashDemo.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python
+
+import wx
+import wx.adv
+
+import ScrolledWindow
+
+#----------------------------------------------------------------------
+# There are better ways to do IDs, but this demo requires that the window
+# IDs be in a specific range. There are better ways to do that, too, but
+# this will do for purposes of this demo.
+
+ID_Menu_New         = 5004
+ID_Menu_Exit        = 5005
+
+ID_WINDOW_TOP       = 5000
+ID_WINDOW_LEFT1     = 5001
+ID_WINDOW_LEFT2     = 5002
+ID_WINDOW_BOTTOM    = 5003
+
+#----------------------------------------------------------------------
+
+class MyParentFrame(wx.MDIParentFrame):
+    def __init__(self):
+        wx.MDIParentFrame.__init__(
+            self, None, -1, "MDI Parent", size=(600,400),
+            style = wx.DEFAULT_FRAME_STYLE | wx.HSCROLL | wx.VSCROLL
+            )
+
+        self.winCount = 0
+        menu = wx.Menu()
+        menu.Append(ID_Menu_New, "&New Window")
+        menu.AppendSeparator()
+        menu.Append(ID_Menu_Exit, "E&xit")
+
+        menubar = wx.MenuBar()
+        menubar.Append(menu, "&File")
+        self.SetMenuBar(menubar)
+
+        #self.CreateStatusBar()
+
+        self.Bind(wx.EVT_MENU, self.OnNewWindow, id=ID_Menu_New)
+        self.Bind(wx.EVT_MENU, self.OnExit, id=ID_Menu_Exit)
+
+        self.Bind(
+            wx.adv.EVT_SASH_DRAGGED_RANGE, self.OnSashDrag, id=ID_WINDOW_TOP,
+            id2=ID_WINDOW_BOTTOM
+            )
+
+        self.Bind(wx.EVT_SIZE, self.OnSize)
+
+
+        # Create some layout windows
+        # A window like a toolbar
+        win = wx.adv.SashLayoutWindow(self, ID_WINDOW_TOP, style=wx.NO_BORDER|wx.adv.SW_3D)
+        win.SetDefaultSize((1000, 30))
+        win.SetOrientation(wx.adv.LAYOUT_HORIZONTAL)
+        win.SetAlignment(wx.adv.LAYOUT_TOP)
+        win.SetBackgroundColour(wx.RED)
+        win.SetSashVisible(wx.adv.SASH_BOTTOM, True)
+
+        self.topWindow = win
+
+
+        # A window like a statusbar
+        win = wx.adv.SashLayoutWindow(self, ID_WINDOW_BOTTOM, style=wx.NO_BORDER|wx.adv.SW_3D)
+        win.SetDefaultSize((1000, 30))
+        win.SetOrientation(wx.adv.LAYOUT_HORIZONTAL)
+        win.SetAlignment(wx.adv.LAYOUT_BOTTOM)
+        win.SetBackgroundColour(wx.BLUE)
+        win.SetSashVisible(wx.adv.SASH_TOP, True)
+
+        self.bottomWindow = win
+
+
+        # A window to the left of the client window
+        win =  wx.adv.SashLayoutWindow(self, ID_WINDOW_LEFT1, style=wx.NO_BORDER|wx.adv.SW_3D)
+        win.SetDefaultSize((120, 1000))
+        win.SetOrientation(wx.adv.LAYOUT_VERTICAL)
+        win.SetAlignment(wx.adv.LAYOUT_LEFT)
+        win.SetBackgroundColour(wx.GREEN)
+        win.SetSashVisible(wx.adv.SASH_RIGHT, True)
+        win.SetExtraBorderSize(10)
+        textWindow = wx.TextCtrl(win, -1, "", style=wx.TE_MULTILINE|wx.SUNKEN_BORDER)
+        textWindow.SetValue("A sub window")
+
+        self.leftWindow1 = win
+
+
+        # Another window to the left of the client window
+        win = wx.adv.SashLayoutWindow(self, ID_WINDOW_LEFT2, style=wx.NO_BORDER|wx.adv.SW_3D)
+        win.SetDefaultSize((120, 1000))
+        win.SetOrientation(wx.adv.LAYOUT_VERTICAL)
+        win.SetAlignment(wx.adv.LAYOUT_LEFT)
+        win.SetBackgroundColour(wx.CYAN)
+        win.SetSashVisible(wx.adv.SASH_RIGHT, True)
+
+        self.leftWindow2 = win
+
+
+    def OnSashDrag(self, event):
+        if event.GetDragStatus() == wx.adv.SASH_STATUS_OUT_OF_RANGE:
+            return
+
+        eID = event.GetId()
+
+        if eID == ID_WINDOW_TOP:
+            self.topWindow.SetDefaultSize((1000, event.GetDragRect().height))
+
+        elif eID == ID_WINDOW_LEFT1:
+            self.leftWindow1.SetDefaultSize((event.GetDragRect().width, 1000))
+
+        elif eID == ID_WINDOW_LEFT2:
+            self.leftWindow2.SetDefaultSize((event.GetDragRect().width, 1000))
+
+        elif eID == ID_WINDOW_BOTTOM:
+            self.bottomWindow.SetDefaultSize((1000, event.GetDragRect().height))
+
+        wx.adv.LayoutAlgorithm().LayoutMDIFrame(self)
+        self.GetClientWindow().Refresh()
+
+
+    def OnSize(self, event):
+        wx.adv.LayoutAlgorithm().LayoutMDIFrame(self)
+
+
+    def OnExit(self, evt):
+        self.Close(True)
+
+
+    def OnNewWindow(self, evt):
+        self.winCount = self.winCount + 1
+        win = wx.MDIChildFrame(self, -1, "Child Window: %d" % self.winCount)
+        canvas = ScrolledWindow.MyCanvas(win)
+        win.Show(True)
+
+
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+    class MyApp(wx.App):
+        def OnInit(self):
+            frame = MyParentFrame()
+            frame.Show(True)
+            self.SetTopWindow(frame)
+            return True
+
+    app = MyApp(False)
+    app.MainLoop()
+
+
+

wx/demo/MDIWindows.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+
+import wx
+import os
+import sys
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        b1 = wx.Button(self, -1, "MDI demo")
+        self.Bind(wx.EVT_BUTTON, self.ShowMDIDemo, b1)
+
+        b2 = wx.Button(self, -1, "MDI with SashWindows demo")
+        self.Bind(wx.EVT_BUTTON, self.ShowMDISashDemo, b2)
+
+        box = wx.BoxSizer(wx.VERTICAL)
+        box.Add((20, 30))
+        box.Add(b1, 0, wx.ALIGN_CENTER|wx.ALL, 15)
+        box.Add(b2, 0, wx.ALIGN_CENTER|wx.ALL, 15)
+        self.SetAutoLayout(True)
+        self.SetSizer(box)
+
+
+    # These are spawned as new processes because on Mac there can be
+    # some problems related to having regular frames and MDI frames in
+    # the same app.
+    def ShowMDIDemo(self, evt):
+        exe, spawn = self.GetPyExecutable()
+        spawn(os.P_NOWAIT, exe, exe, "MDIDemo.py")
+
+    def ShowMDISashDemo(self, evt):
+        exe, spawn = self.GetPyExecutable()
+        spawn(os.P_NOWAIT, exe, exe, "MDISashDemo.py")
+
+    def GetPyExecutable(self):
+        return sys.executable, os.spawnl
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """<html><body>
+<h2><center>Multiple Document Interface</center></h2>
+
+Although Microsoft has deprecated the MDI model, wxWindows still supports
+it.  Here are a couple samples of how to use it - one straightforward, the other
+showing how the MDI interface can be integrated into a SashWindow interface.
+
+</body></html>
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])