wx.aui is an Advanced User Interface library for the wxWidgets toolkit
+that allows developers to create high-quality, cross-platform user
+interfaces quickly and easily.
+
+
Features
+
+
With wx.aui developers can create application frameworks with:
+
+The wx.aui.AuiMDIParentFrame and wx.aui.AuiMDIChildFrame classes
+implement the same API as wx.MDIParentFrame and wx.MDIChildFrame, but
+implement the multiple document interface with a wx.aui.AuiNotebook.
+
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/AUI_Notebook.py b/demo/AUI_Notebook.py
new file mode 100644
index 00000000..2d0a8495
--- /dev/null
+++ b/demo/AUI_Notebook.py
@@ -0,0 +1,57 @@
+
+import wx
+import wx.aui
+
+
+text = """\
+Hello!
+
+Welcome to this little demo of draggable tabs using the wx.aui module.
+
+To try it out, drag a tab from the top of the window all the way to the bottom. After releasing the mouse, the tab will dock at the hinted position. Then try it again with the remaining tabs in various other positions. Finally, try dragging a tab to an existing tab ctrl. You'll soon see that very complex tab layouts may be achieved.
+"""
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ self.nb = wx.aui.AuiNotebook(self)
+ page = wx.TextCtrl(self.nb, -1, text, style=wx.TE_MULTILINE)
+ self.nb.AddPage(page, "Welcome")
+
+ for num in range(1, 5):
+ page = wx.TextCtrl(self.nb, -1, "This is page %d" % num ,
+ style=wx.TE_MULTILINE)
+ self.nb.AddPage(page, "Tab Number %d" % num)
+
+ sizer = wx.BoxSizer()
+ sizer.Add(self.nb, 1, wx.EXPAND)
+ self.SetSizer(sizer)
+ wx.CallAfter(self.nb.SendSizeEvent)
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
Say something nice here
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/About.py b/demo/About.py
new file mode 100644
index 00000000..c9ea6ed1
--- /dev/null
+++ b/demo/About.py
@@ -0,0 +1,74 @@
+import sys
+
+import wx # This module uses the new wx namespace
+import wx.html
+import wx.lib.wxpTag
+
+#---------------------------------------------------------------------------
+
+class MyAboutBox(wx.Dialog):
+ text = '''
+
+
+
+
+
+
wxPython %s
+ (%s)
+ Running on Python %s
+
+
+
+
+
wxPython is a Python extension module that
+encapsulates the wxWindows GUI classes.
+
+
This demo shows off some of the capabilities
+of wxPython. Select items from the menu or tree control,
+sit back and enjoy. Be sure to take a peek at the source code for each
+demo item so you can learn how to use the classes yourself.
+
+
wxPython is brought to you by Robin Dunn and
+Total Control Software, Copyright (c) 1997-2011.
+
+
+Please see license.txt for licensing information.
+
+
+
+
+
+
+
+
+
+'''
+ def __init__(self, parent):
+ wx.Dialog.__init__(self, parent, -1, 'About the wxPython demo',)
+ html = wx.html.HtmlWindow(self, -1, size=(420, -1))
+ if "gtk2" in wx.PlatformInfo:
+ html.SetStandardFonts()
+ py_version = sys.version.split()[0]
+ txt = self.text % (wx.VERSION_STRING,
+ ", ".join(wx.PlatformInfo[1:]),
+ py_version
+ )
+ html.SetPage(txt)
+ btn = html.FindWindowById(wx.ID_OK)
+ ir = html.GetInternalRepresentation()
+ html.SetSize( (ir.GetWidth()+25, ir.GetHeight()+25) )
+ self.SetClientSize(html.GetSize())
+ self.CentreOnParent(wx.BOTH)
+
+#---------------------------------------------------------------------------
+
+
+
+if __name__ == '__main__':
+ app = wx.PySimpleApp()
+ dlg = MyAboutBox(None)
+ dlg.ShowModal()
+ dlg.Destroy()
+ app.MainLoop()
+
diff --git a/demo/AboutBox.py b/demo/AboutBox.py
new file mode 100644
index 00000000..fdec097b
--- /dev/null
+++ b/demo/AboutBox.py
@@ -0,0 +1,73 @@
+
+import wx
+from wx.lib.wordwrap import wordwrap
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Show a wx.AboutBox", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ # First we create and fill the info object
+ info = wx.AboutDialogInfo()
+ info.Name = "Hello World"
+ info.Version = "1.2.3"
+ info.Copyright = "(C) 2006 Programmers and Coders Everywhere"
+ info.Description = wordwrap(
+ "A \"hello world\" program is a software program that prints out "
+ "\"Hello world!\" on a display device. It is used in many introductory "
+ "tutorials for teaching a programming language."
+
+ "\n\nSuch a program is typically one of the simplest programs possible "
+ "in a computer language. A \"hello world\" program can be a useful "
+ "sanity test to make sure that a language's compiler, development "
+ "environment, and run-time environment are correctly installed.",
+ 350, wx.ClientDC(self))
+ info.WebSite = ("http://en.wikipedia.org/wiki/Hello_world", "Hello World home page")
+ info.Developers = [ "Joe Programmer",
+ "Jane Coder",
+ "Vippy the Mascot" ]
+
+ info.License = wordwrap(licenseText, 500, wx.ClientDC(self))
+
+ # Then we call wx.AboutBox giving it that info object
+ wx.AboutBox(info)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.AboutBox
+
+This function shows the native standard about dialog containing the
+information specified in info. If the current platform has a native
+about dialog which is capable of showing all the fields in info, the
+native dialog is used, otherwise the function falls back to the
+generic wxWidgets version of the dialog.
+
+
+"""
+
+
+licenseText = "blah " * 250 + "\n\n" +"yadda " * 100
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ActiveXWrapper_Acrobat.py b/demo/ActiveXWrapper_Acrobat.py
new file mode 100644
index 00000000..e6cc8f02
--- /dev/null
+++ b/demo/ActiveXWrapper_Acrobat.py
@@ -0,0 +1,130 @@
+"""
+
+This demo shows how to embed an ActiveX control in a wxPython application, (Win32 only.)
+
+The MakeActiveXClass function dynamically builds a new Class on the fly, that has the
+same signature and semantics as wxWindow. This means that when you call the function
+you get back a new class that you can use just like wxWindow, (set the size and position,
+use in a sizer, etc.) except its contents will be the COM control.
+
+This demo embeds the Adobe Acrobat Reader, and gives you some buttons for opening a PDF
+file, changing pages, etc. that show how to call methods on the COM object. If you don't
+have Acrobat Reader 4.0 installed it won't work.
+
+"""
+
+import wx
+
+if wx.Platform == '__WXMSW__':
+ from wx.lib.activexwrapper import MakeActiveXClass
+ import win32com.client.gencache
+
+ try:
+ #acrobat = win32com.client.gencache.EnsureModule('{CA8A9783-280D-11CF-A24D-444553540000}', 0x0, 1, 3)
+ acrobat = win32com.client.gencache.EnsureModule('{05BFD3F1-6319-4F30-B752-C7A22889BCC4}', 0x0, 1, 0)
+ except:
+ raise ImportError("Can't load PDF.OCX, install Acrobat 4.0")
+
+
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.pdf = None
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ btnSizer = wx.BoxSizer(wx.HORIZONTAL)
+
+ # this function creates a new class that can be used as
+ # a wxWindow, but contains the given ActiveX control.
+ ActiveXWrapper = MakeActiveXClass(acrobat.AcroPDF)
+
+ # create an instance of the new class
+ self.pdf = ActiveXWrapper( self, -1, style=wx.SUNKEN_BORDER)
+
+ sizer.Add(self.pdf, 1, wx.EXPAND)
+
+ btn = wx.Button(self, wx.NewId(), "Open PDF File")
+ wx.EVT_BUTTON(self, btn.GetId(), self.OnOpenButton)
+ btnSizer.Add(btn, 1, wx.EXPAND|wx.ALL, 5)
+
+ btn = wx.Button(self, wx.NewId(), "<-- Previous Page")
+ wx.EVT_BUTTON(self, btn.GetId(), self.OnPrevPageButton)
+ btnSizer.Add(btn, 1, wx.EXPAND|wx.ALL, 5)
+
+ btn = wx.Button(self, wx.NewId(), "Next Page -->")
+ wx.EVT_BUTTON(self, btn.GetId(), self.OnNextPageButton)
+ btnSizer.Add(btn, 1, wx.EXPAND|wx.ALL, 5)
+
+
+ btnSizer.Add((50, -1), 2, wx.EXPAND)
+ sizer.Add(btnSizer, 0, wx.EXPAND)
+
+ self.SetSizer(sizer)
+ self.SetAutoLayout(True)
+
+ wx.EVT_WINDOW_DESTROY(self, self.OnDestroy)
+
+
+ def OnDestroy(self, evt):
+ if self.pdf:
+ self.pdf.Cleanup()
+ self.pdf = None
+
+
+
+ def OnOpenButton(self, event):
+ dlg = wx.FileDialog(self, wildcard="*.pdf")
+ if dlg.ShowModal() == wx.ID_OK:
+ wx.BeginBusyCursor()
+ self.pdf.LoadFile(dlg.GetPath())
+ wx.EndBusyCursor()
+
+ dlg.Destroy()
+
+
+ def OnPrevPageButton(self, event):
+ self.pdf.gotoPreviousPage()
+
+
+ def OnNextPageButton(self, event):
+ self.pdf.gotoNextPage()
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ if wxPlatform == '__WXMSW__':
+ win = TestPanel(nb, log)
+ return win
+ else:
+ dlg = wx.MessageDialog(frame, 'This demo only works on MSW.',
+ 'Sorry', wx.OK | wx.ICON_INFORMATION)
+ dlg.ShowModal()
+ dlg.Destroy()
+
+
+overview = __doc__
+
+#----------------------------------------------------------------------
+
+
+if __name__ == '__main__':
+ import sys
+ class TestFrame(wx.Frame):
+ def __init__(self):
+ wx.Frame.__init__(self, None, -1, "ActiveX test -- Acrobat", size=(640, 480),
+ style=wx.DEFAULT_FRAME_STYLE|wx.NO_FULL_REPAINT_ON_RESIZE)
+ self.tp = TestPanel(self, sys.stdout)
+
+
+ app = wx.PySimpleApp()
+ frame = TestFrame()
+ frame.Show(True)
+ app.MainLoop()
+
+
+
diff --git a/demo/ActiveXWrapper_IE.py b/demo/ActiveXWrapper_IE.py
new file mode 100644
index 00000000..fa1a9e4a
--- /dev/null
+++ b/demo/ActiveXWrapper_IE.py
@@ -0,0 +1,186 @@
+
+import wx
+
+from wx.lib.activexwrapper import MakeActiveXClass
+import win32com.client.gencache
+browserModule = win32com.client.gencache.EnsureModule(
+ "{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}", 0, 1, 1)
+
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Window):
+ def __init__(self, parent, frame=None):
+ wx.Window.__init__(self, parent)
+ self.ie = None
+ self.current = "http://wxPython.org/"
+ self.frame = frame
+ if frame:
+ self.titleBase = frame.GetTitle()
+
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ btnSizer = wx.BoxSizer(wx.HORIZONTAL)
+
+ # Make a new class that derives from the WebBrowser class in the
+ # COM module imported above. This class also derives from wxWindow and
+ # implements the machinery needed to integrate the two worlds.
+ theClass = MakeActiveXClass(browserModule.WebBrowser, eventObj=self)
+
+ # Create an instance of that class
+ self.ie = theClass(self, -1)
+
+
+ btn = wx.Button(self, wx.NewId(), "Open", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnOpenButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ btn = wx.Button(self, wx.NewId(), "Home", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnHomeButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ btn = wx.Button(self, wx.NewId(), "<--", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnPrevPageButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ btn = wx.Button(self, wx.NewId(), "-->", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnNextPageButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ btn = wx.Button(self, wx.NewId(), "Stop", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnStopButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ btn = wx.Button(self, wx.NewId(), "Search", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnSearchPageButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ btn = wx.Button(self, wx.NewId(), "Refresh", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnRefreshPageButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ txt = wx.StaticText(self, -1, "Location:")
+ btnSizer.Add(txt, 0, wx.CENTER|wx.ALL, 2)
+
+ self.location = wx.ComboBox(self, wx.NewId(), "", style=wx.CB_DROPDOWN)
+ self.Bind(wx.EVT_COMBOBOX, self.OnLocationSelect, self.location)
+ self.location.Bind(wx.EVT_KEY_UP, self.OnLocationKey)
+ self.location.Bind(wx.EVT_CHAR, self.IgnoreReturn)
+ btnSizer.Add(self.location, 1, wx.EXPAND|wx.ALL, 2)
+
+ sizer.Add(btnSizer, 0, wx.EXPAND)
+ sizer.Add(self.ie, 1, wx.EXPAND)
+
+ self.ie.Navigate2(self.current)
+ self.location.Append(self.current)
+
+ self.SetSizer(sizer)
+
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
+
+
+
+ def OnDestroy(self, evt):
+ if self.ie:
+ self.ie.Cleanup()
+ self.ie = None
+ self.frame = None
+
+
+ def OnSize(self, evt):
+ self.Layout()
+
+
+ def OnLocationSelect(self, evt):
+ url = self.location.GetStringSelection()
+ self.ie.Navigate2(url)
+
+ def OnLocationKey(self, evt):
+ if evt.KeyCode() == wx.WXK_RETURN:
+ URL = self.location.GetValue()
+ self.location.Append(URL)
+ self.ie.Navigate2(URL)
+ else:
+ evt.Skip()
+
+ def IgnoreReturn(self, evt):
+ if evt.KeyCode() != wx.WXK_RETURN:
+ evt.Skip()
+
+ def OnOpenButton(self, event):
+ dlg = wx.TextEntryDialog(self, "Open Location",
+ "Enter a full URL or local path",
+ self.current, wx.OK|wx.CANCEL)
+ dlg.CentreOnParent()
+ if dlg.ShowModal() == wx.ID_OK:
+ self.current = dlg.GetValue()
+ self.ie.Navigate2(self.current)
+ dlg.Destroy()
+
+ def OnHomeButton(self, event):
+ self.ie.GoHome()
+
+ def OnPrevPageButton(self, event):
+ self.ie.GoBack()
+
+ def OnNextPageButton(self, event):
+ self.ie.GoForward()
+
+ def OnStopButton(self, evt):
+ self.ie.Stop()
+
+ def OnSearchPageButton(self, evt):
+ self.ie.GoSearch()
+
+ def OnRefreshPageButton(self, evt):
+ self.ie.Refresh2(3)
+
+
+
+ # The following event handlers are called by the web browser COM
+ # control since we passed self to MakeActiveXClass. It will look
+ # here for matching attributes and call them if they exist. See the
+ # module generated by makepy for details of method names, etc.
+ def OnNavigateComplete2(self, pDisp, URL):
+ self.current = URL
+ self.location.SetValue(URL)
+
+ def OnTitleChange(self, text):
+ if self.frame:
+ self.frame.SetTitle(self.titleBase + ' -- ' + text)
+
+ def OnStatusTextChange(self, text):
+ if self.frame:
+ self.frame.SetStatusText(text)
+
+
+#----------------------------------------------------------------------
+
+
+if __name__ == '__main__':
+ class TestFrame(wx.Frame):
+ def __init__(self):
+ wx.Frame.__init__(self, None, -1, "ActiveX test -- Internet Explorer",
+ size=(640, 480))
+ self.CreateStatusBar()
+ self.tp = TestPanel(self, frame=self)
+ self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+ def OnCloseWindow(self, evt):
+ self.tp.Destroy()
+ self.Destroy()
+
+ app = wx.PySimpleApp()
+ frame = TestFrame()
+ frame.Show(True)
+
+ import wx.py
+ shell = wx.py.shell.ShellFrame(frame, size=(640,480),
+ locals=dict(wx=wx, frame=frame, ie=frame.tp.ie))
+ shell.Show()
+ frame.Raise()
+ app.MainLoop()
+
+
+
diff --git a/demo/ActiveX_FlashWindow.py b/demo/ActiveX_FlashWindow.py
new file mode 100644
index 00000000..dfc3b103
--- /dev/null
+++ b/demo/ActiveX_FlashWindow.py
@@ -0,0 +1,105 @@
+import os
+import wx
+
+if wx.Platform == '__WXMSW__':
+ from wx.lib.flashwin import FlashWindow
+
+from Main import opj
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, style=0)
+ self.pdf = None
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ btnSizer = wx.BoxSizer(wx.HORIZONTAL)
+
+ self.flash = FlashWindow(self, style=wx.SUNKEN_BORDER)
+ self.flash.LoadMovie(0, 'file://' + os.path.abspath('data/Asteroid_blaster.swf'))
+
+ sizer.Add(self.flash, proportion=1, flag=wx.EXPAND)
+
+ btn = wx.Button(self, wx.NewId(), "Open Flash File")
+ self.Bind(wx.EVT_BUTTON, self.OnOpenFileButton, btn)
+ btnSizer.Add(btn, proportion=1, flag=wx.EXPAND|wx.ALL, border=5)
+
+ btn = wx.Button(self, wx.NewId(), "Open Flash URL")
+ self.Bind(wx.EVT_BUTTON, self.OnOpenURLButton, btn)
+ btnSizer.Add(btn, proportion=1, flag=wx.EXPAND|wx.ALL, border=5)
+
+ btnSizer.Add((50,-1), proportion=2, flag=wx.EXPAND)
+ sizer.Add(btnSizer, proportion=0, flag=wx.EXPAND)
+
+ self.SetSizer(sizer)
+ self.SetAutoLayout(True)
+
+
+
+ def OnOpenFileButton(self, event):
+ dlg = wx.FileDialog(self, wildcard="*.swf")
+
+ if dlg.ShowModal() == wx.ID_OK:
+ wx.BeginBusyCursor()
+ self.flash.LoadMovie(0, 'file://' + dlg.GetPath())
+ wx.EndBusyCursor()
+
+ dlg.Destroy()
+
+
+ def OnOpenURLButton(self, event):
+ dlg = wx.TextEntryDialog(self, "Enter a URL of a .swf file", "Enter URL")
+
+ if dlg.ShowModal() == wx.ID_OK:
+ wx.BeginBusyCursor()
+ # setting the movie property works too
+ self.flash.movie = dlg.GetValue()
+ wx.EndBusyCursor()
+
+ dlg.Destroy()
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ if wx.Platform == '__WXMSW__':
+ win = TestPanel(nb, log)
+ return win
+ else:
+ from wx.lib.msgpanel import MessagePanel
+ win = MessagePanel(nb, 'This demo only works on Microsoft Windows.',
+ 'Sorry', wx.ICON_WARNING)
+ return win
+
+
+overview = """\
+
+
wx.lib.flashwin.FlashWindow
+
+The wx.lib.pdfwin.FlashWindow class is yet another example of using
+ActiveX controls from wxPython using the new wx.activex module. This
+allows you to use an ActiveX control as if it is a wx.Window, you can
+call its methods, set/get properties, and receive events from the
+ActiveX control in a very intuitive way.
+
+
Using this class is simpler than ActiveXWrapper, doesn't rely on
+the win32all extensions, and is more "wx\'ish", meaning that it uses
+events and etc. as would be expected from any other wx window.
+
+
This demo embeds the Shockwave Flash control, and lets you play a game.
+
+
+"""
+
+#----------------------------------------------------------------------
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
diff --git a/demo/ActiveX_IEHtmlWindow.py b/demo/ActiveX_IEHtmlWindow.py
new file mode 100644
index 00000000..414128e0
--- /dev/null
+++ b/demo/ActiveX_IEHtmlWindow.py
@@ -0,0 +1,240 @@
+# 11/18/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Updated for wx namespace
+#
+
+import wx
+
+if wx.Platform == '__WXMSW__':
+ import wx.lib.iewin as iewin
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log, frame=None):
+ wx.Panel.__init__(
+ self, parent, -1,
+ style=wx.TAB_TRAVERSAL|wx.CLIP_CHILDREN|wx.NO_FULL_REPAINT_ON_RESIZE
+ )
+
+ self.log = log
+ self.current = "http://wxPython.org/"
+ self.frame = frame
+
+ if frame:
+ self.titleBase = frame.GetTitle()
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ btnSizer = wx.BoxSizer(wx.HORIZONTAL)
+
+ self.ie = iewin.IEHtmlWindow(self)
+
+
+ btn = wx.Button(self, -1, "Open", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnOpenButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "Home", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnHomeButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "<--", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnPrevPageButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+ self.Bind(wx.EVT_UPDATE_UI, self.OnCheckCanGoBack, btn)
+
+ btn = wx.Button(self, -1, "-->", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnNextPageButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+ self.Bind(wx.EVT_UPDATE_UI, self.OnCheckCanGoForward, btn)
+
+ btn = wx.Button(self, -1, "Stop", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnStopButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "Search", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnSearchPageButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "Refresh", style=wx.BU_EXACTFIT)
+ self.Bind(wx.EVT_BUTTON, self.OnRefreshPageButton, btn)
+ btnSizer.Add(btn, 0, wx.EXPAND|wx.ALL, 2)
+
+ txt = wx.StaticText(self, -1, "Location:")
+ btnSizer.Add(txt, 0, wx.CENTER|wx.ALL, 2)
+
+ self.location = wx.ComboBox(
+ self, -1, "", style=wx.CB_DROPDOWN|wx.PROCESS_ENTER
+ )
+
+ self.Bind(wx.EVT_COMBOBOX, self.OnLocationSelect, self.location)
+ self.location.Bind(wx.EVT_KEY_UP, self.OnLocationKey)
+ self.location.Bind(wx.EVT_CHAR, self.IgnoreReturn)
+ btnSizer.Add(self.location, 1, wx.EXPAND|wx.ALL, 2)
+
+ sizer.Add(btnSizer, 0, wx.EXPAND)
+ sizer.Add(self.ie, 1, wx.EXPAND)
+
+ self.ie.LoadUrl(self.current)
+ self.location.Append(self.current)
+
+ self.SetSizer(sizer)
+ # Since this is a wx.Window we have to call Layout ourselves
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+
+
+ ## Hook up the event handlers for the IE window. Using
+ ## AddEventSink is how we tell the COM system to look in this
+ ## object for method names matching the COM Event names. They
+ ## are automatically looked for in the ActiveXCtrl class, (so
+ ## deriving a new class from IEHtmlWindow would also have been
+ ## a good appraoch) and now they will be looked for here too.
+ self.ie.AddEventSink(self)
+
+
+
+ def ShutdownDemo(self):
+ # put the frame title back
+ if self.frame:
+ self.frame.SetTitle(self.titleBase)
+
+
+ def OnSize(self, evt):
+ self.Layout()
+
+ def OnLocationSelect(self, evt):
+ url = self.location.GetStringSelection()
+ self.log.write('OnLocationSelect: %s\n' % url)
+ self.ie.Navigate(url)
+
+ def OnLocationKey(self, evt):
+ if evt.GetKeyCode() == wx.WXK_RETURN:
+ URL = self.location.GetValue()
+ self.location.Append(URL)
+ self.ie.Navigate(URL)
+ else:
+ evt.Skip()
+
+
+ def IgnoreReturn(self, evt):
+ if evt.GetKeyCode() != wx.WXK_RETURN:
+ evt.Skip()
+
+ def OnOpenButton(self, event):
+ dlg = wx.TextEntryDialog(self, "Open Location",
+ "Enter a full URL or local path",
+ self.current, wx.OK|wx.CANCEL)
+ dlg.CentreOnParent()
+
+ if dlg.ShowModal() == wx.ID_OK:
+ self.current = dlg.GetValue()
+ self.ie.Navigate(self.current)
+
+ dlg.Destroy()
+
+ def OnHomeButton(self, event):
+ self.ie.GoHome() ## ET Phone Home!
+
+ def OnPrevPageButton(self, event):
+ self.ie.GoBack()
+
+ def OnNextPageButton(self, event):
+ self.ie.GoForward()
+
+ def OnCheckCanGoBack(self, event):
+ event.Enable(self.ie.CanGoBack())
+
+ def OnCheckCanGoForward(self, event):
+ event.Enable(self.ie.CanGoForward())
+
+ def OnStopButton(self, evt):
+ self.ie.Stop()
+
+ def OnSearchPageButton(self, evt):
+ self.ie.GoSearch()
+
+ def OnRefreshPageButton(self, evt):
+ self.ie.Refresh(iewin.REFRESH_COMPLETELY)
+
+
+ # Here are some of the event methods for the IE COM events. See
+ # the MSDN docs for DWebBrowserEvents2 for details on what events
+ # are available, and what the parameters are.
+
+ def BeforeNavigate2(self, this, pDisp, URL, Flags, TargetFrameName,
+ PostData, Headers, Cancel):
+ self.log.write('BeforeNavigate2: %s\n' % URL[0])
+ if URL[0] == 'http://www.microsoft.com/':
+ if wx.MessageBox("Are you sure you want to visit Microsoft?",
+ style=wx.YES_NO|wx.ICON_QUESTION) == wx.NO:
+ # This is how you can cancel loading a page. The
+ # Cancel parameter is defined as an [in,out] type and
+ # so setting the value means it will be returned and
+ # checked in the COM control.
+ Cancel[0] = True
+
+
+ def NewWindow3(self, this, pDisp, Cancel, Flags, urlContext, URL):
+ self.log.write('NewWindow3: %s\n' % URL)
+ Cancel[0] = True # Veto the creation of a new window.
+
+ #def ProgressChange(self, this, progress, progressMax):
+ # self.log.write('ProgressChange: %d of %d\n' % (progress, progressMax))
+
+ def DocumentComplete(self, this, pDisp, URL):
+ self.current = URL[0]
+ self.location.SetValue(self.current)
+
+ def TitleChange(self, this, Text):
+ if self.frame:
+ self.frame.SetTitle(self.titleBase + ' -- ' + Text)
+
+ def StatusTextChange(self, this, Text):
+ if self.frame:
+ self.frame.SetStatusText(Text)
+
+
+
+#----------------------------------------------------------------------
+# for the demo framework...
+
+def runTest(frame, nb, log):
+ if wx.Platform == '__WXMSW__':
+ win = TestPanel(nb, log, frame)
+ return win
+ else:
+ from wx.lib.msgpanel import MessagePanel
+ win = MessagePanel(nb, 'This demo only works on Microsoft Windows.',
+ 'Sorry', wx.ICON_WARNING)
+ return win
+
+
+
+overview = """\
+
+
wx.lib.iewin.IEHtmlWindow
+
+The wx.lib.iewin.IEHtmlWindow class is one example of using ActiveX
+controls from wxPython using the new wx.activex module. This allows
+you to use an ActiveX control as if it is a wx.Window, you can call
+its methods, set/get properties, and receive events from the ActiveX
+control in a very intuitive way.
+
+
+
+The wx.lib.pdfwin.PDFWindow class is another example of using ActiveX
+controls from wxPython using the new wx.activex module. This allows
+you to use an ActiveX control as if it is a wx.Window, you can call
+its methods, set/get properties, and receive events from the ActiveX
+control in a very intuitive way.
+
+
Using this class is simpler than ActiveXWrapper, doesn't rely on
+the win32all extensions, and is more "wx\'ish", meaning that it uses
+events and etc. as would be expected from any other wx window.
+
+
This demo embeds the Adobe Acrobat Reader, and gives you some
+buttons for opening a PDF file, changing pages, etc. that show how to
+call methods on the COM object. If you don't have Acrobat Reader 4.0
+(or greater) installed it won't work.
+
+
+"""
+
+#----------------------------------------------------------------------
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
diff --git a/demo/AdjustChannels.py b/demo/AdjustChannels.py
new file mode 100644
index 00000000..8d0a5bb9
--- /dev/null
+++ b/demo/AdjustChannels.py
@@ -0,0 +1,178 @@
+
+import wx
+
+from Main import opj
+
+#----------------------------------------------------------------------
+
+# AdjustChannels demo. The interesting part is ImageWindow.OnPaint
+
+class TestAdjustChannels(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ topsizer= wx.BoxSizer(wx.HORIZONTAL) # left controls, right image output
+
+ # slider controls controls
+ ctrlsizer= wx.BoxSizer(wx.VERTICAL)
+
+ label= wx.StaticText(self, -1, "Factor red in %")
+ label.SetForegroundColour("RED")
+ ctrlsizer.Add(label, 0, wx.ALL, 5)
+ sliderred= wx.Slider(self, wx.NewId(), 100, 0, 200, size=(150, -1), style = wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_LABELS)
+ sliderred.SetForegroundColour("RED")
+ sliderred.SetTickFreq(50, 5)
+ ctrlsizer.Add(sliderred)
+ ctrlsizer.AddSpacer(15)
+
+ label= wx.StaticText(self, -1, "Factor green in %")
+ label.SetForegroundColour("GREEN")
+ ctrlsizer.Add(label, 0, wx.ALL, 5)
+ slidergreen= wx.Slider(self, wx.NewId(), 100, 0, 200, size=(150, -1), style = wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_LABELS)
+ slidergreen.SetForegroundColour("GREEN")
+ slidergreen.SetTickFreq(50, 5)
+ ctrlsizer.Add(slidergreen)
+ ctrlsizer.AddSpacer(15)
+
+ label= wx.StaticText(self, -1, "Factor blue in %")
+ label.SetForegroundColour("BLUE")
+ ctrlsizer.Add(label, 0, wx.ALL, 5)
+ sliderblue= wx.Slider(self, wx.NewId(), 100, 0, 200, size=(150, -1), style = wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_LABELS)
+ sliderblue.SetForegroundColour("BLUE")
+ sliderblue.SetTickFreq(50, 5)
+ ctrlsizer.Add(sliderblue)
+ ctrlsizer.AddSpacer(20)
+
+ label= wx.StaticText(self, -1, "Factor alpha in %")
+ ctrlsizer.Add(label, 0, wx.ALL, 5)
+ slideralpha= wx.Slider(self, wx.NewId(), 100, 0, 200, size=(150, -1), style = wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_LABELS)
+ slideralpha.SetTickFreq(50, 1)
+ ctrlsizer.Add(slideralpha)
+
+ topsizer.Add(ctrlsizer, 0, wx.ALL, 10)
+
+ # image window
+ self.images= ImageWindow(self)
+ topsizer.Add(self.images, 1, wx.EXPAND)
+
+ self.SetSizer(topsizer)
+ topsizer.Layout()
+
+ # forward the slider change events to the image window
+ sliderred.Bind(wx.EVT_SCROLL, self.images.OnScrollRed)
+ slidergreen.Bind(wx.EVT_SCROLL, self.images.OnScrollGreen)
+ sliderblue.Bind(wx.EVT_SCROLL, self.images.OnScrollBlue)
+ slideralpha.Bind(wx.EVT_SCROLL, self.images.OnScrollAlpha)
+
+
+
+class ImageWindow(wx.Window):
+ def __init__(self, parent):
+ wx.Window.__init__(self, parent)
+ self.image1= wx.Image(opj('bitmaps/image.bmp'), wx.BITMAP_TYPE_BMP)
+ self.image2= wx.Image(opj('bitmaps/toucan.png'), wx.BITMAP_TYPE_PNG)
+
+ # the factors -- 1.0 does not not modify the image
+ self.factorred= 1.0
+ self.factorgreen= 1.0
+ self.factorblue= 1.0
+ self.factoralpha= 1.0
+
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+
+ def OnScrollRed(self, event):
+ # position is a int value -- calculate the factor
+ self.factorred = event.GetPosition() / 100.0
+ self.Refresh()
+
+ def OnScrollGreen(self, event):
+ # position is a int value -- calculate the factor
+ self.factorgreen = event.GetPosition() / 100.0
+ self.Refresh()
+
+ def OnScrollBlue(self, event):
+ # position is a int value -- calculate the factor
+ self.factorblue = event.GetPosition() / 100.0
+ self.Refresh()
+
+ def OnScrollAlpha(self, event):
+ # position is a int value -- calculate the factor
+ self.factoralpha = event.GetPosition() / 100.0
+ self.Refresh()
+
+ def OnPaint(self, event):
+ dc= wx.PaintDC(self)
+ dc= wx.BufferedDC(dc)
+
+ # paint a background to show the alpha manipulation
+ dc.SetBackground(wx.Brush("WHITE"))
+ dc.Clear()
+ dc.SetBrush(wx.Brush("GREY", wx.CROSSDIAG_HATCH))
+ windowsize= self.GetSizeTuple()
+ dc.DrawRectangle(0, 0, windowsize[0], windowsize[1])
+
+ # apply correction to the image channels via wx.Image.AdjustChannels
+ image= self.image1.AdjustChannels(self.factorred, self.factorgreen, self.factorblue, self.factoralpha)
+ bitmap= wx.BitmapFromImage(image)
+ dc.DrawBitmap(bitmap, 10, 10, True)
+
+ image= self.image2.AdjustChannels(self.factorred, self.factorgreen, self.factorblue, self.factoralpha)
+ bitmap= wx.BitmapFromImage(image)
+ dc.DrawBitmap(bitmap, 10, 110, True)
+
+ def OnSize(self, event):
+ self.Refresh()
+
+ def OnEraseBackground(self, event):
+ pass
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestAdjustChannels(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """
+
Adjust Channels
+
+
+The wx.Image member function 'AdjustChannels' is a fast way to manipulate the four
+channels (red, green, blue, alpha) of a wx.Image. It can be used for colour or
+gamma correction of a image. It is also possible to add or enhance the transparency
+of a image via this function (eg. for fade-in/fade-out effects).
+
+
+
+The function expects four float values (one for each channel) and multiplies every
+byte in the channel with the given factor (written in C++). That means a 1.0 will not alter the channel
+and eg. 1.2 will 'enhance' the channel by 20%.
+
+
+
+Examples:
+
+# make a image 10% brighter - first three parameters are the factors for red, green and blue
+image= image.AdjustChannels(1.1, 1.1, 1.1, 1.0)
+
+# add 20% transparency to a image - the last parameter is the factor for the alpha channel
+image= image.AdjustChannels(1.0, 1.0, 1.0, 0.8)
+
+
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/AlphaDrawing.py b/demo/AlphaDrawing.py
new file mode 100644
index 00000000..6fb15a97
--- /dev/null
+++ b/demo/AlphaDrawing.py
@@ -0,0 +1,76 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+ txt = """\
+If this build of wxPython includes the new wx.GCDC class (which
+provides the wx.DC API on top of the new wx.GraphicsContext class)
+then these squares should be transparent.
+"""
+ wx.StaticText(self, -1, txt, (20, 20))
+
+
+ def OnPaint(self, evt):
+ pdc = wx.PaintDC(self)
+ try:
+ dc = wx.GCDC(pdc)
+ except:
+ dc = pdc
+ rect = wx.Rect(0,0, 100, 100)
+ for RGB, pos in [((178, 34, 34), ( 50, 90)),
+ (( 35, 142, 35), (110, 150)),
+ (( 0, 0, 139), (170, 90))
+ ]:
+ r, g, b = RGB
+ penclr = wx.Colour(r, g, b, wx.ALPHA_OPAQUE)
+ brushclr = wx.Colour(r, g, b, 128) # half transparent
+ dc.SetPen(wx.Pen(penclr))
+ dc.SetBrush(wx.Brush(brushclr))
+ rect.SetPosition(pos)
+ dc.DrawRoundedRectangleRect(rect, 8)
+
+ # some additional testing stuff
+ #dc.SetPen(wx.Pen(wx.Colour(0,0,255, 196)))
+ #dc.SetBrush(wx.Brush(wx.Colour(0,0,255, 64)))
+ #dc.DrawCircle(50, 275, 25)
+ #dc.DrawEllipse(100, 275, 75, 50)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
Alpha Drawing
+
+The wx.GCDC class is a class that implemented the wx.DC API using the
+new wx.GraphicsContext class, and so it supports anti-aliased drawing
+using pens and brushes, that can optionally also be drawn using an
+alpha transparency. (On the Mac all the DC classes are using this new
+implementation.) This is accomplished by enabling the wx.Colour class
+to have a fourth component for the alpha value, where 0 is fully
+transparent, and 255 is fully opaque.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/AnalogClock.py b/demo/AnalogClock.py
new file mode 100644
index 00000000..018c4a8f
--- /dev/null
+++ b/demo/AnalogClock.py
@@ -0,0 +1,142 @@
+# AnalogClock demo
+# E. A. Tacao
+# http://j.domaindlx.com/elements28/wxpython/
+# 12 Fev 2006, 22:00 GMT-03:00
+# Distributed under the wxWidgets license.
+
+import wx
+import wx.lib.analogclock as ac
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent)
+
+ # A mostly default clock
+ c1 = ac.AnalogClock(self, size=(200,200))
+
+ if True: # for a simpler test case just set this to False and
+ # only the one clock will be created
+
+ # A plain clock, with square hour and round minute marks, no
+ # shadow, static border
+ c2 = ac.AnalogClock(self, style=wx.STATIC_BORDER,
+ hoursStyle=ac.TICKS_SQUARE,
+ minutesStyle=ac.TICKS_CIRCLE,
+ clockStyle=ac.SHOW_HOURS_TICKS| \
+ ac.SHOW_MINUTES_TICKS|
+ ac.SHOW_HOURS_HAND| \
+ ac.SHOW_MINUTES_HAND| \
+ ac.SHOW_SECONDS_HAND)
+ c2.SetTickSize(12, target=ac.HOUR)
+
+ # No minute tick marks
+ c3 = ac.AnalogClock(self, hoursStyle=ac.TICKS_CIRCLE,
+ clockStyle=ac.SHOW_HOURS_TICKS| \
+ ac.SHOW_HOURS_HAND| \
+ ac.SHOW_MINUTES_HAND| \
+ ac.SHOW_SECONDS_HAND| \
+ ac.SHOW_SHADOWS)
+ c3.SetTickSize(12)
+
+ # A clock with hex numbers no seconds hand and different colours.
+ c4 = ac.AnalogClock(self, hoursStyle=ac.TICKS_HEX,
+ clockStyle=ac.SHOW_HOURS_TICKS| \
+ ac.SHOW_HOURS_HAND| \
+ ac.SHOW_MINUTES_HAND| \
+ ac.SHOW_SHADOWS)
+ colour = wx.Colour(0, 255, 255)
+ c4.SetForegroundColour(colour)
+ colour = wx.Colour(0, 132, 132)
+ c4.SetShadowColour(colour)
+ c4.SetTickFont(wx.Font(10, wx.FONTFAMILY_MODERN, wx.NORMAL, wx.BOLD))
+ c4.SetBackgroundColour(wx.BLACK)
+ c4.SetFaceBorderColour(wx.BLACK)
+ c4.SetFaceFillColour(wx.BLACK)
+
+ # A clock with binary numbers shown only at the quarter tick marks,
+ # no minutes ticks and different colours.
+ c5 = ac.AnalogClock(self, style = wx.RAISED_BORDER,
+ hoursStyle=ac.TICKS_BINARY,
+ clockStyle=ac.SHOW_QUARTERS_TICKS| \
+ ac.SHOW_HOURS_HAND| \
+ ac.SHOW_MINUTES_HAND| \
+ ac.SHOW_SECONDS_HAND| \
+ ac.SHOW_SHADOWS)
+ colour = wx.Colour(0, 128, 0)
+ c5.SetHandFillColour(colour, target=ac.SECOND)
+ c5.SetHandBorderColour(colour, target=ac.SECOND)
+ c5.SetBackgroundColour(colour)
+ colour = wx.Colour(128, 0, 64)
+ c5.SetTickFillColour(colour)
+ c5.SetFaceBorderColour(colour)
+ c5.SetFaceBorderWidth(1)
+ colour = wx.Colour(0, 198, 0)
+ c5.SetFaceFillColour(colour)
+ c5.SetShadowColour(wx.WHITE)
+
+ # A clock with a sunken border, roman numerals shown only at the
+ # quarter tick marks with a roman font, circular minutes ticks,
+ # no seconds hand, no shadows, tick overlapping and different colours.
+ c6 = ac.AnalogClock(self, style = wx.SUNKEN_BORDER,
+ hoursStyle=ac.TICKS_ROMAN,
+ minutesStyle=ac.TICKS_CIRCLE,
+ clockStyle=ac.SHOW_QUARTERS_TICKS| \
+ ac.SHOW_MINUTES_TICKS| \
+ ac.SHOW_HOURS_HAND| \
+ ac.SHOW_MINUTES_HAND| \
+ ac.OVERLAP_TICKS)
+ colour = wx.Colour(128, 0, 0)
+ c6.SetHandFillColour(colour)
+ colour = wx.Colour(179, 0, 89)
+ c6.SetHandBorderColour(colour)
+ c6.SetTickFillColour(colour)
+ c6.SetTickBorderColour(colour)
+ colour = wx.Colour(225, 255, 255)
+ c6.SetFaceBorderColour(colour)
+ c6.SetBackgroundColour(colour)
+ colour = wx.Colour(249, 255, 255)
+ c6.SetFaceFillColour(colour)
+ colour = wx.Colour(255, 213, 213)
+ c6.SetShadowColour(colour)
+ c6.SetTickFont(wx.Font(10, wx.FONTFAMILY_ROMAN, wx.NORMAL, wx.BOLD))
+
+ # layout the clocks in a grid
+ gs = wx.GridSizer(2, 3, 4, 4)
+ gs.Add(c1, 0, wx.EXPAND)
+ gs.Add(c2, 0, wx.EXPAND)
+ gs.Add(c3, 0, wx.EXPAND)
+ gs.Add(c4, 0, wx.EXPAND)
+ gs.Add(c5, 0, wx.EXPAND)
+ gs.Add(c6, 0, wx.EXPAND)
+
+ # put it in another sizer for a border
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(gs, 1, wx.EXPAND|wx.ALL, 10)
+
+ self.SetSizerAndFit(sizer)
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
+
+wx.ArtProvider class can be used to customize the look of wxWindows
+applications. When wxWindows internal classes need to display an icon
+or a bitmap (e.g. in the standard file dialog), it does not use a
+hard-coded resource but asks wx.ArtProvider for it instead. This way
+the users can plug in their own wx.ArtProvider class and easily replace
+standard art with his/her own version. It is easy thing to do: all
+that is needed is to derive a class from wx.ArtProvider, override it's
+CreateBitmap method and register the provider with
+wx.ArtProvider.PushProvider.
+
+
+A combobox that displays a bitmap in front of the list items. It
+currently only allows using bitmaps of one size, and resizes itself so
+that a bitmap can be shown next to the text field.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/BitmapFromBuffer.py b/demo/BitmapFromBuffer.py
new file mode 100644
index 00000000..69f2c066
--- /dev/null
+++ b/demo/BitmapFromBuffer.py
@@ -0,0 +1,148 @@
+
+import wx
+import array
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ self.width, self.height = 120,120
+
+ self.MakeBitmapRGB(self.width, self.height)
+ self.MakeBitmapRGBA(self.width, self.height)
+ self.MakeBitmapRGBpA(self.width, self.height)
+
+ def GetRGB(self, x, y, bpp):
+ # calculate some colour values for this sample based on x,y position
+ r = g = b = 0
+ if y < self.height/3: r = 255
+ if y >= self.height/3 and y <= 2*self.height/3: g = 255
+ if y > 2*self.height/3: b = 255
+
+ if bpp == 4:
+ a = int(x * 255.0 / self.width)
+ return r, g, b, a
+ else:
+ return r, g, b
+
+
+ def MakeBitmapRGB(self, width, height):
+ # Make a bitmap using an array of RGB bytes
+ bpp = 3 # bytes per pixel
+ bytes = array.array('B', [0] * width*height*bpp)
+
+ for y in xrange(height):
+ for x in xrange(width):
+ offset = y*width*bpp + x*bpp
+ r,g,b = self.GetRGB(x, y, bpp)
+ bytes[offset + 0] = r
+ bytes[offset + 1] = g
+ bytes[offset + 2] = b
+
+ self.rgbBmp = wx.BitmapFromBuffer(width, height, bytes)
+
+
+
+ def MakeBitmapRGBA(self, width, height):
+ # Make a bitmap using an array of RGBA bytes
+ bpp = 4 # bytes per pixel
+ bytes = array.array('B', [0] * width*height*bpp)
+
+ for y in xrange(height):
+ for x in xrange(width):
+ offset = y*width*bpp + x*bpp
+ r,g,b,a = self.GetRGB(x, y, bpp)
+ bytes[offset + 0] = r
+ bytes[offset + 1] = g
+ bytes[offset + 2] = b
+ bytes[offset + 3] = a
+
+ self.rgbaBmp = wx.BitmapFromBufferRGBA(width, height, bytes)
+
+
+ def MakeBitmapRGBpA(self, width, height):
+ # Make a bitmap using an array of RGB bytes plus a separate
+ # buffer for the alpha channel
+ bpp = 3 # bytes per pixel
+ bytes = array.array('B', [0] * width*height*bpp)
+
+ for y in xrange(height):
+ for x in xrange(width):
+ offset = y*width*bpp + x*bpp
+ r,g,b = self.GetRGB(x, y, bpp)
+ bytes[offset + 0] = r
+ bytes[offset + 1] = g
+ bytes[offset + 2] = b
+
+ # just use an alpha buffer with a constant alpha value for all
+ # pixels for this example, it could just as easily have
+ # varying alpha values like the other sample.
+ alpha = array.array('B', [128]*width*height)
+ self.rgbaBmp2 = wx.BitmapFromBuffer(width, height, bytes, alpha)
+
+
+ def DrawBitmapAndMessage(self, dc, bmp, msg, x_, y_):
+ x, y = x_, y_
+
+ # draw some text to help show the alpha
+ dc.SetFont(self.GetFont())
+ while y < y_ + self.height + 2*dc.GetCharHeight():
+ dc.DrawText(msg, x,y)
+ y += dc.GetCharHeight() + 5
+
+ # draw the bitmap over the text
+ dc.DrawBitmap(bmp, x+15,y_+15, True)
+
+
+ def OnPaint(self, evt):
+ dc = wx.PaintDC(self)
+ self.DrawBitmapAndMessage(dc, self.rgbBmp, "No alpha channel in this image", 30,35)
+ self.DrawBitmapAndMessage(dc, self.rgbaBmp, "This image has some alpha", 325,35)
+ self.DrawBitmapAndMessage(dc, self.rgbaBmp2,"This one made with RGB+A", 180,220)
+
+
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
BitmapFromBuffer
+
+Two new wx.Bitmap factory functions allow you to create a wx.Bitmap
+directly from a data buffer. The the buffer can be any Python object
+that implements the buffer interface, or is convertable to a buffer,
+such as a string or an array. The new functions are:
+
+
wx.BitmapFromBuffer(width, height, dataBuffer, alphaBuffer=None):
+Creates the bitmap from a buffer of RGB bytes, optionally with a separate
+buffer of alpha bytes.
+
+
wx.BitmapFromBufferRGBA(width, height, dataBuffer): Creates
+the bitmap from a buffer containing RGBA bytes.
+
+
+
+
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Button.py b/demo/Button.py
new file mode 100644
index 00000000..9493ae2d
--- /dev/null
+++ b/demo/Button.py
@@ -0,0 +1,76 @@
+
+import wx
+import images
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1,
+ style=wx.NO_FULL_REPAINT_ON_RESIZE)
+ self.log = log
+
+ b = wx.Button(self, 10, "Default Button", (20, 20))
+ self.Bind(wx.EVT_BUTTON, self.OnClick, b)
+ b.SetDefault()
+ b.SetSize(b.GetBestSize())
+
+ b = wx.Button(self, 20, "HELLO AGAIN!", (20, 80))
+ self.Bind(wx.EVT_BUTTON, self.OnClick, b)
+ b.SetToolTipString("This is a Hello button...")
+
+ b = wx.Button(self, 40, "Flat Button?", (20,160), style=wx.NO_BORDER)
+ b.SetToolTipString("This button has a style flag of wx.NO_BORDER.\n"
+ "On some platforms that will give it a flattened look.")
+ self.Bind(wx.EVT_BUTTON, self.OnClick, b)
+
+ b = wx.Button(self, 50, "wx.Button with icon", (20, 220))
+ b.SetToolTipString("wx.Button can how have an icon on the left, right,\n"
+ "above or below the label.")
+ self.Bind(wx.EVT_BUTTON, self.OnClick, b)
+
+ b.SetBitmap(images.Mondrian.Bitmap,
+ wx.LEFT # Left is the default, the image can be on the other sides too
+ #wx.RIGHT
+ #wx.TOP
+ #wx.BOTTOM
+ )
+ b.SetBitmapMargins((2,2)) # default is 4 but that seems too big to me.
+
+ # Setting the bitmap and margins changes the best size, so
+ # reset the initial size since we're not using a sizer in this
+ # example which would have taken care of this for us.
+ b.SetInitialSize()
+
+ #b = wx.Button(self, 60, "Multi-line\nbutton", (20, 280))
+ #b = wx.Button(self, 70, pos=(160, 280))
+ #b.SetLabel("Another\nmulti-line")
+
+ def OnClick(self, event):
+ self.log.write("Click! (%d)\n" % event.GetId())
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """
+
Button
+
+A button is a control that contains a text string or a bitmap and can be
+placed on nearly any kind of window.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Cairo.py b/demo/Cairo.py
new file mode 100644
index 00000000..b46c6b21
--- /dev/null
+++ b/demo/Cairo.py
@@ -0,0 +1,196 @@
+
+import wx
+import math
+
+try:
+ import wx.lib.wxcairo
+ import cairo
+ haveCairo = True
+except ImportError:
+ haveCairo = False
+
+from Main import opj
+
+#----------------------------------------------------------------------
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+ def OnPaint(self, evt):
+ if self.IsDoubleBuffered():
+ dc = wx.PaintDC(self)
+ else:
+ dc = wx.BufferedPaintDC(self)
+ dc.SetBackground(wx.Brush('white'))
+ dc.Clear()
+
+ self.Render(dc)
+
+
+ def Render(self, dc):
+ # Draw some stuff on the plain dc
+ sz = self.GetSize()
+ dc.SetPen(wx.Pen("navy", 1))
+ x = y = 0
+ while x < sz.width * 2 or y < sz.height * 2:
+ x += 20
+ y += 20
+ dc.DrawLine(x, 0, 0, y)
+
+ # now draw something with cairo
+ ctx = wx.lib.wxcairo.ContextFromDC(dc)
+ ctx.set_line_width(15)
+ ctx.move_to(125, 25)
+ ctx.line_to(225, 225)
+ ctx.rel_line_to(-200, 0)
+ ctx.close_path()
+ ctx.set_source_rgba(0, 0, 0.5, 1)
+ ctx.stroke()
+
+ # and something else...
+ ctx.arc(200, 200, 80, 0, math.pi*2)
+ ctx.set_source_rgba(0, 1, 1, 0.5)
+ ctx.fill_preserve()
+ ctx.set_source_rgb(1, 0.5, 0)
+ ctx.stroke()
+
+ # here's a gradient pattern
+ ptn = cairo.RadialGradient(315, 70, 25,
+ 302, 70, 128)
+ ptn.add_color_stop_rgba(0, 1,1,1,1)
+ ptn.add_color_stop_rgba(1, 0,0,0,1)
+ ctx.set_source(ptn)
+ ctx.arc(328, 96, 75, 0, math.pi*2)
+ ctx.fill()
+
+ # Draw some text
+ face = wx.lib.wxcairo.FontFaceFromFont(
+ wx.FFont(10, wx.SWISS, wx.FONTFLAG_BOLD))
+ ctx.set_font_face(face)
+ ctx.set_font_size(60)
+ ctx.move_to(360, 180)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.show_text("Hello")
+
+ # Text as a path, with fill and stroke
+ ctx.move_to(400, 220)
+ ctx.text_path("World")
+ ctx.set_source_rgb(0.39, 0.07, 0.78)
+ ctx.fill_preserve()
+ ctx.set_source_rgb(0,0,0)
+ ctx.set_line_width(2)
+ ctx.stroke()
+
+ # Show iterating and modifying a (text) path
+ ctx.new_path()
+ ctx.move_to(0, 0)
+ ctx.set_source_rgb(0.3, 0.3, 0.3)
+ ctx.set_font_size(30)
+ text = "This path was warped..."
+ ctx.text_path(text)
+ tw, th = ctx.text_extents(text)[2:4]
+ self.warpPath(ctx, tw, th, 360,300)
+ ctx.fill()
+
+ # Drawing a bitmap. Note that we can easily load a PNG file
+ # into a surface, but I wanted to show how to convert from a
+ # wx.Bitmap here instead. This is how to do it using just cairo:
+ #img = cairo.ImageSurface.create_from_png(opj('bitmaps/toucan.png'))
+
+ # And this is how to convert a wx.Btmap to a cairo image
+ # surface. NOTE: currently on Mac there appears to be a
+ # problem using conversions of some types of images. They
+ # show up totally transparent when used. The conversion itself
+ # appears to be working okay, because converting back to
+ # wx.Bitmap or writing the image surface to a file produces
+ # the expected result. The other platforms are okay.
+ bmp = wx.Bitmap(opj('bitmaps/toucan.png'))
+ #bmp = wx.Bitmap(opj('bitmaps/splash.png'))
+ img = wx.lib.wxcairo.ImageSurfaceFromBitmap(bmp)
+
+ ctx.set_source_surface(img, 70, 230)
+ ctx.paint()
+
+ # this is how to convert an image surface to a wx.Bitmap
+ bmp2 = wx.lib.wxcairo.BitmapFromImageSurface(img)
+ dc.DrawBitmap(bmp2, 280, 300)
+
+
+ def warpPath(self, ctx, tw, th, dx, dy):
+ def f(x, y):
+ xn = x - tw/2
+ yn = y+ xn ** 3 / ((tw/2)**3) * 70
+ return xn+dx, yn+dy
+
+ path = ctx.copy_path()
+ ctx.new_path()
+ for type, points in path:
+ if type == cairo.PATH_MOVE_TO:
+ x, y = f(*points)
+ ctx.move_to(x, y)
+
+ elif type == cairo.PATH_LINE_TO:
+ x, y = f(*points)
+ ctx.line_to(x, y)
+
+ elif type == cairo.PATH_CURVE_TO:
+ x1, y1, x2, y2, x3, y3 = points
+ x1, y1 = f(x1, y1)
+ x2, y2 = f(x2, y2)
+ x3, y3 = f(x3, y3)
+ ctx.curve_to(x1, y1, x2, y2, x3, y3)
+
+ elif type == cairo.PATH_CLOSE_PATH:
+ ctx.close_path()
+
+#----------------------------------------------------------------------
+
+if not haveCairo:
+ from wx.lib.msgpanel import MessagePanel
+ def runTest(frame, nb, log):
+ win = MessagePanel(nb, 'This demo requires the Pycairo package,\n'
+ 'or there is some other unmet dependency.',
+ 'Sorry', wx.ICON_WARNING)
+ return win
+else:
+
+ def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+if haveCairo:
+ extra = "\n
See the docstring in the wx.lib.wxcairo module for details about installing dependencies.'
+
+
+overview = """
+
Cairo Integration
+
+The wx.lib.wxcairo module provides a bit of glue that will allow you to
+use the Pycairo package drawing directly on wx.DC's.
+
+
This sample draws the standard 'snippet' examples that come with
+the Pycairo pacakge, and a few others. The C version of the samples
+can be seen at http://cairographics.org/samples/
+
+
In most snippets you'll see a call to a snippet_normalize()
+function. This is part of the demo and not part of Cairo. It is
+simply scaling the context such that the range of 0.0 to 1.0 is the
+min(width, height) of the window in pixels. In other words, it allows
+the rendering code to use a range or 0.0 to 1.0 and it will always fit
+in the drawing area. (Try resizing the demo and reselecting a snippet
+to see this.)
+
+
+
+A collapsable panel is a container with an embedded button-like
+control which can be used by the user to collapse or expand the pane's
+contents.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ColorPanel.py b/demo/ColorPanel.py
new file mode 100644
index 00000000..29ef92c1
--- /dev/null
+++ b/demo/ColorPanel.py
@@ -0,0 +1,20 @@
+#
+# Note: this module is not a demo per se, but is used by many of
+# the demo modules for various purposes.
+#
+
+import wx
+
+#---------------------------------------------------------------------------
+
+
+class ColoredPanel(wx.Window):
+ def __init__(self, parent, color):
+ wx.Window.__init__(self, parent, -1, style = wx.SIMPLE_BORDER)
+ self.SetBackgroundColour(color)
+ if wx.Platform == '__WXGTK__':
+ self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
+
+
+#---------------------------------------------------------------------------
+
diff --git a/demo/ColourDB.py b/demo/ColourDB.py
new file mode 100644
index 00000000..4cce7599
--- /dev/null
+++ b/demo/ColourDB.py
@@ -0,0 +1,202 @@
+
+import wx
+import wx.lib.colourdb
+
+import images
+
+
+#----------------------------------------------------------------------
+
+class TestWindow(wx.ScrolledWindow):
+ def __init__(self, parent):
+ wx.ScrolledWindow.__init__(self, parent, -1)
+
+ # Populate our color list
+ self.clrList = wx.lib.colourdb.getColourInfoList()
+
+ # Just for style points, we'll use this as a background image.
+ self.bg_bmp = images.GridBG.GetBitmap()
+
+ # This could also be done by getting the window's default font;
+ # either way, we need to have a font loaded for later on.
+ #self.SetBackgroundColour("WHITE")
+ self.font = wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL)
+
+ # Create drawing area and set its font
+ dc = wx.ClientDC(self)
+ dc.SetFont(self.font)
+
+ # Using GetFullTextExtent(), we calculate a basic 'building block'
+ # that will be used to draw a depiction of the color list. We're
+ # using 'Wy' as the model becuase 'W' is a wide character and 'y'
+ # has a descender. This constitutes a 'worst case' scenario, which means
+ # that no matter what we draw later, text-wise, we'll have room for it
+ w,h,d,e = dc.GetFullTextExtent("Wy")
+
+ # Height plus descender
+ self.textHeight = h + d
+
+ # Pad a little bit
+ self.lineHeight = self.textHeight + 5
+
+ # ... and this is the basic width.
+ self.cellWidth = w
+
+ # jmg 11/8/03: why 24?
+ numCells = 24
+
+ # 'prep' our scroll bars.
+ self.SetScrollbars(
+ self.cellWidth, self.lineHeight, numCells, len(self.clrList) + 2
+ )
+
+ # Bind event handlers
+ self.SetBackgroundStyle(wx.BG_STYLE_ERASE)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
+
+
+ # tile the background bitmap loaded in __init__()
+ def TileBackground(self, dc):
+ sz = self.GetClientSize()
+ w = self.bg_bmp.GetWidth()
+ h = self.bg_bmp.GetHeight()
+
+ # adjust for scrolled position
+ spx, spy = self.GetScrollPixelsPerUnit()
+ vsx, vsy = self.GetViewStart()
+ dx, dy = (spx * vsx) % w, (spy * vsy) % h
+
+ x = -dx
+
+ while x < sz.width:
+ y = -dy
+ while y < sz.height:
+ dc.DrawBitmap(self.bg_bmp, x, y)
+ y = y + h
+
+ x = x + w
+
+ # Redraw the background over a 'damaged' area.
+ def OnEraseBackground(self, evt):
+ dc = evt.GetDC()
+
+ if not dc:
+ dc = wx.ClientDC(self)
+ rect = self.GetUpdateRegion().GetBox()
+ dc.SetClippingRect(rect)
+
+ self.TileBackground(dc)
+
+
+ def OnPaint(self, evt):
+ dc = wx.PaintDC(self)
+ self.PrepareDC(dc)
+ self.Draw(dc, self.GetUpdateRegion(), self.GetViewStart())
+
+
+ def Draw(self, dc, rgn=None, vs=None):
+ dc.SetTextForeground("BLACK")
+ dc.SetPen(wx.Pen("BLACK", 1, wx.SOLID))
+ dc.SetFont(self.font)
+ colours = self.clrList
+ numColours = len(colours)
+
+ if rgn:
+ # determine the subset of the color list that has been exposed
+ # and needs drawn. This is based on all the precalculation we
+ # did in __init__()
+ rect = rgn.GetBox()
+ pixStart = vs[1]*self.lineHeight + rect.y
+ pixStop = pixStart + rect.height
+ start = pixStart / self.lineHeight - 1
+ stop = pixStop / self.lineHeight
+ else:
+ start = 0
+ stop = numColours
+
+ for line in range(max(0,start), min(stop,numColours)):
+ clr = colours[line][0]
+ y = (line+1) * self.lineHeight + 2
+
+ dc.DrawText(clr, self.cellWidth, y)
+
+ brush = wx.Brush(clr, wx.SOLID)
+ dc.SetBrush(brush)
+ dc.DrawRectangle(10 * self.cellWidth, y,
+ 6 * self.cellWidth, self.textHeight)
+
+ dc.DrawText(str(tuple(colours[line][1:])),
+ 18 * self.cellWidth, y)
+
+ hexstr = "#%02X%02X%02X" % tuple(colours[line][1:])
+ dc.DrawText(hexstr, 25 * self.cellWidth, y)
+
+
+# On wxGTK there needs to be a panel under wx.ScrolledWindows if they are
+# going to be in a wxNotebook. And, in this demo, we are.
+class TestPanel(wx.Panel):
+ def __init__(self, parent):
+ wx.Panel.__init__(self, parent, -1)
+ self.win = TestWindow(self)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+
+
+ def OnSize(self, evt):
+ self.win.SetSize(evt.GetSize())
+
+
+
+#----------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ # This loads a whole bunch of new color names and values
+ # into TheColourDatabase
+ #
+ # Note 11/24/03 - jg - I moved this into runTest() because
+ # there must be a wx.App existing before this function
+ # can be called - this is a change from 2.4 -> 2.5.
+ wx.lib.colourdb.updateColourDB()
+
+ win = TestPanel(nb)
+
+ return win
+
+#----------------------------------------------------------------------
+
+overview = """
+
+
+ColourDB
+
+
wxWindows maintains a database of standard RGB colours for a predefined
+set of named colours (such as "BLACK'', "LIGHT GREY''). The application
+may add to this set if desired by using Append. There is only one instance
+of this class: TheColourDatabase.
+
+
The colourdb library is a lightweight API that pre-defines
+a multitude of colors for you to use 'out of the box', and this demo serves
+to show you these colors (it also serves as a handy reference).
+
+
A secondary benefit of this demo is the use of the ScrolledWindow class
+and the use of various *DC() classes, including background tiling and the use of
+font data to generate a "building block" type of construct for repetitive use.
+
+
+Important note
+
+
+With implementation of V2.5 and later, it is required to have a wx.App already
+initialized before wx.updateColourDB() can be called.
+Trying to do otherwise will cause an exception to be raised.
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ColourDialog.py b/demo/ColourDialog.py
new file mode 100644
index 00000000..13422421
--- /dev/null
+++ b/demo/ColourDialog.py
@@ -0,0 +1,72 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show a ColourDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ dlg = wx.ColourDialog(self)
+
+ # Ensure the full colour dialog is displayed,
+ # not the abbreviated version.
+ dlg.GetColourData().SetChooseFull(True)
+
+ if dlg.ShowModal() == wx.ID_OK:
+
+ # If the user selected OK, then the dialog's wx.ColourData will
+ # contain valid information. Fetch the data ...
+ data = dlg.GetColourData()
+
+ # ... then do something with it. The actual colour data will be
+ # returned as a three-tuple (r, g, b) in this particular case.
+ self.log.WriteText('You selected: %s\n' % str(data.GetColour().Get()))
+
+ # Once the dialog is destroyed, Mr. wx.ColourData is no longer your
+ # friend. Don't use it again!
+ dlg.Destroy()
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+This class represents the colour chooser dialog.
+
+Use of this dialog is a multi-stage process.
+
+The actual information about how to display the dialog and the colors in the
+dialog's 'registers' are contained in a wx.ColourData instance that is created by
+the dialog at init time. Before displaying the dialog, you may alter these settings
+to suit your needs. In the example, we set the dialog up to show the extended colour
+data selection pane. Otherwise, only the more compact and less extensive colour
+dialog is shown. You may also preset the colour as well as other items.
+
+If the user selects something and selects OK, then the wx.ColourData instance contains
+the colour data that the user selected. Before destroying the dialog, retrieve the data.
+Do not try to retain the wx.ColourData instance. It will probably not be valid
+after the dialog is destroyed.
+
+Along with he wx.ColourDialog documentation, see also the wx.ColourData documentation
+for details.
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ColourSelect.py b/demo/ColourSelect.py
new file mode 100644
index 00000000..d255708d
--- /dev/null
+++ b/demo/ColourSelect.py
@@ -0,0 +1,116 @@
+#----------------------------------------------------------------------------
+# Name: ColourSelect.py
+# Purpose: Colour Selection control display testing on panel for wxPython demo
+#
+# Author: Lorne White (email: lorne.white@telusplanet.net)
+#
+# Version 0.6
+# Date: Nov 14, 2001
+# Licence: wxWindows license
+#
+# Change Log: Add Label parameter to accommodate updated library code
+#
+# Cliff Wells (logiplexsoftware@earthlink.net) 2002/03/11
+# - added code to demonstrate EVT_COLOURSELECT
+# - use sizers
+# - other minor "improvements"
+#----------------------------------------------------------------------------
+#
+
+import wx
+import wx.lib.colourselect as csel
+
+#----------------------------------------------------------------------------
+
+class TestColourSelect(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+ self.SetAutoLayout(True)
+ mainSizer = wx.BoxSizer(wx.VERTICAL)
+ self.SetSizer(mainSizer)
+ t = wx.StaticText(self, -1,
+ "This example uses a colour selection control based on the wxButton\n"
+ "and wxColourDialog Classes. Click Button to get Colour Values")
+ mainSizer.Add(t, 0, wx.ALL, 3)
+
+ b = wx.Button(self, -1, "Show All Colours")
+ self.Bind(wx.EVT_BUTTON, self.OnShowAll, id=b.GetId())
+ mainSizer.Add(b, 0, wx.ALL, 3)
+
+ buttonSizer = wx.FlexGridSizer(cols=2) # sizer to contain all the example buttons
+
+ # show a button with all default values
+ self.colourDefaults = csel.ColourSelect(self, -1)
+
+ self.Bind(csel.EVT_COLOURSELECT, self.OnSelectColour, id=self.colourDefaults.GetId())
+
+ buttonSizer.AddMany([
+ (wx.StaticText(self, -1, "Default Colour/Size"), 0, wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL),
+ (self.colourDefaults, 0, wx.ALL, 3),
+ ])
+
+ # build several examples of buttons with different colours and sizes
+ buttonData = [
+ ("Default Size", (255, 255, 0), wx.DefaultSize, ""),
+ ("Another Size", (255, 0, 255), (60, 20), ""),
+ ("Another Colour", (0, 255, 0), wx.DefaultSize, ""),
+ ("Larger Size", (0, 0, 255), (60, 60), ""),
+ ("With a Label", (127, 0, 255), wx.DefaultSize, "Colour..."),
+ ("Another Colour/Label", (255, 100, 130), (120, -1), "Choose Colour..."),
+ ]
+
+ self.buttonRefs = [] # for saving references to buttons
+
+ # build each button and save a reference to it
+ for name, color, size, label in buttonData:
+ b = csel.ColourSelect(self, -1, label, color, size = size)
+
+ b.Bind(csel.EVT_COLOURSELECT, self.OnSelectColour)
+ self.buttonRefs.append((name, b)) # store reference to button
+
+ buttonSizer.AddMany([
+ (wx.StaticText(self, -1, name), 0, wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL),
+ (b, 0, wx.ALL, 3),
+ ])
+
+ mainSizer.Add(buttonSizer, 0, wx.ALL, 3)
+ self.Layout()
+
+ def OnSelectColour(self, event):
+ self.log.WriteText("Colour selected: %s" % str(event.GetValue()))
+
+ def OnShowAll(self, event):
+ # show the state of each button
+ result = []
+ colour = self.colourDefaults.GetColour() # default control value
+ result.append("Default Colour/Size: " + str(colour))
+
+ for name, button in self.buttonRefs:
+ colour = button.GetColour() # get the colour selection button result
+ result.append(name + ": " + str(colour)) # create string list for easy viewing of results
+
+ out_result = ', '.join(result)
+ self.log.WriteText("Colour Results: " + out_result + "\n")
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestColourSelect(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+
+
+overview = """\
+A coloured button that when clicked allows the user to select a colour from the wxColourDialog.
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ComboBox.py b/demo/ComboBox.py
new file mode 100644
index 00000000..c4d6623c
--- /dev/null
+++ b/demo/ComboBox.py
@@ -0,0 +1,110 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestComboBox(wx.Panel):
+ def OnSetFocus(self, evt):
+ print "OnSetFocus"
+ evt.Skip()
+
+ def OnKillFocus(self, evt):
+ print "OnKillFocus"
+ evt.Skip()
+
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ sampleList = ['zero', 'one', 'two', 'three', 'four', 'five',
+ #'this is a long item that needs a scrollbar...',
+ 'six', 'seven', 'eight']
+
+ wx.StaticText(self, -1, "This example uses the wx.ComboBox control.", (8, 10))
+ wx.StaticText(self, -1, "Select one:", (15, 50), (75, 18))
+
+ # This combobox is created with a preset list of values.
+ cb = wx.ComboBox(self, 500, "default value", (90, 50),
+ (160, -1), sampleList,
+ wx.CB_DROPDOWN
+ #| wx.TE_PROCESS_ENTER
+ #| wx.CB_SORT
+ )
+
+ self.Bind(wx.EVT_COMBOBOX, self.EvtComboBox, cb)
+ self.Bind(wx.EVT_TEXT, self.EvtText, cb)
+ self.Bind(wx.EVT_TEXT_ENTER, self.EvtTextEnter, cb)
+ cb.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus)
+ cb.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
+
+ # Once the combobox is set up, we can append some more data to it.
+ cb.Append("foo", "This is some client data for this item")
+
+ # This combobox is created with no values initially.
+ cb = wx.ComboBox(
+ self, 501, "default value", (90, 80), (160, -1), [], wx.CB_DROPDOWN)
+
+ # Here we dynamically add our values to the second combobox.
+ for item in sampleList:
+ cb.Append(item, item.upper())
+
+ self.Bind(wx.EVT_COMBOBOX, self.EvtComboBox, cb)
+
+ # When the user selects something, we go here.
+ def EvtComboBox(self, evt):
+ cb = evt.GetEventObject()
+ data = cb.GetClientData(evt.GetSelection())
+ self.log.WriteText('EvtComboBox: %s\nClientData: %s\n' % (evt.GetString(), data))
+
+ if evt.GetString() == 'one':
+ self.log.WriteText("You follow directions well!\n\n")
+
+ # Capture events every time a user hits a key in the text entry field.
+ def EvtText(self, evt):
+ self.log.WriteText('EvtText: %s\n' % evt.GetString())
+ evt.Skip()
+
+ # Capture events when the user types something into the control then
+ # hits ENTER.
+ def EvtTextEnter(self, evt):
+ self.log.WriteText('EvtTextEnter: %s' % evt.GetString())
+ evt.Skip()
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestComboBox(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+A ComboBox is like a combination of an edit control and a listbox. It can be
+displayed as static list with editable or read-only text field; or a drop-down
+list with text field; or a drop-down list without a text field.
+
+This example shows both a preset ComboBox and one that is dynamically created
+(that is, it is initially empty but then we 'grow' it out of program-supplied
+data). The former is common for read-only controls.
+
+This example also shows the two form factors for the ComboBox. The first is more
+common, and resembles a Choice control. The latter, although less common, shows
+how all the values in the ComboBox can be visible, yet the functionality is the
+same for both.
+
+Finally, this demo shows how event handling can differ. The first ComboBox is set
+up to handle EVT_TEXT_ENTER events, in which text is typed in and then ENTER is
+hit by the user. This allows the user to enter a line of text which can then be
+processed by the program. EVT_TEXT can also be processed, but in that case the
+event is generated every time that the user hits a key in the ComboBox entry field.
+
+"""
+
+#---------------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ComboCtrl.py b/demo/ComboCtrl.py
new file mode 100644
index 00000000..eb2de5a1
--- /dev/null
+++ b/demo/ComboCtrl.py
@@ -0,0 +1,480 @@
+
+import wx
+import wx.combo
+import os
+
+#----------------------------------------------------------------------
+
+class NullLog:
+ def write(*args):
+ pass
+
+
+# This class is used to provide an interface between a ComboCtrl and a
+# ListCtrl that is used as the popoup for the combo widget. In this
+# case we use multiple inheritance to derive from both wx.ListCtrl and
+# wx.ComboPopup, but it also works well when deriving from just
+# ComboPopup and using a has-a relationship with the popup control,
+# you just need to be sure to return the control itself from the
+# GetControl method.
+
+class ListCtrlComboPopup(wx.ListCtrl, wx.combo.ComboPopup):
+
+ def __init__(self, log=None):
+ if log:
+ self.log = log
+ else:
+ self.log = NullLog()
+
+
+ # Since we are using multiple inheritance, and don't know yet
+ # which window is to be the parent, we'll do 2-phase create of
+ # the ListCtrl instead, and call its Create method later in
+ # our Create method. (See Create below.)
+ self.PostCreate(wx.PreListCtrl())
+
+ # Also init the ComboPopup base class.
+ wx.combo.ComboPopup.__init__(self)
+
+
+ def AddItem(self, txt):
+ self.InsertStringItem(self.GetItemCount(), txt)
+
+ def OnMotion(self, evt):
+ item, flags = self.HitTest(evt.GetPosition())
+ if item >= 0:
+ self.Select(item)
+ self.curitem = item
+
+ def OnLeftDown(self, evt):
+ self.value = self.curitem
+ self.Dismiss()
+
+
+ # The following methods are those that are overridable from the
+ # ComboPopup base class. Most of them are not required, but all
+ # are shown here for demonstration purposes.
+
+
+ # This is called immediately after construction finishes. You can
+ # use self.GetCombo if needed to get to the ComboCtrl instance.
+ def Init(self):
+ self.log.write("ListCtrlComboPopup.Init")
+ self.value = -1
+ self.curitem = -1
+
+
+ # Create the popup child control. Return true for success.
+ def Create(self, parent):
+ self.log.write("ListCtrlComboPopup.Create")
+ wx.ListCtrl.Create(self, parent,
+ style=wx.LC_LIST|wx.LC_SINGLE_SEL|wx.SIMPLE_BORDER)
+ #self.Bind(wx.EVT_MOTION, self.OnMotion)
+ self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
+ return True
+
+
+ # Return the widget that is to be used for the popup
+ def GetControl(self):
+ #self.log.write("ListCtrlComboPopup.GetControl")
+ return self
+
+ # Called just prior to displaying the popup, you can use it to
+ # 'select' the current item.
+ def SetStringValue(self, val):
+ self.log.write("ListCtrlComboPopup.SetStringValue")
+ idx = self.FindItem(-1, val)
+ if idx != wx.NOT_FOUND:
+ self.Select(idx)
+
+ # Return a string representation of the current item.
+ def GetStringValue(self):
+ self.log.write("ListCtrlComboPopup.GetStringValue")
+ if self.value >= 0:
+ return self.GetItemText(self.value)
+ return ""
+
+ # Called immediately after the popup is shown
+ def OnPopup(self):
+ self.log.write("ListCtrlComboPopup.OnPopup")
+ wx.combo.ComboPopup.OnPopup(self)
+
+ # Called when popup is dismissed
+ def OnDismiss(self):
+ self.log.write("ListCtrlComboPopup.OnDismiss")
+ wx.combo.ComboPopup.OnDismiss(self)
+
+ # This is called to custom paint in the combo control itself
+ # (ie. not the popup). Default implementation draws value as
+ # string.
+ def PaintComboControl(self, dc, rect):
+ self.log.write("ListCtrlComboPopup.PaintComboControl")
+ wx.combo.ComboPopup.PaintComboControl(self, dc, rect)
+
+ # Receives key events from the parent ComboCtrl. Events not
+ # handled should be skipped, as usual.
+ def OnComboKeyEvent(self, event):
+ self.log.write("ListCtrlComboPopup.OnComboKeyEvent")
+ wx.combo.ComboPopup.OnComboKeyEvent(self, event)
+
+ # Implement if you need to support special action when user
+ # double-clicks on the parent wxComboCtrl.
+ def OnComboDoubleClick(self):
+ self.log.write("ListCtrlComboPopup.OnComboDoubleClick")
+ wx.combo.ComboPopup.OnComboDoubleClick(self)
+
+ # Return final size of popup. Called on every popup, just prior to OnPopup.
+ # minWidth = preferred minimum width for window
+ # prefHeight = preferred height. Only applies if > 0,
+ # maxHeight = max height for window, as limited by screen size
+ # and should only be rounded down, if necessary.
+ def GetAdjustedSize(self, minWidth, prefHeight, maxHeight):
+ self.log.write("ListCtrlComboPopup.GetAdjustedSize: %d, %d, %d" % (minWidth, prefHeight, maxHeight))
+ return wx.combo.ComboPopup.GetAdjustedSize(self, minWidth, prefHeight, maxHeight)
+
+ # Return true if you want delay the call to Create until the popup
+ # is shown for the first time. It is more efficient, but note that
+ # it is often more convenient to have the control created
+ # immediately.
+ # Default returns false.
+ def LazyCreate(self):
+ self.log.write("ListCtrlComboPopup.LazyCreate")
+ return wx.combo.ComboPopup.LazyCreate(self)
+
+
+
+#----------------------------------------------------------------------
+# This class is a popup containing a TreeCtrl. This time we'll use a
+# has-a style (instead of is-a like above.)
+
+class TreeCtrlComboPopup(wx.combo.ComboPopup):
+
+ # overridden ComboPopup methods
+
+ def Init(self):
+ self.value = None
+ self.curitem = None
+
+
+ def Create(self, parent):
+ self.tree = wx.TreeCtrl(parent, style=wx.TR_HIDE_ROOT
+ |wx.TR_HAS_BUTTONS
+ |wx.TR_SINGLE
+ |wx.TR_LINES_AT_ROOT
+ |wx.SIMPLE_BORDER)
+ self.tree.Bind(wx.EVT_MOTION, self.OnMotion)
+ self.tree.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
+
+
+ def GetControl(self):
+ return self.tree
+
+
+ def GetStringValue(self):
+ if self.value:
+ return self.tree.GetItemText(self.value)
+ return ""
+
+
+ def OnPopup(self):
+ if self.value:
+ self.tree.EnsureVisible(self.value)
+ self.tree.SelectItem(self.value)
+
+
+ def SetStringValue(self, value):
+ # this assumes that item strings are unique...
+ root = self.tree.GetRootItem()
+ if not root:
+ return
+ found = self.FindItem(root, value)
+ if found:
+ self.value = found
+ self.tree.SelectItem(found)
+
+
+ def GetAdjustedSize(self, minWidth, prefHeight, maxHeight):
+ return wx.Size(minWidth, min(200, maxHeight))
+
+
+ # helpers
+
+ def FindItem(self, parentItem, text):
+ item, cookie = self.tree.GetFirstChild(parentItem)
+ while item:
+ if self.tree.GetItemText(item) == text:
+ return item
+ if self.tree.ItemHasChildren(item):
+ item = self.FindItem(item, text)
+ item, cookie = self.tree.GetNextChild(parentItem, cookie)
+ return wx.TreeItemId();
+
+
+ def AddItem(self, value, parent=None):
+ if not parent:
+ root = self.tree.GetRootItem()
+ if not root:
+ root = self.tree.AddRoot("")
+ parent = root
+
+ item = self.tree.AppendItem(parent, value)
+ return item
+
+
+ def OnMotion(self, evt):
+ # have the selection follow the mouse, like in a real combobox
+ item, flags = self.tree.HitTest(evt.GetPosition())
+ if item and flags & wx.TREE_HITTEST_ONITEMLABEL:
+ self.tree.SelectItem(item)
+ self.curitem = item
+ evt.Skip()
+
+
+ def OnLeftDown(self, evt):
+ # do the combobox selection
+ item, flags = self.tree.HitTest(evt.GetPosition())
+ if item and flags & wx.TREE_HITTEST_ONITEMLABEL:
+ self.curitem = item
+ self.value = item
+ self.Dismiss()
+ evt.Skip()
+
+
+#----------------------------------------------------------------------
+# Here we subclass wx.combo.ComboCtrl to do some custom popup animation
+
+CUSTOM_COMBOBOX_ANIMATION_DURATION = 200
+
+class ComboCtrlWithCustomPopupAnim(wx.combo.ComboCtrl):
+ def __init__(self, *args, **kw):
+ wx.combo.ComboCtrl.__init__(self, *args, **kw)
+ self.Bind(wx.EVT_TIMER, self.OnTimer)
+ self.aniTimer = wx.Timer(self)
+
+
+ def AnimateShow(self, rect, flags):
+ self.aniStart = wx.GetLocalTimeMillis()
+ self.aniRect = wx.Rect(*rect)
+ self.aniFlags = flags
+
+ dc = wx.ScreenDC()
+ bmp = wx.EmptyBitmap(rect.width, rect.height)
+ mdc = wx.MemoryDC(bmp)
+ if "wxMac" in wx.PlatformInfo:
+ pass
+ else:
+ mdc.Blit(0, 0, rect.width, rect.height, dc, rect.x, rect.y)
+ del mdc
+ self.aniBackBitmap = bmp
+
+ self.aniTimer.Start(10, wx.TIMER_CONTINUOUS)
+ self.OnTimer(None)
+ return False
+
+
+ def OnTimer(self, evt):
+ stopTimer = False
+ popup = self.GetPopupControl().GetControl()
+ rect = self.aniRect
+ dc = wx.ScreenDC()
+
+ if self.IsPopupWindowState(self.Hidden):
+ stopTimer = True
+ else:
+ pos = wx.GetLocalTimeMillis() - self.aniStart
+ if pos < CUSTOM_COMBOBOX_ANIMATION_DURATION:
+ # Actual animation happens here
+ width = rect.width
+ height = rect.height
+
+ center_x = rect.x + (width/2)
+ center_y = rect.y + (height/2)
+
+ dc.SetPen( wx.BLACK_PEN )
+ dc.SetBrush( wx.TRANSPARENT_BRUSH )
+
+ w = (((pos*256)/CUSTOM_COMBOBOX_ANIMATION_DURATION)*width)/256
+ ratio = float(w) / float(width)
+ h = int(height * ratio)
+
+ dc.DrawBitmap( self.aniBackBitmap, rect.x, rect.y )
+ dc.DrawRectangle( center_x - w/2, center_y - h/2, w, h )
+ else:
+ stopTimer = True
+
+ if stopTimer:
+ dc.DrawBitmap( self.aniBackBitmap, rect.x, rect.y )
+ popup.Move( (0, 0) )
+ self.aniTimer.Stop()
+ self.DoShowPopup( rect, self.aniFlags )
+
+
+#----------------------------------------------------------------------
+# FileSelectorCombo displays a dialog instead of a popup control, it
+# also uses a custom bitmap on the combo button.
+
+class FileSelectorCombo(wx.combo.ComboCtrl):
+ def __init__(self, *args, **kw):
+ wx.combo.ComboCtrl.__init__(self, *args, **kw)
+
+ # make a custom bitmap showing "..."
+ bw, bh = 14, 16
+ bmp = wx.EmptyBitmap(bw,bh)
+ dc = wx.MemoryDC(bmp)
+
+ # clear to a specific background colour
+ bgcolor = wx.Colour(255,254,255)
+ dc.SetBackground(wx.Brush(bgcolor))
+ dc.Clear()
+
+ # draw the label onto the bitmap
+ label = "..."
+ font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
+ font.SetWeight(wx.FONTWEIGHT_BOLD)
+ dc.SetFont(font)
+ tw,th = dc.GetTextExtent(label)
+ dc.DrawText(label, (bw-tw)/2, (bw-tw)/2)
+ del dc
+
+ # now apply a mask using the bgcolor
+ bmp.SetMaskColour(bgcolor)
+
+ # and tell the ComboCtrl to use it
+ self.SetButtonBitmaps(bmp, True)
+
+ self.Bind(wx.EVT_TEXT, self.onText)
+
+ def onText(self, evt):
+ print 'EVT_TEXT:', self.GetValue()
+ evt.Skip()
+
+ # Overridden from ComboCtrl, called when the combo button is clicked
+ def OnButtonClick(self):
+ path = ""
+ name = ""
+ if self.GetValue():
+ path, name = os.path.split(self.GetValue())
+
+ dlg = wx.FileDialog(self, "Choose File", path, name,
+ "All files (*.*)|*.*", wx.FD_OPEN)
+ if dlg.ShowModal() == wx.ID_OK:
+ self.SetValue(dlg.GetPath())
+ dlg.Destroy()
+ self.SetFocus()
+
+ # Overridden from ComboCtrl to avoid assert since there is no ComboPopup
+ def DoSetPopupControl(self, popup):
+ pass
+
+
+#----------------------------------------------------------------------
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ fgs = wx.FlexGridSizer(cols=3, hgap=10, vgap=10)
+
+ cc = self.MakeLCCombo(log=self.log)
+ fgs.Add(cc)
+ fgs.Add((10,10))
+ fgs.Add(wx.StaticText(self, -1, "wx.ComboCtrl with a ListCtrl popup"))
+
+ cc = self.MakeLCCombo(style=wx.CB_READONLY)
+ fgs.Add(cc)
+ fgs.Add((10,10))
+ fgs.Add(wx.StaticText(self, -1, " Read-only"))
+
+ cc = self.MakeLCCombo()
+ cc.SetButtonPosition(side=wx.LEFT)
+ fgs.Add(cc)
+ fgs.Add((10,10))
+ fgs.Add(wx.StaticText(self, -1, " Button on the left"))
+
+ cc = self.MakeLCCombo()
+ cc.SetPopupMaxHeight(250)
+ fgs.Add(cc)
+ fgs.Add((10,10))
+ fgs.Add(wx.StaticText(self, -1, " Max height of popup set"))
+
+ cc = wx.combo.ComboCtrl(self, size=(250,-1))
+ tcp = TreeCtrlComboPopup()
+ cc.SetPopupControl(tcp)
+ fgs.Add(cc)
+ fgs.Add((10,10))
+ fgs.Add(wx.StaticText(self, -1, "TreeCtrl popup"))
+ # add some items to the tree
+ for i in range(5):
+ item = tcp.AddItem('Item %d' % (i+1))
+ for j in range(15):
+ tcp.AddItem('Subitem %d-%d' % (i+1, j+1), parent=item)
+
+ cc = ComboCtrlWithCustomPopupAnim(self, size=(250, -1))
+ popup = ListCtrlComboPopup()
+ cc.SetPopupMaxHeight(150)
+ cc.SetPopupControl(popup)
+ fgs.Add(cc)
+ fgs.Add((10,10))
+ fgs.Add(wx.StaticText(self, -1, "Custom popup animation"))
+ for word in "How cool was that!? Way COOL!".split():
+ popup.AddItem(word)
+ if "wxMac" in wx.PlatformInfo:
+ cc.SetValue("Sorry, animation not working yet on Mac")
+
+
+ cc = FileSelectorCombo(self, size=(250, -1))
+ fgs.Add(cc)
+ fgs.Add((10,10))
+ fgs.Add(wx.StaticText(self, -1, "Custom popup action, and custom button bitmap"))
+
+ box = wx.BoxSizer()
+ box.Add(fgs, 1, wx.EXPAND|wx.ALL, 20)
+ self.SetSizer(box)
+
+
+ def MakeLCCombo(self, log=None, style=0):
+ # Create a ComboCtrl
+ cc = wx.combo.ComboCtrl(self, style=style, size=(250,-1))
+
+ # Create a Popup
+ popup = ListCtrlComboPopup(log)
+
+ # Associate them with each other. This also triggers the
+ # creation of the ListCtrl.
+ cc.SetPopupControl(popup)
+
+ # Add some items to the listctrl.
+ for x in range(75):
+ popup.AddItem("Item-%02d" % x)
+
+ return cc
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.combo.ComboCtrl
+
+A combo control is a generic combobox that allows a totally custom
+popup. In addition it has other customization features. For instance,
+position and size of the dropdown button can be changed.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/ComboTreeBox.py b/demo/ComboTreeBox.py
new file mode 100644
index 00000000..4a4e5b2f
--- /dev/null
+++ b/demo/ComboTreeBox.py
@@ -0,0 +1,69 @@
+import wx
+from wx.lib.combotreebox import ComboTreeBox
+
+
+#---------------------------------------------------------------------------
+
+
+class TestComboTreeBox(wx.Panel):
+ def __init__(self, parent, log):
+ super(TestComboTreeBox, self).__init__(parent)
+ self.log = log
+ panelSizer = wx.FlexGridSizer(cols=2)
+ panelSizer.AddGrowableCol(1)
+ for style, labelText in [(0, 'Default style:'),
+ (wx.CB_READONLY, 'Read-only style:')]:
+ label = wx.StaticText(self, label=labelText)
+ panelSizer.Add(label, flag=wx.ALL|wx.ALIGN_CENTER_VERTICAL,
+ border=5)
+ comboBox = self._createComboTreeBox(style)
+ panelSizer.Add(comboBox, flag=wx.EXPAND|wx.ALL, border=5)
+ self.SetSizerAndFit(panelSizer)
+
+ def _createComboTreeBox(self, style):
+ comboBox = ComboTreeBox(self, style=style)
+ self._bindEventHandlers(comboBox)
+ for i in range(5):
+ child = comboBox.Append('Item %d'%i)
+ for j in range(5):
+ grandChild = comboBox.Append('Item %d.%d'%(i,j), child)
+ for k in range(5):
+ comboBox.Append('Item %d.%d.%d'%(i,j, k), grandChild)
+ return comboBox
+
+ def _bindEventHandlers(self, comboBox):
+ for eventType, handler in [(wx.EVT_COMBOBOX, self.OnItemSelected),
+ (wx.EVT_TEXT, self.OnItemEntered)]:
+ comboBox.Bind(eventType, handler)
+
+ def OnItemSelected(self, event):
+ self.log.WriteText('You selected: %s\n'%event.GetString())
+ event.Skip()
+
+ def OnItemEntered(self, event):
+ self.log.WriteText('You entered: %s\n'%event.GetString())
+ event.Skip()
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestComboTreeBox(nb, log)
+ return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = wx.lib.combotreebox.__doc__
+
+
+#---------------------------------------------------------------------------
+
+
+if __name__ == '__main__':
+ import sys, os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/CommandLinkButton.py b/demo/CommandLinkButton.py
new file mode 100644
index 00000000..5b0e1bf9
--- /dev/null
+++ b/demo/CommandLinkButton.py
@@ -0,0 +1,47 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ cmd = wx.CommandLinkButton(self, -1,
+ "wx.CommandLinkButton",
+ """\
+This type of button includes both a main label and a 'note' that is meant to
+contain a description of what the button does or what it is used for. On
+Windows 7 it is a new native widget type, on the other platforms it is
+implemented generically.""",
+ pos=(25,25))
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.CommandLinkButton
+
+This type of button includes both a main label and a 'note' that is meant to
+contain a description of what the button does or what it is used for. On
+Windows 7 it is a new native widget type, on the other platforms it is
+implemented generically.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ContextHelp.py b/demo/ContextHelp.py
new file mode 100644
index 00000000..0367a5b8
--- /dev/null
+++ b/demo/ContextHelp.py
@@ -0,0 +1,111 @@
+
+import wx
+
+#----------------------------------------------------------------------
+# We first have to set an application-wide help provider. Normally you
+# would do this in your app's OnInit or in other startup code...
+
+provider = wx.SimpleHelpProvider()
+wx.HelpProvider_Set(provider)
+
+# This panel is chock full of controls about which we can demonstrate the
+# help system.
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ # This help text, set for the panel itself, will be used if context
+ # sensitive help cannot be found for any particular control.
+ self.SetHelpText("This is a wx.Panel.")
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+
+ # Init the context help button.
+ # And even include help text about the help button :-)
+ cBtn = wx.ContextHelpButton(self)
+ cBtn.SetHelpText("wx.ContextHelpButton")
+
+ cBtnText = wx.StaticText(self, -1,
+ "This is a wx.ContextHelpButton. Clicking it puts the\n"
+ "app into context sensitive help mode."
+ )
+
+ # Yes, even static text can have help text associated with it :-)
+ cBtnText.SetHelpText("Some helpful text...")
+
+ s = wx.BoxSizer(wx.HORIZONTAL)
+ s.Add(cBtn, 0, wx.ALL, 5)
+ s.Add(cBtnText, 0, wx.ALL, 5)
+ sizer.Add((20,20))
+ sizer.Add(s)
+
+ # A text control with help text.
+ text = wx.TextCtrl(self, -1, "Each sub-window can have its own help message",
+ size=(240, 60), style=wx.TE_MULTILINE)
+ text.SetHelpText("This is my very own help message. This is a really long long long long long long long long long long long long long long long long long long long long message!")
+ sizer.Add((20,20))
+ sizer.Add(text)
+
+ # Same thing, but this time to demonstrate how the help event can be
+ # intercepted.
+ text = wx.TextCtrl(self, -1, "You can also intercept the help event if you like. Watch the log window when you click here...",
+ size=(240, 60), style = wx.TE_MULTILINE)
+ text.SetHelpText("Yet another context help message.")
+ sizer.Add((20,20))
+ sizer.Add(text)
+ text.Bind(wx.EVT_HELP, self.OnCtxHelp, text)
+
+ text = wx.TextCtrl(self, -1, "This one displays the tip itself...",
+ size=(240, 60), style = wx.TE_MULTILINE)
+ sizer.Add((20,20))
+ sizer.Add(text)
+ text.Bind(wx.EVT_HELP, self.OnCtxHelp2, text)
+
+
+ border = wx.BoxSizer(wx.VERTICAL)
+ border.Add(sizer, 0, wx.ALL, 25)
+
+ self.SetAutoLayout(True)
+ self.SetSizer(border)
+ self.Layout()
+
+
+ # On the second text control above, we intercept the help event. This is where
+ # we process it. Anything could happen here. In this case we're just printing
+ # some stuff about it, then passing it on, at which point we see the help tip.
+ def OnCtxHelp(self, evt):
+ self.log.write("OnCtxHelp: %s" % evt)
+ evt.Skip()
+
+ # On the third text control above, we intercept the help event.
+ # Here, we print a note about it, generate our own tip window, and,
+ # unlike last time, we don't pass it on to the underlying provider.
+ def OnCtxHelp2(self, evt):
+ self.log.write("OnCtxHelp2: %s\n" % evt)
+ tip = wx.TipWindow(self, "This is a wx.TipWindow")
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#----------------------------------------------------------------------
+
+
+overview = """
+This demo shows how to incorporate Context Sensitive
+help into your application using the wx.SimpleHelpProvider class.
+
+"""
+
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Cursor.py b/demo/Cursor.py
new file mode 100644
index 00000000..ade91686
--- /dev/null
+++ b/demo/Cursor.py
@@ -0,0 +1,139 @@
+
+import wx
+import images
+
+#----------------------------------------------------------------------
+
+CUSTOMID = 1111
+
+cursors = {
+ "wx.CURSOR_ARROW" : wx.CURSOR_ARROW,
+ "wx.CURSOR_RIGHT_ARROW" : wx.CURSOR_RIGHT_ARROW,
+ "wx.CURSOR_BULLSEYE" : wx.CURSOR_BULLSEYE,
+ "wx.CURSOR_CHAR" : wx.CURSOR_CHAR,
+ "wx.CURSOR_CROSS" : wx.CURSOR_CROSS,
+ "wx.CURSOR_HAND" : wx.CURSOR_HAND,
+ "wx.CURSOR_IBEAM" : wx.CURSOR_IBEAM,
+ "wx.CURSOR_LEFT_BUTTON" : wx.CURSOR_LEFT_BUTTON,
+ "wx.CURSOR_MAGNIFIER" : wx.CURSOR_MAGNIFIER,
+ "wx.CURSOR_MIDDLE_BUTTON" : wx.CURSOR_MIDDLE_BUTTON,
+ "wx.CURSOR_NO_ENTRY" : wx.CURSOR_NO_ENTRY,
+ "wx.CURSOR_PAINT_BRUSH" : wx.CURSOR_PAINT_BRUSH,
+ "wx.CURSOR_PENCIL" : wx.CURSOR_PENCIL,
+ "wx.CURSOR_POINT_LEFT" : wx.CURSOR_POINT_LEFT,
+ "wx.CURSOR_POINT_RIGHT" : wx.CURSOR_POINT_RIGHT,
+ "wx.CURSOR_QUESTION_ARROW" : wx.CURSOR_QUESTION_ARROW,
+ "wx.CURSOR_RIGHT_BUTTON" : wx.CURSOR_RIGHT_BUTTON,
+ "wx.CURSOR_SIZENESW" : wx.CURSOR_SIZENESW,
+ "wx.CURSOR_SIZENS" : wx.CURSOR_SIZENS,
+ "wx.CURSOR_SIZENWSE" : wx.CURSOR_SIZENWSE,
+ "wx.CURSOR_SIZEWE" : wx.CURSOR_SIZEWE,
+ "wx.CURSOR_SIZING" : wx.CURSOR_SIZING,
+ "wx.CURSOR_SPRAYCAN" : wx.CURSOR_SPRAYCAN,
+ "wx.CURSOR_WAIT" : wx.CURSOR_WAIT,
+ "wx.CURSOR_WATCH" : wx.CURSOR_WATCH,
+ "wx.CURSOR_BLANK" : wx.CURSOR_BLANK,
+ "wx.CURSOR_DEFAULT" : wx.CURSOR_DEFAULT,
+ "wx.CURSOR_COPY_ARROW" : wx.CURSOR_COPY_ARROW,
+ "wx.CURSOR_ARROWWAIT" : wx.CURSOR_ARROWWAIT,
+
+ "zz [custom cursor]" : CUSTOMID,
+}
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ # create a list of choices from the dictionary above
+ choices = cursors.keys()
+ choices.sort()
+
+ # create the controls
+ self.cb = wx.ComboBox(self, -1, "wx.CURSOR_DEFAULT", choices=choices,
+ style=wx.CB_READONLY)
+ self.tx = wx.StaticText(self, -1,
+ "This sample allows you to see all the stock cursors \n"
+ "available to wxPython. Simply select a name from the \n"
+ "wx.Choice and then move the mouse into the window \n"
+ "below to see the cursor. NOTE: not all stock cursors \n"
+ "have a specific representaion on all platforms.")
+
+ self.win = wx.Window(self, -1, size=(200,200), style=wx.SIMPLE_BORDER)
+ self.win.SetBackgroundColour("white")
+
+ # bind an event or two
+ self.Bind(wx.EVT_COMBOBOX, self.OnChooseCursor, self.cb)
+ self.win.Bind(wx.EVT_LEFT_DOWN, self.OnDrawDot)
+
+
+ # Setup the layout
+ gbs = wx.GridBagSizer()
+ gbs.Add(self.cb, (2,1))
+ gbs.Add(self.tx, (2,3))
+ gbs.Add(self.win, (5,0), (1, 6), wx.ALIGN_CENTER)
+ self.SetSizer(gbs)
+
+
+ def OnChooseCursor(self, evt):
+ # clear the dots
+ self.win.Refresh()
+
+ choice = self.cb.GetStringSelection()
+ self.log.write("Selecting the %s cursor\n" % choice)
+
+ cnum = cursors[choice]
+
+ if cnum == CUSTOMID:
+ image = images.Pointy.GetImage()
+
+ # since this image didn't come from a .cur file, tell it where the hotspot is
+ image.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_X, 1)
+ image.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_Y, 1)
+
+ # make the image into a cursor
+ cursor = wx.CursorFromImage(image)
+
+ else:
+ # create one of the stock (built-in) cursors
+ cursor = wx.StockCursor(cnum)
+
+ # set the cursor for the window
+ self.win.SetCursor(cursor)
+
+
+ def OnDrawDot(self, evt):
+ # Draw a dot so the user can see where the hotspot is
+ dc = wx.ClientDC(self.win)
+ dc.SetPen(wx.Pen("RED"))
+ dc.SetBrush(wx.Brush("RED"))
+ pos = evt.GetPosition()
+ dc.DrawCircle(pos.x, pos.y, 4)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.Cursor
+
+This demo shows the stock mouse cursors that are available to wxPython.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/CustomDragAndDrop.py b/demo/CustomDragAndDrop.py
new file mode 100644
index 00000000..42fd4006
--- /dev/null
+++ b/demo/CustomDragAndDrop.py
@@ -0,0 +1,347 @@
+
+import cPickle
+import wx
+
+#----------------------------------------------------------------------
+
+
+class DoodlePad(wx.Window):
+ def __init__(self, parent, log):
+ wx.Window.__init__(self, parent, -1, style=wx.SUNKEN_BORDER)
+ self.log = log
+ self.SetBackgroundColour(wx.WHITE)
+ self.lines = []
+ self.x = self.y = 0
+ self.SetMode("Draw")
+
+ self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
+ self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
+ self.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
+ self.Bind(wx.EVT_MOTION, self.OnMotion)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+ def SetMode(self, mode):
+ self.mode = mode
+ if self.mode == "Draw":
+ self.SetCursor(wx.StockCursor(wx.CURSOR_PENCIL))
+ else:
+ self.SetCursor(wx.STANDARD_CURSOR)
+
+
+ def OnPaint(self, event):
+ dc = wx.PaintDC(self)
+ self.DrawSavedLines(dc)
+
+ def DrawSavedLines(self, dc):
+ dc.BeginDrawing()
+ dc.SetPen(wx.Pen(wx.BLUE, 3))
+ for line in self.lines:
+ for coords in line:
+ dc.DrawLine(*coords)
+ dc.EndDrawing()
+
+
+ def OnLeftDown(self, event):
+ if self.mode == "Drag":
+ self.StartDragOpperation()
+ elif self.mode == "Draw":
+ self.curLine = []
+ self.x, self.y = event.GetPositionTuple()
+ self.CaptureMouse()
+ else:
+ wx.Bell()
+ self.log.write("unknown mode!\n")
+
+
+ def OnLeftUp(self, event):
+ if self.HasCapture():
+ self.lines.append(self.curLine)
+ self.curLine = []
+ self.ReleaseMouse()
+
+ def OnRightUp(self, event):
+ self.lines = []
+ self.Refresh()
+
+ def OnMotion(self, event):
+ if self.HasCapture() and event.Dragging() and not self.mode == "Drag":
+ dc = wx.ClientDC(self)
+ dc.BeginDrawing()
+ dc.SetPen(wx.Pen(wx.BLUE, 3))
+ coords = (self.x, self.y) + event.GetPositionTuple()
+ self.curLine.append(coords)
+ dc.DrawLine(*coords)
+ self.x, self.y = event.GetPositionTuple()
+ dc.EndDrawing()
+
+
+ def StartDragOpperation(self):
+ # pickle the lines list
+ linesdata = cPickle.dumps(self.lines, 1)
+
+ # create our own data format and use it in a
+ # custom data object
+ ldata = wx.CustomDataObject("DoodleLines")
+ ldata.SetData(linesdata)
+
+ # Also create a Bitmap version of the drawing
+ size = self.GetSize()
+ bmp = wx.EmptyBitmap(size.width, size.height)
+ dc = wx.MemoryDC()
+ dc.SelectObject(bmp)
+ dc.SetBackground(wx.WHITE_BRUSH)
+ dc.Clear()
+ self.DrawSavedLines(dc)
+ dc.SelectObject(wx.NullBitmap)
+
+ # Now make a data object for the bitmap and also a composite
+ # data object holding both of the others.
+ bdata = wx.BitmapDataObject(bmp)
+ data = wx.DataObjectComposite()
+ data.Add(ldata)
+ data.Add(bdata)
+
+ # And finally, create the drop source and begin the drag
+ # and drop opperation
+ dropSource = wx.DropSource(self)
+ dropSource.SetData(data)
+ self.log.WriteText("Begining DragDrop\n")
+ result = dropSource.DoDragDrop(wx.Drag_AllowMove)
+ self.log.WriteText("DragDrop completed: %d\n" % result)
+
+ if result == wx.DragMove:
+ self.lines = []
+ self.Refresh()
+
+
+#----------------------------------------------------------------------
+
+
+class DoodleDropTarget(wx.DropTarget):
+ def __init__(self, window, log):
+ wx.DropTarget.__init__(self)
+ self.log = log
+ self.dv = window
+
+ # specify the type of data we will accept
+ self.data = wx.CustomDataObject("DoodleLines")
+ self.SetDataObject(self.data)
+
+
+ # some virtual methods that track the progress of the drag
+ def OnEnter(self, x, y, d):
+ self.log.WriteText("OnEnter: %d, %d, %d\n" % (x, y, d))
+ return d
+
+ def OnLeave(self):
+ self.log.WriteText("OnLeave\n")
+
+ def OnDrop(self, x, y):
+ self.log.WriteText("OnDrop: %d %d\n" % (x, y))
+ return True
+
+ def OnDragOver(self, x, y, d):
+ #self.log.WriteText("OnDragOver: %d, %d, %d\n" % (x, y, d))
+
+ # The value returned here tells the source what kind of visual
+ # feedback to give. For example, if wxDragCopy is returned then
+ # only the copy cursor will be shown, even if the source allows
+ # moves. You can use the passed in (x,y) to determine what kind
+ # of feedback to give. In this case we return the suggested value
+ # which is based on whether the Ctrl key is pressed.
+ return d
+
+
+
+ # Called when OnDrop returns True. We need to get the data and
+ # do something with it.
+ def OnData(self, x, y, d):
+ self.log.WriteText("OnData: %d, %d, %d\n" % (x, y, d))
+
+ # copy the data from the drag source to our data object
+ if self.GetData():
+ # convert it back to a list of lines and give it to the viewer
+ linesdata = self.data.GetData()
+ lines = cPickle.loads(linesdata)
+ self.dv.SetLines(lines)
+
+ # what is returned signals the source what to do
+ # with the original data (move, copy, etc.) In this
+ # case we just return the suggested value given to us.
+ return d
+
+
+
+class DoodleViewer(wx.Window):
+ def __init__(self, parent, log):
+ wx.Window.__init__(self, parent, -1, style=wx.SUNKEN_BORDER)
+ self.log = log
+ self.SetBackgroundColour(wx.WHITE)
+ self.lines = []
+ self.x = self.y = 0
+ dt = DoodleDropTarget(self, log)
+ self.SetDropTarget(dt)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+ def SetLines(self, lines):
+ self.lines = lines
+ self.Refresh()
+
+ def OnPaint(self, event):
+ dc = wx.PaintDC(self)
+ self.DrawSavedLines(dc)
+
+ def DrawSavedLines(self, dc):
+ dc.BeginDrawing()
+ dc.SetPen(wx.Pen(wx.RED, 3))
+
+ for line in self.lines:
+ for coords in line:
+ dc.DrawLine(*coords)
+ dc.EndDrawing()
+
+#----------------------------------------------------------------------
+
+class CustomDnDPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+
+ self.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD, False))
+
+ # Make the controls
+ text1 = wx.StaticText(self, -1,
+ "Draw a little picture in this window\n"
+ "then switch the mode below and drag the\n"
+ "picture to the lower window or to another\n"
+ "application that accepts Bitmaps as a\n"
+ "drop target.\n"
+ )
+
+ rb1 = wx.RadioButton(self, -1, "Draw", style=wx.RB_GROUP)
+ rb1.SetValue(True)
+ rb2 = wx.RadioButton(self, -1, "Drag")
+ rb2.SetValue(False)
+
+ text2 = wx.StaticText(self, -1,
+ "The lower window is accepting a\n"
+ "custom data type that is a pickled\n"
+ "Python list of lines data.")
+
+ self.pad = DoodlePad(self, log)
+ view = DoodleViewer(self, log)
+
+ # put them in sizers
+ sizer = wx.BoxSizer(wx.HORIZONTAL)
+ box = wx.BoxSizer(wx.VERTICAL)
+ rbox = wx.BoxSizer(wx.HORIZONTAL)
+
+ rbox.Add(rb1)
+ rbox.Add(rb2)
+ box.Add(text1, 0, wx.ALL, 10)
+ box.Add(rbox, 0, wx.ALIGN_CENTER)
+ box.Add((10,90))
+ box.Add(text2, 0, wx.ALL, 10)
+
+ sizer.Add(box)
+
+ dndsizer = wx.BoxSizer(wx.VERTICAL)
+ dndsizer.Add(self.pad, 1, wx.EXPAND|wx.ALL, 5)
+ dndsizer.Add(view, 1, wx.EXPAND|wx.ALL, 5)
+
+ sizer.Add(dndsizer, 1, wx.EXPAND)
+
+ self.SetAutoLayout(True)
+ self.SetSizer(sizer)
+
+ # Events
+ self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioButton, rb1)
+ self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioButton, rb2)
+
+
+ def OnRadioButton(self, evt):
+ rb = self.FindWindowById(evt.GetId())
+ self.pad.SetMode(rb.GetLabel())
+
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+
+ self.SetAutoLayout(True)
+ sizer = wx.BoxSizer(wx.VERTICAL)
+
+ msg = "Custom Drag-And-Drop"
+ text = wx.StaticText(self, -1, "", style=wx.ALIGN_CENTRE)
+ text.SetFont(wx.Font(24, wx.SWISS, wx.NORMAL, wx.BOLD, False))
+ text.SetLabel(msg)
+ w,h = text.GetTextExtent(msg)
+ text.SetSize(wx.Size(w,h+1))
+ text.SetForegroundColour(wx.BLUE)
+ sizer.Add(text, 0, wx.EXPAND|wx.ALL, 5)
+ sizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND)
+
+ sizer.Add(CustomDnDPanel(self, log), 1, wx.EXPAND)
+
+ self.SetSizer(sizer)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ #win = TestPanel(nb, log)
+ win = CustomDnDPanel(nb, log)
+ return win
+
+
+if __name__ == '__main__':
+ import sys
+
+ class DummyLog:
+ def WriteText(self, text):
+ sys.stdout.write(text)
+
+ class TestApp(wx.App):
+ def OnInit(self):
+ self.MakeFrame()
+ return True
+
+ def MakeFrame(self, event=None):
+ frame = wx.Frame(None, -1, "Custom Drag and Drop", size=(550,400))
+ menu = wx.Menu()
+ item = menu.Append(-1, "Window")
+ mb = wx.MenuBar()
+ mb.Append(menu, "New")
+ frame.SetMenuBar(mb)
+ frame.Bind(wx.EVT_MENU, self.MakeFrame, item)
+ panel = TestPanel(frame, DummyLog())
+ frame.Show(True)
+ self.SetTopWindow(frame)
+
+ #----------------------------------------------------------------------
+
+ app = TestApp(0)
+ app.MainLoop()
+
+#----------------------------------------------------------------------
+
+
+overview = """
+This demo shows Drag and Drop using a custom data type and a custom
+data object. A type called "DoodleLines" is created and a Python
+Pickle of a list is actually transfered in the drag and drop
+opperation.
+
+A second data object is also created containing a bitmap of the image
+and is made available to any drop target that accepts bitmaps, such as
+MS Word.
+
+The two data objects are combined in a wx.DataObjectComposite and the
+rest is handled by the framework.
+
+"""
+
diff --git a/demo/DVC_CustomRenderer.py b/demo/DVC_CustomRenderer.py
new file mode 100644
index 00000000..4a65a2ec
--- /dev/null
+++ b/demo/DVC_CustomRenderer.py
@@ -0,0 +1,180 @@
+
+import wx
+import wx.dataview as dv
+
+#----------------------------------------------------------------------
+
+class MyCustomRenderer(dv.PyDataViewCustomRenderer):
+ def __init__(self, log, *args, **kw):
+ dv.PyDataViewCustomRenderer.__init__(self, *args, **kw)
+ self.log = log
+ self.value = None
+
+
+ def SetValue(self, value):
+ #self.log.write('SetValue: %s' % value)
+ self.value = value
+ return True
+
+ def GetValue(self):
+ #self.log.write('GetValue')
+ return self.value
+
+ def GetSize(self):
+ # Return the size needed to display the value. The renderer
+ # has a helper function we can use for measuring text that is
+ # aware of any custom attributes that may have been set for
+ # this item.
+ return self.GetTextExtent(self.value)
+
+
+ def Render(self, rect, dc, state):
+ if state != 0:
+ self.log.write('Render: %s, %d' % (rect, state))
+
+ if not state & dv.DATAVIEW_CELL_SELECTED:
+ # we'll draw a shaded background to see if the rect correctly
+ # fills the cell
+ dc.SetBrush(wx.Brush('light grey'))
+ dc.SetPen(wx.TRANSPARENT_PEN)
+ rect.Deflate(1, 1)
+ dc.DrawRoundedRectangleRect(rect, 2)
+
+ # And then finish up with this helper function that draws the
+ # text for us, dealing with alignment, font and color
+ # attributes, etc
+ self.RenderText(self.value,
+ 4, # x-offset, to compensate for the rounded rectangles
+ rect,
+ dc,
+ state # wxDataViewCellRenderState flags
+ )
+
+
+ # The HasEditorCtrl, CreateEditorCtrl and GetValueFromEditorCtrl
+ # methods need to be implemented if this renderer is going to
+ # support in-place editing of the cell value, otherwise they can
+ # be omitted.
+
+ def HasEditorCtrl(self):
+ self.log.write('HasEditorCtrl')
+ return True
+
+
+ def CreateEditorCtrl(self, parent, labelRect, value):
+ self.log.write('CreateEditorCtrl: %s' % labelRect)
+ ctrl = wx.TextCtrl(parent,
+ value=value,
+ pos=labelRect.Position,
+ size=labelRect.Size)
+
+ # select the text and put the caret at the end
+ ctrl.SetInsertionPointEnd()
+ ctrl.SelectAll()
+
+ return ctrl
+
+
+ def GetValueFromEditorCtrl(self, editor):
+ self.log.write('GetValueFromEditorCtrl: %s' % editor)
+ value = editor.GetValue()
+ return value
+
+
+ # The LeftClick and Activate methods serve as notifications
+ # letting you know that the user has either clicked or
+ # double-clicked on an item. Implementing them in your renderer
+ # is optional.
+
+ def LeftClick(self, pos, cellRect, model, item, col):
+ self.log.write('LeftClick')
+ return False
+
+
+ def Activate(self, cellRect, model, item, col):
+ self.log.write('Activate')
+ return False
+
+
+#----------------------------------------------------------------------
+
+# To help focus this sammple on the custom renderer, we'll reuse the
+# model class from another sample.
+from DVC_IndexListModel import TestModel
+
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log, model=None, data=None):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ # Create a dataview control
+ self.dvc = dv.DataViewCtrl(self,
+ style=wx.BORDER_THEME
+ | dv.DV_ROW_LINES
+ #| dv.DV_HORIZ_RULES
+ | dv.DV_VERT_RULES
+ | dv.DV_MULTIPLE
+ )
+
+ # Create an instance of the model
+ if model is None:
+ self.model = TestModel(data, log)
+ else:
+ self.model = model
+ self.dvc.AssociateModel(self.model)
+
+ # Now we create some columns.
+ c0 = self.dvc.AppendTextColumn("Id", 0, width=40)
+ c0.Alignment = wx.ALIGN_RIGHT
+ c0.MinWidth = 40
+
+ # We'll use our custom renderer for these columns
+ for title, col, width in [ ('Artist', 1, 170),
+ ('Title', 2, 260),
+ ('Genre', 3, 80)]:
+ renderer = MyCustomRenderer(self.log, mode=dv.DATAVIEW_CELL_EDITABLE)
+ #renderer.SetMode(dv.DATAVIEW_CELL_EDITABLE)
+ column = dv.DataViewColumn(title, renderer, col, width=width)
+ column.Alignment = wx.ALIGN_LEFT
+ self.dvc.AppendColumn(column)
+
+ self.Sizer = wx.BoxSizer(wx.VERTICAL)
+ self.Sizer.Add(self.dvc, 1, wx.EXPAND)
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ # Get the data from the ListCtrl sample to play with, converting it
+ # from a dictionary to a list of lists, including the dictionary key
+ # as the first element of each sublist.
+ import ListCtrl
+ musicdata = ListCtrl.musicdata.items()
+ musicdata.sort()
+ musicdata = [[str(k)] + list(v) for k,v in musicdata]
+
+ win = TestPanel(nb, log, data=musicdata)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
DemoName
+
+Say something nice here
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/DVC_DataViewModel.py b/demo/DVC_DataViewModel.py
new file mode 100644
index 00000000..b832f512
--- /dev/null
+++ b/demo/DVC_DataViewModel.py
@@ -0,0 +1,353 @@
+
+import wx
+import wx.dataview as dv
+import images
+
+import random
+
+#----------------------------------------------------------------------
+
+def makeBlank(self):
+ # Just a little helper function to make an empty image for our
+ # model to use.
+ empty = wx.EmptyBitmap(16,16,32)
+ dc = wx.MemoryDC(empty)
+ dc.SetBackground(wx.Brush((0,0,0,0)))
+ dc.Clear()
+ del dc
+ return empty
+
+#----------------------------------------------------------------------
+# We'll use instaces of these classes to hold our music data. Items in the
+# tree will get associated back to the coresponding Song or Genre object.
+
+class Song(object):
+ def __init__(self, id, artist, title, genre):
+ self.id = id
+ self.artist = artist
+ self.title = title
+ self.genre = genre
+ self.like = False
+ # get a random date value
+ d = random.choice(range(27))+1
+ m = random.choice(range(12))
+ y = random.choice(range(1980, 2005))
+ self.date = wx.DateTimeFromDMY(d,m,y)
+
+ def __repr__(self):
+ return 'Song: %s-%s' % (self.artist, self.title)
+
+
+class Genre(object):
+ def __init__(self, name):
+ self.name = name
+ self.songs = []
+
+ def __repr__(self):
+ return 'Genre: ' + self.name
+
+#----------------------------------------------------------------------
+
+# This model acts as a bridge between the DataViewCtrl and the music data, and
+# organizes it hierarchically as a collection of Genres, each of which is a
+# collection of songs. We derive the class from PyDataViewModel, which knows
+# how to reflect the C++ virtual methods to the Python methods in the derived
+# class.
+
+# This model provides these data columns:
+#
+# 0. Genre: string
+# 1. Artist: string
+# 2. Title: string
+# 3. id: integer
+# 4. Aquired: date
+# 5. Liked: bool
+#
+
+class MyTreeListModel(dv.PyDataViewModel):
+ def __init__(self, data, log):
+ dv.PyDataViewModel.__init__(self)
+ self.data = data
+ self.log = log
+
+ # The objmapper is an instance of DataViewItemObjectMapper and is used
+ # to help associate Python objects with DataViewItem objects. Normally
+ # a dictionary is used so any Python object can be used as data nodes.
+ # If the data nodes are weak-referencable then the objmapper can use a
+ # WeakValueDictionary instead. Each PyDataViewModel automagically has
+ # an instance of DataViewItemObjectMapper preassigned. This
+ # self.objmapper is used by the self.ObjectToItem and
+ # self.ItemToObject methods used below.
+ self.objmapper.UseWeakRefs(True)
+
+
+ # Report how many columns this model provides data for.
+ def GetColumnCount(self):
+ return 6
+
+ # Map the data column numbers to the data type
+ def GetColumnType(self, col):
+ mapper = { 0 : 'string',
+ 1 : 'string',
+ 2 : 'string',
+ 3.: 'string', # the real value is an int, but the renderer should convert it okay
+ 4 : 'datetime',
+ 5 : 'bool',
+ }
+ return mapper[col]
+
+
+ def GetChildren(self, parent, children):
+ # The view calls this method to find the children of any node in the
+ # control. There is an implicit hidden root node, and the top level
+ # item(s) should be reported as children of this node. A List view
+ # simply provides all items as children of this hidden root. A Tree
+ # view adds additional items as children of the other items, as needed,
+ # to provide the tree hierachy.
+ ##self.log.write("GetChildren\n")
+
+ # If the parent item is invalid then it represents the hidden root
+ # item, so we'll use the genre objects as its children and they will
+ # end up being the collection of visible roots in our tree.
+ if not parent:
+ for genre in self.data:
+ children.append(self.ObjectToItem(genre))
+ return len(self.data)
+
+ # Otherwise we'll fetch the python object associated with the parent
+ # item and make DV items for each of it's child objects.
+ node = self.ItemToObject(parent)
+ if isinstance(node, Genre):
+ for song in node.songs:
+ children.append(self.ObjectToItem(song))
+ return len(node.songs)
+ return 0
+
+
+ def IsContainer(self, item):
+ # Return True if the item has children, False otherwise.
+ ##self.log.write("IsContainer\n")
+
+ # The hidden root is a container
+ if not item:
+ return True
+ # and in this model the genre objects are containers
+ node = self.ItemToObject(item)
+ if isinstance(node, Genre):
+ return True
+ # but everything else (the song objects) are not
+ return False
+
+
+ #def HasContainerColumns(self, item):
+ # self.log.write('HasContainerColumns\n')
+ # return True
+
+
+ def GetParent(self, item):
+ # Return the item which is this item's parent.
+ ##self.log.write("GetParent\n")
+
+ if not item:
+ return dv.NullDataViewItem
+
+ node = self.ItemToObject(item)
+ if isinstance(node, Genre):
+ return dv.NullDataViewItem
+ elif isinstance(node, Song):
+ for g in self.data:
+ if g.name == node.genre:
+ return self.ObjectToItem(g)
+
+
+ def GetValue(self, item, col):
+ # Return the value to be displayed for this item and column. For this
+ # example we'll just pull the values from the data objects we
+ # associated with the items in GetChildren.
+
+ # Fetch the data object for this item.
+ node = self.ItemToObject(item)
+
+ if isinstance(node, Genre):
+ # We'll only use the first column for the Genre objects,
+ # for the other columns lets just return empty values
+ mapper = { 0 : node.name,
+ 1 : "",
+ 2 : "",
+ 3 : "",
+ 4 : wx.DateTimeFromTimeT(0), # TODO: There should be some way to indicate a null value...
+ 5 : False,
+ }
+ return mapper[col]
+
+
+ elif isinstance(node, Song):
+ mapper = { 0 : node.genre,
+ 1 : node.artist,
+ 2 : node.title,
+ 3 : node.id,
+ 4 : node.date,
+ 5 : node.like,
+ }
+ return mapper[col]
+
+ else:
+ raise RuntimeError("unknown node type")
+
+
+
+ def GetAttr(self, item, col, attr):
+ ##self.log.write('GetAttr')
+ node = self.ItemToObject(item)
+ if isinstance(node, Genre):
+ attr.SetColour('blue')
+ attr.SetBold(True)
+ return True
+ return False
+
+
+ def SetValue(self, value, item, col):
+ self.log.write("SetValue: %s\n" % value)
+
+ # We're not allowing edits in column zero (see below) so we just need
+ # to deal with Song objects and cols 1 - 5
+
+ node = self.ItemToObject(item)
+ if isinstance(node, Song):
+ if col == 1:
+ node.artist = value
+ elif col == 2:
+ node.title = value
+ elif col == 3:
+ node.id = value
+ elif col == 4:
+ node.date = value
+ elif col == 5:
+ node.like = value
+
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log, data=None, model=None):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ # Create a dataview control
+ self.dvc = dv.DataViewCtrl(self,
+ style=wx.BORDER_THEME
+ | dv.DV_ROW_LINES # nice alternating bg colors
+ #| dv.DV_HORIZ_RULES
+ | dv.DV_VERT_RULES
+ | dv.DV_MULTIPLE
+ )
+
+ # Create an instance of our model...
+ if model is None:
+ self.model = MyTreeListModel(data, log)
+ else:
+ self.model = model
+
+ # Tel the DVC to use the model
+ self.dvc.AssociateModel(self.model)
+
+ # Define the columns that we want in the view. Notice the
+ # parameter which tells the view which col in the data model to pull
+ # values from for each view column.
+ if 1:
+ self.tr = tr = dv.DataViewTextRenderer()
+ c0 = dv.DataViewColumn("Genre", # title
+ tr, # renderer
+ 0, # data model column
+ width=80)
+ self.dvc.AppendColumn(c0)
+ else:
+ self.dvc.AppendTextColumn("Genre", 0, width=80)
+
+ c1 = self.dvc.AppendTextColumn("Artist", 1, width=170, mode=dv.DATAVIEW_CELL_EDITABLE)
+ c2 = self.dvc.AppendTextColumn("Title", 2, width=260, mode=dv.DATAVIEW_CELL_EDITABLE)
+ c3 = self.dvc.AppendDateColumn('Acquired', 4, width=100, mode=dv.DATAVIEW_CELL_ACTIVATABLE)
+ c4 = self.dvc.AppendToggleColumn('Like', 5, width=40, mode=dv.DATAVIEW_CELL_ACTIVATABLE)
+
+ # Notice how we pull the data from col 3, but this is the 6th col
+ # added to the DVC. The order of the view columns is not dependent on
+ # the order of the model columns at all.
+ c5 = self.dvc.AppendTextColumn("id", 3, width=40, mode=dv.DATAVIEW_CELL_EDITABLE)
+ c5.Alignment = wx.ALIGN_RIGHT
+
+ # Set some additional attributes for all the columns
+ for c in self.dvc.Columns:
+ c.Sortable = True
+ c.Reorderable = True
+
+
+ self.Sizer = wx.BoxSizer(wx.VERTICAL)
+ self.Sizer.Add(self.dvc, 1, wx.EXPAND)
+
+ b1 = wx.Button(self, label="New View", name="newView")
+ self.Bind(wx.EVT_BUTTON, self.OnNewView, b1)
+
+ self.Sizer.Add(b1, 0, wx.ALL, 5)
+
+
+ def OnNewView(self, evt):
+ f = wx.Frame(None, title="New view, shared model", size=(600,400))
+ TestPanel(f, self.log, model=self.model)
+ b = f.FindWindowByName("newView")
+ b.Disable()
+ f.Show()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ # Reuse the music data in the ListCtrl sample, and put it in a
+ # hierarchical structure so we can show it as a tree
+ import ListCtrl
+ musicdata = ListCtrl.musicdata.items()
+ musicdata.sort()
+
+ ## For testing Unicode
+ #musicdata = {
+ # 1 : (u'BE \u662f', u'Python \u662f\u6700\u597d\u7684\u7de8\u7a0b\u8a9e\u8a00\uff01', u"Rock \u662f"),
+ #}
+ #musicdata = musicdata.items()
+
+ # our data structure will be a collection of Genres, each of which is a
+ # collection of Songs
+ data = dict()
+ for key, val in musicdata:
+ song = Song(str(key), val[0], val[1], val[2])
+ genre = data.get(song.genre)
+ if genre is None:
+ genre = Genre(song.genre)
+ data[song.genre] = genre
+ genre.songs.append(song)
+ data = data.values()
+
+ # Finally create the test window
+ win = TestPanel(nb, log, data=data)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
DataViewCtrl with custom DataViewModel
+
+This sample shows how to derive a class from PyDataViewModel, implement a set
+of hierarchical data objects and use the DataViewControl to view and
+manipulate them.
+
+
See the comments in the source for lots of details.
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/DVC_IndexListModel.py b/demo/DVC_IndexListModel.py
new file mode 100644
index 00000000..cedc022e
--- /dev/null
+++ b/demo/DVC_IndexListModel.py
@@ -0,0 +1,253 @@
+
+import wx
+import wx.dataview as dv
+
+#----------------------------------------------------------------------
+
+# This model class provides the data to the view when it is asked for.
+# Since it is a list-only model (no hierachical data) then it is able
+# to be referenced by row rather than by item object, so in this way
+# it is easier to comprehend and use than other model types. In this
+# example we also provide a Compare function to assist with sorting of
+# items in our model. Notice that the data items in the data model
+# object don't ever change position due to a sort or column
+# reordering. The view manages all of that and maps view rows and
+# columns to the model's rows and columns as needed.
+#
+# For this example our data is stored in a simple list of lists. In
+# real life you can use whatever you want or need to hold your data.
+
+class TestModel(dv.PyDataViewIndexListModel):
+ def __init__(self, data, log):
+ dv.PyDataViewIndexListModel.__init__(self, len(data))
+ self.data = data
+ self.log = log
+
+ # All of our columns are strings. If the model or the renderers
+ # in the view are other types then that should be reflected here.
+ def GetColumnType(self, col):
+ return "string"
+
+ # This method is called to provide the data object for a
+ # particular row,col
+ def GetValueByRow(self, row, col):
+ return self.data[row][col]
+
+ # This method is called when the user edits a data item in the view.
+ def SetValueByRow(self, value, row, col):
+ self.log.write("SetValue: (%d,%d) %s\n" % (row, col, value))
+ self.data[row][col] = value
+
+ # Report how many columns this model provides data for.
+ def GetColumnCount(self):
+ return len(self.data[0])
+
+ # Report the number of rows in the model
+ def GetCount(self):
+ #self.log.write('GetCount')
+ return len(self.data)
+
+ # Called to check if non-standard attributes should be used in the
+ # cell at (row, col)
+ def GetAttrByRow(self, row, col, attr):
+ ##self.log.write('GetAttrByRow: (%d, %d)' % (row, col))
+ if col == 3:
+ attr.SetColour('blue')
+ attr.SetBold(True)
+ return True
+ return False
+
+
+ # This is called to assist with sorting the data in the view. The
+ # first two args are instances of the DataViewItem class, so we
+ # need to convert them to row numbers with the GetRow method.
+ # Then it's just a matter of fetching the right values from our
+ # data set and comparing them. The return value is -1, 0, or 1,
+ # just like Python's cmp() function.
+ def Compare(self, item1, item2, col, ascending):
+ if not ascending: # swap sort order?
+ item2, item1 = item1, item2
+ row1 = self.GetRow(item1)
+ row2 = self.GetRow(item2)
+ if col == 0:
+ return cmp(int(self.data[row1][col]), int(self.data[row2][col]))
+ else:
+ return cmp(self.data[row1][col], self.data[row2][col])
+
+
+ def DeleteRows(self, rows):
+ # make a copy since we'll be sorting(mutating) the list
+ rows = list(rows)
+ # use reverse order so the indexes don't change as we remove items
+ rows.sort(reverse=True)
+
+ for row in rows:
+ # remove it from our data structure
+ del self.data[row]
+ # notify the view(s) using this model that it has been removed
+ self.RowDeleted(row)
+
+
+ def AddRow(self, value):
+ # update data structure
+ self.data.append(value)
+ # notify views
+ self.RowAppended()
+
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log, model=None, data=None):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ # Create a dataview control
+ self.dvc = dv.DataViewCtrl(self,
+ style=wx.BORDER_THEME
+ | dv.DV_ROW_LINES # nice alternating bg colors
+ #| dv.DV_HORIZ_RULES
+ | dv.DV_VERT_RULES
+ | dv.DV_MULTIPLE
+ )
+
+ # Create an instance of our simple model...
+ if model is None:
+ self.model = TestModel(data, log)
+ else:
+ self.model = model
+
+ # ...and associate it with the dataview control. Models can
+ # be shared between multiple DataViewCtrls, so this does not
+ # assign ownership like many things in wx do. There is some
+ # internal reference counting happening so you don't really
+ # need to hold a reference to it either, but we do for this
+ # example so we can fiddle with the model from the widget
+ # inspector or whatever.
+ self.dvc.AssociateModel(self.model)
+
+ # Now we create some columns. The second parameter is the
+ # column number within the model that the DataViewColumn will
+ # fetch the data from. This means that you can have views
+ # using the same model that show different columns of data, or
+ # that they can be in a different order than in the model.
+ self.dvc.AppendTextColumn("Artist", 1, width=170, mode=dv.DATAVIEW_CELL_EDITABLE)
+ self.dvc.AppendTextColumn("Title", 2, width=260, mode=dv.DATAVIEW_CELL_EDITABLE)
+ self.dvc.AppendTextColumn("Genre", 3, width=80, mode=dv.DATAVIEW_CELL_EDITABLE)
+
+ # There are Prepend methods too, and also convenience methods
+ # for other data types but we are only using strings in this
+ # example. You can also create a DataViewColumn object
+ # yourself and then just use AppendColumn or PrependColumn.
+ c0 = self.dvc.PrependTextColumn("Id", 0, width=40)
+
+ # The DataViewColumn object is returned from the Append and
+ # Prepend methods, and we can modify some of it's properties
+ # like this.
+ c0.Alignment = wx.ALIGN_RIGHT
+ c0.Renderer.Alignment = wx.ALIGN_RIGHT
+ c0.MinWidth = 40
+
+ # Through the magic of Python we can also access the columns
+ # as a list via the Columns property. Here we'll mark them
+ # all as sortable and reorderable.
+ for c in self.dvc.Columns:
+ c.Sortable = True
+ c.Reorderable = True
+
+ # Let's change our minds and not let the first col be moved.
+ c0.Reorderable = False
+
+ # set the Sizer property (same as SetSizer)
+ self.Sizer = wx.BoxSizer(wx.VERTICAL)
+ self.Sizer.Add(self.dvc, 1, wx.EXPAND)
+
+ # Add some buttons to help out with the tests
+ b1 = wx.Button(self, label="New View", name="newView")
+ self.Bind(wx.EVT_BUTTON, self.OnNewView, b1)
+ b2 = wx.Button(self, label="Add Row")
+ self.Bind(wx.EVT_BUTTON, self.OnAddRow, b2)
+ b3 = wx.Button(self, label="Delete Row(s)")
+ self.Bind(wx.EVT_BUTTON, self.OnDeleteRows, b3)
+
+ btnbox = wx.BoxSizer(wx.HORIZONTAL)
+ btnbox.Add(b1, 0, wx.LEFT|wx.RIGHT, 5)
+ btnbox.Add(b2, 0, wx.LEFT|wx.RIGHT, 5)
+ btnbox.Add(b3, 0, wx.LEFT|wx.RIGHT, 5)
+ self.Sizer.Add(btnbox, 0, wx.TOP|wx.BOTTOM, 5)
+
+ # Bind some events so we can see what the DVC sends us
+ self.Bind(dv.EVT_DATAVIEW_ITEM_EDITING_DONE, self.OnEditingDone, self.dvc)
+ self.Bind(dv.EVT_DATAVIEW_ITEM_VALUE_CHANGED, self.OnValueChanged, self.dvc)
+
+
+ def OnNewView(self, evt):
+ f = wx.Frame(None, title="New view, shared model", size=(600,400))
+ TestPanel(f, self.log, self.model)
+ b = f.FindWindowByName("newView")
+ b.Disable()
+ f.Show()
+
+
+ def OnDeleteRows(self, evt):
+ # Remove the selected row(s) from the model. The model will take care
+ # of notifying the view (and any other observers) that the change has
+ # happened.
+ items = self.dvc.GetSelections()
+ rows = [self.model.GetRow(item) for item in items]
+ self.model.DeleteRows(rows)
+
+
+ def OnAddRow(self, evt):
+ # Add some bogus data to a new row in the model's data
+ id = len(self.model.data) + 1
+ value = [str(id),
+ 'new artist %d' % id,
+ 'new title %d' % id,
+ 'genre %d' % id]
+ self.model.AddRow(value)
+
+
+ def OnEditingDone(self, evt):
+ self.log.write("OnEditingDone\n")
+
+ def OnValueChanged(self, evt):
+ self.log.write("OnValueChanged\n")
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ # Get the data from the ListCtrl sample to play with, converting it
+ # from a dictionary to a list of lists, including the dictionary key
+ # as the first element of each sublist.
+ import ListCtrl
+ musicdata = ListCtrl.musicdata.items()
+ musicdata.sort()
+ musicdata = [[str(k)] + list(v) for k,v in musicdata]
+
+ win = TestPanel(nb, log, data=musicdata)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
DataViewCtrl with DataViewIndexListModel
+
+This sample shows how to derive a class from PyDataViewIndexListModel and use
+it to interface with a list of data items. (This model does not have any
+hierarchical relationships in the data.)
+
+
See the comments in the source for lots of details.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/DVC_ListCtrl.py b/demo/DVC_ListCtrl.py
new file mode 100644
index 00000000..626bfbe5
--- /dev/null
+++ b/demo/DVC_ListCtrl.py
@@ -0,0 +1,68 @@
+
+import wx
+import wx.dataview as dv
+
+#----------------------------------------------------------------------
+
+# Reuse the music data in the ListCtrl sample
+import ListCtrl
+musicdata = ListCtrl.musicdata.items()
+musicdata.sort()
+musicdata = [[str(k)] + list(v) for k,v in musicdata]
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ # create the listctrl
+ self.dvlc = dvlc = dv.DataViewListCtrl(self)
+
+ # Give it some columns.
+ # The ID col we'll customize a bit:
+ dvlc.AppendTextColumn('id', width=40)
+ dvlc.AppendTextColumn('artist', width=170)
+ dvlc.AppendTextColumn('title', width=260)
+ dvlc.AppendTextColumn('genre', width=80)
+
+ # Load the data. Each item (row) is added as a sequence of values
+ # whose order matches the columns
+ for itemvalues in musicdata:
+ dvlc.AppendItem(itemvalues)
+
+ # Set the layout so the listctrl fills the panel
+ self.Sizer = wx.BoxSizer()
+ self.Sizer.Add(dvlc, 1, wx.EXPAND)
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
DataViewListCtrl
+
+The DataViewListCtrl class is much like the traditional wx.ListCtrl in report
+mode, in that it stores all items itself and all access to the data is through
+the list ctrl's API. However it is derived from DataViewCtrl and uses a model
+class internally, so it also has many of the benefits of the data view classes
+available as well.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/DVC_TreeCtrl.py b/demo/DVC_TreeCtrl.py
new file mode 100644
index 00000000..aab6c4bc
--- /dev/null
+++ b/demo/DVC_TreeCtrl.py
@@ -0,0 +1,75 @@
+
+import wx
+import wx.dataview as dv
+
+
+#----------------------------------------------------------------------
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent)
+
+ # create the treectrl
+ self.dvtc = dvtc = dv.DataViewTreeCtrl(self)
+
+ isz = (16,16)
+ il = wx.ImageList(*isz)
+ fldridx = il.AddIcon(wx.ArtProvider.GetIcon(wx.ART_FOLDER, wx.ART_OTHER, isz))
+ fldropenidx = il.AddIcon(wx.ArtProvider.GetIcon(wx.ART_FOLDER_OPEN, wx.ART_OTHER, isz))
+ fileidx = il.AddIcon(wx.ArtProvider.GetIcon(wx.ART_NORMAL_FILE, wx.ART_OTHER, isz))
+ dvtc.SetImageList(il)
+
+ self.root = dvtc.AppendContainer(dv.NullDataViewItem,
+ "The Root Item",
+ fldridx, fldropenidx)
+ for x in range(15):
+ child = dvtc.AppendContainer(self.root, "Item %d" % x,
+ fldridx, fldropenidx)
+
+ for y in range(5):
+ last = dvtc.AppendContainer(
+ child, "item %d-%s" % (x, chr(ord("a")+y)),
+ fldridx, fldropenidx)
+
+ for z in range(5):
+ item = dvtc.AppendItem(
+ last, "item %d-%s-%d" % (x, chr(ord("a")+y), z),
+ fileidx)
+
+ # Set the layout so the treectrl fills the panel
+ self.Sizer = wx.BoxSizer()
+ self.Sizer.Add(dvtc, 1, wx.EXPAND)
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
DataViewTreeCtrl
+
+The DataViewTreeCtrl class is much like the traditional wx.TreeCtrl,
+in that it stores all items itself and all access to the data is
+through the tree ctrl's API. However it is derived from DataViewCtrl
+and uses a model class internally, so it also has many of the benefits
+of the data view classes available as well.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/DatePickerCtrl.py b/demo/DatePickerCtrl.py
new file mode 100644
index 00000000..a738af18
--- /dev/null
+++ b/demo/DatePickerCtrl.py
@@ -0,0 +1,64 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ self.SetSizer(sizer)
+
+ dpc = wx.DatePickerCtrl(self, size=(120,-1),
+ style = wx.DP_DROPDOWN
+ | wx.DP_SHOWCENTURY
+ | wx.DP_ALLOWNONE )
+ self.Bind(wx.EVT_DATE_CHANGED, self.OnDateChanged, dpc)
+ sizer.Add(dpc, 0, wx.ALL, 50)
+
+ # In some cases the widget used above will be a native date
+ # picker, so show the generic one too.
+ dpc = wx.GenericDatePickerCtrl(self, size=(120,-1),
+ style = wx.TAB_TRAVERSAL
+ | wx.DP_DROPDOWN
+ | wx.DP_SHOWCENTURY
+ | wx.DP_ALLOWNONE )
+ self.Bind(wx.EVT_DATE_CHANGED, self.OnDateChanged, dpc)
+ sizer.Add(dpc, 0, wx.LEFT, 50)
+
+
+ def OnDateChanged(self, evt):
+ self.log.write("OnDateChanged: %s\n" % evt.GetDate())
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.DatePickerCtrl
+
+This control allows the user to select a date. Unlike
+wx.calendar.CalendarCtrl, which is a relatively big control,
+wx.DatePickerCtrl is implemented as a small window showing the
+currently selected date. The control can be edited using the keyboard,
+and can also display a popup window for more user-friendly date
+selection, depending on the styles used and the platform.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/DelayedResult.py b/demo/DelayedResult.py
new file mode 100644
index 00000000..f5631880
--- /dev/null
+++ b/demo/DelayedResult.py
@@ -0,0 +1,224 @@
+"""
+This demonstrates a simple use of delayedresult: get/compute
+something that takes a long time, without hanging the GUI while this
+is taking place.
+
+The top button runs a small GUI that uses wx.lib.delayedresult.startWorker
+to wrap a long-running function into a separate thread. Just click
+Get, and move the slider, and click Get and Abort a few times, and
+observe that GUI responds. The key functions to look for in the code
+are startWorker() and __handleResult().
+
+The second button runs the same GUI, but without delayedresult. Click
+Get: now the get/compute is taking place in main thread, so the GUI
+does not respond to user actions until worker function returns, it's
+not even possible to Abort.
+"""
+
+import wx
+import wx.lib.delayedresult as delayedresult
+
+
+class FrameSimpleDelayedBase(wx.Frame):
+ def __init__(self, *args, **kwds):
+ wx.Frame.__init__(self, *args, **kwds)
+ pnl = wx.Panel(self)
+ self.checkboxUseDelayed = wx.CheckBox(pnl, -1, "Using delayedresult")
+ self.buttonGet = wx.Button(pnl, -1, "Get")
+ self.buttonAbort = wx.Button(pnl, -1, "Abort")
+ self.slider = wx.Slider(pnl, -1, 0, 0, 10, size=(100,-1),
+ style=wx.SL_HORIZONTAL|wx.SL_AUTOTICKS)
+ self.textCtrlResult = wx.TextCtrl(pnl, -1, "", style=wx.TE_READONLY)
+
+ self.checkboxUseDelayed.SetValue(1)
+ self.checkboxUseDelayed.Enable(False)
+ self.buttonAbort.Enable(False)
+
+ vsizer = wx.BoxSizer(wx.VERTICAL)
+ hsizer = wx.BoxSizer(wx.HORIZONTAL)
+ vsizer.Add(self.checkboxUseDelayed, 0, wx.ALL, 10)
+ hsizer.Add(self.buttonGet, 0, wx.ALL, 5)
+ hsizer.Add(self.buttonAbort, 0, wx.ALL, 5)
+ hsizer.Add(self.slider, 0, wx.ALL, 5)
+ hsizer.Add(self.textCtrlResult, 0, wx.ALL, 5)
+ vsizer.Add(hsizer, 0, wx.ALL, 5)
+ pnl.SetSizer(vsizer)
+ vsizer.SetSizeHints(self)
+
+ self.Bind(wx.EVT_BUTTON, self.handleGet, self.buttonGet)
+ self.Bind(wx.EVT_BUTTON, self.handleAbort, self.buttonAbort)
+
+
+
+
+class FrameSimpleDelayed(FrameSimpleDelayedBase):
+ """This demos simplistic use of delayedresult module."""
+
+ def __init__(self, *args, **kwargs):
+ FrameSimpleDelayedBase.__init__(self, *args, **kwargs)
+ self.jobID = 0
+ self.abortEvent = delayedresult.AbortEvent()
+ self.Bind(wx.EVT_CLOSE, self.handleClose)
+
+ def setLog(self, log):
+ self.log = log
+
+ def handleClose(self, event):
+ """Only needed because in demo, closing the window does not kill the
+ app, so worker thread continues and sends result to dead frame; normally
+ your app would exit so this would not happen."""
+ if self.buttonAbort.IsEnabled():
+ self.log( "Exiting: Aborting job %s" % self.jobID )
+ self.abortEvent.set()
+ self.Destroy()
+
+ def handleGet(self, event):
+ """Compute result in separate thread, doesn't affect GUI response."""
+ self.buttonGet.Enable(False)
+ self.buttonAbort.Enable(True)
+ self.abortEvent.clear()
+ self.jobID += 1
+
+ self.log( "Starting job %s in producer thread: GUI remains responsive"
+ % self.jobID )
+ delayedresult.startWorker(self._resultConsumer, self._resultProducer,
+ wargs=(self.jobID,self.abortEvent), jobID=self.jobID)
+
+
+ def _resultProducer(self, jobID, abortEvent):
+ """Pretend to be a complex worker function or something that takes
+ long time to run due to network access etc. GUI will freeze if this
+ method is not called in separate thread."""
+ import time
+ count = 0
+ while not abortEvent() and count < 50:
+ time.sleep(0.1)
+ count += 1
+ return jobID
+
+
+ def handleAbort(self, event):
+ """Abort the result computation."""
+ self.log( "Aborting result for job %s" % self.jobID )
+ self.buttonGet.Enable(True)
+ self.buttonAbort.Enable(False)
+ self.abortEvent.set()
+
+
+ def _resultConsumer(self, delayedResult):
+ jobID = delayedResult.getJobID()
+ assert jobID == self.jobID
+ try:
+ result = delayedResult.get()
+ except Exception, exc:
+ self.log( "Result for job %s raised exception: %s" % (jobID, exc) )
+ return
+
+ # output result
+ self.log( "Got result for job %s: %s" % (jobID, result) )
+ self.textCtrlResult.SetValue(str(result))
+
+ # get ready for next job:
+ self.buttonGet.Enable(True)
+ self.buttonAbort.Enable(False)
+
+
+class FrameSimpleDirect(FrameSimpleDelayedBase):
+ """This does not use delayedresult so the GUI will freeze while
+ the GET is taking place."""
+
+ def __init__(self, *args, **kwargs):
+ self.jobID = 1
+ FrameSimpleDelayedBase.__init__(self, *args, **kwargs)
+ self.checkboxUseDelayed.SetValue(False)
+
+ def setLog(self, log):
+ self.log = log
+
+ def handleGet(self, event):
+ """Use delayedresult, this will compute result in separate
+ thread, and will affect GUI response because a thread is not
+ used."""
+ self.buttonGet.Enable(False)
+ self.buttonAbort.Enable(True)
+
+ self.log( "Doing job %s without delayedresult (same as GUI thread): GUI hangs (for a while)" % self.jobID )
+ result = self._resultProducer(self.jobID)
+ self._resultConsumer( result )
+
+ def _resultProducer(self, jobID):
+ """Pretend to be a complex worker function or something that takes
+ long time to run due to network access etc. GUI will freeze if this
+ method is not called in separate thread."""
+ import time
+ time.sleep(5)
+ return jobID
+
+ def handleAbort(self, event):
+ """can never be called"""
+ pass
+
+ def _resultConsumer(self, result):
+ # output result
+ self.log( "Got result for job %s: %s" % (self.jobID, result) )
+ self.textCtrlResult.SetValue(str(result))
+
+ # get ready for next job:
+ self.buttonGet.Enable(True)
+ self.buttonAbort.Enable(False)
+ self.jobID += 1
+
+
+#---------------------------------------------------------------------------
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ vsizer = wx.BoxSizer(wx.VERTICAL)
+ b = wx.Button(self, -1, "Long-running function in separate thread")
+ vsizer.Add(b, 0, wx.ALL, 5)
+ self.Bind(wx.EVT_BUTTON, self.OnButton1, b)
+
+ b = wx.Button(self, -1, "Long-running function in GUI thread")
+ vsizer.Add(b, 0, wx.ALL, 5)
+ self.Bind(wx.EVT_BUTTON, self.OnButton2, b)
+
+ bdr = wx.BoxSizer()
+ bdr.Add(vsizer, 0, wx.ALL, 50)
+ self.SetSizer(bdr)
+ self.Layout()
+
+ def OnButton1(self, evt):
+ frame = FrameSimpleDelayed(self, title="Long-running function in separate thread")
+ frame.setLog(self.log.WriteText)
+ frame.Show()
+
+ def OnButton2(self, evt):
+ frame = FrameSimpleDirect(self, title="Long-running function in GUI thread")
+ frame.setLog(self.log.WriteText)
+ frame.Show()
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = __doc__
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
diff --git a/demo/Dialog.py b/demo/Dialog.py
new file mode 100644
index 00000000..611eea54
--- /dev/null
+++ b/demo/Dialog.py
@@ -0,0 +1,173 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+# Create and set a help provider. Normally you would do this in
+# the app's OnInit as it must be done before any SetHelpText calls.
+provider = wx.SimpleHelpProvider()
+wx.HelpProvider.Set(provider)
+
+#---------------------------------------------------------------------------
+
+class TestDialog(wx.Dialog):
+ def __init__(
+ self, parent, ID, title, size=wx.DefaultSize, pos=wx.DefaultPosition,
+ style=wx.DEFAULT_DIALOG_STYLE,
+ ):
+
+ # Instead of calling wx.Dialog.__init__ we precreate the dialog
+ # so we can set an extra style that must be set before
+ # creation, and then we create the GUI object using the Create
+ # method.
+ pre = wx.PreDialog()
+ pre.SetExtraStyle(wx.DIALOG_EX_CONTEXTHELP)
+ pre.Create(parent, ID, title, pos, size, style)
+
+ # This next step is the most important, it turns this Python
+ # object into the real wrapper of the dialog (instead of pre)
+ # as far as the wxPython extension is concerned.
+ self.PostCreate(pre)
+
+ # Now continue with the normal construction of the dialog
+ # contents
+ sizer = wx.BoxSizer(wx.VERTICAL)
+
+ label = wx.StaticText(self, -1, "This is a wx.Dialog")
+ label.SetHelpText("This is the help text for the label")
+ sizer.Add(label, 0, wx.ALIGN_CENTRE|wx.ALL, 5)
+
+ box = wx.BoxSizer(wx.HORIZONTAL)
+
+ label = wx.StaticText(self, -1, "Field #1:")
+ label.SetHelpText("This is the help text for the label")
+ box.Add(label, 0, wx.ALIGN_CENTRE|wx.ALL, 5)
+
+ text = wx.TextCtrl(self, -1, "", size=(80,-1))
+ text.SetHelpText("Here's some help text for field #1")
+ box.Add(text, 1, wx.ALIGN_CENTRE|wx.ALL, 5)
+
+ sizer.Add(box, 0, wx.GROW|wx.ALIGN_CENTER_VERTICAL|wx.ALL, 5)
+
+ box = wx.BoxSizer(wx.HORIZONTAL)
+
+ label = wx.StaticText(self, -1, "Field #2:")
+ label.SetHelpText("This is the help text for the label")
+ box.Add(label, 0, wx.ALIGN_CENTRE|wx.ALL, 5)
+
+ text = wx.TextCtrl(self, -1, "", size=(80,-1))
+ text.SetHelpText("Here's some help text for field #2")
+ box.Add(text, 1, wx.ALIGN_CENTRE|wx.ALL, 5)
+
+ sizer.Add(box, 0, wx.GROW|wx.ALIGN_CENTER_VERTICAL|wx.ALL, 5)
+
+ line = wx.StaticLine(self, -1, size=(20,-1), style=wx.LI_HORIZONTAL)
+ sizer.Add(line, 0, wx.GROW|wx.ALIGN_CENTER_VERTICAL|wx.RIGHT|wx.TOP, 5)
+
+ btnsizer = wx.StdDialogButtonSizer()
+
+ if wx.Platform != "__WXMSW__":
+ btn = wx.ContextHelpButton(self)
+ btnsizer.AddButton(btn)
+
+ btn = wx.Button(self, wx.ID_OK)
+ btn.SetHelpText("The OK button completes the dialog")
+ btn.SetDefault()
+ btnsizer.AddButton(btn)
+
+ btn = wx.Button(self, wx.ID_CANCEL)
+ btn.SetHelpText("The Cancel button cancels the dialog. (Cool, huh?)")
+ btnsizer.AddButton(btn)
+ btnsizer.Realize()
+
+ sizer.Add(btnsizer, 0, wx.ALIGN_CENTER_VERTICAL|wx.ALL, 5)
+
+ self.SetSizer(sizer)
+ sizer.Fit(self)
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show a custom Dialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+ b = wx.Button(self, -1, "Show dialog with ShowWindowModal", (50, 140))
+ self.Bind(wx.EVT_BUTTON, self.OnShowWindowModal, b)
+ self.Bind(wx.EVT_WINDOW_MODAL_DIALOG_CLOSED, self.OnWindowModalDialogClosed)
+
+
+ def OnButton(self, evt):
+ dlg = TestDialog(self, -1, "Sample Dialog", size=(350, 200),
+ style=wx.DEFAULT_DIALOG_STYLE,
+ )
+ dlg.CenterOnScreen()
+
+ # this does not return until the dialog is closed.
+ val = dlg.ShowModal()
+
+ if val == wx.ID_OK:
+ self.log.WriteText("You pressed OK\n")
+ else:
+ self.log.WriteText("You pressed Cancel\n")
+
+ dlg.Destroy()
+
+
+ def OnShowWindowModal(self, evt):
+ dlg = TestDialog(self, -1, "Sample Dialog", size=(350, 200),
+ style=wx.DEFAULT_DIALOG_STYLE)
+ dlg.ShowWindowModal()
+
+
+ def OnWindowModalDialogClosed(self, evt):
+ dialog = evt.GetDialog()
+ val = evt.GetReturnCode()
+ try:
+ btnTxt = { wx.ID_OK : "OK",
+ wx.ID_CANCEL: "Cancel" }[val]
+ except KeyError:
+ btnTxt = ''
+
+ wx.MessageBox("You closed the window-modal dialog with the %s button" % btnTxt)
+
+ dialog.Destroy()
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+wxPython offers quite a few general purpose dialogs for useful data input from
+the user; they are all based on the wx.Dialog class, which you can also subclass
+to create custom dialogs to suit your needs.
+
+The Dialog class, in addition to dialog-like behaviors, also supports the full
+wxWindows layout featureset, which means that you can incorporate sizers or
+layout constraints as needed to achieve the look and feel desired. It even supports
+context-sensitive help, which is illustrated in this example.
+
+The example is very simple; in real world situations, a dialog that had input
+fields such as this would no doubt be required to deliver those values back to
+the calling function. The Dialog class supports data retrieval in this manner.
+However, the data must be retrieved prior to the dialog being destroyed.
+The example shown here is modal; non-modal dialogs are possible as well.
+
+See the documentation for the Dialog class for more details.
+
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/DialogUnits.py b/demo/DialogUnits.py
new file mode 100644
index 00000000..975eb175
--- /dev/null
+++ b/demo/DialogUnits.py
@@ -0,0 +1,127 @@
+#!/usr/bin/env python
+#----------------------------------------------------------------------------
+# Name: DialogUnits.py
+# Purpose: A minimal wxPython program that is a bit smarter than test1.
+#
+# Author: Robin Dunn
+#
+# Created: A long time ago, in a galaxy far, far away...
+# RCS-ID: $Id$
+# Copyright: (c) 1998 by Total Control Software
+# Licence: wxWindows license
+#----------------------------------------------------------------------------
+#
+
+import wx
+
+#---------------------------------------------------------------------------
+
+# Create a new frame class, derived from the wxPython Frame.
+class MyFrame(wx.Frame):
+
+ def __init__(self, parent, id, title):
+ # First, call the base class' __init__ method to create the frame
+ wx.Frame.__init__(self, parent, id, title, (100, 100), (160, 100))
+
+ # Associate some events with methods of this class
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ self.Bind(wx.EVT_MOVE, self.OnMove)
+ self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+ # Add a panel and some controls to display the size and position
+ panel = wx.Panel(self, -1)
+
+ wx.StaticText(panel, -1, "Size:",
+ wx.DLG_PNT(panel, (4, 4)), wx.DefaultSize
+ )
+
+ wx.StaticText(panel, -1, "Pos:",
+ wx.DLG_PNT(panel, (4, 16)), wx.DefaultSize
+ )
+
+ self.sizeCtrl = wx.TextCtrl(panel, -1, "",
+ wx.DLG_PNT(panel, (24, 4)),
+ wx.DLG_SZE(panel, (36, -1)),
+ wx.TE_READONLY)
+
+ self.posCtrl = wx.TextCtrl(panel, -1, "",
+ wx.DLG_PNT(panel, (24, 16)),
+ wx.DLG_SZE(panel, (36, -1)),
+ wx.TE_READONLY)
+
+ #print wx.DLG_PNT(panel, (24, 4)), wx.DLG_SZE(panel, (36, -1))
+ #print wx.DLG_PNT(panel, (24, 16)),wx.DLG_SZE(panel, (36, -1))
+
+ # This method is called automatically when the CLOSE event is
+ # sent to this window
+ def OnCloseWindow(self, event):
+ # tell the window to kill itself
+ self.Destroy()
+
+ # This method is called by the System when the window is resized,
+ # because of the association above.
+ def OnSize(self, event):
+ size = event.GetSize()
+ self.sizeCtrl.SetValue("%s, %s" % (size.width, size.height))
+
+ # tell the event system to continue looking for an event handler,
+ # so the default handler will get called.
+ event.Skip()
+
+ # This method is called by the System when the window is moved,
+ # because of the association above.
+ def OnMove(self, event):
+ pos = event.GetPosition()
+ self.posCtrl.SetValue("%s, %s" % (pos.x, pos.y))
+
+
+
+#---------------------------------------------------------------------------
+# if running standalone
+
+if __name__ == "__main__":
+ # Every wxWindows application must have a class derived from wxApp
+ class MyApp(wx.App):
+
+ # wxWindows calls this method to initialize the application
+ def OnInit(self):
+
+ # Create an instance of our customized Frame class
+ frame = MyFrame(None, -1, "This is a test")
+ frame.Show(True)
+
+ # Tell wxWindows that this is our main window
+ self.SetTopWindow(frame)
+
+ # Return a success flag
+ return True
+
+
+ app = MyApp(0) # Create an instance of the application class
+ app.MainLoop() # Tell it to start processing events
+
+
+#---------------------------------------------------------------------------
+# if running as part of the Demo Framework...
+
+def runTest(frame, nb, log):
+ win = MyFrame(frame, -1, "This is a test")
+ frame.otherWin = win
+ win.Show(True)
+
+
+overview = """\
+A simple example that shows how to use Dialog Units.
+"""
+
+#----------------------------------------------------------------------------
+#
+
+
+
+
+
+
+
+
+
diff --git a/demo/DirDialog.py b/demo/DirDialog.py
new file mode 100644
index 00000000..eed1be3b
--- /dev/null
+++ b/demo/DirDialog.py
@@ -0,0 +1,57 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show a DirDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ # In this case we include a "New directory" button.
+ dlg = wx.DirDialog(self, "Choose a directory:",
+ style=wx.DD_DEFAULT_STYLE
+ #| wx.DD_DIR_MUST_EXIST
+ #| wx.DD_CHANGE_DIR
+ )
+
+ # If the user selects OK, then we process the dialog's data.
+ # This is done by getting the path data from the dialog - BEFORE
+ # we destroy it.
+ if dlg.ShowModal() == wx.ID_OK:
+ self.log.WriteText('You selected: %s\n' % dlg.GetPath())
+
+ # Only destroy a dialog after you're done with it.
+ dlg.Destroy()
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#---------------------------------------------------------------------------
+
+
+
+
+overview = """\
+This class represents the directory chooser dialog. It is used when all you
+need from the user is the name of a directory. Data is retrieved via utility
+methods; see the DirDialog documentation for specifics.
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/DragAndDrop.py b/demo/DragAndDrop.py
new file mode 100644
index 00000000..95b192db
--- /dev/null
+++ b/demo/DragAndDrop.py
@@ -0,0 +1,273 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+ID_CopyBtn = wx.NewId()
+ID_PasteBtn = wx.NewId()
+ID_BitmapBtn = wx.NewId()
+
+#----------------------------------------------------------------------
+
+class ClipTextPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ #self.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD, False))
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(
+ wx.StaticText(
+ self, -1, "Copy/Paste text to/from\n"
+ "this window and other apps"
+ ),
+ 0, wx.EXPAND|wx.ALL, 2
+ )
+
+ self.text = wx.TextCtrl(self, -1, "", style=wx.TE_MULTILINE|wx.HSCROLL)
+ sizer.Add(self.text, 1, wx.EXPAND)
+
+ hsz = wx.BoxSizer(wx.HORIZONTAL)
+ hsz.Add(wx.Button(self, ID_CopyBtn, " Copy "), 1, wx.EXPAND|wx.ALL, 2)
+ hsz.Add(wx.Button(self, ID_PasteBtn, " Paste "), 1, wx.EXPAND|wx.ALL, 2)
+ sizer.Add(hsz, 0, wx.EXPAND)
+ sizer.Add(
+ wx.Button(self, ID_BitmapBtn, " Copy Bitmap "),
+ 0, wx.EXPAND|wx.ALL, 2
+ )
+
+ self.Bind(wx.EVT_BUTTON, self.OnCopy, id=ID_CopyBtn)
+ self.Bind(wx.EVT_BUTTON, self.OnPaste, id=ID_PasteBtn)
+ self.Bind(wx.EVT_BUTTON, self.OnCopyBitmap, id=ID_BitmapBtn)
+
+ self.SetAutoLayout(True)
+ self.SetSizer(sizer)
+
+
+ def OnCopy(self, evt):
+ self.do = wx.TextDataObject()
+ self.do.SetText(self.text.GetValue())
+ if wx.TheClipboard.Open():
+ wx.TheClipboard.SetData(self.do)
+ wx.TheClipboard.Close()
+ else:
+ wx.MessageBox("Unable to open the clipboard", "Error")
+
+
+ def OnPaste(self, evt):
+ success = False
+ do = wx.TextDataObject()
+ if wx.TheClipboard.Open():
+ success = wx.TheClipboard.GetData(do)
+ wx.TheClipboard.Close()
+
+ if success:
+ self.text.SetValue(do.GetText())
+ else:
+ wx.MessageBox(
+ "There is no data in the clipboard in the required format",
+ "Error"
+ )
+
+ def OnCopyBitmap(self, evt):
+ dlg = wx.FileDialog(self, "Choose a bitmap to copy", wildcard="*.bmp")
+
+ if dlg.ShowModal() == wx.ID_OK:
+ bmp = wx.Bitmap(dlg.GetPath(), wx.BITMAP_TYPE_BMP)
+ bmpdo = wx.BitmapDataObject(bmp)
+ if wx.TheClipboard.Open():
+ wx.TheClipboard.SetData(bmpdo)
+ wx.TheClipboard.Close()
+
+ wx.MessageBox(
+ "The bitmap is now in the Clipboard. Switch to a graphics\n"
+ "editor and try pasting it in..."
+ )
+ else:
+ wx.MessageBox(
+ "There is no data in the clipboard in the required format",
+ "Error"
+ )
+
+ dlg.Destroy()
+
+#----------------------------------------------------------------------
+
+class OtherDropTarget(wx.PyDropTarget):
+ def __init__(self, window, log):
+ wx.PyDropTarget.__init__(self)
+ self.log = log
+ self.do = wx.FileDataObject()
+ self.SetDataObject(self.do)
+
+ def OnEnter(self, x, y, d):
+ self.log.WriteText("OnEnter: %d, %d, %d\n" % (x, y, d))
+ return wx.DragCopy
+
+ #def OnDragOver(self, x, y, d):
+ # self.log.WriteText("OnDragOver: %d, %d, %d\n" % (x, y, d))
+ # return wx.DragCopy
+
+ def OnLeave(self):
+ self.log.WriteText("OnLeave\n")
+
+ def OnDrop(self, x, y):
+ self.log.WriteText("OnDrop: %d %d\n" % (x, y))
+ return True
+
+ def OnData(self, x, y, d):
+ self.log.WriteText("OnData: %d, %d, %d\n" % (x, y, d))
+ self.GetData()
+ self.log.WriteText("%s\n" % self.do.GetFilenames())
+ return d
+
+
+class MyFileDropTarget(wx.FileDropTarget):
+ def __init__(self, window, log):
+ wx.FileDropTarget.__init__(self)
+ self.window = window
+ self.log = log
+
+ def OnDropFiles(self, x, y, filenames):
+ self.window.SetInsertionPointEnd()
+ self.window.WriteText("\n%d file(s) dropped at %d,%d:\n" %
+ (len(filenames), x, y))
+
+ for file in filenames:
+ self.window.WriteText(file + '\n')
+
+
+class MyTextDropTarget(wx.TextDropTarget):
+ def __init__(self, window, log):
+ wx.TextDropTarget.__init__(self)
+ self.window = window
+ self.log = log
+
+ def OnDropText(self, x, y, text):
+ self.window.WriteText("(%d, %d)\n%s\n" % (x, y, text))
+
+ def OnDragOver(self, x, y, d):
+ return wx.DragCopy
+
+
+class FileDropPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+
+ #self.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD, False))
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(
+ wx.StaticText(self, -1, " \nDrag some files here:"),
+ 0, wx.EXPAND|wx.ALL, 2
+ )
+
+ self.text = wx.TextCtrl(
+ self, -1, "",
+ style = wx.TE_MULTILINE|wx.HSCROLL|wx.TE_READONLY
+ )
+
+ dt = MyFileDropTarget(self, log)
+ self.text.SetDropTarget(dt)
+ sizer.Add(self.text, 1, wx.EXPAND)
+
+ sizer.Add(
+ wx.StaticText(self, -1, " \nDrag some text here:"),
+ 0, wx.EXPAND|wx.ALL, 2
+ )
+
+ self.text2 = wx.TextCtrl(
+ self, -1, "",
+ style = wx.TE_MULTILINE|wx.HSCROLL|wx.TE_READONLY
+ )
+
+ dt = MyTextDropTarget(self.text2, log)
+ self.text2.SetDropTarget(dt)
+ sizer.Add(self.text2, 1, wx.EXPAND)
+
+ self.SetAutoLayout(True)
+ self.SetSizer(sizer)
+
+
+ def WriteText(self, text):
+ self.text.WriteText(text)
+
+ def SetInsertionPointEnd(self):
+ self.text.SetInsertionPointEnd()
+
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+
+ self.SetAutoLayout(True)
+ outsideSizer = wx.BoxSizer(wx.VERTICAL)
+
+ msg = "Clipboard / Drag-And-Drop"
+ text = wx.StaticText(self, -1, "", style=wx.ALIGN_CENTRE)
+ text.SetFont(wx.Font(24, wx.SWISS, wx.NORMAL, wx.BOLD, False))
+ text.SetLabel(msg)
+
+ w,h = text.GetTextExtent(msg)
+ text.SetSize(wx.Size(w,h+1))
+ text.SetForegroundColour(wx.BLUE)
+ outsideSizer.Add(text, 0, wx.EXPAND|wx.ALL, 5)
+ outsideSizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND)
+
+ inSizer = wx.BoxSizer(wx.HORIZONTAL)
+ inSizer.Add(ClipTextPanel(self, log), 1, wx.EXPAND)
+ inSizer.Add(FileDropPanel(self, log), 1, wx.EXPAND)
+
+ outsideSizer.Add(inSizer, 1, wx.EXPAND)
+ self.SetSizer(outsideSizer)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+
+
+This demo shows some examples of data transfer through clipboard or
+drag and drop. In wxWindows, these two ways to transfer data (either
+between different applications or inside one and the same) are very
+similar which allows to implement both of them using almost the same
+code - or, in other words, if you implement drag and drop support for
+your application, you get clipboard support for free and vice versa.
+
+At the heart of both clipboard and drag and drop operations lies the
+wxDataObject class. The objects of this class (or, to be precise,
+classes derived from it) represent the data which is being carried by
+the mouse during drag and drop operation or copied to or pasted from
+the clipboard. wxDataObject is a "smart" piece of data because it
+knows which formats it supports (see GetFormatCount and GetAllFormats)
+and knows how to render itself in any of them (see GetDataHere). It
+can also receive its value from the outside in a format it supports if
+it implements the SetData method. Please see the documentation of this
+class for more details.
+
+Both clipboard and drag and drop operations have two sides: the source
+and target, the data provider and the data receiver. These which may
+be in the same application and even the same window when, for example,
+you drag some text from one position to another in a word
+processor. Let us describe what each of them should do.
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/DragImage.py b/demo/DragImage.py
new file mode 100644
index 00000000..6b065d9b
--- /dev/null
+++ b/demo/DragImage.py
@@ -0,0 +1,327 @@
+
+import wx
+import images
+
+#----------------------------------------------------------------------
+
+class DragShape:
+ def __init__(self, bmp):
+ self.bmp = bmp
+ self.pos = (0,0)
+ self.shown = True
+ self.text = None
+ self.fullscreen = False
+
+ def HitTest(self, pt):
+ rect = self.GetRect()
+ return rect.InsideXY(pt.x, pt.y)
+
+ def GetRect(self):
+ return wx.Rect(self.pos[0], self.pos[1],
+ self.bmp.GetWidth(), self.bmp.GetHeight())
+
+ def Draw(self, dc, op = wx.COPY):
+ if self.bmp.Ok():
+ memDC = wx.MemoryDC()
+ memDC.SelectObject(self.bmp)
+
+ dc.Blit(self.pos[0], self.pos[1],
+ self.bmp.GetWidth(), self.bmp.GetHeight(),
+ memDC, 0, 0, op, True)
+
+ return True
+ else:
+ return False
+
+
+
+#----------------------------------------------------------------------
+
+class DragCanvas(wx.ScrolledWindow):
+ def __init__(self, parent, ID):
+ wx.ScrolledWindow.__init__(self, parent, ID)
+ self.shapes = []
+ self.dragImage = None
+ self.dragShape = None
+ self.hiliteShape = None
+
+ self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
+ self.bg_bmp = images.Background.GetBitmap()
+ self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
+
+ # Make a shape from an image and mask. This one will demo
+ # dragging outside the window
+ bmp = images.TestStar.GetBitmap()
+ #bmp = wx.Bitmap('bitmaps/toucan.png')
+ shape = DragShape(bmp)
+ shape.pos = (5, 5)
+ shape.fullscreen = True
+ self.shapes.append(shape)
+
+ bmp = images.TheKid.GetBitmap()
+ shape = DragShape(bmp)
+ shape.pos = (200, 5)
+ self.shapes.append(shape)
+
+ # Make a shape from some text
+ text = "Some Text"
+ bg_colour = wx.Colour(57, 115, 57) # matches the bg image
+ font = wx.Font(15, wx.ROMAN, wx.NORMAL, wx.BOLD)
+ textExtent = self.GetFullTextExtent(text, font)
+
+ # create a bitmap the same size as our text
+ bmp = wx.EmptyBitmap(textExtent[0], textExtent[1])
+
+ # 'draw' the text onto the bitmap
+ dc = wx.MemoryDC()
+ dc.SelectObject(bmp)
+ dc.SetBackground(wx.Brush(bg_colour, wx.SOLID))
+ dc.Clear()
+ dc.SetTextForeground(wx.RED)
+ dc.SetFont(font)
+ dc.DrawText(text, 0, 0)
+ dc.SelectObject(wx.NullBitmap)
+ mask = wx.Mask(bmp, bg_colour)
+ bmp.SetMask(mask)
+ shape = DragShape(bmp)
+ shape.pos = (5, 100)
+ shape.text = "Some dragging text"
+ self.shapes.append(shape)
+
+
+ self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
+ self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
+ self.Bind(wx.EVT_MOTION, self.OnMotion)
+ self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveWindow)
+
+
+ # We're not doing anything here, but you might have reason to.
+ # for example, if you were dragging something, you might elect to
+ # 'drop it' when the cursor left the window.
+ def OnLeaveWindow(self, evt):
+ pass
+
+
+ # tile the background bitmap
+ def TileBackground(self, dc):
+ sz = self.GetClientSize()
+ 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
+
+
+ # Go through our list of shapes and draw them in whatever place they are.
+ def DrawShapes(self, dc):
+ for shape in self.shapes:
+ if shape.shown:
+ shape.Draw(dc)
+
+ # This is actually a sophisticated 'hit test', but in this
+ # case we're also determining which shape, if any, was 'hit'.
+ def FindShape(self, pt):
+ for shape in self.shapes:
+ if shape.HitTest(pt):
+ return shape
+ return None
+
+
+ # Clears the background, then redraws it. If the DC is passed, then
+ # we only do so in the area so designated. Otherwise, it's the whole thing.
+ def OnEraseBackground(self, evt):
+ dc = evt.GetDC()
+ if not dc:
+ dc = wx.ClientDC(self)
+ rect = self.GetUpdateRegion().GetBox()
+ dc.SetClippingRect(rect)
+ self.TileBackground(dc)
+
+ # Fired whenever a paint event occurs
+ def OnPaint(self, evt):
+ dc = wx.PaintDC(self)
+ self.PrepareDC(dc)
+ self.DrawShapes(dc)
+
+ # Left mouse button is down.
+ def OnLeftDown(self, evt):
+ # Did the mouse go down on one of our shapes?
+ shape = self.FindShape(evt.GetPosition())
+
+ # If a shape was 'hit', then set that as the shape we're going to
+ # drag around. Get our start position. Dragging has not yet started.
+ # That will happen once the mouse moves, OR the mouse is released.
+ if shape:
+ self.dragShape = shape
+ self.dragStartPos = evt.GetPosition()
+
+ # Left mouse button up.
+ def OnLeftUp(self, evt):
+ if not self.dragImage or not self.dragShape:
+ self.dragImage = None
+ self.dragShape = None
+ return
+
+ # Hide the image, end dragging, and nuke out the drag image.
+ self.dragImage.Hide()
+ self.dragImage.EndDrag()
+ self.dragImage = None
+
+ if self.hiliteShape:
+ self.RefreshRect(self.hiliteShape.GetRect())
+ self.hiliteShape = None
+
+ # reposition and draw the shape
+
+ # Note by jmg 11/28/03
+ # Here's the original:
+ #
+ # self.dragShape.pos = self.dragShape.pos + evt.GetPosition() - self.dragStartPos
+ #
+ # So if there are any problems associated with this, use that as
+ # a starting place in your investigation. I've tried to simulate the
+ # wx.Point __add__ method here -- it won't work for tuples as we
+ # have now from the various methods
+ #
+ # There must be a better way to do this :-)
+ #
+
+ self.dragShape.pos = (
+ self.dragShape.pos[0] + evt.GetPosition()[0] - self.dragStartPos[0],
+ self.dragShape.pos[1] + evt.GetPosition()[1] - self.dragStartPos[1]
+ )
+
+ self.dragShape.shown = True
+ self.RefreshRect(self.dragShape.GetRect())
+ self.dragShape = None
+
+
+ # The mouse is moving
+ def OnMotion(self, evt):
+ # Ignore mouse movement if we're not dragging.
+ if not self.dragShape or not evt.Dragging() or not evt.LeftIsDown():
+ return
+
+ # if we have a shape, but haven't started dragging yet
+ if self.dragShape and not self.dragImage:
+
+ # only start the drag after having moved a couple pixels
+ tolerance = 2
+ pt = evt.GetPosition()
+ dx = abs(pt.x - self.dragStartPos.x)
+ dy = abs(pt.y - self.dragStartPos.y)
+ if dx <= tolerance and dy <= tolerance:
+ return
+
+ # refresh the area of the window where the shape was so it
+ # will get erased.
+ self.dragShape.shown = False
+ self.RefreshRect(self.dragShape.GetRect(), True)
+ self.Update()
+
+ if self.dragShape.text:
+ self.dragImage = wx.DragString(self.dragShape.text,
+ wx.StockCursor(wx.CURSOR_HAND))
+ else:
+ self.dragImage = wx.DragImage(self.dragShape.bmp,
+ wx.StockCursor(wx.CURSOR_HAND))
+
+ hotspot = self.dragStartPos - self.dragShape.pos
+ self.dragImage.BeginDrag(hotspot, self, self.dragShape.fullscreen)
+
+ self.dragImage.Move(pt)
+ self.dragImage.Show()
+
+
+ # if we have shape and image then move it, posibly highlighting another shape.
+ elif self.dragShape and self.dragImage:
+ onShape = self.FindShape(evt.GetPosition())
+ unhiliteOld = False
+ hiliteNew = False
+
+ # figure out what to hilite and what to unhilite
+ if self.hiliteShape:
+ if onShape is None or self.hiliteShape is not onShape:
+ unhiliteOld = True
+
+ if onShape and onShape is not self.hiliteShape and onShape.shown:
+ hiliteNew = True
+
+ # if needed, hide the drag image so we can update the window
+ if unhiliteOld or hiliteNew:
+ self.dragImage.Hide()
+
+ if unhiliteOld:
+ dc = wx.ClientDC(self)
+ self.hiliteShape.Draw(dc)
+ self.hiliteShape = None
+
+ if hiliteNew:
+ dc = wx.ClientDC(self)
+ self.hiliteShape = onShape
+ self.hiliteShape.Draw(dc, wx.INVERT)
+
+ # now move it and show it again if needed
+ self.dragImage.Move(evt.GetPosition())
+ if unhiliteOld or hiliteNew:
+ self.dragImage.Show()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+
+ win = wx.Panel(nb, -1)
+ canvas = DragCanvas(win, -1)
+
+ def onSize(evt, panel=win, canvas=canvas):
+ canvas.SetSize(panel.GetSize())
+
+ win.Bind(wx.EVT_SIZE, onSize)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """\
+DragImage is used when you wish to drag an object on the screen, and a simple
+cursor is not enough.
+
+On Windows, the WIN32 API is used to do achieve smooth dragging. On other
+platforms, GenericDragImage is used. Applications may also prefer to use
+GenericDragImage on Windows, too.
+
+wxPython note: wxPython uses GenericDragImage on all
+platforms, but uses the DragImage name.
+
+To use this class, when you wish to start dragging an image, create a
+DragImage object and store it somewhere you can access it as the
+drag progresses. Call BeginDrag to start, and EndDrag to stop the drag. To move
+the image, initially call Show and then Move. If you wish to update the screen
+contents during the drag (for example, highlight an item as in the example), first
+call Hide, update the screen, call Move, and then call Show.
+
+You can drag within one window, or you can use full-screen dragging either across
+the whole screen, or just restricted to one area of the screen to save resources.
+If you want the user to drag between two windows, then you will need to use
+full-screen dragging.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/DragScroller.py b/demo/DragScroller.py
new file mode 100644
index 00000000..101555ef
--- /dev/null
+++ b/demo/DragScroller.py
@@ -0,0 +1,57 @@
+import wx
+import wx.lib.dragscroller
+
+#-------------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = DragScrollerExample(nb, -1)
+ return win
+
+class DragScrollerExample(wx.ScrolledWindow):
+ def __init__(self, parent, id=-1):
+ wx.ScrolledWindow.__init__(self, parent, id)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
+ self.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
+
+ self.SetScrollbars(1, 1, 2000, 2000, 0, 0)
+
+ self.scroller = wx.lib.dragscroller.DragScroller(self)
+
+ def OnPaint(self, event):
+ dc = wx.PaintDC(self)
+ self.PrepareDC(dc)
+
+ pen = wx.Pen(wx.BLACK, 5)
+ dc.SetPen(pen)
+
+ for y in range(10):
+ for x in range(10):
+ dc.DrawCircle(x*400+20, y*400+20, 200)
+
+ dc.DrawText('Right click and drag in the direction you want to scroll.',
+ 20, 20)
+ dc.DrawText('The distance from the start of the drag determines the speed.',
+ 20, 50)
+
+ def OnRightDown(self, event):
+ self.scroller.Start(event.GetPosition())
+
+ def OnRightUp(self, event):
+ self.scroller.Stop()
+
+
+#-------------------------------------------------------------------------------
+
+overview = """
+
DragScroller
+
+A helper class that adds scrolling to a wx.ScrolledWindow in the direction
+of the drag.
+
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])])
diff --git a/demo/DrawXXXList.py b/demo/DrawXXXList.py
new file mode 100644
index 00000000..5086b14c
--- /dev/null
+++ b/demo/DrawXXXList.py
@@ -0,0 +1,453 @@
+
+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, 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 = []
+
+ for i in range(num):
+ c = random.choice(colours)
+ t = random.randint(1, 4)
+
+ if not cache.has_key( (c, t) ):
+ 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 not cache.has_key(c):
+ 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.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.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))
+
+
+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()
+ 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
+ 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:
+
+
+ DrawPointList(sequence, pens=None)
+
+ 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.
+
+
+ DrawLineList(sequence, pens=None)
+
+ 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.
+
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/DynamicSashWindow.py b/demo/DynamicSashWindow.py
new file mode 100644
index 00000000..fab2767f
--- /dev/null
+++ b/demo/DynamicSashWindow.py
@@ -0,0 +1,166 @@
+
+import wx
+import wx.gizmos as gizmos
+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):
+ stc.StyledTextCtrl.__init__(self, parent, ID, style=wx.NO_BORDER)
+ self.dyn_sash = parent
+ self.log = log
+ self.SetupScrollBars()
+ self.SetMarginWidth(1,0)
+
+ self.StyleSetFont(stc.STC_STYLE_DEFAULT,
+ wx.Font(10, wx.MODERN, wx.NORMAL, wx.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 __del__(self):
+ self.log.write("TestView.__del__\n")
+
+ 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):
+ def __init__(self, parent, ID, log):
+ wx.Panel.__init__(self, parent, ID)
+ self.dyn_sash = parent
+ self.log = log
+ self.SetBackgroundColour("LIGHT BLUE")
+ self.Bind(gizmos.EVT_DYNAMIC_SASH_SPLIT, self.OnSplit)
+
+ def OnSplit(self, evt):
+ v = SimpleView(self.dyn_sash, -1, self.log)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+## if wx.Platform == "__WXMAC__":
+## from wx.lib.msgpanel import MessagePanel
+## win = MessagePanel(nb, 'This demo currently fails on the Mac. The problem is being looked into...',
+## 'Sorry', wx.ICON_WARNING)
+## return win
+
+ if 1:
+ win = gizmos.DynamicSashWindow(nb, -1, style = wx.CLIP_CHILDREN
+ #| wxDS_MANAGE_SCROLLBARS
+ #| wxDS_DRAG_CORNER
+ )
+
+ win.SetFont(wx.Font(10, wx.MODERN, wx.NORMAL, wx.NORMAL))
+ view = TestView(win, -1, log)
+ view.SetText(sampleText)
+ else:
+ win = wx.DynamicSashWindow(nb, -1)
+ view = SimpleView(win, -1, log)
+ return win
+
+#----------------------------------------------------------------------
+
+overview = """\
+
+
DynamicSashWindow
+
+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.
+
+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.
+
+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:
+
+
+
When your view is created
+
When your view receives a wxDynamicSashSplitEvent
+
When your view receives a wxDynamicSashUnifyEvent
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/EditableListBox.py b/demo/EditableListBox.py
new file mode 100644
index 00000000..55de3b69
--- /dev/null
+++ b/demo/EditableListBox.py
@@ -0,0 +1,97 @@
+
+import wx
+import wx.gizmos as gizmos
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ self.elb = gizmos.EditableListBox(
+ self, -1, "List of Stuff", (50,50), (250, 250)
+ )
+ #style=wx.EL_ALLOW_NEW | wx.EL_ALLOW_EDIT | wx.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 = """\
+
+
+This class provides a composite control that lets the user easily enter and edit
+a list of strings.
+
+
Styles supported:
+
+
+
EL_ALLOW_NEW - Allow user to create new items.
+
EL_ALLOW_EDIT - Allow user to edit text in the control.
+
EL_ALLOW_DELETE - Allow user to delete text from the control.
+
SetStrings(const wxArrayString& strings) - Set an array of strings
+ into the control. Note: The wxPython method accepts a Python list instead
+ of an array of strings.
+
+
void GetStrings(wxArrayString& strings) - Retrieves an array
+ of strings from the control. The wxPython version returns a list of strings.
+
+
GetListCtrl() - Retrieves a reference to the actual list control
+ portion of the custom control.
+
+
GetDelButton() - Retrieves a reference to the BitmapButton that is used
+ as the 'delete' button in the control.
+
+
GetNewButton() - Retrieves a reference to the BitmapButton that is used
+ as the 'new' button in the control.
+
+
GetUpButton() - Retrieves a reference to the BitmapButton that is used
+ as the 'up' button in the control.
+
+
GetDownButton() - Retrieves a reference to the BitmapButton that is used
+ as the 'down' button in the control.
+
+
GetEditButton() - Retrieves a reference to the BitmapButton that is used
+ as the 'edit' button in the control.
+
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Editor.py b/demo/Editor.py
new file mode 100644
index 00000000..114f2f00
--- /dev/null
+++ b/demo/Editor.py
@@ -0,0 +1,69 @@
+
+import wx
+import wx.lib.editor as editor
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = wx.Panel(nb, -1)
+ ed = editor.Editor(win, -1, style=wx.SUNKEN_BORDER)
+ box = wx.BoxSizer(wx.VERTICAL)
+ box.Add(ed, 1, wx.ALL|wx.GROW, 1)
+ win.SetSizer(box)
+ win.SetAutoLayout(True)
+
+ ed.SetText(["",
+ "This is a simple text editor, the class name is",
+ "Editor. Type a few lines and try it out.",
+ "",
+ "It uses Windows-style key commands that can be overridden by subclassing.",
+ "Mouse select works. Here are the key commands:",
+ "",
+ "Cursor movement: Arrow keys or mouse",
+ "Beginning of line: Home",
+ "End of line: End",
+ "Beginning of buffer: Control-Home",
+ "End of the buffer: Control-End",
+ "Select text: Hold down Shift while moving the cursor",
+ "Copy: Control-Insert, Control-C",
+ "Cut: Shift-Delete, Control-X",
+ "Paste: Shift-Insert, Control-V",
+ ""])
+
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """
+The Editor class implements a simple text editor using wxPython. You
+can create a custom editor by subclassing Editor. Even though much of
+the editor is implemented in Python, it runs surprisingly smoothly on
+normal hardware with small files.
+
+How to use it
+-------------
+The demo code (demo/Editor.py) shows how to use Editor as a simple text
+box. Use the SetText() and GetText() methods to set or get text from
+the component; these both use a list of strings.
+
+The samples/FrogEdit directory has an example of a simple text editor
+application that uses the Editor component.
+
+Subclassing
+-----------
+To add or change functionality, you can subclass this
+component. One example of this might be to change the key
+Alt key commands. In that case you would (for example) override the
+SetAltFuncs() method.
+
+"""
+
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/EventManager.py b/demo/EventManager.py
new file mode 100644
index 00000000..7f794289
--- /dev/null
+++ b/demo/EventManager.py
@@ -0,0 +1,290 @@
+#---------------------------------------------------------------------------
+# Name: EventManager.py
+# Purpose: A module to demonstrate wxPython.lib.evtmgr.EventManager.
+#
+# Author: Robb Shecter (robb@acm.org)
+#
+# Created: 16-December-2002
+# Copyright: (c) 2002 by Robb Shecter (robb@acm.org)
+# Licence: wxWindows license
+#---------------------------------------------------------------------------
+
+import wx
+import wx.lib.evtmgr as em
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ fsize = self.GetFont().GetPointSize()
+ f1 = wx.Font(fsize+0, wx.SWISS, wx.NORMAL, wx.NORMAL)
+ f2 = wx.Font(fsize+2, wx.SWISS, wx.NORMAL, wx.BOLD)
+ f3 = wx.Font(fsize+6, wx.SWISS, wx.NORMAL, wx.BOLD)
+
+ title1 = wx.StaticText(self, -1, 'EventManager')
+ title1.SetFont(f3)
+ txt = """\
+ This demo shows (1) basic uses and features of the EventManager, as well
+ as (2) how it helps with a real-world task: creating independent, object-
+ oriented components."""
+ message0 = wx.StaticText(self, -1, txt)
+ message0.SetFont(f1)
+
+ title2 = wx.StaticText(self, -1, 'Event Listeners')
+ title2.SetFont(f2)
+
+ txt = """\
+ These objects listen to motion events from the target window, using the ability
+ to register one event with multiple listeners. They also register for mouse events
+ on themselves to implement toggle-button functionality."""
+ message1 = wx.StaticText(self, -1, txt)
+ message1.SetFont(f1)
+
+ title3 = wx.StaticText(self, -1, 'Target Window')
+ title3.SetFont(f2)
+
+ txt = """\
+ A passive window that's used as an event generator. Move the mouse over it to
+ send events to the listeners above."""
+ message2 = wx.StaticText(self, -1, txt)
+ message2.SetFont(f1)
+
+ targetPanel = Tile(self, log, bgColor=wx.Colour(80,10,10), active=0)
+ buttonPanel = wx.Panel(self ,-1)
+ sizer = wx.BoxSizer(wx.HORIZONTAL)
+ target = targetPanel.tile
+
+ sizer.Add((0,0), 1)
+ for factor in [0.2, 0.3, 0.4, 0.5, 0.6, 0.7]:
+ sizer.Add(Tile(buttonPanel, log, factor-0.05, target), 0, wx.ALIGN_CENTER)
+ sizer.Add((0,0),1)
+ sizer.Add(Tile(buttonPanel, log, factor, target), 0, wx.ALIGN_CENTER)
+ sizer.Add((0,0),1)
+
+ buttonPanel.SetSizer(sizer)
+ sizer.Fit(buttonPanel)
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(title1, 0, wx.ALIGN_CENTER | wx.TOP | wx.BOTTOM, 6)
+ sizer.Add(message0, 0, wx.ALIGN_CENTER | wx.ALL, 6)
+ sizer.Add(title2, 0, wx.ALIGN_CENTER | wx.LEFT | wx.TOP | wx.RIGHT, 16)
+ sizer.Add(message1, 0, wx.ALIGN_CENTER | wx.ALL, 6)
+ sizer.Add(buttonPanel, 0, wx.EXPAND | wx.ALL, 16)
+ sizer.Add(title3, 0, wx.ALIGN_CENTER | wx.LEFT | wx.RIGHT, 16)
+ sizer.Add(message2, 0, wx.ALIGN_CENTER | wx.ALL, 6)
+ sizer.Add(targetPanel, 2, wx.EXPAND | wx.LEFT | wx.BOTTOM | wx.RIGHT, 16)
+ self.SetSizer(sizer)
+
+
+
+class Tile(wx.Window):
+ """
+ This outer class is responsible for changing
+ its border color in response to certain mouse
+ events over its contained 'InnerTile'.
+ """
+ normal = wx.Colour(150,150,150)
+ active = wx.Colour(250,245,245)
+ hover = wx.Colour(210,220,210)
+
+ def __init__(self, parent, log, factor=1, thingToWatch=None, bgColor=None, active=1, size=(38,38), borderWidth=3):
+ wx.Window.__init__(self, parent, -1, size=size, style=wx.CLIP_CHILDREN)
+ self.tile = InnerTile(self, log, factor, thingToWatch, bgColor)
+ self.log = log
+ sizer = wx.BoxSizer(wx.HORIZONTAL)
+ sizer.Add(self.tile, 1, wx.EXPAND | wx.ALL, borderWidth)
+ self.SetSizer(sizer)
+ self.Layout()
+ em.eventManager.Register(self.doLayout, wx.EVT_SIZE, self)
+ self.SetBackgroundColour(Tile.normal)
+ if active:
+ # Register myself for mouse events over self.tile in order to
+ # create typical button/hyperlink visual effects.
+ em.eventManager.Register(self.setHover, wx.EVT_ENTER_WINDOW, self.tile)
+ em.eventManager.Register(self.setNormal, wx.EVT_LEAVE_WINDOW, self.tile)
+ em.eventManager.Register(self.setActive, wx.EVT_LEFT_DOWN, self.tile)
+ em.eventManager.Register(self.setHover, wx.EVT_LEFT_UP, self.tile)
+
+
+ def doLayout(self, event):
+ self.Layout()
+
+
+ def setHover(self, event):
+ self.SetBackgroundColour(Tile.hover)
+ self.Refresh()
+
+
+ def setActive(self, event):
+ self.SetBackgroundColour(Tile.active)
+ self.Refresh()
+
+
+ def setNormal(self, event):
+ self.SetBackgroundColour(Tile.normal)
+ self.Refresh()
+
+
+
+class InnerTile(wx.Window):
+ IDLE_COLOR = wx.Colour( 80, 10, 10)
+ START_COLOR = wx.Colour(200, 70, 50)
+ FINAL_COLOR = wx.Colour( 20, 80,240)
+ OFF_COLOR = wx.Colour(185,190,185)
+ # Some pre-computation.
+ DELTAS = map(lambda a,b: b-a, START_COLOR.Get(), FINAL_COLOR.Get())
+ START_COLOR_TUPLE = START_COLOR.Get()
+
+ """
+ This inner panel changes its color in reaction to mouse
+ events over the 'thingToWatch'.
+ """
+ def __init__(self, parent, log, factor, thingToWatch=None, bgColor=None):
+ wx.Window.__init__(self, parent, -1)
+ self.SetMinSize((20,20))
+ self.log=log
+ if bgColor:
+ self.SetBackgroundColour(bgColor)
+ if thingToWatch:
+ self.factor = factor
+ self.thingToWatch = thingToWatch
+ self.state = 0
+ self.toggleOnOff()
+ # Watch for the mouse click to enable/disable myself.
+ em.eventManager.Register(self.toggleOnOff, wx.EVT_LEFT_UP, self)
+
+
+ def toggleOnOff(self, event=None):
+ # Implement being on or off by registering and
+ # de-registering self.makeColor() from the event manager.
+ if self.state:
+ em.eventManager.DeregisterListener(self.makeColor)
+ else:
+ em.eventManager.Register(self.makeColor, wx.EVT_MOTION, self.thingToWatch)
+ self.state = 1 - self.state
+ self.resetColor()
+
+
+ def resetColor(self, event=None):
+ if self.state:
+ self.setColor(InnerTile.IDLE_COLOR)
+ else:
+ self.setColor(InnerTile.OFF_COLOR)
+
+
+ def setColor(self, color):
+ self.SetBackgroundColour(color)
+ self.Refresh()
+
+
+ def makeColor(self, mouseEvent):
+ self.makeColorFromTuple(mouseEvent.GetPositionTuple())
+
+
+ def makeColorFromTuple(self, (x, y)):
+ MAX = 180.0
+ scaled = min((x + y) * self.factor, MAX) # In range [0..MAX]
+ percent = scaled / MAX
+ r = InnerTile.START_COLOR_TUPLE[0] + (InnerTile.DELTAS[0] * percent)
+ g = InnerTile.START_COLOR_TUPLE[1] + (InnerTile.DELTAS[1] * percent)
+ b = InnerTile.START_COLOR_TUPLE[2] + (InnerTile.DELTAS[2] * percent)
+ self.setColor(wx.Colour(int(r), int(g), int(b)))
+
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
EventManager
+
+
The goal of the EventManager is to make wxWindows events more
+'Pythonic' (ie. object-oriented) and easier to work with, without
+impacting performance. It offers these features:
+
+
+
+
+
Allows any number of listeners to register for a single
+ event. (In addition to the standard wxPython feature of a single
+ listener being able to respond to many events.)
+
+
Makes it easy to disconnect and reconnect listeners. This
+ has the effect of reducing the need for case-based branching in
+ application code.
+
+
Has an object-oriented API. Programmers register to get
+ events directly from the objects that generate them, instead of
+ using ID numbers.
+
+
+
+
Usage
+
+
The EventManager class has three public methods. First get a
+reference to it:
+
+
+ from wxPython.lib.evtmgr import eventManager
+
+
+
...and then invoke any of the following methods. These methods are
+'safe'; duplicate registrations or de-registrations will have no
+effect.
+
+
See the demo code as well as the documentation in the source of
+wxPython.lib.evtmgr for more details.
+
+
+
+by Robb Shecter (robb@acm.org)
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ExpandoTextCtrl.py b/demo/ExpandoTextCtrl.py
new file mode 100644
index 00000000..b9ba3091
--- /dev/null
+++ b/demo/ExpandoTextCtrl.py
@@ -0,0 +1,163 @@
+
+import wx
+from wx.lib.expando import ExpandoTextCtrl, EVT_ETC_LAYOUT_NEEDED
+
+#----------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(self, parent, title="Test ExpandoTextCtrl")
+ self.log = log
+ self.pnl = p = wx.Panel(self)
+ self.eom = ExpandoTextCtrl(p, size=(250,-1),
+ value="This control will expand as you type")
+ self.Bind(EVT_ETC_LAYOUT_NEEDED, self.OnRefit, self.eom)
+
+ # create some buttons and sizers to use in testing some
+ # features and also the layout
+ vBtnSizer = wx.BoxSizer(wx.VERTICAL)
+
+ btn = wx.Button(p, -1, "Set MaxHeight")
+ self.Bind(wx.EVT_BUTTON, self.OnSetMaxHeight, btn)
+ vBtnSizer.Add(btn, 0, wx.ALL|wx.EXPAND, 5)
+
+ btn = wx.Button(p, -1, "Set Font")
+ self.Bind(wx.EVT_BUTTON, self.OnSetFont, btn)
+ vBtnSizer.Add(btn, 0, wx.ALL|wx.EXPAND, 5)
+
+ btn = wx.Button(p, -1, "Write Text")
+ self.Bind(wx.EVT_BUTTON, self.OnWriteText, btn)
+ vBtnSizer.Add(btn, 0, wx.ALL|wx.EXPAND, 5)
+
+ btn = wx.Button(p, -1, "Append Text")
+ self.Bind(wx.EVT_BUTTON, self.OnAppendText, btn)
+ vBtnSizer.Add(btn, 0, wx.ALL|wx.EXPAND, 5)
+
+ btn = wx.Button(p, -1, "Set Value")
+ self.Bind(wx.EVT_BUTTON, self.OnSetValue, btn)
+ vBtnSizer.Add(btn, 0, wx.ALL|wx.EXPAND, 5)
+
+ btn = wx.Button(p, -1, "Get Value")
+ self.Bind(wx.EVT_BUTTON, self.OnGetValue, btn)
+ vBtnSizer.Add(btn, 0, wx.ALL|wx.EXPAND, 5)
+
+ for x in range(3):
+ btn = wx.Button(p, -1, " ")
+ vBtnSizer.Add(btn, 0, wx.ALL|wx.EXPAND, 5)
+ self.Bind(wx.EVT_BUTTON, self.OnOtherBtn, btn)
+
+ hBtnSizer = wx.BoxSizer(wx.HORIZONTAL)
+ for x in range(3):
+ btn = wx.Button(p, -1, " ")
+ hBtnSizer.Add(btn, 0, wx.ALL, 5)
+ self.Bind(wx.EVT_BUTTON, self.OnOtherBtn, btn)
+
+ sizer = wx.BoxSizer(wx.HORIZONTAL)
+ col1 = wx.BoxSizer(wx.VERTICAL)
+ col1.Add(self.eom, 0, wx.ALL, 10)
+ col1.Add(hBtnSizer)
+ sizer.Add(col1)
+ sizer.Add(vBtnSizer)
+ p.SetSizer(sizer)
+
+ # Put the panel in a sizer for the frame so we can use self.Fit()
+ frameSizer = wx.BoxSizer()
+ frameSizer.Add(p, 1, wx.EXPAND)
+ self.SetSizer(frameSizer)
+
+ self.Fit()
+
+
+ def OnRefit(self, evt):
+ # The Expando control will redo the layout of the
+ # sizer it belongs to, but sometimes this may not be
+ # enough, so it will send us this event so we can do any
+ # other layout adjustments needed. In this case we'll
+ # just resize the frame to fit the new needs of the sizer.
+ self.Fit()
+
+
+ def OnSetMaxHeight(self, evt):
+ mh = self.eom.GetMaxHeight()
+ dlg = wx.NumberEntryDialog(self, "", "Enter new max height:",
+ "MaxHeight", mh, -1, 1000)
+ if dlg.ShowModal() == wx.ID_OK:
+ self.eom.SetMaxHeight(dlg.GetValue())
+ dlg.Destroy()
+
+
+ def OnSetFont(self, evt):
+ dlg = wx.FontDialog(self, wx.FontData())
+ dlg.GetFontData().SetInitialFont(self.eom.GetFont())
+ if dlg.ShowModal() == wx.ID_OK:
+ self.eom.SetFont(dlg.GetFontData().GetChosenFont())
+ dlg.Destroy()
+
+
+ def OnWriteText(self, evt):
+ self.eom.WriteText("\nThis is a test... Only a test. If this had "
+ "been a real emergency you would have seen the "
+ "quick brown fox jump over the lazy dog.\n")
+
+ def OnAppendText(self, evt):
+ self.eom.AppendText("\nAppended text.")
+
+ def OnSetValue(self, evt):
+ self.eom.SetValue("A new value.")
+
+ def OnGetValue(self, evt):
+ self.log.write("-----------------\n" + self.eom.GetValue())
+
+ def OnOtherBtn(self, evt):
+ # just for testing...
+ #print self.eom.numLines,
+ self.eom._adjustCtrl()
+ #print self.eom.numLines
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, " Test ExpandoTextCtrl ", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ self.win = TestFrame(self, self.log)
+ self.win.Show(True)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
ExpandoTextCtrl
+
+The ExpandoTextCtrl is a multi-line wx.TextCtrl that will
+adjust its height on the fly as needed to accomodate the number of
+lines needed to display the current content of the control. It is
+assumed that the width of the control will be a fixed value and
+that only the height will be adjusted automatically. If the
+control is used in a sizer then the width should be set as part of
+the initial or min size of the control.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/FancyText.py b/demo/FancyText.py
new file mode 100644
index 00000000..b7c954c2
--- /dev/null
+++ b/demo/FancyText.py
@@ -0,0 +1,82 @@
+
+import wx
+import wx.lib.fancytext as fancytext
+
+#----------------------------------------------------------------------
+
+test_str = (''
+ 'some |23textwith subscript'
+ ' some other text')
+
+test_str2 = 'big green text'
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent):
+ wx.Panel.__init__(self, parent, -1)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+ def OnPaint(self, evt):
+ dc = wx.PaintDC(self)
+
+ w, h = fancytext.GetExtent(test_str, dc)
+ fancytext.RenderToDC(test_str, dc, 20, 20)
+
+ fancytext.RenderToDC(test_str2, dc, 20, 20 + h + 10)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = \
+"""
+
+
+
FancyText -- methods for rendering XML specified text
+
+In all cases, 'str' is an XML string. Note that start and end tags
+are only required if *enclose* is set to False. In this case the
+text should be wrapped in FancyText tags.
+
+
In addition, the module exports one class::
+
+ class StaticFancyText(self, window, id, text, background, ...)
+
+This class works similar to StaticText except it interprets its text
+as FancyText.
+
+
The text can supportsuperscripts and subscripts, text
+in different sizes, colors,
+styles, weights and
+families. It also supports a limited set of symbols,
+currently , , as well as greek letters in both
+upper case (...) and lower case (...).
+
+
+The End
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/FileBrowseButton.py b/demo/FileBrowseButton.py
new file mode 100644
index 00000000..2af110a9
--- /dev/null
+++ b/demo/FileBrowseButton.py
@@ -0,0 +1,99 @@
+
+""" Demonstrate filebrowsebutton module of the wxPython.lib Library.
+
+14.1.2001 Bernhard Reiter
+ Added demo for DirBrowseButton and improved overview text.
+"""
+
+import wx
+import wx.lib.filebrowsebutton as filebrowse
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, ID, log):
+ wx.Panel.__init__(self, parent, ID)
+ self.log = log
+
+ self.fbb = filebrowse.FileBrowseButton(
+ self, -1, size=(450, -1), changeCallback = self.fbbCallback
+ )
+
+ self.fbbh = filebrowse.FileBrowseButtonWithHistory(
+ self, -1, size=(450, -1), changeCallback = self.fbbhCallback
+ )
+
+ self.dbb = filebrowse.DirBrowseButton(
+ self, -1, size=(450, -1), changeCallback = self.dbbCallback
+ )
+
+ self.fbbh.callCallback = False
+ self.fbbh.SetHistory(['You', 'can', 'put', 'some', 'filenames', 'here'], 4)
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(self.fbb, 0, wx.ALL, 5)
+ sizer.Add(self.fbbh, 0, wx.ALL, 5)
+ sizer.Add(self.dbb, 0, wx.ALL, 5)
+ box = wx.BoxSizer()
+ box.Add(sizer, 0, wx.ALL, 20)
+ self.SetSizer(box)
+
+
+ def fbbCallback(self, evt):
+ self.log.write('FileBrowseButton: %s\n' % evt.GetString())
+
+
+ def fbbhCallback(self, evt):
+ if hasattr(self, 'fbbh'):
+ value = evt.GetString()
+ if not value:
+ return
+ self.log.write('FileBrowseButtonWithHistory: %s\n' % value)
+ history = self.fbbh.GetHistory()
+ if value not in history:
+ history.append(value)
+ self.fbbh.SetHistory(history)
+ self.fbbh.GetHistoryControl().SetStringSelection(value)
+
+
+ def dbbCallback(self, evt):
+ self.log.write('DirBrowseButton: %s\n' % evt.GetString())
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, -1, log)
+ return win
+
+
+#----------------------------------------------------------------------
+
+overview = """
+
class FileBrowseButton:
+
+%s
+
+
+
class FileBrowseButtonWithHistory(FileBrowseButton):
+
+%s
+
+
+
class DirBrowseButton(FileBrowseButton):
+
+%s
+
+
+<
+""" % ( filebrowse.FileBrowseButton.__doc__,
+ filebrowse.FileBrowseButtonWithHistory.__doc__ ,
+ filebrowse.DirBrowseButton.__doc__
+ )
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/FileDialog.py b/demo/FileDialog.py
new file mode 100644
index 00000000..da832540
--- /dev/null
+++ b/demo/FileDialog.py
@@ -0,0 +1,143 @@
+
+import os
+import wx
+
+#---------------------------------------------------------------------------
+
+# This is how you pre-establish a file filter so that the dialog
+# only shows the extension(s) you want it to.
+wildcard = "Python source (*.py)|*.py|" \
+ "Compiled Python (*.pyc)|*.pyc|" \
+ "SPAM files (*.spam)|*.spam|" \
+ "Egg file (*.egg)|*.egg|" \
+ "All files (*.*)|*.*"
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show an OPEN FileDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+ b = wx.Button(self, -1, "Create and Show a SAVE FileDialog", (50,90))
+ self.Bind(wx.EVT_BUTTON, self.OnButton2, b)
+
+
+ def OnButton(self, evt):
+ self.log.WriteText("CWD: %s\n" % os.getcwd())
+
+ # Create the dialog. In this case the current directory is forced as the starting
+ # directory for the dialog, and no default file name is forced. This can easilly
+ # be changed in your program. This is an 'open' dialog, and allows multitple
+ # file selections as well.
+ #
+ # Finally, if the directory is changed in the process of getting files, this
+ # dialog is set up to change the current working directory to the path chosen.
+ dlg = wx.FileDialog(
+ self, message="Choose a file",
+ defaultDir=os.getcwd(),
+ defaultFile="",
+ wildcard=wildcard,
+ style=wx.OPEN | wx.MULTIPLE | wx.CHANGE_DIR
+ )
+
+ # Show the dialog and retrieve the user response. If it is the OK response,
+ # process the data.
+ if dlg.ShowModal() == wx.ID_OK:
+ # This returns a Python list of files that were selected.
+ paths = dlg.GetPaths()
+
+ self.log.WriteText('You selected %d files:' % len(paths))
+
+ for path in paths:
+ self.log.WriteText(' %s\n' % path)
+
+ # Compare this with the debug above; did we change working dirs?
+ self.log.WriteText("CWD: %s\n" % os.getcwd())
+
+ # Destroy the dialog. Don't do this until you are done with it!
+ # BAD things can happen otherwise!
+ dlg.Destroy()
+
+
+
+ def OnButton2(self, evt):
+ self.log.WriteText("CWD: %s\n" % os.getcwd())
+
+ # Create the dialog. In this case the current directory is forced as the starting
+ # directory for the dialog, and no default file name is forced. This can easilly
+ # be changed in your program. This is an 'save' dialog.
+ #
+ # Unlike the 'open dialog' example found elsewhere, this example does NOT
+ # force the current working directory to change if the user chooses a different
+ # directory than the one initially set.
+ dlg = wx.FileDialog(
+ self, message="Save file as ...", defaultDir=os.getcwd(),
+ defaultFile="", wildcard=wildcard, style=wx.SAVE
+ )
+
+ # This sets the default filter that the user will initially see. Otherwise,
+ # the first filter in the list will be used by default.
+ dlg.SetFilterIndex(2)
+
+ # Show the dialog and retrieve the user response. If it is the OK response,
+ # process the data.
+ if dlg.ShowModal() == wx.ID_OK:
+ path = dlg.GetPath()
+ self.log.WriteText('You selected "%s"' % path)
+
+ # Normally, at this point you would save your data using the file and path
+ # data that the user provided to you, but since we didn't actually start
+ # with any data to work with, that would be difficult.
+ #
+ # The code to do so would be similar to this, assuming 'data' contains
+ # the data you want to save:
+ #
+ # fp = file(path, 'w') # Create file anew
+ # fp.write(data)
+ # fp.close()
+ #
+ # You might want to add some error checking :-)
+ #
+
+ # Note that the current working dir didn't change. This is good since
+ # that's the way we set it up.
+ self.log.WriteText("CWD: %s\n" % os.getcwd())
+
+ # Destroy the dialog. Don't do this until you are done with it!
+ # BAD things can happen otherwise!
+ dlg.Destroy()
+
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+This class provides the file selection dialog. It incorporates OS-native features
+depending on the OS in use, and can be used both for open and save operations.
+The files displayed can be filtered by setting up a wildcard filter, multiple files
+can be selected (open only), and files can be forced in a read-only mode.
+
+There are two ways to get the results back from the dialog. GetFiles() returns only
+the file names themselves, in a Python list. GetPaths() returns the full path and
+filenames combined as a Python list.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/FileHistory.py b/demo/FileHistory.py
new file mode 100644
index 00000000..b94b4567
--- /dev/null
+++ b/demo/FileHistory.py
@@ -0,0 +1,143 @@
+
+import os
+import wx
+
+#----------------------------------------------------------------------
+
+text = """\
+Right-click on the panel above the line to get a menu. This menu will
+be managed by a FileHistory object and so the files you select will
+automatically be added to the end of the menu and will be selectable
+the next time the menu is viewed. The filename selected, either via the
+Open menu item, or from the history, will be displayed in the log
+window below.
+"""
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+ box = wx.BoxSizer(wx.VERTICAL)
+
+ # Make and layout the controls
+ fs = self.GetFont().GetPointSize()
+ bf = wx.Font(fs+4, wx.SWISS, wx.NORMAL, wx.BOLD)
+ nf = wx.Font(fs+2, wx.SWISS, wx.NORMAL, wx.NORMAL)
+
+ t = wx.StaticText(self, -1, "FileHistory")
+ t.SetFont(bf)
+ box.Add(t, 0, wx.CENTER|wx.ALL, 5)
+
+ box.Add(wx.StaticLine(self, -1), 0, wx.EXPAND)
+ box.Add((10,20))
+
+ t = wx.StaticText(self, -1, text)
+ t.SetFont(nf)
+ box.Add(t, 0, wx.CENTER|wx.ALL, 5)
+
+ self.SetSizer(box)
+ self.SetAutoLayout(True)
+
+ # Make a menu
+ self.menu = m = wx.Menu()
+
+ # Little know wx Fact #42: there are a number of pre-set IDs
+ # in the wx package, to be used for common controls such as those
+ # illustrated below. Neat, huh?
+ m.Append(wx.ID_NEW, "&New")
+ m.Append(wx.ID_OPEN, "&Open...")
+ m.Append(wx.ID_CLOSE, "&Close")
+ m.Append(wx.ID_SAVE, "&Save")
+ m.Append(wx.ID_SAVEAS, "Save &as...")
+ m.Enable(wx.ID_NEW, False)
+ m.Enable(wx.ID_CLOSE, False)
+ m.Enable(wx.ID_SAVE, False)
+ m.Enable(wx.ID_SAVEAS, False)
+
+ # and a file history
+ self.filehistory = wx.FileHistory()
+ self.filehistory.UseMenu(self.menu)
+
+ # and finally the event handler bindings
+ self.Bind(wx.EVT_RIGHT_UP, self.OnRightClick)
+
+ self.Bind(wx.EVT_MENU, self.OnFileOpenDialog, id=wx.ID_OPEN)
+
+ self.Bind(
+ wx.EVT_MENU_RANGE, self.OnFileHistory, id=wx.ID_FILE1, id2=wx.ID_FILE9
+ )
+
+ self.Bind(wx.EVT_WINDOW_DESTROY, self.Cleanup)
+
+
+ def Cleanup(self, *args):
+ # A little extra cleanup is required for the FileHistory control
+ del self.filehistory
+ self.menu.Destroy()
+
+
+ def OnRightClick(self, evt):
+ self.PopupMenu(self.menu)
+
+
+ def OnFileOpenDialog(self, evt):
+ dlg = wx.FileDialog(self,
+ defaultDir = os.getcwd(),
+ wildcard = "All Files|*",
+ style = wx.OPEN | wx.CHANGE_DIR)
+
+ if dlg.ShowModal() == wx.ID_OK:
+ path = dlg.GetPath()
+ self.log.write("You selected %s\n" % path)
+
+ # add it to the history
+ self.filehistory.AddFileToHistory(path)
+
+ dlg.Destroy()
+
+
+ def OnFileHistory(self, evt):
+ # get the file based on the menu ID
+ fileNum = evt.GetId() - wx.ID_FILE1
+ path = self.filehistory.GetHistoryFile(fileNum)
+ self.log.write("You selected %s\n" % path)
+
+ # add it back to the history so it will be moved up the list
+ self.filehistory.AddFileToHistory(path)
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
FileHistory
+
+wxFileHistory encapsulates functionality to record the last few files
+visited, and to allow the user to quickly load these files using the
+list appended to a menu, such as the File menu.
+
+
Note that this inclusion is not automatic; as illustrated in this example,
+you must add files (and remove them) as deemed necessary within the framework
+of your program.
+
+
Note also the additional cleanup required for this class, namely trapping the
+enclosing window's Destroy event and deleting the file history control and its
+associated menu.
+
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/FindReplaceDialog.py b/demo/FindReplaceDialog.py
new file mode 100644
index 00000000..b27a83ce
--- /dev/null
+++ b/demo/FindReplaceDialog.py
@@ -0,0 +1,121 @@
+# 11/17/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Updated for wx namespace
+#
+# 11/28/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Changed the event binding slightly.
+
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+ self.findData = wx.FindReplaceData()
+
+ self.fbtn = wx.Button(self, -1, "Show Find Dialog", (25, 50))
+ self.Bind(wx.EVT_BUTTON, self.OnShowFind, self.fbtn)
+
+ self.frbtn = wx.Button(self, -1, "Show Find && Replace Dialog", (25, 90))
+ self.Bind(wx.EVT_BUTTON, self.OnShowFindReplace, self.frbtn)
+
+ def BindFindEvents(self, win):
+ win.Bind(wx.EVT_FIND, self.OnFind)
+ win.Bind(wx.EVT_FIND_NEXT, self.OnFind)
+ win.Bind(wx.EVT_FIND_REPLACE, self.OnFind)
+ win.Bind(wx.EVT_FIND_REPLACE_ALL, self.OnFind)
+ win.Bind(wx.EVT_FIND_CLOSE, self.OnFindClose)
+
+ def EnableButtons(self):
+ self.fbtn.Enable()
+ self.frbtn.Enable()
+
+ def DisableButtons(self):
+ self.fbtn.Disable()
+ self.frbtn.Disable()
+
+ def OnShowFind(self, evt):
+ self.DisableButtons()
+ dlg = wx.FindReplaceDialog(self, self.findData, "Find")
+ self.BindFindEvents(dlg)
+ dlg.Show(True)
+
+
+ def OnShowFindReplace(self, evt):
+ self.DisableButtons()
+ dlg = wx.FindReplaceDialog(self, self.findData, "Find & Replace", wx.FR_REPLACEDIALOG)
+ self.BindFindEvents(dlg)
+ dlg.Show(True)
+
+
+ def OnFind(self, evt):
+ #print repr(evt.GetFindString()), repr(self.findData.GetFindString())
+ map = {
+ wx.wxEVT_COMMAND_FIND : "FIND",
+ wx.wxEVT_COMMAND_FIND_NEXT : "FIND_NEXT",
+ wx.wxEVT_COMMAND_FIND_REPLACE : "REPLACE",
+ wx.wxEVT_COMMAND_FIND_REPLACE_ALL : "REPLACE_ALL",
+ }
+
+ et = evt.GetEventType()
+
+ if et in map:
+ evtType = map[et]
+ else:
+ evtType = "**Unknown Event Type**"
+
+ if et in [wx.wxEVT_COMMAND_FIND_REPLACE, wx.wxEVT_COMMAND_FIND_REPLACE_ALL]:
+ replaceTxt = "Replace text: %s" % evt.GetReplaceString()
+ else:
+ replaceTxt = ""
+
+ self.log.write("%s -- Find text: %s %s Flags: %d \n" %
+ (evtType, evt.GetFindString(), replaceTxt, evt.GetFlags()))
+
+
+ def OnFindClose(self, evt):
+ self.log.write("FindReplaceDialog closing...\n")
+ evt.GetDialog().Destroy()
+ self.EnableButtons()
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+
+
+overview = """\
+FindReplaceDialog is a standard modeless dialog which is used to allow the user
+to search for some text (and possibly replace it with something else). The actual
+searching is supposed to be done in the owner window which is the parent of this
+dialog. Note that it means that unlike for the other standard dialogs this one
+must have a parent window. Also note that there is no way to use this
+dialog in a modal way; it is always, by design and implementation, modeless.
+
+FileReplaceDialog requires the use of FindReplaceData. This holds the
+data for the dialog. It is used to initialize the dialog with the default values
+and will keep the last values from the dialog when it is closed. It is also
+updated each time a FindDialogEvent is generated so instead of using the
+FindDialogEvent methods you can also directly query this object. Care must be
+taken not to use this object after the dialog is destroyed. The data within
+will be invalid after the parent dialog is destroyed.
+"""
+
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/FloatBar.py b/demo/FloatBar.py
new file mode 100644
index 00000000..8f85d6e2
--- /dev/null
+++ b/demo/FloatBar.py
@@ -0,0 +1,145 @@
+#
+# Please note that wx.lib.floatbar is not formally supported as
+# part of wxPython. If it works, fine. If not, unfortunate.
+# GTK users can use the wx.TB_DOCKABLE flag with a regular
+# wx.ToolBar, but everyone else has to take their chances.
+#
+
+import wx
+import wx.lib.floatbar
+
+import images
+
+
+class TestFloatBar(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(
+ self, parent, -1, 'Test ToolBar', wx.DefaultPosition, (500, 300)
+ )
+
+ self.log = log
+
+ win = wx.Window(self, -1)
+ win.SetBackgroundColour("WHITE")
+ wx.StaticText(
+ win, -1, "Drag the toolbar to float it,\n"
+ "Toggle the last tool to remove\nthe title.", (15,15)
+ )
+
+ tb = wx.lib.floatbar.FloatBar(self, -1)
+ self.SetToolBar(tb)
+ tb.SetFloatable(1)
+ tb.SetTitle("Floating!")
+ self.CreateStatusBar()
+
+ tsize = (16,16)
+ new_bmp = wx.ArtProvider.GetBitmap(wx.ART_NEW, wx.ART_TOOLBAR, tsize)
+ open_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, tsize)
+ copy_bmp = wx.ArtProvider.GetBitmap(wx.ART_COPY, wx.ART_TOOLBAR, tsize)
+ paste_bmp= wx.ArtProvider.GetBitmap(wx.ART_PASTE, wx.ART_TOOLBAR, tsize)
+
+ tb.AddSimpleTool(10, new_bmp, "New", "Long help for 'New'")
+ self.Bind(wx.EVT_TOOL, self.OnToolClick, id=10)
+ self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=10)
+
+ tb.AddSimpleTool(20, open_bmp, "Open")
+ self.Bind(wx.EVT_TOOL, self.OnToolClick, id=20)
+ self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=20)
+
+ tb.AddSeparator()
+ tb.AddSimpleTool(30, copy_bmp, "Copy")
+ self.Bind(wx.EVT_TOOL, self.OnToolClick, id=30)
+ self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=30)
+
+ tb.AddSimpleTool(40, paste_bmp, "Paste")
+ self.Bind(wx.EVT_TOOL, self.OnToolClick, id=40)
+ self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=40)
+
+ tb.AddSeparator()
+
+ tb.AddCheckTool(60, images.Tog1.GetBitmap(), images.Tog2.GetBitmap())
+ self.Bind(wx.EVT_TOOL, self.OnToolClick, id=60)
+ self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=60)
+
+ tb.Realize()
+
+ self.tb = tb
+ self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+
+ def OnCloseWindow(self, event):
+ self.Destroy()
+
+ def OnToolClick(self, event):
+ self.log.WriteText("tool %s clicked\n" % event.GetId())
+
+ if event.GetId() == 60:
+ print event.GetExtraLong(), event.IsChecked(), event.GetInt(), self.tb.GetToolState(60)
+
+ if event.GetExtraLong():
+ self.tb.SetTitle("")
+ else:
+ self.tb.SetTitle("Floating!")
+
+ def OnToolRClick(self, event):
+ self.log.WriteText("tool %s right-clicked\n" % event.GetId())
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Show the FloatBar sample", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ if wx.Platform == "__WXMAC__":
+ dlg = wx.MessageDialog(
+ self, 'FloatBar does not work well on this platform.',
+ 'Sorry', wx.OK | wx.ICON_WARNING
+ )
+ dlg.ShowModal()
+ dlg.Destroy()
+ else:
+ win = TestFloatBar(self, self.log)
+ win.Show(True)
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+overview = """\
+FloatBar is a subclass of wx.ToolBar, implemented in Python, which
+can be detached from its frame.
+
+Drag the toolbar with the mouse to make it float, and drag it back, or
+close it to make the toolbar return to its original position.
+
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/demo/FloatCanvas.py b/demo/FloatCanvas.py
new file mode 100644
index 00000000..86919bd0
--- /dev/null
+++ b/demo/FloatCanvas.py
@@ -0,0 +1,1960 @@
+#!/usr/bin/env python
+
+try:
+ import numpy as N
+ import numpy.random as RandomArray
+ haveNumpy = True
+ #print "Using numpy, version:", N.__version__
+except ImportError:
+ # numpy isn't there
+ haveNumpy = False
+ errorText = (
+ "The FloatCanvas requires the numpy module, version 1.* \n\n"
+ "You can get info about it at:\n"
+ "http://numpy.scipy.org/\n\n"
+ )
+
+#---------------------------------------------------------------------------
+
+
+def BuildDrawFrame(): # this gets called when needed, rather than on import
+ try:
+ from floatcanvas import NavCanvas, FloatCanvas, Resources
+ except ImportError: # if it's not there locally, try the wxPython lib.
+ from wx.lib.floatcanvas import NavCanvas, FloatCanvas, Resources
+ import wx.lib.colourdb
+ import time, random
+
+ class DrawFrame(wx.Frame):
+
+ """
+ A frame used for the FloatCanvas Demo
+
+ """
+
+
+ def __init__(self,parent, id,title,position,size):
+ wx.Frame.__init__(self,parent, id,title,position, size)
+
+ ## Set up the MenuBar
+ MenuBar = wx.MenuBar()
+
+ file_menu = wx.Menu()
+ item = file_menu.Append(-1, "&Close","Close this frame")
+ self.Bind(wx.EVT_MENU, self.OnQuit, item)
+
+ item = file_menu.Append(-1, "&SavePNG","Save the current image as a PNG")
+ self.Bind(wx.EVT_MENU, self.OnSavePNG, item)
+ MenuBar.Append(file_menu, "&File")
+
+ draw_menu = wx.Menu()
+
+ item = draw_menu.Append(-1, "&Clear","Clear the Canvas")
+ self.Bind(wx.EVT_MENU, self.Clear, item)
+
+ item = draw_menu.Append(-1, "&Draw Test","Run a test of drawing random components")
+ self.Bind(wx.EVT_MENU, self.DrawTest, item)
+
+ item = draw_menu.Append(-1, "&Line Test","Run a test of drawing random lines")
+ self.Bind(wx.EVT_MENU, self.LineTest, item)
+
+ item = draw_menu.Append(-1, "Draw &Map","Run a test of drawing a map")
+ self.Bind(wx.EVT_MENU, self.DrawMap, item)
+
+ item = draw_menu.Append(-1, "&Text Test","Run a test of text drawing")
+ self.Bind(wx.EVT_MENU, self.TestText, item)
+
+ item = draw_menu.Append(-1, "&ScaledText Test","Run a test of text drawing")
+ self.Bind(wx.EVT_MENU, self.TestScaledText, item)
+
+ item = draw_menu.Append(-1, "&ScaledTextBox Test","Run a test of the Scaled Text Box")
+ self.Bind(wx.EVT_MENU, self.TestScaledTextBox, item)
+
+ item = draw_menu.Append(-1, "&Bitmap Test","Run a test of the Bitmap Object")
+ self.Bind(wx.EVT_MENU, self.TestBitmap, item)
+
+ item = draw_menu.Append(-1, "&Hit Test","Run a test of the hit test code")
+ self.Bind(wx.EVT_MENU, self.TestHitTest, item)
+
+ item = draw_menu.Append(-1, "Hit Test &Foreground","Run a test of the hit test code with a foreground Object")
+ self.Bind(wx.EVT_MENU, self.TestHitTestForeground, item)
+
+ item = draw_menu.Append(-1, "&Animation","Run a test of Animation")
+ self.Bind(wx.EVT_MENU, self.TestAnimation, item)
+
+ #item = draw_menu.Append(-1, "&Speed","Run a test of Drawing Speed")
+ #self.Bind(wx.EVT_MENU, self.SpeedTest, item)
+
+ item = draw_menu.Append(-1, "Change &Properties","Run a test of Changing Object Properties")
+ self.Bind(wx.EVT_MENU, self.PropertiesChangeTest, item)
+
+ item = draw_menu.Append(-1, "&Arrows","Run a test of Arrows")
+ self.Bind(wx.EVT_MENU, self.ArrowTest, item)
+
+ item = draw_menu.Append(-1, "&ArrowLine Test","Run a test of drawing Arrow Lines")
+ self.Bind(wx.EVT_MENU, self.ArrowLineTest, item)
+
+ item = draw_menu.Append(-1, "&Hide","Run a test of hiding and showing objects")
+ self.Bind(wx.EVT_MENU, self.HideTest, item)
+
+ MenuBar.Append(draw_menu, "&Tests")
+
+ view_menu = wx.Menu()
+ item = view_menu.Append(-1, "Zoom to &Fit","Zoom to fit the window")
+ self.Bind(wx.EVT_MENU, self.ZoomToFit, item)
+ MenuBar.Append(view_menu, "&View")
+
+ help_menu = wx.Menu()
+ item = help_menu.Append(-1, "&About",
+ "More information About this program")
+ self.Bind(wx.EVT_MENU, self.OnAbout, item)
+ MenuBar.Append(help_menu, "&Help")
+
+ self.SetMenuBar(MenuBar)
+
+ self.CreateStatusBar()
+
+
+ # Add the Canvas
+ NC = NavCanvas.NavCanvas(self,
+ Debug = 0,
+ BackgroundColor = "DARK SLATE BLUE")
+
+ self.Canvas = NC.Canvas # reference the contained FloatCanvas
+
+ self.MsgWindow = wx.TextCtrl(self, wx.ID_ANY,
+ "Look Here for output from events\n",
+ style = (wx.TE_MULTILINE |
+ wx.TE_READONLY |
+ wx.SUNKEN_BORDER)
+ )
+
+ ##Create a sizer to manage the Canvas and message window
+ MainSizer = wx.BoxSizer(wx.VERTICAL)
+ MainSizer.Add(NC, 4, wx.EXPAND)
+ MainSizer.Add(self.MsgWindow, 1, wx.EXPAND | wx.ALL, 5)
+
+ self.SetSizer(MainSizer)
+ self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+ self.Canvas.Bind(FloatCanvas.EVT_MOTION, self.OnMove)
+ self.Canvas.Bind(FloatCanvas.EVT_MOUSEWHEEL, self.OnWheel)
+
+ self.EventsAreBound = False
+
+ ## getting all the colors for random objects
+ wx.lib.colourdb.updateColourDB()
+ self.colors = wx.lib.colourdb.getColourList()
+
+
+ return None
+
+ def Log(self, text):
+ self.MsgWindow.AppendText(text)
+ if not text[-1] == "\n":
+ self.MsgWindow.AppendText("\n")
+
+
+ def BindAllMouseEvents(self):
+ if not self.EventsAreBound:
+ ## Here is how you catch FloatCanvas mouse events
+ self.Canvas.Bind(FloatCanvas.EVT_LEFT_DOWN, self.OnLeftDown)
+ self.Canvas.Bind(FloatCanvas.EVT_LEFT_UP, self.OnLeftUp)
+ self.Canvas.Bind(FloatCanvas.EVT_LEFT_DCLICK, self.OnLeftDouble)
+
+ self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_DOWN, self.OnMiddleDown)
+ self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_UP, self.OnMiddleUp)
+ self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_DCLICK, self.OnMiddleDouble)
+
+ self.Canvas.Bind(FloatCanvas.EVT_RIGHT_DOWN, self.OnRightDown)
+ self.Canvas.Bind(FloatCanvas.EVT_RIGHT_UP, self.OnRightUp)
+ self.Canvas.Bind(FloatCanvas.EVT_RIGHT_DCLICK, self.OnRightDouble)
+
+ self.EventsAreBound = True
+
+
+ def UnBindAllMouseEvents(self):
+ ## Here is how you unbind FloatCanvas mouse events
+ self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DOWN)
+ self.Canvas.Unbind(FloatCanvas.EVT_LEFT_UP)
+ self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DCLICK)
+
+ self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_DOWN)
+ self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_UP)
+ self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_DCLICK)
+
+ self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_DOWN)
+ self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_UP)
+ self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_DCLICK)
+
+ self.EventsAreBound = False
+
+
+ def PrintCoords(self,event):
+ self.Log("coords are: %s"%(event.Coords,))
+ self.Log("pixel coords are: %s\n"%(event.GetPosition(),))
+
+ def OnSavePNG(self, event=None):
+ import os
+ dlg = wx.FileDialog(
+ self, message="Save file as ...", defaultDir=os.getcwd(),
+ defaultFile="", wildcard="*.png", style=wx.SAVE
+ )
+ if dlg.ShowModal() == wx.ID_OK:
+ path = dlg.GetPath()
+ if not(path[-4:].lower() == ".png"):
+ path = path+".png"
+ self.Canvas.SaveAsImage(path)
+
+
+ def OnLeftDown(self, event):
+ self.Log("LeftDown")
+ self.PrintCoords(event)
+
+ def OnLeftUp(self, event):
+ self.Log("LeftUp")
+ self.PrintCoords(event)
+
+ def OnLeftDouble(self, event):
+ self.Log("LeftDouble")
+ self.PrintCoords(event)
+
+ def OnMiddleDown(self, event):
+ self.Log("MiddleDown")
+ self.PrintCoords(event)
+
+ def OnMiddleUp(self, event):
+ self.Log("MiddleUp")
+ self.PrintCoords(event)
+
+ def OnMiddleDouble(self, event):
+ self.Log("MiddleDouble")
+ self.PrintCoords(event)
+
+ def OnRightDown(self, event):
+ self.Log("RightDown")
+ self.PrintCoords(event)
+
+ def OnRightUp(self, event):
+ self.Log("RightUp")
+ self.PrintCoords(event)
+
+ def OnRightDouble(self, event):
+ self.Log("RightDouble")
+ self.PrintCoords(event)
+
+ def OnWheel(self, event):
+ self.Log("Mouse Wheel")
+ self.PrintCoords(event)
+ Rot = event.GetWheelRotation()
+ Rot = Rot / abs(Rot) * 0.1
+ if event.ControlDown(): # move left-right
+ self.Canvas.MoveImage( (Rot, 0), "Panel" )
+ else: # move up-down
+ self.Canvas.MoveImage( (0, Rot), "Panel" )
+
+ def OnMove(self, event):
+ """
+ Updates the status bar with the world coordinates
+ """
+ self.SetStatusText("%.2f, %.2f"%tuple(event.Coords))
+ event.Skip()
+
+ def OnAbout(self, event):
+ dlg = wx.MessageDialog(self,
+ "This is a small program to demonstrate\n"
+ "the use of the FloatCanvas\n",
+ "About Me",
+ wx.OK | wx.ICON_INFORMATION)
+ dlg.ShowModal()
+ dlg.Destroy()
+
+ def ZoomToFit(self,event):
+ self.Canvas.ZoomToBB()
+
+ def Clear(self,event = None):
+ self.UnBindAllMouseEvents()
+ self.Canvas.InitAll()
+ self.Canvas.Draw()
+
+ def OnQuit(self,event):
+ self.Close(True)
+
+ def OnCloseWindow(self, event):
+ self.Destroy()
+
+ def DrawTest(self,event=None):
+ """
+ This demo draws a few of everything
+
+ """
+
+ wx.GetApp().Yield(True)
+
+ Range = (-10,10)
+ colors = self.colors
+
+ self.BindAllMouseEvents()
+ Canvas = self.Canvas
+
+ Canvas.InitAll()
+ #
+ ## these set the limits for how much you can zoom in and out
+ Canvas.MinScale = 14
+ Canvas.MaxScale = 500
+
+
+ ############# Random tests of everything ##############
+
+ # Rectangles
+ for i in range(3):
+ xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ lw = random.randint(1,5)
+ cf = random.randint(0,len(colors)-1)
+ wh = (random.randint(1,5), random.randint(1,5))
+ Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf])
+
+ # Ellipses
+ for i in range(3):
+ xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ lw = random.randint(1,5)
+ cf = random.randint(0,len(colors)-1)
+ h = random.randint(1,5)
+ w = random.randint(1,5)
+ Canvas.AddEllipse(xy, (h,w), LineWidth = lw,FillColor = colors[cf])
+
+ # Points
+ for i in range(5):
+ xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ D = random.randint(1,50)
+ cf = random.randint(0,len(colors)-1)
+ Canvas.AddPoint(xy, Color = colors[cf], Diameter = D)
+
+ # SquarePoints
+ for i in range(500):
+ xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ S = random.randint(1, 50)
+ cf = random.randint(0,len(colors)-1)
+ Canvas.AddSquarePoint(xy, Color = colors[cf], Size = S)
+
+ # Circles
+ for i in range(5):
+ xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ D = random.randint(1,5)
+ lw = random.randint(1,5)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ Canvas.AddCircle(xy, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
+ Canvas.AddText("Circle # %i"%(i), xy, Size = 12, BackgroundColor = None, Position = "cc")
+ # Lines
+ for i in range(5):
+ points = []
+ for j in range(random.randint(2,10)):
+ point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
+ points.append(point)
+ lw = random.randint(1,10)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl])
+ # Polygons
+ for i in range(3):
+ points = []
+ for j in range(random.randint(2,6)):
+ point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ points.append(point)
+ lw = random.randint(1,6)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ Canvas.AddPolygon(points,
+ LineWidth = lw,
+ LineColor = colors[cl],
+ FillColor = colors[cf],
+ FillStyle = 'Solid')
+
+ ## Pointset
+ for i in range(4):
+ points = []
+ points = RandomArray.uniform(Range[0],Range[1],(100,2))
+ cf = random.randint(0,len(colors)-1)
+ D = random.randint(1,4)
+ Canvas.AddPointSet(points, Color = colors[cf], Diameter = D)
+
+ # Text
+ String = "Unscaled text"
+ for i in range(3):
+ ts = random.randint(10,40)
+ cf = random.randint(0,len(colors)-1)
+ xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ Canvas.AddText(String, xy, Size = ts, Color = colors[cf], Position = "cc")
+
+ # Scaled Text
+ String = "Scaled text"
+ for i in range(3):
+ ts = random.random()*3 + 0.2
+ cf = random.randint(0,len(colors)-1)
+ Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ Canvas.AddScaledText(String, Point, Size = ts, Color = colors[cf], Position = "cc")
+
+ # Arrows
+ N = 5
+ Points = RandomArray.uniform(Range[0], Range[1], (N,2) )
+ for i in range(N):
+ Canvas.AddArrow(Points[i],
+ random.uniform(20,100),
+ Direction = random.uniform(0,360),
+ LineWidth = random.uniform(1,5),
+ LineColor = colors[random.randint(0,len(colors)-1)],
+ ArrowHeadAngle = random.uniform(20,90))
+
+ # ArrowLines
+ for i in range(5):
+ points = []
+ for j in range(random.randint(2,10)):
+ point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
+ points.append(point)
+ lw = random.randint(1,10)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ Canvas.AddArrowLine(points, LineWidth = lw, LineColor = colors[cl], ArrowHeadSize= 16)
+
+
+ Canvas.ZoomToBB()
+
+ def TestAnimation(self,event=None):
+ """
+
+ In this test, a relatively complex background is drawn, and
+ a simple object placed in the foreground is moved over
+ it. This demonstrates how to use the InForeground attribute
+ to make an object in the foregorund draw fast, without
+ having to re-draw the whole background.
+
+ """
+ wx.GetApp().Yield(True)
+ Range = (-10,10)
+ self.Range = Range
+
+ self.UnBindAllMouseEvents()
+ Canvas = self.Canvas
+ Canvas.InitAll()
+
+ ## Random tests of everything:
+ colors = self.colors
+ # Rectangles
+ for i in range(3):
+ xy = (random.uniform(Range[0],Range[1]), random.uniform(Range[0],Range[1]))
+ lw = random.randint(1,5)
+ cf = random.randint(0,len(colors)-1)
+ wh = (random.randint(1,5), random.randint(1,5) )
+ Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf])
+
+ # Ellipses
+ for i in range(3):
+ xy = (random.uniform(Range[0],Range[1]), random.uniform(Range[0],Range[1]))
+ lw = random.randint(1,5)
+ cf = random.randint(0,len(colors)-1)
+ wh = (random.randint(1,5), random.randint(1,5) )
+ Canvas.AddEllipse(xy, wh, LineWidth = lw, FillColor = colors[cf])
+
+ # Circles
+ for i in range(5):
+ xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ D = random.randint(1,5)
+ lw = random.randint(1,5)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ Canvas.AddCircle(xy, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
+ Canvas.AddText("Circle # %i"%(i), xy, Size = 12, BackgroundColor = None, Position = "cc")
+
+ # Lines
+ for i in range(5):
+ points = []
+ for j in range(random.randint(2,10)):
+ point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
+ points.append(point)
+ lw = random.randint(1,10)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl])
+
+ # Polygons
+ for i in range(3):
+ points = []
+ for j in range(random.randint(2,6)):
+ point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ points.append(point)
+ lw = random.randint(1,6)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ Canvas.AddPolygon(points,
+ LineWidth = lw,
+ LineColor = colors[cl],
+ FillColor = colors[cf],
+ FillStyle = 'Solid')
+
+ # Scaled Text
+ String = "Scaled text"
+ for i in range(3):
+ ts = random.random()*3 + 0.2
+ cf = random.randint(0,len(colors)-1)
+ xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ Canvas.AddScaledText(String, xy, Size = ts, Color = colors[cf], Position = "cc")
+
+
+ # Now the Foreground Object:
+ C = Canvas.AddCircle((0,0), 7, LineWidth = 2,LineColor = "Black",FillColor = "Red", InForeground = True)
+ T = Canvas.AddScaledText("Click to Move", (0,0), Size = 0.6, Position = 'cc', InForeground = True)
+ C.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.MoveMe)
+ C.Text = T
+
+ self.Timer = wx.PyTimer(self.ShowFrame)
+ self.FrameDelay = 50 # milliseconds
+
+ Canvas.ZoomToBB()
+
+ def ShowFrame(self):
+ Object = self.MovingObject
+ Range = self.Range
+ if self.TimeStep < self.NumTimeSteps:
+ x,y = Object.XY
+ if x > Range[1] or x < Range[0]:
+ self.dx = -self.dx
+ if y > Range[1] or y < Range[0]:
+ self.dy = -self.dy
+ Object.Move( (self.dx,self.dy) )
+ Object.Text.Move( (self.dx,self.dy))
+ self.Canvas.Draw()
+ self.TimeStep += 1
+ wx.GetApp().Yield(True)
+ else:
+ self.Timer.Stop()
+
+
+ def MoveMe(self, Object):
+ self.MovingObject = Object
+ Range = self.Range
+ self.dx = random.uniform(Range[0]/4,Range[1]/4)
+ self.dy = random.uniform(Range[0]/4,Range[1]/4)
+ #import time
+ #start = time.time()
+ self.NumTimeSteps = 200
+ self.TimeStep = 1
+ self.Timer.Start(self.FrameDelay)
+ #print "Did %i frames in %f seconds"%(N, (time.time() - start) )
+
+ def TestHitTest(self, event=None):
+ wx.GetApp().Yield(True)
+
+ self.UnBindAllMouseEvents()
+ Canvas = self.Canvas
+
+ Canvas.InitAll()
+
+ #Add a Hit-able rectangle
+ w, h = 60, 20
+
+ dx = 80
+ dy = 40
+ x, y = 20, 20
+ FontSize = 8
+
+ #Add one that is not HitAble
+ Canvas.AddRectangle((x,y), (w, h), LineWidth = 2)
+ Canvas.AddText("Not Hit-able", (x,y), Size = FontSize, Position = "bl")
+
+
+ x += dx
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2)
+ R.Name = "Line Rectangle"
+ R.HitFill = False
+ R.HitLineWidth = 5 # Makes it a little easier to hit
+ R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
+ Canvas.AddText("Left Click Line", (x,y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "Red"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+ R.Name = color + "Rectangle"
+ R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
+ Canvas.AddText("Left Click Fill", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x = 20
+ y += dy
+ color = "LightBlue"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+ R.Name = color + " Rectangle"
+ R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit)
+ Canvas.AddText("Right Click Fill", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "Grey"
+ R = Canvas.AddEllipse((x, y), (w, h),LineWidth = 2,FillColor = color)
+ R.Name = color +" Ellipse"
+ R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit)
+ Canvas.AddText("Right Click Fill", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "Brown"
+ R = Canvas.AddCircle((x+dx/2, y+dy/2), dx/4, LineWidth = 2, FillColor = color)
+ R.Name = color + " Circle"
+ R.HitFill = True
+ R.Bind(FloatCanvas.EVT_FC_LEFT_DCLICK, self.RectGotHit)
+ Canvas.AddText("Left D-Click Fill", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x = 20
+ y += dy
+ color = "Pink"
+ R = Canvas.AddCircle((x+dx/2, y+dy/2), dx/4, LineWidth = 2,FillColor = color)
+ R.Name = color + " Circle"
+ R.Bind(FloatCanvas.EVT_FC_LEFT_UP, self.RectGotHit)
+ Canvas.AddText("Left Up Fill", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "White"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+ R.Name = color + " Rectangle"
+ R.Bind(FloatCanvas.EVT_FC_MIDDLE_DOWN, self.RectGotHit)
+ Canvas.AddText("Middle Down", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "AQUAMARINE"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+ R.Name = color + " Rectangle"
+ R.Bind(FloatCanvas.EVT_FC_MIDDLE_UP, self.RectGotHit)
+ Canvas.AddText("Middle Up", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x = 20
+ y += dy
+ color = "CORAL"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+ R.Name = color + " Rectangle"
+ R.Bind(FloatCanvas.EVT_FC_MIDDLE_DCLICK, self.RectGotHit)
+ Canvas.AddText("Middle DoubleClick", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "CYAN"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+ R.Name = color + " Rectangle"
+ R.Bind(FloatCanvas.EVT_FC_RIGHT_UP, self.RectGotHit)
+ Canvas.AddText("Right Up", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "LIME GREEN"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+ R.Name = color + " Rectangle"
+ R.Bind(FloatCanvas.EVT_FC_RIGHT_DCLICK, self.RectGotHit)
+ Canvas.AddText("Right Double Click", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x = 20
+ y += dy
+ color = "MEDIUM GOLDENROD"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+ R.Name = color
+ R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight)
+ R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
+ Canvas.AddText("L and R Click", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "SALMON"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+ R.Name = color + " Rectangle"
+ R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
+ Canvas.AddText("Mouse Enter", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "MEDIUM VIOLET RED"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+ R.Name = color
+ R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
+ Canvas.AddText("Mouse Leave", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x = 20
+ y += dy
+ color = "SKY BLUE"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
+ R.Name = color
+ R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
+ R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
+ Canvas.AddText("Enter and Leave", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "WHEAT"
+ R = Canvas.AddRectangle((x, y), (w+12, h), LineColor = None, FillColor = color)
+ R.Name = color
+ R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
+ R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
+ Canvas.AddText("Mouse Enter&Leave", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "KHAKI"
+ R = Canvas.AddRectangle((x-12, y), (w+12, h), LineColor = None, FillColor = color)
+ R.Name = color
+ R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
+ R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
+ Canvas.AddText("Mouse Enter&Leave", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x = 20
+ y += dy
+ L = Canvas.AddLine(( (x, y), (x+10, y+10), (x+w, y+h) ), LineWidth = 2, LineColor = "Red")
+ L.Name = "A Line"
+ L.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
+ Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(L.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "SEA GREEN"
+ Points = N.array(( (x, y), (x, y+2.*h/3), (x+w, y+h), (x+w, y+h/2.), (x + 2.*w/3, y+h/2.), (x + 2.*w/3,y) ), N.float_)
+ R = Canvas.AddPolygon(Points, LineWidth = 2, FillColor = color)
+ R.Name = color + " Polygon"
+ R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight)
+ Canvas.AddText("RIGHT_DOWN", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "Red"
+ Points = N.array(( (x, y), (x, y+2.*h/3), (x+w, y+h), (x+w, y+h/2.), (x + 2.*w/3, y+h/2.), (x + 2.*w/3,y) ), N.float_)
+ R = Canvas.AddPointSet(Points, Diameter = 4, Color = color)
+ R.Name = "PointSet"
+ R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.PointSetGotHit)
+ Canvas.AddText("LEFT_DOWN", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
+
+ x = 20
+ y += dy
+ T = Canvas.AddText("Hit-able Text", (x, y), Size = 15, Color = "Red", Position = 'tl')
+ T.Name = "Hit-able Text"
+ T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
+ Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "bl")
+
+ x += dx
+ T = Canvas.AddScaledText("Scaled Text", (x, y), Size = 1./2*h, Color = "Pink", Position = 'bl')
+ Canvas.AddPointSet( (x, y), Diameter = 3)
+ T.Name = "Scaled Text"
+ T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
+ Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "tl")
+
+ x += dx
+ color = "Cyan"
+ Point = (x + w/2, y)
+ #Points = N.array(( (x, y), (x, y+2.*h/3), (x+w, y+h), (x+w, y+h/2.), (x + 2.*w/3, y+h/2.), (x + 2.*w/3,y) ), N.float_)
+ R = Canvas.AddSquarePoint(Point, Size = 8, Color = color)
+ R.Name = "SquarePoint"
+ R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
+ Canvas.AddText("LEFT_DOWN", (x, y), Size = FontSize, Position = "bl")
+ Canvas.AddText(R.Name, (x, y), Size = FontSize, Position = "tl")
+
+
+ self.Canvas.ZoomToBB()
+
+ def TestHitTestForeground(self,event=None):
+ wx.GetApp().Yield(True)
+
+ self.UnBindAllMouseEvents()
+ Canvas = self.Canvas
+
+ Canvas.InitAll()
+
+ #Add a Hitable rectangle
+ w, h = 60, 20
+
+ dx = 80
+ dy = 40
+ x,y = 20, 20
+
+ color = "Red"
+ R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color, InForeground = False)
+ R.Name = color + "Rectangle"
+ R.HitFill = True
+ R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
+ Canvas.AddText("Left Click Fill", (x, y), Position = "bl")
+ Canvas.AddText(R.Name, (x, y+h), Position = "tl")
+
+ ## A set of Rectangles that move together
+
+ ## NOTE: In a real app, it might be better to create a new
+ ## custom FloatCanvas DrawObject
+
+ self.MovingRects = []
+ WH = (w/2, h/2)
+ x += dx
+ color = "LightBlue"
+ R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
+ R.HitFill = True
+ R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveLeft)
+ L = Canvas.AddText("Left", (x + w/4, y + h/4), Position = "cc", InForeground = True)
+ self.MovingRects.extend( (R,L) )
+
+ x += w/2
+ R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
+ R.HitFill = True
+ R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveRight)
+ L = Canvas.AddText("Right", (x + w/4, y + h/4), Position = "cc", InForeground = True)
+ self.MovingRects.extend( (R,L) )
+
+ x -= w/2
+ y += h/2
+ R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
+ R.HitFill = True
+ R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveUp)
+ L = Canvas.AddText("Up", (x + w/4, y + h/4), Position = "cc", InForeground = True)
+ self.MovingRects.extend( (R,L) )
+
+
+ x += w/2
+ R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
+ R.HitFill = True
+ R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveDown)
+ L = Canvas.AddText("Down", (x + w/4, y + h/4), Position = "cc", InForeground = True)
+ self.MovingRects.extend( (R,L) )
+
+ self.Canvas.ZoomToBB()
+
+ def RectMoveLeft(self,Object):
+ self.MoveRects("left")
+
+ def RectMoveRight(self,Object):
+ self.MoveRects("right")
+
+ def RectMoveUp(self,Object):
+ self.MoveRects("up")
+
+ def RectMoveDown(self,Object):
+ self.MoveRects("down")
+
+ def MoveRects(self, Dir):
+ for Object in self.MovingRects:
+ X,Y = Object.XY
+ if Dir == "left": X -= 10
+ elif Dir == "right": X += 10
+ elif Dir == "up": Y += 10
+ elif Dir == "down": Y -= 10
+ Object.SetPoint((X,Y))
+ self.Canvas.Draw()
+
+ def PointSetGotHit(self, Object):
+ self.Log(Object.Name + "Got Hit\n")
+
+ def RectGotHit(self, Object):
+ self.Log(Object.Name + "Got Hit\n")
+
+ def RectGotHitRight(self, Object):
+ self.Log(Object.Name + "Got Hit With Right\n")
+
+ def RectGotHitLeft(self, Object):
+ self.Log(Object.Name + "Got Hit with Left\n")
+
+ def RectMouseOver(self, Object):
+ self.Log("Mouse entered:" + Object.Name)
+
+ def RectMouseLeave(self, Object):
+ self.Log("Mouse left " + Object.Name)
+
+
+ def TestText(self, event= None):
+ wx.GetApp().Yield(True)
+
+ self.BindAllMouseEvents()
+ Canvas = self.Canvas
+ Canvas.InitAll()
+
+
+ DefaultSize = 12
+ Point = (3, 0)
+
+ ## Add a non-visible rectangle, just to get a Bounding Box
+ ## Text objects have a zero-size bounding box, because it changes with zoom
+ Canvas.AddRectangle((-10,-10),
+ (20,20),
+ LineWidth = 1,
+ LineColor = None)
+
+ # Text
+ String = "Some text"
+ self.Canvas.AddText("Top Left",Point,Size = DefaultSize,Color = "Yellow",BackgroundColor = "Blue", Position = "tl")
+ self.Canvas.AddText("Bottom Left",Point,Size = DefaultSize,Color = "Cyan",BackgroundColor = "Black",Position = "bl")
+ self.Canvas.AddText("Top Right",Point,Size = DefaultSize,Color = "Black",BackgroundColor = "Cyan",Position = "tr")
+ self.Canvas.AddText("Bottom Right",Point,Size = DefaultSize,Color = "Blue",BackgroundColor = "Yellow",Position = "br")
+ Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
+
+ Point = (3, 2)
+
+ Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
+ self.Canvas.AddText("Top Center",Point,Size = DefaultSize,Color = "Black",Position = "tc")
+ self.Canvas.AddText("Bottom Center",Point,Size = DefaultSize,Color = "White",Position = "bc")
+
+ Point = (3, 4)
+
+ Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
+ self.Canvas.AddText("Center Right",Point,Size = DefaultSize,Color = "Black",Position = "cr")
+ self.Canvas.AddText("Center Left",Point,Size = DefaultSize,Color = "Black",Position = "cl")
+
+ Point = (3, -2)
+
+ Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
+ self.Canvas.AddText("Center Center",
+ Point, Size = DefaultSize,
+ Color = "Black",
+ Position = "cc")
+
+ self.Canvas.AddText("40 Pixels", (-10,8), Size = 40)
+ self.Canvas.AddText("20 Pixels", (-10,5), Size = 20)
+ self.Canvas.AddText("10 Pixels", (-10,3), Size = 10)
+
+ self.Canvas.AddText("MODERN Font", (-10, 0), Family = wx.MODERN)
+ self.Canvas.AddText("DECORATIVE Font", (-10, -1), Family = wx.DECORATIVE)
+ self.Canvas.AddText("ROMAN Font", (-10, -2), Family = wx.ROMAN)
+ self.Canvas.AddText("SCRIPT Font", (-10, -3), Family = wx.SCRIPT)
+ self.Canvas.AddText("ROMAN BOLD Font", (-10, -4), Family = wx.ROMAN, Weight=wx.BOLD)
+ self.Canvas.AddText("ROMAN ITALIC BOLD Font", (-10, -5), Family = wx.ROMAN, Weight=wx.BOLD, Style=wx.ITALIC)
+
+ # NOTE: this font exists on my Linux box..who knows were else you'll find it!
+ Font = wx.Font(20, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "helvetica")
+ self.Canvas.AddText("Helvetica Italic", (-10, -6), Font = Font)
+
+ self.Canvas.ZoomToBB()
+
+ def TestScaledText(self, event= None):
+ wx.GetApp().Yield(True)
+
+ self.BindAllMouseEvents()
+ Canvas = self.Canvas
+ Canvas.InitAll()
+
+ Point = (0, 0)
+
+ T = Canvas.AddScaledText("Top Left",
+ Point,
+ Size = 5,
+ Color = "Yellow",
+ BackgroundColor = "Blue",
+ Position = "tl")
+ T = Canvas.AddScaledText("Bottom Left",Point,Size = 5,Color = "Cyan",BackgroundColor = "Black",Position = "bl")
+ T = Canvas.AddScaledText("Top Right",Point,Size = 5,Color = "Black",BackgroundColor = "Cyan",Position = "tr")
+ T = Canvas.AddScaledText("Bottom Right",Point,Size = 5,Color = "Blue",BackgroundColor = "Yellow",Position = "br")
+ Canvas.AddPointSet((Point), Color = "Red", Diameter = 4)
+
+
+ Point = (0, 20)
+
+ Canvas.AddScaledText("Top Center",Point,Size = 7,Color = "Black",Position = "tc")
+ Canvas.AddScaledText("Bottom Center",Point,Size = 7,Color = "White",Position = "bc")
+ Canvas.AddPointSet((Point), Color = "White", Diameter = 4)
+
+ Point = (0, -20)
+
+ Canvas.AddScaledText("Center Right",Point,Size = 9,Color = "Black",Position = "cr")
+ Canvas.AddScaledText("Center Left",Point,Size = 9,Color = "Black",Position = "cl")
+ Canvas.AddPointSet((Point), Color = "White", Diameter = 4)
+
+ x = -200
+
+ self.Canvas.AddScaledText("MODERN Font", (x, 0), Size = 7, Family = wx.MODERN, Color = (0,0,0))
+ self.Canvas.AddScaledText("DECORATIVE Font", (x, -10), Size = 7, Family = wx.DECORATIVE, Color = (0,0,1))
+ self.Canvas.AddScaledText("ROMAN Font", (x, -20), Size = 7, Family = wx.ROMAN)
+ self.Canvas.AddScaledText("SCRIPT Font", (x, -30), Size = 7, Family = wx.SCRIPT)
+ self.Canvas.AddScaledText("ROMAN BOLD Font", (x, -40), Size = 7, Family = wx.ROMAN, Weight=wx.BOLD)
+ self.Canvas.AddScaledText("ROMAN ITALIC BOLD Font", (x, -50), Size = 7, Family = wx.ROMAN, Weight=wx.BOLD, Style=wx.ITALIC)
+ Canvas.AddPointSet((x,0), Color = "White", Diameter = 4)
+
+
+ # NOTE: this font exists on my OS-X.who knows were else you'll find it!
+ Point = (-100, 50)
+ Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "helvetica")
+ T = self.Canvas.AddScaledText("Helvetica Italic", Point, Size = 20, Font = Font, Position = 'bc')
+
+ Point = (-50, -50)
+ Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "times")
+ T = self.Canvas.AddScaledText("Times Font", Point, Size = 8, Font = Font)
+
+ self.Canvas.ZoomToBB()
+
+ def TestScaledTextBox(self, event= None):
+ wx.GetApp().Yield(True)
+
+ self.UnBindAllMouseEvents()
+ Canvas = self.Canvas
+ Canvas.InitAll()
+
+ Point = (45,40)
+ Box = Canvas.AddScaledTextBox("A Two Line\nString",
+ Point,
+ 2,
+ Color = "Black",
+ BackgroundColor = None,
+ LineColor = "Red",
+ LineStyle = "Solid",
+ LineWidth = 1,
+ Width = None,
+ PadSize = 5,
+ Family = wx.ROMAN,
+ Style = wx.NORMAL,
+ Weight = wx.NORMAL,
+ Underlined = False,
+ Position = 'br',
+ Alignment = "left",
+ InForeground = False)
+
+ # All defaults
+ Box = Canvas.AddScaledTextBox("A Two Line\nString",
+ Point,
+ 2)
+
+ Box = Canvas.AddScaledTextBox("A Two Line\nString",
+ Point,
+ 2,
+ BackgroundColor = "Yellow",
+ LineColor = "Red",
+ LineStyle = "Solid",
+ PadSize = 5,
+ Family = wx.TELETYPE,
+ Position = 'bl')
+
+ Box = Canvas.AddScaledTextBox("A String\nThis box is clickable",
+ Point,
+ 2,
+ BackgroundColor = "Yellow",
+ LineColor = "Red",
+ LineStyle = "Solid",
+ PadSize = 5,
+ Family = wx.TELETYPE,
+ Position = 'tr')
+
+ Box.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.binding2)
+
+ Canvas.AddPoint(Point, Diameter = 4)
+
+ Point = (45,15)
+ Box = Canvas.AddScaledTextBox("A Two Line\nString",
+ Point,
+ 2,
+ Color = "Black",
+ BackgroundColor = 'Red',
+ LineColor = "Blue",
+ LineStyle = "LongDash",
+ LineWidth = 2,
+ Width = None,
+ PadSize = 5,
+ Family = wx.TELETYPE,
+ Style = wx.NORMAL,
+ Weight = wx.NORMAL,
+ Underlined = False,
+ Position = 'cr',
+ Alignment = "left",
+ InForeground = False)
+
+ Box = Canvas.AddScaledTextBox("A Two Line\nString",
+ Point,
+ 1.5,
+ Color = "Black",
+ BackgroundColor = 'Red',
+ LineColor = "Blue",
+ LineStyle = "LongDash",
+ LineWidth = 2,
+ Width = None,
+ PadSize = 5,
+ Family = wx.TELETYPE,
+ Style = wx.NORMAL,
+ Weight = wx.NORMAL,
+ Underlined = False,
+ Position = 'cl',
+ Alignment = "left",
+ InForeground = False)
+
+ Canvas.AddPoint(Point, Diameter = 4)
+
+ Point = (45,-10)
+ Box = Canvas.AddScaledTextBox("A Two Line\nString",
+ Point,
+ 2,
+ Color = "Black",
+ BackgroundColor = 'Red',
+ LineColor = "Blue",
+ LineStyle = "LongDash",
+ LineWidth = 2,
+ Width = None,
+ PadSize = 3,
+ Family = wx.TELETYPE,
+ Style = wx.NORMAL,
+ Weight = wx.NORMAL,
+ Underlined = False,
+ Position = 'tc',
+ Alignment = "left",
+ InForeground = False)
+
+ Box = Canvas.AddScaledTextBox("A three\nLine\nString",
+ Point,
+ 1.5,
+ Color = "Black",
+ BackgroundColor = 'Red',
+ LineColor = "Blue",
+ LineStyle = "LongDash",
+ LineWidth = 2,
+ Width = None,
+ PadSize = 0.5,
+ Family = wx.TELETYPE,
+ Style = wx.NORMAL,
+ Weight = wx.NORMAL,
+ Underlined = False,
+ Position = 'bc',
+ Alignment = "left",
+ InForeground = False)
+
+
+ Canvas.AddPoint(Point, Diameter = 4)
+
+ Box = Canvas.AddScaledTextBox("Some Auto Wrapped Text. There is enough to do.",
+ (80,40),
+ 2,
+ BackgroundColor = 'White',
+ LineWidth = 2,
+ Width = 20,
+ PadSize = 0.5,
+ Family = wx.TELETYPE,
+ )
+
+ Box = Canvas.AddScaledTextBox("Some more auto wrapped text. Wrapped to a different width.\n\nThis is another paragraph.",
+ (80,20),
+ 2,
+ BackgroundColor = 'White',
+ LineWidth = 2,
+ Width = 40,
+ PadSize = 0.5,
+ Family = wx.ROMAN,
+ Alignment = "right"
+ )
+ Point = N.array((100, -20), N.float_)
+ Box = Canvas.AddScaledTextBox("Here is even more auto wrapped text. This time the line spacing is set to 0.8. \n\nThe Padding is set to 0.",
+ Point,
+ Size = 3,
+ BackgroundColor = 'White',
+ LineWidth = 1,
+ Width = 40,
+ PadSize = 0.0,
+ Family = wx.ROMAN,
+ Position = "cc",
+ LineSpacing = 0.8
+ )
+ Canvas.AddPoint(Point, "Red", 2)
+
+ Point = N.array((0, -40), N.float_)
+ # Point = N.array((0, 0), N.float_)
+ for Position in ["tl", "bl", "tr", "br"]:
+ # for Position in ["br"]:
+ Box = Canvas.AddScaledTextBox("Here is a\nfour liner\nanother line\nPosition=%s"%Position,
+ Point,
+ Size = 4,
+ Color = "Red",
+ BackgroundColor = None,#'LightBlue',
+ LineWidth = 1,
+ LineColor = "White",
+ Width = None,
+ PadSize = 2,
+ Family = wx.ROMAN,
+ Position = Position,
+ LineSpacing = 0.8
+ )
+ Canvas.AddPoint(Point, "Red", 4)
+
+ Point = N.array((-20, 60), N.float_)
+ Box = Canvas.AddScaledTextBox("Here is some\ncentered\ntext",
+ Point,
+ Size = 4,
+ Color = "Red",
+ BackgroundColor = 'LightBlue',
+ LineWidth = 1,
+ LineColor = "White",
+ Width = None,
+ PadSize = 2,
+ Family = wx.ROMAN,
+ Position = "tl",
+ Alignment = "center",
+ LineSpacing = 0.8
+ )
+
+ Point = N.array((-20, 20), N.float_)
+ Box = Canvas.AddScaledTextBox("Here is some\nright aligned\ntext",
+ Point,
+ Size = 4,
+ Color = "Red",
+ BackgroundColor = 'LightBlue',
+ LineColor = None,
+ Width = None,
+ PadSize = 2,
+ Family = wx.ROMAN,
+ Position = "tl",
+ Alignment = "right",
+ LineSpacing = 0.8
+ )
+
+ Point = N.array((100, -60), N.float_)
+ Box = Canvas.AddScaledTextBox("Here is some auto wrapped text. This time it is centered, rather than right aligned.\n\nThe Padding is set to 2.",
+ Point,
+ Size = 3,
+ BackgroundColor = 'White',
+ LineWidth = 1,
+ Width = 40,
+ PadSize = 2.0,
+ Family = wx.ROMAN,
+ Position = "cc",
+ LineSpacing = 0.8,
+ Alignment = 'center',
+ )
+
+
+
+
+ self.Canvas.ZoomToBB()
+
+ def binding2(self, event):
+ self.Log("I'm the TextBox")
+
+ def TestBitmap(self, event= None):
+ wx.GetApp().Yield(True)
+
+ self.UnBindAllMouseEvents()
+ Canvas = self.Canvas
+ Canvas.InitAll()
+
+ Canvas.AddRectangle((10, 20),
+ (400, 100),
+ LineWidth = 3,
+ LineColor = "Blue",
+ FillColor = "Red")
+
+ bmp = Resources.getMagPlusBitmap()
+
+ Canvas.AddText("These are Unscaled Bitmaps:", (140, 90))
+
+ Point = (150, 50)
+ BitMap = Canvas.AddBitmap(bmp, Point, Position = "cc" )
+ Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+ Point = (200, 50)
+ BitMap = Canvas.AddBitmap(bmp, Point, Position = "br" )
+ Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+ Point = (200, 50)
+ BitMap = Canvas.AddBitmap(bmp, Point, Position = "bl" )
+ Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+ Point = (200, 50)
+ BitMap = Canvas.AddBitmap(bmp, Point, Position = "tr" )
+ Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+ Point = (200, 50)
+ BitMap = Canvas.AddBitmap(bmp, Point, Position = "tl" )
+ Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+ Point = (250, 50)
+ BitMap = Canvas.AddBitmap(bmp, Point, Position = "cr" )
+ Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+ Point = (250, 50)
+ BitMap = Canvas.AddBitmap(bmp, Point, Position = "cl" )
+ Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+ Point = (300, 50)
+ BitMap = Canvas.AddBitmap(bmp, Point, Position = "tc" )
+ Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+ Point = (300, 50)
+ BitMap = Canvas.AddBitmap(bmp, Point, Position = "bc" )
+ Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+ Canvas.AddScaledText("These are Scaled Bitmaps:", (220, -60), Size = 10, Position = "tr")
+ Point = (250, -100)
+ BitMap = Canvas.AddScaledBitmap(bmp, Point, Height = 50, Position = "bc" )
+ BitMap = Canvas.AddScaledBitmap(bmp, Point, Height = 50, Position = "tc" )
+ Canvas.AddPoint(Point, Diameter=4, Color="Green")
+
+ Point = (300, -100)
+ BitMap = Canvas.AddScaledBitmap(Resources.getMondrianImage(), Point, Height = 50)
+
+ self.Canvas.ZoomToBB()
+
+ def DrawMap(self,event = None):
+ wx.GetApp().Yield(True)
+ import os, time
+
+ self.Canvas.InitAll()
+ self.Canvas.SetProjectionFun("FlatEarth")
+ self.BindAllMouseEvents()
+
+ ## Test of Actual Map Data
+ #start = time.clock()
+ self.Log("Loading Map from a File")
+ wx.GetApp().Yield(True) # so log text will get displayed now.
+ Shorelines = self.Read_MapGen(os.path.join("data",'world.dat'),stats = 0)
+ #print "It took %f seconds to load %i shorelines"%(time.clock() - start,len(Shorelines) )
+ #start = time.clock()
+ for segment in Shorelines:
+ self.Canvas.AddLine(segment)
+ #print "It took %f seconds to add %i shorelines"%(time.clock() - start,len(Shorelines) )
+ #start = time.clock()
+ self.Canvas.ZoomToBB()
+ #print "It took %f seconds to draw %i shorelines"%(time.clock() - start,len(Shorelines) )
+
+
+
+ def LineTest(self,event = None):
+ wx.GetApp().Yield(True)
+ import os, time
+# import random
+ colors = self.colors
+ Range = (-10,10)
+ ## Test of drawing lots of lines
+ Canvas = self.Canvas
+ Canvas.InitAll()
+ #start = time.clock()
+ linepoints = []
+ linecolors = []
+ linewidths = []
+ for i in range(2000):
+ points = (random.randint(Range[0],Range[1]),
+ random.randint(Range[0],Range[1]),
+ random.randint(Range[0],Range[1]),
+ random.randint(Range[0],Range[1]))
+ linepoints.append(points)
+ linewidths.append(random.randint(1,10) )
+ linecolors.append(random.randint(0,len(colors)-1) )
+ for (points,color,width) in zip(linepoints,linecolors,linewidths):
+ Canvas.AddLine((points[0:2],points[2:4]), LineWidth = width, LineColor = colors[color])
+ #print "It took %f seconds to add %i lines"%(time.clock() - start,len(linepoints) )
+ #start = time.clock()
+ Canvas.ZoomToBB()
+ #print "It took %f seconds to draw %i lines"%(time.clock() - start,len(linepoints) )
+
+ def ArrowLineTest(self,event = None):
+ wx.GetApp().Yield(True)
+ Canvas = self.Canvas
+ Canvas.InitAll()
+ # import os, time
+## import random
+ Range = (-100,100)
+ colors = self.colors
+
+ # Lines
+ for i in range(5):
+ points = []
+ for j in range(random.randint(2,10)):
+ point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
+ points.append(point)
+ lw = random.randint(1,4)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ al = random.randint(8,20)
+ aa = random.randint(20,90)
+ Canvas.AddArrowLine(points,
+ LineWidth = lw,
+ LineColor = colors[cl],
+ ArrowHeadSize = al,
+ ArrowHeadAngle = aa)
+
+ Canvas.ZoomToBB()
+
+ def SpeedTest(self,event=None):
+ wx.GetApp().Yield(True)
+ BigRange = (-1000,1000)
+ colors = self.colors
+
+ self.UnBindAllMouseEvents()
+ Canvas = self.Canvas
+
+ Canvas.InitAll()
+
+ # Pointset
+ coords = []
+ for i in range(1000):
+ Point = (random.uniform(BigRange[0],BigRange[1]),random.uniform(BigRange[0],BigRange[1]))
+ coords.append( (Point) )
+ print "Drawing the Points"
+ start = time.clock()
+ for Point in coords:
+ Canvas.AddPoint(Point, Diameter = 4)
+ print "It took %s seconds to add the points"%(time.clock() - start)
+ Canvas.ZoomToBB()
+
+ def PropertiesChangeTest(self,event=None):
+ wx.GetApp().Yield(True)
+
+ Range = (-10,10)
+ colors = self.colors
+
+ self.UnBindAllMouseEvents()
+ Canvas = self.Canvas
+
+ Canvas.InitAll()
+
+ self.ColorObjectsAll = []
+ self.ColorObjectsLine = []
+ self.ColorObjectsColor = []
+ self.ColorObjectsText = []
+ ##One of each object:
+ # Rectangle
+ Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ lw = random.randint(1,5)
+ cf = random.randint(0,len(colors)-1)
+ wh = ( random.randint(1,5), random.randint(1,5) )
+ self.Rectangle = Canvas.AddRectangle(Point, wh, LineWidth = lw, FillColor = colors[cf])
+ self.ColorObjectsAll.append(self.Rectangle)
+
+ # Ellipse
+ Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ lw = random.randint(1,5)
+ cf = random.randint(0,len(colors)-1)
+ wh = ( random.randint(1,5), random.randint(1,5) )
+ self.Ellipse = Canvas.AddEllipse(Point, wh, LineWidth = lw, FillColor = colors[cf])
+ self.ColorObjectsAll.append(self.Ellipse)
+
+ # Point
+ xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ D = random.randint(1,50)
+ lw = random.randint(1,5)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ self.ColorObjectsColor.append(Canvas.AddPoint(xy, colors[cf], D))
+
+ # Circle
+ Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ D = random.randint(1,5)
+ lw = random.randint(1,5)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ self.Circle = Canvas.AddCircle(Point, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
+ self.ColorObjectsAll.append(self.Circle)
+
+ # Line
+ points = []
+ for j in range(random.randint(2,10)):
+ point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
+ points.append(point)
+ lw = random.randint(1,10)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ self.ColorObjectsLine.append(Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl]))
+
+ # Polygon
+## points = []
+## for j in range(random.randint(2,6)):
+## point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+## points.append(point)
+ points = RandomArray.uniform(Range[0],Range[1],(6,2))
+ lw = random.randint(1,6)
+ cf = random.randint(0,len(colors)-1)
+ cl = random.randint(0,len(colors)-1)
+ self.ColorObjectsAll.append(Canvas.AddPolygon(points,
+ LineWidth = lw,
+ LineColor = colors[cl],
+ FillColor = colors[cf],
+ FillStyle = 'Solid'))
+
+ ## Pointset
+ points = RandomArray.uniform(Range[0],Range[1],(100,2))
+ cf = random.randint(0,len(colors)-1)
+ D = random.randint(1,4)
+ self.PointSet = Canvas.AddPointSet(points, Color = colors[cf], Diameter = D)
+ self.ColorObjectsColor.append(self.PointSet)
+
+ ## Point
+ point = RandomArray.uniform(Range[0],Range[1],(2,))
+ cf = random.randint(0,len(colors)-1)
+ D = random.randint(1,4)
+ self.Point = Canvas.AddPoint(point, Color = colors[cf], Diameter = D)
+ self.ColorObjectsColor.append(self.Point)
+
+ # Text
+ String = "Unscaled text"
+ ts = random.randint(10,40)
+ cf = random.randint(0,len(colors)-1)
+ Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ self.ColorObjectsText.append(Canvas.AddText(String, Point, Size = ts, Color = colors[cf], Position = "cc"))
+
+ # Scaled Text
+ String = "Scaled text"
+ ts = random.random()*3 + 0.2
+ cf = random.randint(0,len(colors)-1)
+ Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ self.ColorObjectsText.append(Canvas.AddScaledText(String, Point, Size = ts, Color = colors[cf], Position = "cc"))
+
+ # A "Button"
+ Button = Canvas.AddRectangle((-10, -12), (20, 3), LineStyle = None, FillColor = "Red")
+ Canvas.AddScaledText("Click Here To Change Properties",
+ (0, -10.5),
+ Size = 0.7,
+ Color = "Black",
+ Position = "cc")
+
+ Button.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ChangeProperties)
+
+ Canvas.ZoomToBB()
+
+ def ChangeProperties(self, Object = None):
+ colors = self.colors
+ Range = (-10,10)
+
+ for Object in self.ColorObjectsAll:
+ pass
+ Object.SetFillColor(colors[random.randint(0,len(colors)-1)])
+ Object.SetLineColor(colors[random.randint(0,len(colors)-1)])
+ Object.SetLineWidth(random.randint(1,7))
+ Object.SetLineStyle(FloatCanvas.DrawObject.LineStyleList.keys()[random.randint(0,5)])
+ for Object in self.ColorObjectsLine:
+ Object.SetLineColor(colors[random.randint(0,len(colors)-1)])
+ Object.SetLineWidth(random.randint(1,7))
+ Object.SetLineStyle(FloatCanvas.DrawObject.LineStyleList.keys()[random.randint(0,5)])
+ for Object in self.ColorObjectsColor:
+ Object.SetColor(colors[random.randint(0,len(colors)-1)])
+ for Object in self.ColorObjectsText:
+ Object.SetColor(colors[random.randint(0,len(colors)-1)])
+ Object.SetBackgroundColor(colors[random.randint(0,len(colors)-1)])
+ self.Circle.SetDiameter(random.randint(1,10))
+ self.PointSet.SetDiameter(random.randint(1,8))
+ self.Point.SetDiameter(random.randint(1,8))
+ for Object in (self.Rectangle, self.Ellipse):
+ Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ wh = ( random.randint(1,5), random.randint(1,5) )
+ Object.SetShape(Point, wh)
+ self.Canvas.Draw(Force = True)
+
+ def ArrowTest(self,event=None):
+ wx.GetApp().Yield(True)
+ self.UnBindAllMouseEvents()
+ Canvas = self.Canvas
+
+ Canvas.InitAll()
+ Canvas.MinScale = 15
+ Canvas.MaxScale = 30
+
+ # put in a rectangle to get a bounding box
+ Canvas.AddRectangle((0,0), (20,20), LineColor = None)
+
+ # Draw some Arrows
+ Canvas.AddArrow((10,10),Length = 40, Direction = 0)
+ Canvas.AddArrow((10,10),Length = 50, Direction = 45 ,LineWidth = 2, LineColor = "Black", ArrowHeadAngle = 20)
+ Canvas.AddArrow((10,10),Length = 60, Direction = 90 ,LineWidth = 3, LineColor = "Red", ArrowHeadAngle = 30)
+ Canvas.AddArrow((10,10),Length = 70, Direction = 135,LineWidth = 4, LineColor = "Red", ArrowHeadAngle = 40)
+ Canvas.AddArrow((10,10),Length = 80, Direction = 180,LineWidth = 5, LineColor = "Blue", ArrowHeadAngle = 50)
+ Canvas.AddArrow((10,10),Length = 90, Direction = 225,LineWidth = 4, LineColor = "Blue", ArrowHeadAngle = 60)
+ Canvas.AddArrow((10,10),Length = 100,Direction = 270,LineWidth = 3, LineColor = "Green", ArrowHeadAngle = 70)
+ Canvas.AddArrow((10,10),Length = 110,Direction = 315,LineWidth = 2, LineColor = "Green", ArrowHeadAngle = 90 )
+
+ Canvas.AddText("Clickable Arrow", (4,18), Position = "bc")
+ Arrow = Canvas.AddArrow((4,18), 80, Direction = 90 ,LineWidth = 3, LineColor = "Red", ArrowHeadAngle = 30)
+ Arrow.HitLineWidth = 6
+ Arrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ArrowClicked)
+
+ Canvas.AddText("Changable Arrow: try clicking it", (16,4), Position = "tc")
+ self.RotArrow = Canvas.AddArrow((16,4), 80, Direction = 0 ,LineWidth = 3, LineColor = "Green", ArrowHeadAngle = 30)
+ self.RotArrow.HitLineWidth = 6
+ self.RotArrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RotateArrow)
+
+ Canvas.ZoomToBB()
+
+ def ArrowClicked(self,event):
+ self.Log("The Arrow was Clicked")
+
+ def RotateArrow(self,event):
+ ##print "The Changeable Arrow was Clicked"
+ ## You can do them either one at a time, or both at once
+ ## Doing them both at once prevents the arrow points from being calculated twice
+ #self.RotArrow.SetDirection(self.RotArrow.Direction + random.uniform(-90,90))
+ #self.RotArrow.SetLength(self.RotArrow.Length + random.randint(-20,20))
+ self.RotArrow.SetLengthDirection(self.RotArrow.Length + random.randint(-20,20),
+ self.RotArrow.Direction + random.uniform(-90,90) )
+
+ self.Canvas.Draw(Force = True)
+
+ def HideTest(self, event=None):
+ wx.GetApp().Yield(True)
+
+ self.UnBindAllMouseEvents()
+ Canvas = self.Canvas
+ Canvas.InitAll()
+
+ Range = (-10,10)
+
+ # Create a couple random Polygons
+ points = []
+ for j in range(6):
+ point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ points.append(point)
+ Poly = Canvas.AddPolygon(points,
+ LineWidth = 2,
+ LineColor = "Black",
+ FillColor = "LightBlue",
+ FillStyle = 'Solid')
+
+ points = []
+ for j in range(6):
+ point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ points.append(point)
+ Poly2 = Canvas.AddPolygon(points,
+ LineWidth = 2,
+ LineColor = "Black",
+ FillColor = "Purple",
+ FillStyle = 'Solid',
+ InForeground = True)
+
+ HideButton = Canvas.AddScaledTextBox("Click To Hide\nBackground Polygon",
+ (-10, 0),
+ .5,
+ BackgroundColor="Red",
+ PadSize = 0.5,
+ Position = 'tr',
+ Alignment="center",
+ )
+ HideButton.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.HidePoly)
+ HideButton.HidePoly = Poly
+
+ HideButton2 = Canvas.AddScaledTextBox("Click To Hide\nForeground Polygon",
+ (-10, 5),
+ .5,
+ BackgroundColor="Red",
+ PadSize = 0.5,
+ Position = 'tr',
+ Alignment="center",
+ )
+ # Put a reference to the Polygon in the Button object
+ HideButton2.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.HidePoly)
+ HideButton2.HidePoly = Poly2
+
+
+ Canvas.ZoomToBB()
+
+ def HidePoly(self, Button):
+ Poly = Button.HidePoly
+
+ if Poly.Visible:
+ Poly.Visible = False
+ Button.SetText(Button.String.replace("Hide","Show"))
+ else:
+ Poly.Visible = True
+ Button.SetText(Button.String.replace("Show", "Hide"))
+ self.Canvas.Draw(True)
+
+
+ def TempTest(self, event= None):
+ """
+
+ This is the start of a poly editor test, but it's not complete
+ so you can only run it through a command line flag:
+
+ python FloatCanvasDemo.py --temp
+
+ """
+
+ wx.GetApp().Yield(True)
+
+ self.UnBindAllMouseEvents()
+ Canvas = self.Canvas
+ Canvas.InitAll()
+
+ Range = (-10,10)
+
+ # Create a random Polygon
+ points = []
+ for j in range(6):
+ point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
+ points.append(point)
+ Poly = Canvas.AddPolygon(points,
+ LineWidth = 2,
+ LineColor = "Black",
+ FillColor = "LightBlue",
+ FillStyle = 'Solid')
+
+ Poly.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.SelectPoly)
+
+ self.SelectedPoly = None
+ self.SelectPoints = []
+ self.SelectedPoint = None
+
+ Canvas.ZoomToBB()
+
+ def SelectPoly(self, Object):
+ Canvas = self.Canvas
+ if Object is self.SelectedPoly:
+ pass
+ else:
+ #fixme: Do something to unselect the old one
+ self.SelectedPoly = Object
+ Canvas.RemoveObjects(self.SelectPoints)
+ self.SelectPoints = []
+ # Draw points on the Vertices of the Selected Poly:
+ for i, point in enumerate(Object.Points):
+ P = Canvas.AddPointSet(point, Diameter = 6, Color = "Red")
+ P.VerticeNum = i
+ P.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.SelectPointHit)
+ self.SelectPoints.append(P)
+ #Canvas.ZoomToBB()
+ Canvas.Draw()
+
+ def SelectPointHit(self, Point):
+ self.Log("Point Num: %i Hit"%Point.VerticeNum)
+ self.SelectedPoint = Point
+
+ def Read_MapGen(self, filename, stats = 0,AllLines=0):
+ """
+ This function reads a MapGen Format file, and
+ returns a list of NumPy arrays with the line segments in them.
+
+ Each NumPy array in the list is an NX2 array of Python Floats.
+
+ The demo should have come with a file, "world.dat" that is the
+ shorelines of the whole world, in MapGen format.
+
+ """
+ import string
+ file = open(filename,'rt')
+ data = file.readlines()
+ data = map(string.strip,data)
+
+ Shorelines = []
+ segment = []
+ for line in data:
+ if line:
+ if line == "# -b": #New segment beginning
+ if segment: Shorelines.append(N.array(segment))
+ segment = []
+ else:
+ segment.append(map(float,string.split(line)))
+ if segment: Shorelines.append(N.array(segment))
+
+ if stats:
+ NumSegments = len(Shorelines)
+ NumPoints = 0
+ for segment in Shorelines:
+ NumPoints = NumPoints + len(segment)
+ AvgPoints = NumPoints / NumSegments
+ print "Number of Segments: ", NumSegments
+ print "Average Number of Points per segment: ",AvgPoints
+ if AllLines:
+ Lines = []
+ for segment in Shorelines:
+ Lines.append(segment[0])
+ for point in segment[1:-1]:
+ Lines.append(point)
+ Lines.append(point)
+ Lines.append(segment[-1])
+ return Lines
+ else:
+ return Shorelines
+ return DrawFrame
+
+#---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+
+ # running stand alone, Use wxversion:
+# import wxversion
+# wxversion.select("2.6")
+# wxversion.select("2.8")
+ import wx
+
+
+ # check options:
+ import sys, getopt
+ optlist, args = getopt.getopt(sys.argv[1:],'l',["all",
+ "text",
+ "map",
+ "stext",
+ "stextbox",
+ "bitmap",
+ "hit",
+ "hitf",
+ "animate",
+ "speed",
+ "temp",
+ "props",
+ "arrow",
+ "arrowline",
+ "hide"])
+
+ if not haveNumpy:
+ raise ImportError(errorText)
+ StartUpDemo = "all" # the default
+ if optlist:
+ StartUpDemo = optlist[0][0][2:]
+
+
+ class DemoApp(wx.App):
+ """
+ How the demo works:
+
+ Under the Draw menu, there are three options:
+
+ *Draw Test: will put up a picture of a bunch of randomly generated
+ objects, of each kind supported.
+
+ *Draw Map: will draw a map of the world. Be patient, it is a big map,
+ with a lot of data, and will take a while to load and draw (about 10 sec
+ on my 450Mhz PIII). Redraws take about 2 sec. This demonstrates how the
+ performance is not very good for large drawings.
+
+ *Clear: Clears the Canvas.
+
+ Once you have a picture drawn, you can zoom in and out and move about
+ the picture. There is a tool bar with three tools that can be
+ selected.
+
+ The magnifying glass with the plus is the zoom in tool. Once selected,
+ if you click the image, it will zoom in, centered on where you
+ clicked. If you click and drag the mouse, you will get a rubber band
+ box, and the image will zoom to fit that box when you release it.
+
+ The magnifying glass with the minus is the zoom out tool. Once selected,
+ if you click the image, it will zoom out, centered on where you
+ clicked. (note that this takes a while when you are looking at the map,
+ as it has a LOT of lines to be drawn. The image is double buffered, so
+ you don't see the drawing in progress)
+
+ The hand is the move tool. Once selected, if you click and drag on the
+ image, it will move so that the part you clicked on ends up where you
+ release the mouse. Nothing is changed while you are dragging. The
+ drawing is too slow for that.
+
+ I'd like the cursor to change as you change tools, but the stock
+ wxCursors didn't include anything I liked, so I stuck with the
+ pointer. Please let me know if you have any nice cursor images for me to
+ use.
+
+
+ Any bugs, comments, feedback, questions, and especially code are welcome:
+
+ -Chris Barker
+
+ Chris.Barker@noaa.gov
+
+ """
+
+ def __init__(self, *args, **kwargs):
+ wx.App.__init__(self, *args, **kwargs)
+
+ def OnInit(self):
+ DrawFrame = BuildDrawFrame()
+ frame = DrawFrame(None, -1, "FloatCanvas Demo App",wx.DefaultPosition,(700,700))
+
+ self.SetTopWindow(frame)
+ frame.Show()
+
+ ## check to see if the demo is set to start in a particular mode.
+ ## fixme: should this be in a dict instead?
+ if StartUpDemo == "text":
+ frame.TestText()
+ elif StartUpDemo == "stext":
+ frame.TestScaledText()
+ elif StartUpDemo == "stextbox":
+ frame.TestScaledTextBox()
+ elif StartUpDemo == "bitmap":
+ frame.TestBitmap()
+ elif StartUpDemo == "all":
+ frame.DrawTest()
+ elif StartUpDemo == "map":
+ frame.DrawMap()
+ elif StartUpDemo == "hit":
+ frame.TestHitTest()
+ elif StartUpDemo == "hitf":
+ frame.TestHitTestForeground()
+ elif StartUpDemo == "animate":
+ frame.TestAnimation()
+ elif StartUpDemo == "speed":
+ frame.SpeedTest()
+ elif StartUpDemo == "temp":
+ frame.TempTest()
+ elif StartUpDemo == "props":
+ frame.PropertiesChangeTest()
+ elif StartUpDemo == "arrow":
+ frame.ArrowTest()
+ elif StartUpDemo == "arrowline":
+ frame.ArrowLineTest()
+ elif StartUpDemo == "hide":
+ frame.HideTest()
+
+ return True
+
+ app = DemoApp(False)# put in True if you want output to go to it's own window.
+ app.MainLoop()
+
+else:
+ # It's not running stand-alone, set up for wxPython demo.
+ # don't neeed wxversion here.
+ import wx
+ if not haveNumpy:
+ ## TestPanel and runTest used for integration into wxPython Demo
+ class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ from wx.lib.floatcanvas.ScreenShot import getScreenShotBitmap
+
+ note1 = wx.StaticText(self, -1, errorText)
+ note2 = wx.StaticText(self, -1, "This is what the FloatCanvas can look like:")
+ S = wx.BoxSizer(wx.VERTICAL)
+ S.Add((10, 10), 1)
+ S.Add(note1, 0, wx.ALIGN_CENTER)
+ S.Add(note2, 0, wx.ALIGN_CENTER | wx.BOTTOM, 4)
+ S.Add(wx.StaticBitmap(self,-1,getScreenShotBitmap()),0,wx.ALIGN_CENTER)
+ S.Add((10, 10), 1)
+ self.SetSizer(S)
+ self.Layout()
+
+ else:
+ ## TestPanel and runTest used for integration into wxPython Demo
+ class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+ note1 = wx.StaticText(self, -1, "The FloatCanvas Demo needs")
+ note2 = wx.StaticText(self, -1, "a separate frame")
+ b = wx.Button(self, -1, "Open Demo Frame Now")
+ b.Bind(wx.EVT_BUTTON, self.OnButton)
+
+ S = wx.BoxSizer(wx.VERTICAL)
+ S.Add((10, 10), 1)
+ S.Add(note1, 0, wx.ALIGN_CENTER)
+ S.Add(note2, 0, wx.ALIGN_CENTER | wx.BOTTOM, 5)
+ S.Add(b, 0, wx.ALIGN_CENTER | wx.ALL, 5)
+ S.Add((10, 10), 1)
+ self.SetSizer(S)
+ self.Layout()
+
+ def OnButton(self, evt):
+ DrawFrame = BuildDrawFrame()
+ frame = DrawFrame(None, -1, "FloatCanvas Drawing Window",wx.DefaultPosition,(500,500))
+
+ #win = wx.lib.plot.TestFrame(self, -1, "PlotCanvas Demo")
+ frame.Show()
+ frame.DrawTest()
+
+ def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+ # import to get the doc
+ from wx.lib import floatcanvas
+ overview = floatcanvas.__doc__
+
+
+
+
+
+
+
+
diff --git a/demo/FontDialog.py b/demo/FontDialog.py
new file mode 100644
index 00000000..f5b9bcc9
--- /dev/null
+++ b/demo/FontDialog.py
@@ -0,0 +1,141 @@
+
+import wx
+from wx.lib import stattext
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ btn = wx.Button(self, -1, "Select Font")
+ self.Bind(wx.EVT_BUTTON, self.OnSelectFont, btn)
+
+ self.sampleText = stattext.GenStaticText(self, -1, "Sample Text")
+ self.sampleText.SetBackgroundColour(wx.WHITE)
+
+ self.curFont = self.sampleText.GetFont()
+ self.curClr = wx.BLACK
+
+ fgs = wx.FlexGridSizer(cols=2, vgap=5, hgap=5)
+ fgs.AddGrowableCol(1)
+ fgs.AddGrowableRow(0)
+
+ fgs.Add(btn)
+ fgs.Add(self.sampleText, 0, wx.ADJUST_MINSIZE|wx.GROW)
+
+ fgs.Add((15,15)); fgs.Add((15,15)) # an empty row
+
+ fgs.Add(wx.StaticText(self, -1, "PointSize:"))
+ self.ps = wx.StaticText(self, -1, "")
+ font = self.ps.GetFont()
+ font.SetWeight(wx.BOLD)
+ self.ps.SetFont(font)
+ fgs.Add(self.ps, 0, wx.ADJUST_MINSIZE)
+
+ fgs.Add(wx.StaticText(self, -1, "Family:"))
+ self.family = wx.StaticText(self, -1, "")
+ self.family.SetFont(font)
+ fgs.Add(self.family, 0, wx.ADJUST_MINSIZE)
+
+ fgs.Add(wx.StaticText(self, -1, "Style:"))
+ self.style = wx.StaticText(self, -1, "")
+ self.style.SetFont(font)
+ fgs.Add(self.style, 0, wx.ADJUST_MINSIZE)
+
+ fgs.Add(wx.StaticText(self, -1, "Weight:"))
+ self.weight = wx.StaticText(self, -1, "")
+ self.weight.SetFont(font)
+ fgs.Add(self.weight, 0, wx.ADJUST_MINSIZE)
+
+ fgs.Add(wx.StaticText(self, -1, "Face:"))
+ self.face = wx.StaticText(self, -1, "")
+ self.face.SetFont(font)
+ fgs.Add(self.face, 0, wx.ADJUST_MINSIZE)
+
+ fgs.Add((15,15)); fgs.Add((15,15)) # an empty row
+
+ fgs.Add(wx.StaticText(self, -1, "wx.NativeFontInfo:"))
+ self.nfi = wx.StaticText(self, -1, "")
+ self.nfi.SetFont(font)
+ fgs.Add(self.nfi, 0, wx.ADJUST_MINSIZE)
+
+ # give it some border space
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(fgs, 0, wx.GROW|wx.ADJUST_MINSIZE|wx.ALL, 25)
+
+ self.SetSizer(sizer)
+ self.UpdateUI()
+
+
+ def UpdateUI(self):
+ self.sampleText.SetFont(self.curFont)
+ self.sampleText.SetForegroundColour(self.curClr)
+ self.ps.SetLabel(str(self.curFont.GetPointSize()))
+ self.family.SetLabel(self.curFont.GetFamilyString())
+ self.style.SetLabel(self.curFont.GetStyleString())
+ self.weight.SetLabel(self.curFont.GetWeightString())
+ self.face.SetLabel(self.curFont.GetFaceName())
+ self.nfi.SetLabel(self.curFont.GetNativeFontInfo().ToString())
+ self.Layout()
+
+
+ def OnSelectFont(self, evt):
+ data = wx.FontData()
+ data.EnableEffects(True)
+ data.SetColour(self.curClr) # set colour
+ data.SetInitialFont(self.curFont)
+
+ dlg = wx.FontDialog(self, data)
+
+ if dlg.ShowModal() == wx.ID_OK:
+ data = dlg.GetFontData()
+ font = data.GetChosenFont()
+ colour = data.GetColour()
+
+ self.log.WriteText('You selected: "%s", %d points, color %s\n' %
+ (font.GetFaceName(), font.GetPointSize(),
+ colour.Get()))
+
+ self.curFont = font
+ self.curClr = colour
+ self.UpdateUI()
+
+ # Don't destroy the dialog until you get everything you need from the
+ # dialog!
+ dlg.Destroy()
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+This class allows you to use the system font selection dialog
+from within your program. Generally speaking, this allows you
+to select a font by its name, font size, and weight, and
+on some systems such things as strikethrough and underline.
+
+As with other dialogs used in wxPython, it is important to
+use the class' methods to extract the information you need
+about the font before you destroy the dialog. Failure
+to observe this almost always leads to a program failure of
+some sort, often ugly.
+
+This demo serves two purposes; it shows how to use the dialog
+to GET font information from the user, but also shows how
+to APPLY that information once you get it.
+
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/FontEnumerator.py b/demo/FontEnumerator.py
new file mode 100644
index 00000000..4356a5a8
--- /dev/null
+++ b/demo/FontEnumerator.py
@@ -0,0 +1,80 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+
+ e = wx.FontEnumerator()
+ e.EnumerateFacenames()
+ list = e.GetFacenames()
+
+ list.sort()
+
+ s1 = wx.StaticText(self, -1, "Face names:")
+
+ self.lb1 = wx.ListBox(self, -1, wx.DefaultPosition, (200, 250),
+ list, wx.LB_SINGLE)
+
+ self.Bind(wx.EVT_LISTBOX, self.OnSelect, id=self.lb1.GetId())
+
+ self.txt = wx.StaticText(self, -1, "Sample text...", (285, 50))
+
+ row = wx.BoxSizer(wx.HORIZONTAL)
+ row.Add(s1, 0, wx.ALL, 5)
+ row.Add(self.lb1, 0, wx.ALL, 5)
+ row.Add(self.txt, 0, wx.ALL|wx.ADJUST_MINSIZE, 5)
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(row, 0, wx.ALL, 30)
+ self.SetSizer(sizer)
+ self.Layout()
+
+ self.lb1.SetSelection(0)
+ self.OnSelect(None)
+ wx.FutureCall(300, self.SetTextSize)
+
+
+ def SetTextSize(self):
+ self.txt.SetSize(self.txt.GetBestSize())
+
+
+ def OnSelect(self, evt):
+ face = self.lb1.GetStringSelection()
+ font = wx.Font(28, wx.DEFAULT, wx.NORMAL, wx.NORMAL, False, face)
+ self.txt.SetLabel(face)
+ self.txt.SetFont(font)
+ if wx.Platform == "__WXMAC__": self.Refresh()
+
+## st = font.GetNativeFontInfo().ToString()
+## ni2 = wx.NativeFontInfo()
+## ni2.FromString(st)
+## font2 = wx.FontFromNativeInfo(ni2)
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+wxFontEnumerator enumerates either all available fonts on the system or only
+the ones with given attributes - either only fixed-width (suited for use in
+programs such as terminal emulators and the like) or the fonts available in
+the given encoding.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Frame.py b/demo/Frame.py
new file mode 100644
index 00000000..6a205094
--- /dev/null
+++ b/demo/Frame.py
@@ -0,0 +1,84 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class MyFrame(wx.Frame):
+ def __init__(
+ self, parent, ID, title, pos=wx.DefaultPosition,
+ size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE
+ ):
+
+ wx.Frame.__init__(self, parent, ID, title, pos, size, style)
+ panel = wx.Panel(self, -1)
+
+ button = wx.Button(panel, 1003, "Close Me")
+ button.SetPosition((15, 15))
+ self.Bind(wx.EVT_BUTTON, self.OnCloseMe, button)
+ self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+
+ def OnCloseMe(self, event):
+ self.Close(True)
+
+ def OnCloseWindow(self, event):
+ 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, "Create and Show a Frame", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ win = MyFrame(self, -1, "This is a wx.Frame", size=(350, 200),
+ style = wx.DEFAULT_FRAME_STYLE)
+ win.Show(True)
+
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+A Frame is a window whose size and position can (usually) be changed by
+the user. It usually has thick borders and a title bar, and can optionally
+contain a menu bar, toolbar and status bar. A frame can contain any window
+that is not a Frame or Dialog. It is one of the most fundamental of the
+wxWindows components.
+
+A Frame that has a status bar and toolbar created via the
+CreateStatusBar / CreateToolBar functions manages
+these windows, and adjusts the value returned by GetClientSize
+to reflect the remaining size available to application windows.
+
+By itself, a Frame is not too useful, but with the addition of Panels and
+other child objects, it encompasses the framework around which most user
+interfaces are constructed.
+
+If you plan on using Sizers and auto-layout features, be aware that the Frame
+class lacks the ability to handle these features unless it contains a Panel.
+The Panel has all the necessary functionality to both control the size of
+child components, and also communicate that information in a useful way to
+the Frame itself.
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/GIFAnimationCtrl.py b/demo/GIFAnimationCtrl.py
new file mode 100644
index 00000000..8f010385
--- /dev/null
+++ b/demo/GIFAnimationCtrl.py
@@ -0,0 +1,60 @@
+
+import wx
+from wx.animate import GIFAnimationCtrl
+
+from Main import opj
+
+GIFNames = [
+ 'bitmaps/AG00178_.gif',
+ 'bitmaps/BD13656_.gif',
+ 'bitmaps/AG00185_.gif',
+ 'bitmaps/AG00039_.gif',
+ 'bitmaps/AG00183_.gif',
+ 'bitmaps/AG00028_.gif',
+ ]
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ sizer = wx.FlexGridSizer(cols=3, hgap=5, vgap=5)
+ for name in GIFNames:
+ ani = GIFAnimationCtrl(self, -1, opj(name))
+ ani.GetPlayer().UseBackgroundColour(True)
+ ani.Play()
+ sizer.Add(ani, 0, wx.ALL, 10)
+
+ border = wx.BoxSizer()
+ border.Add(sizer, 1, wx.EXPAND|wx.ALL, 20)
+ self.SetSizer(border)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.animate.GIFAnimationCtrl
+
+wx.animate.GIFAnimationCtrl is like a wx.StaticBitmap but is able to
+display an animation by extracing frames from a multi-images GIF file.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/GLCanvas.py b/demo/GLCanvas.py
new file mode 100644
index 00000000..26635db4
--- /dev/null
+++ b/demo/GLCanvas.py
@@ -0,0 +1,290 @@
+
+import wx
+import sys
+
+try:
+ from wx import glcanvas
+ haveGLCanvas = True
+except ImportError:
+ haveGLCanvas = False
+
+try:
+ # The Python OpenGL package can be found at
+ # http://PyOpenGL.sourceforge.net/
+ from OpenGL.GL import *
+ from OpenGL.GLUT import *
+ haveOpenGL = True
+except ImportError:
+ haveOpenGL = False
+
+#----------------------------------------------------------------------
+
+
+buttonDefs = {
+ wx.NewId() : ('CubeCanvas', 'Cube'),
+ wx.NewId() : ('ConeCanvas', 'Cone'),
+ }
+
+class ButtonPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ box = wx.BoxSizer(wx.VERTICAL)
+ box.Add((20, 30))
+ keys = buttonDefs.keys()
+ keys.sort()
+ for k in keys:
+ text = buttonDefs[k][1]
+ btn = wx.Button(self, k, text)
+ box.Add(btn, 0, wx.ALIGN_CENTER|wx.ALL, 15)
+ self.Bind(wx.EVT_BUTTON, self.OnButton, btn)
+
+ #** Enable this to show putting a GLCanvas on the wx.Panel
+ if 1:
+ c = CubeCanvas(self)
+ c.SetMinSize((200, 200))
+ box.Add(c, 0, wx.ALIGN_CENTER|wx.ALL, 15)
+
+ self.SetAutoLayout(True)
+ self.SetSizer(box)
+
+
+ def OnButton(self, evt):
+ if not haveGLCanvas:
+ dlg = wx.MessageDialog(self,
+ 'The GLCanvas class has not been included with this build of wxPython!',
+ 'Sorry', wx.OK | wx.ICON_WARNING)
+ dlg.ShowModal()
+ dlg.Destroy()
+
+ elif not haveOpenGL:
+ dlg = wx.MessageDialog(self,
+ 'The OpenGL package was not found. You can get it at\n'
+ 'http://PyOpenGL.sourceforge.net/',
+ 'Sorry', wx.OK | wx.ICON_WARNING)
+ dlg.ShowModal()
+ dlg.Destroy()
+
+ else:
+ canvasClassName = buttonDefs[evt.GetId()][0]
+ canvasClass = eval(canvasClassName)
+ frame = wx.Frame(None, -1, canvasClassName, size=(400,400))
+ canvas = canvasClass(frame)
+ frame.Show(True)
+
+
+class MyCanvasBase(glcanvas.GLCanvas):
+ def __init__(self, parent):
+ glcanvas.GLCanvas.__init__(self, parent, -1)
+ self.init = False
+ self.context = glcanvas.GLContext(self)
+
+ # initial mouse position
+ self.lastx = self.x = 30
+ self.lasty = self.y = 30
+ self.size = None
+ self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ self.Bind(wx.EVT_LEFT_DOWN, self.OnMouseDown)
+ self.Bind(wx.EVT_LEFT_UP, self.OnMouseUp)
+ self.Bind(wx.EVT_MOTION, self.OnMouseMotion)
+
+
+ def OnEraseBackground(self, event):
+ pass # Do nothing, to avoid flashing on MSW.
+
+
+ def OnSize(self, event):
+ wx.CallAfter(self.DoSetViewport)
+ event.Skip()
+
+ def DoSetViewport(self):
+ size = self.size = self.GetClientSize()
+ self.SetCurrent(self.context)
+ glViewport(0, 0, size.width, size.height)
+
+
+
+ def OnPaint(self, event):
+ dc = wx.PaintDC(self)
+ self.SetCurrent(self.context)
+ if not self.init:
+ self.InitGL()
+ self.init = True
+ self.OnDraw()
+
+
+ def OnMouseDown(self, evt):
+ self.CaptureMouse()
+ self.x, self.y = self.lastx, self.lasty = evt.GetPosition()
+
+
+ def OnMouseUp(self, evt):
+ self.ReleaseMouse()
+
+
+ def OnMouseMotion(self, evt):
+ if evt.Dragging() and evt.LeftIsDown():
+ self.lastx, self.lasty = self.x, self.y
+ self.x, self.y = evt.GetPosition()
+ self.Refresh(False)
+
+
+
+
+class CubeCanvas(MyCanvasBase):
+ def InitGL(self):
+ # set viewing projection
+ glMatrixMode(GL_PROJECTION)
+ glFrustum(-0.5, 0.5, -0.5, 0.5, 1.0, 3.0)
+
+ # position viewer
+ glMatrixMode(GL_MODELVIEW)
+ glTranslatef(0.0, 0.0, -2.0)
+
+ # position object
+ glRotatef(self.y, 1.0, 0.0, 0.0)
+ glRotatef(self.x, 0.0, 1.0, 0.0)
+
+ glEnable(GL_DEPTH_TEST)
+ glEnable(GL_LIGHTING)
+ glEnable(GL_LIGHT0)
+
+
+ def OnDraw(self):
+ # clear color and depth buffers
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+ # draw six faces of a cube
+ glBegin(GL_QUADS)
+ glNormal3f( 0.0, 0.0, 1.0)
+ glVertex3f( 0.5, 0.5, 0.5)
+ glVertex3f(-0.5, 0.5, 0.5)
+ glVertex3f(-0.5,-0.5, 0.5)
+ glVertex3f( 0.5,-0.5, 0.5)
+
+ glNormal3f( 0.0, 0.0,-1.0)
+ glVertex3f(-0.5,-0.5,-0.5)
+ glVertex3f(-0.5, 0.5,-0.5)
+ glVertex3f( 0.5, 0.5,-0.5)
+ glVertex3f( 0.5,-0.5,-0.5)
+
+ glNormal3f( 0.0, 1.0, 0.0)
+ glVertex3f( 0.5, 0.5, 0.5)
+ glVertex3f( 0.5, 0.5,-0.5)
+ glVertex3f(-0.5, 0.5,-0.5)
+ glVertex3f(-0.5, 0.5, 0.5)
+
+ glNormal3f( 0.0,-1.0, 0.0)
+ glVertex3f(-0.5,-0.5,-0.5)
+ glVertex3f( 0.5,-0.5,-0.5)
+ glVertex3f( 0.5,-0.5, 0.5)
+ glVertex3f(-0.5,-0.5, 0.5)
+
+ glNormal3f( 1.0, 0.0, 0.0)
+ glVertex3f( 0.5, 0.5, 0.5)
+ glVertex3f( 0.5,-0.5, 0.5)
+ glVertex3f( 0.5,-0.5,-0.5)
+ glVertex3f( 0.5, 0.5,-0.5)
+
+ glNormal3f(-1.0, 0.0, 0.0)
+ glVertex3f(-0.5,-0.5,-0.5)
+ glVertex3f(-0.5,-0.5, 0.5)
+ glVertex3f(-0.5, 0.5, 0.5)
+ glVertex3f(-0.5, 0.5,-0.5)
+ glEnd()
+
+ if self.size is None:
+ self.size = self.GetClientSize()
+ w, h = self.size
+ w = max(w, 1.0)
+ h = max(h, 1.0)
+ xScale = 180.0 / w
+ yScale = 180.0 / h
+ glRotatef((self.y - self.lasty) * yScale, 1.0, 0.0, 0.0);
+ glRotatef((self.x - self.lastx) * xScale, 0.0, 1.0, 0.0);
+
+ self.SwapBuffers()
+
+
+
+
+
+class ConeCanvas(MyCanvasBase):
+ def InitGL( self ):
+ glMatrixMode(GL_PROJECTION)
+ # camera frustrum setup
+ glFrustum(-0.5, 0.5, -0.5, 0.5, 1.0, 3.0)
+ glMaterial(GL_FRONT, GL_AMBIENT, [0.2, 0.2, 0.2, 1.0])
+ glMaterial(GL_FRONT, GL_DIFFUSE, [0.8, 0.8, 0.8, 1.0])
+ glMaterial(GL_FRONT, GL_SPECULAR, [1.0, 0.0, 1.0, 1.0])
+ glMaterial(GL_FRONT, GL_SHININESS, 50.0)
+ glLight(GL_LIGHT0, GL_AMBIENT, [0.0, 1.0, 0.0, 1.0])
+ glLight(GL_LIGHT0, GL_DIFFUSE, [1.0, 1.0, 1.0, 1.0])
+ glLight(GL_LIGHT0, GL_SPECULAR, [1.0, 1.0, 1.0, 1.0])
+ glLight(GL_LIGHT0, GL_POSITION, [1.0, 1.0, 1.0, 0.0])
+ glLightModelfv(GL_LIGHT_MODEL_AMBIENT, [0.2, 0.2, 0.2, 1.0])
+ glEnable(GL_LIGHTING)
+ glEnable(GL_LIGHT0)
+ glDepthFunc(GL_LESS)
+ glEnable(GL_DEPTH_TEST)
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+ # position viewer
+ glMatrixMode(GL_MODELVIEW)
+ # position viewer
+ glTranslatef(0.0, 0.0, -2.0);
+ #
+ glutInit(sys.argv)
+
+
+ def OnDraw(self):
+ # clear color and depth buffers
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+ # use a fresh transformation matrix
+ glPushMatrix()
+ # position object
+ #glTranslate(0.0, 0.0, -2.0)
+ glRotate(30.0, 1.0, 0.0, 0.0)
+ glRotate(30.0, 0.0, 1.0, 0.0)
+
+ glTranslate(0, -1, 0)
+ glRotate(250, 1, 0, 0)
+ glutSolidCone(0.5, 1, 30, 5)
+ glPopMatrix()
+ glRotatef((self.y - self.lasty), 0.0, 0.0, 1.0);
+ glRotatef((self.x - self.lastx), 1.0, 0.0, 0.0);
+ # push into visible buffer
+ self.SwapBuffers()
+
+
+
+
+#----------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = ButtonPanel(nb, log)
+ return win
+
+
+
+
+
+
+overview = """\
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
+
+
+#----------------------------------------------------------------------
+
diff --git a/demo/Gauge.py b/demo/Gauge.py
new file mode 100644
index 00000000..d53bcdbf
--- /dev/null
+++ b/demo/Gauge.py
@@ -0,0 +1,60 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+ self.count = 0
+
+ wx.StaticText(self, -1, "This example shows the wx.Gauge control.", (45, 15))
+
+ self.g1 = wx.Gauge(self, -1, 50, (110, 50), (250, 25))
+ self.g2 = wx.Gauge(self, -1, 50, (110, 95), (250, 25))
+
+ self.Bind(wx.EVT_TIMER, self.TimerHandler)
+ self.timer = wx.Timer(self)
+ self.timer.Start(100)
+
+ def __del__(self):
+ self.timer.Stop()
+
+ def TimerHandler(self, event):
+ self.count = self.count + 1
+
+ if self.count >= 50:
+ self.count = 0
+
+ self.g1.SetValue(self.count)
+ self.g2.Pulse()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+A Gauge is a horizontal or vertical bar which shows a quantity in a graphical
+fashion. It is often used to indicate progress through lengthy tasks, such as
+file copying or data analysis.
+
+When the Gauge is initialized, it's "complete" value is usually set; at any rate,
+before using the Gauge, the maximum value of the control must be set. As the task
+progresses, the Gauge is updated by the program via the SetValue method.
+
+This control is for use within a GUI; there is a seperate ProgressDialog class
+to present the same sort of control as a dialog to the user.
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/GenericButtons.py b/demo/GenericButtons.py
new file mode 100644
index 00000000..ff0ba020
--- /dev/null
+++ b/demo/GenericButtons.py
@@ -0,0 +1,184 @@
+
+import wx
+import wx.lib.buttons as buttons
+
+import images
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+ ##self.SetBackgroundColour("sky blue")
+
+ sizer = wx.FlexGridSizer(cols=3, hgap=20, vgap=20)
+
+ # A regular button, selected as the default button
+ b = wx.Button(self, -1, "A real button")
+ b.SetDefault()
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ sizer.Add(b)
+
+ # Same thing, but NOT set as the default button
+ b = wx.Button(self, -1, "non-default")
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ sizer.Add(b)
+ sizer.Add((10,10))
+
+ # Plain old text button based off GenButton()
+ b = buttons.GenButton(self, -1, 'Hello')
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ sizer.Add(b)
+
+ # Plain old text button, disabled.
+ b = buttons.GenButton(self, -1, 'disabled')
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ b.Enable(False)
+ sizer.Add(b)
+
+ # This time, we let the botton be as big as it can be.
+ # Also, this one is fancier, with custom colors and bezel size.
+ b = buttons.GenButton(self, -1, 'bigger')
+ self.Bind(wx.EVT_BUTTON, self.OnBiggerButton, b)
+ b.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
+ b.SetBezelWidth(5)
+ b.SetMinSize(wx.DefaultSize)
+ b.SetBackgroundColour("Navy")
+ b.SetForegroundColour(wx.WHITE)
+ b.SetToolTipString("This is a BIG button...")
+ # let the sizer set best size
+ sizer.Add(b, flag=wx.ADJUST_MINSIZE)
+
+ # An image button
+ bmp = images.Test2.GetBitmap()
+ b = buttons.GenBitmapButton(self, -1, bmp)
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ sizer.Add(b)
+
+ # An image button, disabled.
+ bmp = images.Test2.GetBitmap()
+ b = buttons.GenBitmapButton(self, -1, bmp)
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ sizer.Add(b)
+ b.Enable(False)
+
+ # An image button, using a mask to get rid of the
+ # undesireable part of the image
+ b = buttons.GenBitmapButton(self, -1, None)
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ bmp = images.Bulb1.GetBitmap()
+ mask = wx.Mask(bmp, wx.BLUE)
+ bmp.SetMask(mask)
+ b.SetBitmapLabel(bmp)
+ bmp = images.Bulb2.GetBitmap()
+ mask = wx.Mask(bmp, wx.BLUE)
+ bmp.SetMask(mask)
+ b.SetBitmapSelected(bmp)
+ b.SetInitialSize()
+ sizer.Add(b)
+
+ # A toggle button
+ b = buttons.GenToggleButton(self, -1, "Toggle Button")
+ self.Bind(wx.EVT_BUTTON, self.OnToggleButton, b)
+ sizer.Add(b)
+
+ # An image toggle button
+ b = buttons.GenBitmapToggleButton(self, -1, None)
+ self.Bind(wx.EVT_BUTTON, self.OnToggleButton, b)
+ bmp = images.Bulb1.GetBitmap()
+ mask = wx.Mask(bmp, wx.BLUE)
+ bmp.SetMask(mask)
+ b.SetBitmapLabel(bmp)
+ bmp = images.Bulb2.GetBitmap()
+ mask = wx.Mask(bmp, wx.BLUE)
+ bmp.SetMask(mask)
+ b.SetBitmapSelected(bmp)
+ b.SetToggle(True)
+ b.SetInitialSize()
+ sizer.Add(b)
+
+ # A bitmap button with text.
+ b = buttons.GenBitmapTextButton(self, -1, None, "Bitmapped Text", size = (200, 45))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ bmp = images.Bulb1.GetBitmap()
+ mask = wx.Mask(bmp, wx.BLUE)
+ bmp.SetMask(mask)
+ b.SetBitmapLabel(bmp)
+ bmp = images.Bulb2.GetBitmap()
+ mask = wx.Mask(bmp, wx.BLUE)
+ bmp.SetMask(mask)
+ b.SetBitmapSelected(bmp)
+ b.SetUseFocusIndicator(False)
+ b.SetInitialSize()
+ sizer.Add(b)
+
+
+ # a flat text button
+ b = buttons.GenButton(self, -1, 'Flat buttons too!', style=wx.BORDER_NONE)
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ sizer.Add(b, flag=wx.ALIGN_CENTER_VERTICAL)
+
+ # A flat image button
+ bmp = images.Test2.GetBitmap()
+ bmp.SetMaskColour("blue")
+ b = buttons.GenBitmapButton(self, -1, bmp, style=wx.BORDER_NONE)
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ sizer.Add(b)
+ ##b.SetBackgroundColour("sky blue")
+ ##b.SetBackgroundColour("pink")
+
+ vbox = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(vbox)
+
+ b = buttons.ThemedGenButton(self, -1, 'Drawn with native renderer')
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ vbox.Add(b, 0, wx.ALL, 5)
+
+ b = buttons.ThemedGenToggleButton(self, -1, 'native renderered toggle')
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ vbox.Add(b, 0, wx.ALL, 5)
+
+
+
+ border = wx.BoxSizer(wx.VERTICAL)
+ border.Add(sizer, 0, wx.ALL, 25)
+ self.SetSizer(border)
+
+
+ def OnButton(self, event):
+ self.log.WriteText("Button Clicked: %d\n" % event.GetId())
+
+
+ def OnBiggerButton(self, event):
+ self.log.WriteText("Bigger Button Clicked: %d\n" % event.GetId())
+ b = event.GetEventObject()
+ txt = "big " + b.GetLabel()
+ b.SetLabel(txt)
+ self.GetSizer().Layout()
+
+
+ def OnToggleButton(self, event):
+ msg = (event.GetIsDown() and "on") or "off"
+ self.log.WriteText("Button %d Toggled: %s\n" % (event.GetId(), msg))
+
+
+
+#----------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#----------------------------------------------------------------------
+
+
+overview = buttons.__doc__
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/GenericDirCtrl.py b/demo/GenericDirCtrl.py
new file mode 100644
index 00000000..409abb15
--- /dev/null
+++ b/demo/GenericDirCtrl.py
@@ -0,0 +1,69 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ txt1 = wx.StaticText(self, -1, "style=0")
+ dir1 = wx.GenericDirCtrl(self, -1, size=(200,225), style=0)
+
+ txt2 = wx.StaticText(self, -1, "wx.DIRCTRL_DIR_ONLY")
+ dir2 = wx.GenericDirCtrl(self, -1, size=(200,225), style=wx.DIRCTRL_DIR_ONLY|wx.DIRCTRL_MULTIPLE)
+
+ txt3 = wx.StaticText(self, -1, "wx.DIRCTRL_SHOW_FILTERS")
+ dir3 = wx.GenericDirCtrl(self, -1, size=(200,225), style=wx.DIRCTRL_SHOW_FILTERS,
+ filter="All files (*.*)|*.*|Python files (*.py)|*.py")
+
+ sz = wx.FlexGridSizer(cols=3, hgap=5, vgap=5)
+ sz.Add((35, 35)) # some space above
+ sz.Add((35, 35))
+ sz.Add((35, 35))
+
+ sz.Add(txt1)
+ sz.Add(txt2)
+ sz.Add(txt3)
+
+ sz.Add(dir1, 0, wx.EXPAND)
+ sz.Add(dir2, 0, wx.EXPAND)
+ sz.Add(dir3, 0, wx.EXPAND)
+
+ sz.Add((35,35)) # some space below
+
+ sz.AddGrowableRow(2)
+ sz.AddGrowableCol(0)
+ sz.AddGrowableCol(1)
+ sz.AddGrowableCol(2)
+
+ self.SetSizer(sz)
+ self.SetAutoLayout(True)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+This control can be used to place a directory listing (with optional files)
+on an arbitrary window. The control contains a TreeCtrl window representing
+the directory hierarchy, and optionally, a Choice window containing a list
+of filters.
+
+The filters work in the same manner as in FileDialog.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/GetMouseState.py b/demo/GetMouseState.py
new file mode 100644
index 00000000..836650be
--- /dev/null
+++ b/demo/GetMouseState.py
@@ -0,0 +1,158 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class StaticText(wx.StaticText):
+ """
+ A StaticText that only updates the label if it has changed, to
+ help reduce potential flicker since these controls would be
+ updated very frequently otherwise.
+ """
+ def SetLabel(self, label):
+ if label <> self.GetLabel():
+ wx.StaticText.SetLabel(self, label)
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ self.SetSizer(sizer)
+ sizer.Add((25,25))
+ sizer.Add(wx.StaticText(
+ self, -1,
+ "Mouse and modifier state can be polled with wx.GetMouseState"),
+ 0, wx.CENTER|wx.ALL, 10)
+ sizer.Add(wx.StaticLine(self), 0, wx.EXPAND|wx.TOP, 10)
+
+ row = wx.BoxSizer(wx.HORIZONTAL)
+ sizer.Add(row, 0, wx.CENTER)
+
+ fgs = wx.FlexGridSizer(cols=2, hgap=5, vgap=10)
+ row.Add(fgs, 0, wx.ALL, 30)
+
+ lbl = StaticText(self, -1, "X pos:")
+ self.x = StaticText(self, -1, "00000")
+ fgs.Add(lbl)
+ fgs.Add(self.x)
+
+ lbl = StaticText(self, -1, "Y pos:")
+ self.y = StaticText(self, -1, "00000")
+ fgs.Add(lbl)
+ fgs.Add(self.y)
+
+
+ lbl = StaticText(self, -1, "Left down:")
+ self.lft = StaticText(self, -1, "False")
+ fgs.Add(lbl)
+ fgs.Add(self.lft)
+
+ lbl = StaticText(self, -1, "Middle down:")
+ self.mid = StaticText(self, -1, "False")
+ fgs.Add(lbl)
+ fgs.Add(self.mid)
+
+ lbl = StaticText(self, -1, "Right down:")
+ self.rgt = StaticText(self, -1, "False")
+ fgs.Add(lbl)
+ fgs.Add(self.rgt)
+
+ lbl = StaticText(self, -1, "AUX1 down:")
+ self.aux1 = StaticText(self, -1, "False")
+ fgs.Add(lbl)
+ fgs.Add(self.aux1)
+
+ lbl = StaticText(self, -1, "AUX2 down:")
+ self.aux2 = StaticText(self, -1, "False")
+ fgs.Add(lbl)
+ fgs.Add(self.aux2)
+
+ fgs = wx.FlexGridSizer(cols=2, hgap=5, vgap=10)
+ row.Add(fgs, 0, wx.ALL, 30)
+
+ lbl = StaticText(self, -1, "Control down:")
+ self.ctrl = StaticText(self, -1, "False")
+ fgs.Add(lbl)
+ fgs.Add(self.ctrl)
+
+ lbl = StaticText(self, -1, "Shift down:")
+ self.shft = StaticText(self, -1, "False")
+ fgs.Add(lbl)
+ fgs.Add(self.shft)
+
+ lbl = StaticText(self, -1, "Alt down:")
+ self.alt = StaticText(self, -1, "False")
+ fgs.Add(lbl)
+ fgs.Add(self.alt)
+
+ lbl = StaticText(self, -1, "Meta down:")
+ self.meta = StaticText(self, -1, "False")
+ fgs.Add(lbl)
+ fgs.Add(self.meta)
+
+ lbl = StaticText(self, -1, "Cmd down:")
+ self.cmd = StaticText(self, -1, "False")
+ fgs.Add(lbl)
+ fgs.Add(self.cmd)
+
+ self.timer = wx.Timer(self)
+ self.Bind(wx.EVT_TIMER, self.OnTimer, self.timer)
+ self.timer.Start(100)
+
+
+ def OnTimer(self, evt):
+ ms = wx.GetMouseState()
+ self.x.SetLabel( str(ms.x) )
+ self.y.SetLabel( str(ms.y) )
+
+ self.lft.SetLabel( str(ms.leftIsDown) )
+ self.mid.SetLabel( str(ms.middleIsDown) )
+ self.rgt.SetLabel( str(ms.rightIsDown) )
+ self.aux1.SetLabel( str(ms.aux1IsDown) )
+ self.aux2.SetLabel( str(ms.aux2IsDown) )
+
+ self.ctrl.SetLabel( str(ms.controlDown) )
+ self.shft.SetLabel( str(ms.shiftDown) )
+ self.alt.SetLabel( str(ms.altDown) )
+ self.meta.SetLabel( str(ms.metaDown) )
+ self.cmd.SetLabel( str(ms.cmdDown) )
+
+
+ def ShutdownDemo(self):
+ self.timer.Stop()
+ del self.timer
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.GetMouseState
+
+The mouse and modifier state can be polled with the wx.GetMouseState
+function. It returns an instance of a wx.MouseState object that
+contains the current position of the mouse pointer in screen
+coordinates, as well as boolean values indicating the up/down status
+of the mouse buttons and the modifier keys.
+
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/GraphicsContext.py b/demo/GraphicsContext.py
new file mode 100644
index 00000000..56a29667
--- /dev/null
+++ b/demo/GraphicsContext.py
@@ -0,0 +1,219 @@
+
+import wx
+import colorsys
+from math import cos, sin, radians
+
+from Main import opj
+
+#----------------------------------------------------------------------
+
+BASE = 80.0 # sizes used in shapes drawn below
+BASE2 = BASE/2
+BASE4 = BASE/4
+
+USE_BUFFER = ('wxMSW' in wx.PlatformInfo) # use buffered drawing on Windows
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ if USE_BUFFER:
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+
+
+ def OnSize(self, evt):
+ # When there is a size event then recreate the buffer to match
+ # the new size of the window.
+ self.InitBuffer()
+ evt.Skip()
+
+
+ def OnPaint(self, evt):
+ if USE_BUFFER:
+ # The buffer already contains our drawing, so no need to
+ # do anything else but create the buffered DC. When this
+ # method exits and dc is collected then the buffer will be
+ # blitted to the paint DC automagically
+ dc = wx.BufferedPaintDC(self, self._buffer)
+ else:
+ # Otherwise we need to draw our content to the paint DC at
+ # this time.
+ dc = wx.PaintDC(self)
+ gc = self.MakeGC(dc)
+ self.Draw(gc)
+
+
+ def InitBuffer(self):
+ sz = self.GetClientSize()
+ sz.width = max(1, sz.width)
+ sz.height = max(1, sz.height)
+ self._buffer = wx.EmptyBitmap(sz.width, sz.height, 32)
+
+ dc = wx.MemoryDC(self._buffer)
+ dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
+ dc.Clear()
+ gc = self.MakeGC(dc)
+ self.Draw(gc)
+
+
+ def MakeGC(self, dc):
+ try:
+ if False:
+ # If you want to force the use of Cairo instead of the
+ # native GraphicsContext backend then create the
+ # context like this. It works on Windows so far, (on
+ # wxGTK the Cairo context is already being used as the
+ # native default.)
+ gcr = wx.GraphicsRenderer.GetCairoRenderer
+ gc = gcr() and gcr().CreateContext(dc)
+ if gc is None:
+ wx.MessageBox("Unable to create Cairo Context.", "Oops")
+ gc = wx.GraphicsContext.Create(dc)
+ else:
+ # Otherwise, creating it this way will use the native
+ # backend, (GDI+ on Windows, CoreGraphics on Mac, or
+ # Cairo on GTK).
+ gc = wx.GraphicsContext.Create(dc)
+
+ except NotImplementedError:
+ dc.DrawText("This build of wxPython does not support the wx.GraphicsContext "
+ "family of classes.",
+ 25, 25)
+ return None
+ return gc
+
+
+ def Draw(self, gc):
+ font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
+ font.SetWeight(wx.BOLD)
+ gc.SetFont(font)
+
+ # make a path that contains a circle and some lines, centered at 0,0
+ path = gc.CreatePath()
+ path.AddCircle(0, 0, BASE2)
+ path.MoveToPoint(0, -BASE2)
+ path.AddLineToPoint(0, BASE2)
+ path.MoveToPoint(-BASE2, 0)
+ path.AddLineToPoint(BASE2, 0)
+ path.CloseSubpath()
+ path.AddRectangle(-BASE4, -BASE4/2, BASE2, BASE4)
+
+
+ # Now use that path to demonstrate various capbilites of the grpahics context
+ gc.PushState() # save current translation/scale/other state
+ gc.Translate(60, 75) # reposition the context origin
+
+ gc.SetPen(wx.Pen("navy", 1))
+ gc.SetBrush(wx.Brush("pink"))
+
+ # show the difference between stroking, filling and drawing
+ for label, PathFunc in [("StrokePath", gc.StrokePath),
+ ("FillPath", gc.FillPath),
+ ("DrawPath", gc.DrawPath)]:
+ w, h = gc.GetTextExtent(label)
+
+ gc.DrawText(label, -w/2, -BASE2-h-4)
+ PathFunc(path)
+ gc.Translate(2*BASE, 0)
+
+
+ gc.PopState() # restore saved state
+ gc.PushState() # save it again
+ gc.Translate(60, 200) # offset to the lower part of the window
+
+ gc.DrawText("Scale", 0, -BASE2)
+ gc.Translate(0, 20)
+
+ # for testing clipping
+ #gc.Clip(0, 0, 100, 100)
+ #rgn = wx.RegionFromPoints([ (0,0), (75,0), (75,25,), (100, 25),
+ # (100,100), (0,100), (0,0) ])
+ #gc.ClipRegion(rgn)
+ #gc.ResetClip()
+
+ gc.SetBrush(wx.Brush(wx.Colour(178, 34, 34, 128))) # 128 == half transparent
+ for cnt in range(8):
+ gc.Scale(1.08, 1.08) # increase scale by 8%
+ gc.Translate(5,5)
+ gc.DrawPath(path)
+
+
+ gc.PopState() # restore saved state
+ gc.PushState() # save it again
+ gc.Translate(400, 200)
+ gc.DrawText("Rotate", 0, -BASE2)
+
+ # Move the origin over to the next location
+ gc.Translate(0, 75)
+
+ # draw our path again, rotating it about the central point,
+ # and changing colors as we go
+ for angle in range(0, 360, 30):
+ gc.PushState() # save this new current state so we can
+ # pop back to it at the end of the loop
+ r, g, b = [int(c * 255) for c in colorsys.hsv_to_rgb(float(angle)/360, 1, 1)]
+ gc.SetBrush(wx.Brush(wx.Colour(r, g, b, 64)))
+ gc.SetPen(wx.Pen(wx.Colour(r, g, b, 128)))
+
+ # use translate to artfully reposition each drawn path
+ gc.Translate(1.5 * BASE2 * cos(radians(angle)),
+ 1.5 * BASE2 * sin(radians(angle)))
+
+ # use Rotate to rotate the path
+ gc.Rotate(radians(angle))
+
+ # now draw it
+ gc.DrawPath(path)
+ gc.PopState()
+
+ # Draw a bitmap with an alpha channel on top of the last group
+ bmp = wx.Bitmap(opj('bitmaps/toucan.png'))
+ bsz = bmp.GetSize()
+ gc.DrawBitmap(bmp,
+ #-bsz.width,
+ #-bsz.height/2,
+
+ -bsz.width/2.5,
+ -bsz.height/2.5,
+
+ bsz.width, bsz.height)
+
+
+ gc.PopState()
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.GraphicsContext and wx.GraphicsPath
+
+The new advanced 2D drawing API is implemented via the
+wx.GraphicsContext and wx.GraphicsPath classes. They wrap GDI+ on
+Windows, Cairo on wxGTK and CoreGraphics on OS X. They allow
+path-based drawing with alpha-blending and anti-aliasing, and use a
+floating point cooridnate system.
+
+
When viewing this sample pay attention to how the rounded edges are
+smoothed with anti-aliased drawing, and how the shapes on the lower
+half of the window are partially transparent, allowing you to see what
+was drawn before.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/GraphicsGradient.py b/demo/GraphicsGradient.py
new file mode 100644
index 00000000..f53acf67
--- /dev/null
+++ b/demo/GraphicsGradient.py
@@ -0,0 +1,265 @@
+
+import wx
+g = wx
+
+# To test compatibility of gradients with the generic GraphicsContext classes
+# uncomment this line
+#import wx.lib.graphics as g
+
+#----------------------------------------------------------------------
+
+class GradientPanel(wx.Panel):
+ """
+ This panel will be painted with the gradient brush created by the
+ rest of the sample.
+ """
+ def __init__(self, parent):
+ wx.Panel.__init__(self, parent, -1)
+ self.SetBackgroundStyle(wx.BG_STYLE_PAINT)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ self.SetInitialSize((600,100))
+
+ # create a simple default brush we can use until a gradient
+ # brush is given to us
+ ctx = g.GraphicsContext.CreateMeasuringContext()
+ self.brush = ctx.CreateBrush(wx.Brush('white'))
+
+ def DrawWithBrush(self, brush):
+ self.brush = brush
+ self.Refresh()
+
+ def OnPaint(self, evt):
+ dc = wx.PaintDC(self)
+ gc = g.GraphicsContext.Create(dc)
+ gc.SetBrush(self.brush)
+ gc.SetPen(wx.Pen('black', 1))
+ w, h = gc.GetSize()
+ gc.DrawRectangle(0,0,w,h)
+
+
+
+class GradientStopPanel(wx.Panel):
+ """
+ Contains the controls for editing each gradient stop. (Colour,
+ alpha and relative position.)
+ """
+ def __init__(self, parent, posVal, colour=wx.BLACK, alpha=wx.ALPHA_OPAQUE):
+ wx.Panel.__init__(self, parent)
+
+ # make some widgets
+ self.pos = wx.SpinCtrlDouble(self, value='%2f' % posVal, size=(65,-1),
+ min=0.0, max=1.0, initial=posVal, inc=0.01)
+ self.pos.SetToolTipString(
+ "A value between 0 and 1 representing the distance between (x1,y1) "
+ "and (x2,y2) for this gradient stop.")
+ self.colour = wx.ColourPickerCtrl(self, col=colour)
+ self.colour.SetToolTipString("The colour for this gradient stop")
+ self.minusBtn = wx.Button(self, -1, " - ", style=wx.BU_EXACTFIT)
+ self.minusBtn.SetToolTipString("Remove this gradient stop")
+
+ # put them in a sizer
+ sizer = wx.BoxSizer(wx.HORIZONTAL)
+ sizer.Add(self.pos, 0, wx.ALIGN_CENTER_VERTICAL)
+ sizer.Add(self.colour, 0, wx.ALIGN_CENTER_VERTICAL|wx.LEFT, 10)
+ sizer.Add(self.minusBtn, 0, wx.ALIGN_CENTER_VERTICAL|wx.LEFT, 25)
+ border = wx.BoxSizer()
+ border.Add(sizer, 1, wx.EXPAND|wx.ALL, 4)
+ self.SetSizer(border)
+
+ self.Bind(wx.EVT_BUTTON, self.OnMinusButton, self.minusBtn)
+
+
+ def OnMinusButton(self, evt):
+ wx.CallAfter(self.Parent.RemoveStop, self)
+
+
+
+class TestPanel(wx.Panel):
+ """
+ The main panel for this sample
+ """
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ # make the panel that will display the gradient
+ self.gpanel = GradientPanel(self)
+
+ # and the other widgets for collecting data about the gradient
+ label1 = wx.StaticText(self, -1, "Geometry")
+ label1.SetFont(wx.FFont(15, wx.SWISS, wx.FONTFLAG_BOLD))
+ x1 = 0
+ x2 = self.gpanel.Size.width
+ y0 = self.gpanel.Size.height / 2
+ self.x1 = wx.TextCtrl(self, value=str(x1), size=(50,-1))
+ self.y1 = wx.TextCtrl(self, value=str(y0), size=(50,-1))
+ self.x2 = wx.TextCtrl(self, value=str(x2), size=(50,-1))
+ self.y2 = wx.TextCtrl(self, value=str(y0), size=(50,-1))
+
+ label2 = wx.StaticText(self, -1, "Stops")
+ label2.SetFont(wx.FFont(15, wx.SWISS, wx.FONTFLAG_BOLD))
+ firstStop = GradientStopPanel(self, 0.0)
+ lastStop = GradientStopPanel(self, 1.0, wx.WHITE)
+ self.stops = [firstStop, lastStop]
+ addStopBtn = wx.Button(self, -1, " + ", style=wx.BU_EXACTFIT)
+
+
+ # bind some events
+ self.Bind(wx.EVT_BUTTON, self.OnAddStop, addStopBtn)
+ self.Bind(wx.EVT_SPINCTRLDOUBLE, self.OnPositionUpdated)
+ self.Bind(wx.EVT_COLOURPICKER_CHANGED, self.OnColourChanged)
+ self.Bind(wx.EVT_TEXT, self.OnGeometryChanged)
+
+
+ # do the layout
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(self.gpanel)
+ sizer.Add((1,15))
+ sizer.Add(label1)
+ sizer.Add((1, 5))
+
+ fgs = wx.FlexGridSizer(cols=11, hgap=5, vgap=5)
+ fgs.AddMany([ (wx.StaticText(self, -1, "x1:"), 0, wx.ALIGN_CENTER_VERTICAL),
+ self.x1,
+ ((5,1)),
+ (wx.StaticText(self, -1, "y1:"), 0, wx.ALIGN_CENTER_VERTICAL),
+ self.y1] )
+ fgs.Add((40,1))
+ fgs.AddMany([ (wx.StaticText(self, -1, "x2:"), 0, wx.ALIGN_CENTER_VERTICAL),
+ self.x2,
+ ((5,1)),
+ (wx.StaticText(self, -1, "y2:"), 0, wx.ALIGN_CENTER_VERTICAL),
+ self.y2] )
+ sizer.Add(fgs, 0, wx.LEFT, 25)
+
+ sizer.Add((1,15))
+ sizer.Add(label2)
+ sizer.Add((1, 5))
+ self.stopSizer = wx.BoxSizer(wx.VERTICAL)
+ self.stopSizer.Add(firstStop)
+ self.stopSizer.Add(lastStop)
+ self.stopSizer.Add(addStopBtn, 0, wx.TOP, 10)
+ sizer.Add(self.stopSizer, 0, wx.LEFT, 25)
+
+ border = wx.BoxSizer()
+ border.Add(sizer, 1, wx.EXPAND|wx.ALL, 15)
+ self.SetSizer(border)
+
+ self.SetLimits()
+ self.UpdateBrush()
+
+
+ def RemoveStop(self, stop):
+ self.stops.remove(stop)
+ stop.Destroy()
+ self.Layout()
+ self.SetLimits()
+ self.UpdateBrush()
+
+
+ def OnAddStop(self, evt):
+ newstop = GradientStopPanel(self, 1.0)
+ self.stopSizer.Insert(len(self.stops), newstop)
+ self.stops.append(newstop)
+ self.Layout()
+ self.SetLimits()
+ self.UpdateBrush()
+
+
+ def OnPositionUpdated(self, evt):
+ # called when any of the spinctrls in the nested panels are updated
+ self.SetLimits()
+ self.UpdateBrush()
+
+
+ def OnColourChanged(self, evt):
+ # called when any of the color pickers are updated
+ self.UpdateBrush()
+
+ def OnGeometryChanged(self, evt):
+ # called for changes to x1,y1 or x2,y2
+ self.UpdateBrush()
+
+
+ def SetLimits(self):
+ # Tweak the panels in self.stops to set limits on the allowed
+ # positions, and to disable those that should not be changed or
+ # removed.
+ first = self.stops[0]
+ last = self.stops[-1]
+
+ first.pos.Disable()
+ first.minusBtn.Disable()
+ last.pos.Disable()
+ last.minusBtn.Disable()
+
+ for idx in range(1, len(self.stops)-1):
+ prev = self.stops[idx-1]
+ next = self.stops[idx+1]
+ stop = self.stops[idx]
+
+ stop.pos.SetMin(prev.pos.GetValue())
+ stop.pos.SetMax(next.pos.GetValue())
+ stop.pos.Enable()
+ stop.minusBtn.Enable()
+
+
+ def UpdateBrush(self):
+ """
+ This is where the magic happens. We convert all the values from the
+ widgets on this panel into a collection of gradient stops and then
+ create a brush from them, and finally, ask the display panel to
+ repaint itself with that new brush.
+ """
+ def floatOrZero(value):
+ try:
+ return float(value)
+ except ValueError:
+ return 0.0
+
+ x1 = floatOrZero(self.x1.Value)
+ y1 = floatOrZero(self.y1.Value)
+ x2 = floatOrZero(self.x2.Value)
+ y2 = floatOrZero(self.y2.Value)
+
+ gstops = g.GraphicsGradientStops()
+ gstops.SetStartColour(self.stops[0].colour.GetColour())
+ gstops.SetEndColour(self.stops[-1].colour.GetColour())
+ for s in self.stops[1:-1]:
+ gs = g.GraphicsGradientStop(
+ s.colour.GetColour(), s.pos.GetValue())
+ gstops.Add(gs)
+
+ ctx = g.GraphicsContext.CreateMeasuringContext()
+ brush = ctx.CreateLinearGradientBrush(x1,y1, x2,y2, gstops)
+ self.gpanel.DrawWithBrush(brush)
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
Gradients on a GraphicsContext
+
+Multi-stop gradients can be used as fills in a wx.GraphicsContext.
+This sample shows how to use the GraphicsGradientStops class to
+accomplish this and allows the user to experiment with gradients.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Grid.py b/demo/Grid.py
new file mode 100644
index 00000000..98fac36c
--- /dev/null
+++ b/demo/Grid.py
@@ -0,0 +1,96 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+buttonDefs = {
+ 814 : ('GridSimple', ' Simple wx.Grid, catching all events '),
+ 815 : ('GridStdEdRend', ' wx.Grid showing Editors and Renderers '),
+ 818 : ('GridHugeTable', ' A wx.Grid with a HUGE table (100 MILLION cells!) '),
+ 817 : ('GridCustTable', ' wx.Grid using a custom Table, with non-string data '),
+ 819 : ('GridEnterHandler',' Remapping keys to behave differently '),
+ 820 : ('GridCustEditor', ' Shows how to create a custom Cell Editor '),
+ 821 : ('GridDragable', ' A wx.Grid with dragable rows and columns '),
+ 822 : ('GridDragAndDrop', ' Shows how to make a grid a drop target for files'),
+ }
+
+
+class ButtonPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ box = wx.BoxSizer(wx.VERTICAL)
+ box.Add((20, 20))
+ keys = buttonDefs.keys()
+ keys.sort()
+
+ for k in keys:
+ text = buttonDefs[k][1]
+ btn = wx.Button(self, k, text)
+ box.Add(btn, 0, wx.ALIGN_CENTER|wx.ALL, 10)
+ self.Bind(wx.EVT_BUTTON, self.OnButton, btn)
+
+ self.SetSizer(box)
+ box.Fit(self)
+
+
+ def OnButton(self, evt):
+ modName = buttonDefs[evt.GetId()][0]
+ module = __import__(modName)
+ frame = module.TestFrame(None, self.log)
+ frame.Show(True)
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = ButtonPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+
+overview = """\
+
+
wx.grid.Grid
+
+This demo shows various ways of using the wx.grid.Grid class.
+
+You can look at the sources for these samples to learn a lot about how
+the new classes work.
+
+
GridSimple.py A simple grid that shows
+how to catch all the various events.
+
+
+
GridStdEdRend.py A grid that
+uses non-default Cell Editors and Cell Renderers.
+
+
+
GridHugeTable.py A grid that
+uses a non-default Grid Table. This table is read-only and simply
+generates on the fly a unique string for each cell.
+
+
+
GridCustTable.py This grid
+shows how to deal with tables that have non-string data, and how Cell
+Editors and Cell Renderers are automatically chosen based on the data
+type.
+
+
+
GridEnterHandler.pyThis one
+changes how the ENTER key works, moving the current cell left to right
+and wrapping around to the next row when needed.
+
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/GridBagSizer.py b/demo/GridBagSizer.py
new file mode 100644
index 00000000..9ea8df74
--- /dev/null
+++ b/demo/GridBagSizer.py
@@ -0,0 +1,171 @@
+
+import wx # This module uses the new wx namespace
+
+#----------------------------------------------------------------------
+gbsDescription = """\
+The wx.GridBagSizer is similar to the wx.FlexGridSizer except the items are explicitly positioned
+in a virtual cell of the layout grid, and column or row spanning is allowed. For example, this
+static text is positioned at (0,0) and it spans 7 columns.
+"""
+
+
+class TestFrame(wx.Frame):
+ def __init__(self):
+ wx.Frame.__init__(self, None, -1, "wx.GridBagSizer")
+ p = wx.Panel(self, -1, style = wx.TAB_TRAVERSAL
+ | wx.CLIP_CHILDREN
+ | wx.FULL_REPAINT_ON_RESIZE
+ )
+ p.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
+
+ gbs = self.gbs = wx.GridBagSizer(5, 5)
+
+ gbs.Add( wx.StaticText(p, -1, gbsDescription),
+ (0,0), (1,7), wx.ALIGN_CENTER | wx.ALL, 5)
+
+ gbs.Add( wx.TextCtrl(p, -1, "pos(1,0)"), (1,0) )
+ gbs.Add( wx.TextCtrl(p, -1, "pos(1,1)"), (1,1) )
+ gbs.Add( wx.TextCtrl(p, -1, "pos(2,0)"), (2,0) )
+ gbs.Add( wx.TextCtrl(p, -1, "pos(2,1)"), (2,1) )
+
+ gbs.Add( wx.TextCtrl(p, -1, "pos(3,2), span(1,2)\nthis row and col are growable", style=wx.TE_MULTILINE),
+ (3,2), (1,2), flag=wx.EXPAND )
+
+ gbs.Add( wx.TextCtrl(p, -1, "pos(4,3), span(3,1)", style=wx.TE_MULTILINE),
+ (4,3), (3,1), wx.EXPAND)
+
+ gbs.Add( wx.TextCtrl(p, -1, "pos(5,4)"), (5,4), flag=wx.EXPAND )
+ gbs.Add( wx.TextCtrl(p, -1, "pos(6,5)"), (6,5), flag=wx.EXPAND )
+ gbs.Add( wx.TextCtrl(p, -1, "pos(7,6)"), (7,6) )
+
+ moveBtn1 = wx.Button(p, -1, "Move this to (3,6)")
+ moveBtn2 = wx.Button(p, -1, "Move this to (3,6)");
+ gbs.Add( moveBtn1, (10,2) )
+ gbs.Add( moveBtn2, (10,3) )
+
+ hideBtn = wx.Button(p, -1, "Hide this item -->")
+ gbs.Add(hideBtn, (12, 3))
+
+ hideTxt = wx.TextCtrl(p, -1, "pos(12,4), size(150, -1)", size = (150,-1))
+ gbs.Add( hideTxt, (12,4) )
+
+ showBtn = wx.Button(p, -1, "<-- Show it again")
+ gbs.Add(showBtn, (12, 5))
+ showBtn.Disable()
+ self.hideBtn = hideBtn
+ self.showBtn = showBtn
+ self.hideTxt = hideTxt
+
+ self.Bind(wx.EVT_BUTTON, self.OnHideButton, hideBtn)
+ self.Bind(wx.EVT_BUTTON, self.OnShowButton, showBtn)
+ self.Bind(wx.EVT_BUTTON, self.OnMoveButton, moveBtn1)
+ self.Bind(wx.EVT_BUTTON, self.OnMoveButton, moveBtn2)
+
+ # Add a spacer at the end to ensure some extra space at the bottom
+ gbs.Add((10,10), (14,7))
+
+ gbs.AddGrowableRow(3)
+ gbs.AddGrowableCol(2)
+
+ box = wx.BoxSizer()
+ box.Add(gbs, 1, wx.ALL|wx.EXPAND, 10)
+
+ p.SetSizer(box)
+ self.SetClientSize(p.GetBestSize())
+
+
+ def OnHideButton(self, evt):
+ self.gbs.Hide(self.hideTxt)
+ self.hideBtn.Disable()
+ self.showBtn.Enable()
+ self.gbs.Layout()
+
+
+ def OnShowButton(self, evt):
+ self.gbs.Show(self.hideTxt)
+ self.hideBtn.Enable()
+ self.showBtn.Disable()
+ self.gbs.Layout()
+
+
+ def OnMoveButton(self, evt):
+ btn = evt.GetEventObject()
+ curPos = self.gbs.GetItemPosition(btn)
+
+ # if it's already at the "other" spot then move it back
+ if curPos == (3,6):
+ self.gbs.SetItemPosition(btn, self.lastPos)
+ btn.SetLabel("Move this to (3,6)")
+ else:
+ if self.gbs.CheckForIntersectionPos( (3,6), (1,1) ):
+ wx.MessageBox("""\
+wx.GridBagSizer will not allow items to be in the same cell as
+another item, so this operation will fail. You will also get an
+assert when compiled in debug mode.""",
+ "Warning", wx.OK | wx.ICON_INFORMATION)
+
+ try:
+ if self.gbs.SetItemPosition(btn, (3,6)):
+ self.lastPos = curPos
+ btn.SetLabel("Move it back")
+ except wx.PyAssertionError:
+ pass
+
+ self.gbs.Layout()
+
+
+ def OnLeftDown(self, evt):
+ pt = evt.GetPosition()
+ item = self.gbs.FindItemAtPoint(pt)
+ if item is None:
+ print "no item at", `pt`
+ else:
+ print "item found: ", `item.GetPos()`, "--", `item.GetSpan()`
+
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Show the GridBagSizer sample", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ win = TestFrame()
+ win.Show(True)
+
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.GridBagSizer
+
+The wx.GridBagSizer is more or less a port of the the RowColSizer (that
+has been in the wxPython.lib package for quite some time) to C++. It
+allows items to be placed at specific layout grid cells, and items can
+span across more than one row or column.
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/GridCustEditor.py b/demo/GridCustEditor.py
new file mode 100644
index 00000000..22d6e5bc
--- /dev/null
+++ b/demo/GridCustEditor.py
@@ -0,0 +1,243 @@
+
+import string
+
+import wx
+import wx.grid as gridlib
+
+#---------------------------------------------------------------------------
+class MyCellEditor(gridlib.PyGridCellEditor):
+ """
+ This is a sample GridCellEditor that shows you how to make your own custom
+ grid editors. All the methods that can be overridden are shown here. The
+ ones that must be overridden are marked with "*Must Override*" in the
+ docstring.
+ """
+ def __init__(self, log):
+ self.log = log
+ self.log.write("MyCellEditor ctor\n")
+ gridlib.PyGridCellEditor.__init__(self)
+
+
+ def Create(self, parent, id, evtHandler):
+ """
+ Called to create the control, which must derive from wx.Control.
+ *Must Override*
+ """
+ self.log.write("MyCellEditor: Create\n")
+ self._tc = wx.TextCtrl(parent, id, "")
+ self._tc.SetInsertionPoint(0)
+ self.SetControl(self._tc)
+
+ if evtHandler:
+ self._tc.PushEventHandler(evtHandler)
+
+
+ def SetSize(self, rect):
+ """
+ Called to position/size the edit control within the cell rectangle.
+ If you don't fill the cell (the rect) then be sure to override
+ PaintBackground and do something meaningful there.
+ """
+ self.log.write("MyCellEditor: SetSize %s\n" % rect)
+ self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2,
+ wx.SIZE_ALLOW_MINUS_ONE)
+
+
+ def Show(self, show, attr):
+ """
+ Show or hide the edit control. You can use the attr (if not None)
+ to set colours or fonts for the control.
+ """
+ self.log.write("MyCellEditor: Show(self, %s, %s)\n" % (show, attr))
+ super(MyCellEditor, self).Show(show, attr)
+
+
+ def PaintBackground(self, rect, attr):
+ """
+ Draws the part of the cell not occupied by the edit control. The
+ base class version just fills it with background colour from the
+ attribute. In this class the edit control fills the whole cell so
+ don't do anything at all in order to reduce flicker.
+ """
+ self.log.write("MyCellEditor: PaintBackground\n")
+
+
+ def BeginEdit(self, row, col, grid):
+ """
+ Fetch the value from the table and prepare the edit control
+ to begin editing. Set the focus to the edit control.
+ *Must Override*
+ """
+ self.log.write("MyCellEditor: BeginEdit (%d,%d)\n" % (row, col))
+ self.startValue = grid.GetTable().GetValue(row, col)
+ self._tc.SetValue(self.startValue)
+ self._tc.SetInsertionPointEnd()
+ self._tc.SetFocus()
+
+ # For this example, select the text
+ self._tc.SetSelection(0, self._tc.GetLastPosition())
+
+
+ def EndEdit(self, row, col, grid, oldVal):
+ """
+ End editing the cell. This function must check if the current
+ value of the editing control is valid and different from the
+ original value (available as oldval in its string form.) If
+ it has not changed then simply return None, otherwise return
+ the value in its string form.
+ *Must Override*
+ """
+ self.log.write("MyCellEditor: EndEdit (%s)\n" % oldVal)
+ val = self._tc.GetValue()
+ if val != oldVal: #self.startValue:
+ return val
+ else:
+ return None
+
+
+ def ApplyEdit(self, row, col, grid):
+ """
+ This function should save the value of the control into the
+ grid or grid table. It is called only after EndEdit() returns
+ a non-None value.
+ *Must Override*
+ """
+ self.log.write("MyCellEditor: ApplyEdit (%d,%d)\n" % (row, col))
+ val = self._tc.GetValue()
+ grid.GetTable().SetValue(row, col, val) # update the table
+
+ self.startValue = ''
+ self._tc.SetValue('')
+
+
+ def Reset(self):
+ """
+ Reset the value in the control back to its starting value.
+ *Must Override*
+ """
+ self.log.write("MyCellEditor: Reset\n")
+ self._tc.SetValue(self.startValue)
+ self._tc.SetInsertionPointEnd()
+
+
+ def IsAcceptedKey(self, evt):
+ """
+ Return True to allow the given key to start editing: the base class
+ version only checks that the event has no modifiers. F2 is special
+ and will always start the editor.
+ """
+ self.log.write("MyCellEditor: IsAcceptedKey: %d\n" % (evt.GetKeyCode()))
+
+ ## We can ask the base class to do it
+ #return super(MyCellEditor, self).IsAcceptedKey(evt)
+
+ # or do it ourselves
+ return (not (evt.ControlDown() or evt.AltDown()) and
+ evt.GetKeyCode() != wx.WXK_SHIFT)
+
+
+ def StartingKey(self, evt):
+ """
+ If the editor is enabled by pressing keys on the grid, this will be
+ called to let the editor do something about that first key if desired.
+ """
+ self.log.write("MyCellEditor: StartingKey %d\n" % evt.GetKeyCode())
+ key = evt.GetKeyCode()
+ ch = None
+ if key in [ wx.WXK_NUMPAD0, wx.WXK_NUMPAD1, wx.WXK_NUMPAD2, wx.WXK_NUMPAD3,
+ wx.WXK_NUMPAD4, wx.WXK_NUMPAD5, wx.WXK_NUMPAD6, wx.WXK_NUMPAD7,
+ wx.WXK_NUMPAD8, wx.WXK_NUMPAD9
+ ]:
+
+ ch = ch = chr(ord('0') + key - wx.WXK_NUMPAD0)
+
+ elif key < 256 and key >= 0 and chr(key) in string.printable:
+ ch = chr(key)
+
+ if ch is not None:
+ # For this example, replace the text. Normally we would append it.
+ #self._tc.AppendText(ch)
+ self._tc.SetValue(ch)
+ self._tc.SetInsertionPointEnd()
+ else:
+ evt.Skip()
+
+
+ def StartingClick(self):
+ """
+ If the editor is enabled by clicking on the cell, this method will be
+ called to allow the editor to simulate the click on the control if
+ needed.
+ """
+ self.log.write("MyCellEditor: StartingClick\n")
+
+
+ def Destroy(self):
+ """final cleanup"""
+ self.log.write("MyCellEditor: Destroy\n")
+ super(MyCellEditor, self).Destroy()
+
+
+ def Clone(self):
+ """
+ Create a new object which is the copy of this one
+ *Must Override*
+ """
+ self.log.write("MyCellEditor: Clone\n")
+ return MyCellEditor(self.log)
+
+
+#---------------------------------------------------------------------------
+class GridEditorTest(gridlib.Grid):
+ def __init__(self, parent, log):
+ gridlib.Grid.__init__(self, parent, -1)
+ self.log = log
+
+ self.CreateGrid(10, 3)
+
+ # Somebody changed the grid so the type registry takes precedence
+ # over the default attribute set for editors and renderers, so we
+ # have to set null handlers for the type registry before the
+ # default editor will get used otherwise...
+ #self.RegisterDataType(wxGRID_VALUE_STRING, None, None)
+ #self.SetDefaultEditor(MyCellEditor(self.log))
+
+ # Or we could just do it like this:
+ #self.RegisterDataType(wx.GRID_VALUE_STRING,
+ # wx.GridCellStringRenderer(),
+ # MyCellEditor(self.log))
+ # )
+
+ # but for this example, we'll just set the custom editor on one cell
+ self.SetCellEditor(1, 0, MyCellEditor(self.log))
+ self.SetCellValue(1, 0, "Try to edit this box")
+
+ # and on a column
+ attr = gridlib.GridCellAttr()
+ attr.SetEditor(MyCellEditor(self.log))
+ self.SetColAttr(2, attr)
+ self.SetCellValue(1, 2, "or any in this column")
+
+ self.SetColSize(0, 150)
+ self.SetColSize(1, 150)
+ self.SetColSize(2, 150)
+
+
+#---------------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(self, parent, -1, "Custom Grid Cell Editor Test",
+ size=(640,480))
+ grid = GridEditorTest(self, log)
+
+#---------------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys
+ app = wx.PySimpleApp()
+ frame = TestFrame(None, sys.stdout)
+ frame.Show(True)
+ app.MainLoop()
+
+
diff --git a/demo/GridCustTable.py b/demo/GridCustTable.py
new file mode 100644
index 00000000..17ec48d2
--- /dev/null
+++ b/demo/GridCustTable.py
@@ -0,0 +1,173 @@
+
+import wx
+import wx.grid as gridlib
+
+#---------------------------------------------------------------------------
+
+class CustomDataTable(gridlib.PyGridTableBase):
+ def __init__(self, log):
+ gridlib.PyGridTableBase.__init__(self)
+ self.log = log
+
+ self.colLabels = ['ID', 'Description', 'Severity', 'Priority', 'Platform',
+ 'Opened?', 'Fixed?', 'Tested?', 'TestFloat']
+
+ self.dataTypes = [gridlib.GRID_VALUE_NUMBER,
+ gridlib.GRID_VALUE_STRING,
+ gridlib.GRID_VALUE_CHOICE + ':only in a million years!,wish list,minor,normal,major,critical',
+ gridlib.GRID_VALUE_NUMBER + ':1,5',
+ gridlib.GRID_VALUE_CHOICE + ':all,MSW,GTK,other',
+ gridlib.GRID_VALUE_BOOL,
+ gridlib.GRID_VALUE_BOOL,
+ gridlib.GRID_VALUE_BOOL,
+ gridlib.GRID_VALUE_FLOAT + ':6,2',
+ ]
+
+ self.data = [
+ [1010, "The foo doesn't bar", "major", 1, 'MSW', 1, 1, 1, 1.12],
+ [1011, "I've got a wicket in my wocket", "wish list", 2, 'other', 0, 0, 0, 1.50],
+ [1012, "Rectangle() returns a triangle", "critical", 5, 'all', 0, 0, 0, 1.56]
+
+ ]
+
+
+ #--------------------------------------------------
+ # required methods for the wxPyGridTableBase interface
+
+ def GetNumberRows(self):
+ return len(self.data) + 1
+
+ def GetNumberCols(self):
+ return len(self.data[0])
+
+ def IsEmptyCell(self, row, col):
+ try:
+ return not self.data[row][col]
+ except IndexError:
+ return True
+
+ # Get/Set values in the table. The Python version of these
+ # methods can handle any data-type, (as long as the Editor and
+ # Renderer understands the type too,) not just strings as in the
+ # C++ version.
+ def GetValue(self, row, col):
+ try:
+ return self.data[row][col]
+ except IndexError:
+ return ''
+
+ def SetValue(self, row, col, value):
+ def innerSetValue(row, col, value):
+ try:
+ self.data[row][col] = value
+ except IndexError:
+ # add a new row
+ self.data.append([''] * self.GetNumberCols())
+ innerSetValue(row, col, value)
+
+ # tell the grid we've added a row
+ msg = gridlib.GridTableMessage(self, # The table
+ gridlib.GRIDTABLE_NOTIFY_ROWS_APPENDED, # what we did to it
+ 1 # how many
+ )
+
+ self.GetView().ProcessTableMessage(msg)
+ innerSetValue(row, col, value)
+
+ #--------------------------------------------------
+ # Some optional methods
+
+ # Called when the grid needs to display labels
+ def GetColLabelValue(self, col):
+ return self.colLabels[col]
+
+ # Called to determine the kind of editor/renderer to use by
+ # default, doesn't necessarily have to be the same type used
+ # natively by the editor/renderer if they know how to convert.
+ def GetTypeName(self, row, col):
+ return self.dataTypes[col]
+
+ # Called to determine how the data can be fetched and stored by the
+ # editor and renderer. This allows you to enforce some type-safety
+ # in the grid.
+ def CanGetValueAs(self, row, col, typeName):
+ colType = self.dataTypes[col].split(':')[0]
+ if typeName == colType:
+ return True
+ else:
+ return False
+
+ def CanSetValueAs(self, row, col, typeName):
+ return self.CanGetValueAs(row, col, typeName)
+
+
+
+
+
+#---------------------------------------------------------------------------
+
+
+
+class CustTableGrid(gridlib.Grid):
+ def __init__(self, parent, log):
+ gridlib.Grid.__init__(self, parent, -1)
+
+ table = CustomDataTable(log)
+
+ # The second parameter means that the grid is to take ownership of the
+ # table and will destroy it when done. Otherwise you would need to keep
+ # a reference to it and call it's Destroy method later.
+ self.SetTable(table, True)
+
+ self.SetRowLabelSize(0)
+ self.SetMargins(0,0)
+ self.AutoSizeColumns(False)
+
+ gridlib.EVT_GRID_CELL_LEFT_DCLICK(self, self.OnLeftDClick)
+
+
+ # I do this because I don't like the default behaviour of not starting the
+ # cell editor on double clicks, but only a second click.
+ def OnLeftDClick(self, evt):
+ if self.CanEnableCellControl():
+ self.EnableCellEditControl()
+
+
+#---------------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, log):
+
+ wx.Frame.__init__(
+ self, parent, -1, "Custom Table, data driven Grid Demo", size=(640,480)
+ )
+
+ p = wx.Panel(self, -1, style=0)
+ grid = CustTableGrid(p, log)
+ b = wx.Button(p, -1, "Another Control...")
+ b.SetDefault()
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+ b.Bind(wx.EVT_SET_FOCUS, self.OnButtonFocus)
+ bs = wx.BoxSizer(wx.VERTICAL)
+ bs.Add(grid, 1, wx.GROW|wx.ALL, 5)
+ bs.Add(b)
+ p.SetSizer(bs)
+
+ def OnButton(self, evt):
+ print "button selected"
+
+ def OnButtonFocus(self, evt):
+ print "button focus"
+
+
+#---------------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys
+ app = wx.PySimpleApp()
+ frame = TestFrame(None, sys.stdout)
+ frame.Show(True)
+ app.MainLoop()
+
+
+#---------------------------------------------------------------------------
diff --git a/demo/GridDragAndDrop.py b/demo/GridDragAndDrop.py
new file mode 100644
index 00000000..f3e0e9c5
--- /dev/null
+++ b/demo/GridDragAndDrop.py
@@ -0,0 +1,99 @@
+
+"""
+Example showing how to make a grid a drop target for files.
+
+"""
+
+import wx
+import wx.grid as gridlib
+
+#---------------------------------------------------------------------------
+# Set VIRTUAL to 1 to use a virtual grid
+VIRTUAL = 1
+#---------------------------------------------------------------------------
+
+class GridFileDropTarget(wx.FileDropTarget):
+ def __init__(self, grid):
+ wx.FileDropTarget.__init__(self)
+ self.grid = grid
+
+ def OnDropFiles(self, x, y, filenames):
+ # the x,y coordinates here are Unscrolled coordinates. They must be changed
+ # to scrolled coordinates.
+ x, y = self.grid.CalcUnscrolledPosition(x, y)
+
+ # now we need to get the row and column from the grid
+ col = self.grid.XToCol(x)
+ row = self.grid.YToRow(y)
+
+ if row > -1 and col > -1:
+ self.grid.SetCellValue(row, col, filenames[0])
+ self.grid.AutoSizeColumn(col)
+ self.grid.Refresh()
+
+
+
+class FooTable(gridlib.PyGridTableBase):
+ def __init__(self):
+ gridlib.PyGridTableBase.__init__(self)
+ self.dropTargets = {(0,0):"Drag",
+ (1,0):"A",
+ (2,0):"File",
+ (3,0):"To",
+ (4,0):"A",
+ (5,0):"Cell"}
+ def GetNumberCols(self):
+ return 100
+ def GetNumberRows(self):
+ return 100
+ def GetValue(self, row, col):
+ return self.dropTargets.get((row, col), "")
+
+
+class SimpleGrid(gridlib.Grid):
+ def __init__(self, parent, log):
+ gridlib.Grid.__init__(self, parent, -1)
+ self.log = log
+ self.moveTo = None
+
+ if VIRTUAL:
+ self.table = FooTable()
+ self.SetTable(self.table)
+ else:
+ self.CreateGrid(25, 25)
+
+ # set the drag and drop target
+ dropTarget = GridFileDropTarget(self)
+ self.SetDropTarget(dropTarget)
+ self.EnableDragRowSize()
+ self.EnableDragColSize()
+
+ def SetCellValue(self, row, col, value):
+ if VIRTUAL:
+ self.table.dropTargets[row, col] = value
+ else:
+ gridlib.Grid.SetCellValue(self, row, col, value)
+
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(self, parent, -1, "DragAndDrop Grid", size=(640,480))
+ grid = SimpleGrid(self, log)
+
+
+
+#---------------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys
+ app = wx.PySimpleApp()
+ frame = TestFrame(None, sys.stdout)
+ frame.Show(True)
+ app.MainLoop()
+
+
+#---------------------------------------------------------------------------
+
+
+
+
diff --git a/demo/GridDragable.py b/demo/GridDragable.py
new file mode 100644
index 00000000..8f375b8e
--- /dev/null
+++ b/demo/GridDragable.py
@@ -0,0 +1,205 @@
+
+import wx
+import wx.grid as gridlib
+import wx.lib.gridmovers as gridmovers
+
+#---------------------------------------------------------------------------
+
+class CustomDataTable(gridlib.PyGridTableBase):
+ def __init__(self, log):
+ gridlib.PyGridTableBase.__init__(self)
+ self.log = log
+
+ self.identifiers = ['id','ds','sv','pr','pl','op','fx','ts']
+
+ self.rowLabels = ['Row1','Row2','Row3']
+
+ self.colLabels = {'id':'ID','ds':'Description','sv':'Severity',
+ 'pr':'Priority','pl':'Platform','op':'Opened?',
+ 'fx':'Fixed?','ts':'Tested?'}
+
+ self.data = [{'id':1010,
+ 'ds':"The foo doesn't bar",
+ 'sv':"major",
+ 'pr':1,
+ 'pl':'MSW',
+ 'op':1,
+ 'fx':1,
+ 'ts':1
+ },
+ {'id':1011,
+ 'ds':"I've got a wicket in my wocket",
+ 'sv':"wish list",
+ 'pr':2,
+ 'pl':'other',
+ 'op':0,
+ 'fx':0,
+ 'ts':0
+ },
+ {'id':1012,
+ 'ds':"Rectangle() returns a triangle",
+ 'sv':"critical",
+ 'pr':5,
+ 'pl':'all',
+ 'op':0,
+ 'fx':0,
+ 'ts':0
+ }
+ ]
+
+ #--------------------------------------------------
+ # required methods for the wxPyGridTableBase interface
+
+ def GetNumberRows(self):
+ return len(self.data)
+
+ def GetNumberCols(self):
+ return len(self.identifiers)
+
+ def IsEmptyCell(self, row, col):
+ id = self.identifiers[col]
+ return not self.data[row][id]
+
+ def GetValue(self, row, col):
+ id = self.identifiers[col]
+ return self.data[row][id]
+
+ def SetValue(self, row, col, value):
+ id = self.identifiers[col]
+ self.data[row][id] = value
+
+ #--------------------------------------------------
+ # Some optional methods
+
+ # Called when the grid needs to display column labels
+ def GetColLabelValue(self, col):
+ id = self.identifiers[col]
+ return self.colLabels[id]
+
+ # Called when the grid needs to display row labels
+ def GetRowLabelValue(self,row):
+ return self.rowLabels[row]
+
+ #--------------------------------------------------
+ # Methods added for demo purposes.
+
+ # The physical moving of the cols/rows is left to the implementer.
+ # Because of the dynamic nature of a wxGrid the physical moving of
+ # columns differs from implementation to implementation
+
+ # Move the column
+ def MoveColumn(self,frm,to):
+ grid = self.GetView()
+
+ if grid:
+ # Move the identifiers
+ old = self.identifiers[frm]
+ del self.identifiers[frm]
+
+ if to > frm:
+ self.identifiers.insert(to-1,old)
+ else:
+ self.identifiers.insert(to,old)
+
+ # Notify the grid
+ grid.BeginBatch()
+ msg = gridlib.GridTableMessage(
+ self, gridlib.GRIDTABLE_NOTIFY_COLS_DELETED, frm, 1
+ )
+
+ grid.ProcessTableMessage(msg)
+
+ msg = gridlib.GridTableMessage(
+ self, gridlib.GRIDTABLE_NOTIFY_COLS_INSERTED, to, 1
+ )
+
+ grid.ProcessTableMessage(msg)
+ grid.EndBatch()
+
+ # Move the row
+ def MoveRow(self,frm,to):
+ grid = self.GetView()
+
+ if grid:
+ # Move the rowLabels and data rows
+ oldLabel = self.rowLabels[frm]
+ oldData = self.data[frm]
+ del self.rowLabels[frm]
+ del self.data[frm]
+
+ if to > frm:
+ self.rowLabels.insert(to-1,oldLabel)
+ self.data.insert(to-1,oldData)
+ else:
+ self.rowLabels.insert(to,oldLabel)
+ self.data.insert(to,oldData)
+
+ # Notify the grid
+ grid.BeginBatch()
+
+ msg = gridlib.GridTableMessage(
+ self, gridlib.GRIDTABLE_NOTIFY_ROWS_DELETED, frm, 1
+ )
+
+ grid.ProcessTableMessage(msg)
+
+ msg = gridlib.GridTableMessage(
+ self, gridlib.GRIDTABLE_NOTIFY_ROWS_INSERTED, to, 1
+ )
+
+ grid.ProcessTableMessage(msg)
+ grid.EndBatch()
+
+
+#---------------------------------------------------------------------------
+
+
+class DragableGrid(gridlib.Grid):
+ def __init__(self, parent, log):
+ gridlib.Grid.__init__(self, parent, -1)
+
+ table = CustomDataTable(log)
+
+ # The second parameter means that the grid is to take ownership of the
+ # table and will destroy it when done. Otherwise you would need to keep
+ # a reference to it and call it's Destroy method later.
+ self.SetTable(table, True)
+
+ # Enable Column moving
+ gridmovers.GridColMover(self)
+ self.Bind(gridmovers.EVT_GRID_COL_MOVE, self.OnColMove, self)
+
+ # Enable Row moving
+ gridmovers.GridRowMover(self)
+ self.Bind(gridmovers.EVT_GRID_ROW_MOVE, self.OnRowMove, self)
+
+ # Event method called when a column move needs to take place
+ def OnColMove(self,evt):
+ frm = evt.GetMoveColumn() # Column being moved
+ to = evt.GetBeforeColumn() # Before which column to insert
+ self.GetTable().MoveColumn(frm,to)
+
+ # Event method called when a row move needs to take place
+ def OnRowMove(self,evt):
+ frm = evt.GetMoveRow() # Row being moved
+ to = evt.GetBeforeRow() # Before which row to insert
+ self.GetTable().MoveRow(frm,to)
+
+#---------------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(self, parent, -1, "Custom Table, data driven Grid Demo", size=(640,480))
+ grid = DragableGrid(self, log)
+
+
+#---------------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys
+ app = wx.PySimpleApp()
+ frame = TestFrame(None, sys.stdout)
+ frame.Show(True)
+ app.MainLoop()
+
+#---------------------------------------------------------------------------
diff --git a/demo/GridEnterHandler.py b/demo/GridEnterHandler.py
new file mode 100644
index 00000000..638eac61
--- /dev/null
+++ b/demo/GridEnterHandler.py
@@ -0,0 +1,65 @@
+
+import wx
+import wx.grid as gridlib
+
+#---------------------------------------------------------------------------
+
+class NewEnterHandlingGrid(gridlib.Grid):
+ def __init__(self, parent, log):
+ gridlib.Grid.__init__(self, parent, -1)
+ self.log = log
+
+ self.CreateGrid(20, 6)
+
+ self.SetCellValue(0, 0, "Enter moves to the right")
+ self.SetCellValue(0, 5, "Enter wraps to next row")
+ self.SetColSize(0, 150)
+ self.SetColSize(5, 150)
+
+ self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+
+
+ def OnKeyDown(self, evt):
+ if evt.GetKeyCode() != wx.WXK_RETURN:
+ evt.Skip()
+ return
+
+ if evt.ControlDown(): # the edit control needs this key
+ evt.Skip()
+ return
+
+ self.DisableCellEditControl()
+ success = self.MoveCursorRight(evt.ShiftDown())
+
+ if not success:
+ newRow = self.GetGridCursorRow() + 1
+
+ if newRow < self.GetTable().GetNumberRows():
+ self.SetGridCursor(newRow, 0)
+ self.MakeCellVisible(newRow, 0)
+ else:
+ # this would be a good place to add a new row if your app
+ # needs to do that
+ pass
+
+
+#---------------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(self, parent, -1, "Simple Grid Demo", size=(640,480))
+ grid = NewEnterHandlingGrid(self, log)
+
+
+
+#---------------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys
+ app = wx.PySimpleApp()
+ frame = TestFrame(None, sys.stdout)
+ frame.Show(True)
+ app.MainLoop()
+
+
+#---------------------------------------------------------------------------
diff --git a/demo/GridHugeTable.py b/demo/GridHugeTable.py
new file mode 100644
index 00000000..cd5d2e25
--- /dev/null
+++ b/demo/GridHugeTable.py
@@ -0,0 +1,87 @@
+
+import wx
+import wx.grid as gridlib
+
+#---------------------------------------------------------------------------
+
+class HugeTable(gridlib.PyGridTableBase):
+
+ def __init__(self, log):
+ gridlib.PyGridTableBase.__init__(self)
+ self.log = log
+
+ self.odd=gridlib.GridCellAttr()
+ self.odd.SetBackgroundColour("sky blue")
+ self.even=gridlib.GridCellAttr()
+ self.even.SetBackgroundColour("sea green")
+
+ def GetAttr(self, row, col, kind):
+ attr = [self.even, self.odd][row % 2]
+ attr.IncRef()
+ return attr
+
+
+
+ # This is all it takes to make a custom data table to plug into a
+ # wxGrid. There are many more methods that can be overridden, but
+ # the ones shown below are the required ones. This table simply
+ # provides strings containing the row and column values.
+
+ def GetNumberRows(self):
+ return 10000
+
+ def GetNumberCols(self):
+ return 10000
+
+ def IsEmptyCell(self, row, col):
+ return False
+
+ def GetValue(self, row, col):
+ return str( (row, col) )
+
+ def SetValue(self, row, col, value):
+ self.log.write('SetValue(%d, %d, "%s") ignored.\n' % (row, col, value))
+
+
+#---------------------------------------------------------------------------
+
+
+
+class HugeTableGrid(gridlib.Grid):
+ def __init__(self, parent, log):
+ gridlib.Grid.__init__(self, parent, -1)
+
+ table = HugeTable(log)
+
+ # The second parameter means that the grid is to take ownership of the
+ # table and will destroy it when done. Otherwise you would need to keep
+ # a reference to it and call it's Destroy method later.
+ self.SetTable(table, True)
+
+ self.Bind(gridlib.EVT_GRID_CELL_RIGHT_CLICK, self.OnRightDown)
+
+ def OnRightDown(self, event):
+ print "hello"
+ print self.GetSelectedRows()
+
+
+#---------------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(self, parent, -1, "Huge (virtual) Table Demo", size=(640,480))
+ grid = HugeTableGrid(self, log)
+
+ grid.SetReadOnly(5,5, True)
+
+#---------------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys
+ app = wx.PySimpleApp()
+ frame = TestFrame(None, sys.stdout)
+ frame.Show(True)
+ app.MainLoop()
+
+
+#---------------------------------------------------------------------------
diff --git a/demo/GridLabelRenderer.py b/demo/GridLabelRenderer.py
new file mode 100644
index 00000000..7218ecb5
--- /dev/null
+++ b/demo/GridLabelRenderer.py
@@ -0,0 +1,112 @@
+
+import wx
+import wx.grid as grid
+import wx.lib.mixins.gridlabelrenderer as glr
+
+#----------------------------------------------------------------------
+
+class MyGrid(grid.Grid, glr.GridWithLabelRenderersMixin):
+ def __init__(self, *args, **kw):
+ grid.Grid.__init__(self, *args, **kw)
+ glr.GridWithLabelRenderersMixin.__init__(self)
+
+
+class MyRowLabelRenderer(glr.GridLabelRenderer):
+ def __init__(self, bgcolor):
+ self._bgcolor = bgcolor
+
+ def Draw(self, grid, dc, rect, row):
+ dc.SetBrush(wx.Brush(self._bgcolor))
+ dc.SetPen(wx.TRANSPARENT_PEN)
+ dc.DrawRectangleRect(rect)
+ hAlign, vAlign = grid.GetRowLabelAlignment()
+ text = grid.GetRowLabelValue(row)
+ self.DrawBorder(grid, dc, rect)
+ self.DrawText(grid, dc, rect, text, hAlign, vAlign)
+
+
+class MyColLabelRenderer(glr.GridLabelRenderer):
+ def __init__(self, bgcolor):
+ self._bgcolor = bgcolor
+
+ def Draw(self, grid, dc, rect, col):
+ dc.SetBrush(wx.Brush(self._bgcolor))
+ dc.SetPen(wx.TRANSPARENT_PEN)
+ dc.DrawRectangleRect(rect)
+ hAlign, vAlign = grid.GetColLabelAlignment()
+ text = grid.GetColLabelValue(col)
+ self.DrawBorder(grid, dc, rect)
+ self.DrawText(grid, dc, rect, text, hAlign, vAlign)
+
+
+class MyCornerLabelRenderer(glr.GridLabelRenderer):
+ def __init__(self):
+ import images
+ self._bmp = images.Smiles.getBitmap()
+
+ def Draw(self, grid, dc, rect, rc):
+ x = rect.left + (rect.width - self._bmp.GetWidth()) / 2
+ y = rect.top + (rect.height - self._bmp.GetHeight()) / 2
+ dc.DrawBitmap(self._bmp, x, y, True)
+
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ ROWS = 27
+ COLS = 15
+
+ g = MyGrid(self, size=(100,100))
+ g.CreateGrid(ROWS, COLS)
+
+ g.SetCornerLabelRenderer(MyCornerLabelRenderer())
+
+ for row in range(0, ROWS, 3):
+ g.SetRowLabelRenderer(row+0, MyRowLabelRenderer('#ffe0e0'))
+ g.SetRowLabelRenderer(row+1, MyRowLabelRenderer('#e0ffe0'))
+ g.SetRowLabelRenderer(row+2, MyRowLabelRenderer('#e0e0ff'))
+
+ for col in range(0, COLS, 3):
+ g.SetColLabelRenderer(col+0, MyColLabelRenderer('#e0ffe0'))
+ g.SetColLabelRenderer(col+1, MyColLabelRenderer('#e0e0ff'))
+ g.SetColLabelRenderer(col+2, MyColLabelRenderer('#ffe0e0'))
+
+ self.Sizer = wx.BoxSizer()
+ self.Sizer.Add(g, 1, wx.EXPAND)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
GridLabelRenderer
+
+The wx.lib.mixins.gridlabelrenderer module provides a mixin
+class for wx.grid.Grid that enables it to have plugin renderers that
+work like the normal cell renderers do. If desired you can specify a
+different renderer for each row or col label, and even for the little
+corner label in the upper left corner of the grid. When each of those
+labels needs to be drawn the mixin calls the render's Draw method with
+the dc and rectangle, allowing your renderer class do do just about
+anything that it wants.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/GridSimple.py b/demo/GridSimple.py
new file mode 100644
index 00000000..9939748a
--- /dev/null
+++ b/demo/GridSimple.py
@@ -0,0 +1,269 @@
+
+import wx
+import wx.grid as gridlib
+#import wx.lib.mixins.grid as mixins
+
+#---------------------------------------------------------------------------
+
+class SimpleGrid(gridlib.Grid): ##, mixins.GridAutoEditMixin):
+ def __init__(self, parent, log):
+ gridlib.Grid.__init__(self, parent, -1)
+ ##mixins.GridAutoEditMixin.__init__(self)
+ self.log = log
+ self.moveTo = None
+
+ self.Bind(wx.EVT_IDLE, self.OnIdle)
+
+ self.CreateGrid(25, 25)#, gridlib.Grid.SelectRows)
+ ##self.EnableEditing(False)
+
+ # simple cell formatting
+ self.SetColSize(3, 200)
+ self.SetRowSize(4, 45)
+ self.SetCellValue(0, 0, "First cell")
+ self.SetCellValue(1, 1, "Another cell")
+ self.SetCellValue(2, 2, "Yet another cell")
+ self.SetCellValue(3, 3, "This cell is read-only")
+ self.SetCellFont(0, 0, wx.Font(12, wx.ROMAN, wx.ITALIC, wx.NORMAL))
+ self.SetCellTextColour(1, 1, wx.RED)
+ self.SetCellBackgroundColour(2, 2, wx.CYAN)
+ self.SetReadOnly(3, 3, True)
+
+ self.SetCellEditor(5, 0, gridlib.GridCellNumberEditor(1,1000))
+ self.SetCellValue(5, 0, "123")
+ self.SetCellEditor(6, 0, gridlib.GridCellFloatEditor())
+ self.SetCellValue(6, 0, "123.34")
+ self.SetCellEditor(7, 0, gridlib.GridCellNumberEditor())
+
+ self.SetCellValue(6, 3, "You can veto editing this cell")
+
+ #self.SetRowLabelSize(0)
+ #self.SetColLabelSize(0)
+
+ # attribute objects let you keep a set of formatting values
+ # in one spot, and reuse them if needed
+ attr = gridlib.GridCellAttr()
+ attr.SetTextColour(wx.BLACK)
+ attr.SetBackgroundColour(wx.RED)
+ attr.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
+
+ # you can set cell attributes for the whole row (or column)
+ self.SetRowAttr(5, attr)
+
+ self.SetColLabelValue(0, "Custom")
+ self.SetColLabelValue(1, "column")
+ self.SetColLabelValue(2, "labels")
+
+ self.SetColLabelAlignment(wx.ALIGN_LEFT, wx.ALIGN_BOTTOM)
+
+ #self.SetDefaultCellOverflow(False)
+ #r = gridlib.GridCellAutoWrapStringRenderer()
+ #self.SetCellRenderer(9, 1, r)
+
+ # overflow cells
+ self.SetCellValue( 9, 1, "This default cell will overflow into neighboring cells, but not if you turn overflow off.");
+ self.SetCellSize(11, 1, 3, 3);
+ self.SetCellAlignment(11, 1, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE);
+ self.SetCellValue(11, 1, "This cell is set to span 3 rows and 3 columns");
+
+
+ editor = gridlib.GridCellTextEditor()
+ editor.SetParameters('10')
+ self.SetCellEditor(0, 4, editor)
+ self.SetCellValue(0, 4, "Limited text")
+
+ renderer = gridlib.GridCellAutoWrapStringRenderer()
+ self.SetCellRenderer(15,0, renderer)
+ self.SetCellValue(15,0, "The text in this cell will be rendered with word-wrapping")
+
+
+ # test all the events
+ self.Bind(gridlib.EVT_GRID_CELL_LEFT_CLICK, self.OnCellLeftClick)
+ self.Bind(gridlib.EVT_GRID_CELL_RIGHT_CLICK, self.OnCellRightClick)
+ self.Bind(gridlib.EVT_GRID_CELL_LEFT_DCLICK, self.OnCellLeftDClick)
+ self.Bind(gridlib.EVT_GRID_CELL_RIGHT_DCLICK, self.OnCellRightDClick)
+
+ self.Bind(gridlib.EVT_GRID_LABEL_LEFT_CLICK, self.OnLabelLeftClick)
+ self.Bind(gridlib.EVT_GRID_LABEL_RIGHT_CLICK, self.OnLabelRightClick)
+ self.Bind(gridlib.EVT_GRID_LABEL_LEFT_DCLICK, self.OnLabelLeftDClick)
+ self.Bind(gridlib.EVT_GRID_LABEL_RIGHT_DCLICK, self.OnLabelRightDClick)
+
+ self.Bind(gridlib.EVT_GRID_COL_SORT, self.OnGridColSort)
+
+ self.Bind(gridlib.EVT_GRID_ROW_SIZE, self.OnRowSize)
+ self.Bind(gridlib.EVT_GRID_COL_SIZE, self.OnColSize)
+
+ self.Bind(gridlib.EVT_GRID_RANGE_SELECT, self.OnRangeSelect)
+ self.Bind(gridlib.EVT_GRID_CELL_CHANGE, self.OnCellChange)
+ self.Bind(gridlib.EVT_GRID_SELECT_CELL, self.OnSelectCell)
+
+ self.Bind(gridlib.EVT_GRID_EDITOR_SHOWN, self.OnEditorShown)
+ self.Bind(gridlib.EVT_GRID_EDITOR_HIDDEN, self.OnEditorHidden)
+ self.Bind(gridlib.EVT_GRID_EDITOR_CREATED, self.OnEditorCreated)
+
+
+ def OnCellLeftClick(self, evt):
+ self.log.write("OnCellLeftClick: (%d,%d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+ evt.Skip()
+
+ def OnCellRightClick(self, evt):
+ self.log.write("OnCellRightClick: (%d,%d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+ evt.Skip()
+
+ def OnCellLeftDClick(self, evt):
+ self.log.write("OnCellLeftDClick: (%d,%d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+ evt.Skip()
+
+ def OnCellRightDClick(self, evt):
+ self.log.write("OnCellRightDClick: (%d,%d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+ evt.Skip()
+
+ def OnLabelLeftClick(self, evt):
+ self.log.write("OnLabelLeftClick: (%d,%d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+ evt.Skip()
+
+ def OnLabelRightClick(self, evt):
+ self.log.write("OnLabelRightClick: (%d,%d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+ evt.Skip()
+
+ def OnLabelLeftDClick(self, evt):
+ self.log.write("OnLabelLeftDClick: (%d,%d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+ evt.Skip()
+
+ def OnLabelRightDClick(self, evt):
+ self.log.write("OnLabelRightDClick: (%d,%d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+ evt.Skip()
+
+ def OnGridColSort(self, evt):
+ self.log.write("OnGridColSort: %s %s" % (evt.GetCol(), self.GetSortingColumn()))
+ self.SetSortingColumn(evt.GetCol())
+
+ def OnRowSize(self, evt):
+ self.log.write("OnRowSize: row %d, %s\n" %
+ (evt.GetRowOrCol(), evt.GetPosition()))
+ evt.Skip()
+
+ def OnColSize(self, evt):
+ self.log.write("OnColSize: col %d, %s\n" %
+ (evt.GetRowOrCol(), evt.GetPosition()))
+ evt.Skip()
+
+ def OnRangeSelect(self, evt):
+ if evt.Selecting():
+ msg = 'Selected'
+ else:
+ msg = 'Deselected'
+ self.log.write("OnRangeSelect: %s top-left %s, bottom-right %s\n" %
+ (msg, evt.GetTopLeftCoords(), evt.GetBottomRightCoords()))
+ evt.Skip()
+
+
+ def OnCellChange(self, evt):
+ self.log.write("OnCellChange: (%d,%d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+
+ # Show how to stay in a cell that has bad data. We can't just
+ # call SetGridCursor here since we are nested inside one so it
+ # won't have any effect. Instead, set coordinates to move to in
+ # idle time.
+ value = self.GetCellValue(evt.GetRow(), evt.GetCol())
+
+ if value == 'no good':
+ self.moveTo = evt.GetRow(), evt.GetCol()
+
+
+ def OnIdle(self, evt):
+ if self.moveTo != None:
+ self.SetGridCursor(self.moveTo[0], self.moveTo[1])
+ self.moveTo = None
+
+ evt.Skip()
+
+
+ def OnSelectCell(self, evt):
+ if evt.Selecting():
+ msg = 'Selected'
+ else:
+ msg = 'Deselected'
+ self.log.write("OnSelectCell: %s (%d,%d) %s\n" %
+ (msg, evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+
+ # Another way to stay in a cell that has a bad value...
+ row = self.GetGridCursorRow()
+ col = self.GetGridCursorCol()
+
+ if self.IsCellEditControlEnabled():
+ self.HideCellEditControl()
+ self.DisableCellEditControl()
+
+ value = self.GetCellValue(row, col)
+
+ if value == 'no good 2':
+ return # cancels the cell selection
+
+ evt.Skip()
+
+
+ def OnEditorShown(self, evt):
+ if evt.GetRow() == 6 and evt.GetCol() == 3 and \
+ wx.MessageBox("Are you sure you wish to edit this cell?",
+ "Checking", wx.YES_NO) == wx.NO:
+ evt.Veto()
+ return
+
+ self.log.write("OnEditorShown: (%d,%d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+ evt.Skip()
+
+
+ def OnEditorHidden(self, evt):
+ if evt.GetRow() == 6 and evt.GetCol() == 3 and \
+ wx.MessageBox("Are you sure you wish to finish editing this cell?",
+ "Checking", wx.YES_NO) == wx.NO:
+ evt.Veto()
+ return
+
+ self.log.write("OnEditorHidden: (%d,%d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+ evt.Skip()
+
+
+ def OnEditorCreated(self, evt):
+ self.log.write("OnEditorCreated: (%d, %d) %s\n" %
+ (evt.GetRow(), evt.GetCol(), evt.GetControl()))
+
+
+
+#---------------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(self, parent, -1, "Simple Grid Demo", size=(640,480))
+ self.grid = SimpleGrid(self, log)
+
+
+
+#---------------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys
+ from wx.lib.mixins.inspection import InspectableApp
+ app = InspectableApp(False)
+ frame = TestFrame(None, sys.stdout)
+ frame.Show(True)
+ #import wx.lib.inspection
+ #wx.lib.inspection.InspectionTool().Show()
+ app.MainLoop()
+
+
+#---------------------------------------------------------------------------
+
+
diff --git a/demo/GridStdEdRend.py b/demo/GridStdEdRend.py
new file mode 100644
index 00000000..6a89c3e1
--- /dev/null
+++ b/demo/GridStdEdRend.py
@@ -0,0 +1,184 @@
+
+import random
+
+import wx
+import wx.grid as gridlib
+
+#---------------------------------------------------------------------------
+
+class MyCustomRenderer(gridlib.PyGridCellRenderer):
+ def __init__(self):
+ gridlib.PyGridCellRenderer.__init__(self)
+
+ def Draw(self, grid, attr, dc, rect, row, col, isSelected):
+ dc.SetBackgroundMode(wx.SOLID)
+ dc.SetBrush(wx.Brush(wx.BLACK, wx.SOLID))
+ dc.SetPen(wx.TRANSPARENT_PEN)
+ dc.DrawRectangleRect(rect)
+
+ dc.SetBackgroundMode(wx.TRANSPARENT)
+ dc.SetFont(attr.GetFont())
+
+ text = grid.GetCellValue(row, col)
+ colors = ["RED", "WHITE", "SKY BLUE"]
+ x = rect.x + 1
+ y = rect.y + 1
+
+ for ch in text:
+ dc.SetTextForeground(random.choice(colors))
+ dc.DrawText(ch, x, y)
+ w, h = dc.GetTextExtent(ch)
+ x = x + w
+ if x > rect.right - 5:
+ break
+
+
+ def GetBestSize(self, grid, attr, dc, row, col):
+ text = grid.GetCellValue(row, col)
+ dc.SetFont(attr.GetFont())
+ w, h = dc.GetTextExtent(text)
+ return wx.Size(w, h)
+
+
+ def Clone(self):
+ return MyCustomRenderer()
+
+
+#---------------------------------------------------------------------------
+
+rendererDemoData = [
+ ('GridCellStringRenderer\n(the default)', 'this is a text value', gridlib.GridCellStringRenderer, ()),
+ ('GridCellNumberRenderer', '12345', gridlib.GridCellNumberRenderer, ()),
+ ('GridCellFloatRenderer', '1234.5678', gridlib.GridCellFloatRenderer, (6,2)),
+ ('GridCellBoolRenderer', '1', gridlib.GridCellBoolRenderer, ()),
+ ('MyCustomRenderer', 'This is my renderer', MyCustomRenderer, ()),
+ ]
+
+editorDemoData = [
+ ('GridCellTextEditor\n(the default)', 'Here is some more text', gridlib.GridCellTextEditor, ()),
+ ('GridCellNumberEditor\nwith min,max', '101', gridlib.GridCellNumberEditor, (5, 10005)),
+ ('GridCellNumberEditor\nwithout bounds', '101', gridlib.GridCellNumberEditor, ()),
+ ('GridCellFloatEditor', '1234.5678', gridlib.GridCellFloatEditor, ()),
+ ('GridCellBoolEditor', '1', gridlib.GridCellBoolEditor, ()),
+ ('GridCellChoiceEditor', 'one', gridlib.GridCellChoiceEditor, (['one', 'two', 'three', 'four',
+ 'kick', 'Microsoft', 'out the',
+ 'door'], False)),
+ ]
+
+comboDemoData = [
+ ('GridCellNumberRenderer\nGridCellNumberEditor', '20792', gridlib.GridCellNumberRenderer, gridlib.GridCellNumberEditor),
+ ('GridCellBoolRenderer\nGridCellBoolEditor', '1', gridlib.GridCellBoolRenderer, gridlib.GridCellBoolEditor),
+ ]
+
+
+class EditorsAndRenderersGrid(gridlib.Grid):
+ def __init__(self, parent, log):
+ gridlib.Grid.__init__(self, parent, -1)
+ self.log = log
+
+ self.CreateGrid(25, 8)
+ renCol = 1
+ edCol = 4
+
+
+ self.SetCellValue(0, renCol, '''\
+Cell Renderers are used to draw
+the contents of the cell when they
+need to be refreshed. Different
+types of Renderers can be plugged in
+to different cells in the grid, it can
+even be automatically determined based
+on the type of data in the cell.
+''')
+
+ self.SetCellValue(0, edCol, '''\
+Cell Editors are used when the
+value of the cell is edited by
+the user. An editor class is
+wrapped around a an object
+derived from wxControl and it
+implements some methods required
+to integrate with the grid.
+''')
+
+ self.SetCellValue(16, renCol, '''\
+Here are some combinations of Editors and
+Renderers used together.
+''')
+
+ row = 2
+
+ for label, value, renderClass, args in rendererDemoData:
+ renderer = renderClass(*args)
+ self.SetCellValue(row, renCol, label)
+ self.SetCellValue(row, renCol+1, value)
+ self.SetCellRenderer(row, renCol+1, renderer)
+ row = row + 2
+
+
+ row = 2
+
+ for label, value, editorClass, args in editorDemoData:
+ editor = editorClass(*args)
+ self.SetCellValue(row, edCol, label)
+ self.SetCellValue(row, edCol+1, value)
+ self.SetCellEditor(row, edCol+1, editor)
+ row = row + 2
+
+
+ row = 18
+
+ for label, value, renClass, edClass in comboDemoData:
+ self.SetCellValue(row, renCol, label)
+ self.SetCellValue(row, renCol+1, value)
+ editor = edClass()
+ renderer = renClass()
+ self.SetCellEditor(row, renCol+1, editor)
+ self.SetCellRenderer(row, renCol+1, renderer)
+ row = row + 2
+
+ font = self.GetFont()
+ font.SetWeight(wx.BOLD)
+ attr = gridlib.GridCellAttr()
+ attr.SetFont(font)
+ attr.SetBackgroundColour(wx.LIGHT_GREY)
+ attr.SetReadOnly(True)
+ attr.SetAlignment(wx.RIGHT, -1)
+ self.SetColAttr(renCol, attr)
+ attr.IncRef()
+ self.SetColAttr(edCol, attr)
+
+ # There is a bug in wxGTK for this method...
+ self.AutoSizeColumns(True)
+ self.AutoSizeRows(True)
+
+ self.Bind(gridlib.EVT_GRID_CELL_LEFT_DCLICK, self.OnLeftDClick)
+
+
+ # I do this because I don't like the default behaviour of not starting the
+ # cell editor on double clicks, but only a second click.
+ def OnLeftDClick(self, evt):
+ if self.CanEnableCellControl():
+ self.EnableCellEditControl()
+
+
+#---------------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(self, parent, -1, "Editors and Renderers Demo", size=(640,480))
+ grid = EditorsAndRenderersGrid(self, log)
+
+
+
+#---------------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys
+ app = wx.PySimpleApp()
+ frame = TestFrame(None, sys.stdout)
+ frame.Show(True)
+ app.MainLoop()
+
+
+#---------------------------------------------------------------------------
diff --git a/demo/Grid_MegaExample.py b/demo/Grid_MegaExample.py
new file mode 100644
index 00000000..54c02e3a
--- /dev/null
+++ b/demo/Grid_MegaExample.py
@@ -0,0 +1,497 @@
+
+import wx
+import wx.grid as Grid
+
+import images
+
+#---------------------------------------------------------------------------
+
+class MegaTable(Grid.PyGridTableBase):
+ """
+ A custom wx.Grid Table using user supplied data
+ """
+ def __init__(self, data, colnames, plugins):
+ """data is a list of the form
+ [(rowname, dictionary),
+ dictionary.get(colname, None) returns the data for column
+ colname
+ """
+ # The base class must be initialized *first*
+ Grid.PyGridTableBase.__init__(self)
+ self.data = data
+ self.colnames = colnames
+ self.plugins = plugins or {}
+ # XXX
+ # we need to store the row length and column length to
+ # see if the table has changed size
+ self._rows = self.GetNumberRows()
+ self._cols = self.GetNumberCols()
+
+ def GetNumberCols(self):
+ return len(self.colnames)
+
+ def GetNumberRows(self):
+ return len(self.data)
+
+ def GetColLabelValue(self, col):
+ return self.colnames[col]
+
+ def GetRowLabelValue(self, row):
+ return "row %03d" % int(self.data[row][0])
+
+ def GetValue(self, row, col):
+ return str(self.data[row][1].get(self.GetColLabelValue(col), ""))
+
+ def GetRawValue(self, row, col):
+ return self.data[row][1].get(self.GetColLabelValue(col), "")
+
+ def SetValue(self, row, col, value):
+ self.data[row][1][self.GetColLabelValue(col)] = value
+
+ def ResetView(self, grid):
+ """
+ (Grid) -> Reset the grid view. Call this to
+ update the grid if rows and columns have been added or deleted
+ """
+ grid.BeginBatch()
+
+ for current, new, delmsg, addmsg in [
+ (self._rows, self.GetNumberRows(), Grid.GRIDTABLE_NOTIFY_ROWS_DELETED, Grid.GRIDTABLE_NOTIFY_ROWS_APPENDED),
+ (self._cols, self.GetNumberCols(), Grid.GRIDTABLE_NOTIFY_COLS_DELETED, Grid.GRIDTABLE_NOTIFY_COLS_APPENDED),
+ ]:
+
+ if new < current:
+ msg = Grid.GridTableMessage(self,delmsg,new,current-new)
+ grid.ProcessTableMessage(msg)
+ elif new > current:
+ msg = Grid.GridTableMessage(self,addmsg,new-current)
+ grid.ProcessTableMessage(msg)
+ self.UpdateValues(grid)
+
+ grid.EndBatch()
+
+ self._rows = self.GetNumberRows()
+ self._cols = self.GetNumberCols()
+ # update the column rendering plugins
+ self._updateColAttrs(grid)
+
+ # update the scrollbars and the displayed part of the grid
+ grid.AdjustScrollbars()
+ grid.ForceRefresh()
+
+
+ def UpdateValues(self, grid):
+ """Update all displayed values"""
+ # This sends an event to the grid table to update all of the values
+ msg = Grid.GridTableMessage(self, Grid.GRIDTABLE_REQUEST_VIEW_GET_VALUES)
+ grid.ProcessTableMessage(msg)
+
+ def _updateColAttrs(self, grid):
+ """
+ wx.Grid -> update the column attributes to add the
+ appropriate renderer given the column name. (renderers
+ are stored in the self.plugins dictionary)
+
+ Otherwise default to the default renderer.
+ """
+ col = 0
+
+ for colname in self.colnames:
+ attr = Grid.GridCellAttr()
+ if colname in self.plugins:
+ renderer = self.plugins[colname](self)
+
+ if renderer.colSize:
+ grid.SetColSize(col, renderer.colSize)
+
+ if renderer.rowSize:
+ grid.SetDefaultRowSize(renderer.rowSize)
+
+ attr.SetReadOnly(True)
+ attr.SetRenderer(renderer)
+
+ grid.SetColAttr(col, attr)
+ col += 1
+
+ # ------------------------------------------------------
+ # begin the added code to manipulate the table (non wx related)
+ def AppendRow(self, row):
+ #print 'append'
+ entry = {}
+
+ for name in self.colnames:
+ entry[name] = "Appended_%i"%row
+
+ # XXX Hack
+ # entry["A"] can only be between 1..4
+ entry["A"] = random.choice(range(4))
+ self.data.insert(row, ["Append_%i"%row, entry])
+
+ def DeleteCols(self, cols):
+ """
+ cols -> delete the columns from the dataset
+ cols hold the column indices
+ """
+ # we'll cheat here and just remove the name from the
+ # list of column names. The data will remain but
+ # it won't be shown
+ deleteCount = 0
+ cols = cols[:]
+ cols.sort()
+
+ for i in cols:
+ self.colnames.pop(i-deleteCount)
+ # we need to advance the delete count
+ # to make sure we delete the right columns
+ deleteCount += 1
+
+ if not len(self.colnames):
+ self.data = []
+
+ def DeleteRows(self, rows):
+ """
+ rows -> delete the rows from the dataset
+ rows hold the row indices
+ """
+ deleteCount = 0
+ rows = rows[:]
+ rows.sort()
+
+ for i in rows:
+ self.data.pop(i-deleteCount)
+ # we need to advance the delete count
+ # to make sure we delete the right rows
+ deleteCount += 1
+
+ def SortColumn(self, col):
+ """
+ col -> sort the data based on the column indexed by col
+ """
+ name = self.colnames[col]
+ _data = []
+
+ for row in self.data:
+ rowname, entry = row
+ _data.append((entry.get(name, None), row))
+
+ _data.sort()
+ self.data = []
+
+ for sortvalue, row in _data:
+ self.data.append(row)
+
+ # end table manipulation code
+ # ----------------------------------------------------------
+
+
+# --------------------------------------------------------------------
+# Sample wx.Grid renderers
+
+class MegaImageRenderer(Grid.PyGridCellRenderer):
+ def __init__(self, table):
+ """
+ Image Renderer Test. This just places an image in a cell
+ based on the row index. There are N choices and the
+ choice is made by choice[row%N]
+ """
+ Grid.PyGridCellRenderer.__init__(self)
+ self.table = table
+ self._choices = [images.Smiles.GetBitmap,
+ images.Mondrian.GetBitmap,
+ images.WXPdemo.GetBitmap,
+ ]
+
+ self.colSize = None
+ self.rowSize = None
+
+ def Draw(self, grid, attr, dc, rect, row, col, isSelected):
+ choice = self.table.GetRawValue(row, col)
+ bmp = self._choices[ choice % len(self._choices)]()
+ image = wx.MemoryDC()
+ image.SelectObject(bmp)
+
+ # clear the background
+ dc.SetBackgroundMode(wx.SOLID)
+
+ if isSelected:
+ dc.SetBrush(wx.Brush(wx.BLUE, wx.SOLID))
+ dc.SetPen(wx.Pen(wx.BLUE, 1, wx.SOLID))
+ else:
+ dc.SetBrush(wx.Brush(wx.WHITE, wx.SOLID))
+ dc.SetPen(wx.Pen(wx.WHITE, 1, wx.SOLID))
+ dc.DrawRectangleRect(rect)
+
+
+ # copy the image but only to the size of the grid cell
+ width, height = bmp.GetWidth(), bmp.GetHeight()
+
+ if width > rect.width-2:
+ width = rect.width-2
+
+ if height > rect.height-2:
+ height = rect.height-2
+
+ dc.Blit(rect.x+1, rect.y+1, width, height,
+ image,
+ 0, 0, wx.COPY, True)
+
+
+class MegaFontRenderer(Grid.PyGridCellRenderer):
+ def __init__(self, table, color="blue", font="ARIAL", fontsize=8):
+ """Render data in the specified color and font and fontsize"""
+ Grid.PyGridCellRenderer.__init__(self)
+ self.table = table
+ self.color = color
+ self.font = wx.Font(fontsize, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, font)
+ self.selectedBrush = wx.Brush("blue", wx.SOLID)
+ self.normalBrush = wx.Brush(wx.WHITE, wx.SOLID)
+ self.colSize = None
+ self.rowSize = 50
+
+ def Draw(self, grid, attr, dc, rect, row, col, isSelected):
+ # Here we draw text in a grid cell using various fonts
+ # and colors. We have to set the clipping region on
+ # the grid's DC, otherwise the text will spill over
+ # to the next cell
+ dc.SetClippingRect(rect)
+
+ # clear the background
+ dc.SetBackgroundMode(wx.SOLID)
+
+ if isSelected:
+ dc.SetBrush(wx.Brush(wx.BLUE, wx.SOLID))
+ dc.SetPen(wx.Pen(wx.BLUE, 1, wx.SOLID))
+ else:
+ dc.SetBrush(wx.Brush(wx.WHITE, wx.SOLID))
+ dc.SetPen(wx.Pen(wx.WHITE, 1, wx.SOLID))
+ dc.DrawRectangleRect(rect)
+
+ text = self.table.GetValue(row, col)
+ dc.SetBackgroundMode(wx.SOLID)
+
+ # change the text background based on whether the grid is selected
+ # or not
+ if isSelected:
+ dc.SetBrush(self.selectedBrush)
+ dc.SetTextBackground("blue")
+ else:
+ dc.SetBrush(self.normalBrush)
+ dc.SetTextBackground("white")
+
+ dc.SetTextForeground(self.color)
+ dc.SetFont(self.font)
+ dc.DrawText(text, rect.x+1, rect.y+1)
+
+ # Okay, now for the advanced class :)
+ # Let's add three dots "..."
+ # to indicate that that there is more text to be read
+ # when the text is larger than the grid cell
+
+ width, height = dc.GetTextExtent(text)
+
+ if width > rect.width-2:
+ width, height = dc.GetTextExtent("...")
+ x = rect.x+1 + rect.width-2 - width
+ dc.DrawRectangle(x, rect.y+1, width+1, height)
+ dc.DrawText("...", x, rect.y+1)
+
+ dc.DestroyClippingRegion()
+
+
+# --------------------------------------------------------------------
+# Sample Grid using a specialized table and renderers that can
+# be plugged in based on column names
+
+class MegaGrid(Grid.Grid):
+ def __init__(self, parent, data, colnames, plugins=None):
+ """parent, data, colnames, plugins=None
+ Initialize a grid using the data defined in data and colnames
+ (see MegaTable for a description of the data format)
+ plugins is a dictionary of columnName -> column renderers.
+ """
+
+ # The base class must be initialized *first*
+ Grid.Grid.__init__(self, parent, -1)
+ self._table = MegaTable(data, colnames, plugins)
+ self.SetTable(self._table)
+ self._plugins = plugins
+
+ self.Bind(Grid.EVT_GRID_LABEL_RIGHT_CLICK, self.OnLabelRightClicked)
+
+ def Reset(self):
+ """reset the view based on the data in the table. Call
+ this when rows are added or destroyed"""
+ self._table.ResetView(self)
+
+ def OnLabelRightClicked(self, evt):
+ # Did we click on a row or a column?
+ row, col = evt.GetRow(), evt.GetCol()
+ if row == -1: self.colPopup(col, evt)
+ elif col == -1: self.rowPopup(row, evt)
+
+ def rowPopup(self, row, evt):
+ """(row, evt) -> display a popup menu when a row label is right clicked"""
+ appendID = wx.NewId()
+ deleteID = wx.NewId()
+ x = self.GetRowSize(row)/2
+
+ if not self.GetSelectedRows():
+ self.SelectRow(row)
+
+ menu = wx.Menu()
+ xo, yo = evt.GetPosition()
+ menu.Append(appendID, "Append Row")
+ menu.Append(deleteID, "Delete Row(s)")
+
+ def append(event, self=self, row=row):
+ self._table.AppendRow(row)
+ self.Reset()
+
+ def delete(event, self=self, row=row):
+ rows = self.GetSelectedRows()
+ self._table.DeleteRows(rows)
+ self.Reset()
+
+ self.Bind(wx.EVT_MENU, append, id=appendID)
+ self.Bind(wx.EVT_MENU, delete, id=deleteID)
+ self.PopupMenu(menu)
+ menu.Destroy()
+ return
+
+
+ def colPopup(self, col, evt):
+ """(col, evt) -> display a popup menu when a column label is
+ right clicked"""
+ x = self.GetColSize(col)/2
+ menu = wx.Menu()
+ id1 = wx.NewId()
+ sortID = wx.NewId()
+
+ xo, yo = evt.GetPosition()
+ self.SelectCol(col)
+ cols = self.GetSelectedCols()
+ self.Refresh()
+ menu.Append(id1, "Delete Col(s)")
+ menu.Append(sortID, "Sort Column")
+
+ def delete(event, self=self, col=col):
+ cols = self.GetSelectedCols()
+ self._table.DeleteCols(cols)
+ self.Reset()
+
+ def sort(event, self=self, col=col):
+ self._table.SortColumn(col)
+ self.Reset()
+
+ self.Bind(wx.EVT_MENU, delete, id=id1)
+
+ if len(cols) == 1:
+ self.Bind(wx.EVT_MENU, sort, id=sortID)
+
+ self.PopupMenu(menu)
+ menu.Destroy()
+ return
+
+# -----------------------------------------------------------------
+# Test data
+# data is in the form
+# [rowname, dictionary]
+# where dictionary.get(colname, None) -> returns the value for the cell
+#
+# the colname must also be supplied
+import random
+colnames = ["Row", "This", "Is", "A", "Test"]
+
+data = []
+
+for row in range(1000):
+ d = {}
+ for name in ["This", "Test", "Is"]:
+ d[name] = random.random()
+
+ d["Row"] = len(data)
+ # XXX
+ # the "A" column can only be between one and 4
+ d["A"] = random.choice(range(4))
+ data.append((str(row), d))
+
+class MegaFontRendererFactory:
+ def __init__(self, color, font, fontsize):
+ """
+ (color, font, fontsize) -> set of a factory to generate
+ renderers when called.
+ func = MegaFontRenderFactory(color, font, fontsize)
+ renderer = func(table)
+ """
+ self.color = color
+ self.font = font
+ self.fontsize = fontsize
+
+ def __call__(self, table):
+ return MegaFontRenderer(table, self.color, self.font, self.fontsize)
+
+
+#---------------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, plugins={"This":MegaFontRendererFactory("red", "ARIAL", 8),
+ "A":MegaImageRenderer,
+ "Test":MegaFontRendererFactory("orange", "TIMES", 24),}):
+ wx.Frame.__init__(self, parent, -1,
+ "Test Frame", size=(640,480))
+
+ grid = MegaGrid(self, data, colnames, plugins)
+ grid.Reset()
+
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Show the MegaGrid", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ win = TestFrame(self)
+ win.Show(True)
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+
+overview = """Mega Grid Example
+
+This example attempts to show many examples and tricks of
+using a virtual grid object. Hopefully the source isn't too jumbled.
+
+Features:
+
+
Uses a virtual grid
+
Columns and rows have popup menus (right click on labels)
+
Columns and rows can be deleted (i.e. table can be
+ resized)
+
Dynamic renderers. Renderers are plugins based on
+ column header name. Shows a simple Font Renderer and
+ an Image Renderer.
+
+
+Say something nice here
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/HtmlWindow.py b/demo/HtmlWindow.py
new file mode 100644
index 00000000..ec583b6b
--- /dev/null
+++ b/demo/HtmlWindow.py
@@ -0,0 +1,224 @@
+
+import os
+import sys
+
+import wx
+import wx.html as html
+import wx.lib.wxpTag
+
+from Main import opj
+
+#----------------------------------------------------------------------
+
+# This shows how to catch the OnLinkClicked non-event. (It's a virtual
+# method in the C++ code...)
+class MyHtmlWindow(html.HtmlWindow):
+ def __init__(self, parent, id, log):
+ html.HtmlWindow.__init__(self, parent, id, style=wx.NO_FULL_REPAINT_ON_RESIZE)
+ self.log = log
+ if "gtk2" in wx.PlatformInfo:
+ self.SetStandardFonts()
+
+ def OnLinkClicked(self, linkinfo):
+ self.log.WriteText('OnLinkClicked: %s\n' % linkinfo.GetHref())
+ super(MyHtmlWindow, self).OnLinkClicked(linkinfo)
+
+ def OnSetTitle(self, title):
+ self.log.WriteText('OnSetTitle: %s\n' % title)
+ super(MyHtmlWindow, self).OnSetTitle(title)
+
+ def OnCellMouseHover(self, cell, x, y):
+ self.log.WriteText('OnCellMouseHover: %s, (%d %d)\n' % (cell, x, y))
+ super(MyHtmlWindow, self).OnCellMouseHover(cell, x, y)
+
+ def OnCellClicked(self, cell, x, y, evt):
+ self.log.WriteText('OnCellClicked: %s, (%d %d)\n' % (cell, x, y))
+ if isinstance(cell, html.HtmlWordCell):
+ sel = html.HtmlSelection()
+ self.log.WriteText(' %s\n' % cell.ConvertToText(sel))
+ super(MyHtmlWindow, self).OnCellClicked(cell, x, y, evt)
+
+
+
+# This filter doesn't really do anything but show how to use filters
+class MyHtmlFilter(html.HtmlFilter):
+ def __init__(self, log):
+ html.HtmlFilter.__init__(self)
+ self.log = log
+
+ # This method decides if this filter is able to read the file
+ def CanRead(self, fsfile):
+ self.log.write("CanRead: %s\n" % fsfile.GetMimeType())
+ return False
+
+ # If CanRead returns True then this method is called to actually
+ # read the file and return the contents.
+ def ReadFile(self, fsfile):
+ return ""
+
+
+class TestHtmlPanel(wx.Panel):
+ def __init__(self, parent, frame, log):
+ wx.Panel.__init__(self, parent, -1, style=wx.NO_FULL_REPAINT_ON_RESIZE)
+ self.log = log
+ self.frame = frame
+ self.cwd = os.path.split(sys.argv[0])[0]
+
+ if not self.cwd:
+ self.cwd = os.getcwd()
+ if frame:
+ self.titleBase = frame.GetTitle()
+
+ html.HtmlWindow_AddFilter(MyHtmlFilter(log))
+
+ self.html = MyHtmlWindow(self, -1, log)
+ self.html.SetRelatedFrame(frame, self.titleBase + " -- %s")
+ self.html.SetRelatedStatusBar(0)
+
+ self.printer = html.HtmlEasyPrinting()
+
+ self.box = wx.BoxSizer(wx.VERTICAL)
+ self.box.Add(self.html, 1, wx.GROW)
+
+ subbox = wx.BoxSizer(wx.HORIZONTAL)
+
+ btn = wx.Button(self, -1, "Load File")
+ self.Bind(wx.EVT_BUTTON, self.OnLoadFile, btn)
+ subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "Load URL")
+ self.Bind(wx.EVT_BUTTON, self.OnLoadURL, btn)
+ subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "With Widgets")
+ self.Bind(wx.EVT_BUTTON, self.OnWithWidgets, btn)
+ subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "Back")
+ self.Bind(wx.EVT_BUTTON, self.OnBack, btn)
+ subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "Forward")
+ self.Bind(wx.EVT_BUTTON, self.OnForward, btn)
+ subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "Print")
+ self.Bind(wx.EVT_BUTTON, self.OnPrint, btn)
+ subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "View Source")
+ self.Bind(wx.EVT_BUTTON, self.OnViewSource, btn)
+ subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+ self.box.Add(subbox, 0, wx.GROW)
+ self.SetSizer(self.box)
+ self.SetAutoLayout(True)
+
+ # A button with this ID is created on the widget test page.
+ self.Bind(wx.EVT_BUTTON, self.OnOk, id=wx.ID_OK)
+
+ self.OnShowDefault(None)
+
+
+ def ShutdownDemo(self):
+ # put the frame title back
+ if self.frame:
+ self.frame.SetTitle(self.titleBase)
+
+
+ def OnShowDefault(self, event):
+ name = os.path.join(self.cwd, opj('data/test.htm'))
+ self.html.LoadPage(name)
+
+
+ def OnLoadFile(self, event):
+ dlg = wx.FileDialog(self, style=wx.OPEN,
+ wildcard='HTML Files|*.htm;*.html', )
+
+ if dlg.ShowModal():
+ path = dlg.GetPath()
+ self.html.LoadPage(path)
+
+ dlg.Destroy()
+
+
+ def OnLoadURL(self, event):
+ dlg = wx.TextEntryDialog(self, "Enter a URL")
+
+ if dlg.ShowModal():
+ url = dlg.GetValue()
+ self.html.LoadPage(url)
+
+ dlg.Destroy()
+
+
+ def OnWithWidgets(self, event):
+ os.chdir(self.cwd)
+ name = os.path.join(self.cwd, opj('data/widgetTest.htm'))
+ self.html.LoadPage(name)
+
+
+ def OnOk(self, event):
+ self.log.WriteText("It works!\n")
+
+ def OnBack(self, event):
+ if not self.html.HistoryBack():
+ wx.MessageBox("No more items in history!")
+
+
+ def OnForward(self, event):
+ if not self.html.HistoryForward():
+ wx.MessageBox("No more items in history!")
+
+
+ def OnViewSource(self, event):
+ import wx.lib.dialogs
+
+ source = self.html.GetParser().GetSource()
+
+ dlg = wx.lib.dialogs.ScrolledMessageDialog(self, source, 'HTML Source')
+ dlg.ShowModal()
+ dlg.Destroy()
+
+
+ def OnPrint(self, event):
+ self.printer.GetPrintData().SetPaperId(wx.PAPER_LETTER)
+ self.printer.PrintFile(self.html.GetOpenedPage())
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestHtmlPanel(nb, frame, log)
+ return win
+
+
+#----------------------------------------------------------------------
+
+
+overview = """
+
wx.HtmlWindow
+
+
wx.HtmlWindow is capable of parsing and rendering most
+simple HTML tags.
+
+
It is not intended to be a high-end HTML browser. If you're
+looking for something like that see the IEHtmlWin class, which
+wraps the core MSIE HTML viewer.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
+
+
+
+
+
+
diff --git a/demo/I18N.py b/demo/I18N.py
new file mode 100644
index 00000000..e35f483a
--- /dev/null
+++ b/demo/I18N.py
@@ -0,0 +1,234 @@
+#Boa:FramePanel:LanguageSelectPanel
+import os, sys
+import wx
+from wx.lib import langlistctrl
+from Main import opj
+
+
+# Normally you would just set _ to be a reference to the
+# wx.GetTranslation function, and then wrap all you literal strings in
+# _() function calls. Then everytime you use one of your literals, it
+# would first pass through the translation function and try to load a
+# translated version of the string from the current message catalogs.
+# For this example, since we are changinb language on the fly, and
+# since we are only translating the label for one widget, we'll not do
+# it the automatic way and we'll be more explicit. See the setup in
+# __init__() and the translation done in updateLanguage() below.
+
+_ = wx.GetTranslation
+
+exampleStrings = [
+ 'the quick brown fox jumps over the lazy dog', # demo string
+ 'Tip of the Day', # wx built in translation
+ 'Warning', # wx built in translation
+]
+
+
+[wxID_LANGUAGESELECTPANEL, wxID_LANGUAGESELECTPANELENGLISHBASECH,
+ wxID_LANGUAGESELECTPANELLANGCTRLCONTAINER,
+ wxID_LANGUAGESELECTPANELLANGFILTERRB, wxID_LANGUAGESELECTPANELSTATICLINE1,
+ wxID_LANGUAGESELECTPANELSTATICTEXT1, wxID_LANGUAGESELECTPANELSTATICTEXT2,
+ wxID_LANGUAGESELECTPANELSTATICTEXT3, wxID_LANGUAGESELECTPANELTRANSLATEDST,
+] = [wx.NewId() for _init_ctrls in range(9)]
+
+class LanguageSelectPanel(wx.Panel):
+ def _init_coll_boxSizer3_Items(self, parent):
+ # generated method, don't edit
+
+ parent.AddWindow(self.langCtrlContainer, 1, border=0, flag=wx.GROW)
+ parent.AddSpacer(wx.Size(8, 8), border=0, flag=0)
+ parent.AddWindow(self.langFilterRB, 0, border=0, flag=0)
+
+ def _init_coll_flexGridSizer1_Growables(self, parent):
+ # generated method, don't edit
+
+ parent.AddGrowableRow(1)
+ parent.AddGrowableCol(0)
+
+ def _init_coll_boxSizer1_Items(self, parent):
+ # generated method, don't edit
+
+ parent.AddWindow(self.staticText1, 0, border=8, flag=wx.ALL)
+ parent.AddSizer(self.boxSizer3, 1, border=8, flag=wx.ALL | wx.GROW)
+ parent.AddSizer(self.boxSizer2, 0, border=8, flag=wx.GROW | wx.ALL)
+
+ def _init_coll_boxSizer2_Items(self, parent):
+ # generated method, don't edit
+
+ parent.AddWindow(self.staticText2, 0, border=8, flag=wx.ALL)
+ parent.AddWindow(self.englishBaseCh, 0, border=8, flag=wx.GROW | wx.ALL)
+ parent.AddWindow(self.staticLine1, 0, border=8, flag=wx.GROW | wx.ALL)
+ parent.AddWindow(self.staticText3, 0, border=8, flag=wx.ALL)
+ parent.AddWindow(self.translatedST, 0, border=8, flag=wx.GROW | wx.ALL)
+
+ def _init_sizers(self):
+ # generated method, don't edit
+ self.boxSizer1 = wx.BoxSizer(orient=wx.VERTICAL)
+
+ self.flexGridSizer1 = wx.FlexGridSizer(cols=2, hgap=8, rows=0, vgap=8)
+
+ self.boxSizer3 = wx.BoxSizer(orient=wx.HORIZONTAL)
+
+ self.boxSizer2 = wx.BoxSizer(orient=wx.VERTICAL)
+
+ self._init_coll_boxSizer1_Items(self.boxSizer1)
+ self._init_coll_flexGridSizer1_Growables(self.flexGridSizer1)
+ self._init_coll_boxSizer3_Items(self.boxSizer3)
+ self._init_coll_boxSizer2_Items(self.boxSizer2)
+
+ self.SetSizer(self.boxSizer1)
+
+ def _init_ctrls(self, prnt):
+ # generated method, don't edit
+ wx.Panel.__init__(self, id=wxID_LANGUAGESELECTPANEL,
+ name='LanguageSelectPanel', parent=prnt,
+ style=wx.RESIZE_BORDER | wx.DEFAULT_DIALOG_STYLE)
+
+ self.staticText1 = wx.StaticText(id=wxID_LANGUAGESELECTPANELSTATICTEXT1,
+ label='Choose a language that will be used for example translation.',
+ name='staticText1', parent=self, style=0)
+
+ self.langCtrlContainer = wx.Panel(id=wxID_LANGUAGESELECTPANELLANGCTRLCONTAINER,
+ name='langCtrlContainer', parent=self, style=wx.TAB_TRAVERSAL)
+ self.langCtrlContainer.SetBackgroundColour(wx.Colour(255, 255, 255))
+ self.langCtrlContainer.Bind(wx.EVT_SIZE, self.OnLangCtrlContainerSize)
+
+ self.langFilterRB = wx.RadioBox(choices=['Translated example languages',
+ 'Available languages on your system', 'All languages'],
+ id=wxID_LANGUAGESELECTPANELLANGFILTERRB, label='Filter',
+ majorDimension=1, name='langFilterRB', parent=self,
+ style=wx.RA_SPECIFY_COLS)
+ self.langFilterRB.Bind(wx.EVT_RADIOBOX, self.OnLangFilterRBRadiobox,
+ id=wxID_LANGUAGESELECTPANELLANGFILTERRB)
+
+ self.staticText2 = wx.StaticText(id=wxID_LANGUAGESELECTPANELSTATICTEXT2,
+ label='English Text:', name='staticText2', parent=self,
+ style=0)
+
+ self.staticText3 = wx.StaticText(id=wxID_LANGUAGESELECTPANELSTATICTEXT3,
+ label='Translated Text:', name='staticText3', parent=self,
+ style=0)
+
+ self.englishBaseCh = wx.Choice(choices=self.choices,
+ id=wxID_LANGUAGESELECTPANELENGLISHBASECH, name='englishBaseCh',
+ parent=self, style=0)
+ self.englishBaseCh.Bind(wx.EVT_CHOICE, self.OnLangSelectAndTranslate,
+ id=wxID_LANGUAGESELECTPANELENGLISHBASECH)
+
+ self.staticLine1 = wx.StaticLine(id=wxID_LANGUAGESELECTPANELSTATICLINE1,
+ name='staticLine1', parent=self, style=0)
+
+ self.translatedST = wx.StaticText(id=wxID_LANGUAGESELECTPANELTRANSLATEDST,
+ label='', name='translatedST', parent=self, style=0)
+
+ self._init_sizers()
+
+ def __init__(self, parent, log):
+ self.choices = []
+ self.choices = exampleStrings
+
+ self._init_ctrls(parent)
+
+ self.log = log
+
+ lang = wx.LANGUAGE_DEFAULT
+ filter = 'demo'
+ langs = (wx.LANGUAGE_AFRIKAANS, wx.LANGUAGE_ENGLISH, wx.LANGUAGE_DEFAULT,
+ wx.LANGUAGE_SPANISH, wx.LANGUAGE_GERMAN, wx.LANGUAGE_ITALIAN,
+ wx.LANGUAGE_FRENCH)
+
+
+ # usually you would define wx.Locale in your wx.App.OnInit class.
+ # for the demo we just define it in this module
+ self.locale = None
+ wx.Locale.AddCatalogLookupPathPrefix(opj('data/locale'))
+ self.updateLanguage(wx.LANGUAGE_DEFAULT)
+
+
+ self.filterMap = {'demo': langlistctrl.LC_ONLY,
+ 'available': langlistctrl.LC_AVAILABLE,
+ 'all': langlistctrl.LC_ALL}
+
+ self.filterIdxMap = {0: 'demo',
+ 1: 'available',
+ 2: 'all'}
+ self.langs = langs
+ self.langCtrl = langlistctrl.LanguageListCtrl(self.langCtrlContainer, -1,
+ filter=self.filterMap[filter], only=langs, select=lang)
+
+ self.langCtrl.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnLangSelectAndTranslate)
+ self.langCtrl.Bind(wx.EVT_LIST_ITEM_DESELECTED, self.OnClearTranslatedText)
+
+ self.OnLangCtrlContainerSize()
+
+ self.englishBaseCh.Select(0)
+ self.OnLangSelectAndTranslate()
+
+
+ def updateLanguage(self, lang):
+ # Make *sure* any existing locale is deleted before the new
+ # one is created. The old C++ object needs to be deleted
+ # before the new one is created, and if we just assign a new
+ # instance to the old Python variable, the old C++ locale will
+ # not be destroyed soon enough, likely causing a crash.
+ if self.locale:
+ assert sys.getrefcount(self.locale) <= 2
+ del self.locale
+
+ # create a locale object for this language
+ self.locale = wx.Locale(lang)
+ if self.locale.IsOk():
+ self.locale.AddCatalog('wxpydemo')
+ else:
+ self.locale = None
+
+ def translateExample(self):
+ self.translatedST.SetLabel(_(self.englishBaseCh.GetStringSelection()))
+
+ def OnLangCtrlContainerSize(self, event=None):
+ if event: event.Skip()
+ self.langCtrl.SetSize(self.langCtrlContainer.GetSize())
+
+ def OnLangFilterRBRadiobox(self, event):
+ self.langCtrl.SetUpFilter(
+ self.filterMap[self.filterIdxMap[self.langFilterRB.GetSelection()]],
+ self.langs)
+
+ def OnLangSelectAndTranslate(self, event=None):
+ lang = self.langCtrl.GetLanguage()
+
+ if lang is not None:
+ # set to the selected language
+ self.updateLanguage(lang)
+
+ self.translateExample()
+
+ # set back to default
+ self.updateLanguage(wx.LANGUAGE_DEFAULT)
+
+ def OnClearTranslatedText(self, event):
+ self.translatedST.SetLabel('')
+
+
+def runTest(frame, nb, log):
+ win = LanguageSelectPanel(nb, log)
+ return win
+
+#-------------------------------------------------------------------------------
+
+overview = """
+
Internationalization (I18N)
+
+This demo demonstrates how to setup and use the wx.Locale object to translate text.
+
+This class encapsulates a platform-independent image. An image can be created
+from data, or using wxBitmap.ConvertToImage. An image can be loaded from
+a file in a variety of formats, and is extensible to new formats via image
+format handlers. Functions are available to set and get image bits, so it can
+be used for basic image manipulation.
+
+
The following image handlers are available.
+
+
+
+
wxBMPHandler
For loading and saving, always installed.
+
wxPNGHandler
For loading and saving.
+
wxJPEGHandler
For loading and saving.
+
wxGIFHandler
Only for loading, due to legal issues.
+
wxPCXHandler
For loading and saving.
+
wxPNMHandler
For loading and saving.
+
wxTIFFHandler
For loading and saving.
+
wxIFFHandler
For loading only.
+
wxXPMHandler
For loading and saving.
+
wxICOHandler
For loading and saving.
+
wxCURHandler
For loading and saving.
+
wxANIHandler
For loading only.
+
+
+
When saving in PCX format, wxPCXHandler will count the number of different
+colours in the image; if there are 256 or less colours, it will save as 8 bit,
+else it will save as 24 bit.
+
+
Loading PNMs only works for ASCII or raw RGB images. When saving in PNM format,
+wxPNMHandler will always save as raw RGB.
+
+
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ImageAlpha.py b/demo/ImageAlpha.py
new file mode 100644
index 00000000..9613a8ce
--- /dev/null
+++ b/demo/ImageAlpha.py
@@ -0,0 +1,86 @@
+
+import wx # This module uses the new wx namespace
+from Main import opj
+
+
+#----------------------------------------------------------------------
+
+msg = "Some text will appear mixed in the image's shadow..."
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+ def OnPaint(self, evt):
+ dc = wx.PaintDC(self)
+ dc.SetBackground(wx.Brush("WHITE"))
+ dc.Clear()
+
+ dc.SetFont(wx.Font(16, wx.SWISS, wx.NORMAL, wx.BOLD, True))
+ dc.DrawText("Bitmap alpha blending (on all ports but gtk+ 1.2)",
+ 25,25)
+
+ bmp = wx.Bitmap(opj('bitmaps/toucan.png'))
+ if "gtk1" in wx.PlatformInfo:
+ # Try to make up for lack of alpha support in wxGTK (gtk+
+ # 1.2) by converting the alpha blending into a
+ # transparency mask.
+
+ # first convert to a wx.Image
+ img = bmp.ConvertToImage()
+
+ # Then convert the alpha channel to a mask, specifying the
+ # threshold below which alpha will be made fully
+ # transparent
+ img.ConvertAlphaToMask(220)
+
+ # convert back to a wx.Bitmap
+ bmp = img.ConvertToBitmap()
+
+
+ dc.DrawBitmap(bmp, 25,100, True)
+
+ dc.SetFont(self.GetFont())
+ y = 75
+ for line in range(10):
+ y += dc.GetCharHeight() + 5
+ dc.DrawText(msg, 200, y)
+ dc.DrawBitmap(bmp, 250,100, True)
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
Images with Alpha
+
+wxMSW and wxMac now support alpha channels of supported image
+types, and will properly blend that channel when drawing a
+bitmap. It is not supported yet on wxGTK, (if you would like to
+change that please submit a patch!)
+
+
On wxGTK this demo turns the alpha channel into a 1-bit mask, so
+yes, it looks like crap. Please help us fix it!
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ImageBrowser.py b/demo/ImageBrowser.py
new file mode 100644
index 00000000..31509a9d
--- /dev/null
+++ b/demo/ImageBrowser.py
@@ -0,0 +1,68 @@
+#----------------------------------------------------------------------------
+# Name: ImageBrowser.py
+# Purpose: Image Selection dialog for wxPython demo
+#
+# Author: Lorne White (email: lorne.white@telusplanet.net)
+#
+# Version 0.5
+# Date: Feb 26, 2001
+# Licence: wxWindows license
+#----------------------------------------------------------------------------
+
+import os
+
+import wx
+import wx.lib.imagebrowser as ib
+
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show an ImageDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ # get current working directory
+ dir = os.getcwd()
+
+ # set the initial directory for the demo bitmaps
+ initial_dir = os.path.join(dir, 'bitmaps')
+
+ # open the image browser dialog
+ dlg = ib.ImageDialog(self, initial_dir)
+
+ dlg.Centre()
+
+ if dlg.ShowModal() == wx.ID_OK:
+ # show the selected file
+ self.log.WriteText("You Selected File: " + dlg.GetFile())
+ else:
+ self.log.WriteText("You pressed Cancel\n")
+
+ dlg.Destroy()
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ImageFromStream.py b/demo/ImageFromStream.py
new file mode 100644
index 00000000..15e1e399
--- /dev/null
+++ b/demo/ImageFromStream.py
@@ -0,0 +1,46 @@
+
+import cStringIO
+
+import wx
+
+from Main import opj
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+
+ data = open(opj('bitmaps/image.png'), "rb").read()
+ stream = cStringIO.StringIO(data)
+
+ bmp = wx.BitmapFromImage( wx.ImageFromStream( stream ))
+
+ wx.StaticText(
+ self, -1, "This image was loaded from a Python file-like object:",
+ (15, 15)
+ )
+
+ wx.StaticBitmap(self, -1, bmp, (15, 45))#, (bmp.GetWidth(), bmp.GetHeight()))
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+At long last there is finally a way to load any supported image type
+directly from any Python file-like object, such as a memory buffer
+using StringIO. """
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/Img2PyArtProvider.py b/demo/Img2PyArtProvider.py
new file mode 100644
index 00000000..206979f0
--- /dev/null
+++ b/demo/Img2PyArtProvider.py
@@ -0,0 +1,98 @@
+
+import wx
+from wx.lib.art import flagart, img2pyartprov
+
+FlagArtProvider = None
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ self.SetSizer(sizer)
+
+ title = wx.StaticText(self, -1, "Img2PyArtProvider")
+ title.SetFont(wx.Font(18, wx.SWISS, wx.NORMAL, wx.BOLD))
+ sizer.Add(title, 0, wx.ALIGN_CENTRE|wx.ALL, 5)
+
+ line = wx.StaticLine(self, -1, size=(20,-1), style=wx.LI_HORIZONTAL)
+ sizer.Add(line, 0, wx.GROW|wx.ALIGN_CENTER_VERTICAL|wx.ALL, 5)
+ sizer.Add((20,20))
+
+ box = wx.BoxSizer(wx.HORIZONTAL)
+ ch = wx.ComboBox(self, -1, 'BLANK', choices=flagart.index,
+ style=wx.CB_DROPDOWN|wx.CB_READONLY)
+ self.Bind(wx.EVT_COMBOBOX, self.OnSelectCountry, ch)
+ box.Add(ch, 0, wx.ALIGN_CENTER_VERTICAL)
+ box.Add((50,10))
+
+ bmp = wx.EmptyBitmap(32,22)
+ self.bmpFlag = wx.StaticBitmap(self, -1, bmp)
+ box.Add(self.bmpFlag, 0, wx.ALIGN_CENTER_VERTICAL)
+
+ sizer.Add(box, 0, wx.CENTER|wx.ALL, 10)
+
+ self.country = 'BLANK'
+ global FlagArtProvider
+ if FlagArtProvider is None:
+ FlagArtProvider = img2pyartprov.Img2PyArtProvider(flagart,
+ artIdPrefix='wx.ART_')
+ wx.ArtProvider.Push(FlagArtProvider)
+
+ self.getArt()
+
+
+ def OnSelectCountry(self, evt):
+ self.log.write("OnSelectCountry\n")
+ self.country = evt.GetString()
+ self.getArt()
+
+
+ def getArt(self):
+ bmp = wx.ArtProvider.GetBitmap('wx.ART_'+self.country, wx.ART_OTHER, (32,22))
+ if not bmp.Ok():
+ bmp = wx.EmptyBitmap(32,22)
+ self.clearBmp(bmp)
+ self.bmpFlag.SetBitmap(bmp)
+
+
+ def clearBmp(self, bmp):
+ dc = wx.MemoryDC()
+ dc.SelectObject(bmp)
+ dc.SetBackground(wx.Brush("white"))
+ dc.Clear()
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
Img2PyArtProvider
+
+Img2PyArtProvider is an ArtProvider class that publishes images from
+modules generated by img2py.
+
+
+This sample shows how to access the flag images in wx.lib.art.flagart
+via the ArtProvider.
+
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/InfoBar.py b/demo/InfoBar.py
new file mode 100644
index 00000000..533b75e0
--- /dev/null
+++ b/demo/InfoBar.py
@@ -0,0 +1,125 @@
+import wx
+
+#----------------------------------------------------------------------
+
+flags = [ (wx.ICON_NONE, "ICON_NONE"),
+ (wx.ICON_INFORMATION, "ICON_INFORMATION"),
+ (wx.ICON_QUESTION, "ICON_QUESTION"),
+ (wx.ICON_WARNING, "ICON_WARNING"),
+ (wx.ICON_ERROR, "ICON_ERROR")
+ ]
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ # Create the InfoBar. It starts out in a hidden state so it
+ # won't be visible until we need it.
+ self.info = wx.InfoBar(self)
+ panel = wx.Panel(self)
+
+ self.message = wx.TextCtrl(panel, -1, "Hello World", size=(250,-1))
+ self.flags = wx.Choice(panel, choices=[f[1] for f in flags])
+ self.flags.SetSelection(1) # wx.ICON_INFORMATION is the default
+
+ smBtn = wx.Button(panel, -1, "Show Message")
+ dmBtn = wx.Button(panel, -1, "Dismiss")
+ addBtn = wx.Button(panel, -1, "Add Button")
+
+ fgs = wx.FlexGridSizer(cols=3, vgap=10, hgap=10)
+ fgs.Add(wx.StaticText(panel, -1, "Message:"), 0,
+ wx.ALIGN_CENTER_VERTICAL|wx.ALIGN_RIGHT)
+ fgs.Add(self.message)
+ fgs.Add(self.flags)
+ fgs.AddSpacer(5)
+
+ hbox = wx.BoxSizer(wx.HORIZONTAL)
+ hbox.Add(smBtn, 0, wx.RIGHT, 5)
+ hbox.Add(dmBtn)
+ fgs.Add(hbox)
+ fgs.AddSpacer(5)
+ fgs.AddSpacer(5)
+ fgs.Add(addBtn)
+
+ panel.Sizer = wx.BoxSizer(wx.VERTICAL)
+ text = """\
+An info bar is a transient window shown at top or bottom of its parent window
+to display non-critical information to the user."""
+ panel.Sizer.Add(wx.StaticText(panel, -1, text), 0, wx.TOP|wx.LEFT, 25)
+ panel.Sizer.Add(fgs, 1, wx.EXPAND|wx.ALL, 25)
+
+ self.Sizer = wx.BoxSizer(wx.VERTICAL)
+ self.Sizer.Add(self.info, 0, wx.EXPAND)
+ self.Sizer.Add(panel, 1, wx.EXPAND)
+
+ self.Bind(wx.EVT_BUTTON, self.OnShowMessage, smBtn)
+ self.Bind(wx.EVT_BUTTON, self.OnDismiss, dmBtn)
+ self.Bind(wx.EVT_BUTTON, self.OnAddButton, addBtn)
+
+
+ def OnShowMessage(self, evt):
+ msg = self.message.GetValue()
+ flag = flags[self.flags.GetSelection()][0]
+ self.info.ShowMessage(msg, flag)
+
+
+ def OnDismiss(self, evt):
+ self.info.Dismiss()
+
+
+ def OnAddButton(self, evt):
+ btnId = wx.NewId()
+ self.info.AddButton(btnId, "new button")
+ self.info.Bind(wx.EVT_BUTTON, self.OnButtonClicked, id=btnId)
+
+
+ def OnButtonClicked(self, evt):
+ wx.MessageBox("New button clicked")
+ # Calling evt.Skip() will allow the default handler to run
+ # which will dismiss the info bar. If you don't want it to be
+ # dismissed for a particular button then then don't call
+ # Skip().
+ evt.Skip()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.InfoBar
+
+An info bar is a transient window shown at top or bottom of its parent
+window to display non-critical information to the user.
+
+
This class provides another way to show messages to the user,
+intermediate between message boxes and status bar messages. The
+message boxes are modal and thus interrupt the users work flow and
+should be used sparingly for this reason. However status bar messages
+are often too easy not to notice at all. An info bar provides a way to
+present the messages which has a much higher chance to be noticed by
+the user but without being annoying.
+
+
If no initial value is set, the default will be zero, or
+ the minimum value, if specified. If an illegal string is specified,
+ a ValueError will result. (You can always later set the initial
+ value with SetValue() after instantiation of the control.)
+
+
min
+
The minimum value that the control should allow. This can be
+ adjusted with SetMin(). If the control is not limited, any value
+ below this bound will be colored with the current out-of-bounds color.
+
+
max
+
The maximum value that the control should allow. This can be
+ adjusted with SetMax(). If the control is not limited, any value
+ above this bound will be colored with the current out-of-bounds color.
+
+
limited
+
Boolean indicating whether the control prevents values from
+ exceeding the currently set minimum and maximum values (bounds).
+ If False and bounds are set, out-of-bounds values will
+ be colored with the current out-of-bounds color.
+
+
allow_none
+
Boolean indicating whether or not the control is allowed to be
+ empty, representing a value of None for the control.
+
+
allow_long
+
Boolean indicating whether or not the control is allowed to hold
+ and return a value of type long as well as int. If False, the
+ control will be implicitly limited to have a value such that
+ -sys.maxint-1 <= n <= sys.maxint.
+
+
default_color
+
Color value used for in-bounds values of the control.
+
+
oob_color
+
Color value used for out-of-bounds values of the control
+ when the bounds are set but the control is not limited.
+
+
+
+
EVT_INT(win, id, func)
+
Respond to a wxEVT_COMMAND_INT_UPDATED event, generated when the
+value changes. Notice that this event will always be sent when the
+control's contents changes - whether this is due to user input or
+comes from the program itself (for example, if SetValue() is called.)
+
+
+
SetValue(int)
+
Sets the value of the control to the integer value specified.
+The resulting actual value of the control may be altered to
+conform with the bounds set on the control if limited,
+or colored if not limited but the value is out-of-bounds.
+A ValueError exception will be raised if an invalid value
+is specified.
+
+
GetValue()
+
Retrieves the integer value from the control. The value
+retrieved will be sized as an int if possible or a long,
+if necessary.
+
+
+
SetMin(min=None)
+
Sets the expected minimum value, or lower bound, of the control.
+(The lower bound will only be enforced if the control is
+configured to limit its values to the set bounds.)
+If a value of None is provided, then the control will have
+no explicit lower bound. If the value specified is greater than
+the current lower bound, then the function returns 0 and the
+lower bound will not change from its current setting. On success,
+the function returns 1.
+
If successful and the current value is
+lower than the new lower bound, if the control is limited, the
+value will be automatically adjusted to the new minimum value;
+if not limited, the value in the control will be colored with
+the current out-of-bounds color.
+
+
GetMin()
+
Gets the current lower bound value for the control.
+It will return None if no lower bound is currently specified.
+
+
+
SetMax(max=None)
+
Sets the expected maximum value, or upper bound, of the control.
+(The upper bound will only be enforced if the control is
+configured to limit its values to the set bounds.)
+If a value of None is provided, then the control will
+have no explicit upper bound. If the value specified is less
+than the current lower bound, then the function returns 0 and
+the maximum will not change from its current setting. On success,
+the function returns 1.
+
If successful and the current value
+is greater than the new upper bound, if the control is limited
+the value will be automatically adjusted to the new maximum value;
+if not limited, the value in the control will be colored with the
+current out-of-bounds color.
+
+
GetMax()
+
Gets the current upper bound value for the control.
+It will return None if no upper bound is currently specified.
+
+
+
SetBounds(min=None,max=None)
+
This function is a convenience function for setting the min and max
+values at the same time. The function only applies the maximum bound
+if setting the minimum bound is successful, and returns True
+only if both operations succeed. Note: leaving out an argument
+will remove the corresponding bound.
+
GetBounds()
+
This function returns a two-tuple (min,max), indicating the
+current bounds of the control. Each value can be None if
+that bound is not set.
+
+
+
IsInBounds(value=None)
+
Returns True if no value is specified and the current value
+of the control falls within the current bounds. This function can also
+be called with a value to see if that value would fall within the current
+bounds of the given control.
+
+
+
SetLimited(bool)
+
If called with a value of True, this function will cause the control
+to limit the value to fall within the bounds currently specified.
+If the control's value currently exceeds the bounds, it will then
+be limited accordingly.
+If called with a value of 0, this function will disable value
+limiting, but coloring of out-of-bounds values will still take
+place if bounds have been set for the control.
+
IsLimited()
+
Returns True if the control is currently limiting the
+value to fall within the current bounds.
+
+
+
SetNoneAllowed(bool)
+
If called with a value of True, this function will cause the control
+to allow the value to be empty, representing a value of None.
+If called with a value of false, this function will prevent the value
+from being None. If the value of the control is currently None,
+ie. the control is empty, then the value will be changed to that
+of the lower bound of the control, or 0 if no lower bound is set.
+
IsNoneAllowed()
+
Returns True if the control currently allows its
+value to be None.
+
+
+
SetLongAllowed(bool)
+
If called with a value of True, this function will cause the
+control to allow the value to be a long. If called with a value
+of False, and the value of the control is currently a long value,
+the value of the control will be adjusted to fall within the
+size of an integer type, at either the sys.maxint or -sys.maxint-1,
+for positive and negative values, respectively.
+
IsLongAllowed()
+
Returns True if the control currently allows its
+value to be of type long.
+
+
+
Tells the control what colors to use for normal and out-of-bounds
+values. If the value currently exceeds the bounds, it will be
+recolored accordingly.
+
GetColors()
+
Returns a tuple of (default_color, oob_color) indicating
+the current color settings for the control.
+
+
+
Cut()
+
Will allow cuts to the clipboard of the text portion of the value,
+leaving the value of zero if the entire contents are "cut."
+
Paste()
+
Will paste the contents of the clipboard to the selected portion
+of the value; if the resulting string does not represent a legal
+value, a ValueError will result. If the result is out-of bounds,
+it will either be adjusted or colored as appropriate.
+
+
+ItemsPicker is a widget that allows the user to choose a set of picked
+items out of a given list
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Joystick.py b/demo/Joystick.py
new file mode 100644
index 00000000..f26d7e1a
--- /dev/null
+++ b/demo/Joystick.py
@@ -0,0 +1,1089 @@
+#----------------------------------------------------------------------------
+# Name: Joystick.py
+# Purpose: Demonstrate use of wx.Joystick
+#
+# Author: Jeff Grimmett (grimmtoo@softhome.net), adapted from original
+# .wdr-derived demo
+#
+# Created: 02-Jan-2004
+# RCS-ID: $Id$
+# Copyright:
+# Licence: wxWindows license
+#----------------------------------------------------------------------------
+#
+
+import math
+import wx
+
+haveJoystick = True
+if wx.Platform == "__WXMAC__":
+ haveJoystick = False
+
+#----------------------------------------------------------------------------
+
+# Once all supported versions of Python support 32-bit integers on all
+# platforms, this can go up to 32.
+MAX_BUTTONS = 16
+
+#----------------------------------------------------------------------------
+
+class Label(wx.StaticText):
+ # A derived StaticText that always aligns right and renders
+ # in a bold font.
+ def __init__(self, parent, label):
+ wx.StaticText.__init__(self, parent, -1, label, style=wx.ALIGN_RIGHT)
+
+ f = parent.GetFont()
+ f.SetWeight(wx.BOLD)
+ self.SetFont(f)
+
+#----------------------------------------------------------------------------
+
+
+class JoyGauge(wx.Panel):
+ def __init__(self, parent, stick):
+
+ self.stick = stick
+ size = (100,100)
+
+ wx.Panel.__init__(self, parent, -1, size=size)
+
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ self.Bind(wx.EVT_ERASE_BACKGROUND, lambda e: None)
+
+ self.buffer = wx.EmptyBitmap(*size)
+ dc = wx.BufferedDC(None, self.buffer)
+ self.DrawFace(dc)
+ self.DrawJoystick(dc)
+
+
+ def OnSize(self, event):
+ # The face Bitmap init is done here, to make sure the buffer is always
+ # the same size as the Window
+ w, h = self.GetClientSize()
+ self.buffer = wx.EmptyBitmap(w,h)
+ dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
+ self.DrawFace(dc)
+ self.DrawJoystick(dc)
+
+
+ def DrawFace(self, dc):
+ dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
+ dc.Clear()
+
+
+ def OnPaint(self, evt):
+ # When dc is destroyed it will blit self.buffer to the window,
+ # since no other drawing is needed we'll just return and let it
+ # do it's thing
+ dc = wx.BufferedPaintDC(self, self.buffer)
+
+
+ def DrawJoystick(self, dc):
+ # draw the guage as a maxed square in the center of this window.
+ w, h = self.GetClientSize()
+ edgeSize = min(w, h)
+
+ xorigin = (w - edgeSize) / 2
+ yorigin = (h - edgeSize) / 2
+ center = edgeSize / 2
+
+ # Restrict our drawing activities to the square defined
+ # above.
+ dc.SetClippingRegion(xorigin, yorigin, edgeSize, edgeSize)
+
+ # Optimize drawing a bit (for Win)
+ dc.BeginDrawing()
+
+ dc.SetBrush(wx.Brush(wx.Colour(251, 252, 237)))
+ dc.DrawRectangle(xorigin, yorigin, edgeSize, edgeSize)
+
+ dc.SetPen(wx.Pen(wx.BLACK, 1, wx.DOT_DASH))
+
+ dc.DrawLine(xorigin, yorigin + center, xorigin + edgeSize, yorigin + center)
+ dc.DrawLine(xorigin + center, yorigin, xorigin + center, yorigin + edgeSize)
+
+ if self.stick:
+ # Get the joystick position as a float
+ joyx = float(self.stick.GetPosition().x)
+ joyy = float(self.stick.GetPosition().y)
+
+ # Get the joystick range of motion
+ xmin = self.stick.GetXMin()
+ xmax = self.stick.GetXMax()
+ if xmin < 0:
+ xmax += abs(xmin)
+ joyx += abs(xmin)
+ xmin = 0
+ xrange = max(xmax - xmin, 1)
+
+ ymin = self.stick.GetYMin()
+ ymax = self.stick.GetYMax()
+ if ymin < 0:
+ ymax += abs(ymin)
+ joyy += abs(ymin)
+ ymin = 0
+ yrange = max(ymax - ymin, 1)
+
+ # calc a ratio of our range versus the joystick range
+ xratio = float(edgeSize) / xrange
+ yratio = float(edgeSize) / yrange
+
+ # calc the displayable value based on position times ratio
+ xval = int(joyx * xratio)
+ yval = int(joyy * yratio)
+
+ # and normalize the value from our brush's origin
+ x = xval + xorigin
+ y = yval + yorigin
+
+ # Now to draw it.
+ dc.SetPen(wx.Pen(wx.RED, 2))
+ dc.CrossHair(x, y)
+
+ # Turn off drawing optimization
+ dc.EndDrawing()
+
+
+ def Update(self):
+ dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
+ self.DrawFace(dc)
+ self.DrawJoystick(dc)
+
+
+#----------------------------------------------------------------------------
+
+class JoyPanel(wx.Panel):
+ def __init__(self, parent, stick):
+
+ self.stick = stick
+
+ wx.Panel.__init__(self, parent, -1)
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+
+ fn = parent.GetFont()
+ fn.SetPointSize(fn.GetPointSize() + 3)
+ fn.SetWeight(wx.BOLD)
+
+ t = wx.StaticText(self, -1, "X - Y Axes", style = wx.ALIGN_CENTRE)
+ t.SetFont(fn)
+ sizer.Add(t, 0, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER | wx.ALIGN_CENTER_HORIZONTAL, 1)
+
+ self.control = JoyGauge(self, self.stick)
+ sizer.Add(self.control, 1, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER | wx.ALIGN_CENTER_HORIZONTAL, 1)
+
+ self.SetSizer(sizer)
+ sizer.Fit(self)
+
+ def Update(self):
+ self.control.Update()
+
+
+#----------------------------------------------------------------------------
+
+class POVGauge(wx.Panel):
+ #
+ # Display the current postion of the POV control
+ #
+ def __init__(self, parent, stick):
+
+ self.stick = stick
+ self.size = (100, 100)
+ self.avail = False
+ self.fourDir = False
+ self.cts = False
+
+ wx.Panel.__init__(self, parent, -1, size=self.size)
+
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ self.Bind(wx.EVT_ERASE_BACKGROUND, lambda e: None)
+
+ self.buffer = wx.EmptyBitmap(*self.size)
+ dc = wx.BufferedDC(None, self.buffer)
+ self.DrawFace(dc)
+ self.DrawPOV(dc)
+
+
+ def OnSize(self, event):
+ # calculate the size of our display and make a buffer for it.
+ w, h = self.GetClientSize()
+ s = min(w, h)
+ self.size = (s, s)
+ self.buffer = wx.EmptyBitmap(w,h)
+ dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
+ self.DrawFace(dc)
+ self.DrawPOV(dc)
+
+
+ def DrawFace(self, dc):
+ dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
+ dc.Clear()
+
+
+ def OnPaint(self, evt):
+ # When dc is destroyed it will blit self.buffer to the window,
+ # since no other drawing is needed we'll just return and let it
+ # do it's thing
+ dc = wx.BufferedPaintDC(self, self.buffer)
+
+
+ def DrawPOV(self, dc):
+ # draw the guage as a maxed circle in the center of this window.
+ w, h = self.GetClientSize()
+ diameter = min(w, h)
+
+ xorigin = (w - diameter) / 2
+ yorigin = (h - diameter) / 2
+ xcenter = xorigin + diameter / 2
+ ycenter = yorigin + diameter / 2
+
+ # Optimize drawing a bit (for Win)
+ dc.BeginDrawing()
+
+ # our 'raster'.
+ dc.SetBrush(wx.Brush(wx.WHITE))
+ dc.DrawCircle(xcenter, ycenter, diameter/2)
+ dc.SetBrush(wx.Brush(wx.BLACK))
+ dc.DrawCircle(xcenter, ycenter, 10)
+
+ # fancy decorations
+ dc.SetPen(wx.Pen(wx.BLACK, 1, wx.DOT_DASH))
+ dc.DrawLine(xorigin, ycenter, xorigin + diameter, ycenter)
+ dc.DrawLine(xcenter, yorigin, xcenter, yorigin + diameter)
+
+ if self.stick:
+ if self.avail:
+
+ pos = -1
+
+ # use the appropriate function to get the POV position
+ if self.fourDir:
+ pos = self.stick.GetPOVPosition()
+
+ if self.cts:
+ pos = self.stick.GetPOVCTSPosition()
+
+ # trap invalid values
+ if 0 <= pos <= 36000:
+ vector = 30
+ else:
+ vector = 0
+
+ # rotate CCW by 90 so that 0 is up.
+ pos = (pos / 100) - 90
+
+ # Normalize
+ if pos < 0:
+ pos = pos + 360
+
+ # Stolen from wx.lib.analogclock :-)
+ radiansPerDegree = math.pi / 180
+ pointX = int(round(vector * math.cos(pos * radiansPerDegree)))
+ pointY = int(round(vector * math.sin(pos * radiansPerDegree)))
+
+ # normalise value to match our actual center.
+ nx = pointX + xcenter
+ ny = pointY + ycenter
+
+ # Draw the line
+ dc.SetPen(wx.Pen(wx.BLUE, 2))
+ dc.DrawLine(xcenter, ycenter, nx, ny)
+
+ # And a little thing to show the endpoint
+ dc.SetBrush(wx.Brush(wx.BLUE))
+ dc.DrawCircle(nx, ny, 8)
+
+ # Turn off drawing optimization
+ dc.EndDrawing()
+
+
+ def Update(self):
+ dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
+ self.DrawFace(dc)
+ self.DrawPOV(dc)
+
+
+ def Calibrate(self):
+ s = self.stick
+ self.avail = s.HasPOV()
+ self.fourDir = s.HasPOV4Dir()
+ self.cts = s.HasPOVCTS()
+
+
+#----------------------------------------------------------------------------
+
+class POVStatus(wx.Panel):
+ #
+ # Displays static info about the POV control
+ #
+ def __init__(self, parent, stick):
+
+ self.stick = stick
+
+ wx.Panel.__init__(self, parent, -1, size=(100, 100))
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add((20,20))
+
+ self.avail = wx.CheckBox(self, -1, "Available")
+ sizer.Add(self.avail, 0, wx.ALL | wx.EXPAND | wx.ALIGN_LEFT, 2)
+
+ self.fourDir = wx.CheckBox(self, -1, "4-Way Only")
+ sizer.Add(self.fourDir, 0, wx.ALL | wx.EXPAND | wx.ALIGN_LEFT, 2)
+
+ self.cts = wx.CheckBox(self, -1, "Continuous")
+ sizer.Add(self.cts, 0, wx.ALL | wx.EXPAND | wx.ALIGN_LEFT, 2)
+
+ self.SetSizer(sizer)
+ sizer.Fit(self)
+
+ # Effectively makes the checkboxes read-only.
+ self.Bind(wx.EVT_CHECKBOX, self.Calibrate)
+
+
+ def Calibrate(self, evt=None):
+ s = self.stick
+ self.avail.SetValue(s.HasPOV())
+ self.fourDir.SetValue(s.HasPOV4Dir())
+ self.cts.SetValue(s.HasPOVCTS())
+
+
+#----------------------------------------------------------------------------
+
+class POVPanel(wx.Panel):
+ def __init__(self, parent, stick):
+
+ self.stick = stick
+
+ wx.Panel.__init__(self, parent, -1, size=(100, 100))
+
+ sizer = wx.BoxSizer(wx.HORIZONTAL)
+ gsizer = wx.BoxSizer(wx.VERTICAL)
+
+ sizer.Add((25,25))
+
+ fn = parent.GetFont()
+ fn.SetPointSize(fn.GetPointSize() + 3)
+ fn.SetWeight(wx.BOLD)
+
+ t = wx.StaticText(self, -1, "POV Control", style = wx.ALIGN_CENTER)
+ t.SetFont(fn)
+ gsizer.Add(t, 0, wx.ALL | wx.EXPAND, 1)
+
+ self.display = POVGauge(self, stick)
+ gsizer.Add(self.display, 1, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 1)
+ sizer.Add(gsizer, 1, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 1)
+
+ self.status = POVStatus(self, stick)
+ sizer.Add(self.status, 1, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 1)
+
+ self.SetSizer(sizer)
+ sizer.Fit(self)
+
+
+ def Calibrate(self):
+ self.display.Calibrate()
+ self.status.Calibrate()
+
+
+ def Update(self):
+ self.display.Update()
+
+
+#----------------------------------------------------------------------------
+
+class LED(wx.Panel):
+ def __init__(self, parent, number):
+
+ self.state = -1
+ self.size = (20, 20)
+ self.number = number
+
+ fn = parent.GetFont()
+ fn.SetPointSize(fn.GetPointSize() - 1)
+ fn.SetWeight(wx.BOLD)
+ self.fn = fn
+
+ wx.Panel.__init__(self, parent, -1, size=self.size)
+
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ self.Bind(wx.EVT_ERASE_BACKGROUND, lambda e: None)
+
+ self.buffer = wx.EmptyBitmap(*self.size)
+ dc = wx.BufferedDC(None, self.buffer)
+ self.DrawFace(dc)
+ self.DrawLED(dc)
+
+
+ def OnSize(self, event):
+ # calculate the size of our display.
+ w, h = self.GetClientSize()
+ s = min(w, h)
+ self.size = (s, s)
+ self.buffer = wx.EmptyBitmap(*self.size)
+ dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
+ self.DrawFace(dc)
+ self.DrawLED(dc)
+
+
+ def DrawFace(self, dc):
+ dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
+ dc.Clear()
+
+
+ def OnPaint(self, evt):
+ # When dc is destroyed it will blit self.buffer to the window,
+ # since no other drawing is needed we'll just return and let it
+ # do it's thing
+ dc = wx.BufferedPaintDC(self, self.buffer)
+
+
+ def DrawLED(self, dc):
+ # bitmap size
+ bw, bh = self.size
+
+ # center of bitmap
+ center = bw / 2
+
+ # calc the 0, 0 origin of the bitmap
+ xorigin = center - (bw / 2)
+ yorigin = center - (bh / 2)
+
+ # Optimize drawing a bit (for Win)
+ dc.BeginDrawing()
+
+ # our 'raster'.
+ if self.state == 0:
+ dc.SetBrush(wx.Brush(wx.RED))
+ elif self.state == 1:
+ dc.SetBrush(wx.Brush(wx.GREEN))
+ else:
+ dc.SetBrush(wx.Brush(wx.BLACK))
+
+ dc.DrawCircle(center, center, bw/2)
+
+ txt = str(self.number)
+
+ # Set the font for the DC ...
+ dc.SetFont(self.fn)
+ # ... and calculate how much space our value
+ # will take up.
+ fw, fh = dc.GetTextExtent(txt)
+
+ # Calc the center of the LED, and from that
+ # derive the origin of our value.
+ tx = center - (fw/2)
+ ty = center - (fh/2)
+
+ # I draw the value twice so as to give it a pseudo-shadow.
+ # This is (mostly) because I'm too lazy to figure out how
+ # to blit my text onto the gauge using one of the logical
+ # functions. The pseudo-shadow gives the text contrast
+ # regardless of whether the bar is under it or not.
+ dc.SetTextForeground(wx.WHITE)
+ dc.DrawText(txt, tx, ty)
+
+ # Turn off drawing optimization
+ dc.EndDrawing()
+
+
+ def Update(self):
+ dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
+ self.DrawFace(dc)
+ self.DrawLED(dc)
+
+
+#----------------------------------------------------------------------------
+
+class JoyButtons(wx.Panel):
+ def __init__(self, parent, stick):
+
+ self.stick = stick
+ self.leds = {}
+
+ wx.Panel.__init__(self, parent, -1)
+
+ tsizer = wx.BoxSizer(wx.VERTICAL)
+
+ fn = parent.GetFont()
+ fn.SetPointSize(fn.GetPointSize() + 3)
+ fn.SetWeight(wx.BOLD)
+
+ t = wx.StaticText(self, -1, "Buttons", style = wx.ALIGN_LEFT)
+ t.SetFont(fn)
+ tsizer.Add(t, 0, wx.ALL | wx.EXPAND | wx.ALIGN_LEFT, 1)
+
+ sizer = wx.FlexGridSizer(4, 16, 2, 2)
+
+ fn.SetPointSize(parent.GetFont().GetPointSize() + 1)
+
+ for i in range(0, MAX_BUTTONS):
+ t = LED(self, i)
+ self.leds[i] = t
+ sizer.Add(t, 1, wx.ALL|wx.ALIGN_CENTER|wx.ALIGN_CENTER_VERTICAL, 1)
+ sizer.AddGrowableCol(i)
+
+ tsizer.Add(sizer, 1, wx.ALL | wx.EXPAND | wx.ALIGN_LEFT, 1)
+
+ self.SetSizer(tsizer)
+ tsizer.Fit(self)
+
+ def Calibrate(self):
+ for i in range(0, MAX_BUTTONS):
+ self.leds[i].state = -1
+
+ t = self.stick.GetNumberButtons()
+
+ for i in range(0, t):
+ self.leds[i].state = 0
+
+ def Update(self):
+ t = self.stick.GetButtonState()
+
+ for i in range(0, MAX_BUTTONS):
+ if self.leds[i].state == 1:
+ self.leds[i].state = 0
+
+ if (t & (1<
+
+
wx.Joystick
+This demo illustrates the use of the wx.Joystick class, which is an interface to
+one or more joysticks attached to your system.
+
+
The data that can be retrieved from the joystick comes in four basic flavors.
+All of these are illustrated in the demo. In fact, this demo illustrates everything
+you can get from the wx.Joystick control.
+
+
+
Static information such as Manufacturer ID and model name,
+
Analog input from up to six axes, including X and Y for the actual stick,
+
Button input from the fire button and any other buttons that the stick has,
+
and the POV control (a kind of mini-joystick on top of the joystick) that many sticks come with.
+
+
+
Getting data from the joystick can be event-driven thanks to four event types associated
+with wx.JoystickEvent, or the joystick can be polled programatically to get data on
+a regular basis.
+
+
Data types
+
+Data from the joystick comes in two flavors: that which defines the boundaries, and that
+which defines the current state of the stick. Thus, we have Get*Max() and Get*Min()
+methods for all axes, the max number of axes, the max number of buttons, and so on. In
+general, this data can be read once and stored to speed computation up.
+
+
Analog Input
+
+Analog input (the axes) is delivered as a whole, positive number. If you need to know
+if the axis is at zero (centered) or not, you will first have to calculate that center
+based on the max and min values. The demo shows a bar graph for each axis expressed
+in native numerical format, plus a 'centered' X-Y axis compass showing the relationship
+of that input to the calculated stick position.
+
+Analog input may be jumpy and spurious, so the control has a means of 'smoothing' the
+analog data by setting a movement threshold. This demo sets the threshold to 10, but
+you can set it at any valid value between the min and max.
+
+
Button Input
+
+Button state is retrieved as one int that contains each button state mapped to a bit.
+You get the state of a button by AND-ing its bit against the returned value, in the form
+
+
+ # assume buttonState is what the stick returned, and buttonBit
+ # is the bit you want to examine
+
+ if (buttonState & ( 1 << buttonBit )) :
+ # button pressed, do something with it
+
+
+
The problem here is that some OSs return a 32-bit value for up to 32 buttons
+(imagine that stick!). Python V2.3 will generate an exception for bit
+values over 30. For that reason, this demo is limited to 16 buttons.
+
+
Note that more than one button can be pressed at a time, so be sure to check all of them!
+
+
+
POV Input
+
+POV hats come in two flavors: four-way, and continuous. four-way POVs are restricted to
+the cardinal points of the compass; continuous, or CTS POV hats can deliver input in
+.01 degree increments, theoreticaly. The data is returned as a whole number; the last
+two digits are considered to be to the right of the decimal point, so in order to
+use this information, you need to divide by 100 right off the bat.
+
+
Different methods are provided to retrieve the POV data for a CTS hat
+versus a four-way hat.
+
+
Caveats
+
+The wx.Joystick control is in many ways incomplete at the C++ library level, but it is
+not insurmountable. In short, while the joystick interface can be event-driven,
+the wx.JoystickEvent class lacks event binders for all event types. Thus, you cannot
+rely on wx.JoystickEvents to tell you when something has changed, necessarilly.
+
+
+
There are no events associated with the POV control.
+
There are no events associated with the Rudder
+
There are no events associated with the U and V axes.
+
+
+
Fortunately, there is an easy workaround. In the top level frame, create a wx.Timer
+that will poll the stick at a set interval. Of course, if you do this, you might as
+well forgo catching wxEVT_JOYSTICK_* events at all and rely on the timer to do the
+polling.
+
+
+ A class that implements Delphi's Anchors with wxLayoutConstraints.
+
+ Anchored sides maintain the distance from the edge of the
+ control to the same edge of the parent.
+ When neither side is selected, the control keeps the same
+ relative position to both sides.
+
+ The current position and size of the control and it's parent
+ is used when setting up the constraints. To change the size or
+ position of an already anchored control, set the constraints to
+ None, reposition or resize and reapply the anchors.
+
+ Examples:
+
+ Let's anchor the right and bottom edge of a control and
+ resize it's parent.
+
The class consists of the following eight constraints of class
+wxIndividualLayoutConstraint, some or all of which should be accessed
+directly to set the appropriate constraints.
+
+
+
left: represents the left hand edge of the window
+
+
right: represents the right hand edge of the window
+
+
top: represents the top edge of the window
+
+
bottom: represents the bottom edge of the window
+
+
width: represents the width of the window
+
+
height: represents the height of the window
+
+
centreX: represents the horizontal centre point of the window
+
+
centreY: represents the vertical centre point of the window
+
+
Most constraints are initially set to have the relationship
+wxUnconstrained, which means that their values should be calculated by
+looking at known constraints. The exceptions are width and height,
+which are set to wxAsIs to ensure that if the user does not specify a
+constraint, the existing width and height will be used, to be
+compatible with panel items which often have take a default size. If
+the constraint is wxAsIs, the dimension will not be changed.
+
+"""
+
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Layoutf.py b/demo/Layoutf.py
new file mode 100644
index 00000000..b5b5e385
--- /dev/null
+++ b/demo/Layoutf.py
@@ -0,0 +1,68 @@
+
+import wx
+import wx.lib.layoutf as layoutf
+
+#---------------------------------------------------------------------------
+
+class TestLayoutf(wx.Panel):
+ def __init__(self, parent):
+ wx.Panel.__init__(self, parent, -1)
+
+ self.SetAutoLayout(True)
+ self.Bind(wx.EVT_BUTTON, self.OnButton)
+
+ self.panelA = wx.Window(self, -1, style=wx.SIMPLE_BORDER)
+ self.panelA.SetBackgroundColour(wx.BLUE)
+ self.panelA.SetConstraints(
+ layoutf.Layoutf('t=t10#1;l=l10#1;b=b10#1;r%r50#1',(self,))
+ )
+
+ self.panelB = wx.Window(self, -1, style=wx.SIMPLE_BORDER)
+ self.panelB.SetBackgroundColour(wx.RED)
+ self.panelB.SetConstraints(
+ layoutf.Layoutf('t=t10#1;r=r10#1;b%b30#1;l>10#2', (self,self.panelA))
+ )
+
+ self.panelC = wx.Window(self, -1, style=wx.SIMPLE_BORDER)
+ self.panelC.SetBackgroundColour(wx.WHITE)
+ self.panelC.SetConstraints(
+ layoutf.Layoutf('t_10#3;r=r10#1;b=b10#1;l>10#2', (self,self.panelA,self.panelB))
+ )
+
+ b = wx.Button(self.panelA, -1, ' Panel A ')
+ b.SetConstraints(layoutf.Layoutf('X=X#1;Y=Y#1;h*;w%w50#1', (self.panelA,)))
+
+ b = wx.Button(self.panelB, -1, ' Panel B ')
+ b.SetConstraints(layoutf.Layoutf('t=t2#1;r=r4#1;h*;w*', (self.panelB,)))
+
+ self.panelD = wx.Window(self.panelC, -1, style=wx.SIMPLE_BORDER)
+ self.panelD.SetBackgroundColour(wx.GREEN)
+ self.panelD.SetConstraints(
+ layoutf.Layoutf('b%h50#1;r%w50#1;h=h#2;w=w#2', (self.panelC, b))
+ )
+
+ b = wx.Button(self.panelC, -1, ' Panel C ')
+ b.SetConstraints(layoutf.Layoutf('t_#1;l>#1;h*;w*', (self.panelD,)))
+
+ wx.StaticText(self.panelD, -1, "Panel D", (4, 4)).SetBackgroundColour(wx.GREEN)
+
+ def OnButton(self, event):
+ wx.Bell()
+
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestLayoutf(nb)
+ return win
+
+#---------------------------------------------------------------------------
+
+overview = layoutf.Layoutf.__doc__
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ListBox.py b/demo/ListBox.py
new file mode 100644
index 00000000..0e1816a8
--- /dev/null
+++ b/demo/ListBox.py
@@ -0,0 +1,161 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+# This listbox subclass lets you type the starting letters of what you want to
+# select, and scrolls the list to the match if it is found.
+class FindPrefixListBox(wx.ListBox):
+ def __init__(self, parent, id, pos=wx.DefaultPosition, size=wx.DefaultSize,
+ choices=[], style=0, validator=wx.DefaultValidator):
+ wx.ListBox.__init__(self, parent, id, pos, size, choices, style, validator)
+ self.typedText = ''
+ self.log = parent.log
+ self.Bind(wx.EVT_KEY_DOWN, self.OnKey)
+
+
+ def FindPrefix(self, prefix):
+ self.log.WriteText('Looking for prefix: %s\n' % prefix)
+
+ if prefix:
+ prefix = prefix.lower()
+ length = len(prefix)
+
+ # Changed in 2.5 because ListBox.Number() is no longer supported.
+ # ListBox.GetCount() is now the appropriate way to go.
+ for x in range(self.GetCount()):
+ text = self.GetString(x)
+ text = text.lower()
+
+ if text[:length] == prefix:
+ self.log.WriteText('Prefix %s is found.\n' % prefix)
+ return x
+
+ self.log.WriteText('Prefix %s is not found.\n' % prefix)
+ return -1
+
+
+ def OnKey(self, evt):
+ key = evt.GetKeyCode()
+
+ if key >= 32 and key <= 127:
+ self.typedText = self.typedText + chr(key)
+ item = self.FindPrefix(self.typedText)
+
+ if item != -1:
+ self.SetSelection(item)
+
+ elif key == wx.WXK_BACK: # backspace removes one character and backs up
+ self.typedText = self.typedText[:-1]
+
+ if not self.typedText:
+ self.SetSelection(0)
+ else:
+ item = self.FindPrefix(self.typedText)
+
+ if item != -1:
+ self.SetSelection(item)
+ else:
+ self.typedText = ''
+ evt.Skip()
+
+ def OnKeyDown(self, evt):
+ pass
+
+
+#---------------------------------------------------------------------------
+
+class TestListBox(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ sampleList = ['zero', 'one', 'two', 'three', 'four', 'five',
+ 'six', 'seven', 'eight', 'nine', 'ten', 'eleven',
+ 'twelve', 'thirteen', 'fourteen']
+
+ wx.StaticText(self, -1, "This example uses the wx.ListBox control.", (45, 10))
+ wx.StaticText(self, -1, "Select one:", (15, 50))
+ self.lb1 = wx.ListBox(self, 60, (100, 50), (90, 120), sampleList, wx.LB_SINGLE)
+ self.Bind(wx.EVT_LISTBOX, self.EvtListBox, self.lb1)
+ self.Bind(wx.EVT_LISTBOX_DCLICK, self.EvtListBoxDClick, self.lb1)
+ self.lb1.Bind(wx.EVT_RIGHT_UP, self.EvtRightButton)
+ self.lb1.SetSelection(3)
+ self.lb1.Append("with data", "This one has data");
+ self.lb1.SetClientData(2, "This one has data");
+
+
+ wx.StaticText(self, -1, "Select many:", (220, 50))
+ self.lb2 = wx.ListBox(self, 70, (320, 50), (90, 120), sampleList, wx.LB_EXTENDED)
+ self.Bind(wx.EVT_LISTBOX, self.EvtMultiListBox, self.lb2)
+ self.lb2.Bind(wx.EVT_RIGHT_UP, self.EvtRightButton)
+ self.lb2.SetSelection(0)
+
+ sampleList = sampleList + ['test a', 'test aa', 'test aab',
+ 'test ab', 'test abc', 'test abcc',
+ 'test abcd' ]
+ sampleList.sort()
+ wx.StaticText(self, -1, "Find Prefix:", (15, 250))
+ fp = FindPrefixListBox(self, -1, (100, 250), (90, 120), sampleList, wx.LB_SINGLE)
+ fp.SetSelection(0)
+
+
+ def EvtListBox(self, event):
+ self.log.WriteText('EvtListBox: %s, %s, %s, %s\n' %
+ (event.GetString(),
+ event.IsSelection(),
+ event.GetSelection(),
+ event.GetClientData()))
+
+ lb = event.GetEventObject()
+ data = lb.GetClientData(lb.GetSelection())
+
+ if data is not None:
+ self.log.WriteText('\tdata: %s\n' % data)
+
+
+ def EvtListBoxDClick(self, event):
+ self.log.WriteText('EvtListBoxDClick: %s\n' % self.lb1.GetSelection())
+ self.lb1.Delete(self.lb1.GetSelection())
+
+ def EvtMultiListBox(self, event):
+ self.log.WriteText('EvtMultiListBox: %s\n' % str(self.lb2.GetSelections()))
+
+ def EvtRightButton(self, event):
+ self.log.WriteText('EvtRightButton: %s\n' % event.GetPosition())
+
+ if event.GetEventObject().GetId() == 70:
+ selections = list(self.lb2.GetSelections())
+ selections.reverse()
+
+ for index in selections:
+ self.lb2.Delete(index)
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestListBox(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+
+
+overview = """
+A listbox is used to select one or more of a list of
+strings. The strings are displayed in a scrolling box, with the
+selected string(s) marked in reverse video. A listbox can be single
+selection (if an item is selected, the previous selection is removed)
+or multiple selection (clicking an item toggles the item on or off
+independently of other selections).
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ListCtrl.py b/demo/ListCtrl.py
new file mode 100644
index 00000000..7ad06c1d
--- /dev/null
+++ b/demo/ListCtrl.py
@@ -0,0 +1,513 @@
+#----------------------------------------------------------------------------
+# Name: ListCtrl.py
+# Purpose: Testing lots of stuff, controls, window types, etc.
+#
+# Author: Robin Dunn & Gary Dumer
+#
+# Created:
+# RCS-ID: $Id$
+# Copyright: (c) 1998 by Total Control Software
+# Licence: wxWindows license
+#----------------------------------------------------------------------------
+
+import sys
+import wx
+import wx.lib.mixins.listctrl as listmix
+
+import images
+
+#---------------------------------------------------------------------------
+
+musicdata = {
+1 : ("Bad English", "The Price Of Love", "Rock"),
+2 : ("DNA featuring Suzanne Vega", "Tom's Diner", "Rock"),
+3 : ("George Michael", "Praying For Time", "Rock"),
+4 : ("Gloria Estefan", "Here We Are", "Rock"),
+5 : ("Linda Ronstadt", "Don't Know Much", "Rock"),
+6 : ("Michael Bolton", "How Am I Supposed To Live Without You", "Blues"),
+7 : ("Paul Young", "Oh Girl", "Rock"),
+8 : ("Paula Abdul", "Opposites Attract", "Rock"),
+9 : ("Richard Marx", "Should've Known Better", "Rock"),
+10: ("Rod Stewart", "Forever Young", "Rock"),
+11: ("Roxette", "Dangerous", "Rock"),
+12: ("Sheena Easton", "The Lover In Me", "Rock"),
+13: ("Sinead O'Connor", "Nothing Compares 2 U", "Rock"),
+14: ("Stevie B.", "Because I Love You", "Rock"),
+15: ("Taylor Dayne", "Love Will Lead You Back", "Rock"),
+16: ("The Bangles", "Eternal Flame", "Rock"),
+17: ("Wilson Phillips", "Release Me", "Rock"),
+18: ("Billy Joel", "Blonde Over Blue", "Rock"),
+19: ("Billy Joel", "Famous Last Words", "Rock"),
+20: ("Janet Jackson", "State Of The World", "Rock"),
+21: ("Janet Jackson", "The Knowledge", "Rock"),
+22: ("Spyro Gyra", "End of Romanticism", "Jazz"),
+23: ("Spyro Gyra", "Heliopolis", "Jazz"),
+24: ("Spyro Gyra", "Jubilee", "Jazz"),
+25: ("Spyro Gyra", "Little Linda", "Jazz"),
+26: ("Spyro Gyra", "Morning Dance", "Jazz"),
+27: ("Spyro Gyra", "Song for Lorraine", "Jazz"),
+28: ("Yes", "Owner Of A Lonely Heart", "Rock"),
+29: ("Yes", "Rhythm Of Love", "Rock"),
+30: ("Billy Joel", "Lullabye (Goodnight, My Angel)", "Rock"),
+31: ("Billy Joel", "The River Of Dreams", "Rock"),
+32: ("Billy Joel", "Two Thousand Years", "Rock"),
+33: ("Janet Jackson", "Alright", "Rock"),
+34: ("Janet Jackson", "Black Cat", "Rock"),
+35: ("Janet Jackson", "Come Back To Me", "Rock"),
+36: ("Janet Jackson", "Escapade", "Rock"),
+37: ("Janet Jackson", "Love Will Never Do (Without You)", "Rock"),
+38: ("Janet Jackson", "Miss You Much", "Rock"),
+39: ("Janet Jackson", "Rhythm Nation", "Rock"),
+40: ("Cusco", "Dream Catcher", "New Age"),
+41: ("Cusco", "Geronimos Laughter", "New Age"),
+42: ("Cusco", "Ghost Dance", "New Age"),
+43: ("Blue Man Group", "Drumbone", "New Age"),
+44: ("Blue Man Group", "Endless Column", "New Age"),
+45: ("Blue Man Group", "Klein Mandelbrot", "New Age"),
+46: ("Kenny G", "Silhouette", "Jazz"),
+47: ("Sade", "Smooth Operator", "Jazz"),
+48: ("David Arkenstone", "Papillon (On The Wings Of The Butterfly)", "New Age"),
+49: ("David Arkenstone", "Stepping Stars", "New Age"),
+50: ("David Arkenstone", "Carnation Lily Lily Rose", "New Age"),
+51: ("David Lanz", "Behind The Waterfall", "New Age"),
+52: ("David Lanz", "Cristofori's Dream", "New Age"),
+53: ("David Lanz", "Heartsounds", "New Age"),
+54: ("David Lanz", "Leaves on the Seine", "New Age"),
+}
+
+#---------------------------------------------------------------------------
+
+class TestListCtrl(wx.ListCtrl, listmix.ListCtrlAutoWidthMixin):
+ def __init__(self, parent, ID, pos=wx.DefaultPosition,
+ size=wx.DefaultSize, style=0):
+ wx.ListCtrl.__init__(self, parent, ID, pos, size, style)
+ listmix.ListCtrlAutoWidthMixin.__init__(self)
+
+
+class TestListCtrlPanel(wx.Panel, listmix.ColumnSorterMixin):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1, style=wx.WANTS_CHARS)
+
+ self.log = log
+ tID = wx.NewId()
+
+ 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.il = wx.ImageList(16, 16)
+
+ self.idx1 = self.il.Add(images.Smiles.GetBitmap())
+ self.sm_up = self.il.Add(images.SmallUpArrow.GetBitmap())
+ self.sm_dn = self.il.Add(images.SmallDnArrow.GetBitmap())
+
+ self.list = TestListCtrl(self, tID,
+ style=wx.LC_REPORT
+ #| wx.BORDER_SUNKEN
+ | wx.BORDER_NONE
+ | wx.LC_EDIT_LABELS
+ | wx.LC_SORT_ASCENDING
+ #| wx.LC_NO_HEADER
+ #| wx.LC_VRULES
+ #| wx.LC_HRULES
+ #| wx.LC_SINGLE_SEL
+ )
+
+ self.list.SetImageList(self.il, wx.IMAGE_LIST_SMALL)
+ sizer.Add(self.list, 1, wx.EXPAND)
+
+ self.PopulateList()
+
+ # Now that the list exists we can init the other base class,
+ # see wx/lib/mixins/listctrl.py
+ self.itemDataMap = musicdata
+ listmix.ColumnSorterMixin.__init__(self, 3)
+ #self.SortListItems(0, True)
+
+ self.SetSizer(sizer)
+ self.SetAutoLayout(True)
+
+ self.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnItemSelected, self.list)
+ self.Bind(wx.EVT_LIST_ITEM_DESELECTED, self.OnItemDeselected, self.list)
+ self.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnItemActivated, self.list)
+ self.Bind(wx.EVT_LIST_DELETE_ITEM, self.OnItemDelete, self.list)
+ self.Bind(wx.EVT_LIST_COL_CLICK, self.OnColClick, self.list)
+ self.Bind(wx.EVT_LIST_COL_RIGHT_CLICK, self.OnColRightClick, self.list)
+ self.Bind(wx.EVT_LIST_COL_BEGIN_DRAG, self.OnColBeginDrag, self.list)
+ self.Bind(wx.EVT_LIST_COL_DRAGGING, self.OnColDragging, self.list)
+ self.Bind(wx.EVT_LIST_COL_END_DRAG, self.OnColEndDrag, self.list)
+ self.Bind(wx.EVT_LIST_BEGIN_LABEL_EDIT, self.OnBeginEdit, self.list)
+
+ self.list.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)
+ self.list.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
+
+ # for wxMSW
+ self.list.Bind(wx.EVT_COMMAND_RIGHT_CLICK, self.OnRightClick)
+
+ # for wxGTK
+ self.list.Bind(wx.EVT_RIGHT_UP, self.OnRightClick)
+
+
+ def OnUseNative(self, event):
+ wx.SystemOptions.SetOptionInt("mac.listctrl.always_use_generic", not event.IsChecked())
+ wx.GetApp().GetTopWindow().LoadDemo("ListCtrl")
+
+ def PopulateList(self):
+ if 0:
+ # for normal, simple columns, you can add them like this:
+ self.list.InsertColumn(0, "Artist")
+ self.list.InsertColumn(1, "Title", wx.LIST_FORMAT_RIGHT)
+ self.list.InsertColumn(2, "Genre")
+ else:
+ # but since we want images on the column header we have to do it the hard way:
+ info = wx.ListItem()
+ info.m_mask = wx.LIST_MASK_TEXT | wx.LIST_MASK_IMAGE | wx.LIST_MASK_FORMAT
+ info.m_image = -1
+ info.m_format = 0
+ info.m_text = "Artist"
+ self.list.InsertColumnInfo(0, info)
+
+ info.m_format = wx.LIST_FORMAT_RIGHT
+ info.m_text = "Title"
+ self.list.InsertColumnInfo(1, info)
+
+ info.m_format = 0
+ info.m_text = "Genre"
+ self.list.InsertColumnInfo(2, info)
+
+ items = musicdata.items()
+ for key, data in items:
+ index = self.list.InsertImageStringItem(sys.maxint, data[0], self.idx1)
+ self.list.SetStringItem(index, 1, data[1])
+ self.list.SetStringItem(index, 2, data[2])
+ self.list.SetItemData(index, key)
+
+ self.list.SetColumnWidth(0, wx.LIST_AUTOSIZE)
+ self.list.SetColumnWidth(1, wx.LIST_AUTOSIZE)
+ self.list.SetColumnWidth(2, 100)
+
+ # show how to select an item
+ self.list.SetItemState(5, wx.LIST_STATE_SELECTED, wx.LIST_STATE_SELECTED)
+
+ # show how to change the colour of a couple items
+ item = self.list.GetItem(1)
+ item.SetTextColour(wx.BLUE)
+ self.list.SetItem(item)
+ item = self.list.GetItem(4)
+ item.SetTextColour(wx.RED)
+ self.list.SetItem(item)
+
+ self.currentItem = 0
+
+
+ # Used by the ColumnSorterMixin, see wx/lib/mixins/listctrl.py
+ def GetListCtrl(self):
+ return self.list
+
+ # Used by the ColumnSorterMixin, see wx/lib/mixins/listctrl.py
+ def GetSortImages(self):
+ return (self.sm_dn, self.sm_up)
+
+
+ def OnRightDown(self, event):
+ x = event.GetX()
+ y = event.GetY()
+ self.log.WriteText("x, y = %s\n" % str((x, y)))
+ item, flags = self.list.HitTest((x, y))
+
+ if item != wx.NOT_FOUND and flags & wx.LIST_HITTEST_ONITEM:
+ self.list.Select(item)
+
+ event.Skip()
+
+
+ def getColumnText(self, index, col):
+ item = self.list.GetItem(index, col)
+ return item.GetText()
+
+
+ def OnItemSelected(self, event):
+ ##print event.GetItem().GetTextColour()
+ self.currentItem = event.m_itemIndex
+ self.log.WriteText("OnItemSelected: %s, %s, %s, %s\n" %
+ (self.currentItem,
+ self.list.GetItemText(self.currentItem),
+ self.getColumnText(self.currentItem, 1),
+ self.getColumnText(self.currentItem, 2)))
+
+ if self.currentItem == 10:
+ self.log.WriteText("OnItemSelected: Veto'd selection\n")
+ #event.Veto() # doesn't work
+ # this does
+ self.list.SetItemState(10, 0, wx.LIST_STATE_SELECTED)
+
+ event.Skip()
+
+
+ def OnItemDeselected(self, evt):
+ item = evt.GetItem()
+ self.log.WriteText("OnItemDeselected: %d" % evt.m_itemIndex)
+
+ # Show how to reselect something we don't want deselected
+ if evt.m_itemIndex == 11:
+ wx.CallAfter(self.list.SetItemState, 11, wx.LIST_STATE_SELECTED, wx.LIST_STATE_SELECTED)
+
+
+ def OnItemActivated(self, event):
+ self.currentItem = event.m_itemIndex
+ self.log.WriteText("OnItemActivated: %s\nTopItem: %s" %
+ (self.list.GetItemText(self.currentItem), self.list.GetTopItem()))
+
+ def OnBeginEdit(self, event):
+ self.log.WriteText("OnBeginEdit")
+ event.Allow()
+
+ def OnItemDelete(self, event):
+ self.log.WriteText("OnItemDelete\n")
+
+ def OnColClick(self, event):
+ self.log.WriteText("OnColClick: %d\n" % event.GetColumn())
+ event.Skip()
+
+ def OnColRightClick(self, event):
+ item = self.list.GetColumn(event.GetColumn())
+ self.log.WriteText("OnColRightClick: %d %s\n" %
+ (event.GetColumn(), (item.GetText(), item.GetAlign(),
+ item.GetWidth(), item.GetImage())))
+ if self.list.HasColumnOrderSupport():
+ self.log.WriteText("OnColRightClick: column order: %d\n" %
+ self.list.GetColumnOrder(event.GetColumn()))
+
+ def OnColBeginDrag(self, event):
+ self.log.WriteText("OnColBeginDrag\n")
+ ## Show how to not allow a column to be resized
+ #if event.GetColumn() == 0:
+ # event.Veto()
+
+
+ def OnColDragging(self, event):
+ self.log.WriteText("OnColDragging\n")
+
+ def OnColEndDrag(self, event):
+ self.log.WriteText("OnColEndDrag\n")
+
+ def OnDoubleClick(self, event):
+ self.log.WriteText("OnDoubleClick item %s\n" % self.list.GetItemText(self.currentItem))
+ event.Skip()
+
+ def OnRightClick(self, event):
+ self.log.WriteText("OnRightClick %s\n" % self.list.GetItemText(self.currentItem))
+
+ # only do this part the first time so the events are only bound once
+ if not hasattr(self, "popupID1"):
+ self.popupID1 = wx.NewId()
+ self.popupID2 = wx.NewId()
+ self.popupID3 = wx.NewId()
+ self.popupID4 = wx.NewId()
+ self.popupID5 = wx.NewId()
+ self.popupID6 = wx.NewId()
+
+ self.Bind(wx.EVT_MENU, self.OnPopupOne, id=self.popupID1)
+ self.Bind(wx.EVT_MENU, self.OnPopupTwo, id=self.popupID2)
+ self.Bind(wx.EVT_MENU, self.OnPopupThree, id=self.popupID3)
+ self.Bind(wx.EVT_MENU, self.OnPopupFour, id=self.popupID4)
+ self.Bind(wx.EVT_MENU, self.OnPopupFive, id=self.popupID5)
+ self.Bind(wx.EVT_MENU, self.OnPopupSix, id=self.popupID6)
+
+ # make a menu
+ menu = wx.Menu()
+ # add some items
+ menu.Append(self.popupID1, "FindItem tests")
+ menu.Append(self.popupID2, "Iterate Selected")
+ menu.Append(self.popupID3, "ClearAll and repopulate")
+ menu.Append(self.popupID4, "DeleteAllItems")
+ menu.Append(self.popupID5, "GetItem")
+ menu.Append(self.popupID6, "Edit")
+
+ # Popup the menu. If an item is selected then its handler
+ # will be called before PopupMenu returns.
+ self.PopupMenu(menu)
+ menu.Destroy()
+
+
+ def OnPopupOne(self, event):
+ self.log.WriteText("Popup one\n")
+ print "FindItem:", self.list.FindItem(-1, "Roxette")
+ print "FindItemData:", self.list.FindItemData(-1, 11)
+
+ def OnPopupTwo(self, event):
+ self.log.WriteText("Selected items:\n")
+ index = self.list.GetFirstSelected()
+
+ while index != -1:
+ self.log.WriteText(" %s: %s\n" % (self.list.GetItemText(index), self.getColumnText(index, 1)))
+ index = self.list.GetNextSelected(index)
+
+ def OnPopupThree(self, event):
+ self.log.WriteText("Popup three\n")
+ self.list.ClearAll()
+ wx.CallAfter(self.PopulateList)
+
+ def OnPopupFour(self, event):
+ self.list.DeleteAllItems()
+
+ def OnPopupFive(self, event):
+ item = self.list.GetItem(self.currentItem)
+ print item.m_text, item.m_itemId, self.list.GetItemData(self.currentItem)
+
+ def OnPopupSix(self, event):
+ self.list.EditLabel(self.currentItem)
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestListCtrlPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+
+
+A list control presents lists in a number of formats: list view, report view,
+icon view and small icon view. In any case, elements are numbered from zero.
+For all these modes (but not for virtual list controls), the items are stored
+in the control and must be added to it using InsertItem method.
+
+
To intercept events from a list control, use the event table macros described in
+wxListEvent.
+
+
Mix-ins
+This example demonstrates how to use mixins. The following mixins are available.
+
+
ColumnSorterMixin
+
+ColumnSorterMixin(numColumns)
+
+
A mixin class that handles sorting of a wxListCtrl in REPORT mode when the column
+header is clicked on.
+
+
There are a few requirments needed in order for this to work genericly:
+
+
The combined class must have a GetListCtrl method that returns
+ the ListCtrl to be sorted, and the list control must exist at the time the
+ ColumnSorterMixin.__init__()method is called because it uses
+ GetListCtrl.
+
+
Items in the list control must have a unique data value set with
+ list.SetItemData.
+
+
The combined class must have an attribute named itemDataMap
+ that is a dictionary mapping the data values to a sequence of objects
+ representing the values in each column. These valuesare compared in
+ the column sorter to determine sort order.
+
+
+
Interesting methods to override are GetColumnSorter,
+GetSecondarySortValues, and GetSortImages.
+
+
Methods
+
+
SetColumnCount(newNumColumns)
+
Informs the mixin as to the number of columns in the control. When it is
+set, it also sets up an event handler for EVT_LIST_COL_CLICK events.
+
+
SortListItems(col=-1, ascending=1)
+
Sort the list on demand. Can also be used to set the sort column and order.
+
+
GetColumnWidths()
+
Returns a list of column widths. Can be used to help restore the current
+view later.
+
+
GetSortImages()
+
Returns a tuple of image list indexes the indexes in the image list for an
+image to be put on the column header when sorting in descending order
+
+
GetColumnSorter()
+
Returns a callable object to be used for comparing column values when sorting.
+
+
GetSecondarySortValues(col, key1, key2)
+
Returns a tuple of 2 values to use for secondary sort values when the
+items in the selected column match equal. The default just returns the
+item data values.
+
+
+
+
ListCtrlAutoWidthMixin
+
+ListCtrlAutoWidthMixin()
+
+
A mix-in class that automatically resizes the last column to take up the
+remaining width of the ListCtrl.
+
+
This causes the ListCtrl to automatically take up the full width of the list,
+without either a horizontal scroll bar (unless absolutely necessary) or empty
+space to the right of the last column.
+
+
NOTE: This only works for report-style lists.
+
+
WARNING: If you override the EVT_SIZE event in your ListCtrl,
+make sure you call event.Skip() to ensure that the mixin's _OnResize method is
+called.
+
+
Resize the last column appropriately. If the list's columns are too wide to
+fit within the window, we use a horizontal scrollbar. Otherwise, we expand the
+right-most column to take up the remaining free space in the list. This method is
+called automatically when the ListCtrl is resized; you can also call it yourself
+whenever you want the last column to be resized appropriately (eg, when adding,
+removing or resizing columns). 'minWidth' is the preferred minimum width for
+the last column.
+
+
+
+
+
ListCtrlSelectionManagerMix
+
+ListCtrlSelectionManagerMix()
+
+
Mixin that defines a platform independent selection policy
+
+
As selection single and multi-select list return the item index or a
+list of item indexes respectively.
+
+
Methods
+
+
+
getPopupMenu()
+
Override to implement dynamic menus (create)
+
+
setPopupMenu(menu)
+
Must be set for default behaviour.
+
+
afterPopupMenu()
+
Override to implement dynamic menus (destroy).
+
+
getSelection()
+
Returns the current selection (or selections as a Python list if extended
+selection is enabled)
+
+
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ListCtrl_edit.py b/demo/ListCtrl_edit.py
new file mode 100644
index 00000000..f352931e
--- /dev/null
+++ b/demo/ListCtrl_edit.py
@@ -0,0 +1,152 @@
+#----------------------------------------------------------------------------
+# Name: ListCtrl_edit.py
+# Purpose: Testing editing a ListCtrl
+#
+# Author: Pim van Heuven
+#
+# Created: 2004/10/15
+# Copyright: (c) Pim Van Heuven
+# Licence: wxWindows license
+#----------------------------------------------------------------------------
+
+import sys
+import wx
+import wx.lib.mixins.listctrl as listmix
+
+#---------------------------------------------------------------------------
+
+listctrldata = {
+1 : ("Hey!", "You can edit", "me!"),
+2 : ("Try changing the contents", "by", "clicking"),
+3 : ("in", "a", "cell"),
+4 : ("See how the length columns", "change", "?"),
+5 : ("You can use", "TAB,", "cursor down,"),
+6 : ("and cursor up", "to", "navigate"),
+}
+
+#---------------------------------------------------------------------------
+
+class TestListCtrl(wx.ListCtrl,
+ listmix.ListCtrlAutoWidthMixin,
+ listmix.TextEditMixin):
+
+ def __init__(self, parent, ID, pos=wx.DefaultPosition,
+ size=wx.DefaultSize, style=0):
+ wx.ListCtrl.__init__(self, parent, ID, pos, size, style)
+
+ listmix.ListCtrlAutoWidthMixin.__init__(self)
+ self.Populate()
+ listmix.TextEditMixin.__init__(self)
+
+ def Populate(self):
+ # for normal, simple columns, you can add them like this:
+ self.InsertColumn(0, "Column 1")
+ self.InsertColumn(1, "Column 2")
+ self.InsertColumn(2, "Column 3")
+ self.InsertColumn(3, "Len 1", wx.LIST_FORMAT_RIGHT)
+ self.InsertColumn(4, "Len 2", wx.LIST_FORMAT_RIGHT)
+ self.InsertColumn(5, "Len 3", wx.LIST_FORMAT_RIGHT)
+
+ items = listctrldata.items()
+ for key, data in items:
+ index = self.InsertStringItem(sys.maxint, data[0])
+ self.SetStringItem(index, 1, data[1])
+ self.SetStringItem(index, 2, data[2])
+ self.SetItemData(index, key)
+
+ self.SetColumnWidth(0, wx.LIST_AUTOSIZE)
+ self.SetColumnWidth(1, wx.LIST_AUTOSIZE)
+ self.SetColumnWidth(2, 100)
+
+ self.currentItem = 0
+
+
+ def SetStringItem(self, index, col, data):
+ if col in range(3):
+ wx.ListCtrl.SetStringItem(self, index, col, data)
+ wx.ListCtrl.SetStringItem(self, index, 3+col, str(len(data)))
+ else:
+ try:
+ datalen = int(data)
+ except:
+ return
+
+ wx.ListCtrl.SetStringItem(self, index, col, data)
+
+ data = self.GetItem(index, col-3).GetText()
+ wx.ListCtrl.SetStringItem(self, index, col-3, data[0:datalen])
+
+
+
+
+class TestListCtrlPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1, style=wx.WANTS_CHARS)
+
+ self.log = log
+ tID = wx.NewId()
+
+ 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 = TestListCtrl(self, tID,
+ style=wx.LC_REPORT
+ | wx.BORDER_NONE
+ | wx.LC_SORT_ASCENDING
+ )
+
+ 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_edit")
+
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestListCtrlPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+
+
+
+This demo demonstrates direct editing of all cells of a ListCtrl. To
+enable it just include the TextEditMixin. The ListCtrl can be
+navigated with the TAB and up/down cursor keys.
+
+
Another facet of this demo is that the remaining space of the
+ListCtrls is divided over the first three columns. This is achieved
+with the extended syntax of ListCtrlAutoWidthMixin:
+listmix.ListCtrlAutoWidthMixin.__init__(self, startcol, endcol)
+(Look at the general ListCtrl demo for more information about the
+ListCtrlAutoWidthMixin)
+
+
Finally, the ListCtrl is automatically scrolled, if needed, when
+TAB is pressed consecutively (Windows only).
+
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ListCtrl_virtual.py b/demo/ListCtrl_virtual.py
new file mode 100644
index 00000000..ff211aa2
--- /dev/null
+++ b/demo/ListCtrl_virtual.py
@@ -0,0 +1,145 @@
+
+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.ListItemAttr()
+ self.attr1.SetBackgroundColour("yellow")
+
+ self.attr2 = wx.ListItemAttr()
+ 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.EmptyBitmap(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.m_itemIndex
+ 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.m_itemIndex
+ 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.m_itemIndex)
+
+
+ #-----------------------------------------------------------------
+ # 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 OnGetItemText(), OnGetItemImage(),
+and OnGetItemAttr(). 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:])
+
diff --git a/demo/Listbook.py b/demo/Listbook.py
new file mode 100644
index 00000000..f5840e56
--- /dev/null
+++ b/demo/Listbook.py
@@ -0,0 +1,103 @@
+
+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 = """\
+
+
wx.Listbook
+
+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:])
+
+
+
diff --git a/demo/MDIDemo.py b/demo/MDIDemo.py
new file mode 100644
index 00000000..d884f114
--- /dev/null
+++ b/demo/MDIDemo.py
@@ -0,0 +1,87 @@
+
+import wx
+
+# Importing ScrolledWindow demo to make use of the MyCanvas
+# class defined within.
+import ScrolledWindow
+import images
+
+SHOW_BACKGROUND = 1
+
+#----------------------------------------------------------------------
+ID_New = wx.NewId()
+ID_Exit = wx.NewId()
+#----------------------------------------------------------------------
+
+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
+ sz = self.GetClientSize()
+ 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()
+
+
+
diff --git a/demo/MDISashDemo.py b/demo/MDISashDemo.py
new file mode 100644
index 00000000..ad7b3261
--- /dev/null
+++ b/demo/MDISashDemo.py
@@ -0,0 +1,151 @@
+#!/usr/bin/env python
+
+import wx
+
+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.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.SashLayoutWindow(self, ID_WINDOW_TOP, style=wx.NO_BORDER|wx.SW_3D)
+ win.SetDefaultSize((1000, 30))
+ win.SetOrientation(wx.LAYOUT_HORIZONTAL)
+ win.SetAlignment(wx.LAYOUT_TOP)
+ win.SetBackgroundColour(wx.Colour(255, 0, 0))
+ win.SetSashVisible(wx.SASH_BOTTOM, True)
+
+ self.topWindow = win
+
+
+ # A window like a statusbar
+ win = wx.SashLayoutWindow(self, ID_WINDOW_BOTTOM, style=wx.NO_BORDER|wx.SW_3D)
+ win.SetDefaultSize((1000, 30))
+ win.SetOrientation(wx.LAYOUT_HORIZONTAL)
+ win.SetAlignment(wx.LAYOUT_BOTTOM)
+ win.SetBackgroundColour(wx.Colour(0, 0, 255))
+ win.SetSashVisible(wx.SASH_TOP, True)
+
+ self.bottomWindow = win
+
+
+ # A window to the left of the client window
+ win = wx.SashLayoutWindow(self, ID_WINDOW_LEFT1, style=wx.NO_BORDER|wx.SW_3D)
+ win.SetDefaultSize((120, 1000))
+ win.SetOrientation(wx.LAYOUT_VERTICAL)
+ win.SetAlignment(wx.LAYOUT_LEFT)
+ win.SetBackgroundColour(wx.Colour(0, 255, 0))
+ win.SetSashVisible(wx.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.SashLayoutWindow(self, ID_WINDOW_LEFT2, style=wx.NO_BORDER|wx.SW_3D)
+ win.SetDefaultSize((120, 1000))
+ win.SetOrientation(wx.LAYOUT_VERTICAL)
+ win.SetAlignment(wx.LAYOUT_LEFT)
+ win.SetBackgroundColour(wx.Colour(0, 255, 255))
+ win.SetSashVisible(wx.SASH_RIGHT, True)
+
+ self.leftWindow2 = win
+
+
+ def OnSashDrag(self, event):
+ if event.GetDragStatus() == wx.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.LayoutAlgorithm().LayoutMDIFrame(self)
+ self.GetClientWindow().Refresh()
+
+
+ def OnSize(self, event):
+ wx.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()
+
+
+
diff --git a/demo/MDIWindows.py b/demo/MDIWindows.py
new file mode 100644
index 00000000..4fa3ad01
--- /dev/null
+++ b/demo/MDIWindows.py
@@ -0,0 +1,78 @@
+
+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")
+
+ # TODO: This hack can be removed once we fix the way the Python
+ # app bundles are generated so that they are not bundling and
+ # pointing to an otherwise unused and non-GUI-friendly version of
+ # Python on OS X.
+ def GetPyExecutable(self):
+ if 'wxMac' in wx.PlatformInfo:
+ # sys.executable will be wrong if running the demo from
+ # an app bundle. But the bundle is always using a system
+ # framework so just hardcode the path to it.
+ if sys.version[:3] == "2.4":
+ return '/usr/local/bin/pythonw', os.spawnl
+ else:
+ return '/usr/bin/pythonw', os.spawnl
+ else:
+ return sys.executable, os.spawnl
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
Multiple Document Interface
+
+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.
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/MVCTree.py b/demo/MVCTree.py
new file mode 100644
index 00000000..3f1f5256
--- /dev/null
+++ b/demo/MVCTree.py
@@ -0,0 +1,78 @@
+
+import os
+import sys
+
+import wx
+import wx.lib.mvctree as tree
+
+logger = None
+def selchanging(evt):
+ logger.write("SelChanging!\n")
+
+def selchanged(evt):
+ logger.write("SelChange!\n")
+ logger.write(str(evt.node))
+def expanded(evt):
+ logger.write("Expanded\n")
+def closed(evt):
+ logger.write("Closed!\n")
+def key(evt):
+ logger.write("Key\n")
+def add(evt):
+ logger.write("Add\n")
+def delitem(evt):
+ logger.write("Delete\n")
+
+def runTest(frame, nb, log):
+ #f = wx.Frame(frame, -1, "MVCTree", (0,0), (200,500))
+ global logger
+ logger = log
+ p = tree.MVCTree(nb, -1)
+ #f = wx.Frame(frame, -1, "MVCTree")
+ #p = tree.MVCTree(f, -1)
+ p.SetAssumeChildren(True)
+ p.SetModel(tree.LateFSTreeModel(os.path.normpath(os.getcwd() + os.sep +'..')))
+
+ #Uncomment this to enable live filename editing!
+# p.AddEditor(FileEditor(p))
+
+ p.SetMultiSelect(True)
+ tree.EVT_MVCTREE_SEL_CHANGING(p, p.GetId(), selchanging)
+ tree.EVT_MVCTREE_SEL_CHANGED(p, p.GetId(), selchanged)
+ tree.EVT_MVCTREE_ITEM_EXPANDED(p, p.GetId(), expanded)
+ tree.EVT_MVCTREE_ITEM_COLLAPSED(p, p.GetId(), closed)
+ tree.EVT_MVCTREE_ADD_ITEM(p, p.GetId(), add)
+ tree.EVT_MVCTREE_DELETE_ITEM(p, p.GetId(), delitem)
+ tree.EVT_MVCTREE_KEY_DOWN(p, p.GetId(), key)
+
+ return p
+ #frame.otherWin = f
+ #f.Show(True)
+ #return None
+
+
+overview = """\
+
+MVCTree is a control which handles hierarchical data. It is
+constructed in model-view-controller architecture, so the display of
+that data, and the content of the data can be changed greatly without
+affecting the other parts.
+
+Multiple selections are possible by holding down the Ctrl key.
+
+This demo shows the wxPython directory structure. The interesting part
+is that the tree model is late-bound to the filesystem, so the
+filenames are not retrieved until the directory is expanded. In
+mvctree.py are models for generic data, and both the early and
+late-bound filesystem models.
+
+There is also support for editing, though it's not enabled in this
+demo, to avoid accidentally renaming files!
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/Main.py b/demo/Main.py
new file mode 100644
index 00000000..f3ff53b6
--- /dev/null
+++ b/demo/Main.py
@@ -0,0 +1,3009 @@
+#!/bin/env python
+#----------------------------------------------------------------------------
+# Name: Main.py
+# Purpose: Testing lots of stuff, controls, window types, etc.
+#
+# Author: Robin Dunn
+#
+# Created: A long time ago, in a galaxy far, far away...
+# RCS-ID: $Id$
+# Copyright: (c) 1999 by Total Control Software
+# Licence: wxWindows license
+#----------------------------------------------------------------------------
+
+# FIXME List:
+# * Problems with flickering related to ERASE_BACKGROUND
+# and the splitters. Might be a problem with this 2.5 beta...?
+# UPDATE: can't see on 2.5.2 GTK - maybe just a faster machine :)
+# * Demo Code menu?
+# * Annoying switching between tabs and resulting flicker
+# how to replace a page in the notebook without deleting/adding?
+# Where is SetPage!? tried freeze...tried reparent of dummy panel....
+# AG: It looks like this issue is fixed by Freeze()ing and Thaw()ing the
+# main frame and not the notebook
+
+# TODO List:
+# * UI design more professional (is the new version more professional?)
+# * save file positions (new field in demoModules) (@ LoadDemoSource)
+# * Update main overview
+
+# * Why don't we move _treeList into a separate module
+
+# =====================
+# = EXTERNAL Packages =
+# =====================
+# In order to let a package (like AGW) be included in the wxPython demo,
+# the package owner should create a sub-directory of the wxPython demo folder
+# in which all the package's demos should live. In addition, the sub-folder
+# should contain a Python file called __demo__.py which, when imported, should
+# contain the following methods:
+#
+# * GetDemoBitmap: returns the bitmap to be used in the wxPython demo tree control
+# in a PyEmbeddedImage format;
+# * GetRecentAdditions: returns a list of demos which will be displayed under the
+# "Recent Additions/Updates" tree item. This list should be a subset (or the full
+# set) of the package's demos;
+# * GetDemos: returns a tuple. The first item of the tuple is the package's name
+# as will be displayed in the wxPython demo tree, right after the "Custom Controls"
+# item. The second element of the tuple is the list of demos for the external package.
+# * GetOverview: returns a wx.html-ready representation of the package's documentation.
+#
+# Please see the __demo__.py file in the demo/agw/ folder for an example.
+# Last updated: Andrea Gavana, 20 Oct 2008, 18.00 GMT
+
+import sys, os, time, traceback, types
+import cPickle, cStringIO, re, urllib2
+import shutil
+from threading import Thread
+
+import wx
+import wx.aui
+import wx.html
+from wx.lib.msgpanel import MessagePanel
+
+import wx.lib.mixins.inspection
+
+import version
+
+# We won't import the images module yet, but we'll assign it to this
+# global when we do.
+images = None
+
+# For debugging
+##wx.Trap();
+##print "wx.VERSION_STRING = %s (%s)" % (wx.VERSION_STRING, wx.USE_UNICODE and 'unicode' or 'ansi')
+##print "pid:", os.getpid()
+##raw_input("Press Enter...")
+
+#---------------------------------------------------------------------------
+
+USE_CUSTOMTREECTRL = False
+DEFAULT_PERSPECTIVE = "Default Perspective"
+
+#---------------------------------------------------------------------------
+
+_demoPngs = ["overview", "recent", "frame", "dialog", "moredialog", "core",
+ "book", "customcontrol", "morecontrols", "layout", "process",
+ "clipboard", "images", "miscellaneous"]
+
+_treeList = [
+ # new stuff
+ ('Recent Additions/Updates', [
+ 'PropertyGrid',
+ 'SystemSettings',
+ 'GridLabelRenderer',
+ 'InfoBar',
+ 'WrapSizer',
+ 'UIActionSimulator',
+ 'GraphicsGradient',
+ 'PDFViewer',
+ 'ItemsPicker',
+ 'CommandLinkButton',
+ 'DVC_DataViewModel',
+ 'DVC_IndexListModel',
+ 'DVC_ListCtrl',
+ 'DVC_TreeCtrl',
+ 'DVC_CustomRenderer',
+ 'PenAndBrushStyles',
+ 'HTML2_WebView',
+ ]),
+
+ # managed windows == things with a (optional) caption you can close
+ ('Frames and Dialogs', [
+ 'AUI_DockingWindowMgr',
+ 'AUI_MDI',
+ 'Dialog',
+ 'Frame',
+ 'MDIWindows',
+ 'MiniFrame',
+ 'Wizard',
+ ]),
+
+ # the common dialogs
+ ('Common Dialogs', [
+ 'AboutBox',
+ 'ColourDialog',
+ 'DirDialog',
+ 'FileDialog',
+ 'FindReplaceDialog',
+ 'FontDialog',
+ 'MessageDialog',
+ 'MultiChoiceDialog',
+ 'PageSetupDialog',
+ 'PrintDialog',
+ 'ProgressDialog',
+ 'SingleChoiceDialog',
+ 'TextEntryDialog',
+ ]),
+
+ # dialogs from libraries
+ ('More Dialogs', [
+ 'ImageBrowser',
+ 'ScrolledMessageDialog',
+ ]),
+
+ # core controls
+ ('Core Windows/Controls', [
+ 'BitmapButton',
+ 'Button',
+ 'CheckBox',
+ 'CheckListBox',
+ 'Choice',
+ 'ComboBox',
+ 'CommandLinkButton',
+ 'DVC_CustomRenderer',
+ 'DVC_DataViewModel',
+ 'DVC_IndexListModel',
+ 'DVC_ListCtrl',
+ 'DVC_TreeCtrl',
+ 'Gauge',
+ 'Grid',
+ 'Grid_MegaExample',
+ 'GridLabelRenderer',
+ 'ListBox',
+ 'ListCtrl',
+ 'ListCtrl_virtual',
+ 'ListCtrl_edit',
+ 'Menu',
+ 'PopupMenu',
+ 'PopupWindow',
+ 'RadioBox',
+ 'RadioButton',
+ 'SashWindow',
+ 'ScrolledWindow',
+ 'SearchCtrl',
+ 'Slider',
+ 'SpinButton',
+ 'SpinCtrl',
+ 'SpinCtrlDouble',
+ 'SplitterWindow',
+ 'StaticBitmap',
+ 'StaticBox',
+ 'StaticText',
+ 'StatusBar',
+ 'StockButtons',
+ 'TextCtrl',
+ 'ToggleButton',
+ 'ToolBar',
+ 'TreeCtrl',
+ 'Validator',
+ ]),
+
+ ('"Book" Controls', [
+ 'AUI_Notebook',
+ 'Choicebook',
+ 'FlatNotebook',
+ 'Listbook',
+ 'Notebook',
+ 'Toolbook',
+ 'Treebook',
+ ]),
+
+ ('Custom Controls', [
+ 'AnalogClock',
+ 'ColourSelect',
+ 'ComboTreeBox',
+ 'Editor',
+ 'GenericButtons',
+ 'GenericDirCtrl',
+ 'ItemsPicker',
+ 'LEDNumberCtrl',
+ 'MultiSash',
+ 'PlateButton',
+ 'PopupControl',
+ 'PyColourChooser',
+ 'TreeListCtrl',
+ ]),
+
+ # controls coming from other libraries
+ ('More Windows/Controls', [
+ 'ActiveX_FlashWindow',
+ 'ActiveX_IEHtmlWindow',
+ 'ActiveX_PDFWindow',
+ 'BitmapComboBox',
+ 'Calendar',
+ 'CalendarCtrl',
+ 'CheckListCtrlMixin',
+ 'CollapsiblePane',
+ 'ComboCtrl',
+ 'ContextHelp',
+ 'DatePickerCtrl',
+ 'DynamicSashWindow',
+ 'EditableListBox',
+ 'ExpandoTextCtrl',
+ 'FancyText',
+ 'FileBrowseButton',
+ 'FloatBar',
+ 'FloatCanvas',
+ 'HtmlWindow',
+ 'HTML2_WebView',
+ 'InfoBar',
+ 'IntCtrl',
+ 'MVCTree',
+ 'MaskedEditControls',
+ 'MaskedNumCtrl',
+ 'MediaCtrl',
+ 'MultiSplitterWindow',
+ 'OwnerDrawnComboBox',
+ 'Pickers',
+ 'PropertyGrid',
+ 'PyCrust',
+ 'PyPlot',
+ 'PyShell',
+ 'ResizeWidget',
+ 'RichTextCtrl',
+ 'ScrolledPanel',
+ 'SplitTree',
+ 'StyledTextCtrl_1',
+ 'StyledTextCtrl_2',
+ 'TablePrint',
+ 'Throbber',
+ 'Ticker',
+ 'TimeCtrl',
+ 'TreeMixin',
+ 'VListBox',
+ ]),
+
+ # How to lay out the controls in a frame/dialog
+ ('Window Layout', [
+ 'GridBagSizer',
+ 'LayoutAnchors',
+ 'LayoutConstraints',
+ 'Layoutf',
+ 'RowColSizer',
+ 'ScrolledPanel',
+ 'SizedControls',
+ 'Sizers',
+ 'WrapSizer',
+ 'XmlResource',
+ 'XmlResourceHandler',
+ 'XmlResourceSubclass',
+ ]),
+
+ # ditto
+ ('Process and Events', [
+ 'DelayedResult',
+ 'EventManager',
+ 'KeyEvents',
+ 'Process',
+ 'PythonEvents',
+ 'Threads',
+ 'Timer',
+ ##'infoframe', # needs better explanation and some fixing
+ ]),
+
+ # Clipboard and DnD
+ ('Clipboard and DnD', [
+ 'CustomDragAndDrop',
+ 'DragAndDrop',
+ 'URLDragAndDrop',
+ ]),
+
+ # Images
+ ('Using Images', [
+ 'AdjustChannels',
+ 'AlphaDrawing',
+ 'AnimateCtrl',
+ 'ArtProvider',
+ 'BitmapFromBuffer',
+ 'Cursor',
+ 'DragImage',
+ 'Image',
+ 'ImageAlpha',
+ 'ImageFromStream',
+ 'Img2PyArtProvider',
+ 'Mask',
+ 'RawBitmapAccess',
+ 'Throbber',
+ ]),
+
+ # Other stuff
+ ('Miscellaneous', [
+ 'AlphaDrawing',
+ 'Cairo',
+ 'Cairo_Snippets',
+ 'ColourDB',
+ ##'DialogUnits', # needs more explanations
+ 'DragScroller',
+ 'DrawXXXList',
+ 'FileHistory',
+ 'FontEnumerator',
+ 'GraphicsContext',
+ 'GraphicsGradient',
+ 'GLCanvas',
+ 'I18N',
+ 'Joystick',
+ 'MimeTypesManager',
+ 'MouseGestures',
+ 'OGL',
+ 'PDFViewer',
+ 'PenAndBrushStyles',
+ 'PrintFramework',
+ 'PseudoDC',
+ 'RendererNative',
+ 'ShapedWindow',
+ 'Sound',
+ 'StandardPaths',
+ 'SystemSettings',
+ 'UIActionSimulator',
+ 'Unicode',
+ ]),
+
+
+ ('Check out the samples dir too', [] ),
+
+]
+
+#---------------------------------------------------------------------------
+
+_styleTable = '
Window %s
\n' \
+ '
This class supports the following window %s:\n' \
+ '
'
+
+_trunkURL = "http://docs.wxwidgets.org/trunk/"
+_docsURL = _trunkURL + "classwx%s.html"
+_platformNames = ["wxMSW", "wxGTK", "wxMac"]
+
+
+_importList = ["wx.aui", "wx.calendar", "wx.html", "wx.media", "wx.wizard",
+ "wx.combo", "wx.animate", "wx.gizmos", "wx.glcanvas", "wx.grid",
+ "wx.richtext", "wx.stc"]
+
+_dirWX = dir(wx)
+for mod in _importList:
+ try:
+ module = __import__(mod)
+ except ImportError:
+ continue
+
+#---------------------------------------------------------------------------
+
+def ReplaceCapitals(string):
+ """
+ Replaces the capital letter in a string with an underscore plus the
+ corresponding lowercase character.
+
+ **Parameters:**
+
+ * `string`: the string to be analyzed.
+ """
+
+ newString = ""
+ for char in string:
+ if char.isupper():
+ newString += "_%s"%char.lower()
+ else:
+ newString += char
+
+ return newString
+
+
+def RemoveHTMLTags(data):
+ """
+ Removes all the HTML tags from a string.
+
+ **Parameters:**
+
+ * `data`: the string to be analyzed.
+ """
+
+ p = re.compile(r'<[^<]*?>')
+ return p.sub('', data)
+
+
+def FormatDocs(keyword, values, num):
+
+ names = values.keys()
+ names.sort()
+
+ headers = (num == 2 and [_eventHeaders] or [_styleHeaders])[0]
+ table = (num == 2 and [_eventTable] or [_styleTable])[0]
+ if num == 3:
+ text = " " + table%(keyword.lower(), keyword.lower()) + "\n
\n"
+ else:
+ text = " " + table
+
+ for indx in xrange(2):
+ text += _headerTable%headers[indx]
+
+ text += "\n
\n"
+
+ for name in names:
+
+ text += "
\n"
+
+ description = values[name].strip()
+ pythonValue = name.replace("wx", "wx.")
+
+ if num == 3:
+
+ colour = "#ff0000"
+ value = "Unavailable"
+ cutValue = pythonValue[3:]
+
+ if cutValue in _dirWX:
+ try:
+ val = eval(pythonValue)
+ value = "%s"%hex(val)
+ colour = "#0000ff"
+ except AttributeError:
+ value = "Unavailable"
+ else:
+ for packages in _importList:
+ if cutValue in dir(eval(packages)):
+ val = eval("%s.%s"%(packages, cutValue))
+ value = "%s"%hex(val)
+ colour = "#0000ff"
+ pythonValue = "%s.%s"%(packages, cutValue)
+ break
+
+ text += _styleTag%pythonValue + "\n"
+
+ else:
+
+ text += _eventTag%pythonValue + "\n"
+
+ text += _description%FormatDescription(description) + "\n"
+ text += "
\n"
+
+ text += "\n
\n\n
"
+ return text
+
+
+def FormatDescription(description):
+ """
+ Formats a wxWidgets C++ description in a more wxPython-based way.
+
+ **Parameters:**
+
+ * `description`: the string description to be formatted.
+ """
+
+ description = description.replace("wx", "wx.")
+ description = description.replace("EVT_COMMAND", "wxEVT_COMMAND")
+ description = description.replace("wx.Widgets", "wxWidgets")
+
+ return description
+
+
+def FormatImages(appearance):
+
+ text = "
" + _appearanceTable
+
+ for indx in xrange(2):
+ text += "\n
\n"
+ for key in _platformNames:
+ if indx == 0:
+ src = appearance[key]
+ alt = key + "Appearance"
+ text += _imageTag%(src, src, alt)
+ else:
+ text += _platformTag%key
+
+ text += "
\n"
+
+ text += "\n
\n\n
"
+ return text
+
+
+def FindWindowStyles(text, originalText, widgetName):
+ """
+ Finds the windows styles and events in the input text.
+
+ **Parameters:**
+
+ * `text`: the wxWidgets C++ docs for a particular widget/event, stripped
+ of all HTML tags;
+ * `originalText`: the wxWidgets C++ docs for a particular widget/event, with
+ all HTML tags.
+ """
+
+ winStyles, winEvents, winExtra, winAppearance = {}, {}, {}, {}
+ inStyle = inExtra = inEvent = False
+
+ for line in text:
+ if "following styles:" in line:
+ inStyle = True
+ continue
+
+ elif "Event macros" in line:
+ inEvent = True
+ continue
+
+ if "following extra styles:" in line:
+ inExtra = True
+ continue
+
+ if "Appearance:" in line:
+ winAppearance = FindImages(originalText, widgetName)
+ continue
+
+ elif not line.strip():
+ inStyle = inEvent = inExtra = False
+ continue
+
+ if inStyle:
+ start = line.index(':')
+ windowStyle = line[0:start]
+ styleDescription = line[start+1:]
+ winStyles[windowStyle] = styleDescription
+ elif inEvent:
+ start = line.index(':')
+ eventName = line[0:start]
+ eventDescription = line[start+1:]
+ winEvents[eventName] = eventDescription
+ elif inExtra:
+ start = line.index(':')
+ styleName = line[0:start]
+ styleDescription = line[start+1:]
+ winExtra[styleName] = styleDescription
+
+ return winStyles, winEvents, winExtra, winAppearance
+
+
+def FindImages(text, widgetName):
+ """
+ When the wxWidgets docs contain athe control appearance (a screenshot of the
+ control), this method will try and download the images.
+
+ **Parameters:**
+
+ * `text`: the wxWidgets C++ docs for a particular widget/event, with
+ all HTML tags.
+ """
+
+ winAppearance = {}
+ start = text.find("class='appearance'")
+
+ if start < 0:
+ return winAppearance
+
+ imagesDir = GetDocImagesDir()
+
+ end = start + text.find("
")
+ text = text[start:end]
+ split = text.split()
+
+ for indx, items in enumerate(split):
+
+ if "src=" in items:
+ possibleImage = items.replace("src=", "").strip()
+ possibleImage = possibleImage.replace("'", "")
+ f = urllib2.urlopen(_trunkURL + possibleImage)
+ stream = f.read()
+
+ elif "alt=" in items:
+ plat = items.replace("alt=", "").replace("'", "").strip()
+ path = os.path.join(imagesDir, plat, widgetName + ".png")
+ if not os.path.isfile(path):
+ image = wx.ImageFromStream(cStringIO.StringIO(stream))
+ image.SaveFile(path, wx.BITMAP_TYPE_PNG)
+
+ winAppearance[plat] = path
+
+ return winAppearance
+
+
+#---------------------------------------------------------------------------
+# Set up a thread that will scan the wxWidgets docs for window styles,
+# events and widgets screenshots
+
+class InternetThread(Thread):
+ """ Worker thread class to attempt connection to the internet. """
+
+ def __init__(self, notifyWindow, selectedClass):
+
+ Thread.__init__(self)
+
+ self.notifyWindow = notifyWindow
+ self.selectedClass = selectedClass
+ self.keepRunning = True
+ self.setDaemon(True)
+
+ self.start()
+
+
+ def run(self):
+ """ Run the worker thread. """
+
+ # This is the code executing in the new thread. Simulation of
+ # a long process as a simple urllib2 call
+
+ try:
+ url = _docsURL % ReplaceCapitals(self.selectedClass)
+ fid = urllib2.urlopen(url)
+
+ originalText = fid.read()
+ text = RemoveHTMLTags(originalText).split("\n")
+ data = FindWindowStyles(text, originalText, self.selectedClass)
+
+ if not self.keepRunning:
+ return
+
+ wx.CallAfter(self.notifyWindow.LoadDocumentation, data)
+ except (IOError, urllib2.HTTPError):
+ # Unable to get to the internet
+ t, v = sys.exc_info()[:2]
+ message = traceback.format_exception_only(t, v)
+ wx.CallAfter(self.notifyWindow.StopDownload, message)
+ except:
+ # Some other strange error...
+ t, v = sys.exc_info()[:2]
+ message = traceback.format_exception_only(t, v)
+ wx.CallAfter(self.notifyWindow.StopDownload, message)
+
+
+#---------------------------------------------------------------------------
+# Show how to derive a custom wxLog class
+
+class MyLog(wx.PyLog):
+ def __init__(self, textCtrl, logTime=0):
+ wx.PyLog.__init__(self)
+ self.tc = textCtrl
+ self.logTime = logTime
+
+ def DoLogText(self, message):
+ if self.tc:
+ self.tc.AppendText(message + '\n')
+
+
+
+#---------------------------------------------------------------------------
+# A class to be used to display source code in the demo. Try using the
+# wxSTC in the StyledTextCtrl_2 sample first, fall back to wxTextCtrl
+# if there is an error, such as the stc module not being present.
+#
+
+try:
+ ##raise ImportError # for testing the alternate implementation
+ from wx import stc
+ from StyledTextCtrl_2 import PythonSTC
+
+ class DemoCodeEditor(PythonSTC):
+ def __init__(self, parent, style=wx.BORDER_NONE):
+ PythonSTC.__init__(self, parent, -1, style=style)
+ self.SetUpEditor()
+
+ # Some methods to make it compatible with how the wxTextCtrl is used
+ def SetValue(self, value):
+ if wx.USE_UNICODE:
+ value = value.decode('iso8859_1')
+ val = self.GetReadOnly()
+ self.SetReadOnly(False)
+ self.SetText(value)
+ self.EmptyUndoBuffer()
+ self.SetSavePoint()
+ self.SetReadOnly(val)
+
+ def SetEditable(self, val):
+ self.SetReadOnly(not val)
+
+ def IsModified(self):
+ return self.GetModify()
+
+ def Clear(self):
+ self.ClearAll()
+
+ def SetInsertionPoint(self, pos):
+ self.SetCurrentPos(pos)
+ self.SetAnchor(pos)
+
+ def ShowPosition(self, pos):
+ line = self.LineFromPosition(pos)
+ #self.EnsureVisible(line)
+ self.GotoLine(line)
+
+ def GetLastPosition(self):
+ return self.GetLength()
+
+ def GetPositionFromLine(self, line):
+ return self.PositionFromLine(line)
+
+ def GetRange(self, start, end):
+ return self.GetTextRange(start, end)
+
+ def GetSelection(self):
+ return self.GetAnchor(), self.GetCurrentPos()
+
+ def SetSelection(self, start, end):
+ self.SetSelectionStart(start)
+ self.SetSelectionEnd(end)
+
+ def SelectLine(self, line):
+ start = self.PositionFromLine(line)
+ end = self.GetLineEndPosition(line)
+ self.SetSelection(start, end)
+
+ def SetUpEditor(self):
+ """
+ This method carries out the work of setting up the demo editor.
+ It's seperate so as not to clutter up the init code.
+ """
+ import keyword
+
+ self.SetLexer(stc.STC_LEX_PYTHON)
+ self.SetKeyWords(0, " ".join(keyword.kwlist))
+
+ # Enable folding
+ self.SetProperty("fold", "1" )
+
+ # Highlight tab/space mixing (shouldn't be any)
+ self.SetProperty("tab.timmy.whinge.level", "1")
+
+ # Set left and right margins
+ self.SetMargins(2,2)
+
+ # Set up the numbers in the margin for margin #1
+ self.SetMarginType(1, wx.stc.STC_MARGIN_NUMBER)
+ # Reasonable value for, say, 4-5 digits using a mono font (40 pix)
+ self.SetMarginWidth(1, 40)
+
+ # Indentation and tab stuff
+ self.SetIndent(4) # Proscribed indent size for wx
+ self.SetIndentationGuides(True) # Show indent guides
+ self.SetBackSpaceUnIndents(True)# Backspace unindents rather than delete 1 space
+ self.SetTabIndents(True) # Tab key indents
+ self.SetTabWidth(4) # Proscribed tab size for wx
+ self.SetUseTabs(False) # Use spaces rather than tabs, or
+ # TabTimmy will complain!
+ # White space
+ self.SetViewWhiteSpace(False) # Don't view white space
+
+ # EOL: Since we are loading/saving ourselves, and the
+ # strings will always have \n's in them, set the STC to
+ # edit them that way.
+ self.SetEOLMode(wx.stc.STC_EOL_LF)
+ self.SetViewEOL(False)
+
+ # No right-edge mode indicator
+ self.SetEdgeMode(stc.STC_EDGE_NONE)
+
+ # Setup a margin to hold fold markers
+ self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)
+ self.SetMarginMask(2, stc.STC_MASK_FOLDERS)
+ self.SetMarginSensitive(2, True)
+ self.SetMarginWidth(2, 12)
+
+ # and now set up the fold markers
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, stc.STC_MARK_BOXPLUSCONNECTED, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_BOXMINUSCONNECTED, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNER, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, stc.STC_MARK_LCORNER, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, stc.STC_MARK_VLINE, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDER, stc.STC_MARK_BOXPLUS, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, stc.STC_MARK_BOXMINUS, "white", "black")
+
+ # Global default style
+ if wx.Platform == '__WXMSW__':
+ self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
+ 'fore:#000000,back:#FFFFFF,face:Courier New')
+ elif wx.Platform == '__WXMAC__':
+ # TODO: if this looks fine on Linux too, remove the Mac-specific case
+ # and use this whenever OS != MSW.
+ self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
+ 'fore:#000000,back:#FFFFFF,face:Monaco')
+ else:
+ defsize = wx.SystemSettings.GetFont(wx.SYS_ANSI_FIXED_FONT).GetPointSize()
+ self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
+ 'fore:#000000,back:#FFFFFF,face:Courier,size:%d'%defsize)
+
+ # Clear styles and revert to default.
+ self.StyleClearAll()
+
+ # Following style specs only indicate differences from default.
+ # The rest remains unchanged.
+
+ # Line numbers in margin
+ self.StyleSetSpec(wx.stc.STC_STYLE_LINENUMBER,'fore:#000000,back:#99A9C2')
+ # Highlighted brace
+ self.StyleSetSpec(wx.stc.STC_STYLE_BRACELIGHT,'fore:#00009D,back:#FFFF00')
+ # Unmatched brace
+ self.StyleSetSpec(wx.stc.STC_STYLE_BRACEBAD,'fore:#00009D,back:#FF0000')
+ # Indentation guide
+ self.StyleSetSpec(wx.stc.STC_STYLE_INDENTGUIDE, "fore:#CDCDCD")
+
+ # Python styles
+ self.StyleSetSpec(wx.stc.STC_P_DEFAULT, 'fore:#000000')
+ # Comments
+ self.StyleSetSpec(wx.stc.STC_P_COMMENTLINE, 'fore:#008000,back:#F0FFF0')
+ self.StyleSetSpec(wx.stc.STC_P_COMMENTBLOCK, 'fore:#008000,back:#F0FFF0')
+ # Numbers
+ self.StyleSetSpec(wx.stc.STC_P_NUMBER, 'fore:#008080')
+ # Strings and characters
+ self.StyleSetSpec(wx.stc.STC_P_STRING, 'fore:#800080')
+ self.StyleSetSpec(wx.stc.STC_P_CHARACTER, 'fore:#800080')
+ # Keywords
+ self.StyleSetSpec(wx.stc.STC_P_WORD, 'fore:#000080,bold')
+ # Triple quotes
+ self.StyleSetSpec(wx.stc.STC_P_TRIPLE, 'fore:#800080,back:#FFFFEA')
+ self.StyleSetSpec(wx.stc.STC_P_TRIPLEDOUBLE, 'fore:#800080,back:#FFFFEA')
+ # Class names
+ self.StyleSetSpec(wx.stc.STC_P_CLASSNAME, 'fore:#0000FF,bold')
+ # Function names
+ self.StyleSetSpec(wx.stc.STC_P_DEFNAME, 'fore:#008080,bold')
+ # Operators
+ self.StyleSetSpec(wx.stc.STC_P_OPERATOR, 'fore:#800000,bold')
+ # Identifiers. I leave this as not bold because everything seems
+ # to be an identifier if it doesn't match the above criterae
+ self.StyleSetSpec(wx.stc.STC_P_IDENTIFIER, 'fore:#000000')
+
+ # Caret color
+ self.SetCaretForeground("BLUE")
+ # Selection background
+ self.SetSelBackground(1, '#66CCFF')
+
+ self.SetSelBackground(True, wx.SystemSettings_GetColour(wx.SYS_COLOUR_HIGHLIGHT))
+ self.SetSelForeground(True, wx.SystemSettings_GetColour(wx.SYS_COLOUR_HIGHLIGHTTEXT))
+
+ def RegisterModifiedEvent(self, eventHandler):
+ self.Bind(wx.stc.EVT_STC_CHANGE, eventHandler)
+
+
+except ImportError:
+ class DemoCodeEditor(wx.TextCtrl):
+ def __init__(self, parent):
+ wx.TextCtrl.__init__(self, parent, -1, style =
+ wx.TE_MULTILINE | wx.HSCROLL | wx.TE_RICH2 | wx.TE_NOHIDESEL)
+
+ def RegisterModifiedEvent(self, eventHandler):
+ self.Bind(wx.EVT_TEXT, eventHandler)
+
+ def SetReadOnly(self, flag):
+ self.SetEditable(not flag)
+ # NOTE: STC already has this method
+
+ def GetText(self):
+ return self.GetValue()
+
+ def GetPositionFromLine(self, line):
+ return self.XYToPosition(0,line)
+
+ def GotoLine(self, line):
+ pos = self.GetPositionFromLine(line)
+ self.SetInsertionPoint(pos)
+ self.ShowPosition(pos)
+
+ def SelectLine(self, line):
+ start = self.GetPositionFromLine(line)
+ end = start + self.GetLineLength(line)
+ self.SetSelection(start, end)
+
+
+#---------------------------------------------------------------------------
+# Constants for module versions
+
+modOriginal = 0
+modModified = 1
+modDefault = modOriginal
+
+#---------------------------------------------------------------------------
+
+class DemoCodePanel(wx.Panel):
+ """Panel for the 'Demo Code' tab"""
+ def __init__(self, parent, mainFrame):
+ wx.Panel.__init__(self, parent, size=(1,1))
+ if 'wxMSW' in wx.PlatformInfo:
+ self.Hide()
+ self.mainFrame = mainFrame
+ self.editor = DemoCodeEditor(self)
+ self.editor.RegisterModifiedEvent(self.OnCodeModified)
+
+ self.btnSave = wx.Button(self, -1, "Save Changes")
+ self.btnRestore = wx.Button(self, -1, "Delete Modified")
+ self.btnSave.Enable(False)
+ self.btnSave.Bind(wx.EVT_BUTTON, self.OnSave)
+ self.btnRestore.Bind(wx.EVT_BUTTON, self.OnRestore)
+
+ self.radioButtons = { modOriginal: wx.RadioButton(self, -1, "Original", style = wx.RB_GROUP),
+ modModified: wx.RadioButton(self, -1, "Modified") }
+
+ self.controlBox = wx.BoxSizer(wx.HORIZONTAL)
+ self.controlBox.Add(wx.StaticText(self, -1, "Active Version:"), 0,
+ wx.RIGHT | wx.LEFT | wx.ALIGN_CENTER_VERTICAL, 5)
+ for modID, radioButton in self.radioButtons.items():
+ self.controlBox.Add(radioButton, 0, wx.EXPAND | wx.RIGHT, 5)
+ radioButton.modID = modID # makes it easier for the event handler
+ radioButton.Bind(wx.EVT_RADIOBUTTON, self.OnRadioButton)
+
+ self.controlBox.Add(self.btnSave, 0, wx.RIGHT, 5)
+ self.controlBox.Add(self.btnRestore, 0)
+
+ self.box = wx.BoxSizer(wx.VERTICAL)
+ self.box.Add(self.controlBox, 0, wx.EXPAND)
+ self.box.Add(wx.StaticLine(self), 0, wx.EXPAND)
+ self.box.Add(self.editor, 1, wx.EXPAND)
+
+ self.box.Fit(self)
+ self.SetSizer(self.box)
+
+
+ # Loads a demo from a DemoModules object
+ def LoadDemo(self, demoModules):
+ self.demoModules = demoModules
+ if (modDefault == modModified) and demoModules.Exists(modModified):
+ demoModules.SetActive(modModified)
+ else:
+ demoModules.SetActive(modOriginal)
+ self.radioButtons[demoModules.GetActiveID()].Enable(True)
+ self.ActiveModuleChanged()
+
+
+ def ActiveModuleChanged(self):
+ self.LoadDemoSource(self.demoModules.GetSource())
+ self.UpdateControlState()
+ self.mainFrame.pnl.Freeze()
+ self.ReloadDemo()
+ self.mainFrame.pnl.Thaw()
+
+
+ def LoadDemoSource(self, source):
+ self.editor.Clear()
+ self.editor.SetValue(source)
+ self.JumpToLine(0)
+ self.btnSave.Enable(False)
+
+
+ def JumpToLine(self, line, highlight=False):
+ self.editor.GotoLine(line)
+ self.editor.SetFocus()
+ if highlight:
+ self.editor.SelectLine(line)
+
+
+ def UpdateControlState(self):
+ active = self.demoModules.GetActiveID()
+ # Update the radio/restore buttons
+ for moduleID in self.radioButtons:
+ btn = self.radioButtons[moduleID]
+ if moduleID == active:
+ btn.SetValue(True)
+ else:
+ btn.SetValue(False)
+
+ if self.demoModules.Exists(moduleID):
+ btn.Enable(True)
+ if moduleID == modModified:
+ self.btnRestore.Enable(True)
+ else:
+ btn.Enable(False)
+ if moduleID == modModified:
+ self.btnRestore.Enable(False)
+
+
+ def OnRadioButton(self, event):
+ radioSelected = event.GetEventObject()
+ modSelected = radioSelected.modID
+ if modSelected != self.demoModules.GetActiveID():
+ busy = wx.BusyInfo("Reloading demo module...")
+ self.demoModules.SetActive(modSelected)
+ self.ActiveModuleChanged()
+
+
+ def ReloadDemo(self):
+ if self.demoModules.name != __name__:
+ self.mainFrame.RunModule()
+
+
+ def OnCodeModified(self, event):
+ self.btnSave.Enable(self.editor.IsModified())
+
+
+ def OnSave(self, event):
+ if self.demoModules.Exists(modModified):
+ if self.demoModules.GetActiveID() == modOriginal:
+ overwriteMsg = "You are about to overwrite an already existing modified copy\n" + \
+ "Do you want to continue?"
+ dlg = wx.MessageDialog(self, overwriteMsg, "wxPython Demo",
+ wx.YES_NO | wx.NO_DEFAULT| wx.ICON_EXCLAMATION)
+ result = dlg.ShowModal()
+ if result == wx.ID_NO:
+ return
+ dlg.Destroy()
+
+ self.demoModules.SetActive(modModified)
+ modifiedFilename = GetModifiedFilename(self.demoModules.name)
+
+ # Create the demo directory if one doesn't already exist
+ if not os.path.exists(GetModifiedDirectory()):
+ try:
+ os.makedirs(GetModifiedDirectory())
+ if not os.path.exists(GetModifiedDirectory()):
+ wx.LogMessage("BUG: Created demo directory but it still doesn't exist")
+ raise AssertionError
+ except:
+ wx.LogMessage("Error creating demo directory: %s" % GetModifiedDirectory())
+ return
+ else:
+ wx.LogMessage("Created directory for modified demos: %s" % GetModifiedDirectory())
+
+ # Save
+ f = open(modifiedFilename, "wt")
+ source = self.editor.GetText()
+ try:
+ f.write(source)
+ finally:
+ f.close()
+
+ busy = wx.BusyInfo("Reloading demo module...")
+ self.demoModules.LoadFromFile(modModified, modifiedFilename)
+ self.ActiveModuleChanged()
+
+ self.mainFrame.SetTreeModified(True)
+
+
+ def OnRestore(self, event): # Handles the "Delete Modified" button
+ modifiedFilename = GetModifiedFilename(self.demoModules.name)
+ self.demoModules.Delete(modModified)
+ os.unlink(modifiedFilename) # Delete the modified copy
+ busy = wx.BusyInfo("Reloading demo module...")
+
+ self.ActiveModuleChanged()
+
+ self.mainFrame.SetTreeModified(False)
+
+
+#---------------------------------------------------------------------------
+
+def opj(path):
+ """Convert paths to the platform-specific separator"""
+ st = apply(os.path.join, tuple(path.split('/')))
+ # HACK: on Linux, a leading / gets lost...
+ if path.startswith('/'):
+ st = '/' + st
+ return st
+
+
+def GetDataDir():
+ """
+ Return the standard location on this platform for application data
+ """
+ sp = wx.StandardPaths.Get()
+ return sp.GetUserDataDir()
+
+
+def GetModifiedDirectory():
+ """
+ Returns the directory where modified versions of the demo files
+ are stored
+ """
+ return os.path.join(GetDataDir(), "modified")
+
+
+def GetModifiedFilename(name):
+ """
+ Returns the filename of the modified version of the specified demo
+ """
+ if not name.endswith(".py"):
+ name = name + ".py"
+ return os.path.join(GetModifiedDirectory(), name)
+
+
+def GetOriginalFilename(name):
+ """
+ Returns the filename of the original version of the specified demo
+ """
+ if not name.endswith(".py"):
+ name = name + ".py"
+
+ if os.path.isfile(name):
+ return name
+
+ originalDir = os.getcwd()
+ listDir = os.listdir(originalDir)
+ # Loop over the content of the demo directory
+ for item in listDir:
+ if not os.path.isdir(item):
+ # Not a directory, continue
+ continue
+ dirFile = os.listdir(item)
+ # See if a file called "name" is there
+ if name in dirFile:
+ return os.path.join(item, name)
+
+ # We must return a string...
+ return ""
+
+
+def DoesModifiedExist(name):
+ """Returns whether the specified demo has a modified copy"""
+ if os.path.exists(GetModifiedFilename(name)):
+ return True
+ else:
+ return False
+
+
+def GetConfig():
+ if not os.path.exists(GetDataDir()):
+ os.makedirs(GetDataDir())
+
+ config = wx.FileConfig(
+ localFilename=os.path.join(GetDataDir(), "options"))
+ return config
+
+
+def MakeDocDirs():
+
+ docDir = os.path.join(GetDataDir(), "docs")
+ if not os.path.exists(docDir):
+ os.makedirs(docDir)
+
+ for plat in _platformNames:
+ imageDir = os.path.join(docDir, "images", plat)
+ if not os.path.exists(imageDir):
+ os.makedirs(imageDir)
+
+
+def GetDocFile():
+
+ docFile = os.path.join(GetDataDir(), "docs", "TrunkDocs.pkl")
+
+ return docFile
+
+
+def GetDocImagesDir():
+
+ MakeDocDirs()
+ return os.path.join(GetDataDir(), "docs", "images")
+
+
+def SearchDemo(name, keyword):
+ """ Returns whether a demo contains the search keyword or not. """
+ fid = open(GetOriginalFilename(name), "rt")
+ fullText = fid.read()
+ fid.close()
+
+ fullText = fullText.decode("iso-8859-1")
+
+ if fullText.find(keyword) >= 0:
+ return True
+
+ return False
+
+
+def HuntExternalDemos():
+ """
+ Searches for external demos (i.e. packages like AGW) in the wxPython
+ demo sub-directories. In order to be found, these external packages
+ must have a __demo__.py file in their directory.
+ """
+
+ externalDemos = {}
+ originalDir = os.getcwd()
+ listDir = os.listdir(originalDir)
+ # Loop over the content of the demo directory
+ for item in listDir:
+ if not os.path.isdir(item):
+ # Not a directory, continue
+ continue
+ dirFile = os.listdir(item)
+ # See if a __demo__.py file is there
+ if "__demo__.py" in dirFile:
+ # Extend sys.path and import the external demos
+ sys.path.append(item)
+ externalDemos[item] = __import__("__demo__")
+
+ if not externalDemos:
+ # Nothing to import...
+ return {}
+
+ # Modify the tree items and icons
+ index = 0
+ for category, demos in _treeList:
+ # We put the external packages right before the
+ # More Windows/Controls item
+ if category == "More Windows/Controls":
+ break
+ index += 1
+
+ # Sort and reverse the external demos keys so that they
+ # come back in alphabetical order
+ keys = externalDemos.keys()
+ keys.sort()
+ keys.reverse()
+
+ # Loop over all external packages
+ for extern in keys:
+ package = externalDemos[extern]
+ # Insert a new package in the _treeList of demos
+ _treeList.insert(index, package.GetDemos())
+ # Get the recent additions for this package
+ _treeList[0][1].extend(package.GetRecentAdditions())
+ # Extend the demo bitmaps and the catalog
+ _demoPngs.insert(index+1, extern)
+ images.catalog[extern] = package.GetDemoBitmap()
+
+ # That's all folks...
+ return externalDemos
+
+
+def LookForExternals(externalDemos, demoName):
+ """
+ Checks if a demo name is in any of the external packages (like AGW) or
+ if the user clicked on one of the external packages parent items in the
+ tree, in which case it returns the html overview for the package.
+ """
+
+ pkg = overview = None
+ # Loop over all the external demos
+ for key, package in externalDemos.items():
+ # Get the tree item name for the package and its demos
+ treeName, treeDemos = package.GetDemos()
+ # Get the overview for the package
+ treeOverview = package.GetOverview()
+ if treeName == demoName:
+ # The user clicked on the parent tree item, return the overview
+ return pkg, treeOverview
+ elif demoName in treeDemos:
+ # The user clicked on a real demo, return the package
+ return key, overview
+
+ # No match found, return None for both
+ return pkg, overview
+
+#---------------------------------------------------------------------------
+
+class ModuleDictWrapper(object):
+ """Emulates a module with a dynamically compiled __dict__"""
+ def __init__(self, dict):
+ self.dict = dict
+
+ def __getattr__(self, name):
+ if name in self.dict:
+ return self.dict[name]
+ else:
+ raise AttributeError
+
+class DemoModules(object):
+ """
+ Dynamically manages the original/modified versions of a demo
+ module
+ """
+ def __init__(self, name):
+ self.modActive = -1
+ self.name = name
+
+ # (dict , source , filename , description , error information )
+ # ( 0 , 1 , 2 , 3 , 4 )
+ self.modules = [[dict(), "" , "" , "" , None],
+ [dict(), "" , "" , "" , None]]
+
+ for i in [modOriginal, modModified]:
+ self.modules[i][0]['__file__'] = \
+ os.path.join(os.getcwdu(), GetOriginalFilename(name))
+
+ # load original module
+ self.LoadFromFile(modOriginal, GetOriginalFilename(name))
+ self.SetActive(modOriginal)
+
+ # load modified module (if one exists)
+ if DoesModifiedExist(name):
+ self.LoadFromFile(modModified, GetModifiedFilename(name))
+
+
+ def LoadFromFile(self, modID, filename):
+ self.modules[modID][2] = filename
+ file = open(filename, "rt")
+ self.LoadFromSource(modID, file.read())
+ file.close()
+
+
+ def LoadFromSource(self, modID, source):
+ self.modules[modID][1] = source
+ self.LoadDict(modID)
+
+
+ def LoadDict(self, modID):
+ if self.name != __name__:
+ source = self.modules[modID][1]
+ description = self.modules[modID][2]
+ description = description.encode(sys.getfilesystemencoding())
+
+ try:
+ code = compile(source, description, "exec")
+ exec code in self.modules[modID][0]
+ except:
+ self.modules[modID][4] = DemoError(sys.exc_info())
+ self.modules[modID][0] = None
+ else:
+ self.modules[modID][4] = None
+
+
+ def SetActive(self, modID):
+ if modID != modOriginal and modID != modModified:
+ raise LookupError
+ else:
+ self.modActive = modID
+
+
+ def GetActive(self):
+ dict = self.modules[self.modActive][0]
+ if dict is None:
+ return None
+ else:
+ return ModuleDictWrapper(dict)
+
+
+ def GetActiveID(self):
+ return self.modActive
+
+
+ def GetSource(self, modID = None):
+ if modID is None:
+ modID = self.modActive
+ return self.modules[modID][1]
+
+
+ def GetFilename(self, modID = None):
+ if modID is None:
+ modID = self.modActive
+ return self.modules[self.modActive][2]
+
+
+ def GetErrorInfo(self, modID = None):
+ if modID is None:
+ modID = self.modActive
+ return self.modules[self.modActive][4]
+
+
+ def Exists(self, modID):
+ return self.modules[modID][1] != ""
+
+
+ def UpdateFile(self, modID = None):
+ """Updates the file from which a module was loaded
+ with (possibly updated) source"""
+ if modID is None:
+ modID = self.modActive
+
+ source = self.modules[modID][1]
+ filename = self.modules[modID][2]
+
+ try:
+ file = open(filename, "wt")
+ file.write(source)
+ finally:
+ file.close()
+
+
+ def Delete(self, modID):
+ if self.modActive == modID:
+ self.SetActive(0)
+
+ self.modules[modID][0] = None
+ self.modules[modID][1] = ""
+ self.modules[modID][2] = ""
+
+
+#---------------------------------------------------------------------------
+
+class DemoError(object):
+ """Wraps and stores information about the current exception"""
+ def __init__(self, exc_info):
+ import copy
+
+ excType, excValue = exc_info[:2]
+ # traceback list entries: (filename, line number, function name, text)
+ self.traceback = traceback.extract_tb(exc_info[2])
+
+ # --Based on traceback.py::format_exception_only()--
+ if type(excType) == types.ClassType:
+ self.exception_type = excType.__name__
+ else:
+ self.exception_type = excType
+
+ # If it's a syntax error, extra information needs
+ # to be added to the traceback
+ if excType is SyntaxError:
+ try:
+ msg, (filename, lineno, self.offset, line) = excValue
+ except:
+ pass
+ else:
+ if not filename:
+ filename = ""
+ line = line.strip()
+ self.traceback.append( (filename, lineno, "", line) )
+ excValue = msg
+ try:
+ self.exception_details = str(excValue)
+ except:
+ self.exception_details = "" & type(excValue).__name__
+
+ del exc_info
+
+ def __str__(self):
+ ret = "Type %s \n \
+ Traceback: %s \n \
+ Details : %s" % ( str(self.exception_type), str(self.traceback), self.exception_details )
+ return ret
+
+#---------------------------------------------------------------------------
+
+class DemoErrorPanel(wx.Panel):
+ """Panel put into the demo tab when the demo fails to run due to errors"""
+
+ def __init__(self, parent, codePanel, demoError, log):
+ wx.Panel.__init__(self, parent, -1)#, style=wx.NO_FULL_REPAINT_ON_RESIZE)
+ self.codePanel = codePanel
+ self.nb = parent
+ self.log = log
+
+ self.box = wx.BoxSizer(wx.VERTICAL)
+
+ # Main Label
+ self.box.Add(wx.StaticText(self, -1, "An error has occurred while trying to run the demo")
+ , 0, wx.ALIGN_CENTER | wx.TOP, 10)
+
+ # Exception Information
+ boxInfo = wx.StaticBox(self, -1, "Exception Info" )
+ boxInfoSizer = wx.StaticBoxSizer(boxInfo, wx.VERTICAL ) # Used to center the grid within the box
+ boxInfoGrid = wx.FlexGridSizer( cols=2 )
+ textFlags = wx.ALIGN_RIGHT | wx.LEFT | wx.RIGHT | wx.TOP
+ boxInfoGrid.Add(wx.StaticText(self, -1, "Type: "), 0, textFlags, 5 )
+ boxInfoGrid.Add(wx.StaticText(self, -1, str(demoError.exception_type)) , 0, textFlags, 5 )
+ boxInfoGrid.Add(wx.StaticText(self, -1, "Details: ") , 0, textFlags, 5 )
+ boxInfoGrid.Add(wx.StaticText(self, -1, demoError.exception_details) , 0, textFlags, 5 )
+ boxInfoSizer.Add(boxInfoGrid, 0, wx.ALIGN_CENTRE | wx.ALL, 5 )
+ self.box.Add(boxInfoSizer, 0, wx.ALIGN_CENTER | wx.ALL, 5)
+
+ # Set up the traceback list
+ # This one automatically resizes last column to take up remaining space
+ from ListCtrl import TestListCtrl
+ self.list = TestListCtrl(self, -1, style=wx.LC_REPORT | wx.SUNKEN_BORDER)
+ self.list.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)
+ self.list.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnItemSelected)
+ self.list.InsertColumn(0, "Filename")
+ self.list.InsertColumn(1, "Line", wx.LIST_FORMAT_RIGHT)
+ self.list.InsertColumn(2, "Function")
+ self.list.InsertColumn(3, "Code")
+ self.InsertTraceback(self.list, demoError.traceback)
+ self.list.SetColumnWidth(0, wx.LIST_AUTOSIZE)
+ self.list.SetColumnWidth(2, wx.LIST_AUTOSIZE)
+ self.box.Add(wx.StaticText(self, -1, "Traceback:")
+ , 0, wx.ALIGN_CENTER | wx.TOP, 5)
+ self.box.Add(self.list, 1, wx.GROW | wx.ALIGN_CENTER | wx.ALL, 5)
+ self.box.Add(wx.StaticText(self, -1, "Entries from the demo module are shown in blue\n"
+ + "Double-click on them to go to the offending line")
+ , 0, wx.ALIGN_CENTER | wx.BOTTOM, 5)
+
+ self.box.Fit(self)
+ self.SetSizer(self.box)
+
+
+ def InsertTraceback(self, list, traceback):
+ #Add the traceback data
+ for x in range(len(traceback)):
+ data = traceback[x]
+ list.InsertStringItem(x, os.path.basename(data[0])) # Filename
+ list.SetStringItem(x, 1, str(data[1])) # Line
+ list.SetStringItem(x, 2, str(data[2])) # Function
+ list.SetStringItem(x, 3, str(data[3])) # Code
+
+ # Check whether this entry is from the demo module
+ if data[0] == "" or data[0] == "": # FIXME: make more generalised
+ self.list.SetItemData(x, int(data[1])) # Store line number for easy access
+ # Give it a blue colour
+ item = self.list.GetItem(x)
+ item.SetTextColour(wx.BLUE)
+ self.list.SetItem(item)
+ else:
+ self.list.SetItemData(x, -1) # Editor can't jump into this one's code
+
+
+ def OnItemSelected(self, event):
+ # This occurs before OnDoubleClick and can be used to set the
+ # currentItem. OnDoubleClick doesn't get a wxListEvent....
+ self.currentItem = event.m_itemIndex
+ event.Skip()
+
+
+ def OnDoubleClick(self, event):
+ # If double-clicking on a demo's entry, jump to the line number
+ line = self.list.GetItemData(self.currentItem)
+ if line != -1:
+ self.nb.SetSelection(1) # Switch to the code viewer tab
+ wx.CallAfter(self.codePanel.JumpToLine, line-1, True)
+ event.Skip()
+
+
+#---------------------------------------------------------------------------
+
+class MainPanel(wx.Panel):
+ """
+ Just a simple derived panel where we override Freeze and Thaw so they are
+ only used on wxMSW.
+ """
+ def Freeze(self):
+ if 'wxMSW' in wx.PlatformInfo:
+ return super(MainPanel, self).Freeze()
+
+ def Thaw(self):
+ if 'wxMSW' in wx.PlatformInfo:
+ return super(MainPanel, self).Thaw()
+
+#---------------------------------------------------------------------------
+
+class DemoTaskBarIcon(wx.TaskBarIcon):
+ TBMENU_RESTORE = wx.NewId()
+ TBMENU_CLOSE = wx.NewId()
+ TBMENU_CHANGE = wx.NewId()
+ TBMENU_REMOVE = wx.NewId()
+
+ def __init__(self, frame):
+ wx.TaskBarIcon.__init__(self, wx.TBI_DOCK) # wx.TBI_CUSTOM_STATUSITEM
+ self.frame = frame
+
+ # Set the image
+ icon = self.MakeIcon(images.WXPdemo.GetImage())
+ self.SetIcon(icon, "wxPython Demo")
+ self.imgidx = 1
+
+ # bind some events
+ self.Bind(wx.EVT_TASKBAR_LEFT_DCLICK, self.OnTaskBarActivate)
+ self.Bind(wx.EVT_MENU, self.OnTaskBarActivate, id=self.TBMENU_RESTORE)
+ self.Bind(wx.EVT_MENU, self.OnTaskBarClose, id=self.TBMENU_CLOSE)
+ self.Bind(wx.EVT_MENU, self.OnTaskBarChange, id=self.TBMENU_CHANGE)
+ self.Bind(wx.EVT_MENU, self.OnTaskBarRemove, id=self.TBMENU_REMOVE)
+
+
+ def CreatePopupMenu(self):
+ """
+ This method is called by the base class when it needs to popup
+ the menu for the default EVT_RIGHT_DOWN event. Just create
+ the menu how you want it and return it from this function,
+ the base class takes care of the rest.
+ """
+ menu = wx.Menu()
+ menu.Append(self.TBMENU_RESTORE, "Restore wxPython Demo")
+ menu.Append(self.TBMENU_CLOSE, "Close wxPython Demo")
+ menu.AppendSeparator()
+ menu.Append(self.TBMENU_CHANGE, "Change the TB Icon")
+ menu.Append(self.TBMENU_REMOVE, "Remove the TB Icon")
+ return menu
+
+
+ def MakeIcon(self, img):
+ """
+ The various platforms have different requirements for the
+ icon size...
+ """
+ if "wxMSW" in wx.PlatformInfo:
+ img = img.Scale(16, 16)
+ elif "wxGTK" in wx.PlatformInfo:
+ img = img.Scale(22, 22)
+ # wxMac can be any size upto 128x128, so leave the source img alone....
+ icon = wx.IconFromBitmap(img.ConvertToBitmap() )
+ return icon
+
+
+ def OnTaskBarActivate(self, evt):
+ if self.frame.IsIconized():
+ self.frame.Iconize(False)
+ if not self.frame.IsShown():
+ self.frame.Show(True)
+ self.frame.Raise()
+
+
+ def OnTaskBarClose(self, evt):
+ wx.CallAfter(self.frame.Close)
+
+
+ def OnTaskBarChange(self, evt):
+ names = [ "WXPdemo", "Mondrian", "Pencil", "Carrot" ]
+ name = names[self.imgidx]
+
+ eImg = getattr(images, name)
+ self.imgidx += 1
+ if self.imgidx >= len(names):
+ self.imgidx = 0
+
+ icon = self.MakeIcon(eImg.Image)
+ self.SetIcon(icon, "This is a new icon: " + name)
+
+
+ def OnTaskBarRemove(self, evt):
+ self.RemoveIcon()
+
+
+#---------------------------------------------------------------------------
+class wxPythonDemo(wx.Frame):
+
+ overviewText = "wxPython Demo"
+
+ def __init__(self, parent, title):
+ wx.Frame.__init__(self, parent, -1, title, size = (970, 720),
+ style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE)
+
+ self.SetMinSize((640,480))
+
+ self.pnl = pnl = MainPanel(self)
+
+ self.mgr = wx.aui.AuiManager()
+ self.mgr.SetManagedWindow(pnl)
+
+ self.loaded = False
+ self.cwd = os.getcwd()
+ self.curOverview = ""
+ self.demoPage = None
+ self.codePage = None
+ self.shell = None
+ self.firstTime = True
+ self.finddlg = None
+
+ icon = images.WXPdemo.GetIcon()
+ self.SetIcon(icon)
+
+ try:
+ self.tbicon = DemoTaskBarIcon(self)
+ except:
+ self.tbicon = None
+
+ self.otherWin = None
+
+ self.allowDocs = False
+ self.downloading = False
+ self.internetThread = None
+ self.downloadImage = 2
+ self.sendDownloadError = True
+ self.downloadTimer = wx.Timer(self, wx.ID_ANY)
+
+ self.Bind(wx.EVT_IDLE, self.OnIdle)
+ self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+ self.Bind(wx.EVT_ICONIZE, self.OnIconfiy)
+ self.Bind(wx.EVT_MAXIMIZE, self.OnMaximize)
+ self.Bind(wx.EVT_TIMER, self.OnDownloadTimer, self.downloadTimer)
+
+ self.Centre(wx.BOTH)
+
+ self.statusBar = self.CreateStatusBar(2, wx.ST_SIZEGRIP)
+ self.statusBar.SetStatusWidths([-2, -1])
+
+ statusText = "Welcome to wxPython %s"%version.VERSION_STRING
+ self.statusBar.SetStatusText(statusText, 0)
+
+ self.downloadGauge = wx.Gauge(self.statusBar, -1, 50)
+ self.downloadGauge.SetToolTipString("Downloading Docs...")
+ self.downloadGauge.Hide()
+
+ self.sizeChanged = False
+ self.Reposition()
+
+ self.statusBar.Bind(wx.EVT_SIZE, self.OnStatusBarSize)
+ self.statusBar.Bind(wx.EVT_IDLE, self.OnStatusBarIdle)
+
+ self.dying = False
+ self.skipLoad = False
+ self.allowAuiFloating = False
+
+ def EmptyHandler(evt): pass
+
+ self.ReadConfigurationFile()
+ self.externalDemos = HuntExternalDemos()
+
+ # Create a Notebook
+ self.nb = wx.Notebook(pnl, -1, style=wx.CLIP_CHILDREN)
+ imgList = wx.ImageList(16, 16)
+ for png in ["overview", "code", "demo"]:
+ bmp = images.catalog[png].GetBitmap()
+ imgList.Add(bmp)
+ for indx in xrange(9):
+ bmp = images.catalog["spinning_nb%d"%indx].GetBitmap()
+ imgList.Add(bmp)
+
+ self.nb.AssignImageList(imgList)
+
+ self.BuildMenuBar()
+
+ self.finddata = wx.FindReplaceData()
+ self.finddata.SetFlags(wx.FR_DOWN)
+
+ # Create a TreeCtrl
+ leftPanel = wx.Panel(pnl, style=wx.TAB_TRAVERSAL|wx.CLIP_CHILDREN)
+ self.treeMap = {}
+ self.searchItems = {}
+
+ self.tree = wxPythonDemoTree(leftPanel)
+
+ self.filter = wx.SearchCtrl(leftPanel, style=wx.TE_PROCESS_ENTER)
+ self.filter.ShowCancelButton(True)
+ self.filter.Bind(wx.EVT_TEXT, self.RecreateTree)
+ self.filter.Bind(wx.EVT_SEARCHCTRL_CANCEL_BTN,
+ lambda e: self.filter.SetValue(''))
+ self.filter.Bind(wx.EVT_TEXT_ENTER, self.OnSearch)
+
+ searchMenu = wx.Menu()
+ item = searchMenu.AppendRadioItem(-1, "Sample Name")
+ self.Bind(wx.EVT_MENU, self.OnSearchMenu, item)
+ item = searchMenu.AppendRadioItem(-1, "Sample Content")
+ self.Bind(wx.EVT_MENU, self.OnSearchMenu, item)
+ self.filter.SetMenu(searchMenu)
+
+ self.RecreateTree()
+ self.tree.SetExpansionState(self.expansionState)
+ self.tree.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded)
+ self.tree.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed)
+ self.tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged)
+ self.tree.Bind(wx.EVT_LEFT_DOWN, self.OnTreeLeftDown)
+
+ # Set up a wx.html.HtmlWindow on the Overview Notebook page
+ # we put it in a panel first because there seems to be a
+ # refresh bug of some sort (wxGTK) when it is directly in
+ # the notebook...
+
+ if 0: # the old way
+ self.ovr = wx.html.HtmlWindow(self.nb, -1, size=(400, 400))
+ self.nb.AddPage(self.ovr, self.overviewText, imageId=0)
+
+ else: # hopefully I can remove this hacky code soon, see SF bug #216861
+ panel = wx.Panel(self.nb, -1, style=wx.CLIP_CHILDREN)
+ self.ovr = wx.html.HtmlWindow(panel, -1, size=(400, 400))
+ self.nb.AddPage(panel, self.overviewText, imageId=0)
+
+ def OnOvrSize(evt, ovr=self.ovr):
+ ovr.SetSize(evt.GetSize())
+ panel.Bind(wx.EVT_SIZE, OnOvrSize)
+ panel.Bind(wx.EVT_ERASE_BACKGROUND, EmptyHandler)
+
+ if "gtk2" in wx.PlatformInfo:
+ self.ovr.SetStandardFonts()
+ self.SetOverview(self.overviewText, mainOverview)
+
+
+ # Set up a log window
+ self.log = wx.TextCtrl(pnl, -1,
+ style = wx.TE_MULTILINE|wx.TE_READONLY|wx.HSCROLL)
+ if wx.Platform == "__WXMAC__":
+ self.log.MacCheckSpelling(False)
+
+ # Set the wxWindows log target to be this textctrl
+ #wx.Log_SetActiveTarget(wx.LogTextCtrl(self.log))
+
+ # But instead of the above we want to show how to use our own wx.Log class
+ wx.Log_SetActiveTarget(MyLog(self.log))
+
+ # for serious debugging
+ #wx.Log_SetActiveTarget(wx.LogStderr())
+ #wx.Log_SetTraceMask(wx.TraceMessages)
+
+ self.Bind(wx.EVT_ACTIVATE, self.OnActivate)
+ wx.GetApp().Bind(wx.EVT_ACTIVATE_APP, self.OnAppActivate)
+
+ # add the windows to the splitter and split it.
+ leftBox = wx.BoxSizer(wx.VERTICAL)
+ leftBox.Add(self.tree, 1, wx.EXPAND)
+ leftBox.Add(wx.StaticText(leftPanel, label = "Filter Demos:"), 0, wx.TOP|wx.LEFT, 5)
+ leftBox.Add(self.filter, 0, wx.EXPAND|wx.ALL, 5)
+ if 'wxMac' in wx.PlatformInfo:
+ leftBox.Add((5,5)) # Make sure there is room for the focus ring
+ leftPanel.SetSizer(leftBox)
+
+ # select initial items
+ self.nb.SetSelection(0)
+ self.tree.SelectItem(self.root)
+
+ # Load 'Main' module
+ self.LoadDemo(self.overviewText)
+ self.loaded = True
+
+ # select some other initial module?
+ if len(sys.argv) > 1:
+ arg = sys.argv[1]
+ if arg.endswith('.py'):
+ arg = arg[:-3]
+ selectedDemo = self.treeMap.get(arg, None)
+ if selectedDemo:
+ self.tree.SelectItem(selectedDemo)
+ self.tree.EnsureVisible(selectedDemo)
+
+ # Use the aui manager to set up everything
+ self.mgr.AddPane(self.nb, wx.aui.AuiPaneInfo().CenterPane().Name("Notebook"))
+ self.mgr.AddPane(leftPanel,
+ wx.aui.AuiPaneInfo().
+ Left().Layer(2).BestSize((240, -1)).
+ MinSize((240, -1)).
+ Floatable(self.allowAuiFloating).FloatingSize((240, 700)).
+ Caption("wxPython Demos").
+ CloseButton(False).
+ Name("DemoTree"))
+ self.mgr.AddPane(self.log,
+ wx.aui.AuiPaneInfo().
+ Bottom().BestSize((-1, 150)).
+ MinSize((-1, 140)).
+ Floatable(self.allowAuiFloating).FloatingSize((500, 160)).
+ Caption("Demo Log Messages").
+ CloseButton(False).
+ Name("LogWindow"))
+
+ self.auiConfigurations[DEFAULT_PERSPECTIVE] = self.mgr.SavePerspective()
+ self.mgr.Update()
+
+ self.mgr.SetFlags(self.mgr.GetFlags() ^ wx.aui.AUI_MGR_TRANSPARENT_DRAG)
+
+
+ def ReadConfigurationFile(self):
+
+ self.auiConfigurations = {}
+ self.expansionState = [0, 1]
+
+ config = GetConfig()
+ val = config.Read('ExpansionState')
+ if val:
+ self.expansionState = eval(val)
+
+ val = config.Read('AUIPerspectives')
+ if val:
+ self.auiConfigurations = eval(val)
+
+ val = config.Read('AllowDownloads')
+ if val:
+ self.allowDocs = eval(val)
+
+ val = config.Read('AllowAUIFloating')
+ if val:
+ self.allowAuiFloating = eval(val)
+
+ MakeDocDirs()
+ pickledFile = GetDocFile()
+
+ if not os.path.isfile(pickledFile):
+ self.pickledData = {}
+ return
+
+ fid = open(pickledFile, "rb")
+ try:
+ self.pickledData = cPickle.load(fid)
+ except:
+ self.pickledData = {}
+
+ fid.close()
+
+
+ def BuildMenuBar(self):
+
+ # Make a File menu
+ self.mainmenu = wx.MenuBar()
+ menu = wx.Menu()
+ item = menu.Append(-1, '&Redirect Output',
+ 'Redirect print statements to a window',
+ wx.ITEM_CHECK)
+ self.Bind(wx.EVT_MENU, self.OnToggleRedirect, item)
+
+ wx.App.SetMacExitMenuItemId(9123)
+ exitItem = wx.MenuItem(menu, 9123, 'E&xit\tCtrl-Q', 'Get the heck outta here!')
+ exitItem.SetBitmap(images.catalog['exit'].GetBitmap())
+ menu.AppendItem(exitItem)
+ self.Bind(wx.EVT_MENU, self.OnFileExit, exitItem)
+ self.mainmenu.Append(menu, '&File')
+
+ # Make a Demo menu
+ menu = wx.Menu()
+ for indx, item in enumerate(_treeList[:-1]):
+ menuItem = wx.MenuItem(menu, -1, item[0])
+ submenu = wx.Menu()
+ for childItem in item[1]:
+ mi = submenu.Append(-1, childItem)
+ self.Bind(wx.EVT_MENU, self.OnDemoMenu, mi)
+ menuItem.SetBitmap(images.catalog[_demoPngs[indx+1]].GetBitmap())
+ menuItem.SetSubMenu(submenu)
+ menu.AppendItem(menuItem)
+ self.mainmenu.Append(menu, '&Demo')
+
+ # Make an Option menu
+
+ menu = wx.Menu()
+ item = wx.MenuItem(menu, -1, 'Allow download of docs', 'Docs for window styles and events from the web', wx.ITEM_CHECK)
+ menu.AppendItem(item)
+ item.Check(self.allowDocs)
+ self.Bind(wx.EVT_MENU, self.OnAllowDownload, item)
+
+ item = wx.MenuItem(menu, -1, 'Delete saved docs', 'Deletes the cPickle file where docs are stored')
+ item.SetBitmap(images.catalog['deletedocs'].GetBitmap())
+ menu.AppendItem(item)
+ self.Bind(wx.EVT_MENU, self.OnDeleteDocs, item)
+
+ menu.AppendSeparator()
+ item = wx.MenuItem(menu, -1, 'Allow floating panes', 'Allows the demo panes to be floated using wxAUI', wx.ITEM_CHECK)
+ menu.AppendItem(item)
+ item.Check(self.allowAuiFloating)
+ self.Bind(wx.EVT_MENU, self.OnAllowAuiFloating, item)
+
+ auiPerspectives = self.auiConfigurations.keys()
+ auiPerspectives.sort()
+ perspectivesMenu = wx.Menu()
+ item = wx.MenuItem(perspectivesMenu, -1, DEFAULT_PERSPECTIVE, "Load startup default perspective", wx.ITEM_RADIO)
+ self.Bind(wx.EVT_MENU, self.OnAUIPerspectives, item)
+ perspectivesMenu.AppendItem(item)
+ for indx, key in enumerate(auiPerspectives):
+ if key == DEFAULT_PERSPECTIVE:
+ continue
+ item = wx.MenuItem(perspectivesMenu, -1, key, "Load user perspective %d"%indx, wx.ITEM_RADIO)
+ perspectivesMenu.AppendItem(item)
+ self.Bind(wx.EVT_MENU, self.OnAUIPerspectives, item)
+
+ menu.AppendMenu(wx.ID_ANY, "&AUI Perspectives", perspectivesMenu)
+ self.perspectives_menu = perspectivesMenu
+
+ item = wx.MenuItem(menu, -1, 'Save Perspective', 'Save AUI perspective')
+ item.SetBitmap(images.catalog['saveperspective'].GetBitmap())
+ menu.AppendItem(item)
+ self.Bind(wx.EVT_MENU, self.OnSavePerspective, item)
+
+ item = wx.MenuItem(menu, -1, 'Delete Perspective', 'Delete AUI perspective')
+ item.SetBitmap(images.catalog['deleteperspective'].GetBitmap())
+ menu.AppendItem(item)
+ self.Bind(wx.EVT_MENU, self.OnDeletePerspective, item)
+
+ menu.AppendSeparator()
+
+ item = wx.MenuItem(menu, -1, 'Restore Tree Expansion', 'Restore the initial tree expansion state')
+ item.SetBitmap(images.catalog['expansion'].GetBitmap())
+ menu.AppendItem(item)
+ self.Bind(wx.EVT_MENU, self.OnTreeExpansion, item)
+
+ self.mainmenu.Append(menu, '&Options')
+ self.options_menu = menu
+
+ # Make a Help menu
+ menu = wx.Menu()
+ findItem = wx.MenuItem(menu, -1, '&Find\tCtrl-F', 'Find in the Demo Code')
+ findItem.SetBitmap(images.catalog['find'].GetBitmap())
+ if 'wxMac' not in wx.PlatformInfo:
+ findNextItem = wx.MenuItem(menu, -1, 'Find &Next\tF3', 'Find Next')
+ else:
+ findNextItem = wx.MenuItem(menu, -1, 'Find &Next\tCtrl-G', 'Find Next')
+ findNextItem.SetBitmap(images.catalog['findnext'].GetBitmap())
+ menu.AppendItem(findItem)
+ menu.AppendItem(findNextItem)
+ menu.AppendSeparator()
+
+ shellItem = wx.MenuItem(menu, -1, 'Open Py&Shell Window\tF5',
+ 'An interactive interpreter window with the demo app and frame objects in the namesapce')
+ shellItem.SetBitmap(images.catalog['pyshell'].GetBitmap())
+ menu.AppendItem(shellItem)
+ inspToolItem = wx.MenuItem(menu, -1, 'Open &Widget Inspector\tF6',
+ 'A tool that lets you browse the live widgets and sizers in an application')
+ inspToolItem.SetBitmap(images.catalog['inspect'].GetBitmap())
+ menu.AppendItem(inspToolItem)
+ if 'wxMac' not in wx.PlatformInfo:
+ menu.AppendSeparator()
+ helpItem = menu.Append(wx.ID_ABOUT, '&About wxPython Demo', 'wxPython RULES!!!')
+
+ self.Bind(wx.EVT_MENU, self.OnOpenShellWindow, shellItem)
+ self.Bind(wx.EVT_MENU, self.OnOpenWidgetInspector, inspToolItem)
+ self.Bind(wx.EVT_MENU, self.OnHelpAbout, helpItem)
+ self.Bind(wx.EVT_MENU, self.OnHelpFind, findItem)
+ self.Bind(wx.EVT_MENU, self.OnFindNext, findNextItem)
+ self.Bind(wx.EVT_FIND, self.OnFind)
+ self.Bind(wx.EVT_FIND_NEXT, self.OnFind)
+ self.Bind(wx.EVT_FIND_CLOSE, self.OnFindClose)
+ self.Bind(wx.EVT_UPDATE_UI, self.OnUpdateFindItems, findItem)
+ self.Bind(wx.EVT_UPDATE_UI, self.OnUpdateFindItems, findNextItem)
+ self.mainmenu.Append(menu, '&Help')
+ self.SetMenuBar(self.mainmenu)
+
+ self.EnableAUIMenu()
+
+ if False:
+ # This is another way to set Accelerators, in addition to
+ # using the '\t' syntax in the menu items.
+ aTable = wx.AcceleratorTable([(wx.ACCEL_ALT, ord('X'), exitItem.GetId()),
+ (wx.ACCEL_CTRL, ord('H'), helpItem.GetId()),
+ (wx.ACCEL_CTRL, ord('F'), findItem.GetId()),
+ (wx.ACCEL_NORMAL, wx.WXK_F3, findNextItem.GetId()),
+ (wx.ACCEL_NORMAL, wx.WXK_F9, shellItem.GetId()),
+ ])
+ self.SetAcceleratorTable(aTable)
+
+
+ #---------------------------------------------
+ def RecreateTree(self, evt=None):
+ # Catch the search type (name or content)
+ searchMenu = self.filter.GetMenu().GetMenuItems()
+ fullSearch = searchMenu[1].IsChecked()
+
+ if evt:
+ if fullSearch:
+ # Do not`scan all the demo files for every char
+ # the user input, use wx.EVT_TEXT_ENTER instead
+ return
+
+ expansionState = self.tree.GetExpansionState()
+
+ current = None
+ item = self.tree.GetSelection()
+ if item:
+ prnt = self.tree.GetItemParent(item)
+ if prnt:
+ current = (self.tree.GetItemText(item),
+ self.tree.GetItemText(prnt))
+
+ self.tree.Freeze()
+ self.tree.DeleteAllItems()
+ self.root = self.tree.AddRoot("wxPython Overview")
+ self.tree.SetItemImage(self.root, 0)
+ self.tree.SetItemPyData(self.root, 0)
+
+ treeFont = self.tree.GetFont()
+ catFont = self.tree.GetFont()
+
+ # The native treectrl on MSW has a bug where it doesn't draw
+ # all of the text for an item if the font is larger than the
+ # default. It seems to be clipping the item's label as if it
+ # was the size of the same label in the default font.
+ if USE_CUSTOMTREECTRL or 'wxMSW' not in wx.PlatformInfo:
+ treeFont.SetPointSize(treeFont.GetPointSize()+2)
+
+ treeFont.SetWeight(wx.BOLD)
+ catFont.SetWeight(wx.BOLD)
+ self.tree.SetItemFont(self.root, treeFont)
+
+ firstChild = None
+ selectItem = None
+ filter = self.filter.GetValue()
+ count = 0
+
+ for category, items in _treeList:
+ count += 1
+ if filter:
+ if fullSearch:
+ items = self.searchItems[category]
+ else:
+ items = [item for item in items if filter.lower() in item.lower()]
+ if items:
+ child = self.tree.AppendItem(self.root, category, image=count)
+ self.tree.SetItemFont(child, catFont)
+ self.tree.SetItemPyData(child, count)
+ if not firstChild: firstChild = child
+ for childItem in items:
+ image = count
+ if DoesModifiedExist(childItem):
+ image = len(_demoPngs)
+ theDemo = self.tree.AppendItem(child, childItem, image=image)
+ self.tree.SetItemPyData(theDemo, count)
+ self.treeMap[childItem] = theDemo
+ if current and (childItem, category) == current:
+ selectItem = theDemo
+
+
+ self.tree.Expand(self.root)
+ if firstChild:
+ self.tree.Expand(firstChild)
+ if filter:
+ self.tree.ExpandAll()
+ elif expansionState:
+ self.tree.SetExpansionState(expansionState)
+ if selectItem:
+ self.skipLoad = True
+ self.tree.SelectItem(selectItem)
+ self.skipLoad = False
+
+ self.tree.Thaw()
+ self.searchItems = {}
+
+
+ def OnStatusBarSize(self, evt):
+ self.Reposition() # for normal size events
+
+ # Set a flag so the idle time handler will also do the repositioning.
+ # It is done this way to get around a buglet where GetFieldRect is not
+ # accurate during the EVT_SIZE resulting from a frame maximize.
+ self.sizeChanged = True
+
+
+ def OnStatusBarIdle(self, evt):
+ if self.sizeChanged:
+ self.Reposition()
+
+
+ # reposition the download gauge
+ def Reposition(self):
+ rect = self.statusBar.GetFieldRect(1)
+ self.downloadGauge.SetPosition((rect.x+2, rect.y+2))
+ self.downloadGauge.SetSize((rect.width-4, rect.height-4))
+ self.sizeChanged = False
+
+
+ def OnSearchMenu(self, event):
+
+ # Catch the search type (name or content)
+ searchMenu = self.filter.GetMenu().GetMenuItems()
+ fullSearch = searchMenu[1].IsChecked()
+
+ if fullSearch:
+ self.OnSearch()
+ else:
+ self.RecreateTree()
+
+
+ def OnSearch(self, event=None):
+
+ value = self.filter.GetValue()
+ if not value:
+ self.RecreateTree()
+ return
+
+ wx.BeginBusyCursor()
+
+ for category, items in _treeList:
+ self.searchItems[category] = []
+ for childItem in items:
+ if SearchDemo(childItem, value):
+ self.searchItems[category].append(childItem)
+
+ wx.EndBusyCursor()
+ self.RecreateTree()
+
+
+ def SetTreeModified(self, modified):
+ item = self.tree.GetSelection()
+ if modified:
+ image = len(_demoPngs)
+ else:
+ image = self.tree.GetItemPyData(item)
+ self.tree.SetItemImage(item, image)
+
+
+ def WriteText(self, text):
+ if text[-1:] == '\n':
+ text = text[:-1]
+ wx.LogMessage(text)
+
+ def write(self, txt):
+ self.WriteText(txt)
+
+ #---------------------------------------------
+ def OnItemExpanded(self, event):
+ item = event.GetItem()
+ wx.LogMessage("OnItemExpanded: %s" % self.tree.GetItemText(item))
+ event.Skip()
+
+ #---------------------------------------------
+ def OnItemCollapsed(self, event):
+ item = event.GetItem()
+ wx.LogMessage("OnItemCollapsed: %s" % self.tree.GetItemText(item))
+ event.Skip()
+
+ #---------------------------------------------
+ def OnTreeLeftDown(self, event):
+ # reset the overview text if the tree item is clicked on again
+ pt = event.GetPosition();
+ item, flags = self.tree.HitTest(pt)
+ if item == self.tree.GetSelection():
+ self.SetOverview(self.tree.GetItemText(item)+" Overview", self.curOverview)
+ event.Skip()
+
+ #---------------------------------------------
+ def OnSelChanged(self, event):
+ if self.dying or not self.loaded or self.skipLoad:
+ return
+
+ self.StopDownload()
+
+ item = event.GetItem()
+ itemText = self.tree.GetItemText(item)
+ self.LoadDemo(itemText)
+
+ self.StartDownload()
+
+ #---------------------------------------------
+ def LoadDemo(self, demoName):
+ try:
+ wx.BeginBusyCursor()
+ self.pnl.Freeze()
+
+ os.chdir(self.cwd)
+ self.ShutdownDemoModule()
+
+ if demoName == self.overviewText:
+ # User selected the "wxPython Overview" node
+ # ie: _this_ module
+ # Changing the main window at runtime not yet supported...
+ self.demoModules = DemoModules(__name__)
+ self.SetOverview(self.overviewText, mainOverview)
+ self.LoadDemoSource()
+ self.UpdateNotebook(0)
+ else:
+ if os.path.exists(GetOriginalFilename(demoName)):
+ wx.LogMessage("Loading demo %s.py..." % demoName)
+ self.demoModules = DemoModules(demoName)
+ self.LoadDemoSource()
+
+ else:
+
+ package, overview = LookForExternals(self.externalDemos, demoName)
+
+ if package:
+ wx.LogMessage("Loading demo %s.py..." % ("%s/%s"%(package, demoName)))
+ self.demoModules = DemoModules("%s/%s"%(package, demoName))
+ self.LoadDemoSource()
+ elif overview:
+ self.SetOverview(demoName, overview)
+ self.codePage = None
+ self.UpdateNotebook(0)
+ else:
+ self.SetOverview("wxPython", mainOverview)
+ self.codePage = None
+ self.UpdateNotebook(0)
+
+ finally:
+ wx.EndBusyCursor()
+ self.pnl.Thaw()
+
+ #---------------------------------------------
+ def LoadDemoSource(self):
+ self.codePage = None
+ self.codePage = DemoCodePanel(self.nb, self)
+ self.codePage.LoadDemo(self.demoModules)
+
+ #---------------------------------------------
+ def RunModule(self):
+ """Runs the active module"""
+
+ module = self.demoModules.GetActive()
+ self.ShutdownDemoModule()
+ overviewText = ""
+
+ # o The RunTest() for all samples must now return a window that can
+ # be palced in a tab in the main notebook.
+ # o If an error occurs (or has occurred before) an error tab is created.
+
+ if module is not None:
+ wx.LogMessage("Running demo module...")
+ if hasattr(module, "overview"):
+ overviewText = module.overview
+
+ try:
+ self.demoPage = module.runTest(self, self.nb, self)
+ except:
+ self.demoPage = DemoErrorPanel(self.nb, self.codePage,
+ DemoError(sys.exc_info()), self)
+
+ bg = self.nb.GetThemeBackgroundColour()
+ if bg:
+ self.demoPage.SetBackgroundColour(bg)
+
+ assert self.demoPage is not None, "runTest must return a window!"
+
+ else:
+ # There was a previous error in compiling or exec-ing
+ self.demoPage = DemoErrorPanel(self.nb, self.codePage,
+ self.demoModules.GetErrorInfo(), self)
+
+ self.SetOverview(self.demoModules.name + " Overview", overviewText)
+
+ if self.firstTime:
+ # change to the demo page the first time a module is run
+ self.UpdateNotebook(2)
+ self.firstTime = False
+ else:
+ # otherwise just stay on the same tab in case the user has changed to another one
+ self.UpdateNotebook()
+
+ #---------------------------------------------
+ def ShutdownDemoModule(self):
+ if self.demoPage:
+ # inform the window that it's time to quit if it cares
+ if hasattr(self.demoPage, "ShutdownDemo"):
+ self.demoPage.ShutdownDemo()
+## wx.YieldIfNeeded() # in case the page has pending events
+ self.demoPage = None
+
+ #---------------------------------------------
+ def UpdateNotebook(self, select = -1):
+ nb = self.nb
+ debug = False
+ self.pnl.Freeze()
+
+ def UpdatePage(page, pageText):
+ pageExists = False
+ pagePos = -1
+ for i in range(nb.GetPageCount()):
+ if nb.GetPageText(i) == pageText:
+ pageExists = True
+ pagePos = i
+ break
+
+ if page:
+ if not pageExists:
+ # Add a new page
+ nb.AddPage(page, pageText, imageId=nb.GetPageCount())
+ if debug: wx.LogMessage("DBG: ADDED %s" % pageText)
+ else:
+ if nb.GetPage(pagePos) != page:
+ # Reload an existing page
+ nb.DeletePage(pagePos)
+ nb.InsertPage(pagePos, page, pageText, imageId=pagePos)
+ if debug: wx.LogMessage("DBG: RELOADED %s" % pageText)
+ else:
+ # Excellent! No redraw/flicker
+ if debug: wx.LogMessage("DBG: SAVED from reloading %s" % pageText)
+ elif pageExists:
+ # Delete a page
+ nb.DeletePage(pagePos)
+ if debug: wx.LogMessage("DBG: DELETED %s" % pageText)
+ else:
+ if debug: wx.LogMessage("DBG: STILL GONE - %s" % pageText)
+
+ if select == -1:
+ select = nb.GetSelection()
+
+ UpdatePage(self.codePage, "Demo Code")
+ UpdatePage(self.demoPage, "Demo")
+
+ if select >= 0 and select < nb.GetPageCount():
+ nb.SetSelection(select)
+
+ self.pnl.Thaw()
+
+ #---------------------------------------------
+ def SetOverview(self, name, text):
+ self.curOverview = text
+ lead = text[:6]
+ if lead != '' and lead != '':
+ text = ' '.join(text.split('\n'))
+ if wx.USE_UNICODE:
+ text = text.decode('iso8859_1')
+ self.ovr.SetPage(text)
+ self.nb.SetPageText(0, os.path.split(name)[1])
+
+ #---------------------------------------------
+
+ def StartDownload(self):
+
+ if self.downloading or not self.allowDocs:
+ return
+
+ item = self.tree.GetSelection()
+ if self.tree.ItemHasChildren(item):
+ return
+
+ itemText = self.tree.GetItemText(item)
+
+ if itemText in self.pickledData:
+ self.LoadDocumentation(self.pickledData[itemText])
+ return
+
+ text = self.curOverview
+ text += "
Checking for documentation on the wxWidgets website, please stand by... "
+
+ lead = text[:6]
+ if lead != '' and lead != '':
+ text = ' '.join(text.split('\n'))
+
+ self.ovr.SetPage(text)
+
+ self.downloadTimer.Start(100)
+ self.downloadGauge.Show()
+ self.Reposition()
+ self.downloading = True
+ self.internetThread = InternetThread(self, itemText)
+
+ #---------------------------------------------
+
+ def StopDownload(self, error=None):
+
+ self.downloadTimer.Stop()
+
+ if not self.downloading:
+ return
+
+ if error:
+ if self.sendDownloadError:
+ self.log.write("Warning: problems in downloading documentation from the wxWidgets website.\n")
+ self.log.write("Error message from the documentation downloader was:\n")
+ self.log.write("\n".join(error))
+ self.sendDownloadError = False
+
+ self.nb.SetPageImage(0, 0)
+
+ self.internetThread.keepRunning = False
+ self.internetThread = None
+
+ self.downloading = False
+ self.downloadGauge.Hide()
+ self.Reposition()
+
+ text = self.curOverview
+
+ lead = text[:6]
+ if lead != '' and lead != '':
+ text = ' '.join(text.split('\n'))
+
+ self.ovr.SetPage(text)
+
+ #---------------------------------------------
+
+ def LoadDocumentation(self, data):
+
+ text = self.curOverview
+ addHtml = False
+
+ if '' not in text and '' not in text:
+ text = ' '.join(text.split('\n'))
+
+ styles, events, extra, appearance = data
+
+ if appearance:
+ text += FormatImages(appearance)
+
+ for names, values in zip(["Styles", "Extra Styles", "Events"], [styles, extra, events]):
+ if not values:
+ continue
+
+ headers = (names == "Events" and [2] or [3])[0]
+ text += "
" + FormatDocs(names, values, headers)
+
+ item = self.tree.GetSelection()
+ itemText = self.tree.GetItemText(item)
+
+ self.pickledData[itemText] = data
+
+ if wx.USE_UNICODE:
+ text = text.decode('iso8859_1')
+
+ self.StopDownload()
+ self.ovr.SetPage(text)
+ #print "load time: ", time.time() - start
+
+ # Menu methods
+ def OnFileExit(self, *event):
+ self.Close()
+
+ def OnToggleRedirect(self, event):
+ app = wx.GetApp()
+ if event.Checked():
+ app.RedirectStdio()
+ print "Print statements and other standard output will now be directed to this window."
+ else:
+ app.RestoreStdio()
+ print "Print statements and other standard output will now be sent to the usual location."
+
+
+ def OnAllowDownload(self, event):
+
+ self.allowDocs = event.Checked()
+ if self.allowDocs:
+ self.StartDownload()
+ else:
+ self.StopDownload()
+
+
+ def OnDeleteDocs(self, event):
+
+ deleteMsg = "You are about to delete the downloaded documentation.\n" + \
+ "Do you want to continue?"
+ dlg = wx.MessageDialog(self, deleteMsg, "wxPython Demo",
+ wx.YES_NO | wx.NO_DEFAULT| wx.ICON_QUESTION)
+ result = dlg.ShowModal()
+ if result == wx.ID_NO:
+ dlg.Destroy()
+ return
+
+ dlg.Destroy()
+
+ busy = wx.BusyInfo("Deleting downloaded data...")
+ wx.SafeYield()
+
+ pickledFile = GetDocFile()
+ docDir = os.path.split(pickledFile)[0]
+
+ if os.path.exists(docDir):
+ shutil.rmtree(docDir, ignore_errors=True)
+
+ self.pickledData = {}
+ del busy
+ self.sendDownloadError = True
+
+
+ def OnAllowAuiFloating(self, event):
+
+ self.allowAuiFloating = event.Checked()
+ for pane in self.mgr.GetAllPanes():
+ if pane.name != "Notebook":
+ pane.Floatable(self.allowAuiFloating)
+
+ self.EnableAUIMenu()
+ self.mgr.Update()
+
+
+ def EnableAUIMenu(self):
+
+ menuItems = self.options_menu.GetMenuItems()
+ for indx in xrange(4, len(menuItems)-1):
+ item = menuItems[indx]
+ item.Enable(self.allowAuiFloating)
+
+
+ def OnAUIPerspectives(self, event):
+ perspective = self.perspectives_menu.GetLabel(event.GetId())
+ self.mgr.LoadPerspective(self.auiConfigurations[perspective])
+ self.mgr.Update()
+
+
+ def OnSavePerspective(self, event):
+ dlg = wx.TextEntryDialog(self, "Enter a name for the new perspective:", "AUI Configuration")
+
+ dlg.SetValue(("Perspective %d")%(len(self.auiConfigurations)+1))
+ if dlg.ShowModal() != wx.ID_OK:
+ return
+
+ perspectiveName = dlg.GetValue()
+ menuItems = self.perspectives_menu.GetMenuItems()
+ for item in menuItems:
+ if item.GetLabel() == perspectiveName:
+ wx.MessageBox("The selected perspective name:\n\n%s\n\nAlready exists."%perspectiveName,
+ "Error", style=wx.ICON_ERROR)
+ return
+
+ item = wx.MenuItem(self.perspectives_menu, -1, dlg.GetValue(),
+ "Load user perspective %d"%(len(self.auiConfigurations)+1),
+ wx.ITEM_RADIO)
+ self.Bind(wx.EVT_MENU, self.OnAUIPerspectives, item)
+ self.perspectives_menu.AppendItem(item)
+ item.Check(True)
+ self.auiConfigurations.update({dlg.GetValue(): self.mgr.SavePerspective()})
+
+
+ def OnDeletePerspective(self, event):
+ menuItems = self.perspectives_menu.GetMenuItems()
+ lst = []
+ loadDefault = False
+
+ for indx, item in enumerate(menuItems):
+ if indx > 0:
+ lst.append(item.GetLabel())
+
+ dlg = wx.MultiChoiceDialog(self,
+ "Please select the perspectives\nyou would like to delete:",
+ "Delete AUI Perspectives", lst)
+
+ if dlg.ShowModal() == wx.ID_OK:
+ selections = dlg.GetSelections()
+ strings = [lst[x] for x in selections]
+ for sel in strings:
+ self.auiConfigurations.pop(sel)
+ item = menuItems[lst.index(sel)+1]
+ if item.IsChecked():
+ loadDefault = True
+ self.perspectives_menu.GetMenuItems()[0].Check(True)
+ self.perspectives_menu.DeleteItem(item)
+ lst.remove(sel)
+
+ if loadDefault:
+ self.mgr.LoadPerspective(self.auiConfigurations[DEFAULT_PERSPECTIVE])
+ self.mgr.Update()
+
+
+ def OnTreeExpansion(self, event):
+ self.tree.SetExpansionState(self.expansionState)
+
+
+ def OnHelpAbout(self, event):
+ from About import MyAboutBox
+ about = MyAboutBox(self)
+ about.ShowModal()
+ about.Destroy()
+
+ def OnHelpFind(self, event):
+ if self.finddlg != None:
+ return
+
+ self.nb.SetSelection(1)
+ self.finddlg = wx.FindReplaceDialog(self, self.finddata, "Find",
+ wx.FR_NOMATCHCASE | wx.FR_NOWHOLEWORD)
+ self.finddlg.Show(True)
+
+
+ def OnUpdateFindItems(self, evt):
+ evt.Enable(self.finddlg == None)
+
+
+ def OnFind(self, event):
+ editor = self.codePage.editor
+ self.nb.SetSelection(1)
+ end = editor.GetLastPosition()
+ textstring = editor.GetRange(0, end).lower()
+ findstring = self.finddata.GetFindString().lower()
+ backward = not (self.finddata.GetFlags() & wx.FR_DOWN)
+ if backward:
+ start = editor.GetSelection()[0]
+ loc = textstring.rfind(findstring, 0, start)
+ else:
+ start = editor.GetSelection()[1]
+ loc = textstring.find(findstring, start)
+ if loc == -1 and start != 0:
+ # string not found, start at beginning
+ if backward:
+ start = end
+ loc = textstring.rfind(findstring, 0, start)
+ else:
+ start = 0
+ loc = textstring.find(findstring, start)
+ if loc == -1:
+ dlg = wx.MessageDialog(self, 'Find String Not Found',
+ 'Find String Not Found in Demo File',
+ wx.OK | wx.ICON_INFORMATION)
+ dlg.ShowModal()
+ dlg.Destroy()
+ if self.finddlg:
+ if loc == -1:
+ self.finddlg.SetFocus()
+ return
+ else:
+ self.finddlg.Destroy()
+ self.finddlg = None
+ editor.ShowPosition(loc)
+ editor.SetSelection(loc, loc + len(findstring))
+
+
+
+ def OnFindNext(self, event):
+ if self.finddata.GetFindString():
+ self.OnFind(event)
+ else:
+ self.OnHelpFind(event)
+
+ def OnFindClose(self, event):
+ event.GetDialog().Destroy()
+ self.finddlg = None
+
+
+ def OnOpenShellWindow(self, evt):
+ if self.shell:
+ # if it already exists then just make sure it's visible
+ s = self.shell
+ if s.IsIconized():
+ s.Iconize(False)
+ s.Raise()
+ else:
+ # Make a PyShell window
+ from wx import py
+ namespace = { 'wx' : wx,
+ 'app' : wx.GetApp(),
+ 'frame' : self,
+ }
+ self.shell = py.shell.ShellFrame(None, locals=namespace)
+ self.shell.SetSize((640,480))
+ self.shell.Show()
+
+ # Hook the close event of the main frame window so that we
+ # close the shell at the same time if it still exists
+ def CloseShell(evt):
+ if self.shell:
+ self.shell.Close()
+ evt.Skip()
+ self.Bind(wx.EVT_CLOSE, CloseShell)
+
+
+ def OnOpenWidgetInspector(self, evt):
+ # Activate the widget inspection tool
+ from wx.lib.inspection import InspectionTool
+ if not InspectionTool().initialized:
+ InspectionTool().Init()
+
+ # Find a widget to be selected in the tree. Use either the
+ # one under the cursor, if any, or this frame.
+ wnd = wx.FindWindowAtPointer()
+ if not wnd:
+ wnd = self
+ InspectionTool().Show(wnd, True)
+
+
+ #---------------------------------------------
+ def OnCloseWindow(self, event):
+ self.mgr.UnInit()
+ self.dying = True
+ self.demoPage = None
+ self.codePage = None
+ self.mainmenu = None
+ self.StopDownload()
+
+ if self.tbicon is not None:
+ self.tbicon.Destroy()
+
+ config = GetConfig()
+ config.Write('ExpansionState', str(self.tree.GetExpansionState()))
+ config.Write('AUIPerspectives', str(self.auiConfigurations))
+ config.Write('AllowDownloads', str(self.allowDocs))
+ config.Write('AllowAUIFloating', str(self.allowAuiFloating))
+
+ config.Flush()
+
+ MakeDocDirs()
+ pickledFile = GetDocFile()
+ fid = open(pickledFile, "wb")
+ cPickle.dump(self.pickledData, fid, cPickle.HIGHEST_PROTOCOL)
+ fid.close()
+
+ self.Destroy()
+
+
+ #---------------------------------------------
+ def OnIdle(self, event):
+ if self.otherWin:
+ self.otherWin.Raise()
+ self.demoPage = self.otherWin
+ self.otherWin = None
+
+
+ #---------------------------------------------
+
+ def OnDownloadTimer(self, event):
+
+ self.downloadGauge.Pulse()
+
+ self.downloadImage += 1
+ if self.downloadImage > 9:
+ self.downloadImage = 3
+
+ self.nb.SetPageImage(0, self.downloadImage)
+## wx.SafeYield()
+
+ #---------------------------------------------
+
+ def ShowTip(self):
+ config = GetConfig()
+ showTipText = config.Read("tips")
+ if showTipText:
+ showTip, index = eval(showTipText)
+ else:
+ showTip, index = (1, 0)
+
+ if showTip:
+ tp = wx.CreateFileTipProvider(opj("data/tips.txt"), index)
+ showTip = wx.ShowTip(self, tp)
+ index = tp.GetCurrentTip()
+ config.Write("tips", str( (showTip, index) ))
+ config.Flush()
+
+ #---------------------------------------------
+ def OnDemoMenu(self, event):
+ try:
+ selectedDemo = self.treeMap[self.mainmenu.GetLabel(event.GetId())]
+ except:
+ selectedDemo = None
+ if selectedDemo:
+ self.tree.SelectItem(selectedDemo)
+ self.tree.EnsureVisible(selectedDemo)
+
+
+ #---------------------------------------------
+ def OnIconfiy(self, evt):
+ wx.LogMessage("OnIconfiy: %s" % evt.Iconized())
+ evt.Skip()
+
+ #---------------------------------------------
+ def OnMaximize(self, evt):
+ wx.LogMessage("OnMaximize")
+ evt.Skip()
+
+ #---------------------------------------------
+ def OnActivate(self, evt):
+ wx.LogMessage("OnActivate: %s" % evt.GetActive())
+ evt.Skip()
+
+ #---------------------------------------------
+ def OnAppActivate(self, evt):
+ wx.LogMessage("OnAppActivate: %s" % evt.GetActive())
+ evt.Skip()
+
+#---------------------------------------------------------------------------
+#---------------------------------------------------------------------------
+
+class MySplashScreen(wx.SplashScreen):
+ def __init__(self):
+ bmp = wx.Image(opj("bitmaps/splash.png")).ConvertToBitmap()
+ wx.SplashScreen.__init__(self, bmp,
+ wx.SPLASH_CENTRE_ON_SCREEN | wx.SPLASH_TIMEOUT,
+ 5000, None, -1)
+ self.Bind(wx.EVT_CLOSE, self.OnClose)
+ self.fc = wx.FutureCall(2000, self.ShowMain)
+
+
+ def OnClose(self, evt):
+ # Make sure the default handler runs too so this window gets
+ # destroyed
+ evt.Skip()
+ self.Hide()
+
+ # if the timer is still running then go ahead and show the
+ # main frame now
+ if self.fc.IsRunning():
+ self.fc.Stop()
+ self.ShowMain()
+
+
+ def ShowMain(self):
+ frame = wxPythonDemo(None, "wxPython: (A Demonstration)")
+ frame.Show()
+ if self.fc.IsRunning():
+ self.Raise()
+ wx.CallAfter(frame.ShowTip)
+
+
+
+
+#---------------------------------------------------------------------------
+
+from wx.lib.mixins.treemixin import ExpansionState
+if USE_CUSTOMTREECTRL:
+ import wx.lib.customtreectrl as CT
+ TreeBaseClass = CT.CustomTreeCtrl
+else:
+ TreeBaseClass = wx.TreeCtrl
+
+
+class wxPythonDemoTree(ExpansionState, TreeBaseClass):
+ def __init__(self, parent):
+ TreeBaseClass.__init__(self, parent, style=wx.TR_DEFAULT_STYLE|
+ wx.TR_HAS_VARIABLE_ROW_HEIGHT)
+ self.BuildTreeImageList()
+ if USE_CUSTOMTREECTRL:
+ self.SetSpacing(10)
+ self.SetWindowStyle(self.GetWindowStyle() & ~wx.TR_LINES_AT_ROOT)
+
+ self.SetInitialSize((100,80))
+
+
+ def AppendItem(self, parent, text, image=-1, wnd=None):
+ if USE_CUSTOMTREECTRL:
+ item = TreeBaseClass.AppendItem(self, parent, text, image=image, wnd=wnd)
+ else:
+ item = TreeBaseClass.AppendItem(self, parent, text, image=image)
+ return item
+
+ def BuildTreeImageList(self):
+ imgList = wx.ImageList(16, 16)
+ for png in _demoPngs:
+ imgList.Add(images.catalog[png].GetBitmap())
+
+ # add the image for modified demos.
+ imgList.Add(images.catalog["custom"].GetBitmap())
+
+ self.AssignImageList(imgList)
+
+ def GetItemIdentity(self, item):
+ return self.GetPyData(item)
+
+ def Freeze(self):
+ if 'wxMSW' in wx.PlatformInfo:
+ return super(wxPythonDemoTree, self).Freeze()
+
+ def Thaw(self):
+ if 'wxMSW' in wx.PlatformInfo:
+ return super(wxPythonDemoTree, self).Thaw()
+
+#---------------------------------------------------------------------------
+
+class MyApp(wx.App, wx.lib.mixins.inspection.InspectionMixin):
+ def OnInit(self):
+
+ # Check runtime version
+ if version.VERSION_STRING != wx.VERSION_STRING:
+ wx.MessageBox(caption="Warning",
+ message="You're using version %s of wxPython, but this copy of the demo was written for version %s.\n"
+ "There may be some version incompatibilities..."
+ % (wx.VERSION_STRING, version.VERSION_STRING))
+
+ self.InitInspection() # for the InspectionMixin base class
+
+ # Now that we've warned the user about possibile problems,
+ # lets import images
+ import images as i
+ global images
+ images = i
+
+ # For debugging
+ #self.SetAssertMode(wx.PYAPP_ASSERT_DIALOG|wx.PYAPP_ASSERT_EXCEPTION)
+
+ wx.SystemOptions.SetOptionInt("mac.window-plain-transition", 1)
+ self.SetAppName("wxPyDemo")
+
+ # Create and show the splash screen. It will then create and
+ # show the main frame when it is time to do so. Normally when
+ # using a SplashScreen you would create it, show it and then
+ # continue on with the applicaiton's initialization, finally
+ # creating and showing the main application window(s). In
+ # this case we have nothing else to do so we'll delay showing
+ # the main frame until later (see ShowMain above) so the users
+ # can see the SplashScreen effect.
+ splash = MySplashScreen()
+ splash.Show()
+
+ return True
+
+
+
+#---------------------------------------------------------------------------
+
+def main():
+ try:
+ demoPath = os.path.dirname(__file__)
+ os.chdir(demoPath)
+ except:
+ pass
+ app = MyApp(False)
+ app.MainLoop()
+
+#---------------------------------------------------------------------------
+
+
+mainOverview = """
+
wxPython
+
+
wxPython is a GUI toolkit for the Python programming
+language. It allows Python programmers to create programs with a
+robust, highly functional graphical user interface, simply and easily.
+It is implemented as a Python extension module (native code) that
+wraps the popular wxWindows cross platform GUI library, which is
+written in C++.
+
+
Like Python and wxWindows, wxPython is Open Source which
+means that it is free for anyone to use and the source code is
+available for anyone to look at and modify. Or anyone can contribute
+fixes or enhancements to the project.
+
+
wxPython is a cross-platform toolkit. This means that the
+same program will run on multiple platforms without modification.
+Currently supported platforms are 32-bit Microsoft Windows, most Unix
+or unix-like systems, and Macintosh OS X. Since the language is
+Python, wxPython programs are simple, easy to write and easy to
+understand.
+
+
This demo is not only a collection of test cases for
+wxPython, but is also designed to help you learn about and how to use
+wxPython. Each sample is listed in the tree control on the left.
+When a sample is selected in the tree then a module is loaded and run
+(usually in a tab of this notebook,) and the source code of the module
+is loaded in another tab for you to browse and learn from.
+
+"""
+
+
+#----------------------------------------------------------------------------
+#----------------------------------------------------------------------------
+
+if __name__ == '__main__':
+ __name__ = 'Main'
+ main()
+
+#----------------------------------------------------------------------------
+
diff --git a/demo/Mask.py b/demo/Mask.py
new file mode 100644
index 00000000..01d773f3
--- /dev/null
+++ b/demo/Mask.py
@@ -0,0 +1,136 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+logicList = [
+ ('wx.AND', wx.AND),
+ ('wx.AND_INVERT', wx.AND_INVERT),
+ ('wx.AND_REVERSE', wx.AND_REVERSE),
+ ('wx.CLEAR', wx.CLEAR),
+ ('wx.COPY', wx.COPY),
+ ('wx.EQUIV', wx.EQUIV),
+ ('wx.INVERT', wx.INVERT),
+ ('wx.NAND', wx.NAND),
+
+ ('wx.NO_OP', wx.NO_OP),
+ ('wx.OR', wx.OR),
+ ('wx.OR_INVERT', wx.OR_INVERT),
+ ('wx.OR_REVERSE', wx.OR_REVERSE),
+ ('wx.SET', wx.SET),
+ ('wx.SRC_INVERT', wx.SRC_INVERT),
+ ('wx.XOR', wx.XOR),
+]
+
+if 'mac-cg' in wx.PlatformInfo:
+ # that's all, folks!
+ logicList = [
+ ('wx.COPY', wx.COPY),
+ ('wx.INVERT', wx.INVERT),
+ ('wx.XOR', wx.XOR),
+ ]
+
+import images
+
+class TestMaskWindow(wx.ScrolledWindow):
+ def __init__(self, parent):
+ wx.ScrolledWindow.__init__(self, parent, -1)
+ self.SetBackgroundColour(wx.Colour(0,128,0))
+
+ # A reference bitmap that we won't mask
+ self.bmp_nomask = images.TestStar2.GetBitmap()
+
+ # One that we will
+ self.bmp_withmask = images.TestStar2.GetBitmap()
+
+ # this mask comes from a monochrome bitmap
+ self.bmp_themask = images.TestMask.GetBitmap()
+ mask = wx.Mask(self.bmp_themask)
+
+ # set the mask on our bitmap
+ self.bmp_withmask.SetMask(mask)
+
+ # Now we'll create a mask in a bit of an easier way, by picking a
+ # colour in the image that is to be the transparent colour.
+ self.bmp_withcolourmask = images.TestStar2.GetBitmap()
+ mask = wx.Mask(self.bmp_withcolourmask, wx.WHITE)
+ self.bmp_withcolourmask.SetMask(mask)
+
+ self.SetScrollbars(20, 20, 700/20, 460/20)
+
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+ def OnPaint (self, e):
+ self.SetBackgroundColour(wx.Colour(0,128,0))
+ dc = wx.PaintDC(self)
+ self.PrepareDC(dc)
+ dc.SetTextForeground(wx.WHITE)
+
+ # make an interesting background...
+ dc.SetPen(wx.MEDIUM_GREY_PEN)
+ for i in range(100):
+ dc.DrawLine(0,i*10, i*10,0)
+
+ # draw raw image, mask, and masked images
+ dc.DrawText('original image', 0,0)
+ dc.DrawBitmap(self.bmp_nomask, 0,20, 0)
+ dc.DrawText('with colour mask', 0,100)
+ dc.DrawBitmap(self.bmp_withcolourmask, 0,120, 1)
+ dc.DrawText('the mask image', 0,200)
+ dc.DrawBitmap(self.bmp_themask, 0,220, 0)
+ dc.DrawText('masked image', 0,300)
+ dc.DrawBitmap(self.bmp_withmask, 0,320, 1)
+
+ cx,cy = self.bmp_themask.GetWidth(), self.bmp_themask.GetHeight()
+
+ # draw array of assorted blit operations
+ mdc = wx.MemoryDC()
+ i = 0
+
+ for text, code in logicList:
+ x,y = 120+150*(i%4), 20+100*(i/4)
+ dc.DrawText(text, x, y-20)
+ mdc.SelectObject(self.bmp_withcolourmask)
+ dc.Blit(x,y, cx,cy, mdc, 0,0, code, True)
+ i = i + 1
+
+
+# On wxGTK there needs to be a panel under wx.ScrolledWindows if they are
+# going to be in a wxNotebook...
+class TestPanel(wx.Panel):
+ def __init__(self, parent, ID):
+ wx.Panel.__init__(self, parent, ID)
+ self.win = TestMaskWindow(self)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+
+ def OnSize(self, evt):
+ self.win.SetSize(evt.GetSize())
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, -1)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+This class encapsulates a monochrome mask bitmap, where the masked area is black
+and the unmasked area is white. When associated with a bitmap and drawn in a device
+context, the unmasked area of the bitmap will be drawn, and the masked area will
+not be drawn.
+
+This example shows not only how to create a Mask, but the effects of the Device
+Context (dc) Blit() method's logic codes.
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/MaskedEditControls.py b/demo/MaskedEditControls.py
new file mode 100644
index 00000000..5923db9b
--- /dev/null
+++ b/demo/MaskedEditControls.py
@@ -0,0 +1,647 @@
+
+import string
+import sys
+import traceback
+
+import wx
+import wx.lib.masked as masked
+import wx.lib.scrolledpanel as scroll
+
+
+class demoMixin:
+ """
+ Centralized routines common to demo pages, to remove repetition.
+ """
+ def labelGeneralTable(self, sizer):
+ description = wx.StaticText( self, -1, "Description", )
+ mask = wx.StaticText( self, -1, "Mask Value" )
+ formatcode = wx.StaticText( self, -1, "Format" )
+ regex = wx.StaticText( self, -1, "Regexp Validator(opt.)" )
+ ctrl = wx.StaticText( self, -1, "Masked TextCtrl" )
+
+ description.SetFont( wx.Font(9, wx.SWISS, wx.NORMAL, wx.BOLD))
+ mask.SetFont( wx.Font(9, wx.SWISS, wx.NORMAL, wx.BOLD))
+ formatcode.SetFont( wx.Font(9, wx.SWISS, wx.NORMAL, wx.BOLD) )
+ regex.SetFont( wx.Font(9, wx.SWISS, wx.NORMAL, wx.BOLD))
+ ctrl.SetFont( wx.Font(9, wx.SWISS, wx.NORMAL, wx.BOLD))
+
+ sizer.Add(description)
+ sizer.Add(mask)
+ sizer.Add(formatcode)
+ sizer.Add(regex)
+ sizer.Add(ctrl)
+
+
+ def layoutGeneralTable(self, controls, sizer):
+ for control in controls:
+ sizer.Add( wx.StaticText( self, -1, control[0]) )
+ sizer.Add( wx.StaticText( self, -1, control[1]) )
+ sizer.Add( wx.StaticText( self, -1, control[3]) )
+ sizer.Add( wx.StaticText( self, -1, control[4]) )
+
+ if control in controls:
+ newControl = masked.TextCtrl( self, -1, "",
+ mask = control[1],
+ excludeChars = control[2],
+ formatcodes = control[3],
+ includeChars = "",
+ validRegex = control[4],
+ validRange = control[5],
+ choices = control[6],
+ choiceRequired = True,
+ defaultValue = control[7],
+ demo = True,
+ name = control[0])
+ self.editList.append(newControl)
+ sizer.Add(newControl)
+
+
+ def changeControlParams(self, event, parameter, checked_value, notchecked_value):
+ if event.IsChecked(): value = checked_value
+ else: value = notchecked_value
+
+ kwargs = {parameter: value}
+
+ for control in self.editList:
+ control.SetCtrlParameters(**kwargs)
+ control.Refresh()
+
+ self.Refresh()
+
+
+
+#----------------------------------------------------------------------------
+class demoPage1(scroll.ScrolledPanel, demoMixin):
+ def __init__(self, parent, log):
+ scroll.ScrolledPanel.__init__(self, parent, -1)
+ self.sizer = wx.BoxSizer( wx.VERTICAL )
+ self.editList = []
+
+ label = wx.StaticText( self, -1, """\
+Here are some basic masked TextCtrls to give you an idea of what you can do
+with this control. Note that all controls have been auto-sized by including 'F' in
+the format codes.
+
+Try entering nonsensical or partial values in validated fields to see what happens.
+Note that the State and Last Name fields are list-limited (valid last names are:
+Smith, Jones, Williams). Signs on numbers can be toggled with the minus key.
+""")
+ label.SetForegroundColour( "Blue" )
+ header = wx.BoxSizer( wx.HORIZONTAL )
+ header.Add( label, 0, flag=wx.ALIGN_LEFT|wx.ALL, border = 5 )
+
+ highlight = wx.CheckBox( self, -1, "Highlight Empty" )
+ disallow = wx.CheckBox( self, -1, "Disallow Empty" )
+ showFill = wx.CheckBox( self, -1, "change fillChar" )
+
+ vbox = wx.BoxSizer( wx.VERTICAL )
+ vbox.Add( highlight, 0, wx.ALIGN_LEFT|wx.ALL, 5 )
+ vbox.Add( disallow, 0, wx.ALIGN_LEFT|wx.ALL, 5 )
+ vbox.Add( showFill, 0, wx.ALIGN_LEFT|wx.ALL, 5 )
+ header.Add((15, 0))
+ header.Add(vbox, 0, flag=wx.ALIGN_LEFT|wx.ALL, border=5 )
+
+ self.Bind(wx.EVT_CHECKBOX, self.onHighlightEmpty, id=highlight.GetId())
+ self.Bind(wx.EVT_CHECKBOX, self.onDisallowEmpty, id=disallow.GetId())
+ self.Bind(wx.EVT_CHECKBOX, self.onShowFill, id=showFill.GetId())
+
+ grid = wx.FlexGridSizer( cols=5, vgap=10, hgap=10 )
+ self.labelGeneralTable(grid)
+
+ # The following list is of the controls for the demo. Feel free to play around with
+ # the options!
+ controls = [
+ #description mask excl format regexp range,list,initial
+ ("Phone No", "(###) ###-#### x:###", "", 'F^-', "^\(\d{3}\) \d{3}-\d{4}", '','',''),
+ ("Social Sec#", "###-##-####", "", 'F', "\d{3}-\d{2}-\d{4}", '','',''),
+ ("Full Name", "C{14}", "", 'F_', '^[A-Z][a-zA-Z]+ [A-Z][a-zA-Z]+', '','',''),
+ ("Last Name Only", "C{14}", "", 'F {list}', '^[A-Z][a-zA-Z]+', '',('Smith','Jones','Williams'),''),
+ ("Zip plus 4", "#{5}-#{4}", "", 'F', "\d{5}-(\s{4}|\d{4})", '','',''),
+ ("Customer No", "\CAA-###", "", 'F!', "C[A-Z]{2}-\d{3}", '','',''),
+ ("Invoice Total", "#{9}.##", "", 'F-_,', "", '','',''),
+ ("Integer", "#{9}", "", 'F-_', "", '','',''),
+ ]
+
+ self.layoutGeneralTable(controls, grid)
+ self.sizer.Add( header, 0, flag=wx.ALIGN_LEFT|wx.ALL, border=5 )
+ self.sizer.Add( grid, 0, flag= wx.ALIGN_LEFT|wx.LEFT, border=5 )
+ self.SetSizer(self.sizer)
+ self.SetupScrolling()
+ self.SetAutoLayout(1)
+
+
+ def onDisallowEmpty( self, event ):
+ """ Set emptyInvalid parameter on/off """
+ self.changeControlParams( event, "emptyInvalid", True, False )
+
+ def onHighlightEmpty( self, event ):
+ """ Highlight empty values"""
+ self.changeControlParams( event, "emptyBackgroundColour", "Blue", "White" )
+
+ def onShowFill( self, event ):
+ """ Set fillChar parameter to '?' or ' ' """
+ self.changeControlParams( event, "fillChar", '?', ' ' )
+
+
+class demoPage2(scroll.ScrolledPanel, demoMixin):
+ def __init__( self, parent, log ):
+ self.log = log
+ scroll.ScrolledPanel.__init__( self, parent, -1 )
+ self.sizer = wx.BoxSizer( wx.VERTICAL )
+
+ label = wx.StaticText( self, -1, """\
+All these controls have been created by passing a single parameter, the autoformat code,
+and use the factory class masked.Ctrl with its default controlType.
+The masked package contains an internal dictionary of types and formats (autoformats).
+Many of these already do complicated validation; To see some examples, try
+29 Feb 2002 vs. 2004 for the date formats, or email address validation.
+""")
+
+ label.SetForegroundColour( "Blue" )
+ self.sizer.Add( label, 0, wx.ALIGN_LEFT|wx.ALL, 5 )
+
+ description = wx.StaticText( self, -1, "Description")
+ autofmt = wx.StaticText( self, -1, "AutoFormat Code")
+ ctrl = wx.StaticText( self, -1, "Masked Ctrl")
+
+ description.SetFont( wx.Font( 9, wx.SWISS, wx.NORMAL, wx.BOLD ) )
+ autofmt.SetFont( wx.Font( 9, wx.SWISS, wx.NORMAL, wx.BOLD ) )
+ ctrl.SetFont( wx.Font( 9, wx.SWISS, wx.NORMAL, wx.BOLD ) )
+
+ grid = wx.FlexGridSizer( cols=3, vgap=10, hgap=5 )
+ grid.Add( description, 0, wx.ALIGN_LEFT )
+ grid.Add( autofmt, 0, wx.ALIGN_LEFT )
+ grid.Add( ctrl, 0, wx.ALIGN_LEFT )
+
+ for autoformat, desc in masked.autoformats:
+ grid.Add( wx.StaticText( self, -1, desc), 0, wx.ALIGN_LEFT )
+ grid.Add( wx.StaticText( self, -1, autoformat), 0, wx.ALIGN_LEFT )
+ grid.Add( masked.Ctrl( self, -1, "",
+ autoformat = autoformat,
+ demo = True,
+ name = autoformat),
+ 0, wx.ALIGN_LEFT )
+
+ self.sizer.Add( grid, 0, wx.ALIGN_LEFT|wx.ALL, border=5 )
+ self.SetSizer( self.sizer )
+ self.SetAutoLayout( 1 )
+ self.SetupScrolling()
+
+
+class demoPage3(scroll.ScrolledPanel, demoMixin):
+ def __init__(self, parent, log):
+ self.log = log
+ scroll.ScrolledPanel.__init__(self, parent, -1)
+ self.sizer = wx.BoxSizer( wx.VERTICAL )
+ self.editList = []
+
+ label = wx.StaticText( self, -1, """\
+Here masked TextCtrls that have default values. The states
+control has a list of valid values, and the unsigned integer
+has a legal range specified.
+""")
+ label.SetForegroundColour( "Blue" )
+ requireValid = wx.CheckBox( self, -1, "Require Valid Value" )
+ self.Bind(wx.EVT_CHECKBOX, self.onRequireValid, id=requireValid.GetId())
+
+ header = wx.BoxSizer( wx.HORIZONTAL )
+ header.Add( label, 0, flag=wx.ALIGN_LEFT|wx.ALL, border = 5)
+ header.Add((75, 0))
+ header.Add( requireValid, 0, flag=wx.ALIGN_LEFT|wx.ALL, border=10 )
+
+ grid = wx.FlexGridSizer( cols=5, vgap=10, hgap=10 )
+ self.labelGeneralTable( grid )
+
+ controls = [
+ #description mask excl format regexp range,list,initial
+ ("U.S. State (2 char)", "AA", "", 'F!_', "[A-Z]{2}", '', masked.states, masked.states[0]),
+ ("Integer (signed)", "#{6}", "", 'F-_', "", '','', ' 0 '),
+ ("Integer (unsigned)\n(1-399)","######", "", 'F_', "", (1,399),'', '1 '),
+ ("Float (signed)", "#{6}.#{9}", "", 'F-_R', "", '','', '000000.000000000'),
+ ("Date (MDY) + Time", "##/##/#### ##:##:## AM", 'BCDEFGHIJKLMNOQRSTUVWXYZ','DF!',"", '','', wx.DateTime_Now().Format("%m/%d/%Y %I:%M:%S %p")),
+ ]
+ self.layoutGeneralTable( controls, grid )
+
+ self.sizer.Add( header, 0, flag=wx.ALIGN_LEFT|wx.ALL, border=5 )
+ self.sizer.Add( grid, 0, flag=wx.ALIGN_LEFT|wx.ALL, border=5 )
+
+ self.SetSizer( self.sizer )
+ self.SetAutoLayout( 1 )
+ self.SetupScrolling()
+
+ def onRequireValid( self, event ):
+ """ Set validRequired parameter on/off """
+ self.changeControlParams( event, "validRequired", True, False )
+
+
+class demoPage4(scroll.ScrolledPanel, demoMixin):
+ def __init__( self, parent, log ):
+ self.log = log
+ scroll.ScrolledPanel.__init__( self, parent, -1 )
+ self.sizer = wx.BoxSizer( wx.VERTICAL )
+
+ label = wx.StaticText( self, -1, """\
+These controls have field-specific choice lists and allow autocompletion.
+
+Down arrow or Page Down in an uncompleted field with an auto-completable field will attempt
+to auto-complete a field if it has a choice list.
+Page Down and Shift-Down arrow will also auto-complete, or cycle through the complete list.
+Page Up and Shift-Up arrow will similarly cycle backwards through the list.
+""")
+
+ label.SetForegroundColour( "Blue" )
+ self.sizer.Add( label, 0, wx.ALIGN_LEFT|wx.ALL, 5 )
+
+ description = wx.StaticText( self, -1, "Description" )
+ autofmt = wx.StaticText( self, -1, "AutoFormat Code" )
+ fields = wx.StaticText( self, -1, "Field Objects" )
+ ctrl = wx.StaticText( self, -1, "Masked TextCtrl" )
+
+ description.SetFont( wx.Font( 9, wx.SWISS, wx.NORMAL, wx.BOLD ) )
+ autofmt.SetFont( wx.Font( 9, wx.SWISS, wx.NORMAL, wx.BOLD ) )
+ fields.SetFont( wx.Font( 9, wx.SWISS, wx.NORMAL, wx.BOLD ) )
+ ctrl.SetFont( wx.Font( 9, wx.SWISS, wx.NORMAL, wx.BOLD ) )
+
+ grid = wx.FlexGridSizer( cols=4, vgap=10, hgap=10 )
+ grid.Add( description, 0, wx.ALIGN_LEFT )
+ grid.Add( autofmt, 0, wx.ALIGN_LEFT )
+ grid.Add( fields, 0, wx.ALIGN_LEFT )
+ grid.Add( ctrl, 0, wx.ALIGN_LEFT )
+
+ autoformat = "USPHONEFULLEXT"
+ fieldsDict = {0: masked.Field(choices=["617","781","508","978","413"], choiceRequired=True)}
+ fieldsLabel = """\
+{0: Field(choices=[
+ "617","781",
+ "508","978","413"],
+ choiceRequired=True)}"""
+ grid.Add( wx.StaticText( self, -1, "Restricted Area Code"), 0, wx.ALIGN_LEFT )
+ grid.Add( wx.StaticText( self, -1, autoformat), 0, wx.ALIGN_LEFT )
+ grid.Add( wx.StaticText( self, -1, fieldsLabel), 0, wx.ALIGN_LEFT )
+ grid.Add( masked.TextCtrl( self, -1, "",
+ autoformat = autoformat,
+ fields = fieldsDict,
+ demo = True,
+ name = autoformat),
+ 0, wx.ALIGN_LEFT )
+
+ autoformat = "EXPDATEMMYY"
+ fieldsDict = {1: masked.Field(choices=["03", "04", "05"], choiceRequired=True)}
+ fieldsLabel = """\
+{1: Field(choices=[
+ "03", "04", "05"],
+ choiceRequired=True)}"""
+ exp = masked.TextCtrl( self, -1, "",
+ autoformat = autoformat,
+ fields = fieldsDict,
+ demo = True,
+ name = autoformat)
+
+ grid.Add( wx.StaticText( self, -1, "Restricted Expiration"), 0, wx.ALIGN_LEFT )
+ grid.Add( wx.StaticText( self, -1, autoformat), 0, wx.ALIGN_LEFT )
+ grid.Add( wx.StaticText( self, -1, fieldsLabel), 0, wx.ALIGN_LEFT )
+ grid.Add( exp, 0, wx.ALIGN_LEFT )
+
+ fieldsDict = {0: masked.Field(choices=["02134","02155"], choiceRequired=True),
+ 1: masked.Field(choices=["1234", "5678"], choiceRequired=False)}
+ fieldsLabel = """\
+{0: Field(choices=["02134","02155"],
+ choiceRequired=True),
+ 1: Field(choices=["1234", "5678"],
+ choiceRequired=False)}"""
+ autoformat = "USZIPPLUS4"
+ zip = masked.TextCtrl( self, -1, "",
+ autoformat = autoformat,
+ fields = fieldsDict,
+ demo = True,
+ name = autoformat)
+
+ grid.Add( wx.StaticText( self, -1, "Restricted Zip + 4"), 0, wx.ALIGN_LEFT )
+ grid.Add( wx.StaticText( self, -1, autoformat), 0, wx.ALIGN_LEFT )
+ grid.Add( wx.StaticText( self, -1, fieldsLabel), 0, wx.ALIGN_LEFT )
+ grid.Add( zip, 0, wx.ALIGN_LEFT )
+
+ self.sizer.Add( grid, 0, wx.ALIGN_LEFT|wx.ALL, border=5 )
+ self.SetSizer( self.sizer )
+ self.SetAutoLayout(1)
+ self.SetupScrolling()
+
+
+class demoPage5(scroll.ScrolledPanel, demoMixin):
+ def __init__( self, parent, log ):
+ self.log = log
+ scroll.ScrolledPanel.__init__( self, parent, -1 )
+ self.sizer = wx.BoxSizer( wx.VERTICAL )
+
+
+ labelMaskedCombos = wx.StaticText( self, -1, """\
+These are some examples of masked.ComboBox:""")
+ labelMaskedCombos.SetForegroundColour( "Blue" )
+
+
+ label_statecode = wx.StaticText( self, -1, """\
+A state selector; only
+"legal" values can be
+entered:""")
+ statecode = masked.ComboBox( self, -1, masked.states[0],
+ choices = masked.states,
+ autoformat="USSTATE")
+
+ label_statename = wx.StaticText( self, -1, """\
+A state name selector,
+with auto-select:""")
+
+ # Create this one using factory function:
+ statename = masked.Ctrl( self, -1, masked.state_names[0],
+ controlType = masked.controlTypes.COMBO,
+ choices = masked.state_names,
+ autoformat="USSTATENAME",
+ autoSelect=True)
+ statename.SetCtrlParameters(formatcodes = 'F!V_')
+
+
+ numerators = [ str(i) for i in range(1, 4) ]
+ denominators = [ string.ljust(str(i), 2) for i in [2,3,4,5,8,16,32,64] ]
+ fieldsDict = {0: masked.Field(choices=numerators, choiceRequired=False),
+ 1: masked.Field(choices=denominators, choiceRequired=True)}
+ choices = []
+ for n in numerators:
+ for d in denominators:
+ if n != d:
+ choices.append( '%s/%s' % (n,d) )
+
+
+ label_fraction = wx.StaticText( self, -1, """\
+A masked ComboBox for fraction selection.
+Choices for each side of the fraction can
+be selected with PageUp/Down:""")
+
+ fraction = masked.Ctrl( self, -1, "",
+ controlType = masked.controlTypes.COMBO,
+ choices = choices,
+ choiceRequired = True,
+ mask = "#/##",
+ formatcodes = "F_",
+ validRegex = "^\d\/\d\d?",
+ fields = fieldsDict )
+
+
+ label_code = wx.StaticText( self, -1, """\
+A masked ComboBox to validate
+text from a list of numeric codes:""")
+
+ choices = ["91", "136", "305", "4579"]
+ code = masked.ComboBox( self, -1, choices[0],
+ choices = choices,
+ choiceRequired = True,
+ formatcodes = "F_r",
+ mask = "####")
+
+ label_selector = wx.StaticText( self, -1, """\
+Programmatically set
+choice sets:""")
+ self.list_selector = wx.ComboBox(self, -1, '', choices = ['list1', 'list2', 'list3'])
+ self.dynamicbox = masked.Ctrl( self, -1, ' ',
+ controlType = masked.controlTypes.COMBO,
+ mask = 'XXXX',
+ formatcodes = 'F_',
+ # these are to give dropdown some initial height,
+ # as base control apparently only sets that size
+ # during initial construction :
+ choices = ['', '1', '2', '3', '4', '5'] )
+
+ self.dynamicbox.Clear() # get rid of initial choices used to size the dropdown
+
+
+ labelIpAddrs = wx.StaticText( self, -1, """\
+Here are some examples of IpAddrCtrl, a control derived from masked.TextCtrl:""")
+ labelIpAddrs.SetForegroundColour( "Blue" )
+
+
+ label_ipaddr1 = wx.StaticText( self, -1, "An empty control:")
+ ipaddr1 = masked.IpAddrCtrl( self, -1, style = wx.TE_PROCESS_TAB )
+
+
+ label_ipaddr2 = wx.StaticText( self, -1, "A restricted mask:")
+ ipaddr2 = masked.IpAddrCtrl( self, -1, mask=" 10. 1.109.###" )
+
+
+ label_ipaddr3 = wx.StaticText( self, -1, """\
+A control with restricted legal values:
+10. (1|2) . (129..255) . (0..255)""")
+ ipaddr3 = masked.Ctrl( self, -1,
+ controlType = masked.controlTypes.IPADDR,
+ mask=" 10. #.###.###")
+ ipaddr3.SetFieldParameters(0, validRegex="1|2",validRequired=False ) # requires entry to match or not allowed
+
+ # This allows any value in penultimate field, but colors anything outside of the range invalid:
+ ipaddr3.SetFieldParameters(1, validRange=(129,255), validRequired=False )
+
+
+
+ labelNumerics = wx.StaticText( self, -1, """\
+Here are some useful configurations of a masked.TextCtrl for integer and floating point input that still treat
+the control as a text control. (For a true numeric control, check out the masked.NumCtrl class!)""")
+ labelNumerics.SetForegroundColour( "Blue" )
+
+ label_intctrl1 = wx.StaticText( self, -1, """\
+An integer entry control with
+shifting insert enabled:""")
+ self.intctrl1 = masked.TextCtrl(self, -1, name='intctrl', mask="#{9}", formatcodes = '_-,F>')
+ label_intctrl2 = wx.StaticText( self, -1, """\
+ Right-insert integer entry:""")
+ self.intctrl2 = masked.TextCtrl(self, -1, name='intctrl', mask="#{9}", formatcodes = '_-,Fr')
+
+ label_floatctrl = wx.StaticText( self, -1, """\
+A floating point entry control
+with right-insert for ordinal:""")
+ self.floatctrl = masked.TextCtrl(self, -1, name='floatctrl', mask="#{9}.#{2}", formatcodes="F,_-R", useParensForNegatives=False)
+ self.floatctrl.SetFieldParameters(0, formatcodes='r<', validRequired=True) # right-insert, require explicit cursor movement to change fields
+ self.floatctrl.SetFieldParameters(1, defaultValue='00') # don't allow blank fraction
+
+ label_numselect = wx.StaticText( self, -1, """\
+<= Programmatically set the value
+ of the float entry ctrl:""")
+ numselect = wx.ComboBox(self, -1, choices = [ '', '111', '222.22', '-3', '54321.666666666', '-1353.978',
+ '1234567', '-1234567', '123456789', '-123456789.1',
+ '1234567890.', '-1234567890.1' ])
+
+ parens_check = wx.CheckBox(self, -1, "Use () to indicate negatives in above controls")
+
+
+
+ gridCombos = wx.FlexGridSizer( cols=4, vgap=10, hgap = 10 )
+ gridCombos.Add( label_statecode, 0, wx.ALIGN_LEFT )
+ gridCombos.Add( statecode, 0, wx.ALIGN_LEFT )
+ gridCombos.Add( label_fraction, 0, wx.ALIGN_LEFT )
+ gridCombos.Add( fraction, 0, wx.ALIGN_LEFT )
+ gridCombos.Add( label_statename, 0, wx.ALIGN_LEFT )
+ gridCombos.Add( statename, 0, wx.ALIGN_LEFT )
+ gridCombos.Add( label_code, 0, wx.ALIGN_LEFT )
+ gridCombos.Add( code, 0, wx.ALIGN_LEFT )
+ gridCombos.Add( label_selector, 0, wx.ALIGN_LEFT)
+ hbox = wx.BoxSizer( wx.HORIZONTAL )
+ hbox.Add( self.list_selector, 0, wx.ALIGN_LEFT )
+ hbox.Add(wx.StaticText(self, -1, ' => '), 0, wx.ALIGN_LEFT)
+ hbox.Add( self.dynamicbox, 0, wx.ALIGN_LEFT )
+ gridCombos.Add( hbox, 0, wx.ALIGN_LEFT )
+
+ gridIpAddrs = wx.FlexGridSizer( cols=4, vgap=10, hgap = 15 )
+ gridIpAddrs.Add( label_ipaddr1, 0, wx.ALIGN_LEFT )
+ gridIpAddrs.Add( ipaddr1, 0, wx.ALIGN_LEFT )
+ gridIpAddrs.Add( label_ipaddr2, 0, wx.ALIGN_LEFT )
+ gridIpAddrs.Add( ipaddr2, 0, wx.ALIGN_LEFT )
+ gridIpAddrs.Add( label_ipaddr3, 0, wx.ALIGN_LEFT )
+ gridIpAddrs.Add( ipaddr3, 0, wx.ALIGN_LEFT )
+
+ gridNumerics = wx.FlexGridSizer( cols=4, vgap=10, hgap = 10 )
+ gridNumerics.Add( label_intctrl1, 0, wx.ALIGN_LEFT )
+ gridNumerics.Add( self.intctrl1, 0, wx.ALIGN_LEFT )
+ gridNumerics.Add( label_intctrl2, 0, wx.ALIGN_RIGHT )
+ gridNumerics.Add( self.intctrl2, 0, wx.ALIGN_LEFT )
+ gridNumerics.Add( label_floatctrl, 0, wx.ALIGN_LEFT )
+ gridNumerics.Add( self.floatctrl, 0, wx.ALIGN_LEFT )
+ gridNumerics.Add( label_numselect, 0, wx.ALIGN_RIGHT )
+ gridNumerics.Add( numselect, 0, wx.ALIGN_LEFT )
+
+ self.sizer.Add( labelMaskedCombos, 0, wx.ALIGN_LEFT|wx.ALL, 5 )
+ self.sizer.Add( gridCombos, 0, wx.ALIGN_LEFT|wx.ALL, border=5 )
+ self.sizer.Add( wx.StaticLine(self, -1), 0, wx.EXPAND|wx.TOP|wx.BOTTOM, border=8 )
+ self.sizer.Add( labelIpAddrs, 0, wx.ALIGN_LEFT|wx.ALL, 5 )
+ self.sizer.Add( gridIpAddrs, 0, wx.ALIGN_LEFT|wx.ALL, border=5 )
+ self.sizer.Add( wx.StaticLine(self, -1), 0, wx.EXPAND|wx.TOP|wx.BOTTOM, border=8 )
+ self.sizer.Add( labelNumerics, 0, wx.ALIGN_LEFT|wx.ALL, 5 )
+ self.sizer.Add( gridNumerics, 0, wx.ALIGN_LEFT|wx.ALL, border=5 )
+ self.sizer.Add( parens_check, 0, wx.ALIGN_LEFT|wx.ALL, 5 )
+
+ self.SetSizer( self.sizer )
+ self.SetAutoLayout(1)
+ self.SetupScrolling()
+
+ self.Bind(wx.EVT_COMBOBOX, self.OnComboSelection, id=fraction.GetId())
+ self.Bind(wx.EVT_COMBOBOX, self.OnComboSelection, id=code.GetId())
+ self.Bind(wx.EVT_COMBOBOX, self.OnComboSelection, id=statecode.GetId())
+ self.Bind(wx.EVT_COMBOBOX, self.OnComboSelection, id=statename.GetId())
+ self.Bind(wx.EVT_TEXT, self.OnTextChange, id=code.GetId())
+ self.Bind(wx.EVT_TEXT, self.OnTextChange, id=statecode.GetId())
+ self.Bind(wx.EVT_TEXT, self.OnTextChange, id=statename.GetId())
+ self.Bind(wx.EVT_COMBOBOX, self.OnListSelection, id=self.list_selector.GetId())
+
+ self.Bind(wx.EVT_TEXT, self.OnTextChange, id=self.intctrl1.GetId())
+ self.Bind(wx.EVT_TEXT, self.OnTextChange, id=self.intctrl2.GetId())
+ self.Bind(wx.EVT_TEXT, self.OnTextChange, id=self.floatctrl.GetId())
+ self.Bind(wx.EVT_COMBOBOX, self.OnNumberSelect, id=numselect.GetId())
+ self.Bind(wx.EVT_CHECKBOX, self.OnParensCheck, id=parens_check.GetId())
+
+ self.Bind(wx.EVT_TEXT, self.OnIpAddrChange, id=ipaddr1.GetId())
+ self.Bind(wx.EVT_TEXT, self.OnIpAddrChange, id=ipaddr2.GetId())
+ self.Bind(wx.EVT_TEXT, self.OnIpAddrChange, id=ipaddr3.GetId())
+
+
+
+
+ def OnComboSelection( self, event ):
+ ctl = self.FindWindowById( event.GetId() )
+ if not ctl.IsValid():
+ self.log.write('current value not a valid choice')
+ self.log.write('new value = %s' % ctl.GetValue())
+
+ def OnTextChange( self, event ):
+ ctl = self.FindWindowById( event.GetId() )
+ if ctl.IsValid():
+ self.log.write('new value = %s\n' % ctl.GetValue() )
+
+ def OnNumberSelect( self, event ):
+ value = event.GetString()
+ # Format choice to fit into format for #{9}.#{2}, with sign position reserved:
+ # (ordinal + fraction == 11 + decimal point + sign == 13)
+ if value:
+ floattext = "%13.2f" % float(value)
+ else:
+ floattext = value # clear the value again
+ try:
+ self.floatctrl.SetValue(floattext)
+ except:
+ type, value, tb = sys.exc_info()
+ for line in traceback.format_exception_only(type, value):
+ self.log.write(line)
+
+ def OnParensCheck( self, event ):
+ self.intctrl1.SetCtrlParameters(useParensForNegatives=event.IsChecked())
+ self.intctrl2.SetCtrlParameters(useParensForNegatives=event.IsChecked())
+ self.floatctrl.SetCtrlParameters(useParensForNegatives=event.IsChecked())
+
+ def OnIpAddrChange( self, event ):
+ ipaddr = self.FindWindowById( event.GetId() )
+ if ipaddr.IsValid():
+ self.log.write('new addr = %s\n' % ipaddr.GetAddress() )
+
+ def OnListSelection( self, event ):
+ list = self.list_selector.GetStringSelection()
+ formatcodes = 'F_'
+ if list == 'list1':
+ choices = ['abc', 'defg', 'hi']
+ mask = 'aaaa'
+ elif list == 'list2':
+ choices = ['1', '2', '34', '567']
+ formatcodes += 'r'
+ mask = '###'
+ else:
+ choices = masked.states
+ mask = 'AA'
+ formatcodes += '!'
+ self.dynamicbox.SetCtrlParameters( mask = mask,
+ choices = choices,
+ choiceRequired=True,
+ autoSelect=True,
+ formatcodes=formatcodes)
+ self.dynamicbox.SetValue(choices[0])
+
+# ---------------------------------------------------------------------
+class TestMaskedTextCtrls(wx.Notebook):
+ def __init__(self, parent, id, log):
+ wx.Notebook.__init__(self, parent, id)
+ self.log = log
+
+ win = demoPage1(self, log)
+ self.AddPage(win, "General examples")
+
+ win = demoPage2(self, log)
+ self.AddPage(win, 'Auto-formatted controls')
+
+ win = demoPage3(self, log)
+ self.AddPage(win, "Using default values")
+
+ win = demoPage4(self, log)
+ self.AddPage(win, 'Using auto-complete fields')
+
+ win = demoPage5(self, log)
+ self.AddPage(win, 'Other masked controls')
+
+
+#----------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ testWin = TestMaskedTextCtrls(nb, -1, log)
+ return testWin
+
+def RunStandalone():
+ app = wx.PySimpleApp()
+ frame = wx.Frame(None, -1, "Test MaskedEditCtrls", size=(640, 480))
+ win = TestMaskedTextCtrls(frame, -1, sys.stdout)
+ frame.Show(True)
+ app.MainLoop()
+#----------------------------------------------------------------------------
+import wx.lib.masked.maskededit as maskededit
+# strip out module header used for pydoc:
+demodoc = '\n'.join(maskededit.__doc__.split('\n')[2:])
+overview = """
+
+
+wx.MediaCtrl is a class that allows a way to convieniently display
+various types of media, such as videos, audio files, natively through
+native codecs. Several different formats of audio and video files are
+supported, but some formats may not be playable on all platforms or
+may require specific codecs to be installed.
+
+
+wx.MediaCtrl uses native backends to render media, for example on Windows
+there is a ActiveMovie/DirectShow backend, and on Macintosh there is a
+QuickTime backend.
+
+wx.MediaCtrl is not currently available on unix systems.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/Menu.py b/demo/Menu.py
new file mode 100644
index 00000000..2e97d754
--- /dev/null
+++ b/demo/Menu.py
@@ -0,0 +1,300 @@
+
+import time
+import wx
+import images
+
+#-------------------------------------------------------------------
+
+class MyFrame(wx.Frame):
+
+ def __init__(self, parent, id, log):
+ wx.Frame.__init__(self, parent, id, 'Playing with menus', size=(500, 250))
+ self.log = log
+ self.CenterOnScreen()
+
+ self.CreateStatusBar()
+ self.SetStatusText("This is the statusbar")
+
+ tc = wx.TextCtrl(self, -1, """
+A bunch of bogus menus have been created for this frame. You
+can play around with them to see how they behave and then
+check the source for this sample to see how to implement them.
+""", style=wx.TE_READONLY|wx.TE_MULTILINE)
+
+ # Prepare the menu bar
+ menuBar = wx.MenuBar()
+
+ # 1st menu from left
+ menu1 = wx.Menu()
+ menu1.Append(101, "&Mercury", "This the text in the Statusbar")
+ menu1.Append(102, "&Venus", "")
+ menu1.Append(103, "&Earth", "You may select Earth too")
+ menu1.AppendSeparator()
+ menu1.Append(104, "&Close", "Close this frame")
+ # Add menu to the menu bar
+ menuBar.Append(menu1, "&Planets")
+
+ # 2nd menu from left
+ menu2 = wx.Menu()
+ menu2.Append(201, "Hydrogen")
+ menu2.Append(202, "Helium")
+ # a submenu in the 2nd menu
+ submenu = wx.Menu()
+ submenu.Append(2031,"Lanthanium")
+ submenu.Append(2032,"Cerium")
+ submenu.Append(2033,"Praseodymium")
+ menu2.AppendMenu(203, "Lanthanides", submenu)
+ # Append 2nd menu
+ menuBar.Append(menu2, "&Elements")
+
+ menu3 = wx.Menu()
+ # Radio items
+ menu3.Append(301, "IDLE", "a Python shell using tcl/tk as GUI", wx.ITEM_RADIO)
+ menu3.Append(302, "PyCrust", "a Python shell using wxPython as GUI", wx.ITEM_RADIO)
+ menu3.Append(303, "psi", "a simple Python shell using wxPython as GUI", wx.ITEM_RADIO)
+ menu3.AppendSeparator()
+ menu3.Append(304, "project1", "", wx.ITEM_NORMAL)
+ menu3.Append(305, "project2", "", wx.ITEM_NORMAL)
+ menuBar.Append(menu3, "&Shells")
+
+ menu4 = wx.Menu()
+ # Check menu items
+ menu4.Append(401, "letters", "abcde...", wx.ITEM_CHECK)
+ menu4.Append(402, "digits", "123...", wx.ITEM_CHECK)
+ menu4.Append(403, "letters and digits", "abcd... + 123...", wx.ITEM_CHECK)
+ menuBar.Append(menu4, "Chec&k")
+
+ menu5 = wx.Menu()
+ # Show how to put an icon in the menu
+ item = wx.MenuItem(menu5, 500, "&Smile!\tCtrl+S", "This one has an icon")
+ item.SetBitmap(images.Smiles.GetBitmap())
+ menu5.AppendItem(item)
+
+ # Shortcuts
+ menu5.Append(501, "Interesting thing\tCtrl+A", "Note the shortcut!")
+ menu5.AppendSeparator()
+ menu5.Append(502, "Hello\tShift+H")
+ menu5.AppendSeparator()
+ menu5.Append(503, "remove the submenu")
+ menu6 = wx.Menu()
+ menu6.Append(601, "Submenu Item")
+ menu5.AppendMenu(504, "submenu", menu6)
+ menu5.Append(505, "remove this menu")
+ menu5.Append(506, "this is updated")
+ menu5.Append(507, "insert after this...")
+ menu5.Append(508, "...and before this")
+ menuBar.Append(menu5, "&Fun")
+
+ self.SetMenuBar(menuBar)
+
+ # Menu events
+ self.Bind(wx.EVT_MENU_HIGHLIGHT_ALL, self.OnMenuHighlight)
+
+ self.Bind(wx.EVT_MENU, self.Menu101, id=101)
+ self.Bind(wx.EVT_MENU, self.Menu102, id=102)
+ self.Bind(wx.EVT_MENU, self.Menu103, id=103)
+ self.Bind(wx.EVT_MENU, self.CloseWindow, id=104)
+
+ self.Bind(wx.EVT_MENU, self.Menu201, id=201)
+ self.Bind(wx.EVT_MENU, self.Menu202, id=202)
+ self.Bind(wx.EVT_MENU, self.Menu2031, id=2031)
+ self.Bind(wx.EVT_MENU, self.Menu2032, id=2032)
+ self.Bind(wx.EVT_MENU, self.Menu2033, id=2033)
+
+ self.Bind(wx.EVT_MENU, self.Menu301To303, id=301)
+ self.Bind(wx.EVT_MENU, self.Menu301To303, id=302)
+ self.Bind(wx.EVT_MENU, self.Menu301To303, id=303)
+ self.Bind(wx.EVT_MENU, self.Menu304, id=304)
+ self.Bind(wx.EVT_MENU, self.Menu305, id=305)
+
+ # Range of menu items
+ self.Bind(wx.EVT_MENU_RANGE, self.Menu401To403, id=401, id2=403)
+
+ self.Bind(wx.EVT_MENU, self.Menu500, id=500)
+ self.Bind(wx.EVT_MENU, self.Menu501, id=501)
+ self.Bind(wx.EVT_MENU, self.Menu502, id=502)
+ self.Bind(wx.EVT_MENU, self.TestRemove, id=503)
+ self.Bind(wx.EVT_MENU, self.TestRemove2, id=505)
+ self.Bind(wx.EVT_MENU, self.TestInsert, id=507)
+ self.Bind(wx.EVT_MENU, self.TestInsert, id=508)
+
+ wx.GetApp().Bind(wx.EVT_UPDATE_UI, self.TestUpdateUI, id=506)
+
+ # Methods
+
+ def OnMenuHighlight(self, event):
+ # Show how to get menu item info from this event handler
+ id = event.GetMenuId()
+ item = self.GetMenuBar().FindItemById(id)
+ if item:
+ text = item.GetText()
+ help = item.GetHelp()
+
+ # but in this case just call Skip so the default is done
+ event.Skip()
+
+
+ def Menu101(self, event):
+ self.log.write('Welcome to Mercury\n')
+
+ def Menu102(self, event):
+ self.log.write('Welcome to Venus\n')
+
+ def Menu103(self, event):
+ self.log.write('Welcome to the Earth\n')
+
+ def CloseWindow(self, event):
+ self.Close()
+
+ def Menu201(self, event):
+ self.log.write('Chemical element number 1\n')
+
+ def Menu202(self, event):
+ self.log.write('Chemical element number 2\n')
+
+ def Menu2031(self, event):
+ self.log.write('Element number 57\n')
+
+ def Menu2032(self, event):
+ self.log.write('Element number 58\n')
+
+ def Menu2033(self, event):
+ self.log.write('Element number 59\n')
+
+ def Menu301To303(self, event):
+ id = event.GetId()
+ self.log.write('Event id: %d\n' % id)
+
+ def Menu304(self, event):
+ self.log.write('Not yet available\n')
+
+ def Menu305(self, event):
+ self.log.write('Still vapour\n')
+
+ def Menu401To403(self, event):
+ self.log.write('From a EVT_MENU_RANGE event\n')
+
+ def Menu500(self, event):
+ self.log.write('Have a happy day!\n')
+
+ def Menu501(self, event):
+ self.log.write('Look in the code how the shortcut has been realized\n')
+
+ def Menu502(self, event):
+ self.log.write('Hello from Jean-Michel\n')
+
+
+ def TestRemove(self, evt):
+ mb = self.GetMenuBar()
+ submenuItem = mb.FindItemById(601)
+
+ if not submenuItem:
+ return
+
+ submenu = submenuItem.GetMenu()
+ menu = submenu.GetParent()
+
+ # This works
+ #menu.Remove(504)
+
+ # this also works
+ menu.RemoveItem(mb.FindItemById(504))
+
+ # This doesn't work, as expected since submenuItem is not on menu
+ #menu.RemoveItem(submenuItem)
+
+
+ def TestRemove2(self, evt):
+ mb = self.GetMenuBar()
+ mb.Remove(4)
+
+
+ def TestUpdateUI(self, evt):
+ text = time.ctime()
+ evt.SetText(text)
+
+
+ def TestInsert(self, evt):
+ theID = 508
+ # get the menu
+ mb = self.GetMenuBar()
+ menuItem = mb.FindItemById(theID)
+ menu = menuItem.GetMenu()
+
+ # figure out the position to insert at
+ pos = 0
+
+ for i in menu.GetMenuItems():
+ if i.GetId() == theID:
+ break
+
+ pos += 1
+
+ # now insert the new item
+ ID = wx.NewId()
+ item = wx.MenuItem(menu, ID, "NewItem " + str(ID))
+ menu.InsertItem(pos, item)
+
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Show the Menu sample", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ win = MyFrame(self, -1, self.log)
+ win.Show(True)
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#-------------------------------------------------------------------
+
+
+overview = """\
+A demo of using wx.MenuBar and wx.Menu in various ways.
+
+A menu is a popup (or pull down) list of items, one of which may be selected
+before the menu goes away (clicking elsewhere dismisses the menu). Menus may be
+used to construct either menu bars or popup menus.
+
+A menu item has an integer ID associated with it which can be used to identify
+the selection, or to change the menu item in some way. A menu item with a special
+identifier -1 is a separator item and doesn't have an associated command but just
+makes a separator line appear in the menu.
+
+Menu items may be either normal items, check items or radio items. Normal items
+don't have any special properties while the check items have a boolean flag associated
+to them and they show a checkmark in the menu when the flag is set. wxWindows
+automatically toggles the flag value when the item is clicked and its value may
+be retrieved using either IsChecked method of wx.Menu or wx.MenuBar itself or by
+using wxEvent.IsChecked when you get the menu notification for the item in question.
+
+The radio items are similar to the check items except that all the other items
+in the same radio group are unchecked when a radio item is checked. The radio group
+is formed by a contiguous range of radio items, i.e. it starts at the first item of
+this kind and ends with the first item of a different kind (or the end of the menu).
+Notice that because the radio groups are defined in terms of the item positions
+inserting or removing the items in the menu containing the radio items risks to not
+work correctly. Finally note that the radio items are only supported under Windows
+and GTK+ currently.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/MessageDialog.py b/demo/MessageDialog.py
new file mode 100644
index 00000000..75dd639f
--- /dev/null
+++ b/demo/MessageDialog.py
@@ -0,0 +1,53 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show a MessageDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ dlg = wx.MessageDialog(self, 'Hello from Python and wxPython!',
+ 'A Message Box',
+ wx.OK | wx.ICON_INFORMATION
+ #wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION
+ )
+ dlg.ShowModal()
+ dlg.Destroy()
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#---------------------------------------------------------------------------
+
+
+
+overview = """\
+
+
wx.MessageDialog
+
+This class represents a dialog that shows a single or multi-line
+message, with a choice of OK, Yes, No and Cancel buttons.
+Additionally, various style flags can determine whether an icon is
+displayed, and, if so, what kind. The return value of ShowModal
+indicates which button was pressed.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/MimeTypesManager.py b/demo/MimeTypesManager.py
new file mode 100644
index 00000000..b4d9f048
--- /dev/null
+++ b/demo/MimeTypesManager.py
@@ -0,0 +1,357 @@
+#----------------------------------------------------------------------
+# Name: wxMimeTypesManager
+# Purpose: Demonstrate use of wx.MimeTypesManager, wx.FileType
+#
+# Author: Jeff Grimmett (grimmtoo@softhome.net), adapted from original
+# .wdr-derived demo
+#
+# Created: 12/31/03
+# RCS-ID: $Id$
+# Copyright:
+# Licence: wxWindows license
+#----------------------------------------------------------------------
+#
+
+
+import pprint
+import wx
+import images
+
+
+# helper function to make sure we don't convert unicode objects to strings
+# or vice versa when converting lists and None values to text.
+convert = str
+if 'unicode' in wx.PlatformInfo:
+ convert = unicode
+
+#----------------------------------------------------------------------------
+
+class MimeTypesDemoPanel(wx.Panel):
+ def __init__(self, parent, log):
+
+ self.log = log
+
+ wx.Panel.__init__(self, parent, -1)
+
+ # This will be used for all of the labels that follow (bold label)
+ bfont = self.GetFont()
+ bfont.SetWeight(wx.BOLD)
+
+ # Contains everything
+ tsizer = wx.BoxSizer(wx.VERTICAL)
+
+ # Contains upper controls
+ usizer = wx.BoxSizer(wx.HORIZONTAL)
+
+ # Text control for ext / type entry plus label.
+ t = wx.StaticText(self, -1, 'Extension / MIME type: ', style = wx.ALIGN_RIGHT )
+ t.SetFont(bfont)
+ usizer.Add(t, 0, wx.ALL | wx.ALIGN_CENTER | wx.ALIGN_CENTER_VERTICAL, 2)
+
+ self.ext = wx.TextCtrl(self, -1, value="wav", style = wx.TE_PROCESS_ENTER )
+ usizer.Add(self.ext, 0, wx.ALL | wx.ALIGN_TOP, 4)
+ self.Bind(wx.EVT_TEXT_ENTER, self.OnLookup, self.ext)
+
+ # Select how to look it up
+ self.useExt = wx.RadioButton(self, -1, "By extension", style = wx.RB_GROUP)
+ self.useMime = wx.RadioButton(self, -1, "By MIME type")
+
+ usizer.Add(self.useExt, 0, wx.ALL | wx.ALIGN_CENTER | wx.ALIGN_CENTER_VERTICAL, 4)
+ usizer.Add(self.useMime, 0, wx.ALL | wx.ALIGN_CENTER | wx.ALIGN_CENTER_VERTICAL, 4)
+ self.useExt.SetValue(1)
+
+ # Trigger a lookup (hitting ENTER in the text ctrl will do the same thing)
+ self.go = wx.Button(self, -1, "Go get it!")
+ usizer.Add(self.go, 0, wx.ALL | wx.ALIGN_CENTER | wx.ALIGN_CENTER_VERTICAL, 4)
+ self.Bind(wx.EVT_BUTTON, self.OnLookup, self.go)
+
+ # StaticBox with larger label than usual
+ lbox = wx.StaticBox(self, -1, 'wx.FileType')
+
+ f = self.GetFont()
+ f.SetPointSize(f.GetPointSize() * 2)
+ f.SetWeight(wx.BOLD)
+ lbox.SetFont(f)
+
+ lsizer = wx.StaticBoxSizer(lbox, wx.HORIZONTAL)
+
+ # Contains the wx.FileType info
+ llsizer = wx.GridBagSizer(2, 2)
+
+ #------- Icon info
+
+ t = wx.StaticText(self, -1, 'GetIconInfo: ', style = wx.ALIGN_RIGHT )
+ t.SetFont(bfont)
+ llsizer.Add(t, (0, 0), (1, 1), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ self.icon = wx.StaticBitmap(self, -1, images.NoIcon.GetBitmap())
+ llsizer.Add(self.icon, (0, 1), (1, 1), wx.ALL | wx.ALIGN_CENTER, 2)
+
+ self.iconsource = wx.TextCtrl(self, -1, value="", size=(125, -1), style = wx.TE_READONLY )
+ llsizer.Add(self.iconsource, (0, 2), (1, 1), wx.ALL | wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL, 2)
+
+ self.iconoffset = wx.TextCtrl(self, -1, value="", size=(25,-1), style = wx.TE_READONLY )
+ llsizer.Add(self.iconoffset, (0, 3), (1, 1), wx.ALL | wx.ALIGN_CENTER_VERTICAL, 2)
+
+ #------- MIME Type
+
+ t = wx.StaticText(self, -1, 'GetMimeType: ', style = wx.ALIGN_RIGHT )
+ t.SetFont(bfont)
+ llsizer.Add(t, (1, 0), (1, 1), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ self.mimetype = wx.TextCtrl(self, -1, value="", style = wx.TE_READONLY )
+ llsizer.Add(self.mimetype, (1, 1), (1, 3), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ #------- MIME Types
+
+ t = wx.StaticText(self, -1, 'GetMimeTypes: ', style = wx.ALIGN_RIGHT )
+ t.SetFont(bfont)
+ llsizer.Add(t, (2, 0), (1, 1), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ self.mimetypes = wx.TextCtrl(self, -1, value="", style = wx.TE_READONLY )
+ llsizer.Add(self.mimetypes, (2, 1), (1, 3), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ #------- Extensions
+
+ t = wx.StaticText(self, -1, 'GetExtensions: ', style = wx.ALIGN_RIGHT )
+ t.SetFont(bfont)
+ llsizer.Add(t, (3, 0), (1, 1), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ self.extensions = wx.TextCtrl(self, -1, value="", style = wx.TE_READONLY )
+ llsizer.Add(self.extensions, (3, 1), (1, 3), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ #------- Description
+
+ t = wx.StaticText(self, -1, 'GetDescription: ', style = wx.ALIGN_RIGHT )
+ t.SetFont(bfont)
+ llsizer.Add(t, (4, 0), (1, 1), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ self.description = wx.TextCtrl(self, -1, value="", style = wx.TE_READONLY)
+ llsizer.Add(self.description, (4, 1), (1, 3), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ #------- Open command
+
+ t = wx.StaticText(self, -1, 'GetOpenCommand: ', style = wx.ALIGN_RIGHT )
+ t.SetFont(bfont)
+ llsizer.Add(t, (5, 0), (1, 1), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ self.opencommand = wx.TextCtrl(self, -1, value="", style = wx.TE_READONLY )
+ llsizer.Add(self.opencommand, (5, 1), (1, 3), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ #------- Print command
+
+ t = wx.StaticText(self, -1, 'GetPrintCommand: ', style = wx.ALIGN_RIGHT )
+ t.SetFont(bfont)
+ llsizer.Add(t, (6, 0), (1, 1), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ self.printcommand = wx.TextCtrl(self, -1, value="", style = wx.TE_READONLY )
+ llsizer.Add(self.printcommand, (6, 1), (1, 3), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ #------- All commands
+
+ t = wx.StaticText(self, -1, 'GetAllCommands: ', style = wx.ALIGN_RIGHT )
+ t.SetFont(bfont)
+ llsizer.Add(t, (7, 0), (1, 1), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 2)
+
+ self.allcommands = wx.TextCtrl(self, -1, value="", style = wx.TE_READONLY | wx.TE_DONTWRAP | wx.TE_MULTILINE )
+
+ # Set the default height to be smaller than normal (for
+ # multi-line) so the sizer can then expand it to whatever
+ # space is available
+ self.allcommands.SetSize((-1, 20))
+
+ llsizer.Add(self.allcommands, (7, 1), (1, 3), wx.ALL | wx.GROW | wx.ALIGN_CENTER, 2)
+
+ # Tell the sizer to expand this row as needed
+ llsizer.AddGrowableRow(7)
+ llsizer.AddGrowableCol(2)
+
+ #----------------------------------------------------------------------------
+
+ lrsizer = wx.BoxSizer(wx.VERTICAL)
+
+ #------- List box with known MIME types
+
+ t = wx.StaticText(self, -1, 'Known MIME types')
+ t.SetFont(bfont)
+ lrsizer.Add(t, 0, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 4)
+
+ self.mimelist = wx.ListBox(self, -1, choices=[], style = wx.LB_SINGLE)# | wx.LB_SORT)
+ lrsizer.Add(self.mimelist, 1, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER | wx.FIXED_MINSIZE, 4)
+ self.Bind(wx.EVT_LISTBOX, self.OnListbox, self.mimelist)
+
+ #----------------------------------------------------------------------------
+
+ lsizer.Add(llsizer, 1, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 4)
+ lsizer.Add(lrsizer, 0, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 4)
+
+ #----------------------------------------------------------------------------
+
+ tsizer.Add(usizer, 0, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 4)
+ tsizer.Add(lsizer, 1, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER, 4)
+
+ #----------------------------------------------------------------------------
+
+ self.SetSizer(tsizer)
+ tsizer.Fit(self)
+
+ # Populate the Known MIME types list with what is in the database
+ try:
+ mtypes = wx.TheMimeTypesManager.EnumAllFileTypes()
+ except wx.PyAssertionError:
+ mtypes = []
+
+ # TODO: On wxMac, EnumAllFileTypes produces tons of dupes, which
+ # causes quirky behavior because the list control doesn't expect
+ # dupes, and simply wastes space. So remove the dupes for now,
+ # then remove this hack when we fix EnumAllFileTypes on Mac.
+ mimes = []
+ for mt in mtypes:
+ if mt not in mimes:
+ #self.mimelist.Append(mt)
+ mimes.append(mt)
+ if mimes:
+ mimes.sort()
+ self.mimelist.AppendItems(mimes)
+
+ # Do a lookup of *.wav for a starting position
+ self.OnLookup()
+
+ # Grab the selection from the listbox, push that into
+ # the text box at top, select 'MIME', and then look it up.
+ def OnListbox(self, event):
+ mimetype = event.GetString()
+ self.ext.SetValue(mimetype)
+ self.useMime.SetValue(1)
+ self.OnLookup()
+
+ # Look up a given file extension or MIME type.
+ def OnLookup(self, event=None):
+ txt = self.ext.GetValue()
+
+ # For MIME lookups
+ if self.useMime.GetValue() == 1:
+ fileType = wx.TheMimeTypesManager.GetFileTypeFromMimeType(txt)
+ msg = "Mime type"
+
+ # Select the entered value in the list
+ if fileType:
+ if self.mimelist.FindString(txt) != -1:
+ self.mimelist.SetSelection(self.mimelist.FindString(txt))
+
+ # Must be an extension lookup
+ else:
+ fileType = wx.TheMimeTypesManager.GetFileTypeFromExtension(txt)
+ msg = "File extension"
+
+ # Select the entered value in the list
+ if fileType:
+ if self.mimelist.FindString(convert(fileType.GetMimeType())) != -1:
+ # Using CallAfter to ensure that GUI is ready before trying to
+ # select it (otherwise, it's selected but not visible)
+ wx.CallAfter(self.mimelist.SetSelection, self.mimelist.FindString(convert(fileType.GetMimeType())))
+
+
+ if fileType is None:
+ wx.MessageBox(msg + " not found.", "Oops!")
+ else:
+ self.DoUpdate(fileType)
+
+ # Populate the wx.FileType fields with actual values.
+ def DoUpdate(self, ft):
+
+ #------- Icon info
+ info = ft.GetIconInfo()
+
+ if info is None:
+ bmp = images.NoIcon.GetBitmap()
+ self.icon.SetBitmap(bmp)
+ self.iconsource.SetValue("")
+ self.iconoffset.SetValue("")
+ else:
+ icon, file, idx = info
+ if icon.Ok():
+ self.icon.SetIcon(icon)
+ else:
+ bmp = images.NoIcon.GetBitmap()
+ self.icon.SetBitmap(bmp)
+ self.iconsource.SetValue(file)
+ self.iconoffset.SetValue(convert(idx))
+
+ #------- MIME type
+ self.mimetype.SetValue(convert(ft.GetMimeType()))
+ #------- MIME types
+ self.mimetypes.SetValue(convert(ft.GetMimeTypes()))
+ #------- Associated extensions
+ self.extensions.SetValue(convert(ft.GetExtensions()))
+ #------- Description of file type
+ self.description.SetValue(convert(ft.GetDescription()))
+
+ #------- Prep a fake command line command
+ extList = ft.GetExtensions()
+
+ if extList:
+ ext = extList[0]
+ if len(ext) > 0 and ext[0] == ".": ext = ext[1:]
+ else:
+ ext = ""
+
+ filename = "SPAM" + "." + ext
+ mime = ft.GetMimeType() or ""
+
+ #------- OPEN command
+ cmd = ft.GetOpenCommand(filename, mime)
+ self.opencommand.SetValue(convert(cmd))
+
+ #------- PRINT command
+ cmd = ft.GetPrintCommand(filename, mime)
+ self.printcommand.SetValue(convert(cmd))
+
+ #------- All commands
+ all = ft.GetAllCommands(filename, mime)
+
+ if all is None:
+ self.allcommands.SetValue("")
+ else:
+ verbs, commands = all
+ text = pprint.pformat(map(None, verbs, commands))
+ self.allcommands.SetValue(text)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = MimeTypesDemoPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+overview = """\
+
+The wx.MimeTypesManager class allows the application to retrieve the
+information about all known MIME types from a system-specific location and the
+filename extensions to the MIME types and vice versa. After initialization the
+methods GetFileTypeFromMimeType() and GetFileTypeFromExtension()
+may be called: they will return a wx.FileType object which may be further
+queried for file description, icon and other attributes.
+
+A global instance of wx.MimeTypesManager is always available as
+wx.TheMimeTypesManager. It is recommended to use this instance instead
+of creating your own because gathering MIME information may take quite a long
+on Unix systems.
+
+This demo shows how to use wx.TheMimeTypesManager to list all known MIME types
+and retrieve that information as a wx.FileType from either an extension or
+MIME type.
+
+For further information please consult the wxWindows documentation for
+wx.MimeTypesManager and wx.FileType.
+
+"""
+
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/MiniFrame.py b/demo/MiniFrame.py
new file mode 100644
index 00000000..2bea751f
--- /dev/null
+++ b/demo/MiniFrame.py
@@ -0,0 +1,66 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+class MyMiniFrame(wx.MiniFrame):
+ def __init__(
+ self, parent, title, pos=wx.DefaultPosition, size=wx.DefaultSize,
+ style=wx.DEFAULT_FRAME_STYLE
+ ):
+
+ wx.MiniFrame.__init__(self, parent, -1, title, pos, size, style)
+ panel = wx.Panel(self, -1)
+
+ button = wx.Button(panel, -1, "Close Me")
+ button.SetPosition((15, 15))
+ self.Bind(wx.EVT_BUTTON, self.OnCloseMe, button)
+ self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+ def OnCloseMe(self, event):
+ self.Close(True)
+
+ def OnCloseWindow(self, event):
+ print "OnCloseWindow"
+ 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, "Create and Show a MiniFrame", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ win = MyMiniFrame(self, "This is a wx.MiniFrame",
+ style=wx.DEFAULT_FRAME_STYLE | wx.TINY_CAPTION_HORIZ)
+ win.SetSize((200, 200))
+ win.CenterOnParent(wx.BOTH)
+ win.Show(True)
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+A MiniFrame is a Frame with a small title bar. It is suitable for floating
+toolbars that must not take up too much screen area. In other respects, it's the
+same as a wx.Frame.
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/MouseGestures.py b/demo/MouseGestures.py
new file mode 100644
index 00000000..d4af8490
--- /dev/null
+++ b/demo/MouseGestures.py
@@ -0,0 +1,195 @@
+#*******************
+#By Daniel Pozmanter
+
+#Thanks to Robin Dunn for taking the time to show me how to do this
+#via the mailing list.
+
+#Version 0.0.0
+
+#This is a hacked version of DragAndDrop.py from the wxPython demo 2.5.2.8
+
+import wx, wx.lib.dialogs
+from wx.lib.gestures import MouseGestures
+
+#ToDo:
+
+#Add a dialog to record gestures (Have it showcase the manual mode)
+#Allow users to remove gestures
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+
+ ID_GESTURE = wx.NewId()
+ ID_MOUSE = wx.NewId()
+ ID_MODIFIER = wx.NewId()
+ ID_VISIBLE = wx.NewId()
+
+ self.log = log
+
+ #Mouse Gestures:
+
+ self.mg = MouseGestures(self, Auto=True,
+ MouseButton=wx.MOUSE_BTN_RIGHT)
+
+ self.mg.SetGesturesVisible(True)
+
+ self.mg.AddGesture('LR', self.ShowSomethingClever, 'Left then Right!')
+ self.mg.AddGesture('39', self.ShowSomethingClever, 'You made a V!')
+ self.mg.AddGesture('L', self.LogSomethingClever, 'You moved left')
+ self.mg.AddGesture('9', self.LogSomethingClever, 'You moved right and up')
+ self.mg.AddGesture('U', self.LogSomethingClever, 'You moved up')
+ self.mg.AddGesture('DR', self.OnDownThenRight)
+ self.mg.AddGesture('LDRU', self.SetToBlue)
+ self.mg.AddGesture('RDLU', self.SetToOrange)
+
+ #Widgets:
+
+ self.btnAddGesture = wx.Button(self, ID_GESTURE, 'Add New Gesture')
+ self.btnChangeMouseButton = wx.Button(self, ID_MOUSE, 'Change Mouse Button')
+ self.btnChangeModifier = wx.Button(self, ID_MODIFIER, 'Change Modifier')
+ self.btnToggleVisible = wx.ToggleButton(self, ID_VISIBLE, 'Toggle Gestures Visible')
+ self.btnToggleVisible.SetValue(True)
+
+ msg = "Mouse Gestures"
+ text = wx.StaticText(self, -1, "", style=wx.ALIGN_CENTRE)
+ text.SetFont(wx.Font(24, wx.SWISS, wx.NORMAL, wx.BOLD, False))
+ text.SetLabel(msg)
+
+ w,h = text.GetTextExtent(msg)
+ text.SetSize(wx.Size(w,h+1))
+ text.SetForegroundColour(wx.BLUE)
+
+ #Sizer:
+ outsideSizer = wx.BoxSizer(wx.VERTICAL)
+
+ btnSizer = wx.BoxSizer(wx.HORIZONTAL)
+
+ outsideSizer.Add(text, 0, wx.EXPAND|wx.ALL, 5)
+ outsideSizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND)
+ outsideSizer.Add(wx.StaticText(self, -1, ' '), 0, wx.EXPAND)
+ outsideSizer.Add(wx.StaticText(self, -1, 'Hold The Middle Mouse Button Down to Gesticulate'), 0, wx.EXPAND)
+ outsideSizer.Add(wx.StaticText(self, -1, 'Left Then Right, Left, The Diagonal Up/Right, Down Then Right, Diagonal Down/Right Then Diagonal Up/Right, and Up are Preset'), 0, wx.EXPAND)
+ outsideSizer.Add(wx.StaticText(self, -1, 'Left,Down,Right,Up Sets the line colour to Blue.'), 0, wx.EXPAND)
+ outsideSizer.Add(wx.StaticText(self, -1, 'Right,Down,Left,Up Sets the line colour to Orange.'), 0, wx.EXPAND)
+ outsideSizer.Add(wx.StaticText(self, -1, ' '), 0, wx.EXPAND)
+ btnSizer.Add(self.btnAddGesture, 0, wx.SHAPED)
+ btnSizer.Add(self.btnChangeMouseButton, 0, wx.SHAPED)
+ btnSizer.Add(self.btnChangeModifier, 0, wx.SHAPED)
+ btnSizer.Add(self.btnToggleVisible, 0, wx.SHAPED)
+ outsideSizer.Add(btnSizer, 0, wx.SHAPED)
+
+ self.SetAutoLayout(True)
+ self.SetSizer(outsideSizer)
+
+ #Events:
+ self.Bind(wx.EVT_BUTTON, self.OnAddGesture, id=ID_GESTURE)
+ self.Bind(wx.EVT_BUTTON, self.OnChangeMouseButton, id=ID_MOUSE)
+ self.Bind(wx.EVT_BUTTON, self.OnChangeModifiers, id=ID_MODIFIER)
+ self.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggleVisible, id=ID_VISIBLE)
+
+ def LogSomethingClever(self, somethingclever):
+ self.log.WriteText(somethingclever)
+
+ def OnAddGesture(self, event):
+ d = wx.TextEntryDialog(self, "Enter Gesture (LRUD1379) (EG Right Then Up Then DownLeft is RU1):", "Add New Gesture", "")
+ answer1 = d.ShowModal()
+ gesture = d.GetValue()
+ d.Destroy()
+
+ d = wx.TextEntryDialog(self, 'Print the following text on "%s":' % gesture, "Gesture Action", "")
+ answer2 = d.ShowModal()
+ text = d.GetValue()
+ d.Destroy()
+
+ if (answer1 == wx.ID_OK) and (answer2 == wx.ID_OK):
+ self.mg.AddGesture(gesture.upper(), self.LogSomethingClever, text)
+
+ def OnChangeModifiers(self, event):
+ choices = [wx.WXK_CONTROL, wx.WXK_SHIFT, wx.WXK_ALT]
+ schoices = ['Control', 'Shift', 'Alt']
+
+ d = wx.lib.dialogs.MultipleChoiceDialog(self, 'Select Modifier Keys:\n(Select None if you do not want to use modifier keys\n\n', "Change Modifier Keys", schoices)
+ answer = d.ShowModal()
+ tuply = d.GetValue()
+ d.Destroy()
+
+ if (answer == wx.ID_OK):
+ if len(tuply) > 0:
+ modifiers = []
+ modstring = ''
+ for x in tuply:
+ modifiers.append(choices[x])
+ modstring += schoices[x] + ' '
+ self.mg.SetModifiers(modifiers)
+ self.log.WriteText('Set Modifiers to: ' + modstring)
+ else:
+ self.mg.SetModifiers()
+ self.log.WriteText('UnSet All Modifiers')
+
+ def OnChangeMouseButton(self, event):
+ choices = [wx.MOUSE_BTN_LEFT, wx.MOUSE_BTN_MIDDLE, wx.MOUSE_BTN_RIGHT]
+ schoices = ['Left', 'Middle', 'Right']
+ d = wx.SingleChoiceDialog(self, "Set Mouse Button To", "Change Mouse Button", schoices,
+ wx.CHOICEDLG_STYLE|wx.OK|wx.CANCEL)
+ d.SetSize(wx.Size(250, 200))
+ answer = d.ShowModal()
+ i = d.GetSelection()
+ d.Destroy()
+ if (answer == wx.ID_OK):
+ self.mg.SetMouseButton(choices[i])
+ self.log.WriteText('Set the Mouse Button to ' + schoices[i])
+
+ def OnDownThenRight(self):
+ self.log.WriteText('You made an "L"!')
+
+ def OnToggleVisible(self, event):
+ visual = self.btnToggleVisible.GetValue()
+ self.mg.SetGesturesVisible(visual)
+ if visual:
+ self.log.WriteText('Made Gestures Visible')
+ else:
+ self.log.WriteText('Made Gestures Invisible')
+
+ def SetToBlue(self):
+ self.mg.SetGesturePen(wx.Colour(0, 144, 255), 5)
+ self.log.WriteText('Set Gesture Colour to Blue')
+
+ def SetToOrange(self):
+ self.mg.SetGesturePen(wx.Colour(255, 156, 0), 5)
+ self.log.WriteText('Set Gesture Colour to Orange')
+
+ def ShowSomethingClever(self, somethingclever):
+ d = wx.MessageDialog(self, somethingclever, 'Mouse Gesture Action', wx.OK)
+ d.ShowModal()
+ d.Destroy()
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+
+
+This demo shows how to add MouseGestures
+to your program, and showcases the MouseGestures
+class in all it's mousey glory.
+
+
+This class represents a dialog that shows a list of strings, and
+allows the user to select one or more.
+
+
+
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/MultiSash.py b/demo/MultiSash.py
new file mode 100644
index 00000000..6af173b5
--- /dev/null
+++ b/demo/MultiSash.py
@@ -0,0 +1,94 @@
+
+import wx
+import wx.lib.multisash as sash
+import wx.stc as stc
+
+#---------------------------------------------------------------------------
+
+sampleText="""\
+You can drag the little tab on the vertical sash left to create another view,
+or you can drag the tab on the horizontal sash to the top to create another
+horizontal view.
+
+The red blocks on the sashes will destroy the view (bottom,left) this block
+belongs to.
+
+A yellow rectangle also highlights the current selected view.
+
+By calling GetSaveData on the multiSash control the control will return its
+contents and the positions of each sash as a dictionary.
+Calling SetSaveData with such a dictionary will restore the control to the
+state it was in when it was saved.
+
+If the class, that is used as a view, has GetSaveData/SetSaveData implemented,
+these will also be called to save/restore their state. Any object can be
+returned by GetSaveData, as it is just another object in the dictionary.
+"""
+
+#---------------------------------------------------------------------------
+
+class TestWindow(stc.StyledTextCtrl):
+
+ # shared document reference
+ doc = None
+
+ def __init__(self, parent):
+ stc.StyledTextCtrl.__init__(self, parent, -1, style=wx.NO_BORDER)
+ self.SetMarginWidth(1,0)
+
+ if wx.Platform == '__WXMSW__':
+ fSize = 10
+ else:
+ fSize = 12
+
+ self.StyleSetFont(
+ stc.STC_STYLE_DEFAULT,
+ wx.Font(fSize, wx.MODERN, wx.NORMAL, wx.NORMAL)
+ )
+
+ if self.doc:
+ self.SetDocPointer(self.doc)
+ else:
+ self.SetText(sampleText)
+ TestWindow.doc = self.GetDocPointer()
+
+
+ def ShutDownDemo(self):
+ # Reset doc reference in case this demo is run again
+ TestWindow.doc = None
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ multi = sash.MultiSash(nb, -1, pos = (0,0), size = (640,480))
+
+ # Use this method to set the default class that will be created when
+ # a new sash is created. The class's constructor needs 1 parameter
+ # which is the parent of the window
+ multi.SetDefaultChildClass(TestWindow)
+
+ return multi
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
+
+This class is very similar to wx.SplitterWindow except that it
+allows for more than two windows and more than one sash. Many of
+the same styles, constants, and methods behave the same as in
+wx.SplitterWindow.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/MultipleChoiceDialog.py b/demo/MultipleChoiceDialog.py
new file mode 100644
index 00000000..3a36e987
--- /dev/null
+++ b/demo/MultipleChoiceDialog.py
@@ -0,0 +1,100 @@
+
+import wx
+import wx.lib.dialogs
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show a MultipleChoiceDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ lst = [ 'apple', 'pear', 'banana', 'coconut', 'orange', 'grape', 'pineapple',
+ 'blueberry', 'raspberry', 'blackberry', 'snozzleberry',
+ 'etc', 'etc..', 'etc...' ]
+
+ dlg = wx.lib.dialogs.MultipleChoiceDialog(
+ self,
+ "Pick some from\n this list\nblah blah...",
+ "m.s.d.", lst)
+
+ if (dlg.ShowModal() == wx.ID_OK):
+ self.log.write("Selection: %s -> %s\n" % (dlg.GetValue(), dlg.GetValueString()))
+
+ dlg.Destroy()
+
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+
+overview = """\
+
+
+
+This is a Python implementation of a dialog that is not yet implemented in wxWindows
+proper, so don't let the wxWindows documentation mislead you.
+
+
+
+The wx.lib.pdfviewer.pdfViewer class is derived from wx.ScrolledWindow
+and can display and print PDF files. The whole file can be scrolled from
+end to end at whatever magnification (zoom-level) is specified.
+
+
The viewer uses pyPdf to parse the pdf file so it is a requirement that
+this must be installed. The pyPdf home page is http://pybrary.net/pyPdf/
+and the library can also be downloaded from http://pypi.python.org/pypi/pyPdf/1.12
+
+
There is an optional pdfButtonPanel class, derived from wx.lib.agw.buttonpanel,
+that can be placed, for example, at the top of the scrolled viewer window,
+and which contains navigation and zoom controls.
+
+
Alternatively you can drive the viewer from controls in your own application.
+Externally callable methods are: LoadFile, Save, Print, SetZoom, and GoPage.
+(See pdfviewer.__init__.py)
+
+
The viewer renders the pdf file content using Cairo if installed,
+otherwise wx.GraphicsContext is used. Printing is achieved by writing
+directly to a wx.PrintDC and using wx.Printer.
+
+
Please note that pdfviewer is a far from complete implementation of the pdf
+specification and will probably fail to display any random file you supply.
+However it does seem to be OK with the sort of files produced by ReportLab that
+use Western languages. The biggest limitation is probably that it doesn't (yet?)
+support embedded fonts and will substitute one of the standard fonts instead.
+
+
+"""
+
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
diff --git a/demo/PageSetupDialog.py b/demo/PageSetupDialog.py
new file mode 100644
index 00000000..d81a3149
--- /dev/null
+++ b/demo/PageSetupDialog.py
@@ -0,0 +1,69 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show a PageSetupDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ data = wx.PageSetupDialogData()
+ data.SetMarginTopLeft( (15, 15) )
+ data.SetMarginBottomRight( (15, 15) )
+ #data.SetDefaultMinMargins(True)
+ data.SetPaperId(wx.PAPER_LETTER)
+
+ dlg = wx.PageSetupDialog(self, data)
+
+ if dlg.ShowModal() == wx.ID_OK:
+ data = dlg.GetPageSetupData()
+ tl = data.GetMarginTopLeft()
+ br = data.GetMarginBottomRight()
+ self.log.WriteText('Margins are: %s %s\n' % (str(tl), str(br)))
+
+ dlg.Destroy()
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+This class represents the page setup common dialog. The page setup dialog is standard
+from Windows 95 on, replacing the print setup dialog (which is retained in Windows
+and wxWindows for backward compatibility). On Windows 95 and NT 4.0 and above,
+the page setup dialog is native to the windowing system, otherwise it is emulated.
+
+The page setup dialog contains controls for paper size (A4, A5 etc.), orientation
+(landscape or portrait), and controls for setting left, top, right and bottom margin
+sizes in millimetres.
+
+When the dialog has been closed, you need to query the wx.PageSetupDialogData object
+associated with the dialog.
+
+Note that the OK and Cancel buttons do not destroy the dialog; this must be done by
+the application. As with other dialogs, do not destroy the dialog until you are done
+with the data, and, conversely, do not use the wx.PageSetupDialogData after the
+dialog is destroyed.
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/PenAndBrushStyles.py b/demo/PenAndBrushStyles.py
new file mode 100644
index 00000000..b66dc816
--- /dev/null
+++ b/demo/PenAndBrushStyles.py
@@ -0,0 +1,180 @@
+import wx
+import images
+
+
+pen_styles = ["wx.SOLID", "wx.TRANSPARENT", "wx.DOT", "wx.LONG_DASH",
+ "wx.SHORT_DASH", "wx.DOT_DASH", "wx.BDIAGONAL_HATCH",
+ "wx.CROSSDIAG_HATCH", "wx.FDIAGONAL_HATCH", "wx.CROSS_HATCH",
+ "wx.HORIZONTAL_HATCH", "wx.VERTICAL_HATCH", "wx.USER_DASH"]
+if 'wxMSW' in wx.PlatformInfo:
+ pen_styles.append("wx.STIPPLE")
+
+brush_styles = ["wx.SOLID", "wx.TRANSPARENT", "wx.STIPPLE", "wx.BDIAGONAL_HATCH",
+ "wx.CROSSDIAG_HATCH", "wx.FDIAGONAL_HATCH", "wx.CROSS_HATCH",
+ "wx.HORIZONTAL_HATCH", "wx.VERTICAL_HATCH"]
+
+
+
+
+class BasePanel(wx.Panel):
+ def __init__(self, parent):
+ wx.Panel.__init__(self, parent, style=wx.SUNKEN_BORDER|wx.WANTS_CHARS)
+
+ self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
+
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+ def OnSize(self, event):
+ event.Skip()
+ self.Refresh()
+
+
+class PenPanel(BasePanel):
+
+ def __init__(self, parent, pen_name):
+ BasePanel.__init__(self, parent)
+ self.pen_name = pen_name
+
+
+ def OnPaint(self, event):
+ width, height = self.GetClientSize()
+
+ dc = wx.AutoBufferedPaintDC(self)
+ dc.SetBackground(wx.WHITE_BRUSH)
+ dc.Clear()
+
+ font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
+ font.MakeSmaller()
+ dc.SetFont(font)
+ w, labelHeight = dc.GetTextExtent('Wy')
+
+ name = self.pen_name
+
+ if "STIPPLE" in name:
+ bmp = images.Smiles.GetBitmap()
+ penWidth = 8 #bmp.GetHeight()
+ pen = wx.Pen(wx.BLUE, penWidth, eval(name))
+ pen.SetStipple(bmp)
+ else:
+ penWidth = 3
+ if 'HATCH' in name:
+ penWidth = 8
+ pen = wx.Pen(wx.BLUE, penWidth, eval(name))
+
+ if "USER" in name:
+ # dash values represent units on, off, on. off...
+ pen.SetDashes([2, 5, 2, 2])
+ name += " ([2, 5, 2, 2])"
+
+ dc.SetTextForeground(wx.BLACK)
+ dc.DrawText(name, 1, 1)
+
+ dc.SetPen(pen)
+ y = labelHeight + (height - labelHeight)/2
+ dc.DrawLine(5, y, width-5, y)
+
+
+class BrushPanel(BasePanel):
+ def __init__(self, parent, brush_name):
+ BasePanel.__init__(self, parent)
+ self.brush_name = brush_name
+
+
+ def OnPaint(self, event):
+ width, height = self.GetClientSize()
+
+ dc = wx.AutoBufferedPaintDC(self)
+ dc.SetBackground(wx.WHITE_BRUSH)
+ dc.Clear()
+
+ font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
+ font.MakeSmaller()
+ dc.SetFont(font)
+ w, labelHeight = dc.GetTextExtent('Wy')
+
+ dc.SetPen(wx.TRANSPARENT_PEN)
+ name = self.brush_name
+
+ if "STIPPLE" in name:
+ bmp = images.Smiles.GetBitmap()
+ bmp.SetMask(None)
+ brush = wx.BrushFromBitmap(bmp)
+ else:
+ brush = wx.Brush(wx.BLUE, eval(name))
+
+ dc.SetTextForeground(wx.BLACK)
+ dc.DrawText(name, 1, 1)
+
+ dc.SetBrush(brush)
+ dc.DrawRectangle(5, labelHeight+2, width-10, height-labelHeight-5-2)
+
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, *args, **kw):
+ wx.Panel.__init__(self, *args, **kw)
+
+ font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
+ font.SetWeight(wx.BOLD)
+
+ mainSizer = wx.BoxSizer(wx.VERTICAL)
+ label1 = wx.StaticText(self, -1, "Pen Styles:")
+ label1.SetFont(font)
+
+ mainSizer.Add(label1, 0, wx.EXPAND|wx.ALL, 10)
+
+ gs1 = wx.GridSizer(4, 4, 3, 3) # rows, cols, vgap, hgap
+
+ for pen_name in pen_styles:
+ small = PenPanel(self, pen_name)
+ gs1.Add(small, 0, wx.EXPAND)
+
+ mainSizer.Add(gs1, 1, wx.EXPAND|wx.LEFT|wx.RIGHT|wx.BOTTOM, 10)
+
+ label2 = wx.StaticText(self, -1, "Brush Styles:")
+ label2.SetFont(font)
+
+ mainSizer.Add(label2, 0, wx.EXPAND|wx.ALL, 10)
+
+ gs2 = wx.GridSizer(3, 3, 3, 3) # rows, cols, vgap, hgap
+
+ for brush_name in brush_styles:
+ small = BrushPanel(self, brush_name)
+ gs2.Add(small, 0, wx.EXPAND)
+
+ mainSizer.Add(gs2, 1, wx.EXPAND|wx.LEFT|wx.RIGHT|wx.BOTTOM, 10)
+
+ self.SetSizer(mainSizer)
+
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
+The Picker controls are either native or generic controls usually
+comprised of a button and with an optional text control next to it.
+The pickers enable the user to choose something using one of the
+common dialogs and then displays the result in some way.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/PlateButton.py b/demo/PlateButton.py
new file mode 100644
index 00000000..33c10de0
--- /dev/null
+++ b/demo/PlateButton.py
@@ -0,0 +1,428 @@
+###############################################################################
+# Name: PlateButtonDemo.py #
+# Purpose: PlateButton Test and Demo File #
+# Author: Cody Precord #
+# Copyright: (c) 2007 Cody Precord #
+# Licence: wxWindows Licence #
+###############################################################################
+
+#-----------------------------------------------------------------------------#
+# Imports
+import os
+import webbrowser
+import wx
+import wx.lib.scrolledpanel as scrolled
+try:
+ import wx.lib.platebtn as platebtn
+except ImportError:
+ import platebtn
+
+#-----------------------------------------------------------------------------#
+
+class TestPanel(scrolled.ScrolledPanel):
+ def __init__(self, parent, log):
+ self.log = log
+ scrolled.ScrolledPanel.__init__(self, parent, size=(400, 400))
+
+ # Layout
+ self.__DoLayout()
+ self.SetupScrolling()
+
+ # Event Handlers
+ self.Bind(wx.EVT_BUTTON, self.OnButton)
+ self.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggleButton)
+ self.Bind(wx.EVT_MENU, self.OnMenu)
+
+ def __DoLayout(self):
+ """Layout the panel"""
+ # Make three different panels of buttons with different backgrounds
+ # to test transparency and appearance of buttons under different use
+ # cases
+ p1 = wx.Panel(self)
+ p2 = GradientPanel(self)
+ p3 = wx.Panel(self)
+ p3.SetBackgroundColour(wx.BLUE)
+
+ self.__LayoutPanel(p1, "Default Background:")
+ self.__LayoutPanel(p2, "Gradient Background:", exstyle=True)
+ self.__LayoutPanel(p3, "Solid Background:")
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.AddMany([(p1, 0, wx.EXPAND), (p2, 0, wx.EXPAND),
+ (p3, 0, wx.EXPAND)])
+ hsizer = wx.BoxSizer(wx.HORIZONTAL)
+ hsizer.Add(sizer, 1, wx.EXPAND)
+ self.SetSizer(hsizer)
+ self.SetAutoLayout(True)
+
+ def __LayoutPanel(self, panel, label, exstyle=False):
+ """Puts a set of controls in the panel
+ @param panel: panel to layout
+ @param label: panels title
+ @param exstyle: Set the PB_STYLE_NOBG or not
+
+ """
+ # Bitmaps (32x32) and (16x16)
+ devil = Devil.GetBitmap() # 32x32
+ monkey = Monkey.GetBitmap() # 32x32
+ address = Address.GetBitmap() # 16x16
+ folder = Home.GetBitmap()
+ bookmark = Book.GetBitmap() # 16x16
+
+ vsizer = wx.BoxSizer(wx.VERTICAL)
+ hsizer1 = wx.BoxSizer(wx.HORIZONTAL)
+ hsizer1.Add((15, 15))
+ hsizer2 = wx.BoxSizer(wx.HORIZONTAL)
+ hsizer2.Add((15, 15))
+ hsizer3 = wx.BoxSizer(wx.HORIZONTAL)
+ hsizer3.Add((15, 15))
+ hsizer4 = wx.BoxSizer(wx.HORIZONTAL)
+ hsizer4.Add((15, 15))
+
+ # Button Styles
+ default = platebtn.PB_STYLE_DEFAULT
+ square = platebtn.PB_STYLE_SQUARE
+ sqgrad = platebtn.PB_STYLE_SQUARE | platebtn.PB_STYLE_GRADIENT
+ gradient = platebtn.PB_STYLE_GRADIENT
+ droparrow = platebtn.PB_STYLE_DROPARROW
+ toggle = default | platebtn.PB_STYLE_TOGGLE
+
+ # Create a number of different PlateButtons
+ # Each button is created in the below loop by using the data set in this
+ # lists tuple
+ # (bmp, label, Style, Variant, Menu, Color, Enable)
+ btype = [(None, "Normal PlateButton", default, None, None, None, True),
+ (devil, "Normal w/Bitmap", default, None, None, None, True),
+ (devil, "Disabled", default, None, None, None, False),
+ (None, "Normal w/Menu", default, None, True, None, True),
+ (folder, "Home Folder", default, None, True, None, True),
+ # Row 2
+ (None, "Square PlateButton", square, None, None, None, True),
+ (address, "Square/Bitmap", square, None, None, None, True),
+ (monkey, "Square/Gradient", sqgrad, None, None, None, True),
+ (address, "Square/Small", square, wx.WINDOW_VARIANT_SMALL, True, None, True),
+ (address, "Small Bitmap", default, wx.WINDOW_VARIANT_SMALL, None, wx.Colour(33, 33, 33), True),
+ # Row 3
+ (devil, "Custom Color", default, None, None, wx.RED, True),
+ (monkey, "Gradient Highlight", gradient, None, None, None, True),
+ (monkey, "Custom Gradient", gradient, None, None, wx.Colour(245, 55, 245), True),
+ (None, "Drop Arrow", droparrow, None, None, None, True),
+ (devil, "", default, None, None, None, True),
+ (bookmark, "", default, None, True, None, True),
+ (monkey, "", square, None, None, None, True),
+ # Row 4
+ (None, "Toggle PlateButton", toggle, None, None, None, True),
+ (devil, "Toggle w/Bitmap", toggle, None, None, None, True),
+ (None, "Toggle w/Menu", toggle, None, True, None, True),
+ ]
+
+ # Make and layout three rows of buttons in the panel
+ for btn in btype:
+ if exstyle:
+ # With this style flag set the button can appear transparent on
+ # on top of a background that is not solid in color, such as the
+ # gradient panel in this demo.
+ #
+ # Note: This flag only has affect on wxMSW and should only be
+ # set when the background is not a solid color. On wxMac
+ # it is a no-op as this type of transparency is achieved
+ # without any help needed. On wxGtk it doesn't hurt to
+ # set but also unfortunatly doesn't help at all.
+ bstyle = btn[2] | platebtn.PB_STYLE_NOBG
+ else:
+ bstyle = btn[2]
+
+ if btype.index(btn) < 5:
+ tsizer = hsizer1
+ elif btype.index(btn) < 10:
+ tsizer = hsizer2
+ elif btype.index(btn) < 17:
+ tsizer = hsizer3
+ else:
+ tsizer = hsizer4
+
+ tbtn = platebtn.PlateButton(panel, wx.ID_ANY, btn[1], btn[0], style=bstyle)
+
+ # Set a custom window size variant?
+ if btn[3] is not None:
+ tbtn.SetWindowVariant(btn[3])
+
+ # Make a menu for the button?
+ if btn[4] is not None:
+ menu = wx.Menu()
+ if btn[0] is not None and btn[0] == folder:
+ for fname in os.listdir(wx.GetHomeDir()):
+ if not fname.startswith('.'):
+ menu.Append(wx.NewId(), fname)
+ elif btn[0] is not None and btn[0] == bookmark:
+ for url in ['http://wxpython.org', 'http://slashdot.org',
+ 'http://editra.org', 'http://xkcd.com']:
+ menu.Append(wx.NewId(), url, "Open %s in your browser" % url)
+ else:
+ menu.Append(wx.NewId(), "Menu Item 1")
+ menu.Append(wx.NewId(), "Menu Item 2")
+ menu.Append(wx.NewId(), "Menu Item 3")
+ tbtn.SetMenu(menu)
+
+ # Set a custom colour?
+ if btn[5] is not None:
+ tbtn.SetPressColor(btn[5])
+
+ if btn[2] == droparrow:
+
+ tbtn.Bind(platebtn.EVT_PLATEBTN_DROPARROW_PRESSED, self.OnDropArrowPressed)
+
+ # Enable/Disable button state
+ tbtn.Enable(btn[6])
+
+ tsizer.AddMany([(tbtn, 0, wx.ALIGN_CENTER), ((10, 10))])
+
+ txt_sz = wx.BoxSizer(wx.HORIZONTAL)
+ txt_sz.AddMany([((5, 5)), (wx.StaticText(panel, label=label), 0, wx.ALIGN_LEFT)])
+ vsizer.AddMany([((10, 10)),
+ (txt_sz, 0, wx.ALIGN_LEFT),
+ ((10, 10)), (hsizer1, 0, wx.EXPAND), ((10, 10)),
+ (hsizer2, 0, wx.EXPAND), ((10, 10)),
+ (hsizer3, 0, wx.EXPAND), ((10, 10)),
+ (hsizer4, 0, wx.EXPAND), ((10, 10))])
+ panel.SetSizer(vsizer)
+
+ def OnDropArrowPressed(self, evt):
+ self.log.write("DROPARROW PRESSED")
+
+ def OnButton(self, evt):
+ self.log.write("BUTTON CLICKED: Id: %d, Label: %s" % \
+ (evt.GetId(), evt.GetEventObject().LabelText))
+
+ def OnToggleButton(self, evt):
+ self.log.write("TOGGLE BUTTON CLICKED: Id: %d, Label: %s, Pressed: %s" % \
+ (evt.GetId(), evt.GetEventObject().LabelText,
+ evt.GetEventObject().IsPressed()))
+
+ def OnChildFocus(self, evt):
+ """Override ScrolledPanel.OnChildFocus to prevent erratic
+ scrolling on wxMac.
+
+ """
+ if wx.Platform != '__WXMAC__':
+ evt.Skip()
+
+ child = evt.GetWindow()
+ self.ScrollChildIntoView(child)
+
+ def OnMenu(self, evt):
+ """Events from button menus"""
+ self.log.write("MENU SELECTED: %d" % evt.GetId())
+ e_obj = evt.GetEventObject()
+ mitem = e_obj.FindItemById(evt.GetId())
+ if mitem != wx.NOT_FOUND:
+ label = mitem.GetItemLabel()
+ if label.startswith('http://'):
+ webbrowser.open(label, True)
+
+#-----------------------------------------------------------------------------#
+
+class GradientPanel(wx.Panel):
+ def __init__(self, parent):
+ wx.Panel.__init__(self, parent)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+ def OnPaint(self, evt):
+ dc = wx.PaintDC(self)
+ gc = wx.GraphicsContext.Create(dc)
+ col1 = wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DSHADOW)
+ col2 = platebtn.AdjustColour(col1, -90)
+ col1 = platebtn.AdjustColour(col1, 90)
+ rect = self.GetClientRect()
+ grad = gc.CreateLinearGradientBrush(0, 1, 0, rect.height - 1, col2, col1)
+
+ pen_col = tuple([min(190, x) for x in platebtn.AdjustColour(col1, -60)])
+ gc.SetPen(gc.CreatePen(wx.Pen(pen_col, 1)))
+ gc.SetBrush(grad)
+ gc.DrawRectangle(0, 1, rect.width - 0.5, rect.height - 0.5)
+
+ evt.Skip()
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+class TestLog:
+ def __init__(self):
+ pass
+
+ def write(self, msg):
+ print msg
+
+#----------------------------------------------------------------------
+
+overview = platebtn.__doc__
+
+#----------------------------------------------------------------------
+# Icon Data
+# All icons from the Tango Icon Set
+from wx.lib.embeddedimage import PyEmbeddedImage
+
+Book = PyEmbeddedImage(
+ "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABHNCSVQICAgIfAhkiAAAAkdJ"
+ "REFUOI2VkslrU1EUh787vJeXNNpMGA01DlECrd0UWrD+A06oIIoLwY24FwQRNIu6EBeKy4Jb"
+ "XRS6dEK0WrC2XSgFFZq0RUoHmg4WYslrxuuiGpJWKv4295zLOd/vnssR/FbX8ZvXQTzAGPPn"
+ "ziAMgJAie//ifKL7ZC6pjOwylJc01WGiHUsaoLe3tz+bzZ6fmJwisxQTd25d3iAIwMDde09i"
+ "L76W3GhbjL37jyLtfaysvP0QXf52VQF0dnb2pVIpdvj9DAx/JxiN8Dk9x+TMMm6hxMT4NDeu"
+ "HaG97RB281ksZz9Se+OyNDqvqVMul6NcyrOyukp2cRUAR1cpl/LkfpYpV8voiotQkmJ+Bo+U"
+ "OVkPqFQqVErrFAsuBXeNortGad2lXHT5Ml5gZk5QyQ9g8q+ZnR6magqfGgAAQtlobWPZHpTl"
+ "QWkLIS32xOKEdp/ArbYjrBijYxaW+2OsASCEQFteLMeH7fjxeJuwHC/a8jI3O0c6M4URMbA7"
+ "mF9sQhwYXNebXyClQkqF0hYASllIpWlpaSGZTIIQCKExRgDQALBtuxbvCvmpVmsrgeNVm702"
+ "DOsTn88HgDHw8c0IIwOjtb1q8jUjhNge4PF4AHj/aoh4bCcH4wHevRzCGMPCwgLpdHoLoGEE"
+ "x3EAuHLhGJfOdSOlpP/ZCI+fDtLa2koikdgeEIlEeHj7NEopMpkMQgjaDwd5lDpDMBgE2DJG"
+ "AyAQCBAIBBBC1Arrz7/9QQMgFAptKfiXNEA4HH7e09Nz6n8aw+FwH8AvVXjA30OIWrcAAAAA"
+ "SUVORK5CYII=")
+
+Address = PyEmbeddedImage(
+ "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABHNCSVQICAgIfAhkiAAAAmtJ"
+ "REFUOI19kstLlFEYxn/nfN+ZizPOeBnHS1OklmQSFVjRH9CiTUKbIKRl4V8QuFBwIUTtgqBF"
+ "u3BfuW0XtAhsYWk6BqOZl7mgc/+c73JafKmZ1gNnc+D9ned5ziu0fqievep/Hg83HpXqAVa2"
+ "2inXgmgE/9HUzPToJICYfvn0xe0r22MXL9wEM0WusEQ6N8DmbjMaiZQ+aB9XtRqUNmd5cH2c"
+ "eMfIY1NJPTbQP4QZuQUiRDJhkC/OsZrrI7haQdX38JRBpStBPRGnsy1CCYh3jFDMvXliWrbC"
+ "A/AskBLX3sauS2KrWQo9Z2hEmzCtPeKZTVxlQFuEpmDjIIu5stlGrtxGB+9xXYHjZimmY+wk"
+ "ezAaNsn5FbQQ7JxLEfuRhd5OwgH7EGC7BmU9jFXcIp9dIpG8RimTYW8wSmIhQymVJLpVwAkF"
+ "UDULgI/fLGy1zNe5JiRAQIWxvG62iuepub14tkQLgXRctGGAEATLNZxw4Nh3SAAh/I61MPyr"
+ "SAhVtbBam/3XA4rY2jal050AeEQPIxzl+SCvt4tY+ifFs9044SCIozsRyijuzsDlxZoP0GjQ"
+ "kGyP+046WijtOcTWs6hqHTegyA/1nbhRvgMNSpm0tESxbIfO1gixcBAGTh34ih/x+BegUq3z"
+ "bvYDptR42j+OoxFSEFAGQggE4LoemfW811Ury++LiwD3TIAv8yvcGIwcrO1JklJSEy0sFxpy"
+ "rfcSw7/NmAC7lSp9yWZSqZ5jg+KPAhfSGyd2MPUpnZ9w6jVvI9+QoZDCsZ0jgfcRjutx52q7"
+ "fvu5cEAVgLw//noSmPin/xM0Mz0qAH4B9vTxRRZgeg8AAAAASUVORK5CYII=")
+
+Home = PyEmbeddedImage(
+ "iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAABqNJ"
+ "REFUWIXVl2uMlOUVx3/P817mtjN77Sxy2WFZroLQBbEtyYaAbSG1Ng1JJVZrQ6Jp1ARMI0m/"
+ "mX7wi58MprGXBARTUW6JtiZuJSUFSXBrEQxWQcCVhWVhWYady84777zP8/TDXNhdhmvih57k"
+ "Td6Z97zn/M///M+ZZ+D/2d6R8sW/CjG6E2bcawxxLy/tAhfL2pFsa1s7taEhcay/f7Ck1A+f"
+ "gC+/dQA7IBm2rA/ndnXN7Zw6NVwcGSGTy/HpwMAlPwh+9gT03U08eTfOb8LSqOt++uDSpYs6"
+ "Z84MIyUGiLgu3R0d7SHHef8t+NG3AmCXlL9KxGL/6OnpmdqWTEqkBMsCITBAyHHoTqXaQq77"
+ "9jtSPn6ncW/bgpdA3m9Zr7Umk79ctnx5kyUlKAVao69dQ6fTFJRCAQYItObEwMBVz/d/v17r"
+ "LbeLb92yamhMWtb+rnnz1i5+6KGEtCruQqBHRjDpNCWlCFkWyhiUMSAEbYlEJON53/+51ond"
+ "xvzznhjYDnOjtt3bvWLF9PZUykZrUAoTBOhz5whGRzmeHuHi5SssS6WYEo0ypjWeMRhAA2eH"
+ "hjKZfH7PL5R6WpQJusHqauAty3okEYt91PPoozPb58yxsSyQEqMU+uxZxq5e5eORyzS+sIkH"
+ "jx7lm8YYZ3JZolISrmgCY+hsb0+0JBKP7bbtdw+AfUcM7LLtlxKtrZu+t3ZtsxOJlKvWGpPJ"
+ "oE6e5Go2y+eFHKk/vE7kgcUopRBaM/S7F7GOHmdhPEERyCiFoVz2UDpdGE6n/5NWas1vYKwu"
+ "gG0Qjkm5d8a8eT2LVq+Oi/Fiu3QJdeoU53I5LkTCdL2xHdnaShAESCmRUqK1ZuSPr5PbuZPu"
+ "xiaUEFxTCg0YY7iWzRYvXLlyMq/Uyg1wrZrXAngTpkcs6/CSnp5lc1aujFbHCyHQ/f0Ep07x"
+ "eS5H7v4FzN6+AxmPo5QiEonQ0tJCLBZDKUV46TKcjhl80dvLFNshatt4xqABNxSyo6FQqzc2"
+ "9thPjNn9LuRqDLwt5WDPunVTmrq6yoxojQkC1Gef4Q0McCybpfmpp2h/7jmUUmiticVihMPh"
+ "Ce0rFAoUCgW8Eyc48+yzPBAK0RAKMawUpYo4i56nv7l48YJSatXjcEYC2FIWm2bPFlgWWBZG"
+ "KYK+PjJff01fJsP0V15hyvPPY4zBsiwaGxtxXRetde1SSuG6Lg0NDcSWLGH+3r2ckJIrhQJJ"
+ "28atiNMJhWTntGkzLMv618QpqGw2k88THDzI0PnzHNOahXv20LhqFcYYbNsmGo1WSJqYvHov"
+ "hCASiRCeNo1F773HuWSS/nyepG0TqYCQjoMtpblhDM2lS5QOHODU5cucu+8+unt7Cc+aBYDj"
+ "ODiOMyHx5OTjL8dxcBobWbBrF/nly/lvNst3LIu4lEhxffhqANTp0xQPHeLI4CDB6tUs3rcP"
+ "GY9jjEFKiRDijpJPZkM6DrNefZXwk0/y8cgIzVLSLK/XbQMEWoeHjhzhZDqdHVu/Prb05Zel"
+ "1hpMeXkZYzBm4iKrfhZCYNs2QogbfKp+SimmbdzIwdOnS8H+/cH8RCJSVKqhBqCo9epPBgYO"
+ "d27Y8Nt9zc3bHrYsgiBg//4PyY/la4kmWzQSY82aNWzZ8hq+X7zhOYDjhnhh00Z832d49uyg"
+ "8/DhH38yOPj3ktYragB+DV9gTAtbt7J58+ZtNVWHXL46c3JCQCFEDcyC+QsxxuD7RVTqEVzH"
+ "wrElSmn8kqZYCuDCBxhjKJVKSCkL6y5e/AhoukED463aw44ZHdi2XROg67q1e8dxSHWk0FpX"
+ "gIEUYAlRFtk4wqptMHV6VPcHwhiD1ppUKoVt13UBoK2trQZgzAso+oqxYsBovkgmX6RQVPwg"
+ "Wi6osrb9uwJg2XatElG5kYxhi358Mx8ENQD//nKoPsrodUaB0uTHt2xBNbGgQqkAR3zFT1f8"
+ "DUtkgfrKr2dKKYBg8vc3ZUApBcZMVL8An++y+9CiWmvKS8dlVdPxuoltp7yyS6USQgjvrgDY"
+ "jkO5+Ikj6DhOGY8Az/N45pmn645pNVaxWKzuktsyEKpWpbVGClk38HhAvu/j+9e1Va8lUkpK"
+ "pRJBEGigjfJ5IJgMwAVagcDzPDsej0+Y+ZtZPB6/5fMqoOHhYXzfV8CUSt7LgB4PwAbc0dHR"
+ "N7Zu3brBGHPLEzPAn//0l9u5jDevr69vJxCmXKyAiWdCQZmBViBRcbr5Erg78ymfvgrAKHAe"
+ "8CYDqJoDRCpI7+nPax0zlHeAV7lqQvkfoK5c5SC5ZcEAAAAASUVORK5CYII=")
+
+Monkey = PyEmbeddedImage(
+ "iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAACDhJ"
+ "REFUWIXtlmuMXVUVgL+99zn33HvnPmbmDtOZYabTKXSGmdAWi6JAi6U1GgMN2qAIgYgaMAKJ"
+ "4g8jRhN+GGNMTESDxogQEhtjIiAYqT+0pfZhkdBSSqedFqbTofN+3Lnv89zbH/dOGNtiUjXR"
+ "H65kZWc/17fWXmftA/+X/7KIy1m8eSg1JNB3xIS+UxvRE2nRDKCkWZLCvOsb+VuDfPHAcHn4"
+ "Pwqwub9pg23rJ1PJ1KYN67qsdb1dsZZMikQiAUCtWiVfLHNmfNI/dnoyqNYqR/1APnzgdOXN"
+ "fxtg6zWJh51E4gcfv3F9/Jq+LlmdG6OanyCoLmGCGgBWLImVzJJs7SbZtoaTo+/q3QePu4Hn"
+ "feOVU7Un/2WAW4fi32zONn/77ttubgoWzpEfPw7aRwmQDRWAAbSpK5ZDa+91iHQHu36/v1Ks"
+ "VL67d9j9/mUD3DLQtL4pLvffv3N7dv7sEZbKFdxIYjAkbEkyLJBRPlJAKYpRUllqgUYiiCtN"
+ "W7aZ5tVD/PK5PYWax5a/jFSOXxbAtsHE8O23XDvoBEvMlYps2fwxBoc2oKwY09MT7NmzG7M0"
+ "Xj+geTXbtt1GZ+eVhFHIqVNvsX/vbjraWikHNn84dPrknpO1ofcFuGkgl46p6o+M4W6MUFLy"
+ "11Tc/sB9OzZnRk68xu07PktXRwdRdRETBQhlo+0MT+96FoAv3ns/0i9iQg+hLKzUFUzNzfPS"
+ "C7sYWv9hnn5+T7EamKNacyPCRELwaz9Kfu3QyEJJAfR3ij1dzeoTH+qLJVpTUpU9VvddmYvH"
+ "TIVMppkbNl1PsDSFCV1M6GN8Fxm5XDO0if6rB0iEBbRbwEQhJvTRboFsayeTM9OU8guEBqfm"
+ "easHu2xroMOyQ82gFwTbzs4GT6tb+pOfbM+Ihwa7nNTpWcnQVWuZz1dF96pWjF9k44braYkL"
+ "tFfChAEm8jGRj/arWGEVJ6rU56IAowOMDiGKAIN0UoyOjqBiTcwXamLT+iFOnS/Ql1NW1Quz"
+ "uSb7mIzHeWxjj5U9u6j41hd2sPPmIXo7WjCA0YZkwkG7JUzgYoxmMu/xzJ/PMlUCYcUQlsNU"
+ "GZ7Ze47JQoSQFsZotFsimUyitQZgoDvHzi3r+c5D93K+aLGxx8rG4zwmo4iBQAuG1vaQiQlM"
+ "FNDelqNcqSGkwPUCUDYylkI6KR78yX4e3/U3HnjiFaSTRjppHnjiFR7/1as8+ON9SKe+TtpJ"
+ "/AikUpSqLu25FrRfI2HBxsF1hFoQRQxIQGhtsASY0EfGkvT39TBb9InFU0zNzmI15ZBOEzLW"
+ "xNhMAYCxmUIdIJ5mbHp5rFgHjTVhpduZmJrESaSYWqyyrrcHE3iY0MdSCq0NgJCWEmdiSnBi"
+ "9Dyu6yKUw5qeKzk3tUgm28bJkWHCeBvCSSOdFI9+bivppMOj92xHOmmUk+LRe7bXx+6+te59"
+ "PINOdXLixBuk0i1MzJfp6+4AKQmCgDdPnsFWAkuJM2LrYOKOzmb17Np2JztTVmy/YSMvHThB"
+ "SyZGT4sg197NHZ+6F1OeRUgLoWyEskEqhJAs10JjNOiokYwRKtvN8889Q356lNHpGnPFgJ2b"
+ "+zk8PE7Ccjk/7xamlqLPq7H5cGRV1v6MJGrtbtbW0bcnWSi4bLo6RyqVZvPWT/PG0ddZKFao"
+ "+JpIKFAOltOEFUsirBghinItIF+sMDEzz9vnJjg5cpLrb7iVmakxMnHD6fEFphcXySU95pYC"
+ "b3LJjOwdrn5dAHxkKNOaJPxZoNmpJOq6vmaRa4I77/oyuUySwA+YWaoys1hkdnGJ+XyRhaUi"
+ "rusSaY1tW7Rks7TnWljV1kpXWwuduQxO3CFf9fnNsz9kruBzbLxiIk1kS56vYn3l8HBx0QI4"
+ "PFxcBO766EexzGxitiWdaPH9Ei1tHRg3j+3EWd3dQm/fVUgrjrDjCMupX4eQGKProQ89TOCi"
+ "Q7fRerRc0Y0XBLRmmjCmvCRX1dr37CNcLsVyZV3et49QQ0JKCcYglIWQCiFV/c6lArWcBw7S"
+ "Tta/BDuJUHUgGnuQCqksEAKMQSqJhsS+FcYvAgBQMFeuuVjKIj8/jbATYExDaagBdN1zHdYT"
+ "EH3RGmknWZybwLJsKjUfBXMX2rsIAMyL0wuVINRwaP9urGRr3Qsd1o1F/nuh9spor4T2yvVK"
+ "GXr1eR0gAJVu49De36E1TOUrAZgXL+HwP0rPKuutUiX8Uk97OlFYmsVSkp7+TRD69TrPcjSi"
+ "ej/034MKPUzkIaSFne3gtYMvc+z1/WgR4/hYsRhJ7hufC4v/FGB8Liz25iy9WPZu7GhNxd4d"
+ "O8X83AS9/ZtwUs1gDEZHjUep8TjpsJEzNirZjGckf3zhKY4c/hNGORx5J192Pf29/afc3Rfa"
+ "u9QPiQ3ENw8kfpFO2DvW96aTNh5KWVw1cC3XXreZ9q41NKVzWI4DCMIwoFpcZG56nLeOHuDM"
+ "8BGiKCTA4fi5UrVY9V8+eNp9BHABr9FeEiDe0AQQ/+Ba55F0wnqoO5ewenJxy0QutpIIKYl0"
+ "VE+2xilKKrTRhKFGqjjn8144PlcNC5XgqSNj/s8bRl2g1mirgLkQILFC40CiM6uuXtNuf9VW"
+ "8qbWtBO1pa1EOm7hOArV2B0Z8PyIshsxVwzcxZKn/DB6dXQ2+OlsUY+uMLoMUAUql4qAABwg"
+ "2QBwlttMk7qip9nakkmKLUqxTiJaNSJW32QCg1kMQ/NOocrB8/nwUKkWzTfCvazLxsuN/vvm"
+ "wLIoILbiWmKAtUKXX6LlM+rFAUIgAoIVXruA35i/yOPLEXGB4WVdzga9AsRc6oD/Ofk7fswD"
+ "nMQUbKYAAAAASUVORK5CYII=")
+
+Devil = PyEmbeddedImage(
+ "iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAABrpJ"
+ "REFUWIXtlluMlVcVx3/7u57LzLkMc5gbw2UovFRupQ1INdRkkkrIPDRpLSFREqk8oFKrPhmR"
+ "oEkfNLFJ39SQkrZGJGRMarCpVWmlLa2OCjOtpVBmgJnOfc79zHf/tg/nO5PTEQEbE1/6T/45"
+ "315n7b3+e+21sjd8iv8zRPPgtKKc9aV8UArxfT0Mf/4lcI+BocMXNME+BT4XQi6UtCqCigJz"
+ "oeQNH055cO44uKfB8BTlGwKOqvDW42G49+4FmGrx4Z9uSt98J+988JupwmzFe6mi8NjKroS6"
+ "bmOqNbcqKWKtOnpMxbMCrIrH3ERNXr9SrsxOLwatIYMrs8bAvY91Z7q3ZIyz37xU2h/KzO0E"
+ "qM2DR6QwWztzu9ZoG81W22ipFQr39XQl4jv2dJlpLKHnC4iZBeTEHCyUMGoW6bQm+j7TbspJ"
+ "J55NZ+974KEHkh2dveqNkXln+r35Hw9K+fpdZ+AFSKmKMvX5desSLYZB1XG4MH6d7dtBjYNq"
+ "gtDqs2QAoQuhDUFNMjQs2L2uj5iuU3Vdzo+OLi5K2fkEVG4nQGse3IDWFVJyZWGOvkwbw9OT"
+ "rO4FrQW0JKgxgdCbBDgQGBIUQU8nDH00zqbObq7lFyiDnIcUdxCgND4kCB3ObtycM4uexd8n"
+ "b7Kyw6NrLWgtAq1VoKVBzwqMrEDPgJ6K/ktCzxrIZFyGJm5Q8izWb8zGdDgrl2V5OZZqwIB9"
+ "3e3xL9+7tT3eVsjT2SVJrRR4cfj6JcmTb4f88SPYuUHQ2S5wEHz1lZAnL4Scm4dtGUFvAlYY"
+ "kJYh2b52pVhyEr+zg7E/wbu3zcAx0DR4ZuuWlSnn0hRIiVDr5/3sqKQ3BdcOaRy4X/Dt34fo"
+ "GcFP/hqyOiu4ckBl/3rB0ashiibq85A478+zeWNbSoNnji076mYIgB9Bf097/Mxnt3aknXeu"
+ "o2cEepZ6qrMCLQtmZNMyAi0OXgGcgsQvSrwC2HlJUASvIHELEq8Ise1dXLicL02VnEePwh+i"
+ "o44jxBmggpRPKwAm7Ovtbkn5ExVkWPdCggxBhhIR1ItOehBa4JchdCT4kT0ARYKUEtmYK8Gf"
+ "rtHTnkiZsE+CKoX4IfAEMA4EwEgjNbuzKxLCvzgTLSiRvkD6IN16uwW2RGgCGUhQIptVb8PQ"
+ "q1N61OcE9eX9gk3bPW0C2O3BTl3KUQEnpZQGoAmQGkAIuVhMZcSGMNBRanGCqXKUik+OlJak"
+ "V1cIIVeA6Tg8DpwU4FJnvTgCSGuGigxCNgwOkuzoIJHLMTo6yrZt2zBNE9M0UdV604yMjLBp"
+ "06aPBQvDkKGhIfr6+rBtm9nz57l++DCGJggg3QHXJiA7Df2dUT1A1AUqlLxFD+l56D09qKkU"
+ "ALqu33Jnmnbrom72N7q68F0Hz/ZRoQSQhyNVeHYCdn1MgAJzds1Da0niTU7eMdDdCPALBTRF"
+ "wbIDFJgD2AyFCnytDL/9EDYsCQBeX5i3ZFxXsC9fvuWCdyOg2W5duYKphCyUHAksXUjb4M0S"
+ "/KoEJ5cEOHBqYqZWzrVr5J9//n+SgfkXXySb0pgs2GUHTjX7VeFEFXa9AesVAB9eWyg5lpbQ"
+ "8D+8SnVo6BNloOFfHR7GHRtFM1UKNc/y4bVmvzJkK0ANQgXgOPg+PPXutWJ59eoEY0eO4C0s"
+ "/MdAjW64lQCvVOKfBw+yqk3lvclq2YenjoMPcBrUX8BABV4ow5sPw9jSbfg9+PVsxR0r2H6Q"
+ "M1yG9+4lnJ39rzIgy2X+0t9Pyi2Td8Nw0vKtSbj/u/CzH8Cr12CmDC+VYbYK+6DpOhYgyzBw"
+ "8UapoKQM2pVFRvbs4caJE8gwvKOAm6dO8daOHbRU5tCTGv+YqSnXocOC75Tg0Dz0z8L4NHzr"
+ "Kuw8BBNR3CUYQOwg7LhHcGZrbyqZM1V1fMZHJpKsO3CAnoEBkmvXEiYSqJZFbXycqZdfZuy5"
+ "5wjyC/SkBbO+5OJMTV6GiSpMSphwYXgO3v4bfABYgB3RbQhQgHiDD0FfP5zMpYzOzd2tMcX2"
+ "KRY9bHRc18N1HHTTwNB1YoFLulVDmiqX5hbdmZqX/yU8fbW+w0YwaxkbtlpzBmJNImJJaPkK"
+ "7F8FhzNJXV2TMuIrErowNAVdUXD9ANcLmK/58mbVtYuWL0dgcBBe9WCxaZfWLb4t6k81f/lz"
+ "SQcSgBkJMtPQ8kV4cC3saYEtCmQExCXYAZSK8P5l+PM5uGSBA3gRGxeO00QLqEW/cnkNNENE"
+ "NdEQYkTitIhqdGwiYvQKIKR+z/sR3aYdu5Ht3wLdLRoBlSY2oyGgwYaoT3Fb/At4CANJRbmY"
+ "kwAAAABJRU5ErkJggg==")
+
+
+#-----------------------------------------------------------------------------#
+if __name__ == '__main__':
+ try:
+ import sys
+ import run
+ except ImportError:
+ app = wx.PySimpleApp(False)
+ frame = wx.Frame(None, title="PlateButton Test")
+ sizer = wx.BoxSizer(wx.HORIZONTAL)
+ sizer.Add(TestPanel(frame, TestLog()), 1, wx.EXPAND)
+ frame.CreateStatusBar()
+ frame.SetSizer(sizer)
+ frame.SetInitialSize()
+ frame.Show()
+ app.MainLoop()
+ else:
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/PopupControl.py b/demo/PopupControl.py
new file mode 100644
index 00000000..d5b17f56
--- /dev/null
+++ b/demo/PopupControl.py
@@ -0,0 +1,97 @@
+
+import wx
+import wx.lib.popupctl as pop
+import wx.calendar as cal
+
+class TestDateControl(pop.PopupControl):
+ def __init__(self,*_args,**_kwargs):
+ pop.PopupControl.__init__(self, *_args, **_kwargs)
+
+ self.win = wx.Window(self,-1,pos = (0,0),style = 0)
+ self.cal = cal.CalendarCtrl(self.win,-1,pos = (0,0))
+
+ bz = self.cal.GetBestSize()
+ self.win.SetSize(bz)
+
+ # This method is needed to set the contents that will be displayed
+ # in the popup
+ self.SetPopupContent(self.win)
+
+ # Event registration for date selection
+ self.cal.Bind(cal.EVT_CALENDAR, self.OnCalSelected)
+
+
+ # Method called when a day is selected in the calendar
+ def OnCalSelected(self,evt):
+ self.PopDown()
+ date = self.cal.GetDate()
+
+ # Format the date that was selected for the text part of the control
+ self.SetValue('%02d/%02d/%04d' % (date.GetDay(),
+ date.GetMonth()+1,
+ date.GetYear()))
+ evt.Skip()
+
+
+ # Method overridden from PopupControl
+ # This method is called just before the popup is displayed
+ # Use this method to format any controls in the popup
+ def FormatContent(self):
+ # I parse the value in the text part to resemble the correct date in
+ # the calendar control
+ txtValue = self.GetValue()
+ dmy = txtValue.split('/')
+ didSet = False
+
+ if len(dmy) == 3:
+ date = self.cal.GetDate()
+ d = int(dmy[0])
+ m = int(dmy[1]) - 1
+ y = int(dmy[2])
+
+ if d > 0 and d < 31:
+ if m >= 0 and m < 12:
+ if y > 1000:
+ self.cal.SetDate(wx.DateTimeFromDMY(d,m,y))
+ didSet = True
+
+ if not didSet:
+ self.cal.SetDate(wx.DateTime.Today())
+
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+ date = TestDateControl(self, -1, pos = (30,30))
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+overview = """
+
PopupControl
+
+PopupControl is a class that can display a value and has a button
+that will popup another window similar to how a wx.ComboBox works. The
+popup window can contain whatever is needed to edit the value. This
+example uses a wx.CalendarCtrl.
+
+
Currently a wx.Dialog is used for the popup. Eventually a
+wx.PopupWindow should be used...
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/PopupMenu.py b/demo/PopupMenu.py
new file mode 100644
index 00000000..7d6a9059
--- /dev/null
+++ b/demo/PopupMenu.py
@@ -0,0 +1,156 @@
+
+import wx
+
+import images
+
+#----------------------------------------------------------------------
+
+text = """\
+
+Right-click on any bare area of this panel (or Ctrl-click on the Mac)
+to show a popup menu. Then look at the code for this sample. Notice
+how the PopupMenu method is similar to the ShowModal method of a
+wx.Dialog in that it doesn't return until the popup menu has been
+dismissed. The event handlers for the popup menu items can either be
+attached to the menu itself, or to the window that invokes PopupMenu.
+"""
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+ box = wx.BoxSizer(wx.VERTICAL)
+
+ # Make and layout the controls
+ fs = self.GetFont().GetPointSize()
+ bf = wx.Font(fs+4, wx.SWISS, wx.NORMAL, wx.BOLD)
+ nf = wx.Font(fs+2, wx.SWISS, wx.NORMAL, wx.NORMAL)
+
+ t = wx.StaticText(self, -1, "PopupMenu")
+ t.SetFont(bf)
+ box.Add(t, 0, wx.CENTER|wx.ALL, 5)
+
+ box.Add(wx.StaticLine(self, -1), 0, wx.EXPAND)
+ box.Add((10,20))
+
+ t = wx.StaticText(self, -1, text)
+ t.SetFont(nf)
+ box.Add(t, 0, wx.CENTER|wx.ALL, 5)
+ t.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
+
+ self.SetSizer(box)
+
+ self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
+
+
+ def OnContextMenu(self, event):
+ self.log.WriteText("OnContextMenu\n")
+
+ # only do this part the first time so the events are only bound once
+ #
+ # Yet another anternate way to do IDs. Some prefer them up top to
+ # avoid clutter, some prefer them close to the object of interest
+ # for clarity.
+ if not hasattr(self, "popupID1"):
+ self.popupID1 = wx.NewId()
+ self.popupID2 = wx.NewId()
+ self.popupID3 = wx.NewId()
+ self.popupID4 = wx.NewId()
+ self.popupID5 = wx.NewId()
+ self.popupID6 = wx.NewId()
+ self.popupID7 = wx.NewId()
+ self.popupID8 = wx.NewId()
+ self.popupID9 = wx.NewId()
+
+ self.Bind(wx.EVT_MENU, self.OnPopupOne, id=self.popupID1)
+ self.Bind(wx.EVT_MENU, self.OnPopupTwo, id=self.popupID2)
+ self.Bind(wx.EVT_MENU, self.OnPopupThree, id=self.popupID3)
+ self.Bind(wx.EVT_MENU, self.OnPopupFour, id=self.popupID4)
+ self.Bind(wx.EVT_MENU, self.OnPopupFive, id=self.popupID5)
+ self.Bind(wx.EVT_MENU, self.OnPopupSix, id=self.popupID6)
+ self.Bind(wx.EVT_MENU, self.OnPopupSeven, id=self.popupID7)
+ self.Bind(wx.EVT_MENU, self.OnPopupEight, id=self.popupID8)
+ self.Bind(wx.EVT_MENU, self.OnPopupNine, id=self.popupID9)
+
+ # make a menu
+ menu = wx.Menu()
+ # Show how to put an icon in the menu
+ item = wx.MenuItem(menu, self.popupID1,"One")
+ bmp = images.Smiles.GetBitmap()
+ item.SetBitmap(bmp)
+ menu.AppendItem(item)
+ # add some other items
+ menu.Append(self.popupID2, "Two")
+ menu.Append(self.popupID3, "Three")
+ menu.Append(self.popupID4, "Four")
+ menu.Append(self.popupID5, "Five")
+ menu.Append(self.popupID6, "Six")
+ # make a submenu
+ sm = wx.Menu()
+ sm.Append(self.popupID8, "sub item 1")
+ sm.Append(self.popupID9, "sub item 1")
+ menu.AppendMenu(self.popupID7, "Test Submenu", sm)
+
+
+ # Popup the menu. If an item is selected then its handler
+ # will be called before PopupMenu returns.
+ self.PopupMenu(menu)
+ menu.Destroy()
+
+
+ def OnPopupOne(self, event):
+ self.log.WriteText("Popup one\n")
+
+ def OnPopupTwo(self, event):
+ self.log.WriteText("Popup two\n")
+
+ def OnPopupThree(self, event):
+ self.log.WriteText("Popup three\n")
+
+ def OnPopupFour(self, event):
+ self.log.WriteText("Popup four\n")
+
+ def OnPopupFive(self, event):
+ self.log.WriteText("Popup five\n")
+
+ def OnPopupSix(self, event):
+ self.log.WriteText("Popup six\n")
+
+ def OnPopupSeven(self, event):
+ self.log.WriteText("Popup seven\n")
+
+ def OnPopupEight(self, event):
+ self.log.WriteText("Popup eight\n")
+
+ def OnPopupNine(self, event):
+ self.log.WriteText("Popup nine\n")
+
+
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
PopupMenu
+""" + text + """
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/PopupWindow.py b/demo/PopupWindow.py
new file mode 100644
index 00000000..2928ff27
--- /dev/null
+++ b/demo/PopupWindow.py
@@ -0,0 +1,226 @@
+#
+# 11/30/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Some issues with the listbox example; I tried correcting
+# it but it's still not working the way it should. Commented
+# out for now, as I found it.
+#
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPopup(wx.PopupWindow):
+ """Adds a bit of text and mouse movement to the wx.PopupWindow"""
+ def __init__(self, parent, style):
+ wx.PopupWindow.__init__(self, parent, style)
+ pnl = self.pnl = wx.Panel(self)
+ pnl.SetBackgroundColour("CADET BLUE")
+
+
+ st = wx.StaticText(pnl, -1,
+ "This is a special kind of top level\n"
+ "window that can be used for\n"
+ "popup menus, combobox popups\n"
+ "and such.\n\n"
+ "Try positioning the demo near\n"
+ "the bottom of the screen and \n"
+ "hit the button again.\n\n"
+ "In this demo this window can\n"
+ "be dragged with the left button\n"
+ "and closed with the right."
+ ,
+ pos=(10,10))
+
+ sz = st.GetBestSize()
+ self.SetSize( (sz.width+20, sz.height+20) )
+ pnl.SetSize( (sz.width+20, sz.height+20) )
+
+ pnl.Bind(wx.EVT_LEFT_DOWN, self.OnMouseLeftDown)
+ pnl.Bind(wx.EVT_MOTION, self.OnMouseMotion)
+ pnl.Bind(wx.EVT_LEFT_UP, self.OnMouseLeftUp)
+ pnl.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
+
+ st.Bind(wx.EVT_LEFT_DOWN, self.OnMouseLeftDown)
+ st.Bind(wx.EVT_MOTION, self.OnMouseMotion)
+ st.Bind(wx.EVT_LEFT_UP, self.OnMouseLeftUp)
+ st.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
+
+ wx.CallAfter(self.Refresh)
+
+
+ def OnMouseLeftDown(self, evt):
+ self.Refresh()
+ self.ldPos = evt.GetEventObject().ClientToScreen(evt.GetPosition())
+ self.wPos = self.ClientToScreen((0,0))
+ self.pnl.CaptureMouse()
+
+ def OnMouseMotion(self, evt):
+ if evt.Dragging() and evt.LeftIsDown():
+ dPos = evt.GetEventObject().ClientToScreen(evt.GetPosition())
+ nPos = (self.wPos.x + (dPos.x - self.ldPos.x),
+ self.wPos.y + (dPos.y - self.ldPos.y))
+ self.Move(nPos)
+
+ def OnMouseLeftUp(self, evt):
+ if self.pnl.HasCapture():
+ self.pnl.ReleaseMouse()
+
+ def OnRightUp(self, evt):
+ self.Show(False)
+ self.Destroy()
+
+
+
+class TestTransientPopup(wx.PopupTransientWindow):
+ """Adds a bit of text and mouse movement to the wx.PopupWindow"""
+ def __init__(self, parent, style, log):
+ wx.PopupTransientWindow.__init__(self, parent, style)
+ self.log = log
+ panel = wx.Panel(self)
+ panel.SetBackgroundColour("#FFB6C1")
+
+ st = wx.StaticText(panel, -1,
+ "wx.PopupTransientWindow is a\n"
+ "wx.PopupWindow which disappears\n"
+ "automatically when the user\n"
+ "clicks the mouse outside it or if it\n"
+ "(or its first child) loses focus in \n"
+ "any other way.")
+ btn = wx.Button(panel, -1, "Press Me")
+ spin = wx.SpinCtrl(panel, -1, "Hello", size=(100,-1))
+ btn.Bind(wx.EVT_BUTTON, self.OnButton)
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(st, 0, wx.ALL, 5)
+ sizer.Add(btn, 0, wx.ALL, 5)
+ sizer.Add(spin, 0, wx.ALL, 5)
+ panel.SetSizer(sizer)
+
+ sizer.Fit(panel)
+ sizer.Fit(self)
+ self.Layout()
+
+
+ def ProcessLeftDown(self, evt):
+ self.log.write("ProcessLeftDown: %s\n" % evt.GetPosition())
+ return wx.PopupTransientWindow.ProcessLeftDown(self, evt)
+
+ def OnDismiss(self):
+ self.log.write("OnDismiss\n")
+
+ def OnButton(self, evt):
+ btn = evt.GetEventObject()
+ if btn.GetLabel() == "Press Me":
+ btn.SetLabel("Pressed")
+ else:
+ btn.SetLabel("Press Me")
+
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ b = wx.Button(self, -1, "Show wx.PopupWindow", (25, 50))
+ self.Bind(wx.EVT_BUTTON, self.OnShowPopup, b)
+
+ b = wx.Button(self, -1, "Show wx.PopupTransientWindow", (25, 95))
+ self.Bind(wx.EVT_BUTTON, self.OnShowPopupTransient, b)
+
+ # This isn't working so well, not sure why. Commented out for
+ # now.
+
+# b = wx.Button(self, -1, "Show wx.PopupWindow with listbox", (25, 140))
+# self.Bind(wx.EVT_BUTTON, self.OnShowPopupListbox, b)
+
+
+ def OnShowPopup(self, evt):
+ win = TestPopup(self.GetTopLevelParent(), wx.SIMPLE_BORDER)
+ #win = TestPopupWithListbox(self, wx.SIMPLE_BORDER, self.log)
+
+ # Show the popup right below or above the button
+ # depending on available screen space...
+ btn = evt.GetEventObject()
+ pos = btn.ClientToScreen( (0,0) )
+ sz = btn.GetSize()
+ win.Position(pos, (0, sz[1]))
+
+ win.Show(True)
+
+
+ def OnShowPopupTransient(self, evt):
+ win = TestTransientPopup(self,
+ wx.SIMPLE_BORDER,
+ self.log)
+
+ # Show the popup right below or above the button
+ # depending on available screen space...
+ btn = evt.GetEventObject()
+ pos = btn.ClientToScreen( (0,0) )
+ sz = btn.GetSize()
+ win.Position(pos, (0, sz[1]))
+
+ win.Popup()
+
+
+ def OnShowPopupListbox(self, evt):
+ win = TestPopupWithListbox(self, wx.NO_BORDER, self.log)
+
+ # Show the popup right below or above the button
+ # depending on available screen space...
+ btn = evt.GetEventObject()
+ pos = btn.ClientToScreen( (0,0) )
+ sz = btn.GetSize()
+ win.Position(pos, (0, sz[1]))
+
+ win.Show(True)
+
+
+
+# This class is currently not implemented in the demo. It does not
+# behave the way it should, so for the time being it's only here
+# for show. If you figure out how to make it work, please send
+# a corrected file to Robin!
+class TestPopupWithListbox(wx.PopupWindow):
+ def __init__(self, parent, style, log):
+ wx.PopupWindow.__init__(self, parent, style)
+ self.log = log
+ import keyword
+ self.lb = wx.ListBox(self, -1, choices = keyword.kwlist)
+ #sz = self.lb.GetBestSize()
+ self.SetSize((150, 75)) #sz)
+ self.lb.SetSize(self.GetClientSize())
+ self.lb.SetFocus()
+ self.Bind(wx.EVT_LISTBOX, self.OnListBox)
+ self.Bind(wx.EVT_LISTBOX_DCLICK, self.OnListBoxDClick)
+
+ def OnListBox(self, evt):
+ obj = evt.GetEventObject()
+ self.log.write("OnListBox: %s\n" % obj)
+ self.log.write('Selected: %s\n' % obj.GetString(evt.GetInt()))
+ evt.Skip()
+
+ def OnListBoxDClick(self, evt):
+ self.Hide()
+ self.Destroy()
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/PrintDialog.py b/demo/PrintDialog.py
new file mode 100644
index 00000000..e86dddf2
--- /dev/null
+++ b/demo/PrintDialog.py
@@ -0,0 +1,60 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show a PrintDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ data = wx.PrintDialogData()
+
+ data.EnableSelection(True)
+ data.EnablePrintToFile(True)
+ data.EnablePageNumbers(True)
+ data.SetMinPage(1)
+ data.SetMaxPage(5)
+ data.SetAllPages(True)
+
+ dlg = wx.PrintDialog(self, data)
+
+ if dlg.ShowModal() == wx.ID_OK:
+ data = dlg.GetPrintDialogData()
+ self.log.WriteText('GetAllPages: %d\n' % data.GetAllPages())
+
+ dlg.Destroy()
+
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+This class represents the print and print setup common dialogs. You may obtain
+a wx.PrinterDC device context from a successfully dismissed print dialog.
+
+User information is stored in a wx.PrintDialogData object that is passed to the
+dialog at creation time, and it is filled in by the user. As with other dialogs,
+do not use this data once the dialog is dismissed, and do not destroy the dialog
+until you have everything you need from it.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/PrintFramework.py b/demo/PrintFramework.py
new file mode 100644
index 00000000..4cc1c940
--- /dev/null
+++ b/demo/PrintFramework.py
@@ -0,0 +1,232 @@
+
+import wx
+import ScrolledWindow
+
+#----------------------------------------------------------------------
+
+
+class MyPrintout(wx.Printout):
+ def __init__(self, canvas, log):
+ wx.Printout.__init__(self)
+ self.canvas = canvas
+ self.log = log
+
+ def OnBeginDocument(self, start, end):
+ self.log.WriteText("MyPrintout.OnBeginDocument\n")
+ return super(MyPrintout, self).OnBeginDocument(start, end)
+
+ def OnEndDocument(self):
+ self.log.WriteText("MyPrintout.OnEndDocument\n")
+ super(MyPrintout, self).OnEndDocument()
+
+ def OnBeginPrinting(self):
+ self.log.WriteText("MyPrintout.OnBeginPrinting\n")
+ super(MyPrintout, self).OnBeginPrinting()
+
+ def OnEndPrinting(self):
+ self.log.WriteText("MyPrintout.OnEndPrinting\n")
+ super(MyPrintout, self).OnEndPrinting()
+
+ def OnPreparePrinting(self):
+ self.log.WriteText("MyPrintout.OnPreparePrinting\n")
+ super(MyPrintout, self).OnPreparePrinting()
+
+ def HasPage(self, page):
+ self.log.WriteText("MyPrintout.HasPage: %d\n" % page)
+ if page <= 2:
+ return True
+ else:
+ return False
+
+ def GetPageInfo(self):
+ self.log.WriteText("MyPrintout.GetPageInfo\n")
+ return (1, 2, 1, 2)
+
+ def OnPrintPage(self, page):
+ self.log.WriteText("MyPrintout.OnPrintPage: %d\n" % page)
+ dc = self.GetDC()
+
+ #-------------------------------------------
+ # One possible method of setting scaling factors...
+
+ maxX = self.canvas.getWidth()
+ maxY = self.canvas.getHeight()
+
+ # Let's have at least 50 device units margin
+ marginX = 50
+ marginY = 50
+
+ # Add the margin to the graphic size
+ maxX = maxX + (2 * marginX)
+ maxY = maxY + (2 * marginY)
+
+ # Get the size of the DC in pixels
+ (w, h) = dc.GetSizeTuple()
+
+ # Calculate a suitable scaling factor
+ scaleX = float(w) / maxX
+ scaleY = float(h) / maxY
+
+ # Use x or y scaling factor, whichever fits on the DC
+ actualScale = min(scaleX, scaleY)
+
+ # Calculate the position on the DC for centering the graphic
+ posX = (w - (self.canvas.getWidth() * actualScale)) / 2.0
+ posY = (h - (self.canvas.getHeight() * actualScale)) / 2.0
+
+ # Set the scale and origin
+ dc.SetUserScale(actualScale, actualScale)
+ dc.SetDeviceOrigin(int(posX), int(posY))
+
+ #-------------------------------------------
+
+ self.canvas.DoDrawing(dc, True)
+ dc.DrawText("Page: %d" % page, marginX/2, maxY-marginY)
+
+ return True
+
+
+#----------------------------------------------------------------------
+
+
+class TestPrintPanel(wx.Panel):
+ def __init__(self, parent, frame, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+ self.frame = frame
+
+ self.printData = wx.PrintData()
+ self.printData.SetPaperId(wx.PAPER_LETTER)
+ self.printData.SetPrintMode(wx.PRINT_MODE_PRINTER)
+
+ self.box = wx.BoxSizer(wx.VERTICAL)
+ self.canvas = ScrolledWindow.MyCanvas(self)
+ self.box.Add(self.canvas, 1, wx.GROW)
+
+ subbox = wx.BoxSizer(wx.HORIZONTAL)
+ btn = wx.Button(self, -1, "Page Setup")
+ self.Bind(wx.EVT_BUTTON, self.OnPageSetup, btn)
+ subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "Print Preview")
+ self.Bind(wx.EVT_BUTTON, self.OnPrintPreview, btn)
+ subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+ btn = wx.Button(self, -1, "Print")
+ self.Bind(wx.EVT_BUTTON, self.OnDoPrint, btn)
+ subbox.Add(btn, 1, wx.GROW | wx.ALL, 2)
+
+ self.box.Add(subbox, 0, wx.GROW)
+
+ self.SetAutoLayout(True)
+ self.SetSizer(self.box)
+
+
+
+ def OnPageSetup(self, evt):
+ psdd = wx.PageSetupDialogData(self.printData)
+ psdd.EnablePrinter(True)
+ psdd.CalculatePaperSizeFromId()
+ dlg = wx.PageSetupDialog(self, psdd)
+ dlg.ShowModal()
+
+ # this makes a copy of the wx.PrintData instead of just saving
+ # a reference to the one inside the PrintDialogData that will
+ # be destroyed when the dialog is destroyed
+ self.printData = wx.PrintData( dlg.GetPageSetupData().GetPrintData() )
+
+ dlg.Destroy()
+
+ def OnPrintPreview(self, event):
+ data = wx.PrintDialogData(self.printData)
+ printout = MyPrintout(self.canvas, self.log)
+ printout2 = MyPrintout(self.canvas, self.log)
+ self.preview = wx.PrintPreview(printout, printout2, data)
+
+ if not self.preview.Ok():
+ self.log.WriteText("Houston, we have a problem...\n")
+ return
+
+ pfrm = wx.PreviewFrame(self.preview, self.frame, "This is a print preview")
+
+ pfrm.Initialize()
+ pfrm.SetPosition(self.frame.GetPosition())
+ pfrm.SetSize(self.frame.GetSize())
+ pfrm.Show(True)
+
+
+
+ def OnDoPrint(self, event):
+ pdd = wx.PrintDialogData(self.printData)
+ pdd.SetToPage(2)
+ printer = wx.Printer(pdd)
+ printout = MyPrintout(self.canvas, self.log)
+
+ if not printer.Print(self.frame, printout, True):
+ wx.MessageBox("There was a problem printing.\nPerhaps your current printer is not set correctly?", "Printing", wx.OK)
+ else:
+ self.printData = wx.PrintData( printer.GetPrintDialogData().GetPrintData() )
+ printout.Destroy()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPrintPanel(nb, frame, log)
+ return win
+
+
+#----------------------------------------------------------------------
+
+
+
+
+
+overview = """\
+
+
+
PrintFramework
+
+This is an overview of the classes and methods used to print documents.
+It also demonstrates how to do print previews and invoke the printer
+setup dialog.
+
+
Classes demonstrated here:
+
+
wx.Printout() - This class encapsulates the functionality of printing out
+ an application document. A new class must be derived and members overridden
+ to respond to calls such as OnPrintPage and HasPage. Instances of this class
+ are passed to wx.Printer.Print() or a wx.PrintPreview object to initiate
+ printing or previewing.
+
+
wx.PrintData() - This class holds a variety of information related to
+ printers and printer device contexts. This class is used to create a
+ wx.PrinterDC and a wx.PostScriptDC. It is also used as a data member of
+ wx.PrintDialogData and wx.PageSetupDialogData, as part of the mechanism for
+ transferring data between the print dialogs and the application.
+
+
wx.PrintDialog() - This class represents the print and print setup
+ common dialogs. You may obtain a wx.PrinterDC device context from a
+ successfully dismissed print dialog.
+
+
wx.PrintPreview() - Objects of this class manage the print preview
+ process. The object is passed a wx.Printout object, and the wx.PrintPreview
+ object itself is passed to a wx.PreviewFrame object. Previewing is started by
+ initializing and showing the preview frame. Unlike wxPrinter.Print, flow of
+ control returns to the application immediately after the frame is shown.
+
+wx.Process lets you get notified when an asyncronous child process
+started by wxExecute terminates, and also to get input/output streams
+for the child process's stdout, stderr and stdin.
+
+
+This demo launches a simple python script that echos back on stdout
+lines that it reads from stdin. You can send text to the echo
+process' stdin by typing in the lower textctrl and clicking Send.
+
+
+Clicking the Close Stream button will close the demo's end of the
+stdin pipe to the child process. In our case that will cause the
+child process to exit its main loop.
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/ProgressDialog.py b/demo/ProgressDialog.py
new file mode 100644
index 00000000..bb8879aa
--- /dev/null
+++ b/demo/ProgressDialog.py
@@ -0,0 +1,86 @@
+# 11/21/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Updated for wx namespace
+#
+# 11/30/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o wx.ProgressDialog appears to be broken. No abort button
+# and it's not possible to dismiss it otherwise.
+#
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show a ProgressDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ max = 80
+
+ dlg = wx.ProgressDialog("Progress dialog example",
+ "An informative message",
+ maximum = max,
+ parent=self,
+ style = 0
+ | wx.PD_APP_MODAL
+ | wx.PD_CAN_ABORT
+ #| wx.PD_CAN_SKIP
+ #| wx.PD_ELAPSED_TIME
+ | wx.PD_ESTIMATED_TIME
+ | wx.PD_REMAINING_TIME
+ #| wx.PD_AUTO_HIDE
+ )
+
+ keepGoing = True
+ count = 0
+
+ while keepGoing and count < max:
+ count += 1
+ wx.MilliSleep(250)
+ wx.Yield()
+
+ if count >= max / 2:
+ (keepGoing, skip) = dlg.Update(count, "Half-time!")
+ else:
+ (keepGoing, skip) = dlg.Update(count)
+
+
+ dlg.Destroy()
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+
+This class represents a dialog that shows a short message and a progress bar.
+Optionally, it can display an ABORT button
+
+This dialog indicates the progress of some event that takes a while to accomplish,
+usually, such as file copy progress, download progress, and so on. The display
+is completely under control of the program; you must update the dialog from
+within the program creating it.
+
+When the dialog closes, you must check to see if the user aborted the process or
+not, and act accordingly -- that is, if the PD_CAN_ABORT style flag is set.
+If not then you may progress blissfully onward.
+
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/PropertyGrid.py b/demo/PropertyGrid.py
new file mode 100644
index 00000000..3d5928d7
--- /dev/null
+++ b/demo/PropertyGrid.py
@@ -0,0 +1,1042 @@
+
+import sys, time, math, os, os.path
+
+import wx
+_ = wx.GetTranslation
+import wx.propgrid as wxpg
+
+
+############################################################################
+#
+# TEST RELATED CODE AND VARIABLES
+#
+############################################################################
+
+default_object_content2 = """\
+object.title = "Object Title"
+object.index = 1
+object.PI = %f
+object.wxpython_rules = True
+"""%(math.pi)
+
+default_object_content1 = """\
+
+#
+# Note that the results of autofill will appear on the second page.
+
+#
+# Set number of iterations appropriately to test performance
+iterations = 100
+
+#
+# Test result for 100,000 iterations on Athlon XP 2000+:
+#
+# Time spent per property: 0.054ms
+# Memory allocated per property: ~350 bytes (includes Python object)
+#
+
+for i in range(0,iterations):
+ setattr(object,'title%i'%i,"Object Title")
+ setattr(object,'index%i'%i,1)
+ setattr(object,'PI%i'%i,3.14)
+ setattr(object,'wxpython_rules%i'%i,True)
+"""
+
+
+############################################################################
+#
+# CUSTOM PROPERTY SAMPLES
+#
+############################################################################
+
+
+class ValueObject:
+ def __init__(self):
+ pass
+
+
+class IntProperty2(wxpg.PyProperty):
+ """\
+ This is a simple re-implementation of wxIntProperty.
+ """
+ def __init__(self, label, name = wxpg.LABEL_AS_NAME, value=0):
+ wxpg.PyProperty.__init__(self, label, name)
+ self.SetValue(value)
+
+ def GetClassName(self):
+ """\
+ This is not 100% necessary and in future is probably going to be
+ automated to return class name.
+ """
+ return "IntProperty2"
+
+ def GetEditor(self):
+ return "TextCtrl"
+
+ def ValueToString(self, value, flags):
+ return str(value)
+
+ def StringToValue(self, s, flags):
+ """ If failed, return False or (False, None). If success, return tuple
+ (True, newValue).
+ """
+ try:
+ v = int(s)
+ if self.GetValue() != v:
+ return (True, v)
+ except (ValueError, TypeError):
+ if flags & wxpg.PG_REPORT_ERROR:
+ wx.MessageBox("Cannot convert '%s' into a number."%s, "Error")
+ return False
+
+ def IntToValue(self, v, flags):
+ """ If failed, return False or (False, None). If success, return tuple
+ (True, newValue).
+ """
+ if (self.GetValue() != v):
+ return (True, v)
+ return False
+
+ def ValidateValue(self, value, validationInfo):
+ """ Let's limit the value to range -10000 and 10000.
+ """
+ # Just test this function to make sure validationInfo and
+ # wxPGVFBFlags work properly.
+ oldvfb__ = validationInfo.GetFailureBehavior()
+
+ # Mark the cell if validaton failred
+ validationInfo.SetFailureBehavior(wxpg.PG_VFB_MARK_CELL)
+
+ if value < -10000 or value > 10000:
+ return False
+
+ return (True, value)
+
+
+class SizeProperty(wxpg.PyProperty):
+ """ Demonstrates a property with few children.
+ """
+ def __init__(self, label, name = wxpg.LABEL_AS_NAME, value=wx.Size(0, 0)):
+ wxpg.PyProperty.__init__(self, label, name)
+
+ value = self._ConvertValue(value)
+
+ self.AddPrivateChild( wxpg.IntProperty("X", value=value.x) )
+ self.AddPrivateChild( wxpg.IntProperty("Y", value=value.y) )
+
+ self.m_value = value
+
+ def GetClassName(self):
+ return self.__class__.__name__
+
+ def GetEditor(self):
+ return "TextCtrl"
+
+ def RefreshChildren(self):
+ size = self.m_value
+ self.Item(0).SetValue( size.x )
+ self.Item(1).SetValue( size.y )
+
+ def _ConvertValue(self, value):
+ """ Utility convert arbitrary value to a real wx.Size.
+ """
+ from operator import isSequenceType
+ if isinstance(value, wx.Point):
+ value = wx.Size(value.x, value.y)
+ elif isSequenceType(value):
+ value = wx.Size(*value)
+ return value
+
+ def ChildChanged(self, thisValue, childIndex, childValue):
+ # FIXME: This does not work yet. ChildChanged needs be fixed "for"
+ # wxPython in wxWidgets SVN trunk, and that has to wait for
+ # 2.9.1, as wxPython 2.9.0 uses WX_2_9_0_BRANCH.
+ size = self._ConvertValue(self.m_value)
+ if childIndex == 0:
+ size.x = childValue
+ elif childIndex == 1:
+ size.y = childValue
+ else:
+ raise AssertionError
+
+ return size
+
+
+class DirsProperty(wxpg.PyArrayStringProperty):
+ """ Sample of a custom custom ArrayStringProperty.
+
+ Because currently some of the C++ helpers from wxArrayStringProperty
+ and wxProperytGrid are not available, our implementation has to quite
+ a bit 'manually'. Which is not too bad since Python has excellent
+ string and list manipulation facilities.
+ """
+ def __init__(self, label, name = wxpg.LABEL_AS_NAME, value=[]):
+ wxpg.PyArrayStringProperty.__init__(self, label, name, value)
+
+ # Set default delimiter
+ self.SetAttribute("Delimiter", ',')
+
+ def GetEditor(self):
+ return "TextCtrlAndButton"
+
+ def ValueToString(self, value, flags):
+ return self.m_display
+
+ def OnSetValue(self):
+ self.GenerateValueAsString()
+
+ def DoSetAttribute(self, name, value):
+ # Proper way to call same method from super class
+ retval = self.CallSuperMethod("DoSetAttribute", name, value)
+
+ #
+ # Must re-generate cached string when delimiter changes
+ if name == "Delimiter":
+ self.GenerateValueAsString(delim=value)
+
+ return retval
+
+ def GenerateValueAsString(self, delim=None):
+ """ This function creates a cached version of displayed text
+ (self.m_display).
+ """
+ if not delim:
+ delim = self.GetAttribute("Delimiter")
+ if not delim:
+ delim = ','
+
+ ls = self.GetValue()
+ if delim == '"' or delim == "'":
+ text = ' '.join(['%s%s%s'%(delim,a,delim) for a in ls])
+ else:
+ text = ', '.join(ls)
+ self.m_display = text
+
+ def StringToValue(self, text, argFlags):
+ """ If failed, return False or (False, None). If success, return tuple
+ (True, newValue).
+ """
+ delim = self.GetAttribute("Delimiter")
+ if delim == '"' or delim == "'":
+ # Proper way to call same method from super class
+ return self.CallSuperMethod("StringToValue", text, 0)
+ v = [a.strip() for a in text.split(delim)]
+ return (True, v)
+
+ def OnEvent(self, propgrid, primaryEditor, event):
+ if event.GetEventType() == wx.wxEVT_COMMAND_BUTTON_CLICKED:
+ dlg = wx.DirDialog(propgrid,
+ _("Select a directory to be added to "
+ "the list:"))
+
+ if dlg.ShowModal() == wx.ID_OK:
+ new_path = dlg.GetPath()
+ old_value = self.m_value
+ if old_value:
+ new_value = list(old_value)
+ new_value.append(new_path)
+ else:
+ new_value = [new_path]
+ self.SetValueInEvent(new_value)
+ retval = True
+ else:
+ retval = False
+
+ dlg.Destroy()
+ return retval
+
+ return False
+
+
+class PyObjectPropertyValue:
+ """\
+ Value type of our sample PyObjectProperty. We keep a simple dash-delimited
+ list of string given as argument to constructor.
+ """
+ def __init__(self, s=None):
+ try:
+ self.ls = [a.strip() for a in s.split('-')]
+ except:
+ self.ls = []
+
+ def __repr__(self):
+ return ' - '.join(self.ls)
+
+
+class PyObjectProperty(wxpg.PyProperty):
+ """\
+ Another simple example. This time our value is a PyObject.
+
+ NOTE: We can't return an arbitrary python object in DoGetValue. It cannot
+ be a simple type such as int, bool, double, or string, nor an array
+ or wxObject based. Dictionary, None, or any user-specified Python
+ class is allowed.
+ """
+ def __init__(self, label, name = wxpg.LABEL_AS_NAME, value=None):
+ wxpg.PyProperty.__init__(self, label, name)
+ self.SetValue(value)
+
+ def GetClassName(self):
+ return self.__class__.__name__
+
+ def GetEditor(self):
+ return "TextCtrl"
+
+ def ValueToString(self, value, flags):
+ return repr(value)
+
+ def StringToValue(self, s, flags):
+ """ If failed, return False or (False, None). If success, return tuple
+ (True, newValue).
+ """
+ v = PyObjectPropertyValue(s)
+ return (True, v)
+
+
+class SampleMultiButtonEditor(wxpg.PyTextCtrlEditor):
+ def __init__(self):
+ wxpg.PyTextCtrlEditor.__init__(self)
+
+ def CreateControls(self, propGrid, property, pos, sz):
+ # Create and populate buttons-subwindow
+ buttons = wxpg.PGMultiButton(propGrid, sz)
+
+ # Add two regular buttons
+ buttons.AddButton("...")
+ buttons.AddButton("A")
+ # Add a bitmap button
+ buttons.AddBitmapButton(wx.ArtProvider.GetBitmap(wx.ART_FOLDER))
+
+ # Create the 'primary' editor control (textctrl in this case)
+ wnd = self.CallSuperMethod("CreateControls",
+ propGrid,
+ property,
+ pos,
+ buttons.GetPrimarySize())
+
+ # Finally, move buttons-subwindow to correct position and make sure
+ # returned wxPGWindowList contains our custom button list.
+ buttons.Finalize(propGrid, pos);
+
+ # We must maintain a reference to any editor objects we created
+ # ourselves. Otherwise they might be freed prematurely. Also,
+ # we need it in OnEvent() below, because in Python we cannot "cast"
+ # result of wxPropertyGrid.GetEditorControlSecondary() into
+ # PGMultiButton instance.
+ self.buttons = buttons
+
+ return (wnd, buttons)
+
+ def OnEvent(self, propGrid, prop, ctrl, event):
+ if event.GetEventType() == wx.wxEVT_COMMAND_BUTTON_CLICKED:
+ buttons = self.buttons
+ evtId = event.GetId()
+
+ if evtId == buttons.GetButtonId(0):
+ # Do something when the first button is pressed
+ wx.LogDebug("First button pressed");
+ return False # Return false since value did not change
+ if evtId == buttons.GetButtonId(1):
+ # Do something when the second button is pressed
+ wx.MessageBox("Second button pressed");
+ return False # Return false since value did not change
+ if evtId == buttons.GetButtonId(2):
+ # Do something when the third button is pressed
+ wx.MessageBox("Third button pressed");
+ return False # Return false since value did not change
+
+ return self.CallSuperMethod("OnEvent", propGrid, prop, ctrl, event)
+
+
+class SingleChoiceDialogAdapter(wxpg.PyEditorDialogAdapter):
+ """ This demonstrates use of wxpg.PyEditorDialogAdapter.
+ """
+ def __init__(self, choices):
+ wxpg.PyEditorDialogAdapter.__init__(self)
+ self.choices = choices
+
+ def DoShowDialog(self, propGrid, property):
+ s = wx.GetSingleChoice("Message", "Caption", self.choices)
+
+ if s:
+ self.SetValue(s)
+ return True
+
+ return False;
+
+
+class SingleChoiceProperty(wxpg.PyStringProperty):
+ def __init__(self, label, name=wxpg.LABEL_AS_NAME, value=''):
+ wxpg.PyStringProperty.__init__(self, label, name, value)
+
+ # Prepare choices
+ dialog_choices = []
+ dialog_choices.append("Cat");
+ dialog_choices.append("Dog");
+ dialog_choices.append("Gibbon");
+ dialog_choices.append("Otter");
+
+ self.dialog_choices = dialog_choices
+
+ def GetEditor(self):
+ # Set editor to have button
+ return "TextCtrlAndButton"
+
+ def GetEditorDialog(self):
+ # Set what happens on button click
+ return SingleChoiceDialogAdapter(self.dialog_choices)
+
+
+class TrivialPropertyEditor(wxpg.PyEditor):
+ """\
+ This is a simple re-creation of TextCtrlWithButton. Note that it does
+ not take advantage of wx.TextCtrl and wx.Button creation helper functions
+ in wx.PropertyGrid.
+ """
+ def __init__(self):
+ wxpg.PyEditor.__init__(self)
+
+ def CreateControls(self, propgrid, property, pos, sz):
+ """ Create the actual wxPython controls here for editing the
+ property value.
+
+ You must use propgrid.GetPanel() as parent for created controls.
+
+ Return value is either single editor control or tuple of two
+ editor controls, of which first is the primary one and second
+ is usually a button.
+ """
+ try:
+ x, y = pos
+ w, h = sz
+ h = 64 + 6
+
+ # Make room for button
+ bw = propgrid.GetRowHeight()
+ w -= bw
+
+ s = property.GetDisplayedString();
+
+ tc = wx.TextCtrl(propgrid.GetPanel(), wxpg.PG_SUBID1, s,
+ (x,y), (w,h),
+ wx.TE_PROCESS_ENTER)
+ btn = wx.Button(propgrid.GetPanel(), wxpg.PG_SUBID2, '...',
+ (x+w, y),
+ (bw, h), wx.WANTS_CHARS)
+ return (tc, btn)
+ except:
+ import traceback
+ print(traceback.print_exc())
+
+ def UpdateControl(self, property, ctrl):
+ ctrl.SetValue(property.GetDisplayedString())
+
+ def DrawValue(self, dc, rect, property, text):
+ if not property.IsValueUnspecified():
+ dc.DrawText(property.GetDisplayedString(), rect.x+5, rect.y)
+
+ def OnEvent(self, propgrid, property, ctrl, event):
+ """ Return True if modified editor value should be committed to
+ the property. To just mark the property value modified, call
+ propgrid.EditorsValueWasModified().
+ """
+ if not ctrl:
+ return False
+
+ evtType = event.GetEventType()
+
+ if evtType == wx.wxEVT_COMMAND_TEXT_ENTER:
+ if propgrid.IsEditorsValueModified():
+ return True
+ elif evtType == wx.wxEVT_COMMAND_TEXT_UPDATED:
+ #
+ # Pass this event outside wxPropertyGrid so that,
+ # if necessary, program can tell when user is editing
+ # a textctrl.
+ event.Skip()
+ event.SetId(propgrid.GetId())
+
+ propgrid.EditorsValueWasModified()
+ return False
+
+ return False
+
+ def GetValueFromControl(self, property, ctrl):
+ """ Return tuple (wasSuccess, newValue), where wasSuccess is True if
+ different value was acquired succesfully.
+ """
+ tc = ctrl
+ textVal = tc.GetValue()
+
+ if property.UsesAutoUnspecified() and not textVal:
+ return (True, None)
+
+ res, value = property.StringToValue(textVal,
+ wxpg.PG_EDITABLE_VALUE)
+
+ # Changing unspecified always causes event (returning
+ # True here should be enough to trigger it).
+ if not res and value is None:
+ res = True
+
+ return (res, value)
+
+ def SetValueToUnspecified(self, property, ctrl):
+ ctrl.Remove(0,len(ctrl.GetValue()))
+
+ def SetControlStringValue(self, property, ctrl, text):
+ ctrl.SetValue(text)
+
+ def OnFocus(self, property, ctrl):
+ ctrl.SetSelection(-1,-1)
+ ctrl.SetFocus()
+
+
+class LargeImagePickerCtrl(wx.Panel):
+ """\
+ Control created and used by LargeImageEditor.
+ """
+ def __init__(self):
+ pre = wx.PrePanel()
+ self.PostCreate(pre)
+
+ def Create(self, parent, id_, pos, size, style = 0):
+ wx.Panel.Create(self, parent, id_, pos, size,
+ style | wx.BORDER_SIMPLE)
+ img_spc = size[1]
+ self.tc = wx.TextCtrl(self, -1, "", (img_spc,0), (2048,size[1]),
+ wx.BORDER_NONE)
+ self.SetBackgroundColour(wx.WHITE)
+ self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
+ self.property = None
+ self.bmp = None
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+ def OnPaint(self, event):
+ dc = wx.BufferedPaintDC(self)
+
+ whiteBrush = wx.Brush(wx.WHITE)
+ dc.SetBackground(whiteBrush)
+ dc.Clear()
+
+ bmp = self.bmp
+ if bmp:
+ dc.DrawBitmap(bmp, 2, 2)
+ else:
+ dc.SetPen(wx.Pen(wx.BLACK))
+ dc.SetBrush(whiteBrush)
+ dc.DrawRectangle(2, 2, 64, 64)
+
+ def RefreshThumbnail(self):
+ """\
+ We use here very simple image scaling code.
+ """
+ if not self.property:
+ self.bmp = None
+ return
+
+ path = self.property.DoGetValue()
+
+ if not os.path.isfile(path):
+ self.bmp = None
+ return
+
+ image = wx.Image(path)
+ image.Rescale(64, 64)
+ self.bmp = wx.BitmapFromImage(image)
+
+ def SetProperty(self, property):
+ self.property = property
+ self.tc.SetValue(property.GetDisplayedString())
+ self.RefreshThumbnail()
+
+ def SetValue(self, s):
+ self.RefreshThumbnail()
+ self.tc.SetValue(s)
+
+ def GetLastPosition(self):
+ return self.tc.GetLastPosition()
+
+
+class LargeImageEditor(wxpg.PyEditor):
+ """\
+ Double-height text-editor with image in front.
+ """
+ def __init__(self):
+ wxpg.PyEditor.__init__(self)
+
+ def CreateControls(self, propgrid, property, pos, sz):
+ try:
+ x, y = pos
+ w, h = sz
+ h = 64 + 6
+
+ # Make room for button
+ bw = propgrid.GetRowHeight()
+ w -= bw
+
+ lipc = LargeImagePickerCtrl()
+ if sys.platform.startswith('win'):
+ lipc.Hide()
+ lipc.Create(propgrid.GetPanel(), wxpg.PG_SUBID1, (x,y), (w,h))
+ lipc.SetProperty(property)
+ # Hmmm.. how to have two-stage creation without subclassing?
+ #btn = wx.PreButton()
+ #pre = wx.PreWindow()
+ #self.PostCreate(pre)
+ #if sys.platform == 'win32':
+ # btn.Hide()
+ #btn.Create(propgrid, wxpg.PG_SUBID2, '...', (x2-bw,pos[1]),
+ # (bw,h), wx.WANTS_CHARS)
+ btn = wx.Button(propgrid.GetPanel(), wxpg.PG_SUBID2, '...',
+ (x+w, y),
+ (bw, h), wx.WANTS_CHARS)
+ return (lipc, btn)
+ except:
+ import traceback
+ print(traceback.print_exc())
+
+ def UpdateControl(self, property, ctrl):
+ ctrl.SetValue(property.GetDisplayedString())
+
+ def DrawValue(self, dc, rect, property, text):
+ if not property.IsValueUnspecified():
+ dc.DrawText(property.GetDisplayedString(), rect.x+5, rect.y)
+
+ def OnEvent(self, propgrid, property, ctrl, event):
+ """ Return True if modified editor value should be committed to
+ the property. To just mark the property value modified, call
+ propgrid.EditorsValueWasModified().
+ """
+ if not ctrl:
+ return False
+
+ evtType = event.GetEventType()
+
+ if evtType == wx.wxEVT_COMMAND_TEXT_ENTER:
+ if propgrid.IsEditorsValueModified():
+ return True
+ elif evtType == wx.wxEVT_COMMAND_TEXT_UPDATED:
+ #
+ # Pass this event outside wxPropertyGrid so that,
+ # if necessary, program can tell when user is editing
+ # a textctrl.
+ event.Skip()
+ event.SetId(propgrid.GetId())
+
+ propgrid.EditorsValueWasModified()
+ return False
+
+ return False
+
+ def GetValueFromControl(self, property, ctrl):
+ """ Return tuple (wasSuccess, newValue), where wasSuccess is True if
+ different value was acquired succesfully.
+ """
+ tc = ctrl.tc
+ textVal = tc.GetValue()
+
+ if property.UsesAutoUnspecified() and not textVal:
+ return (None, True)
+
+ res, value = property.StringToValue(textVal,
+ wxpg.PG_EDITABLE_VALUE)
+
+ # Changing unspecified always causes event (returning
+ # True here should be enough to trigger it).
+ if not res and value is None:
+ res = True
+
+ return (res, value)
+
+ def SetValueToUnspecified(self, property, ctrl):
+ ctrl.tc.Remove(0,len(ctrl.tc.GetValue()))
+
+ def SetControlStringValue(self, property, ctrl, txt):
+ ctrl.SetValue(txt)
+
+ def OnFocus(self, property, ctrl):
+ ctrl.tc.SetSelection(-1,-1)
+ ctrl.tc.SetFocus()
+
+ def CanContainCustomImage(self):
+ return True
+
+
+############################################################################
+#
+# MAIN PROPERTY GRID TEST PANEL
+#
+############################################################################
+
+class TestPanel( wx.Panel ):
+
+ def __init__( self, parent, log ):
+ wx.Panel.__init__(self, parent, wx.ID_ANY)
+ self.log = log
+
+ self.panel = panel = wx.Panel(self, wx.ID_ANY)
+ topsizer = wx.BoxSizer(wx.VERTICAL)
+
+ # Difference between using PropertyGridManager vs PropertyGrid is that
+ # the manager supports multiple pages and a description box.
+ self.pg = pg = wxpg.PropertyGridManager(panel,
+ style=wxpg.PG_SPLITTER_AUTO_CENTER |
+ wxpg.PG_AUTO_SORT |
+ wxpg.PG_TOOLBAR)
+
+ # Show help as tooltips
+ pg.SetExtraStyle(wxpg.PG_EX_HELP_AS_TOOLTIPS)
+
+ pg.Bind( wxpg.EVT_PG_CHANGED, self.OnPropGridChange )
+ pg.Bind( wxpg.EVT_PG_PAGE_CHANGED, self.OnPropGridPageChange )
+ pg.Bind( wxpg.EVT_PG_SELECTED, self.OnPropGridSelect )
+ pg.Bind( wxpg.EVT_PG_RIGHT_CLICK, self.OnPropGridRightClick )
+
+
+ #
+ # Let's use some simple custom editor
+ #
+ # NOTE: Editor must be registered *before* adding a property that
+ # uses it.
+ if not getattr(sys, '_PropGridEditorsRegistered', False):
+ pg.RegisterEditor(TrivialPropertyEditor)
+ pg.RegisterEditor(SampleMultiButtonEditor)
+ pg.RegisterEditor(LargeImageEditor)
+ # ensure we only do it once
+ sys._PropGridEditorsRegistered = True
+
+ #
+ # Add properties
+ #
+
+ pg.AddPage( "Page 1 - Testing All" )
+
+ pg.Append( wxpg.PropertyCategory("1 - Basic Properties") )
+ pg.Append( wxpg.StringProperty("String",value="Some Text") )
+ pg.Append( wxpg.IntProperty("Int",value=100) )
+ pg.Append( wxpg.FloatProperty("Float",value=100.0) )
+ pg.Append( wxpg.BoolProperty("Bool",value=True) )
+ pg.Append( wxpg.BoolProperty("Bool_with_Checkbox",value=True) )
+ pg.SetPropertyAttribute("Bool_with_Checkbox", "UseCheckbox", True)
+
+ pg.Append( wxpg.PropertyCategory("2 - More Properties") )
+ pg.Append( wxpg.LongStringProperty("LongString",
+ value="This is a\\nmulti-line string\\nwith\\ttabs\\nmixed\\tin."))
+ pg.Append( wxpg.DirProperty("Dir",value="C:\\Windows") )
+ pg.Append( wxpg.FileProperty("File",value="C:\\Windows\\system.ini") )
+ pg.Append( wxpg.ArrayStringProperty("ArrayString",value=['A','B','C']) )
+
+ pg.Append( wxpg.EnumProperty("Enum","Enum",
+ ['wxPython Rules',
+ 'wxPython Rocks',
+ 'wxPython Is The Best'],
+ [10,11,12],
+ 0) )
+ pg.Append( wxpg.EditEnumProperty("EditEnum","EditEnumProperty",
+ ['A','B','C'],
+ [0,1,2],
+ "Text Not in List") )
+
+ pg.Append( wxpg.PropertyCategory("3 - Advanced Properties") )
+ pg.Append( wxpg.DateProperty("Date",value=wx.DateTime_Now()) )
+ pg.Append( wxpg.FontProperty("Font",value=panel.GetFont()) )
+ pg.Append( wxpg.ColourProperty("Colour",
+ value=panel.GetBackgroundColour()) )
+ pg.Append( wxpg.SystemColourProperty("SystemColour") )
+ pg.Append( wxpg.ImageFileProperty("ImageFile") )
+ pg.Append( wxpg.MultiChoiceProperty("MultiChoice",
+ choices=['wxWidgets','QT','GTK+']) )
+
+ pg.Append( wxpg.PropertyCategory("4 - Additional Properties") )
+ #pg.Append( wxpg.PointProperty("Point",value=panel.GetPosition()) )
+ #pg.Append( SizeProperty("Size",value=panel.GetSize()) )
+ #pg.Append( wxpg.FontDataProperty("FontData") )
+ pg.Append( wxpg.IntProperty("IntWithSpin",value=256) )
+ pg.SetPropertyEditor("IntWithSpin","SpinCtrl")
+
+ pg.SetPropertyAttribute( "File", wxpg.PG_FILE_SHOW_FULL_PATH, 0 )
+ pg.SetPropertyAttribute( "File", wxpg.PG_FILE_INITIAL_PATH,
+ "C:\\Program Files\\Internet Explorer" )
+ pg.SetPropertyAttribute( "Date", wxpg.PG_DATE_PICKER_STYLE,
+ wx.DP_DROPDOWN|wx.DP_SHOWCENTURY )
+
+ pg.Append( wxpg.PropertyCategory("5 - Custom Properties and Editors") )
+ pg.Append( IntProperty2("IntProperty2", value=1024) )
+
+ pg.Append( PyObjectProperty("PyObjectProperty") )
+
+ pg.Append( DirsProperty("Dirs1",value=['C:/Lib','C:/Bin']) )
+ pg.Append( DirsProperty("Dirs2",value=['/lib','/bin']) )
+
+ # Test another type of delimiter
+ pg.SetPropertyAttribute("Dirs2", "Delimiter", '"')
+
+ # SampleMultiButtonEditor
+ pg.Append( wxpg.LongStringProperty("MultipleButtons") );
+ pg.SetPropertyEditor("MultipleButtons", "SampleMultiButtonEditor");
+ pg.Append( SingleChoiceProperty("SingleChoiceProperty") )
+
+ # Custom editor samples
+ prop = pg.Append( wxpg.StringProperty("StringWithCustomEditor",
+ value="test value") )
+ pg.SetPropertyEditor(prop, "TrivialPropertyEditor")
+
+ pg.Append( wxpg.ImageFileProperty("ImageFileWithLargeEditor") )
+ pg.SetPropertyEditor("ImageFileWithLargeEditor", "LargeImageEditor")
+
+ # When page is added, it will become the target page for AutoFill
+ # calls (and for other property insertion methods as well)
+ pg.AddPage( "Page 2 - Results of AutoFill will appear here" )
+
+ topsizer.Add(pg, 1, wx.EXPAND)
+
+ rowsizer = wx.BoxSizer(wx.HORIZONTAL)
+ but = wx.Button(panel,-1,"SetPropertyValues")
+ but.Bind( wx.EVT_BUTTON, self.OnSetPropertyValues )
+ rowsizer.Add(but,1)
+ but = wx.Button(panel,-1,"GetPropertyValues")
+ but.Bind( wx.EVT_BUTTON, self.OnGetPropertyValues )
+ rowsizer.Add(but,1)
+ topsizer.Add(rowsizer,0,wx.EXPAND)
+ rowsizer = wx.BoxSizer(wx.HORIZONTAL)
+ but = wx.Button(panel,-1,"GetPropertyValues(as_strings=True)")
+ but.Bind( wx.EVT_BUTTON, self.OnGetPropertyValues2 )
+ rowsizer.Add(but,1)
+ but = wx.Button(panel,-1,"AutoFill")
+ but.Bind( wx.EVT_BUTTON, self.OnAutoFill )
+ rowsizer.Add(but,1)
+ topsizer.Add(rowsizer,0,wx.EXPAND)
+ rowsizer = wx.BoxSizer(wx.HORIZONTAL)
+ but = wx.Button(panel,-1,"Delete")
+ but.Bind( wx.EVT_BUTTON, self.OnDeleteProperty )
+ rowsizer.Add(but,1)
+ but = wx.Button(panel,-1,"Run Tests")
+ but.Bind( wx.EVT_BUTTON, self.RunTests )
+ rowsizer.Add(but,1)
+ topsizer.Add(rowsizer,0,wx.EXPAND)
+
+ panel.SetSizer(topsizer)
+ topsizer.SetSizeHints(panel)
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(panel, 1, wx.EXPAND)
+ self.SetSizer(sizer)
+ self.SetAutoLayout(True)
+
+ def OnPropGridChange(self, event):
+ p = event.GetProperty()
+ if p:
+ self.log.write('%s changed to "%s"\n' % (p.GetName(),p.GetValueAsString()))
+
+ def OnPropGridSelect(self, event):
+ p = event.GetProperty()
+ if p:
+ self.log.write('%s selected\n' % (event.GetProperty().GetName()))
+ else:
+ self.log.write('Nothing selected\n')
+
+ def OnDeleteProperty(self, event):
+ p = self.pg.GetSelectedProperty()
+ if p:
+ self.pg.DeleteProperty(p)
+ else:
+ wx.MessageBox("First select a property to delete")
+
+ def OnReserved(self, event):
+ pass
+
+ def OnSetPropertyValues(self,event):
+ try:
+ d = self.pg.GetPropertyValues(inc_attributes=True)
+
+ ss = []
+ for k,v in d.iteritems():
+ v = repr(v)
+ if not v or v[0] != '<':
+ if k.startswith('@'):
+ ss.append('setattr(obj, "%s", %s)'%(k,v))
+ else:
+ ss.append('obj.%s = %s'%(k,v))
+
+ dlg = MemoDialog(self,
+ "Enter Content for Object Used in SetPropertyValues",
+ '\n'.join(ss)) # default_object_content1
+
+ if dlg.ShowModal() == wx.ID_OK:
+ import datetime
+ sandbox = {'obj':ValueObject(),
+ 'wx':wx,
+ 'datetime':datetime}
+ exec dlg.tc.GetValue() in sandbox
+ t_start = time.time()
+ #print(sandbox['obj'].__dict__)
+ self.pg.SetPropertyValues(sandbox['obj'])
+ t_end = time.time()
+ self.log.write('SetPropertyValues finished in %.0fms\n' %
+ ((t_end-t_start)*1000.0))
+ except:
+ import traceback
+ traceback.print_exc()
+
+ def OnGetPropertyValues(self,event):
+ try:
+ t_start = time.time()
+ d = self.pg.GetPropertyValues(inc_attributes=True)
+ t_end = time.time()
+ self.log.write('GetPropertyValues finished in %.0fms\n' %
+ ((t_end-t_start)*1000.0))
+ ss = ['%s: %s'%(k,repr(v)) for k,v in d.iteritems()]
+ dlg = MemoDialog(self,"GetPropertyValues Result",
+ 'Contents of resulting dictionary:\n\n'+'\n'.join(ss))
+ dlg.ShowModal()
+ except:
+ import traceback
+ traceback.print_exc()
+
+ def OnGetPropertyValues2(self,event):
+ try:
+ t_start = time.time()
+ d = self.pg.GetPropertyValues(as_strings=True)
+ t_end = time.time()
+ self.log.write('GetPropertyValues(as_strings=True) finished in %.0fms\n' %
+ ((t_end-t_start)*1000.0))
+ ss = ['%s: %s'%(k,repr(v)) for k,v in d.iteritems()]
+ dlg = MemoDialog(self,"GetPropertyValues Result",
+ 'Contents of resulting dictionary:\n\n'+'\n'.join(ss))
+ dlg.ShowModal()
+ except:
+ import traceback
+ traceback.print_exc()
+
+ def OnAutoFill(self,event):
+ try:
+ dlg = MemoDialog(self,"Enter Content for Object Used for AutoFill",default_object_content1)
+ if dlg.ShowModal() == wx.ID_OK:
+ sandbox = {'object':ValueObject(),'wx':wx}
+ exec dlg.tc.GetValue() in sandbox
+ t_start = time.time()
+ self.pg.AutoFill(sandbox['object'])
+ t_end = time.time()
+ self.log.write('AutoFill finished in %.0fms\n' %
+ ((t_end-t_start)*1000.0))
+ except:
+ import traceback
+ traceback.print_exc()
+
+ def OnPropGridRightClick(self, event):
+ p = event.GetProperty()
+ if p:
+ self.log.write('%s right clicked\n' % (event.GetProperty().GetName()))
+ else:
+ self.log.write('Nothing right clicked\n')
+
+ def OnPropGridPageChange(self, event):
+ index = self.pg.GetSelectedPage()
+ self.log.write('Page Changed to \'%s\'\n' % (self.pg.GetPageName(index)))
+
+ def RunTests(self, event):
+ pg = self.pg
+ log = self.log
+
+ # Validate client data
+ log.write('Testing client data set/get')
+ pg.SetPropertyClientData( "Bool", 1234 )
+ if pg.GetPropertyClientData( "Bool" ) != 1234:
+ raise ValueError("Set/GetPropertyClientData() failed")
+
+ # Test setting unicode string
+ log.write('Testing setting an unicode string value')
+ pg.GetPropertyByName("String").SetValue(u"Some Unicode Text")
+
+ #
+ # Test some code that *should* fail (but not crash)
+ try:
+ if wx.GetApp().GetAssertionMode() == wx.PYAPP_ASSERT_EXCEPTION:
+ log.write('Testing exception handling compliancy')
+ a_ = pg.GetPropertyValue( "NotARealProperty" )
+ pg.EnableProperty( "NotAtAllRealProperty", False )
+ pg.SetPropertyHelpString("AgaintNotARealProperty",
+ "Dummy Help String" )
+ except:
+ pass
+
+ # GetPyIterator
+ log.write('GetPage(0).GetPyIterator()\n')
+ it = pg.GetPage(0).GetPyIterator(wxpg.PG_ITERATE_ALL)
+ for prop in it:
+ log.write('Iterating \'%s\'\n' % (prop.GetName()))
+
+ # VIterator
+ log.write('GetPyVIterator()\n')
+ it = pg.GetPyVIterator(wxpg.PG_ITERATE_ALL)
+ for prop in it:
+ log.write('Iterating \'%s\'\n' % (prop.GetName()))
+
+ # Properties
+ log.write('GetPage(0).Properties\n')
+ it = pg.GetPage(0).Properties
+ for prop in it:
+ log.write('Iterating \'%s\'\n' % (prop.GetName()))
+
+ # Items
+ log.write('GetPage(0).Items\n')
+ it = pg.GetPage(0).Items
+ for prop in it:
+ log.write('Iterating \'%s\'\n' % (prop.GetName()))
+
+#---------------------------------------------------------------------------
+
+
+class MemoDialog(wx.Dialog):
+ """\
+ Dialog for multi-line text editing.
+ """
+ def __init__(self,parent=None,title="",text="",pos=None,size=(500,500)):
+ wx.Dialog.__init__(self,parent,-1,title,style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER)
+
+ topsizer = wx.BoxSizer( wx.VERTICAL )
+
+ tc = wx.TextCtrl(self,11,text,style=wx.TE_MULTILINE)
+ self.tc = tc
+ topsizer.Add(tc,1,wx.EXPAND|wx.ALL,8)
+
+ rowsizer = wx.BoxSizer( wx.HORIZONTAL )
+ rowsizer.Add(wx.Button(self,wx.ID_OK,'Ok'),0,wx.ALIGN_RIGHT|wx.ALIGN_CENTRE_VERTICAL,8)
+ rowsizer.Add((0,0),1,wx.ALIGN_RIGHT|wx.ALIGN_CENTRE_VERTICAL,8)
+ rowsizer.Add(wx.Button(self,wx.ID_CANCEL,'Cancel'),0,wx.ALIGN_RIGHT|wx.ALIGN_CENTRE_VERTICAL,8)
+ topsizer.Add(rowsizer,0,wx.EXPAND|wx.ALL,8)
+
+ self.SetSizer( topsizer )
+ topsizer.Layout()
+
+ self.SetSize( size )
+ if not pos:
+ self.CenterOnScreen()
+ else:
+ self.Move(pos)
+
+#----------------------------------------------------------------------
+
+def runTest( frame, nb, log ):
+ win = TestPanel( nb, log )
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+
+
+This demo shows all basic wxPropertyGrid properties, in addition to
+some custom property classes.
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/PseudoDC.py b/demo/PseudoDC.py
new file mode 100644
index 00000000..15ef8da4
--- /dev/null
+++ b/demo/PseudoDC.py
@@ -0,0 +1,343 @@
+
+import wx
+import images
+import random
+
+#---------------------------------------------------------------------------
+
+W = 2000
+H = 2000
+SW = 150
+SH = 150
+SHAPE_COUNT = 2500
+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.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.OffsetXY(-(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 not self.pen_cache.has_key( (c, t) ):
+ self.pen_cache[(c, t)] = wx.Pen(c, t)
+ return self.pen_cache[(c, t)]
+
+
+ def RandomBrush(self):
+ c = random.choice(colours)
+ if not self.brush_cache.has_key(c):
+ 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)
+ # use PrepateDC to set position correctly
+ self.PrepareDC(dc)
+ # we need to clear the dc BEFORE calling PrepareDC
+ bg = wx.Brush(self.GetBackgroundColour())
+ dc.SetBackground(bg)
+ dc.Clear()
+ # 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 to the dc using the calculated clipping rect
+ self.pdc.DrawToDCClipped(dc,r)
+
+ def DoDrawing(self, dc):
+ random.seed()
+ self.objids = []
+ self.boundsdict = {}
+ dc.BeginDrawing()
+ for i in range(SHAPE_COUNT):
+ id = wx.NewId()
+ 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)
+ dc.EndDrawing()
+
+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 = """
+
+
+
wx.PseudoDC
+
+The wx.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:
+DrawToDC(dc)
+
+The operations can be tagged with an id in order to associated them with a
+specific object. To do this use:
+ SetId(id)
+
+Every operation after this will be associated with id until SetId is called
+again. The PseudoDC also supports object level clipping. To enable this use:
+ SetIdBounds(id,rect)
+
+for each object that should be clipped. Then use:
+ DrawToDCClipped(dc, clippingRect)
+
+To draw the PseudoDC to a real dc. This is useful for large scrolled windows
+where many objects are offscreen.
+
+Objects can be moved around without re-drawing using:
+ TranslateId(id, dx, dy)
+
+
+To re-draw an object use:
+ ClearId(id)
+ SetId(id)
+
+and then re-draw the object.
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/PyColourChooser.py b/demo/PyColourChooser.py
new file mode 100644
index 00000000..32921e15
--- /dev/null
+++ b/demo/PyColourChooser.py
@@ -0,0 +1,59 @@
+
+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
+
+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:])
diff --git a/demo/PyCrust.py b/demo/PyCrust.py
new file mode 100644
index 00000000..3fd96ebe
--- /dev/null
+++ b/demo/PyCrust.py
@@ -0,0 +1,20 @@
+
+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:])
+
diff --git a/demo/PyPlot.py b/demo/PyPlot.py
new file mode 100644
index 00000000..84866f64
--- /dev/null
+++ b/demo/PyPlot.py
@@ -0,0 +1,144 @@
+
+import wx
+
+hadImportError = False
+try:
+ import wx.lib.plot
+except ImportError:
+ hadImportError = True
+
+
+################################################################\
+# Where's the code??? |
+# |
+# wx.lib.plot.py came with its own excellent demo built in, |
+# for testing purposes, but it serves quite well to demonstrate |
+# the code and classes within, so we are simply borrowing that |
+# code for the demo. Please load up wx.lib.plot.py for a review |
+# of the code itself. The demo/test is at the bottom of |
+# the file, as expected. |
+################################################################/
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Show the PyPlot sample", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ win = wx.lib.plot.TestFrame(self, -1, "PlotCanvas Demo")
+ win.Show()
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ if not hadImportError:
+ win = TestPanel(nb, log)
+ else:
+ from wx.lib.msgpanel import MessagePanel
+ win = MessagePanel(nb, """\
+This demo requires the Numeric or numarray module,
+which could not be imported. It probably is not installed
+(it's not part of the standard Python distribution). See the
+Python site (http://www.python.org) for information on
+downloading source or binaries.""",
+ 'Sorry', wx.ICON_WARNING)
+
+ return win
+
+
+#----------------------------------------------------------------------
+
+if hadImportError:
+ overview = ""
+else:
+ overview = """\
+
+
PyPlot
+
+This demo illustrates the features of the new PyPlot modules, found
+in wx.lib.plot.py. All methods and functions are documented clearly
+therein; only the overview is included here.
+
+
+PyPlot is an improvement over wxPlotCanvas, which is now deprecated.
+If you are using wxPlotCanvas now, please make plans to migrate in
+anticipation of the time that wxPlotCanvas disappears completely.
+
+
+The demo illustrates four different plot styles (with appropriate
+variations on fonts, etc, to show how flexible it is) as well as
+provides you with a means to tinker with all the features that
+come with the class itself.
+
+
+
File Menu
+
+
+
Page Setup
+
+
This allows you to set up how the plot will be printed. This
+ is built into the library itself.
+
+
Print Preview
+
+
As you might expect, this allows you to preview how the plot
+ will look when printed, in light of the page setup you may
+ have selected above.
+
+
Print
+
+
Surprise! It prints the current plot to your printer! :-)
+
+
Save Plot
+
+
That's right, the library even provides you with the means
+ to export the plotted data out to a graphics file. Several
+ formats are allowed for, basically any image class that
+ supports saving.
+
+
+
Plot Menu
+
+
+
Plot 1 ... Plot 5
+
+
Different data with different plot formats, including one empty
+ plot.
+
+
Enable Zoom
+
+
If Zoom is enabled, you can rubber-band select an area of the
+ plot to examine it in detail using the left mouse button. Right
+ mouse button zooms back out. This is automatically supported
+ by the library, all you have to do is turn it on.
+
+
Enable Grid
+
+
Plots can have different styles of grids, and and these grids can
+ be turned on or off as needed.
+
+
Enable Legend
+
+
Plot can have legends or not, the contents which are definable
+ by you.
+
+
+
+
+%s
+
+""" % wx.lib.plot.__doc__
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/PyShell.py b/demo/PyShell.py
new file mode 100644
index 00000000..0c9fa949
--- /dev/null
+++ b/demo/PyShell.py
@@ -0,0 +1,21 @@
+
+import wx.py as py
+
+#----------------------------------------------------------------------
+
+intro = 'Welcome To PyCrust %s - The Flakiest Python Shell' % py.version.VERSION
+
+def runTest(frame, nb, log):
+ win = py.shell.Shell(nb, -1, introText=intro)
+ return win
+
+#----------------------------------------------------------------------
+
+overview = py.shell.__doc__
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/PythonEvents.py b/demo/PythonEvents.py
new file mode 100644
index 00000000..b65a9183
--- /dev/null
+++ b/demo/PythonEvents.py
@@ -0,0 +1,108 @@
+
+import sys
+
+import wx
+
+#----------------------------------------------------------------------
+
+# This shows the new 'official' way to do custom events as derived
+# from the wxPython 2.5 migration guide.
+
+#######################################################\
+# *** Old and busted *** |
+# |
+# myEVT_BUTTON_CLICKPOS = wx.NewEventType() |
+# |
+# def EVT_BUTTON_CLICKPOS(win, id, func): |
+# win.Connect(id, -1, myEVT_BUTTON_CLICKPOS, func) |
+#######################################################/
+
+#############################\
+# *** The new Hottness *** |
+#############################/
+myEVT_BUTTON_CLICKPOS = wx.NewEventType()
+EVT_BUTTON_CLICKPOS = wx.PyEventBinder(myEVT_BUTTON_CLICKPOS, 1)
+
+#----------------------------------------------------------------------
+
+
+class MyEvent(wx.PyCommandEvent):
+ def __init__(self, evtType, id):
+ wx.PyCommandEvent.__init__(self, evtType, id)
+ self.myVal = None
+
+ #def __del__(self):
+ # print '__del__'
+ # wx.PyCommandEvent.__del__(self)
+
+ def SetMyVal(self, val):
+ self.myVal = val
+
+ def GetMyVal(self):
+ return self.myVal
+
+
+class MyButton(wx.Button):
+ def __init__(self, parent, id, txt, pos):
+ wx.Button.__init__(self, parent, id, txt, pos)
+ self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
+
+ def OnLeftDown(self, event):
+ pt = event.GetPosition()
+ evt = MyEvent(myEVT_BUTTON_CLICKPOS, self.GetId())
+ evt.SetMyVal(pt)
+ #print id(evt), sys.getrefcount(evt)
+ self.GetEventHandler().ProcessEvent(evt)
+ #print id(evt), sys.getrefcount(evt)
+ event.Skip()
+
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ b = MyButton(self, -1, " Click me ", (30,30))
+ self.Bind(wx.EVT_BUTTON, self.OnClick, id=b.GetId())
+
+ # This is our custom event binder created above.
+ self.Bind(EVT_BUTTON_CLICKPOS, self.OnMyEvent, id=b.GetId())
+
+ wx.StaticText(
+ self, -1, "Please see the Overview and Demo Code for details...",
+ (30, 80)
+ )
+
+
+ def OnClick(self, event):
+ self.log.WriteText("OnClick\n")
+
+ def OnMyEvent(self, event):
+ #print id(event), sys.getrefcount(event)
+ self.log.WriteText("MyEvent: %s\n" % (event.GetMyVal(), ) )
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+This demo is a contrived example of defining an event class in wxPython and
+sending it up the containment hierarchy for processing.
+
+V2.5 note: this demo also shows the new style of creating event binders that
+is required if you used the *.Bind() method of setting up event handlers.
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/README.txt b/demo/README.txt
new file mode 100644
index 00000000..c1f635e9
--- /dev/null
+++ b/demo/README.txt
@@ -0,0 +1,7 @@
+To run the main demo in this directory, execute demo.py. In other
+words, one of the following commands should do it:
+
+ demo.py
+ python demo.py
+ pythonw demo.py
+
diff --git a/demo/RadioBox.py b/demo/RadioBox.py
new file mode 100644
index 00000000..6f728dcc
--- /dev/null
+++ b/demo/RadioBox.py
@@ -0,0 +1,66 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestRadioBox(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+ #self.SetBackgroundColour(wx.BLUE)
+
+ sampleList = ['zero', 'one', 'two', 'three', 'four', 'five',
+ 'six', 'seven', 'eight']
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+
+ rb = wx.RadioBox(
+ self, -1, "wx.RadioBox", wx.DefaultPosition, wx.DefaultSize,
+ sampleList, 2, wx.RA_SPECIFY_COLS
+ )
+
+ self.Bind(wx.EVT_RADIOBOX, self.EvtRadioBox, rb)
+ #rb.SetBackgroundColour(wx.BLUE)
+ rb.SetToolTip(wx.ToolTip("This is a ToolTip!"))
+ #rb.SetLabel("wx.RadioBox")
+
+ sizer.Add(rb, 0, wx.ALL, 20)
+
+ rb = wx.RadioBox(
+ self, -1, "", wx.DefaultPosition, wx.DefaultSize,
+ sampleList, 3, wx.RA_SPECIFY_COLS | wx.NO_BORDER
+ )
+
+ self.Bind(wx.EVT_RADIOBOX, self.EvtRadioBox, rb)
+ rb.SetToolTip(wx.ToolTip("This box has no label"))
+
+ sizer.Add(rb, 0, wx.LEFT|wx.RIGHT|wx.BOTTOM, 20)
+
+ self.SetSizer(sizer)
+
+
+ def EvtRadioBox(self, event):
+ self.log.WriteText('EvtRadioBox: %d\n' % event.GetInt())
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestRadioBox(nb, log)
+ return win
+
+
+
+overview = """\
+A RadioBox is used to select one of a number of mutually exclusive
+choices. It is displayed as a vertical column or horizontal row of
+labelled buttons, surrounded by a box that can optionally have a
+label.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/RadioButton.py b/demo/RadioButton.py
new file mode 100644
index 00000000..b84e7e21
--- /dev/null
+++ b/demo/RadioButton.py
@@ -0,0 +1,126 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel( wx.Panel ):
+ def __init__( self, parent, log ):
+
+ wx.Panel.__init__( self, parent, -1 )
+ self.log = log
+ panel = wx.Panel( self, -1 )
+
+ # Layout controls on panel:
+ vs = wx.BoxSizer( wx.VERTICAL )
+
+ box1_title = wx.StaticBox( panel, -1, "Group 1" )
+ box1 = wx.StaticBoxSizer( box1_title, wx.VERTICAL )
+ grid1 = wx.FlexGridSizer( cols=2 )
+
+ # 1st group of controls:
+ self.group1_ctrls = []
+ radio1 = wx.RadioButton( panel, -1, " Radio1 ", style = wx.RB_GROUP )
+ radio2 = wx.RadioButton( panel, -1, " Radio2 " )
+ radio3 = wx.RadioButton( panel, -1, " Radio3 " )
+ text1 = wx.TextCtrl( panel, -1, "" )
+ text2 = wx.TextCtrl( panel, -1, "" )
+ text3 = wx.TextCtrl( panel, -1, "" )
+ self.group1_ctrls.append((radio1, text1))
+ self.group1_ctrls.append((radio2, text2))
+ self.group1_ctrls.append((radio3, text3))
+
+ for radio, text in self.group1_ctrls:
+ grid1.Add( radio, 0, wx.ALIGN_CENTRE|wx.LEFT|wx.RIGHT|wx.TOP, 5 )
+ grid1.Add( text, 0, wx.ALIGN_CENTRE|wx.LEFT|wx.RIGHT|wx.TOP, 5 )
+
+ box1.Add( grid1, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
+ vs.Add( box1, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
+
+ box2_title = wx.StaticBox( panel, -1, "Group 2" )
+ box2 = wx.StaticBoxSizer( box2_title, wx.VERTICAL )
+ grid2 = wx.FlexGridSizer( cols=2 )
+
+ # 2nd group of controls:
+ self.group2_ctrls = []
+ radio4 = wx.RadioButton( panel, -1, " Radio1 ", style = wx.RB_GROUP )
+ radio5 = wx.RadioButton( panel, -1, " Radio2 " )
+ radio6 = wx.RadioButton( panel, -1, " Radio3 " )
+ text4 = wx.TextCtrl( panel, -1, "" )
+ text5 = wx.TextCtrl( panel, -1, "" )
+ text6 = wx.TextCtrl( panel, -1, "" )
+ self.group2_ctrls.append((radio4, text4))
+ self.group2_ctrls.append((radio5, text5))
+ self.group2_ctrls.append((radio6, text6))
+
+ for radio, text in self.group2_ctrls:
+ grid2.Add( radio, 0, wx.ALIGN_CENTRE|wx.LEFT|wx.RIGHT|wx.TOP, 5 )
+ grid2.Add( text, 0, wx.ALIGN_CENTRE|wx.LEFT|wx.RIGHT|wx.TOP, 5 )
+
+ box2.Add( grid2, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
+ vs.Add( box2, 0, wx.ALIGN_CENTRE|wx.ALL, 5 )
+
+ panel.SetSizer( vs )
+ vs.Fit( panel )
+ panel.Move( (50,50) )
+ self.panel = panel
+
+ # Setup event handling and initial state for controls:
+ for radio, text in self.group1_ctrls:
+ self.Bind(wx.EVT_RADIOBUTTON, self.OnGroup1Select, radio )
+
+ for radio, text in self.group2_ctrls:
+ self.Bind(wx.EVT_RADIOBUTTON, self.OnGroup2Select, radio )
+
+ for radio, text in self.group1_ctrls + self.group2_ctrls:
+ radio.SetValue(0)
+ text.Enable(False)
+
+ def OnGroup1Select( self, event ):
+ radio_selected = event.GetEventObject()
+ self.log.write('Group1 %s selected\n' % radio_selected.GetLabel() )
+
+ for radio, text in self.group1_ctrls:
+ if radio is radio_selected:
+ text.Enable(True)
+ else:
+ text.Enable(False)
+
+ def OnGroup2Select( self, event ):
+ radio_selected = event.GetEventObject()
+ self.log.write('Group2 %s selected\n' % radio_selected.GetLabel() )
+
+ for radio, text in self.group2_ctrls:
+ if radio is radio_selected:
+ text.Enable(True)
+ else:
+ text.Enable(False)
+
+#----------------------------------------------------------------------
+
+def runTest( frame, nb, log ):
+ win = TestPanel( nb, log )
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+
+
+This demo shows how individual radio buttons can be used to build
+more complicated selection mechanisms...
+
+It uses 2 groups of wx.RadioButtons, where the groups are defined by
+instantiation. When a wx.RadioButton is created with the wx.RB_GROUP
+style, all subsequent wx.RadioButtons created without it are implicitly
+added to that group by the framework.
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/RawBitmapAccess.py b/demo/RawBitmapAccess.py
new file mode 100644
index 00000000..b4b6b768
--- /dev/null
+++ b/demo/RawBitmapAccess.py
@@ -0,0 +1,206 @@
+import wx
+
+# use the numpy code instead of the raw access code for comparison
+USE_NUMPY = False
+
+# time the execution of making a bitmap?
+TIMEIT = False
+
+# how big to make the bitmaps
+DIM = 100
+
+# should we use a wx.GraphicsContext for painting?
+TEST_GC = False
+
+#----------------------------------------------------------------------
+# attempt to import a numeric module if requested to
+
+if USE_NUMPY:
+ try:
+ import numpy
+ def makeByteArray(shape):
+ return numpy.empty(shape, numpy.uint8)
+ numtype = 'numpy'
+ except ImportError:
+ try:
+ import numarray
+ def makeByteArray(shape):
+ arr = numarray.array(shape=shape, typecode='u1')
+ arr[:] = 0
+ return arr
+ numtype = 'numarray'
+ except ImportError:
+ USE_NUMPY = False
+
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+ if TIMEIT:
+ import timeit
+ timeit.s = self # Put self in timeit's global namespace as
+ # 's' so it can be found in the code
+ # snippets being tested.
+ if not USE_NUMPY:
+ t = timeit.Timer("bmp = s.MakeBitmap(10, 20, 30)")
+ else:
+ t = timeit.Timer("bmp = s.MakeBitmap2(10, 20, 30)")
+ log.write("Timing...\n")
+ num = 100
+ tm = t.timeit(num)
+ log.write("%d passes in %f seconds == %f seconds per pass " %
+ (num, tm, tm/num))
+
+ if not USE_NUMPY:
+ log.write("using raw access\n")
+ self.redBmp = self.MakeBitmap(178, 34, 34)
+ self.greenBmp = self.MakeBitmap( 35, 142, 35)
+ self.blueBmp = self.MakeBitmap( 0, 0, 139)
+ else:
+ log.write("using %s\n" % numtype)
+ self.redBmp = self.MakeBitmap2(178, 34, 34)
+ self.greenBmp = self.MakeBitmap2( 35, 142, 35)
+ self.blueBmp = self.MakeBitmap2( 0, 0, 139)
+
+
+ def OnPaint(self, evt):
+ dc = wx.PaintDC(self)
+ if not TEST_GC:
+ dc.DrawBitmap(self.redBmp, 50, 50, True)
+ dc.DrawBitmap(self.greenBmp, 110, 110, True)
+ dc.DrawBitmap(self.blueBmp, 170, 50, True)
+ self.log.write("using wx.DC\n")
+ else:
+ gc = wx.GraphicsContext.Create(dc)
+ gc.DrawBitmap(self.redBmp, 50, 50, DIM,DIM)
+ gc.DrawBitmap(self.greenBmp, 110, 110, DIM,DIM)
+ gc.DrawBitmap(self.blueBmp, 170, 50, DIM,DIM)
+ self.log.write("using wx.GraphicsContext\n")
+
+ def MakeBitmap(self, red, green, blue, alpha=128):
+ # Create the bitmap that we will stuff pixel values into using
+ # the raw bitmap access classes.
+ bmp = wx.EmptyBitmap(DIM, DIM, 32)
+
+ # Create an object that facilitates access to the bitmap's
+ # pixel buffer
+ pixelData = wx.AlphaPixelData(bmp)
+ if not pixelData:
+ raise RuntimeError("Failed to gain raw access to bitmap data.")
+
+ # We have two ways to access each pixel, first we'll use an
+ # iterator to set every pixel to the colour and alpha values
+ # passed in.
+ for pixel in pixelData:
+ pixel.Set(red, green, blue, alpha)
+
+ # This block of code is another way to do the same as above,
+ # but with the accessor interface instead of the Python
+ # iterator. It is a bit faster than the above because it
+ # avoids the iterator/generator magic, but it is not nearly as
+ # 'clean' looking ;-)
+ #pixels = pixelData.GetPixels()
+ #for y in xrange(DIM):
+ # pixels.MoveTo(pixelData, 0, y)
+ # for x in xrange(DIM):
+ # pixels.Set(red, green, blue, alpha)
+ # pixels.nextPixel()
+
+
+
+ # Next we'll use the pixel accessor to set the border pixels
+ # to be fully opaque
+ pixels = pixelData.GetPixels()
+ for x in xrange(DIM):
+ pixels.MoveTo(pixelData, x, 0)
+ pixels.Set(red, green, blue, wx.ALPHA_OPAQUE)
+ pixels.MoveTo(pixelData, x, DIM-1)
+ pixels.Set(red, green, blue, wx.ALPHA_OPAQUE)
+ for y in xrange(DIM):
+ pixels.MoveTo(pixelData, 0, y)
+ pixels.Set(red, green, blue, wx.ALPHA_OPAQUE)
+ pixels.MoveTo(pixelData, DIM-1, y)
+ pixels.Set(red, green, blue, wx.ALPHA_OPAQUE)
+
+ return bmp
+
+
+ def MakeBitmap2(self, red, green, blue, alpha=128):
+ # Make an array of bytes that is DIM*DIM in size, with enough
+ # slots for each pixel to have a RGB and A value
+ arr = makeByteArray( (DIM,DIM, 4) )
+
+ # just some indexes to keep track of which byte is which
+ R, G, B, A = range(4)
+
+ # initialize all pixel values to the values passed in
+ arr[:,:,R] = red
+ arr[:,:,G] = green
+ arr[:,:,B] = blue
+ arr[:,:,A] = alpha
+
+ # Set the alpha for the border pixels to be fully opaque
+ arr[0, 0:DIM, A] = wx.ALPHA_OPAQUE # first row
+ arr[DIM-1, 0:DIM, A] = wx.ALPHA_OPAQUE # last row
+ arr[0:DIM, 0, A] = wx.ALPHA_OPAQUE # first col
+ arr[0:DIM, DIM-1, A] = wx.ALPHA_OPAQUE # last col
+
+ # finally, use the array to create a bitmap
+ bmp = wx.BitmapFromBufferRGBA(DIM, DIM, arr)
+ return bmp
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
Raw Bitmap Access
+
+wx.NativePixelData and wx.AlphaPixelData provide a cross-platform way
+to access the platform-specific pixel buffer within a wx.Bitmap. They
+provide both a random access method, and an iterator interface.
+
+
Unfortunately, although these classes are convienient ways to access
+and update the contents of a wx.Bitmap, we lose most of the efficiency
+of the C++ classes by requiring one or more Python-to-C++ transitions
+for each pixel. In fact it can be much slower than the other
+ways of creating a bitmap from scratch, especially now that
+wx.BitmapFromBuffer exists and can save the time needed to copy from a
+wx.Image.
+
+
To see this difference for yourself this module has been
+instrumented to allow you to experiment with using either the raw
+access or numpy/numarray, and also to time how long it takes to create
+100 bitmaps like you see on the screen. Simply edit this module in
+the \"Demo Code\" tab and set TIMEIT to True and then watch
+the log window when the sample is reloaded. To try numpy or numarray
+(if you have them installed) then set USE_NUMPY to True as well, and
+watch the log window again. On my machines there is about an
+order of magnitude difference between the raw access functions
+and using a numarray.array with wx.BitmapFromBufferRGBA! Almost
+another order of magnitude improvement can be gained with using the
+new numpy module!
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/RendererNative.py b/demo/RendererNative.py
new file mode 100644
index 00000000..b0d94c4b
--- /dev/null
+++ b/demo/RendererNative.py
@@ -0,0 +1,156 @@
+import wx
+import os
+
+#----------------------------------------------------------------------
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent)
+
+ # Event Handlers
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+ def OnPaint(self, event):
+ dc = wx.GCDC(wx.PaintDC(self))
+ #dc = wx.PaintDC(self)
+ render = wx.RendererNative.Get()
+
+ # Setup Brushes
+ dc.SetBrush(wx.BLACK_BRUSH)
+ dc.SetTextForeground(wx.BLACK)
+ dc.SetFont(wx.NORMAL_FONT)
+
+ # The below code will use RendererNative to draw controls in
+ # various states. The wx.CONTROL_* flags are used to tell the
+ # Renderer which state to draw the control in.
+
+ # Draw some checkboxes
+ cb_lbl = "DrawCheckBoxes:"
+ dc.DrawText(cb_lbl, 15, 15)
+ render.DrawCheckBox(self, dc, (25, 35, 16, 16), wx.CONTROL_CHECKED)
+ render.DrawCheckBox(self, dc, (45, 35, 16, 16), wx.CONTROL_CHECKABLE)
+ render.DrawCheckBox(self, dc, (65, 35, 16, 16))
+ render.DrawCheckBox(self, dc, (85, 35, 16, 16), wx.CONTROL_CHECKED | wx.CONTROL_DISABLED)
+
+ lbl = "DrawRadioBitmap:"
+ dc.DrawText(lbl, 375, 15)
+ render.DrawRadioBitmap(self, dc, (385, 35, 16, 16), wx.CONTROL_CHECKED)
+ render.DrawRadioBitmap(self, dc, (405, 35, 16, 16), wx.CONTROL_CHECKABLE)
+ render.DrawRadioBitmap(self, dc, (425, 35, 16, 16))
+ render.DrawRadioBitmap(self, dc, (445, 35, 16, 16), wx.CONTROL_CHECKED | wx.CONTROL_DISABLED)
+
+ # Draw ComboBoxDropButton
+ xpos = self.GetTextExtent(cb_lbl)[0] + 40
+ cb_lbl = "DrawComboBoxDropButton:"
+ dc.DrawText(cb_lbl, xpos, 15)
+ render.DrawComboBoxDropButton(self, dc, (xpos + 4, 35, 24, 24), wx.CONTROL_CURRENT)
+ render.DrawComboBoxDropButton(self, dc, (xpos + 44, 35, 24, 24), wx.CONTROL_PRESSED)
+ render.DrawComboBoxDropButton(self, dc, (xpos + 84, 35, 24, 24), wx.CONTROL_CURRENT | wx.CONTROL_DISABLED)
+ render.DrawComboBoxDropButton(self, dc, (xpos + 124, 35, 24, 24), wx.CONTROL_PRESSED | wx.CONTROL_DISABLED)
+
+ # Draw DropArrow
+ da_lbl = "DrawDropArrow:"
+ dc.DrawText(da_lbl, 15, 80)
+ render.DrawDropArrow(self, dc, (15, 100, 24, 24), wx.CONTROL_CURRENT)
+ render.DrawDropArrow(self, dc, (35, 100, 24, 24), wx.CONTROL_PRESSED)
+ render.DrawDropArrow(self, dc, (55, 100, 24, 24), wx.CONTROL_CURRENT | wx.CONTROL_DISABLED)
+
+ # Draw HeaderButton
+ dc.DrawText("DrawHeaderButton:", xpos, 80)
+ # Set some extra options for drawing
+ opts = wx.HeaderButtonParams()
+ hb_lbl = "HeaderButton Selected"
+ opts.m_labelText = hb_lbl
+ render.DrawHeaderButton(self, dc, (xpos, 100, self.GetTextExtent(hb_lbl)[0] + 30, 16),
+ wx.CONTROL_SELECTED, wx.HDR_SORT_ICON_DOWN, opts)
+ hb_lbl = "HeaderButton Normal"
+ opts.m_labelText = hb_lbl
+ render.DrawHeaderButton(self, dc, (xpos, 125, self.GetTextExtent(hb_lbl)[0] + 30, 16),
+ sortArrow=wx.HDR_SORT_ICON_UP, params=opts)
+
+ hb_lbl = "HeaderButton Current"
+ opts.m_labelText = hb_lbl
+ render.DrawHeaderButton(self, dc, (xpos, 150, self.GetTextExtent(hb_lbl)[0] + 30, 16),
+ wx.CONTROL_CURRENT, params=opts)
+
+ # Draw ItemSelectionRect
+ isr_lbl = "DrawItemSelectionRect:"
+ dc.DrawText(isr_lbl, 15, 185)
+ render.DrawItemSelectionRect(self, dc, (15, 205, 40, 24), wx.CONTROL_SELECTED)
+ render.DrawItemSelectionRect(self, dc, (65, 205, 40, 24), wx.CONTROL_CURRENT)
+ render.DrawItemSelectionRect(self, dc, (115, 205, 40, 24), wx.CONTROL_FOCUSED)
+
+ # DrawPushButton
+ pb_lbl = "DrawPushButton:"
+ dc.DrawText(pb_lbl, 15, 255)
+ render.DrawPushButton(self, dc, (15, 275, 45, 24), wx.CONTROL_CURRENT)
+ render.DrawPushButton(self, dc, (70, 275, 45, 24), wx.CONTROL_PRESSED | wx.CONTROL_SELECTED)
+ render.DrawPushButton(self, dc, (125, 275, 45, 24), wx.CONTROL_ISDEFAULT)
+ render.DrawPushButton(self, dc, (180, 275, 45, 24), wx.CONTROL_CURRENT | wx.CONTROL_DISABLED)
+
+ # DrawTreeItemButton
+ ti_lbl = "DrawTreeItemButton:"
+ dc.DrawText(ti_lbl, 15, 330)
+ render.DrawTreeItemButton(self, dc, (15, 350, 16, 16))
+ render.DrawTreeItemButton(self, dc, (45, 350, 16, 16), wx.CONTROL_EXPANDED)
+
+ # DrawComboBox
+ dc.DrawText("DrawComboBox:", 270, 185)
+ render.DrawComboBox(self, dc, (270, 205, 100, 21))
+ render.DrawComboBox(self, dc, (270, 230, 100, 21), wx.CONTROL_DISABLED)
+ render.DrawComboBox(self, dc, (270, 255, 100, 21), wx.CONTROL_CURRENT)
+ render.DrawComboBox(self, dc, (270, 280, 100, 21), wx.CONTROL_PRESSED | wx.CONTROL_SELECTED)
+ render.DrawComboBox(self, dc, (270, 305, 100, 21), wx.CONTROL_FOCUSED)
+
+ # DrawChoice
+ dc.DrawText("DrawChoice:", 400, 185)
+ render.DrawChoice(self, dc, (400, 205, 100, 21))
+ render.DrawChoice(self, dc, (400, 230, 100, 21), wx.CONTROL_DISABLED)
+ render.DrawChoice(self, dc, (400, 255, 100, 21), wx.CONTROL_CURRENT)
+ render.DrawChoice(self, dc, (400, 280, 100, 21), wx.CONTROL_PRESSED | wx.CONTROL_SELECTED)
+ render.DrawChoice(self, dc, (400, 305, 100, 21), wx.CONTROL_FOCUSED)
+
+ # DrawTextCtrl
+ dc.DrawText("DrawTextCtrl:", 270, 350)
+ render.DrawTextCtrl(self, dc, (270, 375, 100, 21))
+ render.DrawTextCtrl(self, dc, (380, 375, 100, 21), wx.CONTROL_FOCUSED)
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+overview = """
+
wx.RendererNative
+
wx.RendererNative is a class which virtualizes drawing. It abstracts the
+operations of drawing controls and allows you to draw say, a button, without
+caring about exactly how it is done, in a native and platform independant way.
+
+
+
All drawing functions take some standard parameters:
+
+
win: is the window being drawn.
+
dc: is the wxDC to draw on. Only this device context should be used
+ for drawing.
+
rect: The bounding rectangle for the element to be drawn.
+
flags: The optional flags (none by default) which can be a
+ combination of the wx.CONTROL_XXX constants.
+
+
+
Note: Each drawing function restores the wxDC attributes if it
+changes them, so it is safe to assume that the same pen, brush and colours
+that were active before the call to this function are still in effect
+after it.
+
+"""
+
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/ResizeWidget.py b/demo/ResizeWidget.py
new file mode 100644
index 00000000..2f824230
--- /dev/null
+++ b/demo/ResizeWidget.py
@@ -0,0 +1,76 @@
+
+import wx
+import wx.lib.resizewidget as rw
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ rw1 = rw.ResizeWidget(self)
+ rw2 = rw.ResizeWidget(self)
+ self.rw2 = rw2
+
+ # This one we will reparent to the ResizeWidget...
+ tst = wx.Panel(self)
+ tst.SetBackgroundColour('pink')
+ wx.StaticText(tst, -1, "a panel,\nwith limits")
+ tst.SetMinSize((80,35))
+ tst.SetMaxSize((200,100))
+ rw1.SetManagedChild(tst)
+
+ # This one we will create as a child of the resizer to start with
+ lb = wx.ListBox(rw2, size=(100,70),
+ choices="zero one two three four five six seven eight nine".split())
+
+ # now make a sizer with a bunch of other widgets
+ fgs = wx.FlexGridSizer(cols=4, vgap=5, hgap=5)
+ for i in range(16):
+ if i == 5:
+ fgs.Add(rw1)
+ elif i == 10:
+ fgs.Add(rw2)
+ else:
+ fgs.Add(wx.Button(self))
+
+ self.Bind(wx.EVT_BUTTON, self.OnButton)
+
+ self.Sizer = wx.BoxSizer()
+ self.Sizer.Add(fgs, 0, wx.ALL, 10)
+
+ self.Bind(rw.EVT_RW_LAYOUT_NEEDED, self.OnLayoutNeeded)
+
+
+ def OnLayoutNeeded(self, evt):
+ self.Layout()
+
+
+ def OnButton(self, evt):
+ self.rw2.EnableResize(not self.rw2.IsResizeEnabled())
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
ResizeWidget
+
%s
+
+""" % rw.__doc__
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/RichTextCtrl.py b/demo/RichTextCtrl.py
new file mode 100644
index 00000000..d5bc40d1
--- /dev/null
+++ b/demo/RichTextCtrl.py
@@ -0,0 +1,730 @@
+
+import wx
+import wx.richtext as rt
+import images
+
+#----------------------------------------------------------------------
+
+class RichTextFrame(wx.Frame):
+ def __init__(self, *args, **kw):
+ wx.Frame.__init__(self, *args, **kw)
+
+ self.MakeMenuBar()
+ self.MakeToolBar()
+ self.CreateStatusBar()
+ self.SetStatusText("Welcome to wx.richtext.RichTextCtrl!")
+
+ self.rtc = rt.RichTextCtrl(self, style=wx.VSCROLL|wx.HSCROLL|wx.NO_BORDER);
+ wx.CallAfter(self.rtc.SetFocus)
+
+ self.rtc.Freeze()
+ self.rtc.BeginSuppressUndo()
+
+ self.rtc.BeginParagraphSpacing(0, 20)
+
+ self.rtc.BeginAlignment(wx.TEXT_ALIGNMENT_CENTRE)
+ self.rtc.BeginBold()
+
+ self.rtc.BeginFontSize(14)
+ self.rtc.WriteText("Welcome to wxRichTextCtrl, a wxWidgets control for editing and presenting styled text and images")
+ self.rtc.EndFontSize()
+ self.rtc.Newline()
+
+ self.rtc.BeginItalic()
+ self.rtc.WriteText("by Julian Smart")
+ self.rtc.EndItalic()
+
+ self.rtc.EndBold()
+
+ self.rtc.Newline()
+ self.rtc.WriteImage(images._rt_zebra.GetImage())
+
+ self.rtc.EndAlignment()
+
+ self.rtc.Newline()
+ self.rtc.Newline()
+
+ self.rtc.WriteText("What can you do with this thing? ")
+ self.rtc.WriteImage(images._rt_smiley.GetImage())
+ self.rtc.WriteText(" Well, you can change text ")
+
+ self.rtc.BeginTextColour((255, 0, 0))
+ self.rtc.WriteText("colour, like this red bit.")
+ self.rtc.EndTextColour()
+
+ self.rtc.BeginTextColour((0, 0, 255))
+ self.rtc.WriteText(" And this blue bit.")
+ self.rtc.EndTextColour()
+
+ self.rtc.WriteText(" Naturally you can make things ")
+ self.rtc.BeginBold()
+ self.rtc.WriteText("bold ")
+ self.rtc.EndBold()
+ self.rtc.BeginItalic()
+ self.rtc.WriteText("or italic ")
+ self.rtc.EndItalic()
+ self.rtc.BeginUnderline()
+ self.rtc.WriteText("or underlined.")
+ self.rtc.EndUnderline()
+
+ self.rtc.BeginFontSize(14)
+ self.rtc.WriteText(" Different font sizes on the same line is allowed, too.")
+ self.rtc.EndFontSize()
+
+ self.rtc.WriteText(" Next we'll show an indented paragraph.")
+
+ self.rtc.BeginLeftIndent(60)
+ self.rtc.Newline()
+
+ self.rtc.WriteText("It was in January, the most down-trodden month of an Edinburgh winter. An attractive woman came into the cafe, which is nothing remarkable.")
+ self.rtc.EndLeftIndent()
+
+ self.rtc.Newline()
+
+ self.rtc.WriteText("Next, we'll show a first-line indent, achieved using BeginLeftIndent(100, -40).")
+
+ self.rtc.BeginLeftIndent(100, -40)
+ self.rtc.Newline()
+
+ self.rtc.WriteText("It was in January, the most down-trodden month of an Edinburgh winter. An attractive woman came into the cafe, which is nothing remarkable.")
+ self.rtc.EndLeftIndent()
+
+ self.rtc.Newline()
+
+ self.rtc.WriteText("Numbered bullets are possible, again using sub-indents:")
+
+ self.rtc.BeginNumberedBullet(1, 100, 60)
+ self.rtc.Newline()
+
+ self.rtc.WriteText("This is my first item. Note that wxRichTextCtrl doesn't automatically do numbering, but this will be added later.")
+ self.rtc.EndNumberedBullet()
+
+ self.rtc.BeginNumberedBullet(2, 100, 60)
+ self.rtc.Newline()
+
+ self.rtc.WriteText("This is my second item.")
+ self.rtc.EndNumberedBullet()
+
+ self.rtc.Newline()
+
+ self.rtc.WriteText("The following paragraph is right-indented:")
+
+ self.rtc.BeginRightIndent(200)
+ self.rtc.Newline()
+
+ self.rtc.WriteText("It was in January, the most down-trodden month of an Edinburgh winter. An attractive woman came into the cafe, which is nothing remarkable.")
+ self.rtc.EndRightIndent()
+
+ self.rtc.Newline()
+
+ self.rtc.WriteText("The following paragraph is right-aligned with 1.5 line spacing:")
+
+ self.rtc.BeginAlignment(wx.TEXT_ALIGNMENT_RIGHT)
+ self.rtc.BeginLineSpacing(wx.TEXT_ATTR_LINE_SPACING_HALF)
+ self.rtc.Newline()
+
+ self.rtc.WriteText("It was in January, the most down-trodden month of an Edinburgh winter. An attractive woman came into the cafe, which is nothing remarkable.")
+ self.rtc.EndLineSpacing()
+ self.rtc.EndAlignment()
+
+ self.rtc.Newline()
+ self.rtc.WriteText("Other notable features of wxRichTextCtrl include:")
+
+ self.rtc.BeginSymbolBullet('*', 100, 60)
+ self.rtc.Newline()
+ self.rtc.WriteText("Compatibility with wxTextCtrl API")
+ self.rtc.EndSymbolBullet()
+
+ self.rtc.BeginSymbolBullet('*', 100, 60)
+ self.rtc.Newline()
+ self.rtc.WriteText("Easy stack-based BeginXXX()...EndXXX() style setting in addition to SetStyle()")
+ self.rtc.EndSymbolBullet()
+
+ self.rtc.BeginSymbolBullet('*', 100, 60)
+ self.rtc.Newline()
+ self.rtc.WriteText("XML loading and saving")
+ self.rtc.EndSymbolBullet()
+
+ self.rtc.BeginSymbolBullet('*', 100, 60)
+ self.rtc.Newline()
+ self.rtc.WriteText("Undo/Redo, with batching option and Undo suppressing")
+ self.rtc.EndSymbolBullet()
+
+ self.rtc.BeginSymbolBullet('*', 100, 60)
+ self.rtc.Newline()
+ self.rtc.WriteText("Clipboard copy and paste")
+ self.rtc.EndSymbolBullet()
+
+ self.rtc.BeginSymbolBullet('*', 100, 60)
+ self.rtc.Newline()
+ self.rtc.WriteText("wxRichTextStyleSheet with named character and paragraph styles, and control for applying named styles")
+ self.rtc.EndSymbolBullet()
+
+ self.rtc.BeginSymbolBullet('*', 100, 60)
+ self.rtc.Newline()
+ self.rtc.WriteText("A design that can easily be extended to other content types, ultimately with text boxes, tables, controls, and so on")
+ self.rtc.EndSymbolBullet()
+
+ self.rtc.Newline()
+
+ self.rtc.WriteText("Note: this sample content was generated programmatically from within the MyFrame constructor in the demo. The images were loaded from inline XPMs. Enjoy wxRichTextCtrl!")
+
+ self.rtc.Newline()
+ self.rtc.Newline()
+ self.rtc.BeginFontSize(12)
+ self.rtc.BeginBold()
+ self.rtc.WriteText("Additional comments by David Woods:")
+ self.rtc.EndBold()
+ self.rtc.EndFontSize()
+ self.rtc.Newline()
+ self.rtc.WriteText("I find some of the RichTextCtrl method names, as used above, to be misleading. Some character styles are stacked in the RichTextCtrl, and they are removed in the reverse order from how they are added, regardless of the method called. Allow me to demonstrate what I mean.")
+ self.rtc.Newline()
+
+ self.rtc.WriteText('Start with plain text. ')
+ self.rtc.BeginBold()
+ self.rtc.WriteText('BeginBold() makes it bold. ')
+ self.rtc.BeginItalic()
+ self.rtc.WriteText('BeginItalic() makes it bold-italic. ')
+ self.rtc.EndBold()
+ self.rtc.WriteText('EndBold() should make it italic but instead makes it bold. ')
+ self.rtc.EndItalic()
+ self.rtc.WriteText('EndItalic() takes us back to plain text. ')
+ self.rtc.Newline()
+
+ self.rtc.WriteText('Start with plain text. ')
+ self.rtc.BeginBold()
+ self.rtc.WriteText('BeginBold() makes it bold. ')
+ self.rtc.BeginUnderline()
+ self.rtc.WriteText('BeginUnderline() makes it bold-underline. ')
+ self.rtc.EndBold()
+ self.rtc.WriteText('EndBold() should make it underline but instead makes it bold. ')
+ self.rtc.EndUnderline()
+ self.rtc.WriteText('EndUnderline() takes us back to plain text. ')
+ self.rtc.Newline()
+
+ self.rtc.WriteText('According to Julian, this functions "as expected" because of the way the RichTextCtrl is written. I wrote the SetFontStyle() method here to demonstrate a way to work with overlapping styles that solves this problem.')
+ self.rtc.Newline()
+
+ # Create and initialize text attributes
+ self.textAttr = rt.RichTextAttr()
+ self.SetFontStyle(fontColor=wx.Colour(0, 0, 0), fontBgColor=wx.Colour(255, 255, 255), fontFace='Times New Roman', fontSize=10, fontBold=False, fontItalic=False, fontUnderline=False)
+ self.rtc.WriteText('Start with plain text. ')
+ self.SetFontStyle(fontBold=True)
+ self.rtc.WriteText('Bold. ')
+ self.SetFontStyle(fontItalic=True)
+ self.rtc.WriteText('Bold-italic. ')
+ self.SetFontStyle(fontBold=False)
+ self.rtc.WriteText('Italic. ')
+ self.SetFontStyle(fontItalic=False)
+ self.rtc.WriteText('Back to plain text. ')
+ self.rtc.Newline()
+
+ self.rtc.WriteText('Start with plain text. ')
+ self.SetFontStyle(fontBold=True)
+ self.rtc.WriteText('Bold. ')
+ self.SetFontStyle(fontUnderline=True)
+ self.rtc.WriteText('Bold-Underline. ')
+ self.SetFontStyle(fontBold=False)
+ self.rtc.WriteText('Underline. ')
+ self.SetFontStyle(fontUnderline=False)
+ self.rtc.WriteText('Back to plain text. ')
+ self.rtc.Newline()
+ self.rtc.EndParagraphSpacing()
+
+ self.rtc.EndSuppressUndo()
+ self.rtc.Thaw()
+
+
+ def SetFontStyle(self, fontColor = None, fontBgColor = None, fontFace = None, fontSize = None,
+ fontBold = None, fontItalic = None, fontUnderline = None):
+ if fontColor:
+ self.textAttr.SetTextColour(fontColor)
+ if fontBgColor:
+ self.textAttr.SetBackgroundColour(fontBgColor)
+ if fontFace:
+ self.textAttr.SetFontFaceName(fontFace)
+ if fontSize:
+ self.textAttr.SetFontSize(fontSize)
+ if fontBold != None:
+ if fontBold:
+ self.textAttr.SetFontWeight(wx.FONTWEIGHT_BOLD)
+ else:
+ self.textAttr.SetFontWeight(wx.FONTWEIGHT_NORMAL)
+ if fontItalic != None:
+ if fontItalic:
+ self.textAttr.SetFontStyle(wx.FONTSTYLE_ITALIC)
+ else:
+ self.textAttr.SetFontStyle(wx.FONTSTYLE_NORMAL)
+ if fontUnderline != None:
+ if fontUnderline:
+ self.textAttr.SetFontUnderlined(True)
+ else:
+ self.textAttr.SetFontUnderlined(False)
+ self.rtc.SetDefaultStyle(self.textAttr)
+
+ def OnURL(self, evt):
+ wx.MessageBox(evt.GetString(), "URL Clicked")
+
+
+ def OnFileOpen(self, evt):
+ # This gives us a string suitable for the file dialog based on
+ # the file handlers that are loaded
+ wildcard, types = rt.RichTextBuffer.GetExtWildcard(save=False)
+ dlg = wx.FileDialog(self, "Choose a filename",
+ wildcard=wildcard,
+ style=wx.OPEN)
+ if dlg.ShowModal() == wx.ID_OK:
+ path = dlg.GetPath()
+ if path:
+ fileType = types[dlg.GetFilterIndex()]
+ self.rtc.LoadFile(path, fileType)
+ dlg.Destroy()
+
+
+ def OnFileSave(self, evt):
+ if not self.rtc.GetFilename():
+ self.OnFileSaveAs(evt)
+ return
+ self.rtc.SaveFile()
+
+
+ def OnFileSaveAs(self, evt):
+ wildcard, types = rt.RichTextBuffer.GetExtWildcard(save=True)
+
+ dlg = wx.FileDialog(self, "Choose a filename",
+ wildcard=wildcard,
+ style=wx.SAVE)
+ if dlg.ShowModal() == wx.ID_OK:
+ path = dlg.GetPath()
+ if path:
+ fileType = types[dlg.GetFilterIndex()]
+ ext = rt.RichTextBuffer.FindHandlerByType(fileType).GetExtension()
+ if not path.endswith(ext):
+ path += '.' + ext
+ self.rtc.SaveFile(path, fileType)
+ dlg.Destroy()
+
+
+ def OnFileViewHTML(self, evt):
+ # Get an instance of the html file handler, use it to save the
+ # document to a StringIO stream, and then display the
+ # resulting html text in a dialog with a HtmlWindow.
+ handler = rt.RichTextHTMLHandler()
+ handler.SetFlags(rt.RICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY)
+ handler.SetFontSizeMapping([7,9,11,12,14,22,100])
+
+ import cStringIO
+ stream = cStringIO.StringIO()
+ if not handler.SaveStream(self.rtc.GetBuffer(), stream):
+ return
+
+ import wx.html
+ dlg = wx.Dialog(self, title="HTML", style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER)
+ html = wx.html.HtmlWindow(dlg, size=(500,400), style=wx.BORDER_SUNKEN)
+ html.SetPage(stream.getvalue())
+ btn = wx.Button(dlg, wx.ID_CANCEL)
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(html, 1, wx.ALL|wx.EXPAND, 5)
+ sizer.Add(btn, 0, wx.ALL|wx.CENTER, 10)
+ dlg.SetSizer(sizer)
+ sizer.Fit(dlg)
+
+ dlg.ShowModal()
+
+ handler.DeleteTemporaryImages()
+
+
+
+ def OnFileExit(self, evt):
+ self.Close(True)
+
+
+ def OnBold(self, evt):
+ self.rtc.ApplyBoldToSelection()
+
+ def OnItalic(self, evt):
+ self.rtc.ApplyItalicToSelection()
+
+ def OnUnderline(self, evt):
+ self.rtc.ApplyUnderlineToSelection()
+
+ def OnAlignLeft(self, evt):
+ self.rtc.ApplyAlignmentToSelection(wx.TEXT_ALIGNMENT_LEFT)
+
+ def OnAlignRight(self, evt):
+ self.rtc.ApplyAlignmentToSelection(wx.TEXT_ALIGNMENT_RIGHT)
+
+ def OnAlignCenter(self, evt):
+ self.rtc.ApplyAlignmentToSelection(wx.TEXT_ALIGNMENT_CENTRE)
+
+ def OnIndentMore(self, evt):
+ attr = wx.TextAttr()
+ attr.SetFlags(wx.TEXT_ATTR_LEFT_INDENT)
+ ip = self.rtc.GetInsertionPoint()
+ if self.rtc.GetStyle(ip, attr):
+ r = rt.RichTextRange(ip, ip)
+ if self.rtc.HasSelection():
+ r = self.rtc.GetSelectionRange()
+
+ attr.SetLeftIndent(attr.GetLeftIndent() + 100)
+ attr.SetFlags(wx.TEXT_ATTR_LEFT_INDENT)
+ self.rtc.SetStyle(r, attr)
+
+
+ def OnIndentLess(self, evt):
+ attr = wx.TextAttr()
+ attr.SetFlags(wx.TEXT_ATTR_LEFT_INDENT)
+ ip = self.rtc.GetInsertionPoint()
+ if self.rtc.GetStyle(ip, attr):
+ r = rt.RichTextRange(ip, ip)
+ if self.rtc.HasSelection():
+ r = self.rtc.GetSelectionRange()
+
+ if attr.GetLeftIndent() >= 100:
+ attr.SetLeftIndent(attr.GetLeftIndent() - 100)
+ attr.SetFlags(wx.TEXT_ATTR_LEFT_INDENT)
+ self.rtc.SetStyle(r, attr)
+
+
+ def OnParagraphSpacingMore(self, evt):
+ attr = wx.TextAttr()
+ attr.SetFlags(wx.TEXT_ATTR_PARA_SPACING_AFTER)
+ ip = self.rtc.GetInsertionPoint()
+ if self.rtc.GetStyle(ip, attr):
+ r = rt.RichTextRange(ip, ip)
+ if self.rtc.HasSelection():
+ r = self.rtc.GetSelectionRange()
+
+ attr.SetParagraphSpacingAfter(attr.GetParagraphSpacingAfter() + 20);
+ attr.SetFlags(wx.TEXT_ATTR_PARA_SPACING_AFTER)
+ self.rtc.SetStyle(r, attr)
+
+
+ def OnParagraphSpacingLess(self, evt):
+ attr = wx.TextAttr()
+ attr.SetFlags(wx.TEXT_ATTR_PARA_SPACING_AFTER)
+ ip = self.rtc.GetInsertionPoint()
+ if self.rtc.GetStyle(ip, attr):
+ r = rt.RichTextRange(ip, ip)
+ if self.rtc.HasSelection():
+ r = self.rtc.GetSelectionRange()
+
+ if attr.GetParagraphSpacingAfter() >= 20:
+ attr.SetParagraphSpacingAfter(attr.GetParagraphSpacingAfter() - 20);
+ attr.SetFlags(wx.TEXT_ATTR_PARA_SPACING_AFTER)
+ self.rtc.SetStyle(r, attr)
+
+
+ def OnLineSpacingSingle(self, evt):
+ attr = wx.TextAttr()
+ attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
+ ip = self.rtc.GetInsertionPoint()
+ if self.rtc.GetStyle(ip, attr):
+ r = rt.RichTextRange(ip, ip)
+ if self.rtc.HasSelection():
+ r = self.rtc.GetSelectionRange()
+
+ attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
+ attr.SetLineSpacing(10)
+ self.rtc.SetStyle(r, attr)
+
+
+ def OnLineSpacingHalf(self, evt):
+ attr = wx.TextAttr()
+ attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
+ ip = self.rtc.GetInsertionPoint()
+ if self.rtc.GetStyle(ip, attr):
+ r = rt.RichTextRange(ip, ip)
+ if self.rtc.HasSelection():
+ r = self.rtc.GetSelectionRange()
+
+ attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
+ attr.SetLineSpacing(15)
+ self.rtc.SetStyle(r, attr)
+
+
+ def OnLineSpacingDouble(self, evt):
+ attr = wx.TextAttr()
+ attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
+ ip = self.rtc.GetInsertionPoint()
+ if self.rtc.GetStyle(ip, attr):
+ r = rt.RichTextRange(ip, ip)
+ if self.rtc.HasSelection():
+ r = self.rtc.GetSelectionRange()
+
+ attr.SetFlags(wx.TEXT_ATTR_LINE_SPACING)
+ attr.SetLineSpacing(20)
+ self.rtc.SetStyle(r, attr)
+
+
+ def OnFont(self, evt):
+ if not self.rtc.HasSelection():
+ return
+
+ r = self.rtc.GetSelectionRange()
+ fontData = wx.FontData()
+ fontData.EnableEffects(False)
+ attr = wx.TextAttr()
+ attr.SetFlags(wx.TEXT_ATTR_FONT)
+ if self.rtc.GetStyle(self.rtc.GetInsertionPoint(), attr):
+ fontData.SetInitialFont(attr.GetFont())
+
+ dlg = wx.FontDialog(self, fontData)
+ if dlg.ShowModal() == wx.ID_OK:
+ fontData = dlg.GetFontData()
+ font = fontData.GetChosenFont()
+ if font:
+ attr.SetFlags(wx.TEXT_ATTR_FONT)
+ attr.SetFont(font)
+ self.rtc.SetStyle(r, attr)
+ dlg.Destroy()
+
+
+ def OnColour(self, evt):
+ colourData = wx.ColourData()
+ attr = wx.TextAttr()
+ attr.SetFlags(wx.TEXT_ATTR_TEXT_COLOUR)
+ if self.rtc.GetStyle(self.rtc.GetInsertionPoint(), attr):
+ colourData.SetColour(attr.GetTextColour())
+
+ dlg = wx.ColourDialog(self, colourData)
+ if dlg.ShowModal() == wx.ID_OK:
+ colourData = dlg.GetColourData()
+ colour = colourData.GetColour()
+ if colour:
+ if not self.rtc.HasSelection():
+ self.rtc.BeginTextColour(colour)
+ else:
+ r = self.rtc.GetSelectionRange()
+ attr.SetFlags(wx.TEXT_ATTR_TEXT_COLOUR)
+ attr.SetTextColour(colour)
+ self.rtc.SetStyle(r, attr)
+ dlg.Destroy()
+
+
+
+ def OnUpdateBold(self, evt):
+ evt.Check(self.rtc.IsSelectionBold())
+
+ def OnUpdateItalic(self, evt):
+ evt.Check(self.rtc.IsSelectionItalics())
+
+ def OnUpdateUnderline(self, evt):
+ evt.Check(self.rtc.IsSelectionUnderlined())
+
+ def OnUpdateAlignLeft(self, evt):
+ evt.Check(self.rtc.IsSelectionAligned(wx.TEXT_ALIGNMENT_LEFT))
+
+ def OnUpdateAlignCenter(self, evt):
+ evt.Check(self.rtc.IsSelectionAligned(wx.TEXT_ALIGNMENT_CENTRE))
+
+ def OnUpdateAlignRight(self, evt):
+ evt.Check(self.rtc.IsSelectionAligned(wx.TEXT_ALIGNMENT_RIGHT))
+
+
+ def ForwardEvent(self, evt):
+ # The RichTextCtrl can handle menu and update events for undo,
+ # redo, cut, copy, paste, delete, and select all, so just
+ # forward the event to it.
+ self.rtc.ProcessEvent(evt)
+
+
+ def MakeMenuBar(self):
+ def doBind(item, handler, updateUI=None):
+ self.Bind(wx.EVT_MENU, handler, item)
+ if updateUI is not None:
+ self.Bind(wx.EVT_UPDATE_UI, updateUI, item)
+
+ fileMenu = wx.Menu()
+ doBind( fileMenu.Append(-1, "&Open\tCtrl+O", "Open a file"),
+ self.OnFileOpen )
+ doBind( fileMenu.Append(-1, "&Save\tCtrl+S", "Save a file"),
+ self.OnFileSave )
+ doBind( fileMenu.Append(-1, "&Save As...\tF12", "Save to a new file"),
+ self.OnFileSaveAs )
+ fileMenu.AppendSeparator()
+ doBind( fileMenu.Append(-1, "&View as HTML", "View HTML"),
+ self.OnFileViewHTML)
+ fileMenu.AppendSeparator()
+ doBind( fileMenu.Append(-1, "E&xit\tCtrl+Q", "Quit this program"),
+ self.OnFileExit )
+
+ editMenu = wx.Menu()
+ doBind( editMenu.Append(wx.ID_UNDO, "&Undo\tCtrl+Z"),
+ self.ForwardEvent, self.ForwardEvent)
+ doBind( editMenu.Append(wx.ID_REDO, "&Redo\tCtrl+Y"),
+ self.ForwardEvent, self.ForwardEvent )
+ editMenu.AppendSeparator()
+ doBind( editMenu.Append(wx.ID_CUT, "Cu&t\tCtrl+X"),
+ self.ForwardEvent, self.ForwardEvent )
+ doBind( editMenu.Append(wx.ID_COPY, "&Copy\tCtrl+C"),
+ self.ForwardEvent, self.ForwardEvent)
+ doBind( editMenu.Append(wx.ID_PASTE, "&Paste\tCtrl+V"),
+ self.ForwardEvent, self.ForwardEvent)
+ doBind( editMenu.Append(wx.ID_CLEAR, "&Delete\tDel"),
+ self.ForwardEvent, self.ForwardEvent)
+ editMenu.AppendSeparator()
+ doBind( editMenu.Append(wx.ID_SELECTALL, "Select A&ll\tCtrl+A"),
+ self.ForwardEvent, self.ForwardEvent )
+
+ #doBind( editMenu.AppendSeparator(), )
+ #doBind( editMenu.Append(-1, "&Find...\tCtrl+F"), )
+ #doBind( editMenu.Append(-1, "&Replace...\tCtrl+R"), )
+
+ formatMenu = wx.Menu()
+ doBind( formatMenu.AppendCheckItem(-1, "&Bold\tCtrl+B"),
+ self.OnBold, self.OnUpdateBold)
+ doBind( formatMenu.AppendCheckItem(-1, "&Italic\tCtrl+I"),
+ self.OnItalic, self.OnUpdateItalic)
+ doBind( formatMenu.AppendCheckItem(-1, "&Underline\tCtrl+U"),
+ self.OnUnderline, self.OnUpdateUnderline)
+ formatMenu.AppendSeparator()
+ doBind( formatMenu.AppendCheckItem(-1, "L&eft Align"),
+ self.OnAlignLeft, self.OnUpdateAlignLeft)
+ doBind( formatMenu.AppendCheckItem(-1, "&Centre"),
+ self.OnAlignCenter, self.OnUpdateAlignCenter)
+ doBind( formatMenu.AppendCheckItem(-1, "&Right Align"),
+ self.OnAlignRight, self.OnUpdateAlignRight)
+ formatMenu.AppendSeparator()
+ doBind( formatMenu.Append(-1, "Indent &More"), self.OnIndentMore)
+ doBind( formatMenu.Append(-1, "Indent &Less"), self.OnIndentLess)
+ formatMenu.AppendSeparator()
+ doBind( formatMenu.Append(-1, "Increase Paragraph &Spacing"), self.OnParagraphSpacingMore)
+ doBind( formatMenu.Append(-1, "Decrease &Paragraph Spacing"), self.OnParagraphSpacingLess)
+ formatMenu.AppendSeparator()
+ doBind( formatMenu.Append(-1, "Normal Line Spacing"), self.OnLineSpacingSingle)
+ doBind( formatMenu.Append(-1, "1.5 Line Spacing"), self.OnLineSpacingHalf)
+ doBind( formatMenu.Append(-1, "Double Line Spacing"), self.OnLineSpacingDouble)
+ formatMenu.AppendSeparator()
+ doBind( formatMenu.Append(-1, "&Font..."), self.OnFont)
+
+ mb = wx.MenuBar()
+ mb.Append(fileMenu, "&File")
+ mb.Append(editMenu, "&Edit")
+ mb.Append(formatMenu, "F&ormat")
+ self.SetMenuBar(mb)
+
+
+ def MakeToolBar(self):
+ def doBind(item, handler, updateUI=None):
+ self.Bind(wx.EVT_TOOL, handler, item)
+ if updateUI is not None:
+ self.Bind(wx.EVT_UPDATE_UI, updateUI, item)
+
+ tbar = self.CreateToolBar()
+ doBind( tbar.AddTool(-1, images._rt_open.GetBitmap(),
+ shortHelpString="Open"), self.OnFileOpen)
+ doBind( tbar.AddTool(-1, images._rt_save.GetBitmap(),
+ shortHelpString="Save"), self.OnFileSave)
+ tbar.AddSeparator()
+ doBind( tbar.AddTool(wx.ID_CUT, images._rt_cut.GetBitmap(),
+ shortHelpString="Cut"), self.ForwardEvent, self.ForwardEvent)
+ doBind( tbar.AddTool(wx.ID_COPY, images._rt_copy.GetBitmap(),
+ shortHelpString="Copy"), self.ForwardEvent, self.ForwardEvent)
+ doBind( tbar.AddTool(wx.ID_PASTE, images._rt_paste.GetBitmap(),
+ shortHelpString="Paste"), self.ForwardEvent, self.ForwardEvent)
+ tbar.AddSeparator()
+ doBind( tbar.AddTool(wx.ID_UNDO, images._rt_undo.GetBitmap(),
+ shortHelpString="Undo"), self.ForwardEvent, self.ForwardEvent)
+ doBind( tbar.AddTool(wx.ID_REDO, images._rt_redo.GetBitmap(),
+ shortHelpString="Redo"), self.ForwardEvent, self.ForwardEvent)
+ tbar.AddSeparator()
+ doBind( tbar.AddTool(-1, images._rt_bold.GetBitmap(), isToggle=True,
+ shortHelpString="Bold"), self.OnBold, self.OnUpdateBold)
+ doBind( tbar.AddTool(-1, images._rt_italic.GetBitmap(), isToggle=True,
+ shortHelpString="Italic"), self.OnItalic, self.OnUpdateItalic)
+ doBind( tbar.AddTool(-1, images._rt_underline.GetBitmap(), isToggle=True,
+ shortHelpString="Underline"), self.OnUnderline, self.OnUpdateUnderline)
+ tbar.AddSeparator()
+ doBind( tbar.AddTool(-1, images._rt_alignleft.GetBitmap(), isToggle=True,
+ shortHelpString="Align Left"), self.OnAlignLeft, self.OnUpdateAlignLeft)
+ doBind( tbar.AddTool(-1, images._rt_centre.GetBitmap(), isToggle=True,
+ shortHelpString="Center"), self.OnAlignCenter, self.OnUpdateAlignCenter)
+ doBind( tbar.AddTool(-1, images._rt_alignright.GetBitmap(), isToggle=True,
+ shortHelpString="Align Right"), self.OnAlignRight, self.OnUpdateAlignRight)
+ tbar.AddSeparator()
+ doBind( tbar.AddTool(-1, images._rt_indentless.GetBitmap(),
+ shortHelpString="Indent Less"), self.OnIndentLess)
+ doBind( tbar.AddTool(-1, images._rt_indentmore.GetBitmap(),
+ shortHelpString="Indent More"), self.OnIndentMore)
+ tbar.AddSeparator()
+ doBind( tbar.AddTool(-1, images._rt_font.GetBitmap(),
+ shortHelpString="Font"), self.OnFont)
+ doBind( tbar.AddTool(-1, images._rt_colour.GetBitmap(),
+ shortHelpString="Font Colour"), self.OnColour)
+
+ tbar.Realize()
+
+
+
+#----------------------------------------------------------------------
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Show the RichTextCtrl sample", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+ self.AddRTCHandlers()
+
+
+ def AddRTCHandlers(self):
+ # make sure we haven't already added them.
+ if rt.RichTextBuffer.FindHandlerByType(rt.RICHTEXT_TYPE_HTML) is not None:
+ return
+
+ # This would normally go in your app's OnInit method. I'm
+ # not sure why these file handlers are not loaded by
+ # default by the C++ richtext code, I guess it's so you
+ # can change the name or extension if you wanted...
+ rt.RichTextBuffer.AddHandler(rt.RichTextHTMLHandler())
+ rt.RichTextBuffer.AddHandler(rt.RichTextXMLHandler())
+
+ # ...like this
+ rt.RichTextBuffer.AddHandler(rt.RichTextXMLHandler(name="Other XML",
+ ext="ox",
+ type=99))
+
+ # This is needed for the view as HTML option since we tell it
+ # to store the images in the memory file system.
+ wx.FileSystem.AddHandler(wx.MemoryFSHandler())
+
+
+ def OnButton(self, evt):
+ win = RichTextFrame(self, -1, "wx.richtext.RichTextCtrl",
+ size=(700, 500),
+ style = wx.DEFAULT_FRAME_STYLE)
+ win.Show(True)
+
+ # give easy access to the demo's PyShell if it's running
+ self.rtfrm = win
+ self.rtc = win.rtc
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.richtext.RichTextCtrl
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/RightTextCtrl.py b/demo/RightTextCtrl.py
new file mode 100644
index 00000000..c24da5c1
--- /dev/null
+++ b/demo/RightTextCtrl.py
@@ -0,0 +1,62 @@
+#####################################################################\
+# Note: This control is deprecated because wx.TextCtrl now supports |
+# the wx.TE_RIGHT style flag, which makes this control completely |
+# superfluous. |
+#####################################################################/
+
+import wx
+import wx.lib.rightalign as right
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent):
+ wx.Panel.__init__(self, parent, -1)
+
+ fgs = wx.FlexGridSizer(cols=2, vgap=5, hgap=5)
+
+ txt = wx.StaticText(
+ self, -1,
+ "These text controls will align their contents to\n"
+ "the right (on wxMSW) when they don't have focus.",
+ style=wx.ALIGN_RIGHT
+ )
+
+ fgs.Add(txt)
+ fgs.Add(right.RightTextCtrl(self, -1, "", size=(75, -1)))
+
+ fgs.Add((10,10))
+ fgs.Add(right.RightTextCtrl(self, -1, "123.45", size=(75, -1)))
+
+ fgs.Add((10,10))
+ fgs.Add(right.RightTextCtrl(self, -1, "234.56", size=(75, -1)))
+
+ fgs.Add((10,10))
+ fgs.Add(right.RightTextCtrl(self, -1, "345.67", size=(75, -1)))
+
+ fgs.Add((10,10))
+ fgs.Add(right.RightTextCtrl(self, -1, "456.78", size=(75, -1)))
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(fgs, 0, wx.ALL, 25)
+
+ self.SetSizer(sizer)
+ self.SetAutoLayout(True)
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb)
+ return win
+
+#----------------------------------------------------------------------
+
+overview = right.__doc__
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/RowColSizer.py b/demo/RowColSizer.py
new file mode 100644
index 00000000..d1fb3f56
--- /dev/null
+++ b/demo/RowColSizer.py
@@ -0,0 +1,92 @@
+
+import wx
+import wx.lib.rcsizer as rcs
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent):
+ wx.Panel.__init__(self, parent, -1)
+
+ sizer = rcs.RowColSizer()
+
+ text = "This sizer lays out it's items by row and column "\
+ "that are specified explicitly when the item is \n"\
+ "added to the sizer. Grid cells with nothing in "\
+ "them are supported and column- or row-spanning is \n"\
+ "handled as well. Growable rows and columns are "\
+ "specified just like the wxFlexGridSizer."
+
+ sizer.Add(wx.StaticText(self, -1, text), row=1, col=1, colspan=5)
+
+ sizer.Add(wx.TextCtrl(self, -1, "(3,1)"), flag=wx.EXPAND, row=3, col=1)
+ sizer.Add(wx.TextCtrl(self, -1, "(3,2)"), row=3, col=2)
+ sizer.Add(wx.TextCtrl(self, -1, "(3,3)"), row=3, col=3)
+ sizer.Add(wx.TextCtrl(self, -1, "(3,4)"), row=3, col=4)
+ sizer.Add(
+ wx.TextCtrl(self, -1, "(4,2) span:(2,2)"),
+ flag=wx.EXPAND, row=4, col=2, rowspan=2, colspan=2
+ )
+
+ sizer.Add(wx.TextCtrl(self, -1, "(6,4)"), row=6, col=4)
+ sizer.Add(wx.TextCtrl(self, -1, "(7,2)"), row=7, col=2)
+ sizer.Add(wx.TextCtrl(self, -1, "(8,3)"), row=8, col=3)
+ sizer.Add(
+ wx.TextCtrl(self, -1, "(10,1) colspan: 4"),
+ flag=wx.EXPAND, pos=(10,1), colspan=4
+ )
+
+ sizer.Add(
+ wx.TextCtrl(self, -1, "(3,5) rowspan: 8, growable col", style=wx.TE_MULTILINE),
+ flag=wx.EXPAND, pos=(3,5), size=(8,1)
+ )
+
+ box = wx.BoxSizer(wx.VERTICAL)
+ box.Add(wx.Button(self, -1, "A vertical box"), flag=wx.EXPAND)
+ box.Add(wx.Button(self, -1, "sizer put in the"), flag=wx.EXPAND)
+ box.Add(wx.Button(self, -1, "RowColSizer at (12,1)"), flag=wx.EXPAND)
+ sizer.Add(box, pos=(12,1))
+
+ sizer.Add(
+ wx.TextCtrl(self, -1, "(12,2) align bottom"),
+ flag=wx.ALIGN_BOTTOM, pos=(12,2)
+ )
+
+ sizer.Add(
+ wx.TextCtrl(self, -1, "(12,3) align center"),
+ flag=wx.ALIGN_CENTER_VERTICAL, pos=(12,3)
+ )
+
+ sizer.Add(wx.TextCtrl(self, -1, "(12,4)"),pos=(12,4))
+ sizer.Add(
+ wx.TextCtrl(self, -1, "(12,5) full border"),
+ flag=wx.EXPAND|wx.ALL, border=15, pos=(12,5)
+ )
+
+ sizer.AddGrowableCol(5)
+ sizer.AddGrowableRow(9)
+
+ sizer.AddSpacer(10,10, pos=(1,6))
+ sizer.AddSpacer(10,10, pos=(13,1))
+
+ self.SetSizer(sizer)
+ self.SetAutoLayout(True)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb)
+ return win
+
+
+#----------------------------------------------------------------------
+
+
+overview = rcs.__doc__
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/SashWindow.py b/demo/SashWindow.py
new file mode 100644
index 00000000..72b6357c
--- /dev/null
+++ b/demo/SashWindow.py
@@ -0,0 +1,149 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestSashWindow(wx.Panel):
+
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+
+ self.log = log
+ winids = []
+
+ # Create some layout windows
+ # A window like a toolbar
+ topwin = wx.SashLayoutWindow(
+ self, -1, wx.DefaultPosition, (200, 30),
+ wx.NO_BORDER|wx.SW_3D
+ )
+
+ topwin.SetDefaultSize((1000, 30))
+ topwin.SetOrientation(wx.LAYOUT_HORIZONTAL)
+ topwin.SetAlignment(wx.LAYOUT_TOP)
+ topwin.SetBackgroundColour(wx.Colour(255, 0, 0))
+ topwin.SetSashVisible(wx.SASH_BOTTOM, True)
+
+ self.topWindow = topwin
+ winids.append(topwin.GetId())
+
+ # A window like a statusbar
+ bottomwin = wx.SashLayoutWindow(
+ self, -1, wx.DefaultPosition, (200, 30),
+ wx.NO_BORDER|wx.SW_3D
+ )
+
+ bottomwin.SetDefaultSize((1000, 30))
+ bottomwin.SetOrientation(wx.LAYOUT_HORIZONTAL)
+ bottomwin.SetAlignment(wx.LAYOUT_BOTTOM)
+ bottomwin.SetBackgroundColour(wx.Colour(0, 0, 255))
+ bottomwin.SetSashVisible(wx.SASH_TOP, True)
+
+ self.bottomWindow = bottomwin
+ winids.append(bottomwin.GetId())
+
+ # A window to the left of the client window
+ leftwin1 = wx.SashLayoutWindow(
+ self, -1, wx.DefaultPosition, (200, 30),
+ wx.NO_BORDER|wx.SW_3D
+ )
+
+ leftwin1.SetDefaultSize((120, 1000))
+ leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
+ leftwin1.SetAlignment(wx.LAYOUT_LEFT)
+ leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
+ leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
+ leftwin1.SetExtraBorderSize(10)
+ textWindow = wx.TextCtrl(
+ leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,
+ wx.TE_MULTILINE|wx.SUNKEN_BORDER
+ )
+
+ textWindow.SetValue("A sub window")
+
+ self.leftWindow1 = leftwin1
+ winids.append(leftwin1.GetId())
+
+
+ # Another window to the left of the client window
+ leftwin2 = wx.SashLayoutWindow(
+ self, -1, wx.DefaultPosition, (200, 30),
+ wx.NO_BORDER|wx.SW_3D
+ )
+
+ leftwin2.SetDefaultSize((120, 1000))
+ leftwin2.SetOrientation(wx.LAYOUT_VERTICAL)
+ leftwin2.SetAlignment(wx.LAYOUT_LEFT)
+ leftwin2.SetBackgroundColour(wx.Colour(0, 255, 255))
+ leftwin2.SetSashVisible(wx.SASH_RIGHT, True)
+
+ self.leftWindow2 = leftwin2
+ winids.append(leftwin2.GetId())
+
+ # will occupy the space not used by the Layout Algorithm
+ self.remainingSpace = wx.Panel(self, -1, style=wx.SUNKEN_BORDER)
+
+ self.Bind(
+ wx.EVT_SASH_DRAGGED_RANGE, self.OnSashDrag,
+ id=min(winids), id2=max(winids)
+ )
+
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+
+
+ def OnSashDrag(self, event):
+ if event.GetDragStatus() == wx.SASH_STATUS_OUT_OF_RANGE:
+ self.log.write('drag is out of range')
+ return
+
+ eobj = event.GetEventObject()
+
+ if eobj is self.topWindow:
+ self.log.write('topwin received drag event')
+ self.topWindow.SetDefaultSize((1000, event.GetDragRect().height))
+
+ elif eobj is self.leftWindow1:
+ self.log.write('leftwin1 received drag event')
+ self.leftWindow1.SetDefaultSize((event.GetDragRect().width, 1000))
+
+
+ elif eobj is self.leftWindow2:
+ self.log.write('leftwin2 received drag event')
+ self.leftWindow2.SetDefaultSize((event.GetDragRect().width, 1000))
+
+ elif eobj is self.bottomWindow:
+ self.log.write('bottomwin received drag event')
+ self.bottomWindow.SetDefaultSize((1000, event.GetDragRect().height))
+
+ wx.LayoutAlgorithm().LayoutWindow(self, self.remainingSpace)
+ self.remainingSpace.Refresh()
+
+ def OnSize(self, event):
+ wx.LayoutAlgorithm().LayoutWindow(self, self.remainingSpace)
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestSashWindow(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+wx.SashLayoutWindow responds to OnCalculateLayout events generated by
+wxLayoutAlgorithm. It allows the application to use simple accessors to
+specify how the window should be laid out, rather than having to respond
+to events. The fact that the class derives from wx.SashWindow allows sashes
+to be used if required, to allow the windows to be user-resizable.
+
+The documentation for wx.LayoutAlgorithm explains the purpose of this class
+in more detail.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/ScrolledMessageDialog.py b/demo/ScrolledMessageDialog.py
new file mode 100644
index 00000000..8620a7b1
--- /dev/null
+++ b/demo/ScrolledMessageDialog.py
@@ -0,0 +1,53 @@
+
+import wx
+import wx.lib.dialogs
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show a ScrolledMessageDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ f = open("Main.py", "r")
+ msg = f.read()
+ f.close()
+
+ dlg = wx.lib.dialogs.ScrolledMessageDialog(self, msg, "message test")
+ dlg.ShowModal()
+
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+
+overview = """\
+
+ScrolledMessageDialog(parent, msg, caption, pos=wx.DefaultPosition, size=(500,300))
+
+This class represents a message dialog that uses a wxTextCtrl to display the
+message. This allows more flexible information display without having to be
+as much concerned with layout requirements. A text file can simply be used
+
+This dialog offers no special attributes or methods beyond those supported
+by wxDialog.
+
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/ScrolledPanel.py b/demo/ScrolledPanel.py
new file mode 100644
index 00000000..e5226cf7
--- /dev/null
+++ b/demo/ScrolledPanel.py
@@ -0,0 +1,123 @@
+
+import wx
+import wx.lib.scrolledpanel as scrolled
+
+#----------------------------------------------------------------------
+
+text = "one two buckle my shoe three four shut the door five six pick up sticks seven eight lay them straight nine ten big fat hen"
+
+
+class TestPanel(scrolled.ScrolledPanel):
+ def __init__(self, parent, log):
+ self.log = log
+ scrolled.ScrolledPanel.__init__(self, parent, -1)
+
+ vbox = wx.BoxSizer(wx.VERTICAL)
+ desc = wx.StaticText(self, -1,
+ "ScrolledPanel extends wx.ScrolledWindow, adding all "
+ "the necessary bits to set up scroll handling for you.\n\n"
+ "Here are three fixed size examples of its use. The "
+ "demo panel for this sample is also using it -- the \nwxStaticLine "
+ "below is intentionally made too long so a scrollbar will be "
+ "activated."
+ )
+ desc.SetForegroundColour("Blue")
+ vbox.Add(desc, 0, wx.ALIGN_LEFT|wx.ALL, 5)
+ vbox.Add(wx.StaticLine(self, -1, size=(1024,-1)), 0, wx.ALL, 5)
+ vbox.Add((20,20))
+
+ words = text.split()
+
+ panel1 = scrolled.ScrolledPanel(self, -1, size=(140, 300),
+ style = wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER, name="panel1" )
+ fgs1 = wx.FlexGridSizer(cols=2, vgap=4, hgap=4)
+
+ for word in words:
+ label = wx.StaticText(panel1, -1, word+":")
+
+ # A test for scrolling with a too big control
+ #if word == "three":
+ # tc = wx.TextCtrl(panel1, -1, word, size=(150,-1))
+ #else:
+ # tc = wx.TextCtrl(panel1, -1, word, size=(50,-1))
+
+ tc = wx.TextCtrl(panel1, -1, word, size=(50,-1))
+
+ fgs1.Add(label, flag=wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL | wx.LEFT, border=10)
+ fgs1.Add(tc, flag=wx.RIGHT, border=10)
+
+ panel1.SetSizer( fgs1 )
+ panel1.SetAutoLayout(1)
+ panel1.SetupScrolling()
+
+ panel2 = scrolled.ScrolledPanel(self, -1, size=(350, 50),
+ style = wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER, name="panel2")
+ panel3 = scrolled.ScrolledPanel(self, -1, size=(200,100),
+ style = wx.TAB_TRAVERSAL|wx.SUNKEN_BORDER, name="panel3")
+
+ fgs2 = wx.FlexGridSizer(cols=25, vgap=4, hgap=4)
+ fgs3 = wx.FlexGridSizer(cols=5, vgap=4, hgap=4)
+
+ for i in range(len(words)):
+ word = words[i]
+ if i % 5 != 4:
+ label2 = wx.StaticText(panel2, -1, word)
+ fgs2.Add(label2, flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL)
+ label3 = wx.StaticText(panel3, -1, word)
+ fgs3.Add(label3, flag=wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL)
+ else:
+ tc2 = wx.TextCtrl(panel2, -1, word, size=(50,-1))
+ fgs2.Add(tc2, flag=wx.LEFT, border=5)
+ tc3 = wx.TextCtrl(panel3, -1, word )
+ fgs3.Add(tc3, flag=wx.LEFT, border=5)
+
+ panel2.SetSizer( fgs2 )
+ panel2.SetAutoLayout(1)
+ panel2.SetupScrolling(scroll_y = False)
+
+ panel3.SetSizer( fgs3 )
+ panel3.SetAutoLayout(1)
+ panel3.SetupScrolling()
+
+ hbox = wx.BoxSizer(wx.HORIZONTAL)
+ hbox.Add((20,20))
+ hbox.Add(panel1, 0, wx.FIXED_MINSIZE)
+ hbox.Add((40, 10))
+
+ vbox2 = wx.BoxSizer(wx.VERTICAL)
+ vbox2.Add(panel2, 0, wx.FIXED_MINSIZE)
+ vbox2.Add((20, 50))
+
+ vbox2.Add(panel3, 0, wx.FIXED_MINSIZE)
+ vbox2.Add((20, 10))
+ hbox.Add(vbox2)
+
+ vbox.Add(hbox, 0)
+ self.SetSizer(vbox)
+ self.SetAutoLayout(1)
+ self.SetupScrolling()
+
+
+#----------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+ScrolledPanel fills a "hole" in the implementation of wx.ScrolledWindow,
+providing automatic scrollbar and scrolling behavior and the tab traversal
+mangement that wx.ScrolledWindow lacks.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/ScrolledWindow.py b/demo/ScrolledWindow.py
new file mode 100644
index 00000000..fcd1d74f
--- /dev/null
+++ b/demo/ScrolledWindow.py
@@ -0,0 +1,260 @@
+
+import wx
+import images
+
+# There are two different approaches to drawing, buffered or direct.
+# This sample shows both approaches so you can easily compare and
+# contrast the two by changing this value.
+BUFFERED = 1
+
+#---------------------------------------------------------------------------
+
+class MyCanvas(wx.ScrolledWindow):
+ def __init__(self, parent, id = -1, size = wx.DefaultSize):
+ wx.ScrolledWindow.__init__(self, parent, id, (0, 0), size=size, style=wx.SUNKEN_BORDER)
+
+ self.lines = []
+ self.maxWidth = 1000
+ self.maxHeight = 1000
+ self.x = self.y = 0
+ self.curLine = []
+ self.drawing = False
+
+ self.SetBackgroundColour("WHITE")
+ self.SetCursor(wx.StockCursor(wx.CURSOR_PENCIL))
+ 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)
+
+ if BUFFERED:
+ # Initialize the buffer bitmap. No real DC is needed at this point.
+ self.buffer = wx.EmptyBitmap(self.maxWidth, self.maxHeight)
+ dc = wx.BufferedDC(None, self.buffer)
+ dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
+ dc.Clear()
+ self.DoDrawing(dc)
+
+ self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftButtonEvent)
+ self.Bind(wx.EVT_LEFT_UP, self.OnLeftButtonEvent)
+ self.Bind(wx.EVT_MOTION, self.OnLeftButtonEvent)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+ def getWidth(self):
+ return self.maxWidth
+
+ def getHeight(self):
+ return self.maxHeight
+
+
+ def OnPaint(self, event):
+ if BUFFERED:
+ # Create a buffered paint DC. It will create the real
+ # wx.PaintDC and then blit the bitmap to it when dc is
+ # deleted. Since we don't need to draw anything else
+ # here that's all there is to it.
+ dc = wx.BufferedPaintDC(self, self.buffer, wx.BUFFER_VIRTUAL_AREA)
+ else:
+ dc = wx.PaintDC(self)
+ self.PrepareDC(dc)
+ # Since we're not buffering in this case, we have to
+ # (re)paint the all the contents of the window, which can
+ # be potentially time consuming and flickery depending on
+ # what is being drawn and how much of it there is.
+ self.DoDrawing(dc)
+
+
+ def DoDrawing(self, dc, printing=False):
+ dc.BeginDrawing()
+ dc.SetPen(wx.Pen('RED'))
+ dc.DrawRectangle(5, 5, 50, 50)
+
+ dc.SetBrush(wx.LIGHT_GREY_BRUSH)
+ dc.SetPen(wx.Pen('BLUE', 4))
+ dc.DrawRectangle(15, 15, 50, 50)
+
+ dc.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.NORMAL))
+ dc.SetTextForeground(wx.Colour(0xFF, 0x20, 0xFF))
+ te = dc.GetTextExtent("Hello World")
+ dc.DrawText("Hello World", 60, 65)
+
+ dc.SetPen(wx.Pen('VIOLET', 4))
+ dc.DrawLine(5, 65+te[1], 60+te[0], 65+te[1])
+
+ lst = [(100,110), (150,110), (150,160), (100,160)]
+ dc.DrawLines(lst, -60)
+ dc.SetPen(wx.GREY_PEN)
+ dc.DrawPolygon(lst, 75)
+ dc.SetPen(wx.GREEN_PEN)
+ dc.DrawSpline(lst+[(100,100)])
+
+ dc.DrawBitmap(self.bmp, 200, 20, True)
+ dc.SetTextForeground(wx.Colour(0, 0xFF, 0x80))
+ dc.DrawText("a bitmap", 200, 85)
+
+ font = wx.Font(20, wx.SWISS, wx.NORMAL, wx.NORMAL)
+ dc.SetFont(font)
+ dc.SetTextForeground(wx.BLACK)
+
+ for a in range(0, 360, 45):
+ dc.DrawRotatedText("Rotated text...", 300, 300, a)
+
+ dc.SetPen(wx.TRANSPARENT_PEN)
+ dc.SetBrush(wx.BLUE_BRUSH)
+ dc.DrawRectangle(50,500, 50,50)
+ dc.DrawRectangle(100,500, 50,50)
+
+ dc.SetPen(wx.Pen('RED'))
+ dc.DrawEllipticArc(200,500, 50,75, 0, 90)
+
+ if not printing:
+ # This has troubles when used on a print preview in wxGTK,
+ # probably something to do with the pen styles and the scaling
+ # it does...
+ y = 20
+
+ for style in [wx.DOT, wx.LONG_DASH, wx.SHORT_DASH, wx.DOT_DASH, wx.USER_DASH]:
+ pen = wx.Pen("DARK ORCHID", 1, style)
+ if style == wx.USER_DASH:
+ pen.SetCap(wx.CAP_BUTT)
+ pen.SetDashes([1,2])
+ pen.SetColour("RED")
+ dc.SetPen(pen)
+ dc.DrawLine(300,y, 400,y)
+ y = y + 10
+
+ dc.SetBrush(wx.TRANSPARENT_BRUSH)
+ dc.SetPen(wx.Pen(wx.Colour(0xFF, 0x20, 0xFF), 1, wx.SOLID))
+ dc.DrawRectangle(450,50, 100,100)
+ old_pen = dc.GetPen()
+ new_pen = wx.Pen("BLACK", 5)
+ dc.SetPen(new_pen)
+ dc.DrawRectangle(470,70, 60,60)
+ dc.SetPen(old_pen)
+ dc.DrawRectangle(490,90, 20,20)
+
+ dc.GradientFillLinear((20, 260, 50, 50),
+ "red", "blue")
+ dc.GradientFillConcentric((20, 325, 50, 50),
+ "red", "blue", (25,25))
+ self.DrawSavedLines(dc)
+ dc.EndDrawing()
+
+
+ def DrawSavedLines(self, dc):
+ dc.SetPen(wx.Pen('MEDIUM FOREST GREEN', 4))
+ for line in self.lines:
+ for coords in line:
+ apply(dc.DrawLine, coords)
+
+
+ def SetXY(self, event):
+ self.x, self.y = self.ConvertEventCoords(event)
+
+ def ConvertEventCoords(self, event):
+ newpos = self.CalcUnscrolledPosition(event.GetX(), event.GetY())
+ return newpos
+
+ def OnLeftButtonEvent(self, event):
+ if self.IsAutoScrolling():
+ self.StopAutoScrolling()
+
+ if event.LeftDown():
+ self.SetFocus()
+ self.SetXY(event)
+ self.curLine = []
+ self.CaptureMouse()
+ self.drawing = True
+
+ elif event.Dragging() and self.drawing:
+ if BUFFERED:
+ # If doing buffered drawing we'll just update the
+ # buffer here and then refresh that portion of the
+ # window. Then the system will send an event and that
+ # portion of the buffer will be redrawn in the
+ # EVT_PAINT handler.
+ dc = wx.BufferedDC(None, self.buffer)
+ else:
+ # otherwise we'll draw directly to a wx.ClientDC
+ dc = wx.ClientDC(self)
+ self.PrepareDC(dc)
+
+ dc.SetPen(wx.Pen('MEDIUM FOREST GREEN', 4))
+ coords = (self.x, self.y) + self.ConvertEventCoords(event)
+ self.curLine.append(coords)
+ dc.DrawLine(*coords)
+ self.SetXY(event)
+
+ if BUFFERED:
+ # figure out what part of the window to refresh, based
+ # on what parts of the buffer we just updated
+ x1,y1, x2,y2 = dc.GetBoundingBox()
+ x1,y1 = self.CalcScrolledPosition(x1, y1)
+ x2,y2 = self.CalcScrolledPosition(x2, y2)
+ # make a rectangle
+ rect = wx.Rect()
+ rect.SetTopLeft((x1,y1))
+ rect.SetBottomRight((x2,y2))
+ rect.Inflate(2,2)
+ # refresh it
+ self.RefreshRect(rect)
+
+ elif event.LeftUp() and self.drawing:
+ self.lines.append(self.curLine)
+ self.curLine = []
+ self.ReleaseMouse()
+ self.drawing = False
+
+
+## This is an example of what to do for the EVT_MOUSEWHEEL event,
+## but since wx.ScrolledWindow does this already it's not
+## necessary to do it ourselves. You would need to add an event table
+## entry to __init__() to direct wheelmouse events to this handler.
+
+## wheelScroll = 0
+## def OnWheel(self, evt):
+## delta = evt.GetWheelDelta()
+## rot = evt.GetWheelRotation()
+## linesPer = evt.GetLinesPerAction()
+## print delta, rot, linesPer
+## ws = self.wheelScroll
+## ws = ws + rot
+## lines = ws / delta
+## ws = ws - lines * delta
+## self.wheelScroll = ws
+## if lines != 0:
+## lines = lines * linesPer
+## vsx, vsy = self.GetViewStart()
+## scrollTo = vsy - lines
+## self.Scroll(-1, scrollTo)
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = MyCanvas(nb)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+
+overview = """
+
+
+The wx.ScrolledWindow class manages scrolling for its client area, transforming the
+coordinates according to the scrollbar positions, and setting the scroll positions,
+thumb sizes and ranges according to the area in view.
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/SearchCtrl.py b/demo/SearchCtrl.py
new file mode 100644
index 00000000..8776ea85
--- /dev/null
+++ b/demo/SearchCtrl.py
@@ -0,0 +1,106 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent)
+
+ # Create controls
+ sb = wx.StaticBox(self, -1, "Options")
+ searchBtnOpt = wx.CheckBox(self, -1, "Search button")
+ searchBtnOpt.SetValue(True)
+ cancelBtnOpt = wx.CheckBox(self, -1, "Cancel button")
+ menuBtnOpt = wx.CheckBox(self, -1, "Search menu")
+
+ self.search = wx.SearchCtrl(self, size=(200,-1), style=wx.TE_PROCESS_ENTER)
+
+ # Setup the layout
+ box = wx.StaticBoxSizer(sb, wx.VERTICAL)
+ box.Add(searchBtnOpt, 0, wx.ALL, 5)
+ box.Add(cancelBtnOpt, 0, wx.ALL, 5)
+ box.Add(menuBtnOpt, 0, wx.ALL, 5)
+
+ sizer = wx.BoxSizer(wx.HORIZONTAL)
+ sizer.Add(box, 0, wx.ALL, 15)
+ sizer.Add((15,15))
+ sizer.Add(self.search, 0, wx.ALL, 15)
+
+## self.tc = wx.TextCtrl(self) # just for testing that heights match...
+## sizer.Add(self.tc, 0, wx.TOP, 15)
+
+ self.SetSizer(sizer)
+
+
+ # Set event bindings
+ self.Bind(wx.EVT_CHECKBOX, self.OnToggleSearchButton, searchBtnOpt)
+ self.Bind(wx.EVT_CHECKBOX, self.OnToggleCancelButton, cancelBtnOpt)
+ self.Bind(wx.EVT_CHECKBOX, self.OnToggleSearchMenu, menuBtnOpt)
+
+ self.Bind(wx.EVT_SEARCHCTRL_SEARCH_BTN, self.OnSearch, self.search)
+ self.Bind(wx.EVT_SEARCHCTRL_CANCEL_BTN, self.OnCancel, self.search)
+ self.Bind(wx.EVT_TEXT_ENTER, self.OnDoSearch, self.search)
+ ##self.Bind(wx.EVT_TEXT, self.OnDoSearch, self.search)
+
+
+ def OnToggleSearchButton(self, evt):
+ self.search.ShowSearchButton( evt.GetInt() )
+
+ def OnToggleCancelButton(self, evt):
+ self.search.ShowCancelButton( evt.GetInt() )
+
+ def OnToggleSearchMenu(self, evt):
+ if evt.GetInt():
+ self.search.SetMenu( self.MakeMenu() )
+ else:
+ self.search.SetMenu(None)
+
+
+ def OnSearch(self, evt):
+ self.log.write("OnSearch")
+
+ def OnCancel(self, evt):
+ self.log.write("OnCancel")
+
+ def OnDoSearch(self, evt):
+ self.log.write("OnDoSearch: " + self.search.GetValue())
+
+
+ def MakeMenu(self):
+ menu = wx.Menu()
+ item = menu.Append(-1, "Recent Searches")
+ item.Enable(False)
+ for txt in [ "You can maintain",
+ "a list of old",
+ "search strings here",
+ "and bind EVT_MENU to",
+ "catch their selections" ]:
+ menu.Append(-1, txt)
+ return menu
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.SearchCtrl
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/ShapedWindow.py b/demo/ShapedWindow.py
new file mode 100644
index 00000000..80983b1e
--- /dev/null
+++ b/demo/ShapedWindow.py
@@ -0,0 +1,136 @@
+
+import wx
+import images
+
+#----------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Frame.__init__(self, parent, -1, "Shaped Window",
+ style =
+ wx.FRAME_SHAPED
+ | wx.SIMPLE_BORDER
+ | wx.FRAME_NO_TASKBAR
+ | wx.STAY_ON_TOP
+ )
+
+ self.hasShape = False
+ self.delta = (0,0)
+
+ self.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)
+ self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
+ self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
+ self.Bind(wx.EVT_MOTION, self.OnMouseMove)
+ self.Bind(wx.EVT_RIGHT_UP, self.OnExit)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+ self.bmp = images.Vippi.GetBitmap()
+ w, h = self.bmp.GetWidth(), self.bmp.GetHeight()
+ self.SetClientSize( (w, h) )
+
+ if wx.Platform != "__WXMAC__":
+ # wxMac clips the tooltip to the window shape, YUCK!!!
+ self.SetToolTipString("Right-click to close the window\n"
+ "Double-click the image to set/unset the window shape")
+
+ if wx.Platform == "__WXGTK__":
+ # wxGTK requires that the window be created before you can
+ # set its shape, so delay the call to SetWindowShape until
+ # this event.
+ self.Bind(wx.EVT_WINDOW_CREATE, self.SetWindowShape)
+ else:
+ # On wxMSW and wxMac the window has already been created, so go for it.
+ self.SetWindowShape()
+
+ dc = wx.ClientDC(self)
+ dc.DrawBitmap(self.bmp, 0,0, True)
+
+
+ def SetWindowShape(self, *evt):
+ # Use the bitmap's mask to determine the region
+ r = wx.RegionFromBitmap(self.bmp)
+ self.hasShape = self.SetShape(r)
+
+
+ def OnDoubleClick(self, evt):
+ if self.hasShape:
+ self.SetShape(wx.Region())
+ self.hasShape = False
+ else:
+ self.SetWindowShape()
+
+
+ def OnPaint(self, evt):
+ dc = wx.PaintDC(self)
+ dc.DrawBitmap(self.bmp, 0,0, True)
+
+ def OnExit(self, evt):
+ self.Close()
+
+
+ def OnLeftDown(self, evt):
+ self.CaptureMouse()
+ x, y = self.ClientToScreen(evt.GetPosition())
+ originx, originy = self.GetPosition()
+ dx = x - originx
+ dy = y - originy
+ self.delta = ((dx, dy))
+
+
+ def OnLeftUp(self, evt):
+ if self.HasCapture():
+ self.ReleaseMouse()
+
+
+ def OnMouseMove(self, evt):
+ if evt.Dragging() and evt.LeftIsDown():
+ x, y = self.ClientToScreen(evt.GetPosition())
+ fp = (x - self.delta[0], y - self.delta[1])
+ self.Move(fp)
+
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Show the ShapedWindow 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):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
Shaped Window
+
+Top level windows now have a SetShape method that lets you set a
+non-rectangular shape for the window using a wxRegion. All pixels
+outside of the region will not be drawn and the window will not be
+sensitive to the mouse in those areas either.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/SingleChoiceDialog.py b/demo/SingleChoiceDialog.py
new file mode 100644
index 00000000..2317d7e3
--- /dev/null
+++ b/demo/SingleChoiceDialog.py
@@ -0,0 +1,55 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show a SingleChoiceDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ dlg = wx.SingleChoiceDialog(
+ self, 'Test Single Choice', 'The Caption',
+ ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight'],
+ wx.CHOICEDLG_STYLE
+ )
+
+ if dlg.ShowModal() == wx.ID_OK:
+ self.log.WriteText('You selected: %s\n' % dlg.GetStringSelection())
+
+ dlg.Destroy()
+
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+#---------------------------------------------------------------------------
+
+
+
+
+overview = """\
+This class represents a dialog that shows a list of strings, and allows the user
+to select one. Double-clicking on a list item is equivalent to single-clicking
+and then pressing OK.
+
+As with all dialogs, be sure to retrieve the information you need BEFORE you
+destroy the dialog.
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/SizedControls.py b/demo/SizedControls.py
new file mode 100644
index 00000000..d5f3c2fb
--- /dev/null
+++ b/demo/SizedControls.py
@@ -0,0 +1,400 @@
+import wx
+import wx.lib.sized_controls as sc
+
+overview = """\
+
Sized Controls
+SizedControls is an addon library that attempts to simplify the
+creation of sizer-based layouts. It adds the following classes:
+
+
SizedPanel
+
+This class automatically creates its own sizer (a vertical box sizer
+by default) and automatically adds its children to the sizer. You can
+change the SizedPanel's sizer type by calling
+panel.SetSizerType(\"type\", [args]), where valid types are
+\"horizontal\", \"vertical\", \"form\" (a 2-col flex grid sizer), and
+\"grid\". Args include \"cols\" and \"rows\" attributes for
+grids. This class also applies control borders that adhere to the
+native platform's Human Interface Guidelines (HIG) on Win, GTK and
+Mac.
+
+
SizedScrolledPanel
+
+This class automatically creates its own sizer (a vertical box sizer
+by default) and automatically adds its children to the sizer. You can
+change the SizedScrolledPanel's sizer type by calling
+panel.SetSizerType(\"type\", [args]), where valid types are
+\"horizontal\", \"vertical\", \"form\" (a 2-col flex grid sizer), and
+\"grid\". Args include \"cols\" and \"rows\" attributes for
+grids. This class also applies control borders that adhere to the
+native platform's Human Interface Guidelines (HIG) on Win, GTK and
+Mac.
+
+
SizedFrame and SizedDialog
+
+These classes automatically setup a SizedPanel which is appropriately
+positioned and given appropriate borders in accordance with the
+platform's HIGs.
+
+
Since controls are added to the parent's sizer upon creation, you
+don't need to use sizer.Add or even create sizers yourself. You just
+use SetSizerType() to change the sizer you want to use, and
+control.SetSizerProps() to change the sizer properties of the
+control. So as a result, code that used to look like this:
+
+
+
+and the latter example will adhere to HIG spacing guidelines on all platforms,
+unlike the former example. Please check the demos for more complete and sophisticated examples of SizedControls
+in action.
+
+
wx.Window.SetSizerProps Quick Reference
+
+
wx.Window.SetSizerProps(<props>)
+
+
+
+
+
Parameter
Values
Summary
+
+
+
+
expand
True/False
+
Whether or not the control should grow to fill free space if
+free space is available.
+
+
+
+
proportion
Number (typically 0-10)
+
How much of the free space the control should take up. Note that this value is
+relative to other controls, so a proportion of 2 means take up
+'twice as much' space as controls with a proportion of 1.
+
+
+
+
halign
"left", "center", "centre", "right"
+
Determines horizontal alignment of control.
+
+
+
+
valign
"top", "center", "centre", "bottom"
+
Determines vertical alignment of control.
+
+
+
+
border
Tuple: ([dirs], integer)
+
Specifies amount of border padding to apply to specified directions.
+Example: (["left", "right"], 6) would add six pixels to left and right borders.
+Note that, unfortunately,
+it is not currently possible to assign different border sizes to each direction.
+
+
+
+
minsize
One of the following string values: "fixed", "adjust"
+
Determines whether or not the minsize can be updated when the control's best size changes.
+
+
+
+"""
+
+class FormDialog(sc.SizedDialog):
+ def __init__(self, parent, id):
+ sc.SizedDialog.__init__(self, None, -1, "SizedForm Dialog",
+ style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)
+
+ pane = self.GetContentsPane()
+ pane.SetSizerType("form")
+
+ # row 1
+ wx.StaticText(pane, -1, "Name")
+ textCtrl = wx.TextCtrl(pane, -1, "Your name here")
+ textCtrl.SetSizerProps(expand=True)
+
+ # row 2
+ wx.StaticText(pane, -1, "Email")
+ emailCtrl = wx.TextCtrl(pane, -1, "")
+ emailCtrl.SetSizerProps(expand=True)
+
+ # row 3
+ wx.StaticText(pane, -1, "Gender")
+ wx.Choice(pane, -1, choices=["male", "female"])
+
+ # row 4
+ wx.StaticText(pane, -1, "State")
+ wx.TextCtrl(pane, -1, size=(60, -1)) # two chars for state
+
+ # row 5
+ wx.StaticText(pane, -1, "Title")
+
+ # here's how to add a 'nested sizer' using sized_controls
+ radioPane = sc.SizedPanel(pane, -1)
+ radioPane.SetSizerType("horizontal")
+ radioPane.SetSizerProps(expand=True)
+
+ # make these children of the radioPane to have them use
+ # the horizontal layout
+ wx.RadioButton(radioPane, -1, "Mr.")
+ wx.RadioButton(radioPane, -1, "Mrs.")
+ wx.RadioButton(radioPane, -1, "Dr.")
+ # end row 5
+
+ # add dialog buttons
+ self.SetButtonSizer(self.CreateStdDialogButtonSizer(wx.OK | wx.CANCEL))
+
+ # a little trick to make sure that you can't resize the dialog to
+ # less screen space than the controls need
+ self.Fit()
+ self.SetMinSize(self.GetSize())
+
+
+class ScrolledFormDialog(sc.SizedDialog):
+ def __init__(self, parent, id):
+ sc.SizedDialog.__init__(self, None, -1, "SizedForm Dialog with a scolled panel",
+ style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER,
+ size=wx.Size(-1, 220))
+
+ cPane = self.GetContentsPane()
+ pane = sc.SizedScrolledPanel(cPane, wx.ID_ANY)
+ pane.SetSizerProps(expand=True, proportion=1)
+ pane.SetSizerType("form")
+
+ # row 1
+ wx.StaticText(pane, -1, "Name")
+ textCtrl = wx.TextCtrl(pane, -1, "Your name here")
+ textCtrl.SetSizerProps(expand=True)
+
+ # row 2
+ wx.StaticText(pane, -1, "Email")
+ emailCtrl = wx.TextCtrl(pane, -1, "")
+ emailCtrl.SetSizerProps(expand=True)
+
+ # row 3
+ wx.StaticText(pane, -1, "Gender")
+ wx.Choice(pane, -1, choices=["male", "female"])
+
+ # row 4
+ wx.StaticText(pane, -1, "State")
+ wx.TextCtrl(pane, -1, size=(60, -1)) # two chars for state
+
+ # row 5
+ wx.StaticText(pane, -1, "Title")
+
+ # here's how to add a 'nested sizer' using sized_controls
+ radioPane = sc.SizedPanel(pane, -1)
+ radioPane.SetSizerType("horizontal")
+ radioPane.SetSizerProps(expand=True)
+
+ # make these children of the radioPane to have them use
+ # the horizontal layout
+ wx.RadioButton(radioPane, -1, "Mr.")
+ wx.RadioButton(radioPane, -1, "Mrs.")
+ wx.RadioButton(radioPane, -1, "Dr.")
+ # end row 5
+
+ # add dialog buttons
+ self.SetButtonSizer(self.CreateStdDialogButtonSizer(wx.OK | wx.CANCEL))
+
+
+class ErrorDialog(sc.SizedDialog):
+ def __init__(self, parent, id):
+ sc.SizedDialog.__init__(self, parent, id, "Error log viewer",
+ style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER)
+
+ # Always use self.GetContentsPane() - this ensures that your dialog
+ # automatically adheres to HIG spacing requirements on all platforms.
+ # pane here is a sc.SizedPanel with a vertical sizer layout. All children
+ # should be added to this pane, NOT to self.
+ pane = self.GetContentsPane()
+
+ # first row
+ self.listCtrl = wx.ListCtrl(pane, -1, size=(300, -1), style=wx.LC_REPORT)
+ self.listCtrl.SetSizerProps(expand=True, proportion=1)
+ self.ConfigureListCtrl()
+
+ # second row
+ self.lblDetails = wx.StaticText(pane, -1, "Error Details")
+
+ # third row
+ self.details = wx.TextCtrl(pane, -1, style=wx.TE_MULTILINE)
+ self.details.SetSizerProps(expand=True, proportion=1)
+
+ # final row
+ # since we want to use a custom button layout, we won't use the
+ # CreateStdDialogBtnSizer here, we'll just create our own panel with
+ # a horizontal layout and add the buttons to that.
+ btnpane = sc.SizedPanel(pane, -1)
+ btnpane.SetSizerType("horizontal")
+ btnpane.SetSizerProps(expand=True)
+
+ self.saveBtn = wx.Button(btnpane, wx.ID_SAVE)
+ spacer = sc.SizedPanel(btnpane, -1)
+ spacer.SetSizerProps(expand=True, proportion=1)
+
+ self.clearBtn = wx.Button(btnpane, -1, "Clear")
+
+ self.Fit()
+ self.SetMinSize(self.GetSize())
+
+ def ConfigureListCtrl(self):
+ self.listCtrl.InsertColumn(0, "Time")
+ self.listCtrl.InsertColumn(1, "Error Message")
+ self.listCtrl.SetColumnWidth(0, 100)
+ self.listCtrl.SetColumnWidth(1, 280)
+
+
+class GridFrame(sc.SizedFrame):
+ def __init__(self, parent, id):
+ sc.SizedFrame.__init__(self, parent, id, "Grid Layout Demo Frame")
+
+ pane = self.GetContentsPane()
+ pane.SetSizerType("grid", {"cols":3}) # 3-column grid layout
+
+ # row 1
+ wx.TextCtrl(pane, -1).SetSizerProps(halign="left")
+ wx.TextCtrl(pane, -1).SetSizerProps(halign="center")
+ wx.TextCtrl(pane, -1).SetSizerProps(halign="right")
+
+ # row 2
+ wx.TextCtrl(pane, -1).SetSizerProps(valign="center")
+ wx.TextCtrl(pane, -1).SetSizerProps(expand=True, proportion=1)
+ wx.TextCtrl(pane, -1).SetSizerProps(valign="center")
+
+ # row 3
+ wx.TextCtrl(pane, -1).SetSizerProps(halign="left")
+ wx.TextCtrl(pane, -1).SetSizerProps(halign="center")
+ wx.TextCtrl(pane, -1).SetSizerProps(halign="right")
+
+ self.CreateStatusBar() # should always do this when there's a resize border
+
+ self.Fit()
+ self.SetMinSize(self.GetSize())
+
+
+#---------------------------------------------------------------------------
+
+class TestPanel(sc.SizedScrolledPanel):
+ def __init__(self, parent, log):
+ self.log = log
+ self.parent = parent
+ sc.SizedScrolledPanel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Sized Controls Form Dialog")
+ b.SetSizerProps({'halign': 'center', 'border': ('all', 15)})
+ self.Bind(wx.EVT_BUTTON, self.OnFormButton, b)
+
+ b1 = wx.Button(self, -1, "Sized Controls Form Dialog with scrolled panel")
+ b1.SetSizerProps({'halign': 'center', 'border': ('all', 15)})
+ self.Bind(wx.EVT_BUTTON, self.OnFormScrolledButton, b1)
+
+ b2 = wx.Button(self, -1, "Sized Controls Error Dialog")
+ b2.SetSizerProps({'halign': 'center', 'border': ('all', 15)})
+ self.Bind(wx.EVT_BUTTON, self.OnErrorButton, b2)
+
+ b3 = wx.Button(self, -1, "Sized Controls Grid Layout Demo")
+ b3.SetSizerProps({'halign': 'center', 'border': ('all', 15)})
+ self.Bind(wx.EVT_BUTTON, self.OnGridButton, b3)
+
+
+ def OnFormButton(self, evt):
+
+ dlg = FormDialog(self, -1)
+ dlg.CenterOnScreen()
+
+ # this does not return until the dialog is closed.
+ val = dlg.ShowModal()
+
+ if val == wx.ID_OK:
+ self.log.WriteText("You pressed OK\n")
+ else:
+ self.log.WriteText("You pressed Cancel\n")
+
+ dlg.Destroy()
+
+ def OnFormScrolledButton(self, evt):
+
+ dlg = ScrolledFormDialog(self, -1)
+ dlg.CenterOnScreen()
+
+ # this does not return until the dialog is closed.
+ val = dlg.ShowModal()
+
+ if val == wx.ID_OK:
+ self.log.WriteText("You pressed OK\n")
+ else:
+ self.log.WriteText("You pressed Cancel\n")
+
+ dlg.Destroy()
+
+ def OnErrorButton(self, evt):
+
+ dlg = ErrorDialog(self, -1)
+ dlg.CenterOnScreen()
+
+ # this does not return until the dialog is closed.
+ val = dlg.ShowModal()
+
+ if val == wx.ID_OK:
+ self.log.WriteText("You pressed OK\n")
+ else:
+ self.log.WriteText("You pressed Cancel\n")
+
+ dlg.Destroy()
+
+ def OnGridButton(self, evt):
+
+ dlg = GridFrame(self, -1)
+ dlg.CenterOnScreen()
+
+ dlg.Show()
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Sizers.py b/demo/Sizers.py
new file mode 100644
index 00000000..1d79096a
--- /dev/null
+++ b/demo/Sizers.py
@@ -0,0 +1,601 @@
+# 11/26/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Had to do a bit of rework for the demo; there was no panel attached
+# to the demo window, so all buttons were showing as dark gray on
+# dark gray. I have no idea why this didn't break before. Robin,
+# please examine my changes to ensure you approve. It's rather
+# hackish looking.
+#
+
+#----------------------------------------------------------------------
+# sizer test code
+#----------------------------------------------------------------------
+
+import wx
+
+#----------------------------------------------------------------------
+
+class SampleWindow(wx.PyWindow):
+ """
+ A simple window that is used as sizer items in the tests below to
+ show how the various sizers work.
+ """
+ def __init__(self, parent, text, pos=wx.DefaultPosition, size=wx.DefaultSize):
+ wx.PyWindow.__init__(self, parent, -1,
+ #style=wx.RAISED_BORDER
+ #style=wx.SUNKEN_BORDER
+ style=wx.SIMPLE_BORDER
+ )
+ self.text = text
+ if size != wx.DefaultSize:
+ self.bestsize = size
+ else:
+ self.bestsize = (80,25)
+ self.SetSize(self.GetBestSize())
+
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ self.Bind(wx.EVT_LEFT_UP, self.OnCloseParent)
+
+
+ def OnPaint(self, evt):
+ sz = self.GetSize()
+ dc = wx.PaintDC(self)
+ w,h = dc.GetTextExtent(self.text)
+ dc.Clear()
+ dc.DrawText(self.text, (sz.width-w)/2, (sz.height-h)/2)
+
+ def OnSize(self, evt):
+ self.Refresh()
+
+ def OnCloseParent(self, evt):
+ p = wx.GetTopLevelParent(self)
+ if p:
+ p.Close()
+
+ def DoGetBestSize(self):
+ return self.bestsize
+
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox1(win):
+ box = wx.BoxSizer(wx.HORIZONTAL)
+ box.Add(SampleWindow(win, "one"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "two"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "three"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "four"), 0, wx.EXPAND)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox2(win):
+ box = wx.BoxSizer(wx.VERTICAL)
+ box.Add(SampleWindow(win, "one"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "two"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "three"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "four"), 0, wx.EXPAND)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox3(win):
+ box = wx.BoxSizer(wx.HORIZONTAL)
+ box.Add(SampleWindow(win, "one"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "two"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "three"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "four"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "five"), 1, wx.EXPAND)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox4(win):
+ box = wx.BoxSizer(wx.HORIZONTAL)
+ box.Add(SampleWindow(win, "one"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "two"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "three"), 1, wx.EXPAND)
+ box.Add(SampleWindow(win, "four"), 1, wx.EXPAND)
+ box.Add(SampleWindow(win, "five"), 1, wx.EXPAND)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox5(win):
+ box = wx.BoxSizer(wx.HORIZONTAL)
+ box.Add(SampleWindow(win, "one"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "two"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "three"), 3, wx.EXPAND)
+ box.Add(SampleWindow(win, "four"), 1, wx.EXPAND)
+ box.Add(SampleWindow(win, "five"), 1, wx.EXPAND)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox6(win):
+ box = wx.BoxSizer(wx.HORIZONTAL)
+ box.Add(SampleWindow(win, "one"), 1, wx.ALIGN_TOP)
+ box.Add(SampleWindow(win, "two"), 1, wx.EXPAND)
+ box.Add(SampleWindow(win, "three"), 1, wx.ALIGN_CENTER)
+ box.Add(SampleWindow(win, "four"), 1, wx.EXPAND)
+ box.Add(SampleWindow(win, "five"), 1, wx.ALIGN_BOTTOM)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox7(win):
+ box = wx.BoxSizer(wx.HORIZONTAL)
+ box.Add(SampleWindow(win, "one"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "two"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "three"), 0, wx.EXPAND)
+ box.Add((60, 20), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "five"), 1, wx.EXPAND)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeSimpleBox8(win):
+ box = wx.BoxSizer(wx.VERTICAL)
+ box.Add(SampleWindow(win, "one"), 0, wx.EXPAND)
+ box.Add((0,0), 1)
+ box.Add(SampleWindow(win, "two"), 0, wx.ALIGN_CENTER)
+ box.Add((0,0), 1)
+ box.Add(SampleWindow(win, "three"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "four"), 0, wx.EXPAND)
+# box.Add(SampleWindow(win, "five"), 1, wx.EXPAND)
+
+ return box
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+
+def makeSimpleBorder1(win):
+ bdr = wx.BoxSizer(wx.HORIZONTAL)
+ btn = SampleWindow(win, "border")
+ btn.SetSize((80, 80))
+ bdr.Add(btn, 1, wx.EXPAND|wx.ALL, 15)
+
+ return bdr
+
+#----------------------------------------------------------------------
+
+def makeSimpleBorder2(win):
+ bdr = wx.BoxSizer(wx.HORIZONTAL)
+ btn = SampleWindow(win, "border")
+ btn.SetSize((80, 80))
+ bdr.Add(btn, 1, wx.EXPAND | wx.EAST | wx.WEST, 15)
+
+ return bdr
+
+#----------------------------------------------------------------------
+
+def makeSimpleBorder3(win):
+ bdr = wx.BoxSizer(wx.HORIZONTAL)
+ btn = SampleWindow(win, "border")
+ btn.SetSize((80, 80))
+ bdr.Add(btn, 1, wx.EXPAND | wx.NORTH | wx.WEST, 15)
+
+ return bdr
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+
+def makeBoxInBox(win):
+ box = wx.BoxSizer(wx.VERTICAL)
+
+ box.Add(SampleWindow(win, "one"), 0, wx.EXPAND)
+
+ box2 = wx.BoxSizer(wx.HORIZONTAL)
+ box2.Add(SampleWindow(win, "two"), 0, wx.EXPAND)
+ btn3 = SampleWindow(win, "three")
+ box2.Add(btn3, 0, wx.EXPAND)
+ box2.Add(SampleWindow(win, "four"), 0, wx.EXPAND)
+ box2.Add(SampleWindow(win, "five"), 0, wx.EXPAND)
+
+ box3 = wx.BoxSizer(wx.VERTICAL)
+ box3.AddMany([ (SampleWindow(win, "six"), 0, wx.EXPAND),
+ (SampleWindow(win, "seven"), 2, wx.EXPAND),
+ (SampleWindow(win, "eight"), 1, wx.EXPAND),
+ (SampleWindow(win, "nine"), 1, wx.EXPAND),
+ ])
+
+ box2.Add(box3, 1, wx.EXPAND)
+ box.Add(box2, 1, wx.EXPAND)
+
+ box.Add(SampleWindow(win, "ten"), 0, wx.EXPAND)
+
+ ##box.Hide(btn3)
+
+ return box
+
+#----------------------------------------------------------------------
+
+def makeBoxInBorder(win):
+ bdr = wx.BoxSizer(wx.HORIZONTAL)
+ box = makeSimpleBox3(win)
+ bdr.Add(box, 1, wx.EXPAND | wx.ALL, 15)
+
+ return bdr
+
+#----------------------------------------------------------------------
+
+def makeBorderInBox(win):
+ insideBox = wx.BoxSizer(wx.HORIZONTAL)
+
+ box2 = wx.BoxSizer(wx.HORIZONTAL)
+ box2.AddMany([ (SampleWindow(win, "one"), 0, wx.EXPAND),
+ (SampleWindow(win, "two"), 0, wx.EXPAND),
+ (SampleWindow(win, "three"), 0, wx.EXPAND),
+ (SampleWindow(win, "four"), 0, wx.EXPAND),
+ (SampleWindow(win, "five"), 0, wx.EXPAND),
+ ])
+
+ insideBox.Add(box2, 0, wx.EXPAND)
+
+ bdr = wx.BoxSizer(wx.HORIZONTAL)
+ bdr.Add(SampleWindow(win, "border"), 1, wx.EXPAND | wx.ALL)
+ insideBox.Add(bdr, 1, wx.EXPAND | wx.ALL, 20)
+
+ box3 = wx.BoxSizer(wx.VERTICAL)
+ box3.AddMany([ (SampleWindow(win, "six"), 0, wx.EXPAND),
+ (SampleWindow(win, "seven"), 2, wx.EXPAND),
+ (SampleWindow(win, "eight"), 1, wx.EXPAND),
+ (SampleWindow(win, "nine"), 1, wx.EXPAND),
+ ])
+ insideBox.Add(box3, 1, wx.EXPAND)
+
+ outsideBox = wx.BoxSizer(wx.VERTICAL)
+ outsideBox.Add(SampleWindow(win, "top"), 0, wx.EXPAND)
+ outsideBox.Add(insideBox, 1, wx.EXPAND)
+ outsideBox.Add(SampleWindow(win, "bottom"), 0, wx.EXPAND)
+
+ return outsideBox
+
+
+#----------------------------------------------------------------------
+
+def makeGrid1(win):
+ gs = wx.GridSizer(3, 3, 2, 2) # rows, cols, vgap, hgap
+
+ gs.AddMany([ (SampleWindow(win, 'one'), 0, wx.EXPAND),
+ (SampleWindow(win, 'two'), 0, wx.EXPAND),
+ (SampleWindow(win, 'three'), 0, wx.EXPAND),
+ (SampleWindow(win, 'four'), 0, wx.EXPAND),
+ (SampleWindow(win, 'five'), 0, wx.EXPAND),
+ #(75, 50),
+ (SampleWindow(win, 'six'), 0, wx.EXPAND),
+ (SampleWindow(win, 'seven'), 0, wx.EXPAND),
+ (SampleWindow(win, 'eight'), 0, wx.EXPAND),
+ (SampleWindow(win, 'nine'), 0, wx.EXPAND),
+ ])
+
+ return gs
+
+#----------------------------------------------------------------------
+
+def makeGrid2(win):
+ gs = wx.GridSizer(3, 3) # rows, cols, vgap, hgap
+
+ box = wx.BoxSizer(wx.VERTICAL)
+ box.Add(SampleWindow(win, 'A'), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, 'B'), 1, wx.EXPAND)
+
+ gs2 = wx.GridSizer(2,2, 4, 4)
+ gs2.AddMany([ (SampleWindow(win, 'C'), 0, wx.EXPAND),
+ (SampleWindow(win, 'E'), 0, wx.EXPAND),
+ (SampleWindow(win, 'F'), 0, wx.EXPAND),
+ (SampleWindow(win, 'G'), 0, wx.EXPAND)])
+
+ gs.AddMany([ (SampleWindow(win, 'one'), 0, wx.ALIGN_RIGHT | wx.ALIGN_BOTTOM),
+ (SampleWindow(win, 'two'), 0, wx.EXPAND),
+ (SampleWindow(win, 'three'), 0, wx.ALIGN_LEFT | wx.ALIGN_BOTTOM),
+ (SampleWindow(win, 'four'), 0, wx.EXPAND),
+ (SampleWindow(win, 'five'), 0, wx.ALIGN_CENTER),
+ (SampleWindow(win, 'six'), 0, wx.EXPAND),
+ (box, 0, wx.EXPAND | wx.ALL, 10),
+ (SampleWindow(win, 'eight'), 0, wx.EXPAND),
+ (gs2, 0, wx.EXPAND | wx.ALL, 4),
+ ])
+
+ return gs
+
+#----------------------------------------------------------------------
+
+def makeGrid3(win):
+ gs = wx.FlexGridSizer(3, 3, 2, 2) # rows, cols, vgap, hgap
+
+ gs.AddMany([ (SampleWindow(win, 'one'), 0, wx.EXPAND),
+ (SampleWindow(win, 'two'), 0, wx.EXPAND),
+ (SampleWindow(win, 'three'), 0, wx.EXPAND),
+ (SampleWindow(win, 'four'), 0, wx.EXPAND),
+ #(SampleWindow(win, 'five'), 0, wx.EXPAND),
+ ((175, 50)),
+ (SampleWindow(win, 'six'), 0, wx.EXPAND),
+ (SampleWindow(win, 'seven'), 0, wx.EXPAND),
+ (SampleWindow(win, 'eight'), 0, wx.EXPAND),
+ (SampleWindow(win, 'nine'), 0, wx.EXPAND),
+ ])
+
+ gs.AddGrowableRow(0)
+ gs.AddGrowableRow(2)
+ gs.AddGrowableCol(1)
+ return gs
+
+#----------------------------------------------------------------------
+
+def makeGrid4(win):
+ bpos = wx.DefaultPosition
+ bsize = wx.Size(100, 50)
+ gs = wx.GridSizer(3, 3, 2, 2) # rows, cols, vgap, hgap
+
+ gs.AddMany([ (SampleWindow(win, 'one', bpos, bsize),
+ 0, wx.ALIGN_TOP | wx.ALIGN_LEFT ),
+ (SampleWindow(win, 'two', bpos, bsize),
+ 0, wx.ALIGN_TOP | wx.ALIGN_CENTER_HORIZONTAL ),
+ (SampleWindow(win, 'three', bpos, bsize),
+ 0, wx.ALIGN_TOP | wx.ALIGN_RIGHT ),
+ (SampleWindow(win, 'four', bpos, bsize),
+ 0, wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_LEFT ),
+ (SampleWindow(win, 'five', bpos, bsize),
+ 0, wx.ALIGN_CENTER ),
+ (SampleWindow(win, 'six', bpos, bsize),
+ 0, wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_RIGHT ),
+ (SampleWindow(win, 'seven', bpos, bsize),
+ 0, wx.ALIGN_BOTTOM | wx.ALIGN_LEFT ),
+ (SampleWindow(win, 'eight', bpos, bsize),
+ 0, wx.ALIGN_BOTTOM | wx.ALIGN_CENTER_HORIZONTAL ),
+ (SampleWindow(win, 'nine', bpos, bsize),
+ 0, wx.ALIGN_BOTTOM | wx.ALIGN_RIGHT ),
+ ])
+
+ return gs
+
+#----------------------------------------------------------------------
+
+def makeShapes(win):
+ bpos = wx.DefaultPosition
+ bsize = wx.Size(100, 50)
+ gs = wx.GridSizer(3, 3, 2, 2) # rows, cols, vgap, hgap
+
+ gs.AddMany([ (SampleWindow(win, 'one', bpos, bsize),
+ 0, wx.SHAPED | wx.ALIGN_TOP | wx.ALIGN_LEFT ),
+ (SampleWindow(win, 'two', bpos, bsize),
+ 0, wx.SHAPED | wx.ALIGN_TOP | wx.ALIGN_CENTER_HORIZONTAL ),
+ (SampleWindow(win, 'three', bpos, bsize),
+ 0, wx.SHAPED | wx.ALIGN_TOP | wx.ALIGN_RIGHT ),
+ (SampleWindow(win, 'four', bpos, bsize),
+ 0, wx.SHAPED | wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_LEFT ),
+ (SampleWindow(win, 'five', bpos, bsize),
+ 0, wx.SHAPED | wx.ALIGN_CENTER ),
+ (SampleWindow(win, 'six', bpos, bsize),
+ 0, wx.SHAPED | wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_RIGHT ),
+ (SampleWindow(win, 'seven', bpos, bsize),
+ 0, wx.SHAPED | wx.ALIGN_BOTTOM | wx.ALIGN_LEFT ),
+ (SampleWindow(win, 'eight', bpos, bsize),
+ 0, wx.SHAPED | wx.ALIGN_BOTTOM | wx.ALIGN_CENTER_HORIZONTAL ),
+ (SampleWindow(win, 'nine', bpos, bsize),
+ 0, wx.SHAPED | wx.ALIGN_BOTTOM | wx.ALIGN_RIGHT ),
+ ])
+
+ return gs
+
+#----------------------------------------------------------------------
+
+def makeSimpleBoxShaped(win):
+ box = wx.BoxSizer(wx.HORIZONTAL)
+ box.Add(SampleWindow(win, "one"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "two"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "three"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "four"), 0, wx.EXPAND)
+ box.Add(SampleWindow(win, "five"), 1, wx.SHAPED)
+
+ return box
+
+#----------------------------------------------------------------------
+
+theTests = [
+ ("Simple horizontal boxes", makeSimpleBox1,
+ "This is a HORIZONTAL box sizer with four non-stretchable buttons held "
+ "within it. Notice that the buttons are added and aligned in the horizontal "
+ "dimension. Also notice that they are fixed size in the horizontal dimension, "
+ "but will stretch vertically."
+ ),
+
+ ("Simple vertical boxes", makeSimpleBox2,
+ "Exactly the same as the previous sample but using a VERTICAL box sizer "
+ "instead of a HORIZONTAL one."
+ ),
+
+ ("Add a stretchable", makeSimpleBox3,
+ "We've added one more button with the stretchable flag turned on. Notice "
+ "how it grows to fill the extra space in the otherwise fixed dimension."
+ ),
+
+ ("More than one stretchable", makeSimpleBox4,
+ "Here there are several items that are stretchable, they all divide up the "
+ "extra space evenly."
+ ),
+
+ ("Weighting factor", makeSimpleBox5,
+ "This one shows more than one stretchable, but one of them has a weighting "
+ "factor so it gets more of the free space."
+ ),
+
+ ("Edge Affinity", makeSimpleBox6,
+ "For items that don't completly fill their allotted space, and don't "
+ "stretch, you can specify which side (or the center) they should stay "
+ "attached to."
+ ),
+
+ ("Spacer", makeSimpleBox7,
+ "You can add empty space to be managed by a Sizer just as if it were a "
+ "window or another Sizer."
+ ),
+
+ ("Centering in available space", makeSimpleBox8,
+ "This one shows an item that does not expand to fill it's space, but rather"
+ "stays centered within it."
+ ),
+
+# ("Percent Sizer", makeSimpleBox6,
+# "You can use the wx.BoxSizer like a Percent Sizer. Just make sure that all "
+# "the weighting factors add up to 100!"
+# ),
+
+ ("", None, ""),
+
+ ("Simple border sizer", makeSimpleBorder1,
+ "The wx.BoxSizer can leave empty space around its contents. This one "
+ "gives a border all the way around."
+ ),
+
+ ("East and West border", makeSimpleBorder2,
+ "You can pick and choose which sides have borders."
+ ),
+
+ ("North and West border", makeSimpleBorder3,
+ "You can pick and choose which sides have borders."
+ ),
+
+ ("", None, ""),
+
+ ("Boxes inside of boxes", makeBoxInBox,
+ "This one shows nesting of boxes within boxes within boxes, using both "
+ "orientations. Notice also that button seven has a greater weighting "
+ "factor than its siblings."
+ ),
+
+ ("Boxes inside a Border", makeBoxInBorder,
+ "Sizers of different types can be nested within each other as well. "
+ "Here is a box sizer with several buttons embedded within a border sizer."
+ ),
+
+ ("Border in a Box", makeBorderInBox,
+ "Another nesting example. This one has Boxes and a Border inside another Box."
+ ),
+
+ ("", None, ""),
+
+ ("Simple Grid", makeGrid1,
+ "This is an example of the wx.GridSizer. In this case all row heights "
+ "and column widths are kept the same as all the others and all items "
+ "fill their available space. The horizontal and vertical gaps are set to "
+ "2 pixels each."
+ ),
+
+ ("More Grid Features", makeGrid2,
+ "This is another example of the wx.GridSizer. This one has no gaps in the grid, "
+ "but various cells are given different alignment options and some of them "
+ "hold nested sizers."
+ ),
+
+ ("Flexible Grid", makeGrid3,
+ "This grid allows the rows to have different heights and the columns to have "
+ "different widths. You can also specify rows and columns that are growable, "
+ "which we have done for the first and last row and the middle column for "
+ "this example.\n"
+ "\nThere is also a spacer in the middle cell instead of an actual window."
+ ),
+
+ ("Grid with Alignment", makeGrid4,
+ "New alignment flags allow for the positioning of items in any corner or centered "
+ "position."
+ ),
+
+ ("", None, ""),
+
+ ("Proportional resize", makeSimpleBoxShaped,
+ "Managed items can preserve their original aspect ratio. The last item has the "
+ "wx.SHAPED flag set and will resize proportional to its original size."
+ ),
+
+ ("Proportional resize with Alignments", makeShapes,
+ "This one shows various alignments as well as proportional resizing for all items."
+ ),
+
+ ]
+#----------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, title, sizerFunc):
+ wx.Frame.__init__(self, parent, -1, title)
+
+ p = wx.Panel(self, -1)
+
+ self.sizer = sizerFunc(p)
+ self.CreateStatusBar()
+ self.SetStatusText("Resize this frame to see how the sizers respond...")
+
+ p.SetSizer(self.sizer)
+ self.sizer.Fit(p)
+ self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+ self.Fit()
+
+ def OnCloseWindow(self, event):
+ self.MakeModal(False)
+ self.Destroy()
+
+
+#----------------------------------------------------------------------
+
+class TestSelectionPanel(wx.Panel):
+ def __init__(self, parent):
+ wx.Panel.__init__(self, parent)
+
+ self.list = wx.ListBox(self, -1,
+ wx.DLG_PNT(self, 10, 10), wx.DLG_SZE(self, 100, 100),
+ [])
+ self.Bind(wx.EVT_LISTBOX, self.OnSelect, self.list)
+ self.Bind(wx.EVT_LISTBOX_DCLICK, self.OnDClick, self.list)
+
+ wx.Button(self, -1, "Try it!", wx.DLG_PNT(self, 120, 10)).SetDefault()
+ self.Bind(wx.EVT_BUTTON, self.OnDClick)
+
+ self.text = wx.TextCtrl(self, -1, "",
+ wx.DLG_PNT(self, 10, 115),
+ wx.DLG_SZE(self, 200, 50),
+ wx.TE_MULTILINE | wx.TE_READONLY)
+
+ for item in theTests:
+ self.list.Append(item[0])
+
+
+ def OnSelect(self, event):
+ pos = self.list.GetSelection()
+ self.text.SetValue(theTests[pos][2])
+
+
+ def OnDClick(self, event):
+ pos = self.list.GetSelection()
+ title = theTests[pos][0]
+ func = theTests[pos][1]
+
+ if func:
+ win = TestFrame(self, title, func)
+ win.CentreOnParent(wx.BOTH)
+ win.Show(True)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestSelectionPanel(nb)
+ return win
+
+overview = ""
+
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+#----------------------------------------------------------------------
diff --git a/demo/Slider.py b/demo/Slider.py
new file mode 100644
index 00000000..7be4bdb5
--- /dev/null
+++ b/demo/Slider.py
@@ -0,0 +1,48 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+ self.count = 0
+
+ wx.StaticText(self, -1, "This is a wx.Slider.", (45, 15))
+
+ slider = wx.Slider(
+ self, 100, 25, 1, 100, (30, 60), (250, -1),
+ wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_LABELS
+ )
+
+ slider.SetTickFreq(5, 1)
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+
+overview = """\
+A slider is a control with a handle which can be pulled back and forth to
+change the value.
+
+In Windows versions below Windows 95, a scrollbar is used to simulate the slider.
+In Windows 95, the track bar control is used.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Sound.py b/demo/Sound.py
new file mode 100644
index 00000000..2a2977f7
--- /dev/null
+++ b/demo/Sound.py
@@ -0,0 +1,93 @@
+
+import wx
+
+from Main import opj
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ b = wx.Button(self, -1, "Play Sound 1 (sync)", (25, 25))
+ self.Bind(wx.EVT_BUTTON, self.OnButton1, b)
+
+ b = wx.Button(self, -1, "Play Sound 2 (async)", (25, 65))
+ self.Bind(wx.EVT_BUTTON, self.OnButton2, b)
+
+ b = wx.Button(self, -1, "Select .WAV file", (25, 105))
+ self.Bind(wx.EVT_BUTTON, self.OnSelectSound, b)
+
+
+ def OnButton1(self, evt):
+ try:
+ sound = wx.Sound(opj('data/anykey.wav'))
+ self.log.write("before Play...\n")
+ sound.Play(wx.SOUND_SYNC)
+ self.log.write("...after Play\n")
+ except NotImplementedError, v:
+ wx.MessageBox(str(v), "Exception Message")
+
+
+ def OnButton2(self, evt):
+ try:
+ if True:
+ sound = wx.Sound(opj('data/plan.wav'))
+ else:
+ # sounds can also be loaded from a buffer object
+ data = open(opj('data/plan.wav'), 'rb').read()
+ sound = wx.SoundFromData(data)
+
+ self.log.write("before Play...\n")
+ sound.Play(wx.SOUND_ASYNC)
+ self.sound = sound # save a reference (This shoudln't be needed, but there seems to be a bug...)
+ wx.YieldIfNeeded()
+ self.log.write("...after Play\n")
+ except NotImplementedError, v:
+ wx.MessageBox(str(v), "Exception Message")
+
+
+ def OnSelectSound(self, evt):
+ dlg = wx.FileDialog(wx.GetTopLevelParent(self),
+ "Choose a sound file",
+ wildcard="WAV files (*.wav)|*.wav",
+ style=wx.OPEN)
+ if dlg.ShowModal() == wx.ID_OK:
+ try:
+ #sound = wx.Sound(dlg.GetPath(), wx.SOUND_SYNC)
+ #sound.Play()
+
+ # another way to do it.
+ wx.Sound.PlaySound(dlg.GetPath(), wx.SOUND_SYNC)
+
+ except NotImplementedError, v:
+ wx.MessageBox(str(v), "Exception Message")
+ dlg.Destroy()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """
+
Sound
+This class represents a short wave file, in Windows WAV format, that can
+be stored in memory and played.
+
+This demo offers two examples, both driven by buttons, but obviously the event
+that drives the playing of the sound can come from anywhere.
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/SpinButton.py b/demo/SpinButton.py
new file mode 100644
index 00000000..12fb117f
--- /dev/null
+++ b/demo/SpinButton.py
@@ -0,0 +1,61 @@
+# 11/30/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o EVT_SPIN events (or something about them) freezes up the app.
+#
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+ self.count = 0
+
+ wx.StaticText(self, -1, "This example uses the wx.SpinButton control.", (45, 15))
+
+ self.text = wx.TextCtrl(self, -1, "1", (30, 50), (60, -1))
+ h = self.text.GetSize().height
+ w = self.text.GetSize().width + self.text.GetPosition().x + 2
+
+ self.spin = wx.SpinButton(self, -1,
+ (w, 50),
+ (h*2/3, h),
+ wx.SP_VERTICAL)
+ self.spin.SetRange(1, 100)
+ self.spin.SetValue(1)
+
+ self.Bind(wx.EVT_SPIN, self.OnSpin, self.spin)
+
+
+ def OnSpin(self, event):
+ self.text.SetValue(str(event.GetPosition()))
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+A wx.SpinButton has two small up and down (or left and right) arrow buttons.
+It is often used next to a text control for increment and decrementing a value.
+Portable programs should try to use wx.SpinCtrl instead as wx.SpinButton is not
+implemented for all platforms (Win32 and GTK only currently).
+
+NB: the range supported by this control (and wx.SpinCtrl) depends on the platform
+but is at least -0x8000 to 0x7fff. Under GTK and Win32 with sufficiently new version
+of comctrl32.dll (at least 4.71 is required, 5.80 is recommended) the full 32 bit
+range is supported.
+
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/SpinCtrl.py b/demo/SpinCtrl.py
new file mode 100644
index 00000000..b110ab0d
--- /dev/null
+++ b/demo/SpinCtrl.py
@@ -0,0 +1,55 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ wx.StaticText(self, -1, "This example uses the wx.SpinCtrl control.", (45, 15))
+ sc = wx.SpinCtrl(self, -1, "", (30, 50))
+ sc.SetRange(1,100)
+ sc.SetValue(5)
+ self.sc = sc
+
+ self.Bind(wx.EVT_SPINCTRL, self.OnSpin, sc)
+ self.Bind(wx.EVT_TEXT, self.OnText, sc)
+
+
+ def OnSpin(self, evt):
+ self.log.write('OnSpin: %d\n' % self.sc.GetValue())
+
+ def OnText(self, evt):
+ self.log.write('OnText: %d\n' % self.sc.GetValue())
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+wx.SpinCtrl combines wx.TextCtrl and wx.SpinButton in one control.
+
+Portable programs should try to use this control as wx.SpinButton is not
+implemented for all platforms (Win32 and GTK only currently).
+
+NB: the range supported by this control depends on the platform
+but is at least -0x8000 to 0x7fff. Under GTK and Win32 with sufficiently new version
+of comctrl32.dll (at least 4.71 is required, 5.80 is recommended) the full 32 bit
+range is supported.
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/SpinCtrlDouble.py b/demo/SpinCtrlDouble.py
new file mode 100644
index 00000000..bf608bc1
--- /dev/null
+++ b/demo/SpinCtrlDouble.py
@@ -0,0 +1,41 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ wx.StaticText(self, -1, "wx.SpinCtrlDouble:", pos=(25,25))
+ spin = wx.SpinCtrlDouble(self, value='0.00', pos=(75,50), size=(80,-1),
+ min=-5.0, max=25.25, inc=0.25)
+ spin.SetDigits(2)
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.SpinCtrlDouble
+
+Essentially the same as a wx.SpinCtrl, except it can handle floating
+point numbers, and fractional increments.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/SplitTree.py b/demo/SplitTree.py
new file mode 100644
index 00000000..2e95db5b
--- /dev/null
+++ b/demo/SplitTree.py
@@ -0,0 +1,145 @@
+# 11/13/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Updated for wx namespace
+#
+# 11/26/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Bigtime errors on startup. Blows up with a program error.
+# Error:
+#
+# 21:04:11: Debug: ..\..\src\msw\treectrl.cpp(1508): assert "IsVisible(item)"
+# failed: The item you call GetNextVisible() for must be visible itself!
+#
+# I suspect this error is in the lib itself.
+#
+
+import wx
+import wx.gizmos as gizmos
+
+
+#----------------------------------------------------------------------
+
+class TestTree(gizmos.RemotelyScrolledTreeCtrl):
+ def __init__(self, parent, style=wx.TR_HAS_BUTTONS):
+ gizmos.RemotelyScrolledTreeCtrl.__init__(self, parent, -1, style=style)
+
+ # make an image list
+ im1 = im2 = -1
+ self.il = wx.ImageList(16, 16)
+ im1 = self.il.Add(wx.ArtProvider.GetBitmap(wx.ART_FOLDER, wx.ART_TOOLBAR, (16,16)))
+ im2 = self.il.Add(wx.ArtProvider.GetBitmap(wx.ART_NORMAL_FILE, wx.ART_TOOLBAR, (16,16)))
+ self.SetImageList(self.il)
+
+ # Add some items
+ root = self.AddRoot("Root")
+
+ for i in range(30):
+ item = self.AppendItem(root, "Item %d" % i, im1)
+
+ for j in range(10):
+ child = self.AppendItem(item, "Child %d" % j, im2)
+
+ self.Expand(root)
+
+
+
+class TestValueWindow(gizmos.TreeCompanionWindow):
+ def __init__(self, parent, style=0):
+ gizmos.TreeCompanionWindow.__init__(self, parent, -1, style=style)
+ self.SetBackgroundColour("WHITE")
+
+ # This method is called to draw each item in the value window
+ def DrawItem(self, dc, itemId, rect):
+ tree = self.GetTreeCtrl()
+
+ if tree:
+ text = "This is "
+ parent = tree.GetItemParent(itemId)
+
+ if parent.IsOk():
+ ptext = tree.GetItemText(parent)
+ text = text + ptext + " --> "
+
+ text = text + tree.GetItemText(itemId)
+ pen = wx.Pen(
+ wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DLIGHT),
+ 1, wx.SOLID
+ )
+
+ dc.SetPen(pen)
+ dc.SetBrush(wx.Brush(self.GetBackgroundColour(), wx.SOLID))
+ dc.DrawRectangle(rect.x, rect.y, rect.width+1, rect.height+1)
+ dc.SetTextForeground("BLACK")
+ dc.SetBackgroundMode(wx.TRANSPARENT)
+ tw, th = dc.GetTextExtent(text)
+ x = 5
+ y = rect.y + max(0, (rect.height - th) / 2)
+ dc.DrawText(text, x, y)
+
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1, size=(640,480))
+ self.log = log
+
+ scroller = gizmos.SplitterScrolledWindow(
+ self, -1, style=wx.NO_BORDER | wx.CLIP_CHILDREN | wx.VSCROLL
+ )
+
+ splitter = gizmos.ThinSplitterWindow(
+ scroller, -1, style=wx.SP_3DBORDER | wx.CLIP_CHILDREN
+ )
+
+ splitter.SetSashSize(2)
+ tree = TestTree(splitter, style = wx.TR_HAS_BUTTONS |
+ wx.TR_NO_LINES |
+ wx.TR_ROW_LINES |
+ #wx.TR_HIDE_ROOT |
+ wx.NO_BORDER )
+
+ valueWindow = TestValueWindow(splitter, style=wx.NO_BORDER)
+
+ wx.CallAfter(splitter.SplitVertically, tree, valueWindow, 150)
+ scroller.SetTargetWindow(tree)
+ scroller.EnableScrolling(False, False)
+
+ valueWindow.SetTreeCtrl(tree)
+ tree.SetCompanionWindow(valueWindow)
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(scroller, 1, wx.EXPAND|wx.ALL, 25)
+ self.SetSizer(sizer)
+ self.Layout()
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ if wx.Platform == "__WXMAC__":
+ from wx.lib.msgpanel import MessagePanel
+ win = MessagePanel(nb, 'This demo currently fails on the Mac. The problem is being looked into...',
+ 'Sorry', wx.ICON_WARNING)
+ return win
+
+ win = TestPanel(nb, log)
+ return win
+
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+This demo shows a collection of classes that were designed to operate
+together and provide a tree control with additional columns for each
+item. The classes are wx.RemotelyScrolledTreeCtrl, wx.TreeCompanionWindow,
+wx.ThinSplitterWindow, and wx.SplitterScrolledWindow, some of which may
+also be useful by themselves.
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/SplitterWindow.py b/demo/SplitterWindow.py
new file mode 100644
index 00000000..dafc4600
--- /dev/null
+++ b/demo/SplitterWindow.py
@@ -0,0 +1,61 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class MySplitter(wx.SplitterWindow):
+ def __init__(self, parent, ID, log):
+ wx.SplitterWindow.__init__(self, parent, ID,
+ style = wx.SP_LIVE_UPDATE
+ )
+ self.log = log
+
+ self.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGED, self.OnSashChanged)
+ self.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGING, self.OnSashChanging)
+
+ def OnSashChanged(self, evt):
+ self.log.WriteText("sash changed to %s\n" % str(evt.GetSashPosition()))
+
+ def OnSashChanging(self, evt):
+ self.log.WriteText("sash changing to %s\n" % str(evt.GetSashPosition()))
+ # uncomment this to not allow the change
+ #evt.SetSashPosition(-1)
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ splitter = MySplitter(nb, -1, log)
+
+ #sty = wx.BORDER_NONE
+ #sty = wx.BORDER_SIMPLE
+ sty = wx.BORDER_SUNKEN
+
+ p1 = wx.Window(splitter, style=sty)
+ p1.SetBackgroundColour("pink")
+ wx.StaticText(p1, -1, "Panel One", (5,5))
+
+ p2 = wx.Window(splitter, style=sty)
+ p2.SetBackgroundColour("sky blue")
+ wx.StaticText(p2, -1, "Panel Two", (5,5))
+
+ splitter.SetMinimumPaneSize(20)
+ splitter.SplitVertically(p1, p2, -100)
+
+ return splitter
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+This class manages up to two subwindows. The current view can be split
+into two programmatically (perhaps from a menu command), and unsplit
+either programmatically or via the wx.SplitterWindow user interface.
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/StandardPaths.py b/demo/StandardPaths.py
new file mode 100644
index 00000000..a3a7fed6
--- /dev/null
+++ b/demo/StandardPaths.py
@@ -0,0 +1,112 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ sizer = wx.FlexGridSizer(cols=3, hgap=5, vgap=5)
+ sizer.AddGrowableCol(1)
+ box = wx.BoxSizer(wx.VERTICAL)
+ fs = self.GetFont().GetPointSize()
+ bf = wx.Font(fs+4, wx.SWISS, wx.NORMAL, wx.BOLD)
+
+ t = wx.StaticText(self, -1, "StandardPaths")
+ t.SetFont(bf)
+ box.Add(t, 0, wx.CENTER|wx.ALL, 4)
+ box.Add(wx.StaticLine(self, -1), 0, wx.EXPAND)
+
+ # get the global (singleton) instance of wx.StandardPaths
+ sp = wx.StandardPaths.Get()
+
+ # StandardPaths will use the value of wx.App().GetAppName()
+ # for some of the stnadard path components. Let's set it to
+ # something that makes that obvious for the demo. In your own
+ # apps you'll set it in to something more meaningfull for your
+ # app in your OnInit, (or just let it default.)
+ wx.GetApp().SetAppName("AppName")
+
+ self.help = {}
+
+ # Loop through all of the getters in wx.StandardPaths and make
+ # a set of items in the sizer for each.
+ def makeitem(name, *args):
+ func = getattr(sp, name)
+ sizer.Add(wx.StaticText(self, -1, "%s%s:" %(name, repr(args))),
+ 0, wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL)
+ sizer.Add(wx.TextCtrl(self, -1, func(*args),
+ size=(275,-1), style=wx.TE_READONLY),
+ 0, wx.EXPAND|wx.ALIGN_CENTER_VERTICAL)
+
+ btn = wx.Button(self, wx.ID_HELP)
+ sizer.Add(btn)
+ self.help[btn] = func.__doc__
+
+ for x in ['GetConfigDir',
+ 'GetUserConfigDir',
+ 'GetDataDir',
+ 'GetLocalDataDir',
+ 'GetUserDataDir',
+ 'GetUserLocalDataDir',
+ 'GetDocumentsDir',
+ 'GetAppDocumentsDir',
+ 'GetPluginsDir',
+ 'GetInstallPrefix',
+ 'GetResourcesDir',
+ 'GetTempDir',
+ 'GetExecutablePath',
+ ]:
+ makeitem(x)
+
+ # this one needs parameters
+ makeitem('GetLocalizedResourcesDir', 'en',
+ wx.StandardPaths.ResourceCat_Messages )
+
+ self.Bind(wx.EVT_BUTTON, self.OnShowDoc, id=wx.ID_HELP)
+
+ box.Add(sizer, 0, wx.CENTER|wx.EXPAND|wx.ALL, 20)
+ self.SetSizer(box)
+
+
+ def OnShowDoc(self, evt):
+ doc = self.help[evt.GetEventObject()]
+
+ # trim the whitespace from each line
+ lines = []
+ for line in doc.split('\n'):
+ lines.append(line.strip())
+ doc = '\n'.join(lines)
+ wx.TipWindow(self, doc, 500)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
StandardPaths
+
+wxWidgets provides this class to simply determine where to locate
+certain types of files in a platform specific manner. This includes
+things like configuration files, general data files writeable by the
+user, and application files that are shared by all user.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/StaticBitmap.py b/demo/StaticBitmap.py
new file mode 100644
index 00000000..968e3659
--- /dev/null
+++ b/demo/StaticBitmap.py
@@ -0,0 +1,55 @@
+
+import wx
+import images
+
+
+USE_GENERIC = 0
+
+if USE_GENERIC:
+ from wx.lib.stattext import GenStaticText as StaticText
+ from wx.lib.statbmp import GenStaticBitmap as StaticBitmap
+else:
+ StaticText = wx.StaticText
+ StaticBitmap = wx.StaticBitmap
+
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+ ##self.SetBackgroundColour("sky blue")
+
+ StaticText(self, -1, "This is a wx.StaticBitmap.", (45, 15))
+
+ bmp = images.Test2.GetBitmap()
+ mask = wx.Mask(bmp, wx.BLUE)
+ bmp.SetMask(mask)
+ StaticBitmap(self, -1, bmp, (80, 50), (bmp.GetWidth(), bmp.GetHeight()))
+
+ bmp = images.Robin.GetBitmap()
+ StaticBitmap(self, -1, bmp, (80, 150))
+
+ StaticText(self, -1, "Hey, if Ousterhout can do it, so can I.", (200, 175))
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+overview = """\
+A StaticBitmap control displays a bitmap.
+
+A bitmap can be derived from most image formats using the wx.Image class.
+
+"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/StaticBox.py b/demo/StaticBox.py
new file mode 100644
index 00000000..f4ab8934
--- /dev/null
+++ b/demo/StaticBox.py
@@ -0,0 +1,47 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ box = wx.StaticBox(self, -1, "This is a wx.StaticBox")
+ bsizer = wx.StaticBoxSizer(box, wx.VERTICAL)
+
+ t = wx.StaticText(self, -1, "Controls placed \"inside\" the box are really its siblings")
+ bsizer.Add(t, 0, wx.TOP|wx.LEFT, 10)
+
+
+ border = wx.BoxSizer()
+ border.Add(bsizer, 1, wx.EXPAND|wx.ALL, 25)
+ self.SetSizer(border)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.StaticBox
+
+This control draws a box and can be used to group other controls.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/StaticText.py b/demo/StaticText.py
new file mode 100644
index 00000000..52b738ee
--- /dev/null
+++ b/demo/StaticText.py
@@ -0,0 +1,68 @@
+
+import wx
+
+
+USE_GENERIC = 0
+
+if USE_GENERIC:
+ from wx.lib.stattext import GenStaticText as StaticText
+else:
+ StaticText = wx.StaticText
+
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent):
+ wx.Panel.__init__(self, parent, -1)
+ ##self.SetBackgroundColour("sky blue")
+
+ StaticText(self, -1, "This is an example of static text", (20, 10))
+ StaticText(self, -1, "using the wx.StaticText Control.", (20, 30))
+
+ StaticText(
+ self, -1, "Is this yellow?", (20, 70), (120, -1)
+ ).SetBackgroundColour('Yellow')
+
+ StaticText(
+ self, -1, "align center", (160, 70), (120, -1), wx.ALIGN_CENTER
+ ).SetBackgroundColour('Yellow')
+
+ StaticText(
+ self, -1, "align right", (300, 70), (120, -1), wx.ALIGN_RIGHT
+ ).SetBackgroundColour('Yellow')
+
+ str = "This is a different font."
+ text = StaticText(self, -1, str, (20, 120))
+ font = wx.Font(18, wx.SWISS, wx.NORMAL, wx.NORMAL)
+ text.SetFont(font)
+
+ StaticText(self, -1,
+ "Multi-line wx.StaticText\nline 2\nline 3\n\nafter empty line",
+ (20,170))
+ StaticText(self, -1,
+ "Align right multi-line\nline 2\nline 3\n\nafter empty line",
+ (220,170), style=wx.ALIGN_RIGHT)
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ panel = TestPanel(nb)
+ return panel
+
+
+#---------------------------------------------------------------------------
+
+
+overview = '''\
+A StaticText control displays one or more lines of read-only text.
+
+'''
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/StatusBar.py b/demo/StatusBar.py
new file mode 100644
index 00000000..3f218842
--- /dev/null
+++ b/demo/StatusBar.py
@@ -0,0 +1,140 @@
+
+import time
+import wx
+
+#---------------------------------------------------------------------------
+
+class CustomStatusBar(wx.StatusBar):
+ def __init__(self, parent, log):
+ wx.StatusBar.__init__(self, parent, -1)
+
+ # This status bar has three fields
+ self.SetFieldsCount(3)
+ # Sets the three fields to be relative widths to each other.
+ self.SetStatusWidths([-2, -1, -2])
+ self.log = log
+ self.sizeChanged = False
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ self.Bind(wx.EVT_IDLE, self.OnIdle)
+
+ # Field 0 ... just text
+ self.SetStatusText("A Custom StatusBar...", 0)
+
+ # This will fall into field 1 (the second field)
+ self.cb = wx.CheckBox(self, 1001, "toggle clock")
+ self.Bind(wx.EVT_CHECKBOX, self.OnToggleClock, self.cb)
+ self.cb.SetValue(True)
+
+ # set the initial position of the checkbox
+ self.Reposition()
+
+ # We're going to use a timer to drive a 'clock' in the last
+ # field.
+ self.timer = wx.PyTimer(self.Notify)
+ self.timer.Start(1000)
+ self.Notify()
+
+
+ # Handles events from the timer we started in __init__().
+ # We're using it to drive a 'clock' in field 2 (the third field).
+ def Notify(self):
+ t = time.localtime(time.time())
+ st = time.strftime("%d-%b-%Y %I:%M:%S", t)
+ self.SetStatusText(st, 2)
+ self.log.WriteText("tick...\n")
+
+
+ # the checkbox was clicked
+ def OnToggleClock(self, event):
+ if self.cb.GetValue():
+ self.timer.Start(1000)
+ self.Notify()
+ else:
+ self.timer.Stop()
+
+
+ def OnSize(self, evt):
+ evt.Skip()
+ self.Reposition() # for normal size events
+
+ # Set a flag so the idle time handler will also do the repositioning.
+ # It is done this way to get around a buglet where GetFieldRect is not
+ # accurate during the EVT_SIZE resulting from a frame maximize.
+ self.sizeChanged = True
+
+
+ def OnIdle(self, evt):
+ if self.sizeChanged:
+ self.Reposition()
+
+
+ # reposition the checkbox
+ def Reposition(self):
+ rect = self.GetFieldRect(1)
+ rect.x += 1
+ rect.y += 1
+ self.cb.SetRect(rect)
+ self.sizeChanged = False
+
+
+
+class TestCustomStatusBar(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(self, parent, -1, 'Test Custom StatusBar')
+
+ self.sb = CustomStatusBar(self, log)
+ self.SetStatusBar(self.sb)
+ tc = wx.TextCtrl(self, -1, "", style=wx.TE_READONLY|wx.TE_MULTILINE)
+
+ self.SetSize((640, 480))
+ self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+ def OnCloseWindow(self, event):
+ self.sb.timer.Stop()
+ del self.sb.timer
+ 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 the StatusBar sample", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ win = TestCustomStatusBar(self, self.log)
+ win.Show(True)
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+A status bar is a narrow window that can be placed along the bottom of
+a frame to give small amounts of status information. It can contain
+one or more fields, one or more of which can be variable length
+according to the size of the window.
+
+This example demonstrates how to create a custom status bar with actual
+gadgets embedded in it. In this case, the first field is just plain text,
+The second one has a checkbox that enables the timer, and the third
+field has a clock that shows the current time when it is enabled.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/StockButtons.py b/demo/StockButtons.py
new file mode 100644
index 00000000..59957a7c
--- /dev/null
+++ b/demo/StockButtons.py
@@ -0,0 +1,112 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+
+stockIDs = [
+ wx.ID_ABOUT,
+ wx.ID_ADD,
+ wx.ID_APPLY,
+ wx.ID_BOLD,
+ wx.ID_CANCEL,
+ wx.ID_CLEAR,
+ wx.ID_CLOSE,
+ wx.ID_COPY,
+ wx.ID_CUT,
+ wx.ID_DELETE,
+ wx.ID_EDIT,
+ wx.ID_FIND,
+ wx.ID_FILE,
+ wx.ID_REPLACE,
+ wx.ID_BACKWARD,
+ wx.ID_DOWN,
+ wx.ID_FORWARD,
+ wx.ID_UP,
+ wx.ID_HELP,
+ wx.ID_HOME,
+ wx.ID_INDENT,
+ wx.ID_INDEX,
+ wx.ID_ITALIC,
+ wx.ID_JUSTIFY_CENTER,
+ wx.ID_JUSTIFY_FILL,
+ wx.ID_JUSTIFY_LEFT,
+ wx.ID_JUSTIFY_RIGHT,
+ wx.ID_NEW,
+ wx.ID_NO,
+ wx.ID_OK,
+ wx.ID_OPEN,
+ wx.ID_PASTE,
+ wx.ID_PREFERENCES,
+ wx.ID_PRINT,
+ wx.ID_PREVIEW,
+ wx.ID_PROPERTIES,
+ wx.ID_EXIT,
+ wx.ID_REDO,
+ wx.ID_REFRESH,
+ wx.ID_REMOVE,
+ wx.ID_REVERT_TO_SAVED,
+ wx.ID_SAVE,
+ wx.ID_SAVEAS,
+ wx.ID_SELECTALL,
+ wx.ID_STOP,
+ wx.ID_UNDELETE,
+ wx.ID_UNDERLINE,
+ wx.ID_UNDO,
+ wx.ID_UNINDENT,
+ wx.ID_YES,
+ wx.ID_ZOOM_100,
+ wx.ID_ZOOM_FIT,
+ wx.ID_ZOOM_IN,
+ wx.ID_ZOOM_OUT,
+
+ ]
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ sizer = wx.FlexGridSizer(cols=5, hgap=4, vgap=4)
+ for ID in stockIDs:
+ b = wx.Button(self, ID)
+ sizer.Add(b)
+
+ self.SetSizer(sizer)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
Stock Buttons
+
+It is now possible to create \"stock\" buttons. Basically this means
+that you only have to provide one of the stock IDs (and an empty
+label) when creating the button and wxWidgets will choose the stock
+label to go with it automatically. Additionally on the platforms that
+have a native concept of a stock button (currently only GTK2) then the
+native stock button will be used.
+
+
This sample shows buttons for all of the currenlty available stock
+IDs. Notice that when the button is created that no label is given,
+and compare that with the button that is created.
+
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/StyledTextCtrl_1.py b/demo/StyledTextCtrl_1.py
new file mode 100644
index 00000000..c0c19a59
--- /dev/null
+++ b/demo/StyledTextCtrl_1.py
@@ -0,0 +1,320 @@
+#
+# 11/21/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o wx.TheClipboard.Flush() generates a warning on program exit.
+#
+
+import wx
+import wx.stc as stc
+
+import images
+
+#----------------------------------------------------------------------
+
+debug = 1
+
+
+demoText = """\
+This editor is provided by a class named wx.StyledTextCtrl. As
+the name suggests, you can define styles that can be applied to
+sections of text. This will typically be used for things like
+syntax highlighting code editors, but I'm sure that there are other
+applications as well. A style is a combination of font, point size,
+foreground and background colours. The editor can handle
+proportional fonts just as easily as monospaced fonts, and various
+styles can use different sized fonts.
+
+There are a few canned language lexers and colourizers included,
+(see the next demo) or you can handle the colourization yourself.
+If you do you can simply register an event handler and the editor
+will let you know when the visible portion of the text needs
+styling.
+
+wx.StyledTextCtrl also supports setting markers in the margin...
+
+
+
+
+...and indicators within the text. You can use these for whatever
+you want in your application. Cut, Copy, Paste, Drag and Drop of
+text works, as well as virtually unlimited Undo and Redo
+capabilities, (right click to try it out.)
+"""
+
+if wx.Platform == '__WXMSW__':
+ face1 = 'Arial'
+ face2 = 'Times New Roman'
+ face3 = 'Courier New'
+ pb = 10
+else:
+ face1 = 'Helvetica'
+ face2 = 'Times'
+ face3 = 'Courier'
+ pb = 12
+
+
+#----------------------------------------------------------------------
+# This shows how to catch the Modified event from the wx.StyledTextCtrl
+
+class MySTC(stc.StyledTextCtrl):
+ def __init__(self, parent, ID, log):
+ stc.StyledTextCtrl.__init__(self, parent, ID)
+ self.log = log
+
+ self.Bind(stc.EVT_STC_DO_DROP, self.OnDoDrop)
+ self.Bind(stc.EVT_STC_DRAG_OVER, self.OnDragOver)
+ self.Bind(stc.EVT_STC_START_DRAG, self.OnStartDrag)
+ self.Bind(stc.EVT_STC_MODIFIED, self.OnModified)
+
+ self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
+
+ def OnDestroy(self, evt):
+ # This is how the clipboard contents can be preserved after
+ # the app has exited.
+ wx.TheClipboard.Flush()
+ evt.Skip()
+
+
+ def OnStartDrag(self, evt):
+ self.log.write("OnStartDrag: %d, %s\n"
+ % (evt.GetDragAllowMove(), evt.GetDragText()))
+
+ if debug and evt.GetPosition() < 250:
+ evt.SetDragAllowMove(False) # you can prevent moving of text (only copy)
+ evt.SetDragText("DRAGGED TEXT") # you can change what is dragged
+ #evt.SetDragText("") # or prevent the drag with empty text
+
+
+ def OnDragOver(self, evt):
+ self.log.write(
+ "OnDragOver: x,y=(%d, %d) pos: %d DragResult: %d\n"
+ % (evt.GetX(), evt.GetY(), evt.GetPosition(), evt.GetDragResult())
+ )
+
+ if debug and evt.GetPosition() < 250:
+ evt.SetDragResult(wx.DragNone) # prevent dropping at the beginning of the buffer
+
+
+ def OnDoDrop(self, evt):
+ self.log.write("OnDoDrop: x,y=(%d, %d) pos: %d DragResult: %d\n"
+ "\ttext: %s\n"
+ % (evt.GetX(), evt.GetY(), evt.GetPosition(), evt.GetDragResult(),
+ evt.GetDragText()))
+
+ if debug and evt.GetPosition() < 500:
+ evt.SetDragText("DROPPED TEXT") # Can change text if needed
+ #evt.SetDragResult(wx.DragNone) # Can also change the drag operation, but it
+ # is probably better to do it in OnDragOver so
+ # there is visual feedback
+
+ #evt.SetPosition(25) # Can also change position, but I'm not sure why
+ # you would want to...
+
+
+
+
+ def OnModified(self, evt):
+ self.log.write("""OnModified
+ Mod type: %s
+ At position: %d
+ Lines added: %d
+ Text Length: %d
+ Text: %s\n""" % ( self.transModType(evt.GetModificationType()),
+ evt.GetPosition(),
+ evt.GetLinesAdded(),
+ evt.GetLength(),
+ repr(evt.GetText()) ))
+
+
+ def transModType(self, modType):
+ st = ""
+ table = [(stc.STC_MOD_INSERTTEXT, "InsertText"),
+ (stc.STC_MOD_DELETETEXT, "DeleteText"),
+ (stc.STC_MOD_CHANGESTYLE, "ChangeStyle"),
+ (stc.STC_MOD_CHANGEFOLD, "ChangeFold"),
+ (stc.STC_PERFORMED_USER, "UserFlag"),
+ (stc.STC_PERFORMED_UNDO, "Undo"),
+ (stc.STC_PERFORMED_REDO, "Redo"),
+ (stc.STC_LASTSTEPINUNDOREDO, "Last-Undo/Redo"),
+ (stc.STC_MOD_CHANGEMARKER, "ChangeMarker"),
+ (stc.STC_MOD_BEFOREINSERT, "B4-Insert"),
+ (stc.STC_MOD_BEFOREDELETE, "B4-Delete")
+ ]
+
+ for flag,text in table:
+ if flag & modType:
+ st = st + text + " "
+
+ if not st:
+ st = 'UNKNOWN'
+
+ return st
+
+
+
+
+#----------------------------------------------------------------------
+
+_USE_PANEL = 1
+
+def runTest(frame, nb, log):
+ if not _USE_PANEL:
+ ed = p = MySTC(nb, -1, log)
+
+ else:
+ p = wx.Panel(nb, -1, style=wx.NO_FULL_REPAINT_ON_RESIZE)
+ ed = MySTC(p, -1, log)
+ s = wx.BoxSizer(wx.HORIZONTAL)
+ s.Add(ed, 1, wx.EXPAND)
+ p.SetSizer(s)
+ p.SetAutoLayout(True)
+
+
+ #ed.SetBufferedDraw(False)
+ #ed.StyleClearAll()
+ #ed.SetScrollWidth(800)
+ #ed.SetWrapMode(True)
+ #ed.SetUseAntiAliasing(False)
+ #ed.SetViewEOL(True)
+
+ #ed.CmdKeyClear(stc.STC_KEY_BACK,
+ # stc.STC_SCMOD_CTRL)
+ #ed.CmdKeyAssign(stc.STC_KEY_BACK,
+ # stc.STC_SCMOD_CTRL,
+ # stc.STC_CMD_DELWORDLEFT)
+
+ ed.SetText(demoText)
+
+ if wx.USE_UNICODE:
+ import codecs
+ decode = codecs.lookup("utf-8")[1]
+
+ ed.GotoPos(ed.GetLength())
+ ed.AddText("\n\nwx.StyledTextCtrl can also do Unicode:\n")
+ uniline = ed.GetCurrentLine()
+ unitext, l = decode('\xd0\x9f\xd0\xb8\xd1\x82\xd0\xbe\xd0\xbd - '
+ '\xd0\xbb\xd1\x83\xd1\x87\xd1\x88\xd0\xb8\xd0\xb9 '
+ '\xd1\x8f\xd0\xb7\xd1\x8b\xd0\xba \xd0\xbf\xd1\x80\xd0\xbe\xd0\xb3\xd1\x80\xd0\xb0\xd0\xbc\xd0\xbc\xd0\xb8\xd1\x80\xd0\xbe\xd0\xb2\xd0\xb0\xd0\xbd\xd0\xb8\xd1\x8f!\n\n')
+ ed.AddText('\tRussian: ')
+ ed.AddText(unitext)
+ ed.GotoPos(0)
+ #else:
+ # #ed.StyleSetFontEncoding(stc.STC_STYLE_DEFAULT, wx.FONTENCODING_KOI8)
+ # #text = u'\u041f\u0438\u0442\u043e\u043d - \u043b\u0443\u0447\u0448\u0438\u0439 \u044f\u0437\u044b\u043a \n\u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u044f!'
+ # #text = text.encode('koi8-r')
+ # #ed.StyleSetFontEncoding(stc.STC_STYLE_DEFAULT, wx.FONTENCODING_BIG5)
+ # #text = u'Python \u662f\u6700\u597d\u7684\u7de8\u7a0b\u8a9e\u8a00\uff01'
+ # #text = text.encode('big5')
+ # ed.GotoPos(ed.GetLength())
+ # ed.AddText('\n\n' + text)
+
+ ed.EmptyUndoBuffer()
+
+ # make some styles
+ ed.StyleSetSpec(stc.STC_STYLE_DEFAULT, "size:%d,face:%s" % (pb, face3))
+ ed.StyleClearAll()
+ ed.StyleSetSpec(1, "size:%d,bold,face:%s,fore:#0000FF" % (pb, face1))
+ ed.StyleSetSpec(2, "face:%s,italic,fore:#FF0000,size:%d" % (face2, pb))
+ ed.StyleSetSpec(3, "face:%s,bold,size:%d" % (face2, pb))
+ ed.StyleSetSpec(4, "face:%s,size:%d" % (face1, pb-1))
+ ed.StyleSetSpec(5, "back:#FFF0F0")
+
+ # Now set some text to those styles... Normally this would be
+ # done in an event handler that happens when text needs displayed.
+ ed.StartStyling(98, 0xff)
+ ed.SetStyling(6, 1) # set style for 6 characters using style 1
+
+ ed.StartStyling(190, 0xff)
+ ed.SetStyling(20, 2)
+
+ ed.StartStyling(310, 0xff)
+ ed.SetStyling(4, 3)
+ ed.SetStyling(2, 0)
+ ed.SetStyling(10, 4)
+
+
+ # line numbers in the margin
+ ed.SetMarginType(0, stc.STC_MARGIN_NUMBER)
+ ed.SetMarginWidth(0, 22)
+ ed.StyleSetSpec(stc.STC_STYLE_LINENUMBER, "size:%d,face:%s" % (pb-2, face1))
+
+ # setup some markers
+ ed.SetMarginType(1, stc.STC_MARGIN_SYMBOL)
+ ed.MarkerDefine(0, stc.STC_MARK_ROUNDRECT, "#CCFF00", "RED")
+ ed.MarkerDefine(1, stc.STC_MARK_CIRCLE, "FOREST GREEN", "SIENNA")
+ ed.MarkerDefine(2, stc.STC_MARK_SHORTARROW, "blue", "blue")
+ ed.MarkerDefine(3, stc.STC_MARK_ARROW, "#00FF00", "#00FF00")
+
+ # put some markers on some lines
+ ed.MarkerAdd(17, 0)
+ ed.MarkerAdd(18, 1)
+ ed.MarkerAdd(19, 2)
+ ed.MarkerAdd(20, 3)
+ ed.MarkerAdd(20, 0)
+
+
+ # and an indicator or two
+ ed.IndicatorSetStyle(0, stc.STC_INDIC_SQUIGGLE)
+ ed.IndicatorSetForeground(0, wx.RED)
+ ed.IndicatorSetStyle(1, stc.STC_INDIC_DIAGONAL)
+ ed.IndicatorSetForeground(1, wx.BLUE)
+ ed.IndicatorSetStyle(2, stc.STC_INDIC_STRIKE)
+ ed.IndicatorSetForeground(2, wx.RED)
+
+ ed.StartStyling(836, stc.STC_INDICS_MASK)
+ ed.SetStyling(10, stc.STC_INDIC0_MASK)
+ ed.SetStyling(8, stc.STC_INDIC1_MASK)
+ ed.SetStyling(10, stc.STC_INDIC2_MASK | stc.STC_INDIC1_MASK)
+
+ # add some annotations
+ ed.AnnotationSetText(23, "\nThis is an annotaion, it is not part of \nthe document's text.\n")
+ ed.AnnotationSetVisible(stc.STC_ANNOTATION_BOXED)
+ ed.AnnotationSetStyle(23, 5) # line number, style number
+
+ # some test stuff...
+ if debug:
+ print "GetTextLength(): ", ed.GetTextLength(), len(ed.GetText())
+ print "GetText(): ", repr(ed.GetText())
+ print
+ print "GetStyledText(98, 104): ", repr(ed.GetStyledText(98, 104)), len(ed.GetStyledText(98, 104))
+ print
+ print "GetCurLine(): ", repr(ed.GetCurLine())
+ ed.GotoPos(5)
+ print "GetCurLine(): ", repr(ed.GetCurLine())
+ print
+ print "GetLine(1): ", repr(ed.GetLine(1))
+ print
+ ed.SetSelection(25, 35)
+ print "GetSelectedText(): ", repr(ed.GetSelectedText())
+ print "GetTextRange(25, 35): ", repr(ed.GetTextRange(25, 35))
+ print "FindText(0, max, 'indicators'): ",
+ print ed.FindText(0, ed.GetTextLength(), "indicators")
+ if wx.USE_UNICODE:
+ end = ed.GetLength()
+ start = ed.PositionFromLine(uniline)
+ print "GetTextRange(%d, %d): " % (start, end),
+ print repr(ed.GetTextRange(start, end))
+
+
+ wx.CallAfter(ed.GotoPos, 0)
+ return p
+
+
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+
+Once again, no docs yet. Sorry. But this
+and this should
+be helpful.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/StyledTextCtrl_2.py b/demo/StyledTextCtrl_2.py
new file mode 100644
index 00000000..7926e07c
--- /dev/null
+++ b/demo/StyledTextCtrl_2.py
@@ -0,0 +1,409 @@
+
+import keyword
+
+import wx
+import wx.stc as stc
+
+import images
+
+#----------------------------------------------------------------------
+
+demoText = """\
+## This version of the editor has been set up to edit Python source
+## code. Here is a copy of wxPython/demo/Main.py to play with.
+
+
+"""
+
+#----------------------------------------------------------------------
+
+
+if wx.Platform == '__WXMSW__':
+ faces = { 'times': 'Times New Roman',
+ 'mono' : 'Courier New',
+ 'helv' : 'Arial',
+ 'other': 'Comic Sans MS',
+ 'size' : 10,
+ 'size2': 8,
+ }
+elif wx.Platform == '__WXMAC__':
+ faces = { 'times': 'Times New Roman',
+ 'mono' : 'Monaco',
+ 'helv' : 'Arial',
+ 'other': 'Comic Sans MS',
+ 'size' : 12,
+ 'size2': 10,
+ }
+else:
+ faces = { 'times': 'Times',
+ 'mono' : 'Courier',
+ 'helv' : 'Helvetica',
+ 'other': 'new century schoolbook',
+ 'size' : 12,
+ 'size2': 10,
+ }
+
+
+#----------------------------------------------------------------------
+
+class PythonSTC(stc.StyledTextCtrl):
+
+ fold_symbols = 2
+
+ def __init__(self, parent, ID,
+ pos=wx.DefaultPosition, size=wx.DefaultSize,
+ style=0):
+ stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
+
+ self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
+ self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
+
+ self.SetLexer(stc.STC_LEX_PYTHON)
+ self.SetKeyWords(0, " ".join(keyword.kwlist))
+
+ self.SetProperty("fold", "1")
+ self.SetProperty("tab.timmy.whinge.level", "1")
+ self.SetMargins(0,0)
+
+ self.SetViewWhiteSpace(False)
+ #self.SetBufferedDraw(False)
+ #self.SetViewEOL(True)
+ #self.SetEOLMode(stc.STC_EOL_CRLF)
+ #self.SetUseAntiAliasing(True)
+
+ self.SetEdgeMode(stc.STC_EDGE_BACKGROUND)
+ self.SetEdgeColumn(78)
+
+ # Setup a margin to hold fold markers
+ #self.SetFoldFlags(16) ### WHAT IS THIS VALUE? WHAT ARE THE OTHER FLAGS? DOES IT MATTER?
+ self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)
+ self.SetMarginMask(2, stc.STC_MASK_FOLDERS)
+ self.SetMarginSensitive(2, True)
+ self.SetMarginWidth(2, 12)
+
+ if self.fold_symbols == 0:
+ # Arrow pointing right for contracted folders, arrow pointing down for expanded
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, stc.STC_MARK_ARROWDOWN, "black", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDER, stc.STC_MARK_ARROW, "black", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, stc.STC_MARK_EMPTY, "black", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, stc.STC_MARK_EMPTY, "black", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, stc.STC_MARK_EMPTY, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_EMPTY, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_EMPTY, "white", "black")
+
+ elif self.fold_symbols == 1:
+ # Plus for contracted folders, minus for expanded
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, stc.STC_MARK_MINUS, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDER, stc.STC_MARK_PLUS, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, stc.STC_MARK_EMPTY, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, stc.STC_MARK_EMPTY, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, stc.STC_MARK_EMPTY, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_EMPTY, "white", "black")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_EMPTY, "white", "black")
+
+ elif self.fold_symbols == 2:
+ # Like a flattened tree control using circular headers and curved joins
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, stc.STC_MARK_CIRCLEMINUS, "white", "#404040")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDER, stc.STC_MARK_CIRCLEPLUS, "white", "#404040")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, stc.STC_MARK_VLINE, "white", "#404040")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, stc.STC_MARK_LCORNERCURVE, "white", "#404040")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, stc.STC_MARK_CIRCLEPLUSCONNECTED, "white", "#404040")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_CIRCLEMINUSCONNECTED, "white", "#404040")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNERCURVE, "white", "#404040")
+
+ elif self.fold_symbols == 3:
+ # Like a flattened tree control using square headers
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, stc.STC_MARK_BOXMINUS, "white", "#808080")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDER, stc.STC_MARK_BOXPLUS, "white", "#808080")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB, stc.STC_MARK_VLINE, "white", "#808080")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL, stc.STC_MARK_LCORNER, "white", "#808080")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND, stc.STC_MARK_BOXPLUSCONNECTED, "white", "#808080")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_BOXMINUSCONNECTED, "white", "#808080")
+ self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_TCORNER, "white", "#808080")
+
+
+ self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI)
+ self.Bind(stc.EVT_STC_MARGINCLICK, self.OnMarginClick)
+ self.Bind(wx.EVT_KEY_DOWN, self.OnKeyPressed)
+
+ # Make some styles, The lexer defines what each style is used for, we
+ # just have to define what each style looks like. This set is adapted from
+ # Scintilla sample property files.
+
+ # Global default styles for all languages
+ self.StyleSetSpec(stc.STC_STYLE_DEFAULT, "face:%(helv)s,size:%(size)d" % faces)
+ self.StyleClearAll() # Reset all to be like the default
+
+ # Global default styles for all languages
+ self.StyleSetSpec(stc.STC_STYLE_DEFAULT, "face:%(helv)s,size:%(size)d" % faces)
+ self.StyleSetSpec(stc.STC_STYLE_LINENUMBER, "back:#C0C0C0,face:%(helv)s,size:%(size2)d" % faces)
+ self.StyleSetSpec(stc.STC_STYLE_CONTROLCHAR, "face:%(other)s" % faces)
+ self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT, "fore:#FFFFFF,back:#0000FF,bold")
+ self.StyleSetSpec(stc.STC_STYLE_BRACEBAD, "fore:#000000,back:#FF0000,bold")
+
+ # Python styles
+ # Default
+ self.StyleSetSpec(stc.STC_P_DEFAULT, "fore:#000000,face:%(helv)s,size:%(size)d" % faces)
+ # Comments
+ self.StyleSetSpec(stc.STC_P_COMMENTLINE, "fore:#007F00,face:%(other)s,size:%(size)d" % faces)
+ # Number
+ self.StyleSetSpec(stc.STC_P_NUMBER, "fore:#007F7F,size:%(size)d" % faces)
+ # String
+ self.StyleSetSpec(stc.STC_P_STRING, "fore:#7F007F,face:%(helv)s,size:%(size)d" % faces)
+ # Single quoted string
+ self.StyleSetSpec(stc.STC_P_CHARACTER, "fore:#7F007F,face:%(helv)s,size:%(size)d" % faces)
+ # Keyword
+ self.StyleSetSpec(stc.STC_P_WORD, "fore:#00007F,bold,size:%(size)d" % faces)
+ # Triple quotes
+ self.StyleSetSpec(stc.STC_P_TRIPLE, "fore:#7F0000,size:%(size)d" % faces)
+ # Triple double quotes
+ self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE, "fore:#7F0000,size:%(size)d" % faces)
+ # Class name definition
+ self.StyleSetSpec(stc.STC_P_CLASSNAME, "fore:#0000FF,bold,underline,size:%(size)d" % faces)
+ # Function or method name definition
+ self.StyleSetSpec(stc.STC_P_DEFNAME, "fore:#007F7F,bold,size:%(size)d" % faces)
+ # Operators
+ self.StyleSetSpec(stc.STC_P_OPERATOR, "bold,size:%(size)d" % faces)
+ # Identifiers
+ self.StyleSetSpec(stc.STC_P_IDENTIFIER, "fore:#000000,face:%(helv)s,size:%(size)d" % faces)
+ # Comment-blocks
+ self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, "fore:#7F7F7F,size:%(size)d" % faces)
+ # End of line where string is not closed
+ self.StyleSetSpec(stc.STC_P_STRINGEOL, "fore:#000000,face:%(mono)s,back:#E0C0E0,eol,size:%(size)d" % faces)
+
+ self.SetCaretForeground("BLUE")
+
+
+ # register some images for use in the AutoComplete box.
+ self.RegisterImage(1, images.Smiles.GetBitmap())
+ self.RegisterImage(2,
+ wx.ArtProvider.GetBitmap(wx.ART_NEW, size=(16,16)))
+ self.RegisterImage(3,
+ wx.ArtProvider.GetBitmap(wx.ART_COPY, size=(16,16)))
+
+
+ def OnKeyPressed(self, event):
+ if self.CallTipActive():
+ self.CallTipCancel()
+ key = event.GetKeyCode()
+
+ if key == 32 and event.ControlDown():
+ pos = self.GetCurrentPos()
+
+ # Tips
+ if event.ShiftDown():
+ self.CallTipSetBackground("yellow")
+ self.CallTipShow(pos, 'lots of of text: blah, blah, blah\n\n'
+ 'show some suff, maybe parameters..\n\n'
+ 'fubar(param1, param2)')
+ # Code completion
+ else:
+ #lst = []
+ #for x in range(50000):
+ # lst.append('%05d' % x)
+ #st = " ".join(lst)
+ #print len(st)
+ #self.AutoCompShow(0, st)
+
+ kw = keyword.kwlist[:]
+ kw.append("zzzzzz?2")
+ kw.append("aaaaa?2")
+ kw.append("__init__?3")
+ kw.append("zzaaaaa?2")
+ kw.append("zzbaaaa?2")
+ kw.append("this_is_a_longer_value")
+ #kw.append("this_is_a_much_much_much_much_much_much_much_longer_value")
+
+ kw.sort() # Python sorts are case sensitive
+ self.AutoCompSetIgnoreCase(False) # so this needs to match
+
+ # Images are specified with a appended "?type"
+ for i in range(len(kw)):
+ if kw[i] in keyword.kwlist:
+ kw[i] = kw[i] + "?1"
+
+ self.AutoCompShow(0, " ".join(kw))
+ else:
+ event.Skip()
+
+
+ def OnUpdateUI(self, evt):
+ # check for matching braces
+ braceAtCaret = -1
+ braceOpposite = -1
+ charBefore = None
+ caretPos = self.GetCurrentPos()
+
+ if caretPos > 0:
+ charBefore = self.GetCharAt(caretPos - 1)
+ styleBefore = self.GetStyleAt(caretPos - 1)
+
+ # check before
+ if charBefore and chr(charBefore) in "[]{}()" and styleBefore == stc.STC_P_OPERATOR:
+ braceAtCaret = caretPos - 1
+
+ # check after
+ if braceAtCaret < 0:
+ charAfter = self.GetCharAt(caretPos)
+ styleAfter = self.GetStyleAt(caretPos)
+
+ if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:
+ braceAtCaret = caretPos
+
+ if braceAtCaret >= 0:
+ braceOpposite = self.BraceMatch(braceAtCaret)
+
+ if braceAtCaret != -1 and braceOpposite == -1:
+ self.BraceBadLight(braceAtCaret)
+ else:
+ self.BraceHighlight(braceAtCaret, braceOpposite)
+ #pt = self.PointFromPosition(braceOpposite)
+ #self.Refresh(True, wxRect(pt.x, pt.y, 5,5))
+ #print pt
+ #self.Refresh(False)
+
+
+ def OnMarginClick(self, evt):
+ # fold and unfold as needed
+ if evt.GetMargin() == 2:
+ if evt.GetShift() and evt.GetControl():
+ self.FoldAll()
+ else:
+ lineClicked = self.LineFromPosition(evt.GetPosition())
+
+ if self.GetFoldLevel(lineClicked) & stc.STC_FOLDLEVELHEADERFLAG:
+ if evt.GetShift():
+ self.SetFoldExpanded(lineClicked, True)
+ self.Expand(lineClicked, True, True, 1)
+ elif evt.GetControl():
+ if self.GetFoldExpanded(lineClicked):
+ self.SetFoldExpanded(lineClicked, False)
+ self.Expand(lineClicked, False, True, 0)
+ else:
+ self.SetFoldExpanded(lineClicked, True)
+ self.Expand(lineClicked, True, True, 100)
+ else:
+ self.ToggleFold(lineClicked)
+
+
+ def FoldAll(self):
+ lineCount = self.GetLineCount()
+ expanding = True
+
+ # find out if we are folding or unfolding
+ for lineNum in range(lineCount):
+ if self.GetFoldLevel(lineNum) & stc.STC_FOLDLEVELHEADERFLAG:
+ expanding = not self.GetFoldExpanded(lineNum)
+ break
+
+ lineNum = 0
+
+ while lineNum < lineCount:
+ level = self.GetFoldLevel(lineNum)
+ if level & stc.STC_FOLDLEVELHEADERFLAG and \
+ (level & stc.STC_FOLDLEVELNUMBERMASK) == stc.STC_FOLDLEVELBASE:
+
+ if expanding:
+ self.SetFoldExpanded(lineNum, True)
+ lineNum = self.Expand(lineNum, True)
+ lineNum = lineNum - 1
+ else:
+ lastChild = self.GetLastChild(lineNum, -1)
+ self.SetFoldExpanded(lineNum, False)
+
+ if lastChild > lineNum:
+ self.HideLines(lineNum+1, lastChild)
+
+ lineNum = lineNum + 1
+
+
+
+ def Expand(self, line, doExpand, force=False, visLevels=0, level=-1):
+ lastChild = self.GetLastChild(line, level)
+ line = line + 1
+
+ while line <= lastChild:
+ if force:
+ if visLevels > 0:
+ self.ShowLines(line, line)
+ else:
+ self.HideLines(line, line)
+ else:
+ if doExpand:
+ self.ShowLines(line, line)
+
+ if level == -1:
+ level = self.GetFoldLevel(line)
+
+ if level & stc.STC_FOLDLEVELHEADERFLAG:
+ if force:
+ if visLevels > 1:
+ self.SetFoldExpanded(line, True)
+ else:
+ self.SetFoldExpanded(line, False)
+
+ line = self.Expand(line, doExpand, force, visLevels-1)
+
+ else:
+ if doExpand and self.GetFoldExpanded(line):
+ line = self.Expand(line, True, force, visLevels-1)
+ else:
+ line = self.Expand(line, False, force, visLevels-1)
+ else:
+ line = line + 1
+
+ return line
+
+
+#----------------------------------------------------------------------
+
+_USE_PANEL = 1
+
+def runTest(frame, nb, log):
+ if not _USE_PANEL:
+ ed = p = PythonSTC(nb, -1)
+ else:
+ p = wx.Panel(nb, -1, style = wx.NO_FULL_REPAINT_ON_RESIZE)
+ ed = PythonSTC(p, -1)
+ s = wx.BoxSizer(wx.HORIZONTAL)
+ s.Add(ed, 1, wx.EXPAND)
+ p.SetSizer(s)
+ p.SetAutoLayout(True)
+
+
+ ed.SetText(demoText + open('Main.py').read())
+ ed.EmptyUndoBuffer()
+ ed.Colourise(0, -1)
+
+ # line numbers in the margin
+ ed.SetMarginType(1, stc.STC_MARGIN_NUMBER)
+ ed.SetMarginWidth(1, 25)
+
+ return p
+
+
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+
+Once again, no docs yet. Sorry. But this
+and this should
+be helpful.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
+
+
+
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+
diff --git a/demo/SystemSettings.py b/demo/SystemSettings.py
new file mode 100644
index 00000000..d3861bb4
--- /dev/null
+++ b/demo/SystemSettings.py
@@ -0,0 +1,325 @@
+###############################################################################
+# Name: SystemSettingsDemo.py #
+# Purpose: SystemSettings Test and Demo File #
+# Author: Cody Precord #
+# Copyright: (c) 2009 Cody Precord #
+# Licence: wxWindows Licence #
+###############################################################################
+
+"""
+wx.SystemSettings:
+
+
Allows the application to ask for details about the system.
+
+
This can include settings such as standard colours, fonts, and user interface
+element sizes.
+
+This demo shows various ways of using the new
+ PrintOut class. To understand the class you need to examine the demo examples
+and the library printout.py module classes.
+
+The initial class primarily contains a Table preview/printing class. There is a lot of flexibility
+in manipulating the placement, sizing, colours, alignment of the table text and cell background colors.
+There are also a number of options for printing Header and Footer information on the page.
+
+There is also a class to extract the parameters from a wxGrid and easily recreate a Table printout.
+
+The data is printed from a list object containing the column and row values. The label or table header
+can be defined and will be repeated for all pages.
+
+The correct "Total Page" does get calculated and used in the print out Footer.
+
+There is still problems with the print framework to properly get the total pages in the preview unless
+the program knows it before trying to parse through the available pages. This will be fixed
+when the framework allows for it.
+
+
+""" % os.path.join(os.path.dirname(printout.__file__), "printout.py")
+
+
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/TestTable.txt b/demo/TestTable.txt
new file mode 100644
index 00000000..beaccdef
--- /dev/null
+++ b/demo/TestTable.txt
@@ -0,0 +1,38 @@
+Name Type Platform Location Availability Description
+WebReuser Development Windows 95, Windows NT, HPUX 9.05 and 10.2, Solaris 2.4 and 2.5 http://www.stablesoft.com Evaluation WebReuser is a re-use tool from Hitachi Europe Limited. WebReuser is a tool that simplifies software reuse. Its ability to track, schematize and search documents makes it the ideal way to understand C++ code. These features also make WebReuser an ideal tool to classify any Web resource. WebReuser can even be used for more general documentation management tasks.
+MacAnova Development Windows, Motif, Mac http://www.stat.umn.edu/~gary/macanova/macanova.home.html Free A large statistical application from the School of Statistics, University of Minnesota. It is based on a modified version of wxWindows 1.65.
+Hardy Development Win 3.1, WIN32, Motif (Sun only) http://www.aiai.ed.ac.uk/~hardy/ Freeware for personal and academic use A hypertext-based diagramming and knowledge-based system development tool, with NASA's CLIPS built-in. It is a superset of wxCLIPS.
+wxCLIPS Development Win 3.1, WIN32, Motif, XView http://web.ukonline.co.uk/julian.smart/wxclips Freeware A GUI development environment for CLIPS applications.
+wxPython Development wxWindows 2 for the new version http://alldunn.com/wxPython/ Freeware Python/wxWindows combination by Robin Dunn and Harri Pasanen. Python is an elegant object-oriented, interpreted language that runs on many platforms.
+MrEd Development Win 3.1, WIN32, Motif, XView http://www.cs.rice.edu/CS/PLT/packages/mred/ Freeware MrEd is a combined editor and Scheme development environment by Matthew Flatt.
+WXLisp Development Win 3.1, WIN32, Motif, XView http://www.cadlab.de/~lipuser/wxlisp/wxlisp.html Freeware A combination of wxWindows and XLisp.
+Scriptum Development Motif http://www.isoft.com.ar/eng/products/system/scriptum.html Freeware Graphical editor with visual highlighting, navigation/browsing, undo, class browser for C++ and Java, source code management, file locking, remote editing using ftp, configurable.
+WipeOut Development XView/Linux http://www.softwarebuero.de/wipeout-eng.html Giftware WipeOut is an integrated development environment for C++ projects, available for Linux/XView. The authors are working on versions for SunOS/Solaris. Source is available for porting to other platforms.
+OPL Development Win 3.1, WIN32, Motif, XView http://www.ozemail.com.au/~adavison/ Freeware Object Prolog is a portable implementation of Prolog by Andrew Davison, with object-oriented extensions, entirely written in C++. In the initial version, a binding to wxWindows is available. In the revamped version, this binding has not been written yet.
+Dataplore Graphics and sound Windows, other? http://www.datan.de/dataplore Commercial Data visualisation tool, from Datan
+VCG Tool Graphics and sound Win 3.1, WIN32, Motif, XView http://www.cs.uni-sb.de:80/RW/users/sander/html/gsvcg1.html Freeware A graph layout tool similar to GraphPlace, but with extensions. Very nice indeed!
+Y.E.S. Graphics and sound Win 3.1, WIN32, XView (Linux) ftp://ftp.musik.uni-essen.de/pub/EsAC/program/ Shareware Monophonic notation program.
+JAZZ Graphics and sound XView (Linux) http://rokke.aug.hiagder.no/per/jazz.html Freeware A MIDI sequencer for Linux.
+ISP Graphics and sound Win 3.1, WIN32, Motif, XView ftp://www.remstar.com/pub/wxwin/contrib/isp-100/ Freeware Image and sound player educational tool.
+ClockWorks Graphics and sound Win 3.1, WIN32, Motif, XView http://web.ukonline.co.uk/Members/julian.smart/freesoft.html#clockworks Freeware A configurable analogue clock, with a collection of 'fine art' faces. By Julian Smart.
+M Miscellaneous Windows 95, Windows NT, Linux http://www.phy.hw.ac.uk/~karsten/M/index.html GPL M is a cross-platform e-mail application. It will be available for X11/Unix and Windows platforms, supporting a wide range of e-mail transfer protocols as well as including full MIME support. M's wealth of features and ease of use make it one of the most powerful MUAs available, providing a consistent and intuitive interface across all platforms.
+Boolean Miscellaneous Windows 95, Windows NT, Solaris http://www.xs4all.nl/~kholwerd/bool.html Freeware A GDSII CAD file format viewer, and program to perform boolean operations on sets of 2D polygons. By Klaas Holwerda.
+TimeMan Miscellaneous wxGTK, Unix http://www.bgif.no/neureka/TimeMan/ Freeware A time manager, written using wxGTK
+Forty Thieves Miscellaneous Motif, Windows apps/forty/forty.htm Freeware A fiendish patience game, by Chris Breeze. A nice demo of what's possible with wxWindows.
+Lean Integration Platform Miscellaneous Windows NT, various flavours of UNIX http://www.c-lab.de/~lipuser/lip To be decided LIP is a workflow-oriented tool integration system which uses wxLisp (and thus wxWindows) as an implementation basis. Lisp combined with the wxWindows bindings make up the compatible extension language platform of the system.
+wxWeb Miscellaneous Win 3.1, WIN32, Motif ftp://www.remstar.com/pub/wxwin/contrib/wxweb Freeware Andrew Davison's Web browser, with SimSock portable socket library and wxHtml canvas. Includes an http server for UNIX and Windows.
+SANTIS Miscellaneous Win 3.1, Windows 95, Linux, Solaris OpenLook and Motif, Silicon Graphics http://www.physiology.rwth-aachen.de/bs/santis/ Free for non-commercial use SANTIS is a software tool designed for the analysis of signals and time series data of any kind, in particular for scientific purposes. It was developed at the Laboratory of Biomedical Systems Analysis, Institute of Physiology at the University of Aachen, Germany.
+Xbaies Miscellaneous Win 3.1, WIN32, Motif, XView xbaies.htm Freeware A shell for building Bayesian network models, by Robert Cowell.
+wxTinyBB Miscellaneous Win 3.1, WIN32, Motif, XView ftp://www.remstar.com/pub/wxwin/contrib/wxtinybb Freeware/commercial A tiny blackboard shell demo showing an embedded (commercial) Prolog engine. Demo written by Arvindra Sehmi. A good example of a nice interface using wxWindows.
+Gambit Miscellaneous Win 3.1, WIN32, Motif, XView http://www.hss.caltech.edu/~gambit/Gambit.html Freeware A large wxWindows application with source, and features such as a table control with printing.
+Tex2RTF Miscellaneous Win 3.1, WIN32, Motif, XView http://web.ukonline.co.uk/julian.smart/tex2rtf Freeware Converts subset of LaTeX syntax to WinHelp, wordprocessor RTF, HTML, and wxHelp. As used for wxWindows documentation.
+wxPoem Miscellaneous Win 3.1, WIN32, Motif, XView none.htm Freeware A poetry display program for wxWindows. Included as a sample in the wxWindows distribution.
+Sonar tracking software Miscellaneous See Web site http://www.desertstar.com Demonstration Miscellaneous sonar tracking software from Desert Star Systems, who use wxWindows for all their Windows-based software.
+Name Research software Platform Location Availability Description
+DisCo Research software N/A http://www.cs.tut.fi/laitos/DisCo/tool.fm.html N/A A tool for specification of reactive systems.
+CAFE Research software N/A cafe.htm N/A Cellular Analysis of Fire and Extinction
+CODA Research software See Web site http://www.ozemail.com.au/~mbedward/coda/coda.html See Web site CODA assists in the design of networks of nature reserves or protected areas. It has been used for major reserve planning studies, as a teaching resource and for research into conservation planning methods.
+EGRESS Research software N/A http://www.aiai.ed.ac.uk/~jimd/Egress2/projInfo_contents.html N/A An evacuation decision model.
+ACT Research software N/A none.htm N/A A general process and tracker and automator being built at NASA.
+Rectangular nesting program Research software N/A http://www.elec-eng.leeds.ac.uk/een5mpd/research.html N/A Optimized layout of rectangles on a page.
+Finite element post processor Research software N/A http://www.ime.auc.dk/afd3/odessy/manuals/index.htm N/A Finite element postprocessor, produced at Aalborg University in Denmark by John Rasmussen and Erik Lund.
diff --git a/demo/TextCtrl.py b/demo/TextCtrl.py
new file mode 100644
index 00000000..6b19578c
--- /dev/null
+++ b/demo/TextCtrl.py
@@ -0,0 +1,178 @@
+
+import sys
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ # def OnSetFocus(self, evt):
+ # print "OnSetFocus"
+ # evt.Skip()
+ # def OnKillFocus(self, evt):
+ # print "OnKillFocus"
+ # evt.Skip()
+ # def OnWindowDestroy(self, evt):
+ # print "OnWindowDestroy"
+ # evt.Skip()
+
+
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ l1 = wx.StaticText(self, -1, "wx.TextCtrl")
+ t1 = wx.TextCtrl(self, -1, "Test it out and see", size=(125, -1))
+ wx.CallAfter(t1.SetInsertionPoint, 0)
+ self.tc1 = t1
+
+ self.Bind(wx.EVT_TEXT, self.EvtText, t1)
+ t1.Bind(wx.EVT_CHAR, self.EvtChar)
+ # t1.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus)
+ # t1.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
+ # t1.Bind(wx.EVT_WINDOW_DESTROY, self.OnWindowDestroy)
+
+ l2 = wx.StaticText(self, -1, "Password")
+ t2 = wx.TextCtrl(self, -1, "", size=(125, -1), style=wx.TE_PASSWORD)
+ self.Bind(wx.EVT_TEXT, self.EvtText, t2)
+
+ l3 = wx.StaticText(self, -1, "Multi-line")
+ t3 = wx.TextCtrl(self, -1,
+ "Here is a looooooooooooooong line of text set in the control.\n\n"
+ "The quick brown fox jumped over the lazy dog...",
+ size=(200, 100), style=wx.TE_MULTILINE|wx.TE_PROCESS_ENTER)
+
+ t3.SetInsertionPoint(0)
+ self.Bind(wx.EVT_TEXT, self.EvtText, t3)
+ self.Bind(wx.EVT_TEXT_ENTER, self.EvtTextEnter, t3)
+
+ b = wx.Button(self, -1, "Test Replace")
+ self.Bind(wx.EVT_BUTTON, self.OnTestReplace, b)
+ b2 = wx.Button(self, -1, "Test GetSelection")
+ self.Bind(wx.EVT_BUTTON, self.OnTestGetSelection, b2)
+ b3 = wx.Button(self, -1, "Test WriteText")
+ self.Bind(wx.EVT_BUTTON, self.OnTestWriteText, b3)
+ self.tc = t3
+
+
+ l4 = wx.StaticText(self, -1, "Rich Text")
+ t4 = wx.TextCtrl(self, -1, "If supported by the native control, this is red, and this is a different font.",
+ size=(200, 100), style=wx.TE_MULTILINE|wx.TE_RICH2)
+ t4.SetInsertionPoint(0)
+ t4.SetStyle(44, 47, wx.TextAttr("RED", "YELLOW"))
+ points = t4.GetFont().GetPointSize() # get the current size
+ f = wx.Font(points+3, wx.ROMAN, wx.ITALIC, wx.BOLD, True)
+ t4.SetStyle(63, 77, wx.TextAttr("BLUE", wx.NullColour, f))
+
+ l5 = wx.StaticText(self, -1, "Test Positions")
+ t5 = wx.TextCtrl(self, -1, "0123456789\n" * 5, size=(200, 100),
+ style = wx.TE_MULTILINE
+ #| wx.TE_RICH
+ | wx.TE_RICH2
+ )
+ t5.Bind(wx.EVT_LEFT_DOWN, self.OnT5LeftDown)
+ self.t5 = t5
+
+ space = 6
+ bsizer = wx.BoxSizer(wx.VERTICAL)
+ bsizer.Add(b, 0, wx.GROW|wx.ALL, space)
+ bsizer.Add(b2, 0, wx.GROW|wx.ALL, space)
+ bsizer.Add(b3, 0, wx.GROW|wx.ALL, space)
+
+ sizer = wx.FlexGridSizer(cols=3, hgap=space, vgap=space)
+ sizer.AddMany([ l1, t1, (0,0),
+ l2, t2, (0,0),
+ l3, t3, bsizer,
+ l4, t4, (0,0),
+ l5, t5, (0,0),
+ ])
+ border = wx.BoxSizer(wx.VERTICAL)
+ border.Add(sizer, 0, wx.ALL, 25)
+ self.SetSizer(border)
+ self.SetAutoLayout(True)
+
+
+ def EvtText(self, event):
+ self.log.WriteText('EvtText: %s\n' % event.GetString())
+
+ def EvtTextEnter(self, event):
+ self.log.WriteText('EvtTextEnter\n')
+ event.Skip()
+
+ def EvtChar(self, event):
+ self.log.WriteText('EvtChar: %d\n' % event.GetKeyCode())
+ event.Skip()
+
+
+ def OnTestReplace(self, evt):
+ self.tc.Replace(5, 9, "IS A")
+ #self.tc.Remove(5, 9)
+
+ def OnTestWriteText(self, evt):
+ self.tc.WriteText("TEXT")
+
+ def OnTestGetSelection(self, evt):
+ start, end = self.tc.GetSelection()
+ text = self.tc.GetValue()
+ if wx.Platform == "__WXMSW__": # This is why GetStringSelection was added
+ text = text.replace('\n', '\r\n')
+
+ self.log.write("multi-line GetSelection(): (%d, %d)\n"
+ "\tGetStringSelection(): %s\n"
+ "\tSelectedText: %s\n" %
+ (start, end,
+ self.tc.GetStringSelection(),
+ repr(text[start:end])))
+
+ start, end = self.tc1.GetSelection()
+ text = self.tc1.GetValue()
+
+ if wx.Platform == "__WXMSW__": # This is why GetStringSelection was added
+ text = text.replace('\n', '\r\n')
+
+ self.log.write("single-line GetSelection(): (%d, %d)\n"
+ "\tGetStringSelection(): %s\n"
+ "\tSelectedText: %s\n" %
+ (start, end,
+ self.tc1.GetStringSelection(),
+ repr(text[start:end])))
+
+
+ def OnT5LeftDown(self, evt):
+ evt.Skip()
+ wx.CallAfter(self.LogT5Position, evt)
+
+ def LogT5Position(self, evt):
+ text = self.t5.GetValue()
+ ip = self.t5.GetInsertionPoint()
+ lp = self.t5.GetLastPosition()
+ self.log.write("LogT5Position:\n"
+ "\tGetInsertionPoint:\t%d\n"
+ "\ttext[insertionpoint]:\t%s\n"
+ "\tGetLastPosition:\t%d\n"
+ "\tlen(text):\t\t%d\n"
+ % (ip, text[ip], lp, len(text)))
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+A TextCtrl allows text to be displayed and (possibly) edited. It may be single
+line or multi-line, support styles or not, be read-only or not, and even supports
+text masking for such things as passwords.
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/TextEntryDialog.py b/demo/TextEntryDialog.py
new file mode 100644
index 00000000..568095aa
--- /dev/null
+++ b/demo/TextEntryDialog.py
@@ -0,0 +1,56 @@
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Create and Show a TextEntryDialog", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ dlg = wx.TextEntryDialog(
+ self, 'What is your favorite programming language?',
+ 'Eh??', 'Python')
+
+ dlg.SetValue("Python is the best!")
+
+ if dlg.ShowModal() == wx.ID_OK:
+ self.log.WriteText('You entered: %s\n' % dlg.GetValue())
+
+ dlg.Destroy()
+
+
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+
+overview = """\
+This class represents a dialog that requests a one-line text string from the user.
+It is implemented as a generic wxWindows dialog. Along with the usual wx.Dialog
+style flags, all of the wx.TextCtrl TE_* style flags are accepted, so, for example,
+wx.TE_PASSWORD could be used to create a password dialog.
+
+As with other dialogs of this type, the user input must be retrieved prior to
+destroying the dialog.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/Threads.py b/demo/Threads.py
new file mode 100644
index 00000000..11c6a34d
--- /dev/null
+++ b/demo/Threads.py
@@ -0,0 +1,263 @@
+
+import random
+import time
+import thread
+
+import wx
+import wx.lib.newevent
+
+#----------------------------------------------------------------------
+
+# This creates a new Event class and a EVT binder function
+(UpdateBarEvent, EVT_UPDATE_BARGRAPH) = wx.lib.newevent.NewEvent()
+
+
+#----------------------------------------------------------------------
+
+class CalcBarThread:
+ def __init__(self, win, barNum, val):
+ self.win = win
+ self.barNum = barNum
+ self.val = val
+
+ def Start(self):
+ self.keepGoing = self.running = True
+ thread.start_new_thread(self.Run, ())
+
+ def Stop(self):
+ self.keepGoing = False
+
+ def IsRunning(self):
+ return self.running
+
+ def Run(self):
+ while self.keepGoing:
+ # We communicate with the UI by sending events to it. There can be
+ # no manipulation of UI objects from the worker thread.
+ 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
+ if int(random.random() * 2):
+ self.val = self.val + sleeptime
+ else:
+ self.val = self.val - sleeptime
+
+ if self.val < 0: self.val = 0
+ if self.val > 300: self.val = 300
+
+ self.running = False
+
+#----------------------------------------------------------------------
+
+
+class GraphWindow(wx.Window):
+ def __init__(self, parent, labels):
+ wx.Window.__init__(self, parent, -1)
+
+ self.values = []
+ for label in labels:
+ self.values.append((label, 0))
+
+ font = wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD)
+ self.SetFont(font)
+
+ self.colors = [ wx.RED, wx.GREEN, wx.BLUE, wx.CYAN,
+ "Yellow", "Navy" ]
+
+ self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+ def SetValue(self, index, value):
+ assert index < len(self.values)
+ cur = self.values[index]
+ self.values[index:index+1] = [(cur[0], value)]
+
+
+ def SetFont(self, font):
+ wx.Window.SetFont(self, font)
+ wmax = hmax = 0
+ for label, val in self.values:
+ w,h = self.GetTextExtent(label)
+ if w > wmax: wmax = w
+ if h > hmax: hmax = h
+ self.linePos = wmax + 10
+ self.barHeight = hmax
+
+
+ def GetBestHeight(self):
+ return 2 * (self.barHeight + 1) * len(self.values)
+
+
+ def Draw(self, dc, size):
+ dc.SetFont(self.GetFont())
+ dc.SetTextForeground(wx.BLUE)
+ dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
+ dc.Clear()
+ dc.SetPen(wx.Pen(wx.BLACK, 3, wx.SOLID))
+ dc.DrawLine(self.linePos, 0, self.linePos, size.height-10)
+
+ bh = ypos = self.barHeight
+ for x in range(len(self.values)):
+ label, val = self.values[x]
+ dc.DrawText(label, 5, ypos)
+
+ if val:
+ color = self.colors[ x % len(self.colors) ]
+ dc.SetPen(wx.Pen(color))
+ dc.SetBrush(wx.Brush(color))
+ dc.DrawRectangle(self.linePos+3, ypos, val, bh)
+
+ ypos = ypos + 2*bh
+ if ypos > size[1]-10:
+ break
+
+
+ def OnPaint(self, evt):
+ dc = wx.BufferedPaintDC(self)
+ self.Draw(dc, self.GetSize())
+
+
+ def OnEraseBackground(self, evt):
+ pass
+
+
+
+
+#----------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(self, parent, -1, "Thread Test", size=(450,300))
+ self.log = log
+
+ #self.CenterOnParent()
+
+ 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"
+ "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.SetMinSize((450, self.graph.GetBestHeight()))
+
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(panel, 0, wx.EXPAND)
+ sizer.Add(self.graph, 1, wx.EXPAND)
+
+ self.SetSizer(sizer)
+ self.SetAutoLayout(True)
+ sizer.Fit(self)
+
+ 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.append(CalcBarThread(self, 2, 100))
+ self.threads.append(CalcBarThread(self, 3, 150))
+ self.threads.append(CalcBarThread(self, 4, 225))
+ self.threads.append(CalcBarThread(self, 5, 300))
+ self.threads.append(CalcBarThread(self, 6, 250))
+ self.threads.append(CalcBarThread(self, 7, 175))
+
+ for t in self.threads:
+ t.Start()
+
+ self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+
+ def OnUpdate(self, evt):
+ self.graph.SetValue(evt.barNum, evt.value)
+ self.graph.Refresh(False)
+
+
+ def OnCloseWindow(self, evt):
+ busy = wx.BusyInfo("One moment please, waiting for threads to die...")
+ wx.Yield()
+
+ for t in self.threads:
+ t.Stop()
+
+ running = 1
+
+ while running:
+ running = 0
+
+ for t in self.threads:
+ running = running + t.IsRunning()
+
+ time.sleep(0.1)
+
+ 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):
+ self.win = TestFrame(self, self.log)
+ self.win.Show(True)
+
+
+ def ShutdownDemo(self):
+ if hasattr(self, 'win') and self.win:
+ self.win.Close()
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ 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
+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
+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
+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.
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Throbber.py b/demo/Throbber.py
new file mode 100644
index 00000000..1d9400fd
--- /dev/null
+++ b/demo/Throbber.py
@@ -0,0 +1,248 @@
+
+import wx
+import wx.lib.throbber as throb
+
+import throbImages
+
+from wx.lib.throbber import __doc__ as docString
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ # create the throbbers
+ self.throbbers = {
+ 'plain': { 'throbber': None,
+ 'text': "Plain throbber." },
+ 'reverse': { 'throbber': None,
+ 'text': "This throbber runs in reverse and faster." },
+ 'autoreverse': { 'throbber': None,
+ 'text': "This throbber switches direction." },
+ 'label': { 'throbber': None,
+ 'text': "With a label." },
+ 'overlay': { 'throbber': None,
+ 'text': "With an overlayed image." },
+ 'overlay+text': { 'throbber': None,
+ 'text': "With a label and an overlayed image." },
+ }
+
+ images = [throbImages.catalog[i].GetBitmap()
+ for i in throbImages.index
+ if i not in ['eclouds', 'logo']]
+
+ self.throbbers['plain']['throbber'] = \
+ throb.Throbber(self, -1, images, size=(36, 36),frameDelay = 0.1)
+
+ self.throbbers['reverse']['throbber'] = \
+ throb.Throbber(self, -1, images, frameDelay = 0.07)
+
+ self.throbbers['reverse']['throbber'].Reverse()
+
+ self.throbbers['autoreverse']['throbber'] = \
+ throb.Throbber(self, -1, images, frameDelay = 0.1, reverse = True)
+
+ self.throbbers['autoreverse']['throbber'].sequence.append(0)
+
+ self.throbbers['label']['throbber'] = \
+ throb.Throbber(self, -1, images, frameDelay = 0.1, label = 'Label')
+
+ self.throbbers['label']['throbber'].SetFont(wx.Font(
+ pointSize = 10, family = wx.DEFAULT, style = wx.NORMAL, weight = wx.BOLD
+ ))
+
+ self.throbbers['overlay']['throbber'] = \
+ throb.Throbber(
+ self, -1, images, frameDelay = 0.1,
+ overlay = throbImages.catalog['logo'].GetBitmap()
+ )
+
+ self.throbbers['overlay+text']['throbber'] = \
+ throb.Throbber(
+ self, -1, images, frameDelay = 0.1,
+ overlay = throbImages.catalog['logo'].GetBitmap(), label = "Python!"
+ )
+
+ self.throbbers['overlay+text']['throbber'].SetFont(wx.Font(
+ pointSize = 8, family = wx.DEFAULT, style = wx.NORMAL, weight = wx.BOLD
+ ))
+
+ self.customThrobber = \
+ throb.Throbber(self, -1, images, size=(36, 36),
+ frameDelay = 0.1,
+ rest = 4,
+ sequence = [ 1, 5, 2, 7, 3, 6, 4, 4, 4, 4, 7, 2, 2, 0 ]
+ )
+
+ box = wx.BoxSizer(wx.VERTICAL)
+ sizer = wx.GridBagSizer()
+ box.Add(sizer, 1, wx.EXPAND|wx.ALL, 5)
+
+ row = 2
+
+ # use a list so we can keep our order
+ for t in ['plain', 'reverse', 'autoreverse', 'label', 'overlay', 'overlay+text']:
+ sizer.Add(
+ self.throbbers[t]['throbber'], (row, 0), (1, 1),
+ flag = wx.ALIGN_CENTER|wx.ALL, border=2
+ )
+
+ sizer.Add(
+ wx.StaticText(self, -1, self.throbbers[t]['text']),
+ (row, 1), flag = wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_LEFT
+ )
+
+ row += 1
+
+ # Add custom throbber to sizer.
+ row += 2
+ sizer.Add(
+ self.customThrobber, (row, 0), (1, 1),
+ flag = wx.ALIGN_CENTER|wx.ALL, border=2
+ )
+
+ sizer.Add(
+ wx.StaticText(self, -1, 'with custom & manual sequences'),
+ (row, 1), flag = wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_LEFT
+ )
+
+ sizer.AddGrowableCol(1)
+
+ # start and stop buttons
+ startButton = wx.Button(self, -1, "Start")
+ self.Bind(wx.EVT_BUTTON, self.OnStartAnimation, startButton)
+
+ stopButton = wx.Button(self, -1, "Stop")
+ self.Bind(wx.EVT_BUTTON, self.OnStopAnimation, stopButton)
+
+ buttonBox = wx.BoxSizer(wx.HORIZONTAL)
+ buttonBox.AddMany([
+ (startButton, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL, 5),
+ (stopButton, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL, 5),
+ ])
+
+ sizer.Add(
+ buttonBox, (len(self.throbbers) + 2, 0), (1, 3), flag = wx.ALIGN_CENTER
+ )
+
+ # Buttoms for the custom throbber.
+ nextButton = wx.Button(self, -1, "Next")
+ self.Bind(wx.EVT_BUTTON, self.OnNext, nextButton)
+
+ prevButton = wx.Button(self, -1, "Previous")
+ self.Bind(wx.EVT_BUTTON, self.OnPrevious, prevButton)
+
+ incButton = wx.Button(self, -1, "Increment")
+ self.Bind(wx.EVT_BUTTON, self.OnIncrement, incButton)
+
+ decButton = wx.Button(self, -1, "Decrement")
+ self.Bind(wx.EVT_BUTTON, self.OnDecrement, decButton)
+
+ revButton = wx.Button(self, -1, "Reverse")
+ self.Bind(wx.EVT_BUTTON, self.OnReverse, revButton)
+
+ restButton = wx.Button(self, -1, "Rest")
+ self.Bind(wx.EVT_BUTTON, self.OnRest, restButton)
+
+ startButton = wx.Button(self, -1, "Start")
+ self.Bind(wx.EVT_BUTTON, self.OnStart, startButton)
+
+ stopButton = wx.Button(self, -1, "Stop")
+ self.Bind(wx.EVT_BUTTON, self.OnStop, stopButton)
+
+ customBox1 = wx.BoxSizer(wx.HORIZONTAL)
+ customBox1.AddMany([
+ (nextButton, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL, 5),
+ (prevButton, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL, 5),
+ (incButton, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL, 5),
+ (decButton, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL, 5),
+ (revButton, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL, 5),
+ ])
+
+ customBox2 = wx.BoxSizer(wx.HORIZONTAL)
+ customBox2.AddMany([
+ (restButton, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL, 5),
+ (startButton, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL, 5),
+ (stopButton, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALL, 5),
+ ])
+
+ sizer.Add( customBox1, (len(self.throbbers) + 5, 0), (1, 3), flag = wx.ALIGN_CENTER )
+ sizer.Add( customBox2, (len(self.throbbers) + 6, 0), (1, 3), flag = wx.ALIGN_CENTER )
+
+ # Layout.
+ self.SetSizer(box)
+ self.SetAutoLayout(True)
+ self.Layout()
+ sizer.SetSizeHints(self)
+ sizer.Fit(self)
+
+ for t in self.throbbers.keys():
+ self.throbbers[t]['throbber'].Start()
+
+ self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
+
+ def OnDestroy(self, event):
+ self.log.write("got destroy event")
+ event.Skip()
+
+ def OnStartAnimation(self, event):
+ for t in self.throbbers.keys():
+ self.throbbers[t]['throbber'].Start()
+
+ def OnStopAnimation(self, event):
+ for t in self.throbbers.keys():
+ self.throbbers[t]['throbber'].Rest()
+
+ def OnNext(self, event):
+ self.customThrobber.Next()
+
+ def OnPrevious(self, event):
+ self.customThrobber.Previous()
+
+ def OnIncrement(self, event):
+ self.customThrobber.Increment()
+
+ def OnDecrement(self, event):
+ self.customThrobber.Decrement()
+
+ def OnReverse(self, event):
+ self.customThrobber.Reverse()
+
+ def OnRest(self, event):
+ self.customThrobber.Rest()
+
+ def OnStart(self, event):
+ self.customThrobber.Start()
+
+ def OnStop(self, event):
+ self.customThrobber.Stop()
+
+ def ShutdownDemo(self):
+ for t in self.throbbers.keys():
+ self.throbbers[t]['throbber'].Rest()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
"""
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])])
+
diff --git a/demo/Timer.py b/demo/Timer.py
new file mode 100644
index 00000000..4ed40872
--- /dev/null
+++ b/demo/Timer.py
@@ -0,0 +1,267 @@
+import time
+import wx
+import wx.lib.scrolledpanel as sp
+
+#----------------------------------------------------------------------
+
+
+header = """\
+This demo shows the various ways that wx.Timers can be used in your code. Just
+select one of the buttons in the left column to start a timer in the indicated way,
+and watch the log window below for messages printed when the timer event or callback
+happens. Clicking the corresponding button on the right will stop that timer. Since
+timers are not owned by any other wx object you should hold on to a reference to the
+timer until you are completely finished with it. """
+
+doc1 = """\
+Binding an event handler to the wx.EVT_TIMER event is the
+prefered way to use the wx.Timer class directly. It makes
+handling timer events work just like normal window events. You
+just need to specify the window that is to receive the event in
+the wx.Timer constructor. If that window needs to be able to
+receive events from more than one timer then you can optionally
+specify an ID for the timer and the event binding.
+"""
+
+
+doc2 = """\
+wx.CallLater is a convenience class for wx.Timer. You just
+specify the timeout in milliseconds and a callable object, along
+with any args or keyword args you would like to be passed to your
+callable, and wx.CallLater takes care of the rest. If you don't
+need to get the return value of the callable or to restart the
+timer then there is no need to hold a reference to this object.
+"""
+
+
+doc3 = """\
+If you derive a class from wx.Timer and give it a Notify method
+then it will be called when the timer expires.
+"""
+
+
+doc4 = """\
+wx.PyTimer is the old way (a kludge that goes back all the way to
+the first version of wxPython) to bind a timer directly to a
+callable. You should migrate any code that uses this method to
+use EVT_TIMER instead as this may be deprecated in the future.
+"""
+
+
+class TestPanel(sp.ScrolledPanel):
+ def __init__(self, parent, log):
+ self.log = log
+ sp.ScrolledPanel.__init__(self, parent, -1)
+
+ outsideSizer = wx.BoxSizer(wx.VERTICAL)
+
+ text = wx.StaticText(self, -1, "wx.Timer", style=wx.ALIGN_CENTRE)
+ text.SetFont(wx.Font(24, wx.SWISS, wx.NORMAL, wx.BOLD, False))
+ text.SetSize(text.GetBestSize())
+ text.SetForegroundColour(wx.BLUE)
+ outsideSizer.Add(text, 0, wx.EXPAND|wx.ALL, 5)
+ outsideSizer.Add(wx.StaticText(self, -1, header), 0, wx.ALIGN_CENTER|wx.ALL, 5)
+ outsideSizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND)
+ outsideSizer.Add((20,20))
+
+
+ t1b1 = wx.Button(self, -1, "EVT_TIMER")
+ t1b2 = wx.Button(self, -1, "stop timer")
+ t1st = wx.StaticText(self, -1, doc1)
+ t1b2.Disable()
+ self.Bind(wx.EVT_BUTTON, self.OnTest1Start, t1b1)
+ self.Bind(wx.EVT_BUTTON, self.OnTest1Stop, t1b2)
+
+ # Bind all EVT_TIMER events to self.OnTest1Timer
+ self.Bind(wx.EVT_TIMER, self.OnTest1Timer)
+
+
+ t2b1 = wx.Button(self, -1, "wx.CallLater")
+ t2b2 = wx.Button(self, -1, "stop timer")
+ t2st = wx.StaticText(self, -1, doc2)
+ t2b2.Disable()
+ self.Bind(wx.EVT_BUTTON, self.OnTest2Start, t2b1)
+ self.Bind(wx.EVT_BUTTON, self.OnTest2Stop, t2b2)
+
+ t3b1 = wx.Button(self, -1, "self.Notify")
+ t3b2 = wx.Button(self, -1, "stop timer")
+ t3st = wx.StaticText(self, -1, doc3)
+ t3b2.Disable()
+ self.Bind(wx.EVT_BUTTON, self.OnTest3Start, t3b1)
+ self.Bind(wx.EVT_BUTTON, self.OnTest3Stop, t3b2)
+
+ t4b1 = wx.Button(self, -1, "wx.PyTimer")
+ t4b2 = wx.Button(self, -1, "stop timer")
+ t4st = wx.StaticText(self, -1, doc4)
+ t4b2.Disable()
+ self.Bind(wx.EVT_BUTTON, self.OnTest4Start, t4b1)
+ self.Bind(wx.EVT_BUTTON, self.OnTest4Stop, t4b2)
+
+
+ self.t1b2 = t1b2
+ self.t2b2 = t2b2
+ self.t3b2 = t3b2
+ self.t4b2 = t4b2
+
+ fgs = wx.FlexGridSizer(cols=3, hgap=10, vgap=10)
+ fgs.Add(t1b1)
+ fgs.Add(t1b2)
+ fgs.Add(t1st)
+
+ fgs.Add(t2b1)
+ fgs.Add(t2b2)
+ fgs.Add(t2st)
+
+ fgs.Add(t3b1)
+ fgs.Add(t3b2)
+ fgs.Add(t3st)
+
+ fgs.Add(t4b1)
+ fgs.Add(t4b2)
+ fgs.Add(t4st)
+
+ outsideSizer.Add(fgs, 0, wx.ALIGN_CENTER|wx.ALL, 10)
+ self.SetSizer(outsideSizer)
+ self.SetupScrolling()
+
+
+ # Test 1 shows how to use a timer to generate EVT_TIMER
+ # events, by passing self to the wx.Timer constructor. The
+ # event is bound above to the OnTest1Timer method.
+
+ def OnTest1Start(self, evt):
+ self.t1 = wx.Timer(self)
+ self.t1.Start(1000)
+ self.log.write("EVT_TIMER timer started\n")
+ self.t1b2.Enable()
+
+ def OnTest1Stop(self, evt):
+ self.t1.Stop()
+ self.log.write("EVT_TIMER timer stoped\n")
+ del self.t1
+ self.t1b2.Disable()
+
+ def OnTest1Timer(self, evt):
+ self.log.write("got EVT_TIMER event\n")
+
+
+
+ # Test 2 shows how to use the wx.CallLater class.
+
+ def OnTest2Start(self, evt):
+ # Call OnTest2Timer one second in the future, passing some
+ # optional arbitrary args. There is no need to hold a
+ # reference to this one, unless we want to manipulate or query
+ # it later like we do in the two methods below
+ self.t2 = wx.CallLater(1000, self.OnTest2Timer,
+ 'a', 'b', 'c', one=1, two=2)
+ self.log.write("CallLater scheduled\n")
+ self.t2b2.Enable()
+
+ def OnTest2Stop(self, evt):
+ self.t2.Stop()
+ self.log.write("CallLater stopped, last return value was: %s\n" %
+ repr(self.t2.GetResult()))
+ del self.t2
+ self.t2b2.Disable()
+
+ def OnTest2Timer(self, *args, **kw):
+ self.log.write("CallLater called with args=%s, kwargs=%s\n" % (args, kw))
+
+ # Normally a FutureCall is one-shot, but we can make it
+ # recurring just by calling Restart. We can even use a
+ # different timeout or pass differnt args this time.
+ self.t2.Restart(1500, "restarted")
+
+ # The return value of this function is saved and can be
+ # retrived later. See OnTest2Stop above.
+ return "This is my return value"
+
+
+
+ # Test 3 shows how to use a class derived from wx.Timer. See
+ # also the NotifyTimer class below.
+
+ def OnTest3Start(self, evt):
+ self.t3 = NotifyTimer(self.log)
+ self.t3.Start(1000)
+ self.log.write("NotifyTimer timer started\n")
+ self.t3b2.Enable()
+
+ def OnTest3Stop(self, evt):
+ self.t3.Stop()
+ self.log.write("NotifyTimer timer stoped\n")
+ del self.t3
+ self.t3b2.Disable()
+
+
+
+ # Test 4 shows the old way (a kludge that goes back all the
+ # way to the first version of wxPython) to bind a timer
+ # directly to a callable. You should migrate any code that
+ # uses this method to use EVT_TIMER instead as this may be
+ # deprecated in the future.
+ def OnTest4Start(self, evt):
+ self.t4 = wx.PyTimer(self.OnTest4Timer)
+ self.t4.Start(1000)
+ self.log.write("wx.PyTimer timer started\n")
+ self.t4b2.Enable()
+
+ def OnTest4Stop(self, evt):
+ self.t4.Stop()
+ self.log.write("wx.PyTimer timer stoped\n")
+ del self.t4
+ self.t4b2.Disable()
+
+ def OnTest4Timer(self):
+ self.log.write("got wx.PyTimer event\n")
+
+
+
+#----------------------------------------------------------------------
+
+
+# When deriving from wx.Timer you must provide a Notify method
+# that will be called when the timer expires.
+class NotifyTimer(wx.Timer):
+ def __init__(self, log):
+ wx.Timer.__init__(self)
+ self.log = log
+
+ def Notify(self):
+ self.log.write("got NotifyTimer event\n")
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#----------------------------------------------------------------------
+
+overview = """
+
wx.Timer
+
+The wx.Timer class allows you to execute code at specified intervals
+from within the wxPython event loop. Timers can be one-shot or
+repeating. This demo shows the principle method of using a timer
+(with events) as well as the convenient wx.FutureCall class. Also
+there are two other usage patterns shown here that have been preserved
+for backwards compatibility.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
+
+
diff --git a/demo/ToggleButton.py b/demo/ToggleButton.py
new file mode 100644
index 00000000..50073863
--- /dev/null
+++ b/demo/ToggleButton.py
@@ -0,0 +1,53 @@
+
+import wx
+import images
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+ panel = wx.Panel(self, -1)
+ buttons = wx.BoxSizer(wx.HORIZONTAL)
+
+ for word in "These are toggle buttons".split():
+ b = wx.ToggleButton(panel, -1, word)
+ self.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggle, b)
+ buttons.Add(b, flag=wx.ALL, border=5)
+
+ panel.SetAutoLayout(True)
+ panel.SetSizer(buttons)
+ buttons.Fit(panel)
+ panel.Move((50,50))
+
+ b = wx.ToggleButton(self, -1, "can have bitmaps too", pos=(50,125))
+ b.SetBitmap(images.Mondrian.Bitmap)
+ b.SetInitialSize() # adjust default size for the bitmap
+ self.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggle, b)
+
+ def OnToggle(self, evt):
+ self.log.write("Button %d toggled\n" % evt.GetId())
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+wx.ToggleButton is a button that stays pressed when clicked by the user.
+In other words, it is similar to wxCheckBox in functionality but looks like a
+wxButton.
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/ToolBar.py b/demo/ToolBar.py
new file mode 100644
index 00000000..28f38905
--- /dev/null
+++ b/demo/ToolBar.py
@@ -0,0 +1,252 @@
+
+import wx
+import images
+
+FRAMETB = True
+TBFLAGS = ( wx.TB_HORIZONTAL
+ | wx.NO_BORDER
+ | wx.TB_FLAT
+ #| wx.TB_TEXT
+ #| wx.TB_HORZ_LAYOUT
+ )
+
+#---------------------------------------------------------------------------
+
+class TestSearchCtrl(wx.SearchCtrl):
+ maxSearches = 5
+
+ def __init__(self, parent, id=-1, value="",
+ pos=wx.DefaultPosition, size=wx.DefaultSize, style=0,
+ doSearch=None):
+ style |= wx.TE_PROCESS_ENTER
+ wx.SearchCtrl.__init__(self, parent, id, value, pos, size, style)
+ self.Bind(wx.EVT_TEXT_ENTER, self.OnTextEntered)
+ self.Bind(wx.EVT_MENU_RANGE, self.OnMenuItem, id=1, id2=self.maxSearches)
+ self.doSearch = doSearch
+ self.searches = []
+
+ def OnTextEntered(self, evt):
+ text = self.GetValue()
+ if self.doSearch(text):
+ self.searches.append(text)
+ if len(self.searches) > self.maxSearches:
+ del self.searches[0]
+ self.SetMenu(self.MakeMenu())
+ self.SetValue("")
+
+ def OnMenuItem(self, evt):
+ text = self.searches[evt.GetId()-1]
+ self.doSearch(text)
+
+ def MakeMenu(self):
+ menu = wx.Menu()
+ item = menu.Append(-1, "Recent Searches")
+ item.Enable(False)
+ for idx, txt in enumerate(self.searches):
+ menu.Append(1+idx, txt)
+ return menu
+
+
+
+class TestToolBar(wx.Frame):
+ def __init__(self, parent, log):
+ wx.Frame.__init__(self, parent, -1, 'Test ToolBar', size=(600, 400))
+ self.log = log
+ self.timer = None
+ self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+ client = wx.Panel(self)
+ client.SetBackgroundColour(wx.NamedColour("WHITE"))
+
+ if FRAMETB:
+ # Use the wxFrame internals to create the toolbar and
+ # associate it all in one tidy method call. By using
+ # CreateToolBar or SetToolBar the "client area" of the
+ # frame will be adjusted to exclude the toolbar.
+ tb = self.CreateToolBar( TBFLAGS )
+
+ # Here's a 'simple' toolbar example, and how to bind it using SetToolBar()
+ #tb = wx.ToolBarSimple(self, -1, wx.DefaultPosition, wx.DefaultSize,
+ # wx.TB_HORIZONTAL | wx.NO_BORDER | wx.TB_FLAT)
+ #self.SetToolBar(tb)
+ # But we're doing it a different way here.
+
+ else:
+ # The toolbar can also be a child of another widget, and
+ # be managed by a sizer, although there may be some
+ # implications of doing this on some platforms.
+ tb = wx.ToolBar(client, style=TBFLAGS)
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(tb, 0, wx.EXPAND)
+ client.SetSizer(sizer)
+
+
+ log.write("Default toolbar tool size: %s\n" % tb.GetToolBitmapSize())
+
+ self.CreateStatusBar()
+
+ tsize = (24,24)
+ new_bmp = wx.ArtProvider.GetBitmap(wx.ART_NEW, wx.ART_TOOLBAR, tsize)
+ open_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, tsize)
+ copy_bmp = wx.ArtProvider.GetBitmap(wx.ART_COPY, wx.ART_TOOLBAR, tsize)
+ paste_bmp= wx.ArtProvider.GetBitmap(wx.ART_PASTE, wx.ART_TOOLBAR, tsize)
+
+ tb.SetToolBitmapSize(tsize)
+
+ #tb.AddSimpleTool(10, new_bmp, "New", "Long help for 'New'")
+ tb.AddLabelTool(10, "New", new_bmp, shortHelp="New", longHelp="Long help for 'New'")
+ self.Bind(wx.EVT_TOOL, self.OnToolClick, id=10)
+ self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=10)
+
+ #tb.AddSimpleTool(20, open_bmp, "Open", "Long help for 'Open'")
+ tb.AddLabelTool(20, "Open", open_bmp, shortHelp="Open", longHelp="Long help for 'Open'")
+ self.Bind(wx.EVT_TOOL, self.OnToolClick, id=20)
+ self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=20)
+
+ tb.AddSeparator()
+ tb.AddSimpleTool(30, copy_bmp, "Copy", "Long help for 'Copy'")
+ self.Bind(wx.EVT_TOOL, self.OnToolClick, id=30)
+ self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=30)
+
+ tb.AddSimpleTool(40, paste_bmp, "Paste", "Long help for 'Paste'")
+ self.Bind(wx.EVT_TOOL, self.OnToolClick, id=40)
+ self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=40)
+
+ tb.AddSeparator()
+
+ #tool = tb.AddCheckTool(50, images.Tog1.GetBitmap(), shortHelp="Toggle this")
+ tool = tb.AddCheckLabelTool(50, "Checkable", images.Tog1.GetBitmap(),
+ shortHelp="Toggle this")
+ self.Bind(wx.EVT_TOOL, self.OnToolClick, id=50)
+
+ self.Bind(wx.EVT_TOOL_ENTER, self.OnToolEnter)
+ self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick) # Match all
+ self.Bind(wx.EVT_TIMER, self.OnClearSB)
+
+ tb.AddSeparator()
+ cbID = wx.NewId()
+
+ tb.AddControl(
+ wx.ComboBox(
+ tb, cbID, "", choices=["", "This", "is a", "wx.ComboBox"],
+ size=(150,-1), style=wx.CB_DROPDOWN
+ ))
+ self.Bind(wx.EVT_COMBOBOX, self.OnCombo, id=cbID)
+
+ tb.AddStretchableSpace()
+ search = TestSearchCtrl(tb, size=(150,-1), doSearch=self.DoSearch)
+ tb.AddControl(search)
+
+ # Final thing to do for a toolbar is call the Realize() method. This
+ # causes it to render (more or less, that is).
+ tb.Realize()
+
+
+ def DoSearch(self, text):
+ # called by TestSearchCtrl
+ self.log.WriteText("DoSearch: %s\n" % text)
+ # return true to tell the search ctrl to remember the text
+ return True
+
+
+ def OnToolClick(self, event):
+ self.log.WriteText("tool %s clicked\n" % event.GetId())
+ #tb = self.GetToolBar()
+ tb = event.GetEventObject()
+ tb.EnableTool(10, not tb.GetToolEnabled(10))
+
+ def OnToolRClick(self, event):
+ self.log.WriteText("tool %s right-clicked\n" % event.GetId())
+
+ def OnCombo(self, event):
+ self.log.WriteText("combobox item selected: %s\n" % event.GetString())
+
+ def OnToolEnter(self, event):
+ self.log.WriteText('OnToolEnter: %s, %s\n' % (event.GetId(), event.GetInt()))
+
+ if self.timer is None:
+ self.timer = wx.Timer(self)
+
+ if self.timer.IsRunning():
+ self.timer.Stop()
+
+ self.timer.Start(2000)
+ event.Skip()
+
+
+ def OnClearSB(self, event): # called for the timer event handler
+ self.SetStatusText("")
+ self.timer.Stop()
+ self.timer = None
+
+
+ def OnCloseWindow(self, event):
+ if self.timer is not None:
+ self.timer.Stop()
+ self.timer = None
+ 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 the ToolBar sample", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ win = TestToolBar(self, self.log)
+ win.Show(True)
+ self.frame = win
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+
+
+overview = """\
+wx.ToolBar is a narrow strip of icons on one side of a frame (top, bottom, sides)
+that acts much like a menu does, except it is always visible. Additionally, actual
+wxWindows controls, such as wx.TextCtrl or wx.ComboBox, can be added to the toolbar
+and used from within it.
+
+Toolbar creation is a two-step process. First, the toolbar is defined using the
+various Add* methods of wx.ToolBar. Once all is set up, then wx.Toolbar.Realize()
+must be called to render it.
+
+wx.Toolbar events are also propogated as Menu events; this is especially handy when
+you have a menu bar that contains items that carry out the same function. For example,
+it is not uncommon to have a little 'floppy' toolbar icon to 'save' the current file
+(whatever it is) as well as a FILE/SAVE menu item that does the same thing. In this
+case, both events can be captured and acted upon using the same event handler
+with no ill effects.
+
+If there are cases where a toolbar icon should *not* be associated with a menu item,
+use a unique ID to trap it.
+
+There are a number of ways to create a toolbar for a wx.Frame. wx.Frame.CreateToolBar()
+does all the work except it adds no buttons at all unless you override the virtual method
+OnCreateToolBar(). On the other hand, you can just subclass wx.ToolBar and then use
+wx.Frame.SetToolBar() instead.
+
+Note that wx.TB_DOCKABLE is only supported under GTK. An attempt to alleviate this
+is provided in wx.lib.floatbar, but it is not formally supported.
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Toolbook.py b/demo/Toolbook.py
new file mode 100644
index 00000000..61dd9acf
--- /dev/null
+++ b/demo/Toolbook.py
@@ -0,0 +1,110 @@
+
+import wx
+
+import ColorPanel
+import images
+
+colourList = [ "Aquamarine", "Grey", "Blue", "Blue Violet", "Brown", "Cadet Blue",
+ "Coral", "Wheat", #"Cyan", "Dark Grey", "Dark Green",
+ #"Steel Blue",
+ ]
+
+#----------------------------------------------------------------------------
+
+def getNextImageID(count):
+ imID = 0
+ while True:
+ yield imID
+ imID += 1
+ if imID == count:
+ imID = 0
+
+
+class TestTB(wx.Toolbook):
+ def __init__(self, parent, id, log):
+ wx.Toolbook.__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)
+ imageIdGenerator = getNextImageID(il.GetImageCount())
+
+ # Now make a bunch of panels for the list book
+ first = True
+ for colour in colourList:
+ win = self.makeColorPanel(colour)
+ self.AddPage(win, colour, imageId=imageIdGenerator.next())
+ if first:
+ st = wx.StaticText(win.win, -1,
+ "You can put nearly any type of window here,\n"
+ "and the toolbar can be on either side of the Toolbook",
+ wx.Point(10, 10))
+ first = False
+
+ self.Bind(wx.EVT_TOOLBOOK_PAGE_CHANGED, self.OnPageChanged)
+ self.Bind(wx.EVT_TOOLBOOK_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 = TestTB(nb, -1, log)
+ return testWin
+
+#----------------------------------------------------------------------------
+
+
+overview = """\
+
+
wx.Toolbook
+
+This class is a control similar to a notebook control, but with a
+wx.Toolbar 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:])
+
+
+
diff --git a/demo/TreeCtrl.py b/demo/TreeCtrl.py
new file mode 100644
index 00000000..b00d22de
--- /dev/null
+++ b/demo/TreeCtrl.py
@@ -0,0 +1,211 @@
+
+import string
+import wx
+import images
+
+#---------------------------------------------------------------------------
+
+class MyTreeCtrl(wx.TreeCtrl):
+ def __init__(self, parent, id, pos, size, style, log):
+ wx.TreeCtrl.__init__(self, parent, id, pos, size, style)
+ self.log = log
+
+ def OnCompareItems(self, item1, item2):
+ t1 = self.GetItemText(item1)
+ t2 = self.GetItemText(item2)
+ self.log.WriteText('compare: ' + t1 + ' <> ' + t2 + '\n')
+ if t1 < t2: return -1
+ if t1 == t2: return 0
+ return 1
+
+#---------------------------------------------------------------------------
+
+class TestTreeCtrlPanel(wx.Panel):
+ def __init__(self, parent, log):
+ # Use the WANTS_CHARS style so the panel doesn't eat the Return key.
+ wx.Panel.__init__(self, parent, -1, style=wx.WANTS_CHARS)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+
+ self.log = log
+ tID = wx.NewId()
+
+ self.tree = MyTreeCtrl(self, tID, wx.DefaultPosition, wx.DefaultSize,
+ wx.TR_HAS_BUTTONS
+ | wx.TR_EDIT_LABELS
+ #| wx.TR_MULTIPLE
+ #| wx.TR_HIDE_ROOT
+ , self.log)
+
+ isz = (16,16)
+ il = wx.ImageList(isz[0], isz[1])
+ fldridx = il.Add(wx.ArtProvider_GetBitmap(wx.ART_FOLDER, wx.ART_OTHER, isz))
+ fldropenidx = il.Add(wx.ArtProvider_GetBitmap(wx.ART_FOLDER_OPEN, wx.ART_OTHER, isz))
+ fileidx = il.Add(wx.ArtProvider_GetBitmap(wx.ART_NORMAL_FILE, wx.ART_OTHER, isz))
+ smileidx = il.Add(images.Smiles.GetBitmap())
+
+ self.tree.SetImageList(il)
+ self.il = il
+
+ # NOTE: For some reason tree items have to have a data object in
+ # order to be sorted. Since our compare just uses the labels
+ # we don't need any real data, so we'll just use None below for
+ # the item data.
+
+ self.root = self.tree.AddRoot("The Root Item")
+ self.tree.SetPyData(self.root, None)
+ self.tree.SetItemImage(self.root, fldridx, wx.TreeItemIcon_Normal)
+ self.tree.SetItemImage(self.root, fldropenidx, wx.TreeItemIcon_Expanded)
+
+
+ for x in range(15):
+ child = self.tree.AppendItem(self.root, "Item %d" % x)
+ self.tree.SetPyData(child, None)
+ self.tree.SetItemImage(child, fldridx, wx.TreeItemIcon_Normal)
+ self.tree.SetItemImage(child, fldropenidx, wx.TreeItemIcon_Expanded)
+
+ for y in range(5):
+ last = self.tree.AppendItem(child, "item %d-%s" % (x, chr(ord("a")+y)))
+ self.tree.SetPyData(last, None)
+ self.tree.SetItemImage(last, fldridx, wx.TreeItemIcon_Normal)
+ self.tree.SetItemImage(last, fldropenidx, wx.TreeItemIcon_Expanded)
+
+ for z in range(5):
+ item = self.tree.AppendItem(last, "item %d-%s-%d" % (x, chr(ord("a")+y), z))
+ self.tree.SetPyData(item, None)
+ self.tree.SetItemImage(item, fileidx, wx.TreeItemIcon_Normal)
+ self.tree.SetItemImage(item, smileidx, wx.TreeItemIcon_Selected)
+
+ self.tree.Expand(self.root)
+ self.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded, self.tree)
+ self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed, self.tree)
+ self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, self.tree)
+ self.Bind(wx.EVT_TREE_BEGIN_LABEL_EDIT, self.OnBeginEdit, self.tree)
+ self.Bind(wx.EVT_TREE_END_LABEL_EDIT, self.OnEndEdit, self.tree)
+ self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnActivate, self.tree)
+
+ self.tree.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDClick)
+ self.tree.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
+ self.tree.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
+
+
+ def OnRightDown(self, event):
+ pt = event.GetPosition();
+ item, flags = self.tree.HitTest(pt)
+ if item:
+ self.log.WriteText("OnRightClick: %s, %s, %s\n" %
+ (self.tree.GetItemText(item), type(item), item.__class__))
+ self.tree.SelectItem(item)
+
+
+ def OnRightUp(self, event):
+ pt = event.GetPosition();
+ item, flags = self.tree.HitTest(pt)
+ if item:
+ self.log.WriteText("OnRightUp: %s (manually starting label edit)\n"
+ % self.tree.GetItemText(item))
+ self.tree.EditLabel(item)
+
+
+
+ def OnBeginEdit(self, event):
+ self.log.WriteText("OnBeginEdit\n")
+ # show how to prevent edit...
+ item = event.GetItem()
+ if item and self.tree.GetItemText(item) == "The Root Item":
+ wx.Bell()
+ self.log.WriteText("You can't edit this one...\n")
+
+ # Lets just see what's visible of its children
+ cookie = 0
+ root = event.GetItem()
+ (child, cookie) = self.tree.GetFirstChild(root)
+
+ while child.IsOk():
+ self.log.WriteText("Child [%s] visible = %d" %
+ (self.tree.GetItemText(child),
+ self.tree.IsVisible(child)))
+ (child, cookie) = self.tree.GetNextChild(root, cookie)
+
+ event.Veto()
+
+
+ def OnEndEdit(self, event):
+ self.log.WriteText("OnEndEdit: %s %s\n" %
+ (event.IsEditCancelled(), event.GetLabel()) )
+ # show how to reject edit, we'll not allow any digits
+ for x in event.GetLabel():
+ if x in string.digits:
+ self.log.WriteText("You can't enter digits...\n")
+ event.Veto()
+ return
+
+
+ def OnLeftDClick(self, event):
+ pt = event.GetPosition();
+ item, flags = self.tree.HitTest(pt)
+ if item:
+ self.log.WriteText("OnLeftDClick: %s\n" % self.tree.GetItemText(item))
+ parent = self.tree.GetItemParent(item)
+ if parent.IsOk():
+ self.tree.SortChildren(parent)
+ event.Skip()
+
+
+ def OnSize(self, event):
+ w,h = self.GetClientSizeTuple()
+ self.tree.SetDimensions(0, 0, w, h)
+
+
+ def OnItemExpanded(self, event):
+ item = event.GetItem()
+ if item:
+ self.log.WriteText("OnItemExpanded: %s\n" % self.tree.GetItemText(item))
+
+ def OnItemCollapsed(self, event):
+ item = event.GetItem()
+ if item:
+ self.log.WriteText("OnItemCollapsed: %s\n" % self.tree.GetItemText(item))
+
+ def OnSelChanged(self, event):
+ self.item = event.GetItem()
+ if self.item:
+ self.log.WriteText("OnSelChanged: %s\n" % self.tree.GetItemText(self.item))
+ if wx.Platform == '__WXMSW__':
+ self.log.WriteText("BoundingRect: %s\n" %
+ self.tree.GetBoundingRect(self.item, True))
+ #items = self.tree.GetSelections()
+ #print map(self.tree.GetItemText, items)
+ event.Skip()
+
+
+ def OnActivate(self, event):
+ if self.item:
+ self.log.WriteText("OnActivate: %s\n" % self.tree.GetItemText(self.item))
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestTreeCtrlPanel(nb, log)
+ return win
+
+#---------------------------------------------------------------------------
+
+
+
+
+
+overview = """\
+A TreeCtrl presents information as a hierarchy, with items that may be
+expanded to show further items. Items in a tree control are referenced by
+wx.TreeItemId handles.
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/TreeListCtrl.py b/demo/TreeListCtrl.py
new file mode 100644
index 00000000..2518b2a2
--- /dev/null
+++ b/demo/TreeListCtrl.py
@@ -0,0 +1,121 @@
+
+import wx
+import wx.gizmos as gizmos
+
+import images
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+
+ self.tree = gizmos.TreeListCtrl(self, -1, style =
+ wx.TR_DEFAULT_STYLE
+ #| wx.TR_HAS_BUTTONS
+ #| wx.TR_TWIST_BUTTONS
+ #| wx.TR_ROW_LINES
+ #| wx.TR_COLUMN_LINES
+ #| wx.TR_NO_LINES
+ | wx.TR_FULL_ROW_HIGHLIGHT
+ )
+
+ isz = (16,16)
+ il = wx.ImageList(isz[0], isz[1])
+ fldridx = il.Add(wx.ArtProvider_GetBitmap(wx.ART_FOLDER, wx.ART_OTHER, isz))
+ fldropenidx = il.Add(wx.ArtProvider_GetBitmap(wx.ART_FILE_OPEN, wx.ART_OTHER, isz))
+ fileidx = il.Add(wx.ArtProvider_GetBitmap(wx.ART_NORMAL_FILE, wx.ART_OTHER, isz))
+ smileidx = il.Add(images.Smiles.GetBitmap())
+
+ self.tree.SetImageList(il)
+ self.il = il
+
+ # create some columns
+ self.tree.AddColumn("Main column")
+ self.tree.AddColumn("Column 1")
+ self.tree.AddColumn("Column 2")
+ self.tree.SetMainColumn(0) # the one with the tree in it...
+ self.tree.SetColumnWidth(0, 175)
+
+
+ self.root = self.tree.AddRoot("The Root Item")
+ self.tree.SetItemText(self.root, "col 1 root", 1)
+ self.tree.SetItemText(self.root, "col 2 root", 2)
+ self.tree.SetItemImage(self.root, fldridx, which = wx.TreeItemIcon_Normal)
+ self.tree.SetItemImage(self.root, fldropenidx, which = wx.TreeItemIcon_Expanded)
+
+
+ for x in range(15):
+ txt = "Item %d" % x
+ child = self.tree.AppendItem(self.root, txt)
+ self.tree.SetItemText(child, txt + "(c1)", 1)
+ self.tree.SetItemText(child, txt + "(c2)", 2)
+ self.tree.SetItemImage(child, fldridx, which = wx.TreeItemIcon_Normal)
+ self.tree.SetItemImage(child, fldropenidx, which = wx.TreeItemIcon_Expanded)
+
+ for y in range(5):
+ txt = "item %d-%s" % (x, chr(ord("a")+y))
+ last = self.tree.AppendItem(child, txt)
+ self.tree.SetItemText(last, txt + "(c1)", 1)
+ self.tree.SetItemText(last, txt + "(c2)", 2)
+ self.tree.SetItemImage(last, fldridx, which = wx.TreeItemIcon_Normal)
+ self.tree.SetItemImage(last, fldropenidx, which = wx.TreeItemIcon_Expanded)
+
+ for z in range(5):
+ txt = "item %d-%s-%d" % (x, chr(ord("a")+y), z)
+ item = self.tree.AppendItem(last, txt)
+ self.tree.SetItemText(item, txt + "(c1)", 1)
+ self.tree.SetItemText(item, txt + "(c2)", 2)
+ self.tree.SetItemImage(item, fileidx, which = wx.TreeItemIcon_Normal)
+ self.tree.SetItemImage(item, smileidx, which = wx.TreeItemIcon_Selected)
+
+
+ self.tree.Expand(self.root)
+
+ self.tree.GetMainWindow().Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
+ self.tree.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnActivate)
+
+
+ def OnActivate(self, evt):
+ self.log.write('OnActivate: %s' % self.tree.GetItemText(evt.GetItem()))
+
+
+ def OnRightUp(self, evt):
+ pos = evt.GetPosition()
+ item, flags, col = self.tree.HitTest(pos)
+ if item:
+ self.log.write('Flags: %s, Col:%s, Text: %s' %
+ (flags, col, self.tree.GetItemText(item, col)))
+
+ def OnSize(self, evt):
+ self.tree.SetSize(self.GetSize())
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
TreeListCtrl
+
+The TreeListCtrl is essentially a wx.TreeCtrl with extra columns,
+such that the look is similar to a wx.ListCtrl.
+
+
+"""
+
+
+if __name__ == '__main__':
+ #raw_input("Press enter...")
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/TreeMixin.py b/demo/TreeMixin.py
new file mode 100644
index 00000000..059ddd61
--- /dev/null
+++ b/demo/TreeMixin.py
@@ -0,0 +1,265 @@
+import wx, wx.lib.customtreectrl, wx.gizmos
+try:
+ import treemixin
+except ImportError:
+ from wx.lib.mixins import treemixin
+
+overview = treemixin.__doc__
+
+class TreeModel(object):
+ ''' TreeModel holds the domain objects that are shown in the different
+ tree controls. Each domain object is simply a two-tuple consisting of
+ a label and a list of child tuples, i.e. (label, [list of child tuples]).
+ '''
+ def __init__(self, *args, **kwargs):
+ self.items = []
+ self.itemCounter = 0
+ super(TreeModel, self).__init__(*args, **kwargs)
+
+ def GetItem(self, indices):
+ text, children = 'Hidden root', self.items
+ for index in indices:
+ text, children = children[index]
+ return text, children
+
+ def GetText(self, indices):
+ return self.GetItem(indices)[0]
+
+ def GetChildren(self, indices):
+ return self.GetItem(indices)[1]
+
+ def GetChildrenCount(self, indices):
+ return len(self.GetChildren(indices))
+
+ def SetChildrenCount(self, indices, count):
+ children = self.GetChildren(indices)
+ while len(children) > count:
+ children.pop()
+ while len(children) < count:
+ children.append(('item %d'%self.itemCounter, []))
+ self.itemCounter += 1
+
+ def MoveItem(self, itemToMoveIndex, newParentIndex):
+ itemToMove = self.GetItem(itemToMoveIndex)
+ newParentChildren = self.GetChildren(newParentIndex)
+ newParentChildren.append(itemToMove)
+ oldParentChildren = self.GetChildren(itemToMoveIndex[:-1])
+ oldParentChildren.remove(itemToMove)
+
+
+class DemoTreeMixin(treemixin.VirtualTree, treemixin.DragAndDrop,
+ treemixin.ExpansionState):
+ def __init__(self, *args, **kwargs):
+ self.model = kwargs.pop('treemodel')
+ self.log = kwargs.pop('log')
+ super(DemoTreeMixin, self).__init__(*args, **kwargs)
+ self.CreateImageList()
+
+ def CreateImageList(self):
+ size = (16, 16)
+ self.imageList = wx.ImageList(*size)
+ for art in wx.ART_FOLDER, wx.ART_FILE_OPEN, wx.ART_NORMAL_FILE:
+ self.imageList.Add(wx.ArtProvider.GetBitmap(art, wx.ART_OTHER,
+ size))
+ self.AssignImageList(self.imageList)
+
+ def OnGetItemText(self, indices):
+ return self.model.GetText(indices)
+
+ def OnGetChildrenCount(self, indices):
+ return self.model.GetChildrenCount(indices)
+
+ def OnGetItemFont(self, indices):
+ # Show how to change the item font. Here we use a small font for
+ # items that have children and the default font otherwise.
+ if self.model.GetChildrenCount(indices) > 0:
+ return wx.SMALL_FONT
+ else:
+ return super(DemoTreeMixin, self).OnGetItemFont(indices)
+
+ def OnGetItemTextColour(self, indices):
+ # Show how to change the item text colour. In this case second level
+ # items are coloured red and third level items are blue. All other
+ # items have the default text colour.
+ if len(indices) % 2 == 0:
+ return wx.RED
+ elif len(indices) % 3 == 0:
+ return wx.BLUE
+ else:
+ return super(DemoTreeMixin, self).OnGetItemTextColour(indices)
+
+ def OnGetItemBackgroundColour(self, indices):
+ # Show how to change the item background colour. In this case the
+ # background colour of each third item is green.
+ if indices[-1] == 2:
+ return wx.GREEN
+ else:
+ return super(DemoTreeMixin,
+ self).OnGetItemBackgroundColour(indices)
+
+ def OnGetItemImage(self, indices, which):
+ # Return the right icon depending on whether the item has children.
+ if which in [wx.TreeItemIcon_Normal, wx.TreeItemIcon_Selected]:
+ if self.model.GetChildrenCount(indices):
+ return 0
+ else:
+ return 2
+ else:
+ return 1
+
+ def OnDrop(self, dropTarget, dragItem):
+ dropIndex = self.GetIndexOfItem(dropTarget)
+ dropText = self.model.GetText(dropIndex)
+ dragIndex = self.GetIndexOfItem(dragItem)
+ dragText = self.model.GetText(dragIndex)
+ self.log.write('drop %s %s on %s %s'%(dragText, dragIndex,
+ dropText, dropIndex))
+ self.model.MoveItem(dragIndex, dropIndex)
+ self.GetParent().RefreshItems()
+
+
+class VirtualTreeCtrl(DemoTreeMixin, wx.TreeCtrl):
+ pass
+
+
+class VirtualTreeListCtrl(DemoTreeMixin, wx.gizmos.TreeListCtrl):
+ def __init__(self, *args, **kwargs):
+ kwargs['style'] = wx.TR_DEFAULT_STYLE | wx.TR_FULL_ROW_HIGHLIGHT
+ super(VirtualTreeListCtrl, self).__init__(*args, **kwargs)
+ self.AddColumn('Column 0')
+ self.AddColumn('Column 1')
+ for art in wx.ART_TIP, wx.ART_WARNING:
+ self.imageList.Add(wx.ArtProvider.GetBitmap(art, wx.ART_OTHER,
+ (16, 16)))
+
+ def OnGetItemText(self, indices, column=0):
+ # Return a different label depending on column.
+ return '%s, column %d'%\
+ (super(VirtualTreeListCtrl, self).OnGetItemText(indices), column)
+
+ def OnGetItemImage(self, indices, which, column=0):
+ # Also change the image of the other columns when the item has
+ # children.
+ if column == 0:
+ return super(VirtualTreeListCtrl, self).OnGetItemImage(indices,
+ which)
+ elif self.OnGetChildrenCount(indices):
+ return 4
+ else:
+ return 3
+
+
+class VirtualCustomTreeCtrl(DemoTreeMixin,
+ wx.lib.customtreectrl.CustomTreeCtrl):
+ def __init__(self, *args, **kwargs):
+ self.checked = {}
+ kwargs['style'] = wx.TR_HIDE_ROOT | \
+ wx.TR_HAS_BUTTONS | wx.TR_FULL_ROW_HIGHLIGHT
+ super(VirtualCustomTreeCtrl, self).__init__(*args, **kwargs)
+ self.Bind(wx.lib.customtreectrl.EVT_TREE_ITEM_CHECKED,
+ self.OnItemChecked)
+
+ def OnGetItemType(self, indices):
+ if len(indices) == 1:
+ return 1
+ elif len(indices) == 2:
+ return 2
+ else:
+ return 0
+
+ def OnGetItemChecked(self, indices):
+ return self.checked.get(indices, False)
+
+ def OnItemChecked(self, event):
+ item = event.GetItem()
+ itemIndex = self.GetIndexOfItem(item)
+ if self.GetItemType(item) == 2:
+ # It's a radio item; reset other items on the same level
+ for nr in range(self.GetChildrenCount(self.GetItemParent(item))):
+ self.checked[itemIndex[:-1]+(nr,)] = False
+ self.checked[itemIndex] = True
+
+
+
+class TreeNotebook(wx.Notebook):
+ def __init__(self, *args, **kwargs):
+ treemodel = kwargs.pop('treemodel')
+ log = kwargs.pop('log')
+ super(TreeNotebook, self).__init__(*args, **kwargs)
+ self.trees = []
+ for class_, title in [(VirtualTreeCtrl, 'TreeCtrl'),
+ (VirtualTreeListCtrl, 'TreeListCtrl'),
+ (VirtualCustomTreeCtrl, 'CustomTreeCtrl')]:
+ tree = class_(self, treemodel=treemodel, log=log)
+ self.trees.append(tree)
+ self.AddPage(tree, title)
+ self.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.OnPageChanged)
+
+ def OnPageChanged(self, event):
+ oldTree = self.GetPage(event.OldSelection)
+ newTree = self.GetPage(event.Selection)
+ newTree.RefreshItems()
+ newTree.SetExpansionState(oldTree.GetExpansionState())
+ event.Skip()
+
+ def GetIndicesOfSelectedItems(self):
+ tree = self.trees[self.GetSelection()]
+ if tree.GetSelections():
+ return [tree.GetIndexOfItem(item) for item in tree.GetSelections()]
+ else:
+ return [()]
+
+ def RefreshItems(self):
+ tree = self.trees[self.GetSelection()]
+ tree.RefreshItems()
+ tree.UnselectAll()
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ super(TestPanel, self).__init__(parent)
+ self.treemodel = TreeModel()
+ self.CreateControls()
+ self.LayoutControls()
+
+ def CreateControls(self):
+ self.notebook = TreeNotebook(self, treemodel=self.treemodel,
+ log=self.log)
+ self.label = wx.StaticText(self, label='Number of children: ')
+ self.childrenCountCtrl = wx.SpinCtrl(self, value='0', max=10000)
+ self.button = wx.Button(self, label='Update children')
+ self.button.Bind(wx.EVT_BUTTON, self.OnEnter)
+
+ def LayoutControls(self):
+ hSizer = wx.BoxSizer(wx.HORIZONTAL)
+ options = dict(flag=wx.ALIGN_CENTER_VERTICAL|wx.ALL, border=2)
+ hSizer.Add(self.label, **options)
+ hSizer.Add(self.childrenCountCtrl, 2, **options)
+ hSizer.Add(self.button, **options)
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(self.notebook, 1, wx.EXPAND)
+ sizer.Add(hSizer, 0, wx.EXPAND)
+ self.SetSizer(sizer)
+
+ def OnEnter(self, event):
+ indicesList = self.notebook.GetIndicesOfSelectedItems()
+ newChildrenCount = self.childrenCountCtrl.GetValue()
+ for indices in indicesList:
+ text = self.treemodel.GetText(indices)
+ oldChildrenCount = self.treemodel.GetChildrenCount(indices)
+ self.log.write('%s %s now has %d children (was %d)'%(text, indices,
+ newChildrenCount, oldChildrenCount))
+ self.treemodel.SetChildrenCount(indices, newChildrenCount)
+ self.notebook.RefreshItems()
+
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+
+if __name__ == '__main__':
+ import sys, os, run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Treebook.py b/demo/Treebook.py
new file mode 100644
index 00000000..5d96cf4a
--- /dev/null
+++ b/demo/Treebook.py
@@ -0,0 +1,124 @@
+
+import wx
+
+import ColorPanel
+import images
+
+colourList = [ "Aquamarine", "Grey", "Blue", "Blue Violet", "Brown", "Cadet Blue",
+ "Coral", "Wheat", "Cyan", "Dark Grey", "Dark Green",
+ "Steel Blue",
+ ]
+
+#----------------------------------------------------------------------------
+
+def getNextImageID(count):
+ imID = 0
+ while True:
+ yield imID
+ imID += 1
+ if imID == count:
+ imID = 0
+
+
+class TestTB(wx.Treebook):
+ def __init__(self, parent, id, log):
+ wx.Treebook.__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)
+ imageIdGenerator = getNextImageID(il.GetImageCount())
+
+ # Now make a bunch of panels for the list book
+ first = True
+ for colour in colourList:
+ win = self.makeColorPanel(colour)
+ self.AddPage(win, colour, imageId=imageIdGenerator.next())
+ if first:
+ st = wx.StaticText(win.win, -1,
+ "You can put nearly any type of window here,\n"
+ "and the wx.TreeCtrl can be on either side of the\n"
+ "Treebook",
+ wx.Point(10, 10))
+ first = False
+
+ win = self.makeColorPanel(colour)
+ st = wx.StaticText(win.win, -1, "this is a sub-page", (10,10))
+ self.AddSubPage(win, 'a sub-page', imageId=imageIdGenerator.next())
+
+ self.Bind(wx.EVT_TREEBOOK_PAGE_CHANGED, self.OnPageChanged)
+ self.Bind(wx.EVT_TREEBOOK_PAGE_CHANGING, self.OnPageChanging)
+
+ # This is a workaround for a sizing bug on Mac...
+ wx.FutureCall(100, self.AdjustSize)
+
+ def AdjustSize(self):
+ #print self.GetTreeCtrl().GetBestSize()
+ self.GetTreeCtrl().InvalidateBestSize()
+ self.SendSizeEvent()
+ #print self.GetTreeCtrl().GetBestSize()
+
+
+ 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 = TestTB(nb, -1, log)
+ return testWin
+
+#----------------------------------------------------------------------------
+
+
+overview = """\
+
+
wx.Treebook
+
+This class is a control similar to a notebook control, but with a
+wx.TreeCtrl 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:])
+
+
+
diff --git a/demo/UIActionSimulator.py b/demo/UIActionSimulator.py
new file mode 100644
index 00000000..55987977
--- /dev/null
+++ b/demo/UIActionSimulator.py
@@ -0,0 +1,150 @@
+
+import wx
+import wx.lib.buttons as buttons
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ self.recordingKeys = False
+ self.stopwatchKeys = wx.StopWatch()
+ self.uisim = wx.UIActionSimulator()
+
+
+ # create widgets and bind events
+ keyLabel = wx.StaticText(self, -1, "Key Events")
+ keyLabel.SetFont(wx.FFont(18, wx.SWISS, wx.FONTFLAG_BOLD))
+
+ self.txt = wx.TextCtrl(self, size=(300,-1))
+ self.txt.Bind(wx.EVT_KEY_DOWN, self.OnTxtKeyDown)
+ self.txt.Bind(wx.EVT_KEY_UP, self.OnTxtKeyUp)
+
+ self.recordBtn = buttons.GenToggleButton(self, -1, "Record")
+ self.Bind(wx.EVT_BUTTON, self.OnToggleRecordKeys, self.recordBtn)
+ self.recordBtn.SetToolTipString(
+ "Click this button and then type some keys in the\n"
+ "textctrl. Click here again when done.")
+
+ self.playbackKeysBtn = buttons.GenButton(self, -1, "Playback")
+ self.Bind(wx.EVT_BUTTON, self.OnPlaybackKeys, self.playbackKeysBtn)
+ self.playbackKeysBtn.SetToolTipString(
+ "Record some key events and then click here to\n"
+ "replay the recorded events.")
+ self.playbackKeysBtn.Disable()
+
+
+ # create the layout
+ gbs = wx.GridBagSizer(10,10)
+ gbs.Add(keyLabel, (0,0), span=(1,2))
+ gbs.Add(self.txt, (1,1), span=(1,2))
+ btnsizer = wx.BoxSizer(wx.HORIZONTAL)
+ btnsizer.Add(self.recordBtn)
+ btnsizer.Add((10,10))
+ btnsizer.Add(self.playbackKeysBtn)
+ gbs.Add(btnsizer, (2,1), span=(1,2))
+
+ self.Sizer = wx.BoxSizer()
+ self.Sizer.Add(gbs, 1, wx.EXPAND|wx.ALL, 20)
+
+
+ def OnToggleRecordKeys(self, evt):
+ self.recordingKeys = not self.recordingKeys
+ if self.recordingKeys:
+ self.recordBtn.SetLabel('Recording')
+ self.keyEvents = list()
+ self.stopwatchKeys.Start()
+ self.playbackKeysBtn.Disable()
+ self.txt.Clear()
+ self.txt.SetFocus()
+ else:
+ self.playbackKeysBtn.Enable()
+ self.recordBtn.SetLabel('Record')
+
+
+ def OnPlaybackKeys(self, evt):
+ self._playbackEvents = self.keyEvents[:] # make a copy so we can pop()
+ if self._playbackEvents:
+ self.playbackKeysBtn.Disable()
+ self.txt.Clear()
+ self.txt.SetFocus()
+ self._setNextKeyEvent()
+
+
+ def _playbackKey(self, evtType, key, modifiers):
+ if evtType == 'down':
+ self.uisim.KeyDown(key, modifiers)
+ elif evtType == 'up':
+ self.uisim.KeyUp(key, modifiers)
+
+ if self._playbackEvents:
+ self._setNextKeyEvent()
+ else:
+ self.playbackKeysBtn.Enable()
+
+
+ def _setNextKeyEvent(self):
+ evtType, key, modifiers, milli = self._playbackEvents.pop(0)
+ milli = max(milli/2, 1) # play back faster than it was recorded
+ print (evtType, key, modifiers, milli)
+ wx.CallLater(milli, self._playbackKey, evtType, key, modifiers)
+
+
+ def _onKeyEvent(self, evt, evtType):
+ evt.Skip()
+ if not self.recordingKeys:
+ return
+ evtInfo = ( evtType,
+ evt.KeyCode,
+ evt.Modifiers,
+ self.stopwatchKeys.Time(),
+ )
+ self.keyEvents.append(evtInfo)
+ self.stopwatchKeys.Start()
+
+
+ def OnTxtKeyDown(self, evt):
+ self._onKeyEvent(evt, 'down')
+
+ def OnTxtKeyUp(self, evt):
+ self._onKeyEvent(evt, 'up')
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ try:
+ uisim = wx.UIActionSimulator()
+ win = TestPanel(nb, log)
+ return win
+ except NotImplementedError:
+ from wx.lib.msgpanel import MessagePanel
+ win = MessagePanel(nb,
+ "This build of wxWidgets does not include the \n"
+ "wx.UIActionSimulator implementation.",
+ "Sorry", wx.ICON_WARNING)
+ return win
+
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
UIActionSimulator
+
+wx.UIActionSimulator is a class that facilitates the injection of
+mouse or keyboard events into the application's message queue.
+
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/URLDragAndDrop.py b/demo/URLDragAndDrop.py
new file mode 100644
index 00000000..68795f66
--- /dev/null
+++ b/demo/URLDragAndDrop.py
@@ -0,0 +1,130 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+class MyURLDropTarget(wx.PyDropTarget):
+ def __init__(self, window):
+ wx.PyDropTarget.__init__(self)
+ self.window = window
+
+ self.data = wx.URLDataObject();
+ self.SetDataObject(self.data)
+
+ def OnDragOver(self, x, y, d):
+ return wx.DragLink
+
+ def OnData(self, x, y, d):
+ if not self.GetData():
+ return wx.DragNone
+
+ url = self.data.GetURL()
+ self.window.AppendText(url + "\n")
+
+ return d
+
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+
+ self.SetAutoLayout(True)
+ outsideSizer = wx.BoxSizer(wx.VERTICAL)
+
+ msg = "Drag-And-Drop of URLs"
+ text = wx.StaticText(self, -1, "", style=wx.ALIGN_CENTRE)
+ text.SetFont(wx.Font(24, wx.SWISS, wx.NORMAL, wx.BOLD, False))
+ text.SetLabel(msg)
+ w,h = text.GetTextExtent(msg)
+ text.SetSize(wx.Size(w,h+1))
+ text.SetForegroundColour(wx.BLUE)
+ outsideSizer.Add(text, 0, wx.EXPAND|wx.ALL, 5)
+ outsideSizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND)
+ outsideSizer.Add((20,20))
+
+ self.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD, False))
+
+ inSizer = wx.FlexGridSizer(cols=2, hgap=5, vgap=5)
+ inSizer.AddGrowableCol(0)
+
+ inSizer.Add((20,20))
+ inSizer.Add((20,20))
+ inSizer.Add(wx.StaticText(self, -1,
+ "Drag URLs from your browser to\nthis window:",
+ style = wx.ALIGN_RIGHT),
+ 0, wx.ALIGN_RIGHT )
+ self.dropText = wx.TextCtrl(self, -1, "", size=(380, 180),
+ style=wx.TE_MULTILINE|wx.TE_READONLY)
+ inSizer.Add(self.dropText, 0, wx.EXPAND)
+
+
+ inSizer.Add(wx.StaticText(self, -1,
+ "Drag this URL to your browser:",
+ style = wx.ALIGN_RIGHT),
+ 0, wx.ALIGN_RIGHT )
+ self.dragText = wx.TextCtrl(self, -1, "http://wxPython.org/")
+ inSizer.Add(self.dragText, 0, wx.EXPAND)
+ self.dragText.Bind(wx.EVT_MOTION, self.OnStartDrag)
+
+
+## inSizer.Add(wx.StaticText(self, -1,
+## "Drag this TEXT to your browser:",
+## style = wx.ALIGN_RIGHT),
+## 0, wx.ALIGN_RIGHT )
+## self.dragText2 = wx.TextCtrl(self, -1, "http://wxPython.org/")
+## inSizer.Add(self.dragText2, 0, wx.EXPAND)
+## self.dragText2.Bind(EVT_MOTION, self.OnStartDrag2)
+
+
+ outsideSizer.Add(inSizer, 1, wx.EXPAND)
+ self.SetSizer(outsideSizer)
+
+ self.dropText.SetDropTarget(MyURLDropTarget(self.dropText))
+
+
+ def OnStartDrag(self, evt):
+ if evt.Dragging():
+ url = self.dragText.GetValue()
+ data = wx.URLDataObject()
+ data.SetURL(url)
+
+ dropSource = wx.DropSource(self.dragText)
+ dropSource.SetData(data)
+ result = dropSource.DoDragDrop()
+
+
+ def OnStartDrag2(self, evt):
+ if evt.Dragging():
+ url = self.dragText2.GetValue()
+ data = wx.TextDataObject()
+ data.SetText(url)
+
+ dropSource = wx.DropSource(self.dragText2)
+ dropSource.SetData(data)
+ result = dropSource.DoDragDrop()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+
+overview = """\
+"""
+
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Unicode.py b/demo/Unicode.py
new file mode 100644
index 00000000..aa7373d5
--- /dev/null
+++ b/demo/Unicode.py
@@ -0,0 +1,153 @@
+
+import wx
+
+#----------------------------------------------------------------------
+
+# Some unicode strings
+chi_uni = (u'Python \u662f\u6700\u597d\u7684\u7de8\u7a0b\u8a9e\u8a00\uff01',
+ 'Python is the best\nprogramming language!')
+
+lt1_uni = (u'Pythonas yra \u017eaviausia \u0161neka',
+ 'Python is the best')
+lt2_uni = (u'A\u0161 m\u0117gstu \u0161okolad\u0105',
+ 'I like chocolate')
+
+kor_uni = (u'\ud30c\uc774\uc36c\uc740 \ucd5c\uace0\uc758 \ud504\ub85c\uadf8\ub798\ubc0d \uc5b8\uc5b4\uc774\ub2e4!',
+ 'Python is the best\nprogramming language!')
+
+bul_uni = (u'\u041f\u0438\u0442\u043e\u043d \u0435 \u043d\u0430\u0439-\u0434\u043e\u0431\u0440\u0438\u044f \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u0435\u043d \u0435\u0437\u0438\u043a!',
+ 'Python is the best\nprogramming language!')
+rus_uni = (u'\u041f\u0438\u0442\u043e\u043d - \u043b\u0443\u0447\u0448\u0438\u0439 \u044f\u0437\u044b\u043a \n\u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u044f!',
+ 'Python is the best\nprogramming language!')
+
+
+# Equivalents in UTF-8. Should I demo these somehow???
+chi_utf8 = ('Python \xe6\x98\xaf\xe6\x9c\x80\xe5\xa5\xbd\xe7\x9a\x84\xe7\xb7\xa8\xe7\xa8\x8b\xe8\xaa\x9e\xe8\xa8\x80\xef\xbc\x81',
+ 'Python is the best programming language')
+
+lt1_utf8 = ('Pythonas yra \xc5\xbeaviausia \xc5\xa1neka',
+ 'Python is the best')
+lt2_utf8 = ('A\xc5\xa1 m\xc4\x97gstu \xc5\xa1okolad\xc4\x85',
+ 'I like chocolate')
+
+kor_utf8 = ('\xed\x8c\x8c\xec\x9d\xb4\xec\x8d\xac\xec\x9d\x80 \xec\xb5\x9c\xea\xb3\xa0\xec\x9d\x98 \xed\x94\x84\xeb\xa1\x9c\xea\xb7\xb8\xeb\x9e\x98\xeb\xb0\x8d \xec\x96\xb8\xec\x96\xb4\xec\x9d\xb4\xeb\x8b\xa4!',
+ 'Python is the best programming language!')
+
+bul_utf8 = ('\xd0\x9f\xd0\xb8\xd1\x82\xd0\xbe\xd0\xbd \xd0\xb5 \xd0\xbd\xd0\xb0\xd0\xb9-\xd0\xb4\xd0\xbe\xd0\xb1\xd1\x80\xd0\xb8\xd1\x8f \xd0\xbf\xd1\x80\xd0\xbe\xd0\xb3\xd1\x80\xd0\xb0\xd0\xbc\xd0\xb5\xd0\xbd \xd0\xb5\xd0\xb7\xd0\xb8\xd0\xba!',
+ 'Python is the best programming language!')
+rus_utf8 = ('\xd0\x9f\xd0\xb8\xd1\x82\xd0\xbe\xd0\xbd - \xd0\xbb\xd1\x83\xd1\x87\xd1\x88\xd0\xb8\xd0\xb9 \xd1\x8f\xd0\xb7\xd1\x8b\xd0\xba \xd0\xbf\xd1\x80\xd0\xbe\xd0\xb3\xd1\x80\xd0\xb0\xd0\xbc\xd0\xbc\xd0\xb8\xd1\x80\xd0\xbe\xd0\xb2\xd0\xb0\xd0\xbd\xd0\xb8\xd1\x8f!',
+ 'Python is the best programming language!')
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ box = wx.BoxSizer(wx.VERTICAL)
+
+ if not wx.USE_UNICODE:
+ self.AddLine(box)
+ self.AddText(box, "Sorry, this wxPython was not built with Unicode support.",
+ font = wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
+ self.AddLine(box)
+
+ else:
+ font = self.GetFont()
+ font.SetPointSize(14)
+ font.SetWeight(wx.BOLD)
+
+ self.AddLine(box)
+ self.AddText(box, chi_uni[0], chi_uni[1], 'Chinese:', font)
+ self.AddLine(box)
+
+ self.AddText(box, lt1_uni[0], lt1_uni[1], 'Lithuanian:', font)
+ self.AddLine(box)
+ self.AddText(box, lt2_uni[0], lt2_uni[1], 'Lithuanian:', font)
+ self.AddLine(box)
+
+ self.AddText(box, kor_uni[0], kor_uni[1], 'Korean:', font)
+ self.AddLine(box)
+
+ self.AddText(box, bul_uni[0], bul_uni[1], 'Bulgarian:', font)
+ self.AddLine(box)
+ self.AddText(box, rus_uni[0], rus_uni[1], 'Russian:', font)
+ self.AddLine(box)
+
+
+ border = wx.BoxSizer(wx.VERTICAL)
+ border.Add(box, 1, wx.EXPAND|wx.ALL, 10)
+ self.SetAutoLayout(True)
+ self.SetSizer(border)
+
+
+ def AddLine(self, sizer):
+ sizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND)
+
+ def AddText(self, sizer, text1, text2='', lang='', font=None):
+ # create some controls
+ lang = wx.StaticText(self, -1, lang)
+ text1 = wx.StaticText(self, -1, text1)
+ text2 = wx.StaticText(self, -1, text2, style=wx.ALIGN_RIGHT)
+ if font is not None:
+ text1.SetFont(font)
+
+ # put them in a sizer
+ row = wx.BoxSizer(wx.HORIZONTAL)
+ row.Add(lang)
+ row.Add((15,10))
+ row.Add(text1, 1, wx.EXPAND)
+ row.Add(text2)
+
+ # put the row in the main sizer
+ sizer.Add(row, 0, wx.EXPAND|wx.ALL, 5)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wxPython Unicode Support
+
+
+wxWidgets and wxPython can be built to use either ANSI or Unicode strings.
+This demo shows how Unicode can be used to support text in many different
+languages using one locale when Unicode is enabled.
+
+
So what is the difference between the ANSI and Unicode builds?
+
+
If ANSI is used, Python strings (bytes) are always used, and you can only
+display strings that use either the ASCII encoding, or the system's default
+encoding. Any attempt to display other strings will result in garbled
+characters.
+
+
When unicode is enabled, then all functions and methods in wxPython
+that return a wxString will return an Python unicode object, and parameters
+that expect a wxString can accept either a Python string or unicode object. (NOTE: If you aren't familiar with the difference between Python
+strings and Unicode objects, you should view this Python Unicode Object introduction.)
+If a string object is passed then it will be decoded into unicode using the
+converter pointed to by wxConvCurrent, which will use the default
+system encoding. If you need to use string in some other encoding
+then you should convert it to unicode using the Python codecs first
+and then pass the unicode to the wxPython method.
+
+
+
+"""
+
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/VListBox.py b/demo/VListBox.py
new file mode 100644
index 00000000..e0ef9a1f
--- /dev/null
+++ b/demo/VListBox.py
@@ -0,0 +1,175 @@
+
+import wx
+from wx import html
+
+#----------------------------------------------------------------------
+
+# The wx.VListBox is much like a regular wx.ListBox except you draw the
+# items yourself and the items can vary in height.
+class MyVListBox(wx.VListBox):
+
+ # This method must be overridden. When called it should draw the
+ # n'th item on the dc within the rect. How it is drawn, and what
+ # is drawn is entirely up to you.
+ def OnDrawItem(self, dc, rect, n):
+ if self.GetSelection() == n:
+ c = wx.SystemSettings.GetColour(wx.SYS_COLOUR_HIGHLIGHTTEXT)
+ else:
+ c = self.GetForegroundColour()
+ dc.SetFont(self.GetFont())
+ dc.SetTextForeground(c)
+ dc.DrawLabel(self._getItemText(n), rect,
+ wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL)
+
+ # This method must be overridden. It should return the height
+ # required to draw the n'th item.
+ def OnMeasureItem(self, n):
+ height = 0
+ for line in self._getItemText(n).split('\n'):
+ w, h = self.GetTextExtent(line)
+ height += h
+ return height + 5
+
+
+ # These are also overridable:
+ #
+ # OnDrawSeparator(dc, rect, n)
+ # Draw a separator between items. Note that rect may be reduced
+ # in size if desired so OnDrawItem gets a smaller rect.
+ #
+ # OnDrawBackground(dc, rect, n)
+ # Draw the background and maybe a border if desired.
+
+
+ def _getItemText(self, item):
+ if item % 2 == 0:
+ return "This is item# %d" % item
+ else:
+ return "This is item# %d\n with an extra line" % item
+
+#----------------------------------------------------------------------
+
+# The wx.HtmlListBox derives from wx.VListBox, but draws each item
+# itself as a wx.HtmlCell.
+class MyHtmlListBox(wx.HtmlListBox):
+
+ def __init__(self, *args, **kw):
+ self.log = kw.pop('log')
+ wx.HtmlListBox.__init__(self, *args, **kw)
+
+ def OnGetItem(self, n):
+ if n == 1:
+ return """
+
+
col 1
+
Lorem ipsum dolor
+ sit amet, consectetuer adipiscing elit.
+
+
+The "V" in wxVListBox stands for both "virtual" because it can have an
+unlimited number of items since it doesn't store them itself, and
+"variable" since items can vary in height. It has much the same
+interface as wxListBox and also emits the same events so you can use
+the same EVT_LISTBOX function to connect a handler.
+
+
+The wx.HtmlListBox derives from wx.VListBox, but draws each item itself
+as a wx.HtmlCell. This means that you just need to provide a snippet
+of HTML for each item when requested.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/Validator.py b/demo/Validator.py
new file mode 100644
index 00000000..9faf3f72
--- /dev/null
+++ b/demo/Validator.py
@@ -0,0 +1,240 @@
+
+import string
+import wx
+
+#----------------------------------------------------------------------
+
+ALPHA_ONLY = 1
+DIGIT_ONLY = 2
+
+class MyValidator(wx.PyValidator):
+ def __init__(self, flag=None, pyVar=None):
+ wx.PyValidator.__init__(self)
+ self.flag = flag
+ self.Bind(wx.EVT_CHAR, self.OnChar)
+
+ def Clone(self):
+ return MyValidator(self.flag)
+
+ def Validate(self, win):
+ tc = self.GetWindow()
+ val = tc.GetValue()
+
+ if self.flag == ALPHA_ONLY:
+ for x in val:
+ if x not in string.letters:
+ return False
+
+ elif self.flag == DIGIT_ONLY:
+ for x in val:
+ if x not in string.digits:
+ return False
+
+ return True
+
+
+ def OnChar(self, event):
+ key = event.GetKeyCode()
+
+ if key < wx.WXK_SPACE or key == wx.WXK_DELETE or key > 255:
+ event.Skip()
+ return
+
+ if self.flag == ALPHA_ONLY and chr(key) in string.letters:
+ event.Skip()
+ return
+
+ if self.flag == DIGIT_ONLY and chr(key) in string.digits:
+ event.Skip()
+ return
+
+ if not wx.Validator_IsSilent():
+ wx.Bell()
+
+ # Returning without calling even.Skip eats the event before it
+ # gets to the text control
+ return
+
+#----------------------------------------------------------------------
+
+class TestValidatorPanel(wx.Panel):
+ def __init__(self, parent):
+ wx.Panel.__init__(self, parent, -1)
+ self.SetAutoLayout(True)
+ VSPACE = 10
+
+ fgs = wx.FlexGridSizer(cols=2)
+
+ fgs.Add((1,1))
+ fgs.Add(wx.StaticText(self, -1, "These controls have validators that limit\n"
+ "the type of characters that can be entered."))
+
+ fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
+
+ label = wx.StaticText(self, -1, "Alpha Only: ")
+ fgs.Add(label, 0, wx.ALIGN_RIGHT|wx.CENTER)
+
+ fgs.Add(wx.TextCtrl(self, -1, "", validator = MyValidator(ALPHA_ONLY)))
+
+ fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
+
+ label = wx.StaticText(self, -1, "Digits Only: ")
+ fgs.Add(label, 0, wx.ALIGN_RIGHT|wx.CENTER)
+ fgs.Add(wx.TextCtrl(self, -1, "", validator = MyValidator(DIGIT_ONLY)))
+
+ fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
+ fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
+ fgs.Add((0,0))
+ b = wx.Button(self, -1, "Test Dialog Validation")
+ self.Bind(wx.EVT_BUTTON, self.OnDoDialog, b)
+ fgs.Add(b)
+
+ border = wx.BoxSizer()
+ border.Add(fgs, 1, wx.GROW|wx.ALL, 25)
+ self.SetSizer(border)
+ self.Layout()
+
+ def OnDoDialog(self, evt):
+ dlg = TestValidateDialog(self)
+ dlg.ShowModal()
+ dlg.Destroy()
+
+
+#----------------------------------------------------------------------
+
+class TextObjectValidator(wx.PyValidator):
+ """ This validator is used to ensure that the user has entered something
+ into the text object editor dialog's text field.
+ """
+ def __init__(self):
+ """ Standard constructor.
+ """
+ wx.PyValidator.__init__(self)
+
+
+
+ def Clone(self):
+ """ Standard cloner.
+
+ Note that every validator must implement the Clone() method.
+ """
+ return TextObjectValidator()
+
+
+ def Validate(self, win):
+ """ Validate the contents of the given text control.
+ """
+ textCtrl = self.GetWindow()
+ text = textCtrl.GetValue()
+
+ if len(text) == 0:
+ wx.MessageBox("A text object must contain some text!", "Error")
+ textCtrl.SetBackgroundColour("pink")
+ textCtrl.SetFocus()
+ textCtrl.Refresh()
+ return False
+ else:
+ textCtrl.SetBackgroundColour(
+ wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOW))
+ textCtrl.Refresh()
+ return True
+
+
+ def TransferToWindow(self):
+ """ Transfer data from validator to window.
+
+ The default implementation returns False, indicating that an error
+ occurred. We simply return True, as we don't do any data transfer.
+ """
+ return True # Prevent wxDialog from complaining.
+
+
+ def TransferFromWindow(self):
+ """ Transfer data from window to validator.
+
+ The default implementation returns False, indicating that an error
+ occurred. We simply return True, as we don't do any data transfer.
+ """
+ return True # Prevent wxDialog from complaining.
+
+#----------------------------------------------------------------------
+
+class TestValidateDialog(wx.Dialog):
+ def __init__(self, parent):
+ wx.Dialog.__init__(self, parent, -1, "Validated Dialog")
+
+ self.SetAutoLayout(True)
+ VSPACE = 10
+
+ fgs = wx.FlexGridSizer(cols=2)
+
+ fgs.Add((1,1));
+ fgs.Add(wx.StaticText(self, -1,
+ "These controls must have text entered into them. Each\n"
+ "one has a validator that is checked when the Ok\n"
+ "button is clicked."))
+
+ fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
+
+ label = wx.StaticText(self, -1, "First: ")
+ fgs.Add(label, 0, wx.ALIGN_RIGHT|wx.CENTER)
+
+ fgs.Add(wx.TextCtrl(self, -1, "", validator = TextObjectValidator()))
+
+ fgs.Add((1,VSPACE)); fgs.Add((1,VSPACE))
+
+ label = wx.StaticText(self, -1, "Second: ")
+ fgs.Add(label, 0, wx.ALIGN_RIGHT|wx.CENTER)
+ fgs.Add(wx.TextCtrl(self, -1, "", validator = TextObjectValidator()))
+
+
+ buttons = wx.StdDialogButtonSizer() #wx.BoxSizer(wx.HORIZONTAL)
+ b = wx.Button(self, wx.ID_OK, "OK")
+ b.SetDefault()
+ buttons.AddButton(b)
+ buttons.AddButton(wx.Button(self, wx.ID_CANCEL, "Cancel"))
+ buttons.Realize()
+
+ border = wx.BoxSizer(wx.VERTICAL)
+ border.Add(fgs, 1, wx.GROW|wx.ALL, 25)
+ border.Add(buttons, 0, wx.GROW|wx.BOTTOM, 5)
+ self.SetSizer(border)
+ border.Fit(self)
+ self.Layout()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestValidatorPanel(nb)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """\
+
+
+wx.Validator is the base class for a family of validator classes that mediate
+between a class of control, and application data.
+
+
A validator has three major roles:
+
+
+
to transfer data from a C++ variable or own storage to and from a control;
+
to validate data in a control, and show an appropriate error message;
+
to filter events (such as keystrokes), thereby changing the behaviour of the associated control.
+
+
Validators can be plugged into controls dynamically.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/Wizard.py b/demo/Wizard.py
new file mode 100644
index 00000000..eceba135
--- /dev/null
+++ b/demo/Wizard.py
@@ -0,0 +1,246 @@
+
+import wx
+import wx.wizard as wiz
+import images
+
+#----------------------------------------------------------------------
+
+def makePageTitle(wizPg, title):
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ wizPg.SetSizer(sizer)
+ title = wx.StaticText(wizPg, -1, title)
+ title.SetFont(wx.Font(18, wx.SWISS, wx.NORMAL, wx.BOLD))
+ sizer.Add(title, 0, wx.ALIGN_CENTRE|wx.ALL, 5)
+ sizer.Add(wx.StaticLine(wizPg, -1), 0, wx.EXPAND|wx.ALL, 5)
+ return sizer
+
+#----------------------------------------------------------------------
+
+class TitledPage(wiz.WizardPageSimple):
+ def __init__(self, parent, title):
+ wiz.WizardPageSimple.__init__(self, parent)
+ self.sizer = makePageTitle(self, title)
+
+
+#----------------------------------------------------------------------
+
+class SkipNextPage(wiz.PyWizardPage):
+ def __init__(self, parent, title):
+ wiz.PyWizardPage.__init__(self, parent)
+ self.next = self.prev = None
+ self.sizer = makePageTitle(self, title)
+
+ self.cb = wx.CheckBox(self, -1, "Skip next page")
+ self.sizer.Add(self.cb, 0, wx.ALL, 5)
+
+ def SetNext(self, next):
+ self.next = next
+
+ def SetPrev(self, prev):
+ self.prev = prev
+
+
+ # Classes derived from wxPyWizardPanel must override
+ # GetNext and GetPrev, and may also override GetBitmap
+ # as well as all those methods overridable by
+ # wx.PyWindow.
+
+ def GetNext(self):
+ """If the checkbox is set then return the next page's next page"""
+ if self.cb.GetValue():
+ self.next.GetNext().SetPrev(self)
+ return self.next.GetNext()
+ else:
+ self.next.GetNext().SetPrev(self.next)
+ return self.next
+
+ def GetPrev(self):
+ return self.prev
+
+#----------------------------------------------------------------------
+
+class UseAltBitmapPage(wiz.PyWizardPage):
+ def __init__(self, parent, title):
+ wiz.PyWizardPage.__init__(self, parent)
+ self.next = self.prev = None
+ self.sizer = makePageTitle(self, title)
+
+ self.sizer.Add(wx.StaticText(self, -1, "This page uses a different bitmap"),
+ 0, wx.ALL, 5)
+
+ def SetNext(self, next):
+ self.next = next
+
+ def SetPrev(self, prev):
+ self.prev = prev
+
+ def GetNext(self):
+ return self.next
+
+ def GetPrev(self):
+ return self.prev
+
+ def GetBitmap(self):
+ # You usually wouldn't need to override this method
+ # since you can set a non-default bitmap in the
+ # wxWizardPageSimple constructor, but if you need to
+ # dynamically change the bitmap based on the
+ # contents of the wizard, or need to also change the
+ # next/prev order then it can be done by overriding
+ # GetBitmap.
+ return images.WizTest2.GetBitmap()
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Run Simple Wizard", pos=(50, 50))
+ self.Bind(wx.EVT_BUTTON, self.OnRunSimpleWizard, b)
+
+ b = wx.Button(self, -1, "Run Dynamic Wizard", pos=(50, 100))
+ self.Bind(wx.EVT_BUTTON, self.OnRunDynamicWizard, b)
+
+ self.Bind(wiz.EVT_WIZARD_PAGE_CHANGED, self.OnWizPageChanged)
+ self.Bind(wiz.EVT_WIZARD_PAGE_CHANGING, self.OnWizPageChanging)
+ self.Bind(wiz.EVT_WIZARD_CANCEL, self.OnWizCancel)
+
+
+ def OnWizPageChanged(self, evt):
+ if evt.GetDirection():
+ dir = "forward"
+ else:
+ dir = "backward"
+
+ page = evt.GetPage()
+ self.log.write("OnWizPageChanged: %s, %s\n" % (dir, page.__class__))
+
+
+ def OnWizPageChanging(self, evt):
+ if evt.GetDirection():
+ dir = "forward"
+ else:
+ dir = "backward"
+
+ page = evt.GetPage()
+ self.log.write("OnWizPageChanging: %s, %s\n" % (dir, page.__class__))
+
+
+ def OnWizCancel(self, evt):
+ page = evt.GetPage()
+ self.log.write("OnWizCancel: %s\n" % page.__class__)
+
+ # Show how to prevent cancelling of the wizard. The
+ # other events can be Veto'd too.
+ if page is self.page1:
+ wx.MessageBox("Cancelling on the first page has been prevented.", "Sorry")
+ evt.Veto()
+
+
+ def OnWizFinished(self, evt):
+ self.log.write("OnWizFinished\n")
+
+
+ def OnRunSimpleWizard(self, evt):
+ # Create the wizard and the pages
+ wizard = wiz.Wizard(self, -1, "Simple Wizard", images.WizTest1.GetBitmap())
+ page1 = TitledPage(wizard, "Page 1")
+ page2 = TitledPage(wizard, "Page 2")
+ page3 = TitledPage(wizard, "Page 3")
+ page4 = TitledPage(wizard, "Page 4")
+ self.page1 = page1
+
+ page1.sizer.Add(wx.StaticText(page1, -1, """
+This wizard is totally useless, but is meant to show how to
+chain simple wizard pages together in a non-dynamic manner.
+IOW, the order of the pages never changes, and so the
+wxWizardPageSimple class can easily be used for the pages."""))
+ wizard.FitToPage(page1)
+ page4.sizer.Add(wx.StaticText(page4, -1, "\nThis is the last page."))
+
+ # Use the convenience Chain function to connect the pages
+ wiz.WizardPageSimple.Chain(page1, page2)
+ wiz.WizardPageSimple.Chain(page2, page3)
+ wiz.WizardPageSimple.Chain(page3, page4)
+
+ wizard.GetPageAreaSizer().Add(page1)
+ if wizard.RunWizard(page1):
+ wx.MessageBox("Wizard completed successfully", "That's all folks!")
+ else:
+ wx.MessageBox("Wizard was cancelled", "That's all folks!")
+
+
+
+ def OnRunDynamicWizard(self, evt):
+ # Create the wizard and the pages
+ #wizard = wx.PreWizard()
+ #wizard.SetExtraStyle(wx.WIZARD_EX_HELPBUTTON)
+ #wizard.Create(self, self.ID_wiz, "Simple Wizard",
+ # images.WizTest1.GetBitmap())
+ wizard = wiz.Wizard(self, -1, "Dynamic Wizard", images.WizTest1.GetBitmap())
+
+ page1 = TitledPage(wizard, "Page 1")
+ page2 = SkipNextPage(wizard, "Page 2")
+ page3 = TitledPage(wizard, "Page 3")
+ page4 = UseAltBitmapPage(wizard, "Page 4")
+ page5 = TitledPage(wizard, "Page 5")
+ self.page1 = page1
+
+ page1.sizer.Add(wx.StaticText(page1, -1, """
+This wizard shows the ability to choose at runtime the order
+of the pages and also which bitmap is shown.
+"""))
+ wizard.FitToPage(page1)
+ page5.sizer.Add(wx.StaticText(page5, -1, "\nThis is the last page."))
+
+ # Set the initial order of the pages
+ page1.SetNext(page2)
+ page2.SetPrev(page1)
+ page2.SetNext(page3)
+ page3.SetPrev(page2)
+ page3.SetNext(page4)
+ page4.SetPrev(page3)
+ page4.SetNext(page5)
+ page5.SetPrev(page4)
+
+
+ wizard.GetPageAreaSizer().Add(page1)
+ if wizard.RunWizard(page1):
+ wx.MessageBox("Wizard completed successfully", "That's all folks!")
+ else:
+ wx.MessageBox("Wizard was cancelled", "That's all folks!")
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wxWizard
+
+wxWizard is the central class for implementing 'wizard-like'
+dialogs. These dialogs are mostly familiar to Windows users and are
+nothing else but a sequence of 'pages' each of them displayed inside a
+dialog which has the buttons to pass to the next (and previous) pages.
+
+The wizards are typically used to decompose a complex dialog into
+several simple steps and are mainly useful to the novice users, hence
+it is important to keep them as simple as possible.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/WrapSizer.py b/demo/WrapSizer.py
new file mode 100644
index 00000000..08d83200
--- /dev/null
+++ b/demo/WrapSizer.py
@@ -0,0 +1,92 @@
+
+import wx
+from wx.lib.buttons import GenButton
+
+import random
+
+#----------------------------------------------------------------------
+
+class WrapSizerTest(wx.Frame):
+ def __init__(self, *args, **kw):
+ wx.Frame.__init__(self, *args, **kw)
+
+ # Make a title area and sizer for the upper part of the panel
+ pnl = wx.Panel(self)
+ stx = wx.StaticText(pnl, -1, "wx.WrapSizer Layout")
+ stx.SetFont(wx.FFont(28, wx.SWISS))
+ sln = wx.StaticLine(pnl)
+ upper = wx.BoxSizer(wx.VERTICAL)
+ upper.Add(stx, 0, wx.ALIGN_CENTER_HORIZONTAL|wx.TOP, 8)
+ upper.Add(sln, 0, wx.EXPAND|wx.ALL, 8)
+
+ # In the lower part of the panel we'll put a bunch of buttons
+ # in a WrapSizer
+ def _makeButtons(words):
+ sizer = wx.WrapSizer()
+ for word in words:
+ btn = GenButton(pnl, -1, word, style=wx.BU_EXACTFIT)
+ sizer.Add(btn, 0, wx.ALL, 4)
+
+ # Add a little color to make it interesting
+ r = random.randint(128, 255)
+ g = random.randint(128, 255)
+ b = random.randint(128, 255)
+ btn.SetBackgroundColour(wx.Colour(r,g,b))
+ btn.Refresh()
+
+ return sizer
+
+ lower1 = _makeButtons(sampleText.split())
+ lower2 = _makeButtons("Try resizing this Frame to see how it works.".split())
+
+ pnl.Sizer = wx.BoxSizer(wx.VERTICAL)
+ pnl.Sizer.Add(upper, 0, wx.EXPAND)
+ pnl.Sizer.Add(lower1, 0, wx.EXPAND|wx.LEFT|wx.RIGHT, 8)
+ pnl.Sizer.Add((16,16))
+ pnl.Sizer.Add(lower2, 0, wx.EXPAND|wx.LEFT|wx.RIGHT, 8)
+
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ b = wx.Button(self, -1, "Demonstrate wx.WrapSizer", (50,50))
+ self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+ def OnButton(self, evt):
+ win = WrapSizerTest(self, -1, "wx.WrapSizer Demo", size=(640, 480))
+ win.Show(True)
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+sampleText = """\
+The wx.WrapSizer implements a commonly requested layout mechanism where
+however many items will fit on a "line" are positioned next to each other, and
+then the location of the next item in the sizer is on the next logical line of
+the parent's layout. """
+
+overview = """
+
WrapSizer
+""" + \
+sampleText + \
+"""
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/XMLtreeview.py b/demo/XMLtreeview.py
new file mode 100644
index 00000000..36dc81f6
--- /dev/null
+++ b/demo/XMLtreeview.py
@@ -0,0 +1,108 @@
+
+import sys
+import wx
+
+from xml.parsers import expat
+
+#----------------------------------------------------------------------
+
+class XMLTree(wx.TreeCtrl):
+ def __init__(self, parent, ID):
+ wx.TreeCtrl.__init__(self, parent, ID)
+ self._root = self.AddRoot("Root")
+ self.nodeStack = [self._root]
+
+ # Trees need an image list to do DnD...
+ self.il = wx.ImageList(16,16)
+ self.SetImageList(self.il)
+
+ # event handlers for DnD
+ self.Bind(wx.EVT_TREE_BEGIN_DRAG, self.OnBeginDrag)
+ self.Bind(wx.EVT_TREE_END_DRAG, self.OnEndDrag)
+
+
+ def OnBeginDrag(self, event):
+ item = event.GetItem()
+
+ if item != self.GetRootItem():
+ self.draggingItem = item
+ event.Allow() # if DnD of this item is okay Allow it.
+
+ def IsDescendant(self, firstItem, secondItem):
+ "Recursive check if firstItem is a descendant of a secondItem."
+ if firstItem == self._root:
+ return False
+ parentItem = self.GetItemParent(firstItem)
+ if parentItem == secondItem:
+ return True
+ else:
+ return self.IsDescendant(parentItem, secondItem)
+
+ def OnEndDrag(self, evt):
+ itemSrc = self.draggingItem
+ itemDst = evt.GetItem()
+ self.draggingItem = None
+
+ if not itemDst.IsOk():
+ print "Can't drag to here..."
+ return
+
+ if self.IsDescendant(itemDst, itemSrc):
+ print "Can't move item to its descendant"
+ return
+
+ # For this simple example just take the text of the source item
+ # and append it to the destination item. In real life you would
+ # possibly want to copy subtrees...
+ text = self.GetItemText(itemSrc)
+ self.AppendItem(itemDst, text)
+ self.Delete(itemSrc)
+
+
+ # Define a handler for start element events
+ def StartElement(self, name, attrs ):
+ name = name.encode()
+
+ id = self.AppendItem(self.nodeStack[-1], name)
+ self.nodeStack.append(id)
+
+ def EndElement(self, name ):
+ self.nodeStack = self.nodeStack[:-1]
+
+ def CharacterData(self, data ):
+ if data.strip():
+ data = data.encode()
+
+ self.AppendItem(self.nodeStack[-1], data)
+
+
+ def LoadTree(self, filename):
+ # Create a parser
+ Parser = expat.ParserCreate()
+
+ # Tell the parser what the start element handler is
+ Parser.StartElementHandler = self.StartElement
+ Parser.EndElementHandler = self.EndElement
+ Parser.CharacterDataHandler = self.CharacterData
+
+ # Parse the XML File
+ ParserStatus = Parser.Parse(open(filename,'r').read(), 1)
+
+
+def runTest(frame, nb, log):
+ win = XMLTree(nb, -1)
+ win.LoadTree("paper.xml")
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """\
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
diff --git a/demo/XmlResource.py b/demo/XmlResource.py
new file mode 100644
index 00000000..5d241b1d
--- /dev/null
+++ b/demo/XmlResource.py
@@ -0,0 +1,76 @@
+
+import wx
+import wx.xrc as xrc
+
+from Main import opj
+
+#----------------------------------------------------------------------
+
+RESFILE = opj("data/resource_wdr.xrc")
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ wx.Panel.__init__(self, parent, -1)
+ self.log = log
+
+ # make the components
+ label = wx.StaticText(self, -1, "The lower panel was built from this XML:")
+ label.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
+
+ resourceText = open(RESFILE).read()
+ text = wx.TextCtrl(self, -1, resourceText,
+ style=wx.TE_READONLY|wx.TE_MULTILINE)
+ text.SetInsertionPoint(0)
+
+ line = wx.StaticLine(self, -1)
+
+ # This shows a few different ways to load XML Resources
+ if 0:
+ # XML Resources can be loaded from a file like this:
+ res = xrc.XmlResource(RESFILE)
+
+ elif 1:
+ # or from a Virtual FileSystem:
+ wx.FileSystem_AddHandler(wx.MemoryFSHandler())
+ wx.MemoryFSHandler_AddFile("XRC_Resources/data_file", resourceText)
+ res = xrc.XmlResource("memory:XRC_Resources/data_file")
+
+ else:
+ # or from a string, like this:
+ res = xrc.EmptyXmlResource()
+ res.LoadFromString(resourceText)
+
+
+ # Now create a panel from the resource data
+ panel = res.LoadPanel(self, "MyPanel")
+
+ # and do the layout
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(label, 0, wx.EXPAND|wx.TOP|wx.LEFT, 5)
+ sizer.Add(text, 1, wx.EXPAND|wx.ALL, 5)
+ sizer.Add(line, 0, wx.EXPAND)
+ sizer.Add(panel, 1, wx.EXPAND|wx.ALL, 5)
+
+ self.SetSizer(sizer)
+ self.SetAutoLayout(True)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/XmlResourceHandler.py b/demo/XmlResourceHandler.py
new file mode 100644
index 00000000..ef0c3a07
--- /dev/null
+++ b/demo/XmlResourceHandler.py
@@ -0,0 +1,202 @@
+
+import wx
+import wx.xrc as xrc
+
+#----------------------------------------------------------------------
+
+resourceText = r'''
+
+
+
+
+
+
+'''
+
+#----------------------------------------------------------------------
+
+class MyCustomPanel(wx.Panel):
+ def __init__(self, parent, id, pos, size, style, name):
+ wx.Panel.__init__(self, parent, id, pos, size, style, name)
+
+ # This is the little bit of customization that we do for this
+ # silly example.
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ t = wx.StaticText(self, -1, "MyCustomPanel")
+ f = t.GetFont()
+ f.SetWeight(wx.BOLD)
+ f.SetPointSize(f.GetPointSize()+2)
+ t.SetFont(f)
+ self.t = t
+
+ def OnSize(self, evt):
+ sz = self.GetSize()
+ w, h = self.t.GetTextExtent(self.t.GetLabel())
+ self.t.SetPosition(((sz.width-w)/2, (sz.height-h)/2))
+
+
+# To do it the more complex way, (see below) we need to write the
+# class a little differently... This could obviously be done with a
+# single class, but I wanted to make separate ones to make clear what
+# the different requirements are.
+class PreMyCustomPanel(wx.Panel):
+ def __init__(self):
+ p = wx.PrePanel()
+ self.PostCreate(p)
+
+ def Create(self, parent, id, pos, size, style, name):
+ wx.Panel.Create(self, parent, id, pos, size, style, name)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ t = wx.StaticText(self, -1, "MyCustomPanel")
+ f = t.GetFont()
+ f.SetWeight(wx.BOLD)
+ f.SetPointSize(f.GetPointSize()+2)
+ t.SetFont(f)
+ self.t = t
+
+ def OnSize(self, evt):
+ sz = self.GetSize()
+ w, h = self.t.GetTextExtent(self.t.GetLabel())
+ self.t.SetPosition(((sz.width-w)/2, (sz.height-h)/2))
+
+#----------------------------------------------------------------------
+
+class MyCustomPanelXmlHandler(xrc.XmlResourceHandler):
+ def __init__(self):
+ xrc.XmlResourceHandler.__init__(self)
+ # Specify the styles recognized by objects of this type
+ self.AddStyle("wxTAB_TRAVERSAL", wx.TAB_TRAVERSAL)
+ self.AddStyle("wxWS_EX_VALIDATE_RECURSIVELY", wx.WS_EX_VALIDATE_RECURSIVELY)
+ self.AddStyle("wxCLIP_CHILDREN", wx.CLIP_CHILDREN)
+ self.AddWindowStyles()
+
+ # This method and the next one are required for XmlResourceHandlers
+ def CanHandle(self, node):
+ return self.IsOfClass(node, "MyCustomPanel")
+
+ def DoCreateResource(self):
+ # NOTE: wxWindows can be created in either a single-phase or
+ # in a two-phase way. Single phase is what you normally do,
+ # and two-phase creates the instnace first, and then later
+ # creates the actual window when the Create method is called.
+ # (In wxPython the first phase is done using the wxPre*
+ # function, for example, wxPreFrame, wxPrePanel, etc.)
+ #
+ # wxXmlResource supports either method, a premade instance can
+ # be created and populated by xrc using the appropriate
+ # LoadOn* method (such as LoadOnPanel) or xrc can create the
+ # instance too, using the Load* method. However this makes
+ # the handlers a bit more complex. If you can be sure that a
+ # particular class will never be loaded using a pre-existing
+ # instance, then you can make the handle much simpler. I'll
+ # show both methods below.
+
+ if 1:
+ # The simple method assumes that there is no existing
+ # instance. Be sure of that with an assert.
+ assert self.GetInstance() is None
+
+ # Now create the object
+ panel = MyCustomPanel(self.GetParentAsWindow(),
+ self.GetID(),
+ self.GetPosition(),
+ self.GetSize(),
+ self.GetStyle("style", wx.TAB_TRAVERSAL),
+ self.GetName()
+ )
+ else:
+ # When using the more complex (but more flexible) method
+ # the instance may already have been created, check for it
+ panel = self.GetInstance()
+ if panel is None:
+ # if not, then create the instance (but not the window)
+ panel = PreMyCustomPanel()
+
+ # Now call the panel's Create method to actually create the window
+ panel.Create(self.GetParentAsWindow(),
+ self.GetID(),
+ self.GetPosition(),
+ self.GetSize(),
+ self.GetStyle("style", wx.TAB_TRAVERSAL),
+ self.GetName()
+ )
+
+ # These two things should be done in either case:
+ # Set standard window attributes
+ self.SetupWindow(panel)
+ # Create any child windows of this node
+ self.CreateChildren(panel)
+
+ return panel
+
+
+#----------------------------------------------------------------------
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ # make the components
+ label = wx.StaticText(self, -1, "The lower panel was built from this XML:")
+ label.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
+
+ text = wx.TextCtrl(self, -1, resourceText,
+ style=wx.TE_READONLY|wx.TE_MULTILINE)
+ text.SetInsertionPoint(0)
+
+ line = wx.StaticLine(self, -1)
+
+ # Load the resource
+ res = xrc.EmptyXmlResource()
+ res.InsertHandler(MyCustomPanelXmlHandler())
+ res.LoadFromString(resourceText)
+
+ # Now create a panel from the resource data
+ panel = res.LoadObject(self, "MyPanel", "MyCustomPanel")
+
+ # and do the layout
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(label, 0, wx.EXPAND|wx.TOP|wx.LEFT, 5)
+ sizer.Add(text, 1, wx.EXPAND|wx.ALL, 5)
+ sizer.Add(line, 0, wx.EXPAND)
+ sizer.Add(panel, 1, wx.EXPAND|wx.ALL, 5)
+
+ self.SetSizer(sizer)
+ self.SetAutoLayout(True)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.XmlResourceHandler
+
+Deriving a class from wx.XmlResourceHandler allows you to specify your
+own classes in XRC resources, and your handler class will then be used
+to create instances of that class when the resource is loaded.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/XmlResourceSubclass.py b/demo/XmlResourceSubclass.py
new file mode 100644
index 00000000..4cda2a45
--- /dev/null
+++ b/demo/XmlResourceSubclass.py
@@ -0,0 +1,120 @@
+
+import wx
+import wx.xrc as xrc
+
+#----------------------------------------------------------------------
+
+resourceText = r'''
+
+
+
+
+
+
+'''
+
+#----------------------------------------------------------------------
+
+class MyCustomPanel(wx.Panel):
+ def __init__(self):
+ p = wx.PrePanel()
+ # the Create step is done by XRC.
+ self.PostCreate(p)
+ self.Bind(wx.EVT_WINDOW_CREATE, self.OnCreate)
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+
+
+ def OnCreate(self, evt):
+ # This is the little bit of customization that we do for this
+ # silly example. It could just as easily have been done in
+ # the resource. We do it in the EVT_WINDOW_CREATE handler
+ # because the window doesn't really exist yet in the __init__.
+ if self is evt.GetEventObject():
+ t = wx.StaticText(self, -1, "MyCustomPanel")
+ f = t.GetFont()
+ f.SetWeight(wx.BOLD)
+ f.SetPointSize(f.GetPointSize()+2)
+ t.SetFont(f)
+ self.t = t
+ # On OSX the EVT_SIZE happens before EVT_WINDOW_CREATE !?!
+ # so give it another kick
+ wx.CallAfter(self.OnSize, None)
+ evt.Skip()
+
+ def OnSize(self, evt):
+ if hasattr(self, 't'):
+ sz = self.GetSize()
+ w, h = self.t.GetTextExtent(self.t.GetLabel())
+ self.t.SetPosition(((sz.width-w)/2, (sz.height-h)/2))
+
+#----------------------------------------------------------------------
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ # make the components
+ label = wx.StaticText(self, -1, "The lower panel was built from this XML:")
+ label.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
+
+ text = wx.TextCtrl(self, -1, resourceText,
+ style=wx.TE_READONLY|wx.TE_MULTILINE)
+ text.SetInsertionPoint(0)
+
+ line = wx.StaticLine(self, -1)
+
+ # Load the resource
+ res = xrc.EmptyXmlResource()
+ res.LoadFromString(resourceText)
+
+ # Now create a panel from the resource data
+ panel = res.LoadPanel(self, "MyPanel")
+
+ # and do the layout
+ sizer = wx.BoxSizer(wx.VERTICAL)
+ sizer.Add(label, 0, wx.EXPAND|wx.TOP|wx.LEFT, 5)
+ sizer.Add(text, 1, wx.EXPAND|wx.ALL, 5)
+ sizer.Add(line, 0, wx.EXPAND)
+ sizer.Add(panel, 1, wx.EXPAND|wx.ALL, 5)
+
+ self.SetSizer(sizer)
+ self.SetAutoLayout(True)
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.XmlResourceSubclass
+
+Sometimes it is necessary to use custom classes, but you still want
+them to be created from XRC. The subclass XRC attribute allows you to
+do that.
+
+
+"""
+
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
diff --git a/demo/agw/AGWInfoBar.py b/demo/agw/AGWInfoBar.py
new file mode 100644
index 00000000..46e1b6bc
--- /dev/null
+++ b/demo/agw/AGWInfoBar.py
@@ -0,0 +1,174 @@
+import wx
+import random
+
+import os
+import sys
+
+try:
+ dirName = os.path.dirname(os.path.abspath(__file__))
+except:
+ dirName = os.path.dirname(os.path.abspath(sys.argv[0]))
+
+sys.path.append(os.path.split(dirName)[0])
+
+try:
+ import agw.infobar as IB
+except ImportError: # if it's not there locally, try the wxPython lib.
+ import wx.lib.agw.infobar as IB
+
+from images import catalog
+
+#----------------------------------------------------------------------
+
+def GetValidImages():
+
+ keys = catalog.keys()
+ valid_images = []
+ counter = 0
+
+ for key in keys:
+ bmp = catalog[key].GetBitmap()
+ if bmp.GetWidth() == 16 and bmp.GetHeight() == 16:
+ valid_images.append(bmp)
+
+ return valid_images
+
+#----------------------------------------------------------------------
+
+flags = [ (wx.ICON_NONE, "ICON_NONE"),
+ (wx.ICON_INFORMATION, "ICON_INFORMATION"),
+ (wx.ICON_QUESTION, "ICON_QUESTION"),
+ (wx.ICON_WARNING, "ICON_WARNING"),
+ (wx.ICON_ERROR, "ICON_ERROR")
+ ]
+
+
+class TestPanel(wx.Panel):
+ def __init__(self, parent, log):
+ self.log = log
+ wx.Panel.__init__(self, parent, -1)
+
+ # Create the InfoBar. It starts out in a hidden state so it
+ # won't be visible until we need it.
+ self.info = IB.InfoBar(self)
+
+ panel = wx.Panel(self)
+
+ self.message = wx.TextCtrl(panel, -1, "Hello World", size=(250,-1))
+ self.flags = wx.Choice(panel, choices=[f[1] for f in flags])
+ self.flags.SetSelection(1) # wx.ICON_INFORMATION is the default
+
+ self.checkBitmap = wx.CheckBox(panel, -1, 'With Bitmap')
+
+ smBtn = wx.Button(panel, -1, "Show Message")
+ dmBtn = wx.Button(panel, -1, "Dismiss")
+ addBtn = wx.Button(panel, -1, "Add Button")
+
+ fgs = wx.FlexGridSizer(cols=3, vgap=10, hgap=10)
+ fgs.Add(wx.StaticText(panel, -1, "Message:"), 0,
+ wx.ALIGN_CENTER_VERTICAL|wx.ALIGN_RIGHT)
+ fgs.Add(self.message)
+ fgs.Add(self.flags)
+ fgs.AddSpacer(5)
+
+ hbox = wx.BoxSizer(wx.HORIZONTAL)
+ hbox.Add(smBtn, 0, wx.RIGHT, 5)
+ hbox.Add(dmBtn)
+ fgs.Add(hbox)
+ fgs.AddSpacer(5)
+ fgs.AddSpacer(5)
+
+ hbox2 = wx.BoxSizer(wx.HORIZONTAL)
+
+ hbox2.Add(addBtn, 0, wx.RIGHT, 10)
+ hbox2.Add(self.checkBitmap, 0, wx.ALIGN_CENTER)
+ fgs.Add(hbox2)
+
+ panel.Sizer = wx.BoxSizer(wx.VERTICAL)
+ text = """\
+An info bar is a transient window shown at top or bottom of its parent window
+to display non-critical information to the user."""
+ panel.Sizer.Add(wx.StaticText(panel, -1, text), 0, wx.TOP|wx.LEFT, 25)
+ panel.Sizer.Add(fgs, 1, wx.EXPAND|wx.ALL, 25)
+
+ self.Sizer = wx.BoxSizer(wx.VERTICAL)
+ self.Sizer.Add(self.info, 0, wx.EXPAND)
+ self.Sizer.Add(panel, 1, wx.EXPAND)
+
+ self.Bind(wx.EVT_BUTTON, self.OnShowMessage, smBtn)
+ self.Bind(wx.EVT_BUTTON, self.OnDismiss, dmBtn)
+ self.Bind(wx.EVT_BUTTON, self.OnAddButton, addBtn)
+
+ self.valid_images = GetValidImages()
+
+
+ def OnShowMessage(self, event):
+ msg = self.message.GetValue()
+ flag = flags[self.flags.GetSelection()][0]
+ self.info.ShowMessage(msg, flag)
+
+
+ def OnDismiss(self, event):
+ self.info.Dismiss()
+
+
+ def OnAddButton(self, event):
+ btnId = wx.NewId()
+
+ if self.checkBitmap.GetValue():
+ bitmap = random.choice(self.valid_images)
+ else:
+ bitmap = wx.NullBitmap
+
+ self.info.AddButton(btnId, "New Button", bitmap)
+ self.info.Bind(wx.EVT_BUTTON, self.OnButtonClicked, id=btnId)
+
+
+ def OnButtonClicked(self, event):
+ wx.MessageBox("New Button clicked")
+ # Calling event.Skip() will allow the default handler to run
+ # which will dismiss the info bar. If you don't want it to be
+ # dismissed for a particular button then then don't call
+ # Skip().
+ event.Skip()
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestPanel(nb, log)
+ return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """
+
wx.InfoBar
+
+An info bar is a transient window shown at top or bottom of its parent
+window to display non-critical information to the user.
+
+
This class provides another way to show messages to the user,
+intermediate between message boxes and status bar messages. The
+message boxes are modal and thus interrupt the users work flow and
+should be used sparingly for this reason. However status bar messages
+are often too easy not to notice at all. An info bar provides a way to
+present the messages which has a much higher chance to be noticed by
+the user but without being annoying.
+
+
AUI is an Advanced User Interface library for the wxPython toolkit " \
+ "that allows developers to create high-quality, cross-platform user " \
+ "interfaces quickly and easily.
" \
+ "
Features
" \
+ "
With AUI, developers can create application frameworks with:
Implementation of a simple minimize pane system: Clicking on this minimize button causes a new " \
+ "AuiToolBar to be created and added to the frame manager, (currently the implementation is such " \
+ "that panes at West will have a toolbar at the right, panes at South will have toolbars at the " \
+ "bottom etc...) and the pane is hidden in the manager. " \
+ "Clicking on the restore button on the newly created toolbar will result in the toolbar being " \
+ "removed and the original pane being restored;
" \
+ "
Panes can be docked on top of each other to form AuiNotebooks; AuiNotebooks tabs can be torn " \
+ "off to create floating panes;
" \
+ "
On Windows XP, use the nice sash drawing provided by XP while dragging the sash;
" \
+ "
Possibility to set an icon on docked panes;
" \
+ "
Possibility to draw a sash visual grip, for enhanced visualization of sashes;
" \
+ "
Implementation of a native docking art (ModernDockArt). Windows XP only, requires Mark Hammond's " \
+ "pywin32 package (winxptheme);
" \
+ "
Possibility to set a transparency for floating panes (a la Paint .NET);
" \
+ "
Snapping the main frame to the screen in any positin specified by horizontal and vertical " \
+ "alignments;
" \
+ "
Snapping floating panes on left/right/top/bottom or any combination of directions, a la Winamp;
" \
+ "
'Fly-out' floating panes, i.e. panes which show themselves only when the mouse hover them;
" \
+ "
Ability to set custom bitmaps for pane buttons (close, maximize, etc...);
" \
+ "
Implementation of the style AUI_MGR_ANIMATE_FRAMES, which fade-out floating panes when " \
+ "they are closed (all platforms which support frames transparency) and show a moving rectangle " \
+ "when they are docked and minimized (Windows excluding Vista and GTK only);
" \
+ "
A pane switcher dialog is available to cycle through existing AUI panes;
" \
+ "
Some flags which allow to choose the orientation and the position of the minimized panes;
" \
+ "
The functions [Get]MinimizeMode() in AuiPaneInfo which allow to set/get the flags described above;
" \
+ "
Events like EVT_AUI_PANE_DOCKING, EVT_AUI_PANE_DOCKED, EVT_AUI_PANE_FLOATING "\
+ "and EVT_AUI_PANE_FLOATED are "\
+ "available for all panes except toolbar panes;
" \
+ "
Implementation of the RequestUserAttention method for panes;
" \
+ "
Ability to show the caption bar of docked panes on the left instead of on the top (with caption " \
+ "text rotated by 90 degrees then). This is similar to what wxDockIt did. To enable this feature on any " \
+ "given pane, simply call CaptionVisible(True, left=True);
" \
+ "
New Aero-style docking guides: you can enable them by using the AuiManager style AUI_MGR_AERO_DOCKING_GUIDES;
" \
+ "
New Whidbey-style docking guides: you can enable them by using the AuiManager style AUI_MGR_WHIDBEY_DOCKING_GUIDES;
" \
+ "
A slide-in/slide-out preview of minimized panes can be seen by enabling the AuiManager style" \
+ "AUI_MGR_PREVIEW_MINIMIZED_PANES and by hovering with the mouse on the minimized pane toolbar tool;
" \
+ "
Native of custom-drawn mini frames can be used as floating panes, depending on the AUI_MGR_USE_NATIVE_MINIFRAMES style;
" \
+ "
A 'smooth docking effect' can be obtained by using the AUI_MGR_SMOOTH_DOCKING style (similar to PyQT docking style);
" \
+ '
Implementation of "Movable" panes, i.e. a pane that is set as `Movable()` but not `Floatable()` can be dragged and docked into a new location but will not form a floating window in between.
' \
+ "
" \
+ "
AuiNotebook:
" \
+ "
" \
+ "
Implementation of the style AUI_NB_HIDE_ON_SINGLE_TAB, a la wx.lib.agw.flatnotebook;
" \
+ "
Implementation of the style AUI_NB_SMART_TABS, a la wx.lib.agw.flatnotebook;
" \
+ "
Implementation of the style AUI_NB_USE_IMAGES_DROPDOWN, which allows to show tab images " \
+ "on the tab dropdown menu instead of bare check menu items (a la wx.lib.agw.flatnotebook);
" \
+ "
6 different tab arts are available, namely:
" \
+ "
" \
+ "
Default 'glossy' theme (as in wx.aui.AuiNotebook)
" \
+ "
Simple theme (as in wx.aui.AuiNotebook)
" \
+ "
Firefox 2 theme
" \
+ "
Visual Studio 2003 theme (VC71)
" \
+ "
Visual Studio 2005 theme (VC81)
" \
+ "
Google Chrome theme
" \
+ "
" \
+ "
Enabling/disabling tabs;
" \
+ "
Setting the colour of the tab's text;
" \
+ "
Implementation of the style AUI_NB_CLOSE_ON_TAB_LEFT, which draws the tab close button on " \
+ "the left instead of on the right (a la Camino browser);
" \
+ "
Ability to save and load perspectives in wx.aui.AuiNotebook (experimental);
" \
+ "
Possibility to add custom buttons in the wx.aui.AuiNotebook tab area;
" \
+ "
Implementation of the style AUI_NB_TAB_FLOAT, which allows the floating of single tabs. " \
+ "Known limitation: when the notebook is more or less full screen, tabs cannot be dragged far " \
+ "enough outside of the notebook to become floating pages.
" \
+ "
Implementation of the style AUI_NB_DRAW_DND_TAB (on by default), which draws an image " \
+ "representation of a tab while dragging;
" \
+ "
Implementation of the AuiNotebook unsplit functionality, which unsplit a splitted AuiNotebook " \
+ "when double-clicking on a sash (Use SetSashDClickUnsplit);
" \
+ "
Possibility to hide all the tabs by calling HideAllTAbs;
" \
+ "
wxPython controls can now be added inside page tabs by calling AddControlToPage, and they can be " \
+ "removed by calling RemoveControlFromPage;
" \
+ "
Possibility to preview all the pages in a AuiNotebook (as thumbnails) by using the NotebookPreview " \
+ "method of AuiNotebook
;" \
+ "
Tab labels can be edited by calling the SetRenamable method on a AuiNotebook page;
" \
+ "
Support for multi-lines tab labels in AuiNotebook;
" \
+ "
Support for setting minimum and maximum tab widths for fixed width tabs;
"\
+ "
Implementation of the style AUI_NB_ORDER_BY_ACCESS, which orders the tabs by last access time inside the "\
+ "Tab Navigator dialog
;" \
+ "
Implementation of the style AUI_NB_NO_TAB_FOCUS, allowing the developer not to draw the tab " \
+ "focus rectangle on tne AuiNotebook tabs.
"\
+ "
" \
+ "
AuiToolBar:
" \
+ "
" \
+ "
AUI_TB_PLAIN_BACKGROUND style that allows to easy setup a plain background to the AUI toolbar, " \
+ "without the need to override drawing methods. This style contrasts with the default behaviour " \
+ "of the wx.aui.AuiToolBar that draws a background gradient and this break the window design when " \
+ "putting it within a control that has margin between the borders and the toolbar (example: put " \
+ "wx.aui.AuiToolBar within a wx.StaticBoxSizer that has a plain background);
Ability of creating AuiToolBar tools with [counter]clockwise rotation. This allows to propose a " \
+ "variant of the minimizing functionality with a rotated button which keeps the caption of the pane as label;
" \
+ "
Allow setting the alignment of all tools in a toolbar that is expanded.
" \
+ "
Implementation of the AUI_MINIMIZE_POS_TOOLBAR flag, which allows to minimize a pane inside " \
+ "an existing toolbar. Limitation: if the minimized icon in the toolbar ends up in the overflowing " \
+ "items (i.e., a menu is needed to show the icon), this style will not work.
To intercept events from a list control, use the event table macros described in
+wxListEvent.
+
+
Mix-ins
+This example demonstrates how to use mixins. The following mixins are available.
+
+
ColumnSorterMixin
+
+ColumnSorterMixin(numColumns)
+
+
A mixin class that handles sorting of a wxListCtrl in REPORT mode when the column
+header is clicked on.
+
+
There are a few requirments needed in order for this to work genericly:
+
+
The combined class must have a GetListCtrl method that returns
+ the ListCtrl to be sorted, and the list control must exist at the time the
+ ColumnSorterMixin.__init__()method is called because it uses
+ GetListCtrl.
+
+
Items in the list control must have a unique data value set with
+ list.SetItemData.
+
+
The combined class must have an attribute named itemDataMap
+ that is a dictionary mapping the data values to a sequence of objects
+ representing the values in each column. These valuesare compared in
+ the column sorter to determine sort order.
+
+
+
Interesting methods to override are GetColumnSorter,
+GetSecondarySortValues, and GetSortImages.
+
+
Methods
+
+
SetColumnCount(newNumColumns)
+
Informs the mixin as to the number of columns in the control. When it is
+set, it also sets up an event handler for EVT_LIST_COL_CLICK events.
+
+
SortListItems(col=-1, ascending=1)
+
Sort the list on demand. Can also be used to set the sort column and order.
+
+
GetColumnWidths()
+
Returns a list of column widths. Can be used to help restore the current
+view later.
+
+
GetSortImages()
+
Returns a tuple of image list indexes the indexes in the image list for an
+image to be put on the column header when sorting in descending order
+
+
GetColumnSorter()
+
Returns a callable object to be used for comparing column values when sorting.
+
+
GetSecondarySortValues(col, key1, key2)
+
Returns a tuple of 2 values to use for secondary sort values when the
+items in the selected column match equal. The default just returns the
+item data values.
+
+
+
+
ListCtrlAutoWidthMixin
+
+ListCtrlAutoWidthMixin()
+
+
A mix-in class that automatically resizes the last column to take up the
+remaining width of the ListCtrl.
+
+
This causes the ListCtrl to automatically take up the full width of the list,
+without either a horizontal scroll bar (unless absolutely necessary) or empty
+space to the right of the last column.
+
+
NOTE: This only works for report-style lists.
+
+
WARNING: If you override the EVT_SIZE event in your ListCtrl,
+make sure you call event.Skip() to ensure that the mixin's _OnResize method is
+called.
+
+
Resize the last column appropriately. If the list's columns are too wide to
+fit within the window, we use a horizontal scrollbar. Otherwise, we expand the
+right-most column to take up the remaining free space in the list. This method is
+called automatically when the ListCtrl is resized; you can also call it yourself
+whenever you want the last column to be resized appropriately (eg, when adding,
+removing or resizing columns). 'minWidth' is the preferred minimum width for
+the last column.
+
+
+
+
+
ListCtrlSelectionManagerMix
+
+ListCtrlSelectionManagerMix()
+
+
Mixin that defines a platform independent selection policy
+
+
As selection single and multi-select list return the item index or a
+list of item indexes respectively.
+
+
Methods
+
+
+
getPopupMenu()
+
Override to implement dynamic menus (create)
+
+
setPopupMenu(menu)
+
Must be set for default behaviour.
+
+
afterPopupMenu()
+
Override to implement dynamic menus (destroy).
+
+
\n\n"
+
+ # Get the number of widgets in the package...
+ numWidgets = len(GetDemos()[1])
+ widgetsFound, endRemarks = 0, 0
+ for line in splitted:
+ # Loop over the lines in the AGW documentation
+ newLine = line
+ if line.startswith("- "):
+ # That's a new widget
+ indxStart = line.index("-") + 1
+ indxEnd = line.index(":")
+ sw = line[indxStart:indxEnd]
+ # Put a bullet
+ newLine = "
+////////////////////////////////////////////////////////////////////////////
+// Name: stc.h
+// Purpose: A wxWidgets implementation of Scintilla. This class is the
+// one meant to be used directly by wx applications. It does not
+// derive directly from the Scintilla classes, and in fact there
+// is no mention of Scintilla classes at all in this header.
+// This class delegates all method calls and events to the
+// Scintilla objects and so forth. This allows the use of
+// Scintilla without polluting the namespace with all the
+// classes and itentifiers from Scintilla.
+//
+// Author: Robin Dunn
+//
+// Created: 13-Jan-2000
+// RCS-ID: $Id$
+// Copyright: (c) 2000 by Total Control Software
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __stc_h__
+#define __stc_h__
+
+
+#include "wx/wx.h"
+#include "wx/dnd.h"
+
+
+#ifdef WXMAKINGDLL_STC
+ #define WXDLLIMPEXP_STC WXEXPORT
+#elif defined(WXUSINGDLL)
+ #define WXDLLIMPEXP_STC WXIMPORT
+#else // not making nor using DLL
+ #define WXDLLIMPEXP_STC
+#endif
+
+
+// SWIG can't handle "#if" type of conditionals, only "#ifdef"
+#ifdef SWIG
+#define STC_USE_DND 1
+#else
+#if wxUSE_DRAG_AND_DROP
+#define STC_USE_DND 1
+#endif
+#endif
+
+//----------------------------------------------------------------------
+
+// Should a wxPopupWindow be used for the call tips and autocomplete windows?
+#ifndef wxSTC_USE_POPUP
+#define wxSTC_USE_POPUP 1
+#endif
+
+//----------------------------------------------------------------------
+// BEGIN generated section. The following code is automatically generated
+// by gen_iface.py. Do not edit this file. Edit stc.h.in instead
+// and regenerate
+
+#define wxSTC_INVALID_POSITION -1
+
+// Define start of Scintilla messages to be greater than all Windows edit (EM_*) messages
+// as many EM_ messages can be used although that use is deprecated.
+#define wxSTC_START 2000
+#define wxSTC_OPTIONAL_START 3000
+#define wxSTC_LEXER_START 4000
+#define wxSTC_WS_INVISIBLE 0
+#define wxSTC_WS_VISIBLEALWAYS 1
+#define wxSTC_WS_VISIBLEAFTERINDENT 2
+#define wxSTC_EOL_CRLF 0
+#define wxSTC_EOL_CR 1
+#define wxSTC_EOL_LF 2
+
+// The SC_CP_UTF8 value can be used to enter Unicode mode.
+// This is the same value as CP_UTF8 in Windows
+#define wxSTC_CP_UTF8 65001
+
+// The SC_CP_DBCS value can be used to indicate a DBCS mode for GTK+.
+#define wxSTC_CP_DBCS 1
+#define wxSTC_MARKER_MAX 31
+#define wxSTC_MARK_CIRCLE 0
+#define wxSTC_MARK_ROUNDRECT 1
+#define wxSTC_MARK_ARROW 2
+#define wxSTC_MARK_SMALLRECT 3
+#define wxSTC_MARK_SHORTARROW 4
+#define wxSTC_MARK_EMPTY 5
+#define wxSTC_MARK_ARROWDOWN 6
+#define wxSTC_MARK_MINUS 7
+#define wxSTC_MARK_PLUS 8
+
+// Shapes used for outlining column.
+#define wxSTC_MARK_VLINE 9
+#define wxSTC_MARK_LCORNER 10
+#define wxSTC_MARK_TCORNER 11
+#define wxSTC_MARK_BOXPLUS 12
+#define wxSTC_MARK_BOXPLUSCONNECTED 13
+#define wxSTC_MARK_BOXMINUS 14
+#define wxSTC_MARK_BOXMINUSCONNECTED 15
+#define wxSTC_MARK_LCORNERCURVE 16
+#define wxSTC_MARK_TCORNERCURVE 17
+#define wxSTC_MARK_CIRCLEPLUS 18
+#define wxSTC_MARK_CIRCLEPLUSCONNECTED 19
+#define wxSTC_MARK_CIRCLEMINUS 20
+#define wxSTC_MARK_CIRCLEMINUSCONNECTED 21
+
+// Invisible mark that only sets the line background color.
+#define wxSTC_MARK_BACKGROUND 22
+#define wxSTC_MARK_DOTDOTDOT 23
+#define wxSTC_MARK_ARROWS 24
+#define wxSTC_MARK_PIXMAP 25
+#define wxSTC_MARK_FULLRECT 26
+#define wxSTC_MARK_CHARACTER 10000
+
+// Markers used for outlining column.
+#define wxSTC_MARKNUM_FOLDEREND 25
+#define wxSTC_MARKNUM_FOLDEROPENMID 26
+#define wxSTC_MARKNUM_FOLDERMIDTAIL 27
+#define wxSTC_MARKNUM_FOLDERTAIL 28
+#define wxSTC_MARKNUM_FOLDERSUB 29
+#define wxSTC_MARKNUM_FOLDER 30
+#define wxSTC_MARKNUM_FOLDEROPEN 31
+#define wxSTC_MASK_FOLDERS 0xFE000000
+#define wxSTC_MARGIN_SYMBOL 0
+#define wxSTC_MARGIN_NUMBER 1
+
+// Styles in range 32..37 are predefined for parts of the UI and are not used as normal styles.
+// Styles 38 and 39 are for future use.
+#define wxSTC_STYLE_DEFAULT 32
+#define wxSTC_STYLE_LINENUMBER 33
+#define wxSTC_STYLE_BRACELIGHT 34
+#define wxSTC_STYLE_BRACEBAD 35
+#define wxSTC_STYLE_CONTROLCHAR 36
+#define wxSTC_STYLE_INDENTGUIDE 37
+#define wxSTC_STYLE_LASTPREDEFINED 39
+#define wxSTC_STYLE_MAX 127
+
+// Character set identifiers are used in StyleSetCharacterSet.
+// The values are the same as the Windows *_CHARSET values.
+#define wxSTC_CHARSET_ANSI 0
+#define wxSTC_CHARSET_DEFAULT 1
+#define wxSTC_CHARSET_BALTIC 186
+#define wxSTC_CHARSET_CHINESEBIG5 136
+#define wxSTC_CHARSET_EASTEUROPE 238
+#define wxSTC_CHARSET_GB2312 134
+#define wxSTC_CHARSET_GREEK 161
+#define wxSTC_CHARSET_HANGUL 129
+#define wxSTC_CHARSET_MAC 77
+#define wxSTC_CHARSET_OEM 255
+#define wxSTC_CHARSET_RUSSIAN 204
+#define wxSTC_CHARSET_CYRILLIC 1251
+#define wxSTC_CHARSET_SHIFTJIS 128
+#define wxSTC_CHARSET_SYMBOL 2
+#define wxSTC_CHARSET_TURKISH 162
+#define wxSTC_CHARSET_JOHAB 130
+#define wxSTC_CHARSET_HEBREW 177
+#define wxSTC_CHARSET_ARABIC 178
+#define wxSTC_CHARSET_VIETNAMESE 163
+#define wxSTC_CHARSET_THAI 222
+#define wxSTC_CHARSET_8859_15 1000
+#define wxSTC_CASE_MIXED 0
+#define wxSTC_CASE_UPPER 1
+#define wxSTC_CASE_LOWER 2
+#define wxSTC_INDIC_MAX 7
+#define wxSTC_INDIC_PLAIN 0
+#define wxSTC_INDIC_SQUIGGLE 1
+#define wxSTC_INDIC_TT 2
+#define wxSTC_INDIC_DIAGONAL 3
+#define wxSTC_INDIC_STRIKE 4
+#define wxSTC_INDIC_HIDDEN 5
+#define wxSTC_INDIC_BOX 6
+#define wxSTC_INDIC0_MASK 0x20
+#define wxSTC_INDIC1_MASK 0x40
+#define wxSTC_INDIC2_MASK 0x80
+#define wxSTC_INDICS_MASK 0xE0
+
+// PrintColourMode - use same colours as screen.
+#define wxSTC_PRINT_NORMAL 0
+
+// PrintColourMode - invert the light value of each style for printing.
+#define wxSTC_PRINT_INVERTLIGHT 1
+
+// PrintColourMode - force black text on white background for printing.
+#define wxSTC_PRINT_BLACKONWHITE 2
+
+// PrintColourMode - text stays coloured, but all background is forced to be white for printing.
+#define wxSTC_PRINT_COLOURONWHITE 3
+
+// PrintColourMode - only the default-background is forced to be white for printing.
+#define wxSTC_PRINT_COLOURONWHITEDEFAULTBG 4
+#define wxSTC_FIND_WHOLEWORD 2
+#define wxSTC_FIND_MATCHCASE 4
+#define wxSTC_FIND_WORDSTART 0x00100000
+#define wxSTC_FIND_REGEXP 0x00200000
+#define wxSTC_FIND_POSIX 0x00400000
+#define wxSTC_FOLDLEVELBASE 0x400
+#define wxSTC_FOLDLEVELWHITEFLAG 0x1000
+#define wxSTC_FOLDLEVELHEADERFLAG 0x2000
+#define wxSTC_FOLDLEVELBOXHEADERFLAG 0x4000
+#define wxSTC_FOLDLEVELBOXFOOTERFLAG 0x8000
+#define wxSTC_FOLDLEVELCONTRACTED 0x10000
+#define wxSTC_FOLDLEVELUNINDENT 0x20000
+#define wxSTC_FOLDLEVELNUMBERMASK 0x0FFF
+#define wxSTC_FOLDFLAG_LINEBEFORE_EXPANDED 0x0002
+#define wxSTC_FOLDFLAG_LINEBEFORE_CONTRACTED 0x0004
+#define wxSTC_FOLDFLAG_LINEAFTER_EXPANDED 0x0008
+#define wxSTC_FOLDFLAG_LINEAFTER_CONTRACTED 0x0010
+#define wxSTC_FOLDFLAG_LEVELNUMBERS 0x0040
+#define wxSTC_FOLDFLAG_BOX 0x0001
+#define wxSTC_TIME_FOREVER 10000000
+#define wxSTC_WRAP_NONE 0
+#define wxSTC_WRAP_WORD 1
+#define wxSTC_WRAP_CHAR 2
+#define wxSTC_WRAPVISUALFLAG_NONE 0x0000
+#define wxSTC_WRAPVISUALFLAG_END 0x0001
+#define wxSTC_WRAPVISUALFLAG_START 0x0002
+#define wxSTC_WRAPVISUALFLAGLOC_DEFAULT 0x0000
+#define wxSTC_WRAPVISUALFLAGLOC_END_BY_TEXT 0x0001
+#define wxSTC_WRAPVISUALFLAGLOC_START_BY_TEXT 0x0002
+#define wxSTC_CACHE_NONE 0
+#define wxSTC_CACHE_CARET 1
+#define wxSTC_CACHE_PAGE 2
+#define wxSTC_CACHE_DOCUMENT 3
+#define wxSTC_EDGE_NONE 0
+#define wxSTC_EDGE_LINE 1
+#define wxSTC_EDGE_BACKGROUND 2
+#define wxSTC_CURSORNORMAL -1
+#define wxSTC_CURSORWAIT 4
+
+// Constants for use with SetVisiblePolicy, similar to SetCaretPolicy.
+#define wxSTC_VISIBLE_SLOP 0x01
+#define wxSTC_VISIBLE_STRICT 0x04
+
+// Caret policy, used by SetXCaretPolicy and SetYCaretPolicy.
+// If CARET_SLOP is set, we can define a slop value: caretSlop.
+// This value defines an unwanted zone (UZ) where the caret is... unwanted.
+// This zone is defined as a number of pixels near the vertical margins,
+// and as a number of lines near the horizontal margins.
+// By keeping the caret away from the edges, it is seen within its context,
+// so it is likely that the identifier that the caret is on can be completely seen,
+// and that the current line is seen with some of the lines following it which are
+// often dependent on that line.
+#define wxSTC_CARET_SLOP 0x01
+
+// If CARET_STRICT is set, the policy is enforced... strictly.
+// The caret is centred on the display if slop is not set,
+// and cannot go in the UZ if slop is set.
+#define wxSTC_CARET_STRICT 0x04
+
+// If CARET_JUMPS is set, the display is moved more energetically
+// so the caret can move in the same direction longer before the policy is applied again.
+#define wxSTC_CARET_JUMPS 0x10
+
+// If CARET_EVEN is not set, instead of having symmetrical UZs,
+// the left and bottom UZs are extended up to right and top UZs respectively.
+// This way, we favour the displaying of useful information: the begining of lines,
+// where most code reside, and the lines after the caret, eg. the body of a function.
+#define wxSTC_CARET_EVEN 0x08
+
+// Selection modes
+#define wxSTC_SEL_STREAM 0
+#define wxSTC_SEL_RECTANGLE 1
+#define wxSTC_SEL_LINES 2
+
+// Maximum value of keywordSet parameter of SetKeyWords.
+#define wxSTC_KEYWORDSET_MAX 8
+
+// Notifications
+// Type of modification and the action which caused the modification.
+// These are defined as a bit mask to make it easy to specify which notifications are wanted.
+// One bit is set from each of SC_MOD_* and SC_PERFORMED_*.
+#define wxSTC_MOD_INSERTTEXT 0x1
+#define wxSTC_MOD_DELETETEXT 0x2
+#define wxSTC_MOD_CHANGESTYLE 0x4
+#define wxSTC_MOD_CHANGEFOLD 0x8
+#define wxSTC_PERFORMED_USER 0x10
+#define wxSTC_PERFORMED_UNDO 0x20
+#define wxSTC_PERFORMED_REDO 0x40
+#define wxSTC_MULTISTEPUNDOREDO 0x80
+#define wxSTC_LASTSTEPINUNDOREDO 0x100
+#define wxSTC_MOD_CHANGEMARKER 0x200
+#define wxSTC_MOD_BEFOREINSERT 0x400
+#define wxSTC_MOD_BEFOREDELETE 0x800
+#define wxSTC_MULTILINEUNDOREDO 0x1000
+#define wxSTC_MODEVENTMASKALL 0x1FFF
+
+// Symbolic key codes and modifier flags.
+// ASCII and other printable characters below 256.
+// Extended keys above 300.
+#define wxSTC_KEY_DOWN 300
+#define wxSTC_KEY_UP 301
+#define wxSTC_KEY_LEFT 302
+#define wxSTC_KEY_RIGHT 303
+#define wxSTC_KEY_HOME 304
+#define wxSTC_KEY_END 305
+#define wxSTC_KEY_PRIOR 306
+#define wxSTC_KEY_NEXT 307
+#define wxSTC_KEY_DELETE 308
+#define wxSTC_KEY_INSERT 309
+#define wxSTC_KEY_ESCAPE 7
+#define wxSTC_KEY_BACK 8
+#define wxSTC_KEY_TAB 9
+#define wxSTC_KEY_RETURN 13
+#define wxSTC_KEY_ADD 310
+#define wxSTC_KEY_SUBTRACT 311
+#define wxSTC_KEY_DIVIDE 312
+#define wxSTC_SCMOD_NORM 0
+#define wxSTC_SCMOD_SHIFT 1
+#define wxSTC_SCMOD_CTRL 2
+#define wxSTC_SCMOD_ALT 4
+
+// For SciLexer.h
+#define wxSTC_LEX_CONTAINER 0
+#define wxSTC_LEX_NULL 1
+#define wxSTC_LEX_PYTHON 2
+#define wxSTC_LEX_CPP 3
+#define wxSTC_LEX_HTML 4
+#define wxSTC_LEX_XML 5
+#define wxSTC_LEX_PERL 6
+#define wxSTC_LEX_SQL 7
+#define wxSTC_LEX_VB 8
+#define wxSTC_LEX_PROPERTIES 9
+#define wxSTC_LEX_ERRORLIST 10
+#define wxSTC_LEX_MAKEFILE 11
+#define wxSTC_LEX_BATCH 12
+#define wxSTC_LEX_XCODE 13
+#define wxSTC_LEX_LATEX 14
+#define wxSTC_LEX_LUA 15
+#define wxSTC_LEX_DIFF 16
+#define wxSTC_LEX_CONF 17
+#define wxSTC_LEX_PASCAL 18
+#define wxSTC_LEX_AVE 19
+#define wxSTC_LEX_ADA 20
+#define wxSTC_LEX_LISP 21
+#define wxSTC_LEX_RUBY 22
+#define wxSTC_LEX_EIFFEL 23
+#define wxSTC_LEX_EIFFELKW 24
+#define wxSTC_LEX_TCL 25
+#define wxSTC_LEX_NNCRONTAB 26
+#define wxSTC_LEX_BULLANT 27
+#define wxSTC_LEX_VBSCRIPT 28
+#define wxSTC_LEX_BAAN 31
+#define wxSTC_LEX_MATLAB 32
+#define wxSTC_LEX_SCRIPTOL 33
+#define wxSTC_LEX_ASM 34
+#define wxSTC_LEX_CPPNOCASE 35
+#define wxSTC_LEX_FORTRAN 36
+#define wxSTC_LEX_F77 37
+#define wxSTC_LEX_CSS 38
+#define wxSTC_LEX_POV 39
+#define wxSTC_LEX_LOUT 40
+#define wxSTC_LEX_ESCRIPT 41
+#define wxSTC_LEX_PS 42
+#define wxSTC_LEX_NSIS 43
+#define wxSTC_LEX_MMIXAL 44
+#define wxSTC_LEX_CLW 45
+#define wxSTC_LEX_CLWNOCASE 46
+#define wxSTC_LEX_LOT 47
+#define wxSTC_LEX_YAML 48
+#define wxSTC_LEX_TEX 49
+#define wxSTC_LEX_METAPOST 50
+#define wxSTC_LEX_POWERBASIC 51
+#define wxSTC_LEX_FORTH 52
+#define wxSTC_LEX_ERLANG 53
+#define wxSTC_LEX_OCTAVE 54
+#define wxSTC_LEX_MSSQL 55
+#define wxSTC_LEX_VERILOG 56
+#define wxSTC_LEX_KIX 57
+#define wxSTC_LEX_GUI4CLI 58
+#define wxSTC_LEX_SPECMAN 59
+#define wxSTC_LEX_AU3 60
+#define wxSTC_LEX_APDL 61
+#define wxSTC_LEX_BASH 62
+#define wxSTC_LEX_ASN1 63
+#define wxSTC_LEX_VHDL 64
+#define wxSTC_LEX_CAML 65
+#define wxSTC_LEX_BLITZBASIC 66
+#define wxSTC_LEX_PUREBASIC 67
+#define wxSTC_LEX_HASKELL 68
+#define wxSTC_LEX_PHPSCRIPT 69
+#define wxSTC_LEX_TADS3 70
+#define wxSTC_LEX_REBOL 71
+#define wxSTC_LEX_SMALLTALK 72
+#define wxSTC_LEX_FLAGSHIP 73
+#define wxSTC_LEX_CSOUND 74
+#define wxSTC_LEX_FREEBASIC 75
+
+// These are deprecated, STC_LEX_HTML should be used instead.
+#define wxSTC_LEX_ASP 29
+#define wxSTC_LEX_PHP 30
+
+// When a lexer specifies its language as SCLEX_AUTOMATIC it receives a
+// value assigned in sequence from SCLEX_AUTOMATIC+1.
+#define wxSTC_LEX_AUTOMATIC 1000
+
+// Lexical states for SCLEX_PYTHON
+#define wxSTC_P_DEFAULT 0
+#define wxSTC_P_COMMENTLINE 1
+#define wxSTC_P_NUMBER 2
+#define wxSTC_P_STRING 3
+#define wxSTC_P_CHARACTER 4
+#define wxSTC_P_WORD 5
+#define wxSTC_P_TRIPLE 6
+#define wxSTC_P_TRIPLEDOUBLE 7
+#define wxSTC_P_CLASSNAME 8
+#define wxSTC_P_DEFNAME 9
+#define wxSTC_P_OPERATOR 10
+#define wxSTC_P_IDENTIFIER 11
+#define wxSTC_P_COMMENTBLOCK 12
+#define wxSTC_P_STRINGEOL 13
+#define wxSTC_P_WORD2 14
+#define wxSTC_P_DECORATOR 15
+
+// Lexical states for SCLEX_CPP
+#define wxSTC_C_DEFAULT 0
+#define wxSTC_C_COMMENT 1
+#define wxSTC_C_COMMENTLINE 2
+#define wxSTC_C_COMMENTDOC 3
+#define wxSTC_C_NUMBER 4
+#define wxSTC_C_WORD 5
+#define wxSTC_C_STRING 6
+#define wxSTC_C_CHARACTER 7
+#define wxSTC_C_UUID 8
+#define wxSTC_C_PREPROCESSOR 9
+#define wxSTC_C_OPERATOR 10
+#define wxSTC_C_IDENTIFIER 11
+#define wxSTC_C_STRINGEOL 12
+#define wxSTC_C_VERBATIM 13
+#define wxSTC_C_REGEX 14
+#define wxSTC_C_COMMENTLINEDOC 15
+#define wxSTC_C_WORD2 16
+#define wxSTC_C_COMMENTDOCKEYWORD 17
+#define wxSTC_C_COMMENTDOCKEYWORDERROR 18
+#define wxSTC_C_GLOBALCLASS 19
+
+// Lexical states for SCLEX_HTML, SCLEX_XML
+#define wxSTC_H_DEFAULT 0
+#define wxSTC_H_TAG 1
+#define wxSTC_H_TAGUNKNOWN 2
+#define wxSTC_H_ATTRIBUTE 3
+#define wxSTC_H_ATTRIBUTEUNKNOWN 4
+#define wxSTC_H_NUMBER 5
+#define wxSTC_H_DOUBLESTRING 6
+#define wxSTC_H_SINGLESTRING 7
+#define wxSTC_H_OTHER 8
+#define wxSTC_H_COMMENT 9
+#define wxSTC_H_ENTITY 10
+
+// XML and ASP
+#define wxSTC_H_TAGEND 11
+#define wxSTC_H_XMLSTART 12
+#define wxSTC_H_XMLEND 13
+#define wxSTC_H_SCRIPT 14
+#define wxSTC_H_ASP 15
+#define wxSTC_H_ASPAT 16
+#define wxSTC_H_CDATA 17
+#define wxSTC_H_QUESTION 18
+
+// More HTML
+#define wxSTC_H_VALUE 19
+
+// X-Code
+#define wxSTC_H_XCCOMMENT 20
+
+// SGML
+#define wxSTC_H_SGML_DEFAULT 21
+#define wxSTC_H_SGML_COMMAND 22
+#define wxSTC_H_SGML_1ST_PARAM 23
+#define wxSTC_H_SGML_DOUBLESTRING 24
+#define wxSTC_H_SGML_SIMPLESTRING 25
+#define wxSTC_H_SGML_ERROR 26
+#define wxSTC_H_SGML_SPECIAL 27
+#define wxSTC_H_SGML_ENTITY 28
+#define wxSTC_H_SGML_COMMENT 29
+#define wxSTC_H_SGML_1ST_PARAM_COMMENT 30
+#define wxSTC_H_SGML_BLOCK_DEFAULT 31
+
+// Embedded Javascript
+#define wxSTC_HJ_START 40
+#define wxSTC_HJ_DEFAULT 41
+#define wxSTC_HJ_COMMENT 42
+#define wxSTC_HJ_COMMENTLINE 43
+#define wxSTC_HJ_COMMENTDOC 44
+#define wxSTC_HJ_NUMBER 45
+#define wxSTC_HJ_WORD 46
+#define wxSTC_HJ_KEYWORD 47
+#define wxSTC_HJ_DOUBLESTRING 48
+#define wxSTC_HJ_SINGLESTRING 49
+#define wxSTC_HJ_SYMBOLS 50
+#define wxSTC_HJ_STRINGEOL 51
+#define wxSTC_HJ_REGEX 52
+
+// ASP Javascript
+#define wxSTC_HJA_START 55
+#define wxSTC_HJA_DEFAULT 56
+#define wxSTC_HJA_COMMENT 57
+#define wxSTC_HJA_COMMENTLINE 58
+#define wxSTC_HJA_COMMENTDOC 59
+#define wxSTC_HJA_NUMBER 60
+#define wxSTC_HJA_WORD 61
+#define wxSTC_HJA_KEYWORD 62
+#define wxSTC_HJA_DOUBLESTRING 63
+#define wxSTC_HJA_SINGLESTRING 64
+#define wxSTC_HJA_SYMBOLS 65
+#define wxSTC_HJA_STRINGEOL 66
+#define wxSTC_HJA_REGEX 67
+
+// Embedded VBScript
+#define wxSTC_HB_START 70
+#define wxSTC_HB_DEFAULT 71
+#define wxSTC_HB_COMMENTLINE 72
+#define wxSTC_HB_NUMBER 73
+#define wxSTC_HB_WORD 74
+#define wxSTC_HB_STRING 75
+#define wxSTC_HB_IDENTIFIER 76
+#define wxSTC_HB_STRINGEOL 77
+
+// ASP VBScript
+#define wxSTC_HBA_START 80
+#define wxSTC_HBA_DEFAULT 81
+#define wxSTC_HBA_COMMENTLINE 82
+#define wxSTC_HBA_NUMBER 83
+#define wxSTC_HBA_WORD 84
+#define wxSTC_HBA_STRING 85
+#define wxSTC_HBA_IDENTIFIER 86
+#define wxSTC_HBA_STRINGEOL 87
+
+// Embedded Python
+#define wxSTC_HP_START 90
+#define wxSTC_HP_DEFAULT 91
+#define wxSTC_HP_COMMENTLINE 92
+#define wxSTC_HP_NUMBER 93
+#define wxSTC_HP_STRING 94
+#define wxSTC_HP_CHARACTER 95
+#define wxSTC_HP_WORD 96
+#define wxSTC_HP_TRIPLE 97
+#define wxSTC_HP_TRIPLEDOUBLE 98
+#define wxSTC_HP_CLASSNAME 99
+#define wxSTC_HP_DEFNAME 100
+#define wxSTC_HP_OPERATOR 101
+#define wxSTC_HP_IDENTIFIER 102
+
+// PHP
+#define wxSTC_HPHP_COMPLEX_VARIABLE 104
+
+// ASP Python
+#define wxSTC_HPA_START 105
+#define wxSTC_HPA_DEFAULT 106
+#define wxSTC_HPA_COMMENTLINE 107
+#define wxSTC_HPA_NUMBER 108
+#define wxSTC_HPA_STRING 109
+#define wxSTC_HPA_CHARACTER 110
+#define wxSTC_HPA_WORD 111
+#define wxSTC_HPA_TRIPLE 112
+#define wxSTC_HPA_TRIPLEDOUBLE 113
+#define wxSTC_HPA_CLASSNAME 114
+#define wxSTC_HPA_DEFNAME 115
+#define wxSTC_HPA_OPERATOR 116
+#define wxSTC_HPA_IDENTIFIER 117
+
+// PHP
+#define wxSTC_HPHP_DEFAULT 118
+#define wxSTC_HPHP_HSTRING 119
+#define wxSTC_HPHP_SIMPLESTRING 120
+#define wxSTC_HPHP_WORD 121
+#define wxSTC_HPHP_NUMBER 122
+#define wxSTC_HPHP_VARIABLE 123
+#define wxSTC_HPHP_COMMENT 124
+#define wxSTC_HPHP_COMMENTLINE 125
+#define wxSTC_HPHP_HSTRING_VARIABLE 126
+#define wxSTC_HPHP_OPERATOR 127
+
+// Lexical states for SCLEX_PERL
+#define wxSTC_PL_DEFAULT 0
+#define wxSTC_PL_ERROR 1
+#define wxSTC_PL_COMMENTLINE 2
+#define wxSTC_PL_POD 3
+#define wxSTC_PL_NUMBER 4
+#define wxSTC_PL_WORD 5
+#define wxSTC_PL_STRING 6
+#define wxSTC_PL_CHARACTER 7
+#define wxSTC_PL_PUNCTUATION 8
+#define wxSTC_PL_PREPROCESSOR 9
+#define wxSTC_PL_OPERATOR 10
+#define wxSTC_PL_IDENTIFIER 11
+#define wxSTC_PL_SCALAR 12
+#define wxSTC_PL_ARRAY 13
+#define wxSTC_PL_HASH 14
+#define wxSTC_PL_SYMBOLTABLE 15
+#define wxSTC_PL_VARIABLE_INDEXER 16
+#define wxSTC_PL_REGEX 17
+#define wxSTC_PL_REGSUBST 18
+#define wxSTC_PL_LONGQUOTE 19
+#define wxSTC_PL_BACKTICKS 20
+#define wxSTC_PL_DATASECTION 21
+#define wxSTC_PL_HERE_DELIM 22
+#define wxSTC_PL_HERE_Q 23
+#define wxSTC_PL_HERE_QQ 24
+#define wxSTC_PL_HERE_QX 25
+#define wxSTC_PL_STRING_Q 26
+#define wxSTC_PL_STRING_QQ 27
+#define wxSTC_PL_STRING_QX 28
+#define wxSTC_PL_STRING_QR 29
+#define wxSTC_PL_STRING_QW 30
+#define wxSTC_PL_POD_VERB 31
+
+// Lexical states for SCLEX_RUBY
+#define wxSTC_RB_DEFAULT 0
+#define wxSTC_RB_ERROR 1
+#define wxSTC_RB_COMMENTLINE 2
+#define wxSTC_RB_POD 3
+#define wxSTC_RB_NUMBER 4
+#define wxSTC_RB_WORD 5
+#define wxSTC_RB_STRING 6
+#define wxSTC_RB_CHARACTER 7
+#define wxSTC_RB_CLASSNAME 8
+#define wxSTC_RB_DEFNAME 9
+#define wxSTC_RB_OPERATOR 10
+#define wxSTC_RB_IDENTIFIER 11
+#define wxSTC_RB_REGEX 12
+#define wxSTC_RB_GLOBAL 13
+#define wxSTC_RB_SYMBOL 14
+#define wxSTC_RB_MODULE_NAME 15
+#define wxSTC_RB_INSTANCE_VAR 16
+#define wxSTC_RB_CLASS_VAR 17
+#define wxSTC_RB_BACKTICKS 18
+#define wxSTC_RB_DATASECTION 19
+#define wxSTC_RB_HERE_DELIM 20
+#define wxSTC_RB_HERE_Q 21
+#define wxSTC_RB_HERE_QQ 22
+#define wxSTC_RB_HERE_QX 23
+#define wxSTC_RB_STRING_Q 24
+#define wxSTC_RB_STRING_QQ 25
+#define wxSTC_RB_STRING_QX 26
+#define wxSTC_RB_STRING_QR 27
+#define wxSTC_RB_STRING_QW 28
+#define wxSTC_RB_WORD_DEMOTED 29
+#define wxSTC_RB_STDIN 30
+#define wxSTC_RB_STDOUT 31
+#define wxSTC_RB_STDERR 40
+#define wxSTC_RB_UPPER_BOUND 41
+
+// Lexical states for SCLEX_VB, SCLEX_VBSCRIPT, SCLEX_POWERBASIC
+#define wxSTC_B_DEFAULT 0
+#define wxSTC_B_COMMENT 1
+#define wxSTC_B_NUMBER 2
+#define wxSTC_B_KEYWORD 3
+#define wxSTC_B_STRING 4
+#define wxSTC_B_PREPROCESSOR 5
+#define wxSTC_B_OPERATOR 6
+#define wxSTC_B_IDENTIFIER 7
+#define wxSTC_B_DATE 8
+#define wxSTC_B_STRINGEOL 9
+#define wxSTC_B_KEYWORD2 10
+#define wxSTC_B_KEYWORD3 11
+#define wxSTC_B_KEYWORD4 12
+#define wxSTC_B_CONSTANT 13
+#define wxSTC_B_ASM 14
+#define wxSTC_B_LABEL 15
+#define wxSTC_B_ERROR 16
+#define wxSTC_B_HEXNUMBER 17
+#define wxSTC_B_BINNUMBER 18
+
+// Lexical states for SCLEX_PROPERTIES
+#define wxSTC_PROPS_DEFAULT 0
+#define wxSTC_PROPS_COMMENT 1
+#define wxSTC_PROPS_SECTION 2
+#define wxSTC_PROPS_ASSIGNMENT 3
+#define wxSTC_PROPS_DEFVAL 4
+
+// Lexical states for SCLEX_LATEX
+#define wxSTC_L_DEFAULT 0
+#define wxSTC_L_COMMAND 1
+#define wxSTC_L_TAG 2
+#define wxSTC_L_MATH 3
+#define wxSTC_L_COMMENT 4
+
+// Lexical states for SCLEX_LUA
+#define wxSTC_LUA_DEFAULT 0
+#define wxSTC_LUA_COMMENT 1
+#define wxSTC_LUA_COMMENTLINE 2
+#define wxSTC_LUA_COMMENTDOC 3
+#define wxSTC_LUA_NUMBER 4
+#define wxSTC_LUA_WORD 5
+#define wxSTC_LUA_STRING 6
+#define wxSTC_LUA_CHARACTER 7
+#define wxSTC_LUA_LITERALSTRING 8
+#define wxSTC_LUA_PREPROCESSOR 9
+#define wxSTC_LUA_OPERATOR 10
+#define wxSTC_LUA_IDENTIFIER 11
+#define wxSTC_LUA_STRINGEOL 12
+#define wxSTC_LUA_WORD2 13
+#define wxSTC_LUA_WORD3 14
+#define wxSTC_LUA_WORD4 15
+#define wxSTC_LUA_WORD5 16
+#define wxSTC_LUA_WORD6 17
+#define wxSTC_LUA_WORD7 18
+#define wxSTC_LUA_WORD8 19
+
+// Lexical states for SCLEX_ERRORLIST
+#define wxSTC_ERR_DEFAULT 0
+#define wxSTC_ERR_PYTHON 1
+#define wxSTC_ERR_GCC 2
+#define wxSTC_ERR_MS 3
+#define wxSTC_ERR_CMD 4
+#define wxSTC_ERR_BORLAND 5
+#define wxSTC_ERR_PERL 6
+#define wxSTC_ERR_NET 7
+#define wxSTC_ERR_LUA 8
+#define wxSTC_ERR_CTAG 9
+#define wxSTC_ERR_DIFF_CHANGED 10
+#define wxSTC_ERR_DIFF_ADDITION 11
+#define wxSTC_ERR_DIFF_DELETION 12
+#define wxSTC_ERR_DIFF_MESSAGE 13
+#define wxSTC_ERR_PHP 14
+#define wxSTC_ERR_ELF 15
+#define wxSTC_ERR_IFC 16
+#define wxSTC_ERR_IFORT 17
+#define wxSTC_ERR_ABSF 18
+#define wxSTC_ERR_TIDY 19
+#define wxSTC_ERR_JAVA_STACK 20
+
+// Lexical states for SCLEX_BATCH
+#define wxSTC_BAT_DEFAULT 0
+#define wxSTC_BAT_COMMENT 1
+#define wxSTC_BAT_WORD 2
+#define wxSTC_BAT_LABEL 3
+#define wxSTC_BAT_HIDE 4
+#define wxSTC_BAT_COMMAND 5
+#define wxSTC_BAT_IDENTIFIER 6
+#define wxSTC_BAT_OPERATOR 7
+
+// Lexical states for SCLEX_MAKEFILE
+#define wxSTC_MAKE_DEFAULT 0
+#define wxSTC_MAKE_COMMENT 1
+#define wxSTC_MAKE_PREPROCESSOR 2
+#define wxSTC_MAKE_IDENTIFIER 3
+#define wxSTC_MAKE_OPERATOR 4
+#define wxSTC_MAKE_TARGET 5
+#define wxSTC_MAKE_IDEOL 9
+
+// Lexical states for SCLEX_DIFF
+#define wxSTC_DIFF_DEFAULT 0
+#define wxSTC_DIFF_COMMENT 1
+#define wxSTC_DIFF_COMMAND 2
+#define wxSTC_DIFF_HEADER 3
+#define wxSTC_DIFF_POSITION 4
+#define wxSTC_DIFF_DELETED 5
+#define wxSTC_DIFF_ADDED 6
+
+// Lexical states for SCLEX_CONF (Apache Configuration Files Lexer)
+#define wxSTC_CONF_DEFAULT 0
+#define wxSTC_CONF_COMMENT 1
+#define wxSTC_CONF_NUMBER 2
+#define wxSTC_CONF_IDENTIFIER 3
+#define wxSTC_CONF_EXTENSION 4
+#define wxSTC_CONF_PARAMETER 5
+#define wxSTC_CONF_STRING 6
+#define wxSTC_CONF_OPERATOR 7
+#define wxSTC_CONF_IP 8
+#define wxSTC_CONF_DIRECTIVE 9
+
+// Lexical states for SCLEX_AVE, Avenue
+#define wxSTC_AVE_DEFAULT 0
+#define wxSTC_AVE_COMMENT 1
+#define wxSTC_AVE_NUMBER 2
+#define wxSTC_AVE_WORD 3
+#define wxSTC_AVE_STRING 6
+#define wxSTC_AVE_ENUM 7
+#define wxSTC_AVE_STRINGEOL 8
+#define wxSTC_AVE_IDENTIFIER 9
+#define wxSTC_AVE_OPERATOR 10
+#define wxSTC_AVE_WORD1 11
+#define wxSTC_AVE_WORD2 12
+#define wxSTC_AVE_WORD3 13
+#define wxSTC_AVE_WORD4 14
+#define wxSTC_AVE_WORD5 15
+#define wxSTC_AVE_WORD6 16
+
+// Lexical states for SCLEX_ADA
+#define wxSTC_ADA_DEFAULT 0
+#define wxSTC_ADA_WORD 1
+#define wxSTC_ADA_IDENTIFIER 2
+#define wxSTC_ADA_NUMBER 3
+#define wxSTC_ADA_DELIMITER 4
+#define wxSTC_ADA_CHARACTER 5
+#define wxSTC_ADA_CHARACTEREOL 6
+#define wxSTC_ADA_STRING 7
+#define wxSTC_ADA_STRINGEOL 8
+#define wxSTC_ADA_LABEL 9
+#define wxSTC_ADA_COMMENTLINE 10
+#define wxSTC_ADA_ILLEGAL 11
+
+// Lexical states for SCLEX_BAAN
+#define wxSTC_BAAN_DEFAULT 0
+#define wxSTC_BAAN_COMMENT 1
+#define wxSTC_BAAN_COMMENTDOC 2
+#define wxSTC_BAAN_NUMBER 3
+#define wxSTC_BAAN_WORD 4
+#define wxSTC_BAAN_STRING 5
+#define wxSTC_BAAN_PREPROCESSOR 6
+#define wxSTC_BAAN_OPERATOR 7
+#define wxSTC_BAAN_IDENTIFIER 8
+#define wxSTC_BAAN_STRINGEOL 9
+#define wxSTC_BAAN_WORD2 10
+
+// Lexical states for SCLEX_LISP
+#define wxSTC_LISP_DEFAULT 0
+#define wxSTC_LISP_COMMENT 1
+#define wxSTC_LISP_NUMBER 2
+#define wxSTC_LISP_KEYWORD 3
+#define wxSTC_LISP_KEYWORD_KW 4
+#define wxSTC_LISP_SYMBOL 5
+#define wxSTC_LISP_STRING 6
+#define wxSTC_LISP_STRINGEOL 8
+#define wxSTC_LISP_IDENTIFIER 9
+#define wxSTC_LISP_OPERATOR 10
+#define wxSTC_LISP_SPECIAL 11
+#define wxSTC_LISP_MULTI_COMMENT 12
+
+// Lexical states for SCLEX_EIFFEL and SCLEX_EIFFELKW
+#define wxSTC_EIFFEL_DEFAULT 0
+#define wxSTC_EIFFEL_COMMENTLINE 1
+#define wxSTC_EIFFEL_NUMBER 2
+#define wxSTC_EIFFEL_WORD 3
+#define wxSTC_EIFFEL_STRING 4
+#define wxSTC_EIFFEL_CHARACTER 5
+#define wxSTC_EIFFEL_OPERATOR 6
+#define wxSTC_EIFFEL_IDENTIFIER 7
+#define wxSTC_EIFFEL_STRINGEOL 8
+
+// Lexical states for SCLEX_NNCRONTAB (nnCron crontab Lexer)
+#define wxSTC_NNCRONTAB_DEFAULT 0
+#define wxSTC_NNCRONTAB_COMMENT 1
+#define wxSTC_NNCRONTAB_TASK 2
+#define wxSTC_NNCRONTAB_SECTION 3
+#define wxSTC_NNCRONTAB_KEYWORD 4
+#define wxSTC_NNCRONTAB_MODIFIER 5
+#define wxSTC_NNCRONTAB_ASTERISK 6
+#define wxSTC_NNCRONTAB_NUMBER 7
+#define wxSTC_NNCRONTAB_STRING 8
+#define wxSTC_NNCRONTAB_ENVIRONMENT 9
+#define wxSTC_NNCRONTAB_IDENTIFIER 10
+
+// Lexical states for SCLEX_FORTH (Forth Lexer)
+#define wxSTC_FORTH_DEFAULT 0
+#define wxSTC_FORTH_COMMENT 1
+#define wxSTC_FORTH_COMMENT_ML 2
+#define wxSTC_FORTH_IDENTIFIER 3
+#define wxSTC_FORTH_CONTROL 4
+#define wxSTC_FORTH_KEYWORD 5
+#define wxSTC_FORTH_DEFWORD 6
+#define wxSTC_FORTH_PREWORD1 7
+#define wxSTC_FORTH_PREWORD2 8
+#define wxSTC_FORTH_NUMBER 9
+#define wxSTC_FORTH_STRING 10
+#define wxSTC_FORTH_LOCALE 11
+
+// Lexical states for SCLEX_MATLAB
+#define wxSTC_MATLAB_DEFAULT 0
+#define wxSTC_MATLAB_COMMENT 1
+#define wxSTC_MATLAB_COMMAND 2
+#define wxSTC_MATLAB_NUMBER 3
+#define wxSTC_MATLAB_KEYWORD 4
+
+// single quoted string
+#define wxSTC_MATLAB_STRING 5
+#define wxSTC_MATLAB_OPERATOR 6
+#define wxSTC_MATLAB_IDENTIFIER 7
+#define wxSTC_MATLAB_DOUBLEQUOTESTRING 8
+
+// Lexical states for SCLEX_SCRIPTOL
+#define wxSTC_SCRIPTOL_DEFAULT 0
+#define wxSTC_SCRIPTOL_WHITE 1
+#define wxSTC_SCRIPTOL_COMMENTLINE 2
+#define wxSTC_SCRIPTOL_PERSISTENT 3
+#define wxSTC_SCRIPTOL_CSTYLE 4
+#define wxSTC_SCRIPTOL_COMMENTBLOCK 5
+#define wxSTC_SCRIPTOL_NUMBER 6
+#define wxSTC_SCRIPTOL_STRING 7
+#define wxSTC_SCRIPTOL_CHARACTER 8
+#define wxSTC_SCRIPTOL_STRINGEOL 9
+#define wxSTC_SCRIPTOL_KEYWORD 10
+#define wxSTC_SCRIPTOL_OPERATOR 11
+#define wxSTC_SCRIPTOL_IDENTIFIER 12
+#define wxSTC_SCRIPTOL_TRIPLE 13
+#define wxSTC_SCRIPTOL_CLASSNAME 14
+#define wxSTC_SCRIPTOL_PREPROCESSOR 15
+
+// Lexical states for SCLEX_ASM
+#define wxSTC_ASM_DEFAULT 0
+#define wxSTC_ASM_COMMENT 1
+#define wxSTC_ASM_NUMBER 2
+#define wxSTC_ASM_STRING 3
+#define wxSTC_ASM_OPERATOR 4
+#define wxSTC_ASM_IDENTIFIER 5
+#define wxSTC_ASM_CPUINSTRUCTION 6
+#define wxSTC_ASM_MATHINSTRUCTION 7
+#define wxSTC_ASM_REGISTER 8
+#define wxSTC_ASM_DIRECTIVE 9
+#define wxSTC_ASM_DIRECTIVEOPERAND 10
+#define wxSTC_ASM_COMMENTBLOCK 11
+#define wxSTC_ASM_CHARACTER 12
+#define wxSTC_ASM_STRINGEOL 13
+#define wxSTC_ASM_EXTINSTRUCTION 14
+
+// Lexical states for SCLEX_FORTRAN
+#define wxSTC_F_DEFAULT 0
+#define wxSTC_F_COMMENT 1
+#define wxSTC_F_NUMBER 2
+#define wxSTC_F_STRING1 3
+#define wxSTC_F_STRING2 4
+#define wxSTC_F_STRINGEOL 5
+#define wxSTC_F_OPERATOR 6
+#define wxSTC_F_IDENTIFIER 7
+#define wxSTC_F_WORD 8
+#define wxSTC_F_WORD2 9
+#define wxSTC_F_WORD3 10
+#define wxSTC_F_PREPROCESSOR 11
+#define wxSTC_F_OPERATOR2 12
+#define wxSTC_F_LABEL 13
+#define wxSTC_F_CONTINUATION 14
+
+// Lexical states for SCLEX_CSS
+#define wxSTC_CSS_DEFAULT 0
+#define wxSTC_CSS_TAG 1
+#define wxSTC_CSS_CLASS 2
+#define wxSTC_CSS_PSEUDOCLASS 3
+#define wxSTC_CSS_UNKNOWN_PSEUDOCLASS 4
+#define wxSTC_CSS_OPERATOR 5
+#define wxSTC_CSS_IDENTIFIER 6
+#define wxSTC_CSS_UNKNOWN_IDENTIFIER 7
+#define wxSTC_CSS_VALUE 8
+#define wxSTC_CSS_COMMENT 9
+#define wxSTC_CSS_ID 10
+#define wxSTC_CSS_IMPORTANT 11
+#define wxSTC_CSS_DIRECTIVE 12
+#define wxSTC_CSS_DOUBLESTRING 13
+#define wxSTC_CSS_SINGLESTRING 14
+#define wxSTC_CSS_IDENTIFIER2 15
+#define wxSTC_CSS_ATTRIBUTE 16
+
+// Lexical states for SCLEX_POV
+#define wxSTC_POV_DEFAULT 0
+#define wxSTC_POV_COMMENT 1
+#define wxSTC_POV_COMMENTLINE 2
+#define wxSTC_POV_NUMBER 3
+#define wxSTC_POV_OPERATOR 4
+#define wxSTC_POV_IDENTIFIER 5
+#define wxSTC_POV_STRING 6
+#define wxSTC_POV_STRINGEOL 7
+#define wxSTC_POV_DIRECTIVE 8
+#define wxSTC_POV_BADDIRECTIVE 9
+#define wxSTC_POV_WORD2 10
+#define wxSTC_POV_WORD3 11
+#define wxSTC_POV_WORD4 12
+#define wxSTC_POV_WORD5 13
+#define wxSTC_POV_WORD6 14
+#define wxSTC_POV_WORD7 15
+#define wxSTC_POV_WORD8 16
+
+// Lexical states for SCLEX_LOUT
+#define wxSTC_LOUT_DEFAULT 0
+#define wxSTC_LOUT_COMMENT 1
+#define wxSTC_LOUT_NUMBER 2
+#define wxSTC_LOUT_WORD 3
+#define wxSTC_LOUT_WORD2 4
+#define wxSTC_LOUT_WORD3 5
+#define wxSTC_LOUT_WORD4 6
+#define wxSTC_LOUT_STRING 7
+#define wxSTC_LOUT_OPERATOR 8
+#define wxSTC_LOUT_IDENTIFIER 9
+#define wxSTC_LOUT_STRINGEOL 10
+
+// Lexical states for SCLEX_ESCRIPT
+#define wxSTC_ESCRIPT_DEFAULT 0
+#define wxSTC_ESCRIPT_COMMENT 1
+#define wxSTC_ESCRIPT_COMMENTLINE 2
+#define wxSTC_ESCRIPT_COMMENTDOC 3
+#define wxSTC_ESCRIPT_NUMBER 4
+#define wxSTC_ESCRIPT_WORD 5
+#define wxSTC_ESCRIPT_STRING 6
+#define wxSTC_ESCRIPT_OPERATOR 7
+#define wxSTC_ESCRIPT_IDENTIFIER 8
+#define wxSTC_ESCRIPT_BRACE 9
+#define wxSTC_ESCRIPT_WORD2 10
+#define wxSTC_ESCRIPT_WORD3 11
+
+// Lexical states for SCLEX_PS
+#define wxSTC_PS_DEFAULT 0
+#define wxSTC_PS_COMMENT 1
+#define wxSTC_PS_DSC_COMMENT 2
+#define wxSTC_PS_DSC_VALUE 3
+#define wxSTC_PS_NUMBER 4
+#define wxSTC_PS_NAME 5
+#define wxSTC_PS_KEYWORD 6
+#define wxSTC_PS_LITERAL 7
+#define wxSTC_PS_IMMEVAL 8
+#define wxSTC_PS_PAREN_ARRAY 9
+#define wxSTC_PS_PAREN_DICT 10
+#define wxSTC_PS_PAREN_PROC 11
+#define wxSTC_PS_TEXT 12
+#define wxSTC_PS_HEXSTRING 13
+#define wxSTC_PS_BASE85STRING 14
+#define wxSTC_PS_BADSTRINGCHAR 15
+
+// Lexical states for SCLEX_NSIS
+#define wxSTC_NSIS_DEFAULT 0
+#define wxSTC_NSIS_COMMENT 1
+#define wxSTC_NSIS_STRINGDQ 2
+#define wxSTC_NSIS_STRINGLQ 3
+#define wxSTC_NSIS_STRINGRQ 4
+#define wxSTC_NSIS_FUNCTION 5
+#define wxSTC_NSIS_VARIABLE 6
+#define wxSTC_NSIS_LABEL 7
+#define wxSTC_NSIS_USERDEFINED 8
+#define wxSTC_NSIS_SECTIONDEF 9
+#define wxSTC_NSIS_SUBSECTIONDEF 10
+#define wxSTC_NSIS_IFDEFINEDEF 11
+#define wxSTC_NSIS_MACRODEF 12
+#define wxSTC_NSIS_STRINGVAR 13
+#define wxSTC_NSIS_NUMBER 14
+#define wxSTC_NSIS_SECTIONGROUP 15
+#define wxSTC_NSIS_PAGEEX 16
+#define wxSTC_NSIS_FUNCTIONDEF 17
+#define wxSTC_NSIS_COMMENTBOX 18
+
+// Lexical states for SCLEX_MMIXAL
+#define wxSTC_MMIXAL_LEADWS 0
+#define wxSTC_MMIXAL_COMMENT 1
+#define wxSTC_MMIXAL_LABEL 2
+#define wxSTC_MMIXAL_OPCODE 3
+#define wxSTC_MMIXAL_OPCODE_PRE 4
+#define wxSTC_MMIXAL_OPCODE_VALID 5
+#define wxSTC_MMIXAL_OPCODE_UNKNOWN 6
+#define wxSTC_MMIXAL_OPCODE_POST 7
+#define wxSTC_MMIXAL_OPERANDS 8
+#define wxSTC_MMIXAL_NUMBER 9
+#define wxSTC_MMIXAL_REF 10
+#define wxSTC_MMIXAL_CHAR 11
+#define wxSTC_MMIXAL_STRING 12
+#define wxSTC_MMIXAL_REGISTER 13
+#define wxSTC_MMIXAL_HEX 14
+#define wxSTC_MMIXAL_OPERATOR 15
+#define wxSTC_MMIXAL_SYMBOL 16
+#define wxSTC_MMIXAL_INCLUDE 17
+
+// Lexical states for SCLEX_CLW
+#define wxSTC_CLW_DEFAULT 0
+#define wxSTC_CLW_LABEL 1
+#define wxSTC_CLW_COMMENT 2
+#define wxSTC_CLW_STRING 3
+#define wxSTC_CLW_USER_IDENTIFIER 4
+#define wxSTC_CLW_INTEGER_CONSTANT 5
+#define wxSTC_CLW_REAL_CONSTANT 6
+#define wxSTC_CLW_PICTURE_STRING 7
+#define wxSTC_CLW_KEYWORD 8
+#define wxSTC_CLW_COMPILER_DIRECTIVE 9
+#define wxSTC_CLW_RUNTIME_EXPRESSIONS 10
+#define wxSTC_CLW_BUILTIN_PROCEDURES_FUNCTION 11
+#define wxSTC_CLW_STRUCTURE_DATA_TYPE 12
+#define wxSTC_CLW_ATTRIBUTE 13
+#define wxSTC_CLW_STANDARD_EQUATE 14
+#define wxSTC_CLW_ERROR 15
+#define wxSTC_CLW_DEPRECATED 16
+
+// Lexical states for SCLEX_LOT
+#define wxSTC_LOT_DEFAULT 0
+#define wxSTC_LOT_HEADER 1
+#define wxSTC_LOT_BREAK 2
+#define wxSTC_LOT_SET 3
+#define wxSTC_LOT_PASS 4
+#define wxSTC_LOT_FAIL 5
+#define wxSTC_LOT_ABORT 6
+
+// Lexical states for SCLEX_YAML
+#define wxSTC_YAML_DEFAULT 0
+#define wxSTC_YAML_COMMENT 1
+#define wxSTC_YAML_IDENTIFIER 2
+#define wxSTC_YAML_KEYWORD 3
+#define wxSTC_YAML_NUMBER 4
+#define wxSTC_YAML_REFERENCE 5
+#define wxSTC_YAML_DOCUMENT 6
+#define wxSTC_YAML_TEXT 7
+#define wxSTC_YAML_ERROR 8
+
+// Lexical states for SCLEX_TEX
+#define wxSTC_TEX_DEFAULT 0
+#define wxSTC_TEX_SPECIAL 1
+#define wxSTC_TEX_GROUP 2
+#define wxSTC_TEX_SYMBOL 3
+#define wxSTC_TEX_COMMAND 4
+#define wxSTC_TEX_TEXT 5
+#define wxSTC_METAPOST_DEFAULT 0
+#define wxSTC_METAPOST_SPECIAL 1
+#define wxSTC_METAPOST_GROUP 2
+#define wxSTC_METAPOST_SYMBOL 3
+#define wxSTC_METAPOST_COMMAND 4
+#define wxSTC_METAPOST_TEXT 5
+#define wxSTC_METAPOST_EXTRA 6
+
+// Lexical states for SCLEX_ERLANG
+#define wxSTC_ERLANG_DEFAULT 0
+#define wxSTC_ERLANG_COMMENT 1
+#define wxSTC_ERLANG_VARIABLE 2
+#define wxSTC_ERLANG_NUMBER 3
+#define wxSTC_ERLANG_KEYWORD 4
+#define wxSTC_ERLANG_STRING 5
+#define wxSTC_ERLANG_OPERATOR 6
+#define wxSTC_ERLANG_ATOM 7
+#define wxSTC_ERLANG_FUNCTION_NAME 8
+#define wxSTC_ERLANG_CHARACTER 9
+#define wxSTC_ERLANG_MACRO 10
+#define wxSTC_ERLANG_RECORD 11
+#define wxSTC_ERLANG_SEPARATOR 12
+#define wxSTC_ERLANG_NODE_NAME 13
+#define wxSTC_ERLANG_UNKNOWN 31
+
+// Lexical states for SCLEX_OCTAVE are identical to MatLab
+// Lexical states for SCLEX_MSSQL
+#define wxSTC_MSSQL_DEFAULT 0
+#define wxSTC_MSSQL_COMMENT 1
+#define wxSTC_MSSQL_LINE_COMMENT 2
+#define wxSTC_MSSQL_NUMBER 3
+#define wxSTC_MSSQL_STRING 4
+#define wxSTC_MSSQL_OPERATOR 5
+#define wxSTC_MSSQL_IDENTIFIER 6
+#define wxSTC_MSSQL_VARIABLE 7
+#define wxSTC_MSSQL_COLUMN_NAME 8
+#define wxSTC_MSSQL_STATEMENT 9
+#define wxSTC_MSSQL_DATATYPE 10
+#define wxSTC_MSSQL_SYSTABLE 11
+#define wxSTC_MSSQL_GLOBAL_VARIABLE 12
+#define wxSTC_MSSQL_FUNCTION 13
+#define wxSTC_MSSQL_STORED_PROCEDURE 14
+#define wxSTC_MSSQL_DEFAULT_PREF_DATATYPE 15
+#define wxSTC_MSSQL_COLUMN_NAME_2 16
+
+// Lexical states for SCLEX_VERILOG
+#define wxSTC_V_DEFAULT 0
+#define wxSTC_V_COMMENT 1
+#define wxSTC_V_COMMENTLINE 2
+#define wxSTC_V_COMMENTLINEBANG 3
+#define wxSTC_V_NUMBER 4
+#define wxSTC_V_WORD 5
+#define wxSTC_V_STRING 6
+#define wxSTC_V_WORD2 7
+#define wxSTC_V_WORD3 8
+#define wxSTC_V_PREPROCESSOR 9
+#define wxSTC_V_OPERATOR 10
+#define wxSTC_V_IDENTIFIER 11
+#define wxSTC_V_STRINGEOL 12
+#define wxSTC_V_USER 19
+
+// Lexical states for SCLEX_KIX
+#define wxSTC_KIX_DEFAULT 0
+#define wxSTC_KIX_COMMENT 1
+#define wxSTC_KIX_STRING1 2
+#define wxSTC_KIX_STRING2 3
+#define wxSTC_KIX_NUMBER 4
+#define wxSTC_KIX_VAR 5
+#define wxSTC_KIX_MACRO 6
+#define wxSTC_KIX_KEYWORD 7
+#define wxSTC_KIX_FUNCTIONS 8
+#define wxSTC_KIX_OPERATOR 9
+#define wxSTC_KIX_IDENTIFIER 31
+
+// Lexical states for SCLEX_GUI4CLI
+#define wxSTC_GC_DEFAULT 0
+#define wxSTC_GC_COMMENTLINE 1
+#define wxSTC_GC_COMMENTBLOCK 2
+#define wxSTC_GC_GLOBAL 3
+#define wxSTC_GC_EVENT 4
+#define wxSTC_GC_ATTRIBUTE 5
+#define wxSTC_GC_CONTROL 6
+#define wxSTC_GC_COMMAND 7
+#define wxSTC_GC_STRING 8
+#define wxSTC_GC_OPERATOR 9
+
+// Lexical states for SCLEX_SPECMAN
+#define wxSTC_SN_DEFAULT 0
+#define wxSTC_SN_CODE 1
+#define wxSTC_SN_COMMENTLINE 2
+#define wxSTC_SN_COMMENTLINEBANG 3
+#define wxSTC_SN_NUMBER 4
+#define wxSTC_SN_WORD 5
+#define wxSTC_SN_STRING 6
+#define wxSTC_SN_WORD2 7
+#define wxSTC_SN_WORD3 8
+#define wxSTC_SN_PREPROCESSOR 9
+#define wxSTC_SN_OPERATOR 10
+#define wxSTC_SN_IDENTIFIER 11
+#define wxSTC_SN_STRINGEOL 12
+#define wxSTC_SN_REGEXTAG 13
+#define wxSTC_SN_SIGNAL 14
+#define wxSTC_SN_USER 19
+
+// Lexical states for SCLEX_AU3
+#define wxSTC_AU3_DEFAULT 0
+#define wxSTC_AU3_COMMENT 1
+#define wxSTC_AU3_COMMENTBLOCK 2
+#define wxSTC_AU3_NUMBER 3
+#define wxSTC_AU3_FUNCTION 4
+#define wxSTC_AU3_KEYWORD 5
+#define wxSTC_AU3_MACRO 6
+#define wxSTC_AU3_STRING 7
+#define wxSTC_AU3_OPERATOR 8
+#define wxSTC_AU3_VARIABLE 9
+#define wxSTC_AU3_SENT 10
+#define wxSTC_AU3_PREPROCESSOR 11
+#define wxSTC_AU3_SPECIAL 12
+#define wxSTC_AU3_EXPAND 13
+#define wxSTC_AU3_COMOBJ 14
+
+// Lexical states for SCLEX_APDL
+#define wxSTC_APDL_DEFAULT 0
+#define wxSTC_APDL_COMMENT 1
+#define wxSTC_APDL_COMMENTBLOCK 2
+#define wxSTC_APDL_NUMBER 3
+#define wxSTC_APDL_STRING 4
+#define wxSTC_APDL_OPERATOR 5
+#define wxSTC_APDL_WORD 6
+#define wxSTC_APDL_PROCESSOR 7
+#define wxSTC_APDL_COMMAND 8
+#define wxSTC_APDL_SLASHCOMMAND 9
+#define wxSTC_APDL_STARCOMMAND 10
+#define wxSTC_APDL_ARGUMENT 11
+#define wxSTC_APDL_FUNCTION 12
+
+// Lexical states for SCLEX_BASH
+#define wxSTC_SH_DEFAULT 0
+#define wxSTC_SH_ERROR 1
+#define wxSTC_SH_COMMENTLINE 2
+#define wxSTC_SH_NUMBER 3
+#define wxSTC_SH_WORD 4
+#define wxSTC_SH_STRING 5
+#define wxSTC_SH_CHARACTER 6
+#define wxSTC_SH_OPERATOR 7
+#define wxSTC_SH_IDENTIFIER 8
+#define wxSTC_SH_SCALAR 9
+#define wxSTC_SH_PARAM 10
+#define wxSTC_SH_BACKTICKS 11
+#define wxSTC_SH_HERE_DELIM 12
+#define wxSTC_SH_HERE_Q 13
+
+// Lexical states for SCLEX_ASN1
+#define wxSTC_ASN1_DEFAULT 0
+#define wxSTC_ASN1_COMMENT 1
+#define wxSTC_ASN1_IDENTIFIER 2
+#define wxSTC_ASN1_STRING 3
+#define wxSTC_ASN1_OID 4
+#define wxSTC_ASN1_SCALAR 5
+#define wxSTC_ASN1_KEYWORD 6
+#define wxSTC_ASN1_ATTRIBUTE 7
+#define wxSTC_ASN1_DESCRIPTOR 8
+#define wxSTC_ASN1_TYPE 9
+#define wxSTC_ASN1_OPERATOR 10
+
+// Lexical states for SCLEX_VHDL
+#define wxSTC_VHDL_DEFAULT 0
+#define wxSTC_VHDL_COMMENT 1
+#define wxSTC_VHDL_COMMENTLINEBANG 2
+#define wxSTC_VHDL_NUMBER 3
+#define wxSTC_VHDL_STRING 4
+#define wxSTC_VHDL_OPERATOR 5
+#define wxSTC_VHDL_IDENTIFIER 6
+#define wxSTC_VHDL_STRINGEOL 7
+#define wxSTC_VHDL_KEYWORD 8
+#define wxSTC_VHDL_STDOPERATOR 9
+#define wxSTC_VHDL_ATTRIBUTE 10
+#define wxSTC_VHDL_STDFUNCTION 11
+#define wxSTC_VHDL_STDPACKAGE 12
+#define wxSTC_VHDL_STDTYPE 13
+#define wxSTC_VHDL_USERWORD 14
+
+// Lexical states for SCLEX_CAML
+#define wxSTC_CAML_DEFAULT 0
+#define wxSTC_CAML_IDENTIFIER 1
+#define wxSTC_CAML_TAGNAME 2
+#define wxSTC_CAML_KEYWORD 3
+#define wxSTC_CAML_KEYWORD2 4
+#define wxSTC_CAML_KEYWORD3 5
+#define wxSTC_CAML_LINENUM 6
+#define wxSTC_CAML_OPERATOR 7
+#define wxSTC_CAML_NUMBER 8
+#define wxSTC_CAML_CHAR 9
+#define wxSTC_CAML_STRING 11
+#define wxSTC_CAML_COMMENT 12
+#define wxSTC_CAML_COMMENT1 13
+#define wxSTC_CAML_COMMENT2 14
+#define wxSTC_CAML_COMMENT3 15
+
+// Lexical states for SCLEX_HASKELL
+#define wxSTC_HA_DEFAULT 0
+#define wxSTC_HA_IDENTIFIER 1
+#define wxSTC_HA_KEYWORD 2
+#define wxSTC_HA_NUMBER 3
+#define wxSTC_HA_STRING 4
+#define wxSTC_HA_CHARACTER 5
+#define wxSTC_HA_CLASS 6
+#define wxSTC_HA_MODULE 7
+#define wxSTC_HA_CAPITAL 8
+#define wxSTC_HA_DATA 9
+#define wxSTC_HA_IMPORT 10
+#define wxSTC_HA_OPERATOR 11
+#define wxSTC_HA_INSTANCE 12
+#define wxSTC_HA_COMMENTLINE 13
+#define wxSTC_HA_COMMENTBLOCK 14
+#define wxSTC_HA_COMMENTBLOCK2 15
+#define wxSTC_HA_COMMENTBLOCK3 16
+
+// Lexical states of SCLEX_TADS3
+#define wxSTC_T3_DEFAULT 0
+#define wxSTC_T3_X_DEFAULT 1
+#define wxSTC_T3_PREPROCESSOR 2
+#define wxSTC_T3_BLOCK_COMMENT 3
+#define wxSTC_T3_LINE_COMMENT 4
+#define wxSTC_T3_OPERATOR 5
+#define wxSTC_T3_KEYWORD 6
+#define wxSTC_T3_NUMBER 7
+#define wxSTC_T3_IDENTIFIER 8
+#define wxSTC_T3_S_STRING 9
+#define wxSTC_T3_D_STRING 10
+#define wxSTC_T3_X_STRING 11
+#define wxSTC_T3_LIB_DIRECTIVE 12
+#define wxSTC_T3_MSG_PARAM 13
+#define wxSTC_T3_HTML_TAG 14
+#define wxSTC_T3_HTML_DEFAULT 15
+#define wxSTC_T3_HTML_STRING 16
+#define wxSTC_T3_USER1 17
+#define wxSTC_T3_USER2 18
+#define wxSTC_T3_USER3 19
+
+// Lexical states for SCLEX_REBOL
+#define wxSTC_REBOL_DEFAULT 0
+#define wxSTC_REBOL_COMMENTLINE 1
+#define wxSTC_REBOL_COMMENTBLOCK 2
+#define wxSTC_REBOL_PREFACE 3
+#define wxSTC_REBOL_OPERATOR 4
+#define wxSTC_REBOL_CHARACTER 5
+#define wxSTC_REBOL_QUOTEDSTRING 6
+#define wxSTC_REBOL_BRACEDSTRING 7
+#define wxSTC_REBOL_NUMBER 8
+#define wxSTC_REBOL_PAIR 9
+#define wxSTC_REBOL_TUPLE 10
+#define wxSTC_REBOL_BINARY 11
+#define wxSTC_REBOL_MONEY 12
+#define wxSTC_REBOL_ISSUE 13
+#define wxSTC_REBOL_TAG 14
+#define wxSTC_REBOL_FILE 15
+#define wxSTC_REBOL_EMAIL 16
+#define wxSTC_REBOL_URL 17
+#define wxSTC_REBOL_DATE 18
+#define wxSTC_REBOL_TIME 19
+#define wxSTC_REBOL_IDENTIFIER 20
+#define wxSTC_REBOL_WORD 21
+#define wxSTC_REBOL_WORD2 22
+#define wxSTC_REBOL_WORD3 23
+#define wxSTC_REBOL_WORD4 24
+#define wxSTC_REBOL_WORD5 25
+#define wxSTC_REBOL_WORD6 26
+#define wxSTC_REBOL_WORD7 27
+#define wxSTC_REBOL_WORD8 28
+
+// Lexical states for SCLEX_SQL
+#define wxSTC_SQL_DEFAULT 0
+#define wxSTC_SQL_COMMENT 1
+#define wxSTC_SQL_COMMENTLINE 2
+#define wxSTC_SQL_COMMENTDOC 3
+#define wxSTC_SQL_NUMBER 4
+#define wxSTC_SQL_WORD 5
+#define wxSTC_SQL_STRING 6
+#define wxSTC_SQL_CHARACTER 7
+#define wxSTC_SQL_SQLPLUS 8
+#define wxSTC_SQL_SQLPLUS_PROMPT 9
+#define wxSTC_SQL_OPERATOR 10
+#define wxSTC_SQL_IDENTIFIER 11
+#define wxSTC_SQL_SQLPLUS_COMMENT 13
+#define wxSTC_SQL_COMMENTLINEDOC 15
+#define wxSTC_SQL_WORD2 16
+#define wxSTC_SQL_COMMENTDOCKEYWORD 17
+#define wxSTC_SQL_COMMENTDOCKEYWORDERROR 18
+#define wxSTC_SQL_USER1 19
+#define wxSTC_SQL_USER2 20
+#define wxSTC_SQL_USER3 21
+#define wxSTC_SQL_USER4 22
+#define wxSTC_SQL_QUOTEDIDENTIFIER 23
+
+// Lexical states for SCLEX_SMALLTALK
+#define wxSTC_ST_DEFAULT 0
+#define wxSTC_ST_STRING 1
+#define wxSTC_ST_NUMBER 2
+#define wxSTC_ST_COMMENT 3
+#define wxSTC_ST_SYMBOL 4
+#define wxSTC_ST_BINARY 5
+#define wxSTC_ST_BOOL 6
+#define wxSTC_ST_SELF 7
+#define wxSTC_ST_SUPER 8
+#define wxSTC_ST_NIL 9
+#define wxSTC_ST_GLOBAL 10
+#define wxSTC_ST_RETURN 11
+#define wxSTC_ST_SPECIAL 12
+#define wxSTC_ST_KWSEND 13
+#define wxSTC_ST_ASSIGN 14
+#define wxSTC_ST_CHARACTER 15
+#define wxSTC_ST_SPEC_SEL 16
+
+// Lexical states for SCLEX_FLAGSHIP (clipper)
+#define wxSTC_FS_DEFAULT 0
+#define wxSTC_FS_COMMENT 1
+#define wxSTC_FS_COMMENTLINE 2
+#define wxSTC_FS_COMMENTDOC 3
+#define wxSTC_FS_COMMENTLINEDOC 4
+#define wxSTC_FS_COMMENTDOCKEYWORD 5
+#define wxSTC_FS_COMMENTDOCKEYWORDERROR 6
+#define wxSTC_FS_KEYWORD 7
+#define wxSTC_FS_KEYWORD2 8
+#define wxSTC_FS_KEYWORD3 9
+#define wxSTC_FS_KEYWORD4 10
+#define wxSTC_FS_NUMBER 11
+#define wxSTC_FS_STRING 12
+#define wxSTC_FS_PREPROCESSOR 13
+#define wxSTC_FS_OPERATOR 14
+#define wxSTC_FS_IDENTIFIER 15
+#define wxSTC_FS_DATE 16
+#define wxSTC_FS_STRINGEOL 17
+#define wxSTC_FS_CONSTANT 18
+#define wxSTC_FS_ASM 19
+#define wxSTC_FS_LABEL 20
+#define wxSTC_FS_ERROR 21
+#define wxSTC_FS_HEXNUMBER 22
+#define wxSTC_FS_BINNUMBER 23
+
+// Lexical states for SCLEX_CSOUND
+#define wxSTC_CSOUND_DEFAULT 0
+#define wxSTC_CSOUND_COMMENT 1
+#define wxSTC_CSOUND_NUMBER 2
+#define wxSTC_CSOUND_OPERATOR 3
+#define wxSTC_CSOUND_INSTR 4
+#define wxSTC_CSOUND_IDENTIFIER 5
+#define wxSTC_CSOUND_OPCODE 6
+#define wxSTC_CSOUND_HEADERSTMT 7
+#define wxSTC_CSOUND_USERKEYWORD 8
+#define wxSTC_CSOUND_COMMENTBLOCK 9
+#define wxSTC_CSOUND_PARAM 10
+#define wxSTC_CSOUND_ARATE_VAR 11
+#define wxSTC_CSOUND_KRATE_VAR 12
+#define wxSTC_CSOUND_IRATE_VAR 13
+#define wxSTC_CSOUND_GLOBAL_VAR 14
+#define wxSTC_CSOUND_STRINGEOL 15
+
+
+//-----------------------------------------
+// Commands that can be bound to keystrokes
+
+
+// Redoes the next action on the undo history.
+#define wxSTC_CMD_REDO 2011
+
+// Select all the text in the document.
+#define wxSTC_CMD_SELECTALL 2013
+
+// Undo one action in the undo history.
+#define wxSTC_CMD_UNDO 2176
+
+// Cut the selection to the clipboard.
+#define wxSTC_CMD_CUT 2177
+
+// Copy the selection to the clipboard.
+#define wxSTC_CMD_COPY 2178
+
+// Paste the contents of the clipboard into the document replacing the selection.
+#define wxSTC_CMD_PASTE 2179
+
+// Clear the selection.
+#define wxSTC_CMD_CLEAR 2180
+
+// Move caret down one line.
+#define wxSTC_CMD_LINEDOWN 2300
+
+// Move caret down one line extending selection to new caret position.
+#define wxSTC_CMD_LINEDOWNEXTEND 2301
+
+// Move caret up one line.
+#define wxSTC_CMD_LINEUP 2302
+
+// Move caret up one line extending selection to new caret position.
+#define wxSTC_CMD_LINEUPEXTEND 2303
+
+// Move caret left one character.
+#define wxSTC_CMD_CHARLEFT 2304
+
+// Move caret left one character extending selection to new caret position.
+#define wxSTC_CMD_CHARLEFTEXTEND 2305
+
+// Move caret right one character.
+#define wxSTC_CMD_CHARRIGHT 2306
+
+// Move caret right one character extending selection to new caret position.
+#define wxSTC_CMD_CHARRIGHTEXTEND 2307
+
+// Move caret left one word.
+#define wxSTC_CMD_WORDLEFT 2308
+
+// Move caret left one word extending selection to new caret position.
+#define wxSTC_CMD_WORDLEFTEXTEND 2309
+
+// Move caret right one word.
+#define wxSTC_CMD_WORDRIGHT 2310
+
+// Move caret right one word extending selection to new caret position.
+#define wxSTC_CMD_WORDRIGHTEXTEND 2311
+
+// Move caret to first position on line.
+#define wxSTC_CMD_HOME 2312
+
+// Move caret to first position on line extending selection to new caret position.
+#define wxSTC_CMD_HOMEEXTEND 2313
+
+// Move caret to last position on line.
+#define wxSTC_CMD_LINEEND 2314
+
+// Move caret to last position on line extending selection to new caret position.
+#define wxSTC_CMD_LINEENDEXTEND 2315
+
+// Move caret to first position in document.
+#define wxSTC_CMD_DOCUMENTSTART 2316
+
+// Move caret to first position in document extending selection to new caret position.
+#define wxSTC_CMD_DOCUMENTSTARTEXTEND 2317
+
+// Move caret to last position in document.
+#define wxSTC_CMD_DOCUMENTEND 2318
+
+// Move caret to last position in document extending selection to new caret position.
+#define wxSTC_CMD_DOCUMENTENDEXTEND 2319
+
+// Move caret one page up.
+#define wxSTC_CMD_PAGEUP 2320
+
+// Move caret one page up extending selection to new caret position.
+#define wxSTC_CMD_PAGEUPEXTEND 2321
+
+// Move caret one page down.
+#define wxSTC_CMD_PAGEDOWN 2322
+
+// Move caret one page down extending selection to new caret position.
+#define wxSTC_CMD_PAGEDOWNEXTEND 2323
+
+// Switch from insert to overtype mode or the reverse.
+#define wxSTC_CMD_EDITTOGGLEOVERTYPE 2324
+
+// Cancel any modes such as call tip or auto-completion list display.
+#define wxSTC_CMD_CANCEL 2325
+
+// Delete the selection or if no selection, the character before the caret.
+#define wxSTC_CMD_DELETEBACK 2326
+
+// If selection is empty or all on one line replace the selection with a tab character.
+// If more than one line selected, indent the lines.
+#define wxSTC_CMD_TAB 2327
+
+// Dedent the selected lines.
+#define wxSTC_CMD_BACKTAB 2328
+
+// Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
+#define wxSTC_CMD_NEWLINE 2329
+
+// Insert a Form Feed character.
+#define wxSTC_CMD_FORMFEED 2330
+
+// Move caret to before first visible character on line.
+// If already there move to first character on line.
+#define wxSTC_CMD_VCHOME 2331
+
+// Like VCHome but extending selection to new caret position.
+#define wxSTC_CMD_VCHOMEEXTEND 2332
+
+// Magnify the displayed text by increasing the sizes by 1 point.
+#define wxSTC_CMD_ZOOMIN 2333
+
+// Make the displayed text smaller by decreasing the sizes by 1 point.
+#define wxSTC_CMD_ZOOMOUT 2334
+
+// Delete the word to the left of the caret.
+#define wxSTC_CMD_DELWORDLEFT 2335
+
+// Delete the word to the right of the caret.
+#define wxSTC_CMD_DELWORDRIGHT 2336
+
+// Cut the line containing the caret.
+#define wxSTC_CMD_LINECUT 2337
+
+// Delete the line containing the caret.
+#define wxSTC_CMD_LINEDELETE 2338
+
+// Switch the current line with the previous.
+#define wxSTC_CMD_LINETRANSPOSE 2339
+
+// Duplicate the current line.
+#define wxSTC_CMD_LINEDUPLICATE 2404
+
+// Transform the selection to lower case.
+#define wxSTC_CMD_LOWERCASE 2340
+
+// Transform the selection to upper case.
+#define wxSTC_CMD_UPPERCASE 2341
+
+// Scroll the document down, keeping the caret visible.
+#define wxSTC_CMD_LINESCROLLDOWN 2342
+
+// Scroll the document up, keeping the caret visible.
+#define wxSTC_CMD_LINESCROLLUP 2343
+
+// Delete the selection or if no selection, the character before the caret.
+// Will not delete the character before at the start of a line.
+#define wxSTC_CMD_DELETEBACKNOTLINE 2344
+
+// Move caret to first position on display line.
+#define wxSTC_CMD_HOMEDISPLAY 2345
+
+// Move caret to first position on display line extending selection to
+// new caret position.
+#define wxSTC_CMD_HOMEDISPLAYEXTEND 2346
+
+// Move caret to last position on display line.
+#define wxSTC_CMD_LINEENDDISPLAY 2347
+
+// Move caret to last position on display line extending selection to new
+// caret position.
+#define wxSTC_CMD_LINEENDDISPLAYEXTEND 2348
+
+// These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)?
+// except they behave differently when word-wrap is enabled:
+// They go first to the start / end of the display line, like (Home|LineEnd)Display
+// The difference is that, the cursor is already at the point, it goes on to the start
+// or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?.
+#define wxSTC_CMD_HOMEWRAP 2349
+#define wxSTC_CMD_HOMEWRAPEXTEND 2450
+#define wxSTC_CMD_LINEENDWRAP 2451
+#define wxSTC_CMD_LINEENDWRAPEXTEND 2452
+#define wxSTC_CMD_VCHOMEWRAP 2453
+#define wxSTC_CMD_VCHOMEWRAPEXTEND 2454
+
+// Copy the line containing the caret.
+#define wxSTC_CMD_LINECOPY 2455
+
+// Move to the previous change in capitalisation.
+#define wxSTC_CMD_WORDPARTLEFT 2390
+
+// Move to the previous change in capitalisation extending selection
+// to new caret position.
+#define wxSTC_CMD_WORDPARTLEFTEXTEND 2391
+
+// Move to the change next in capitalisation.
+#define wxSTC_CMD_WORDPARTRIGHT 2392
+
+// Move to the next change in capitalisation extending selection
+// to new caret position.
+#define wxSTC_CMD_WORDPARTRIGHTEXTEND 2393
+
+// Delete back from the current position to the start of the line.
+#define wxSTC_CMD_DELLINELEFT 2395
+
+// Delete forwards from the current position to the end of the line.
+#define wxSTC_CMD_DELLINERIGHT 2396
+
+// Move caret between paragraphs (delimited by empty lines).
+#define wxSTC_CMD_PARADOWN 2413
+#define wxSTC_CMD_PARADOWNEXTEND 2414
+#define wxSTC_CMD_PARAUP 2415
+#define wxSTC_CMD_PARAUPEXTEND 2416
+
+// Move caret down one line, extending rectangular selection to new caret position.
+#define wxSTC_CMD_LINEDOWNRECTEXTEND 2426
+
+// Move caret up one line, extending rectangular selection to new caret position.
+#define wxSTC_CMD_LINEUPRECTEXTEND 2427
+
+// Move caret left one character, extending rectangular selection to new caret position.
+#define wxSTC_CMD_CHARLEFTRECTEXTEND 2428
+
+// Move caret right one character, extending rectangular selection to new caret position.
+#define wxSTC_CMD_CHARRIGHTRECTEXTEND 2429
+
+// Move caret to first position on line, extending rectangular selection to new caret position.
+#define wxSTC_CMD_HOMERECTEXTEND 2430
+
+// Move caret to before first visible character on line.
+// If already there move to first character on line.
+// In either case, extend rectangular selection to new caret position.
+#define wxSTC_CMD_VCHOMERECTEXTEND 2431
+
+// Move caret to last position on line, extending rectangular selection to new caret position.
+#define wxSTC_CMD_LINEENDRECTEXTEND 2432
+
+// Move caret one page up, extending rectangular selection to new caret position.
+#define wxSTC_CMD_PAGEUPRECTEXTEND 2433
+
+// Move caret one page down, extending rectangular selection to new caret position.
+#define wxSTC_CMD_PAGEDOWNRECTEXTEND 2434
+
+// Move caret to top of page, or one page up if already at top of page.
+#define wxSTC_CMD_STUTTEREDPAGEUP 2435
+
+// Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
+#define wxSTC_CMD_STUTTEREDPAGEUPEXTEND 2436
+
+// Move caret to bottom of page, or one page down if already at bottom of page.
+#define wxSTC_CMD_STUTTEREDPAGEDOWN 2437
+
+// Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
+#define wxSTC_CMD_STUTTEREDPAGEDOWNEXTEND 2438
+
+// Move caret left one word, position cursor at end of word.
+#define wxSTC_CMD_WORDLEFTEND 2439
+
+// Move caret left one word, position cursor at end of word, extending selection to new caret position.
+#define wxSTC_CMD_WORDLEFTENDEXTEND 2440
+
+// Move caret right one word, position cursor at end of word.
+#define wxSTC_CMD_WORDRIGHTEND 2441
+
+// Move caret right one word, position cursor at end of word, extending selection to new caret position.
+#define wxSTC_CMD_WORDRIGHTENDEXTEND 2442
+
+
+// END of generated section
+//----------------------------------------------------------------------
+
+class ScintillaWX; // forward declare
+class WordList;
+struct SCNotification;
+
+#ifndef SWIG
+extern WXDLLIMPEXP_STC const wxChar* wxSTCNameStr;
+class WXDLLIMPEXP_STC wxStyledTextCtrl;
+class WXDLLIMPEXP_STC wxStyledTextEvent;
+#endif
+
+//----------------------------------------------------------------------
+
+class WXDLLIMPEXP_STC wxStyledTextCtrl : public wxControl {
+public:
+
+#ifdef SWIG
+ %pythonAppend wxStyledTextCtrl "self._setOORInfo(self)"
+ %pythonAppend wxStyledTextCtrl() ""
+
+ wxStyledTextCtrl(wxWindow *parent, wxWindowID id=wxID_ANY,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxString& name = wxPySTCNameStr);
+ %RenameCtor(PreStyledTextCtrl, wxStyledTextCtrl());
+
+#else
+ wxStyledTextCtrl(wxWindow *parent, wxWindowID id=wxID_ANY,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxString& name = wxSTCNameStr);
+ wxStyledTextCtrl() { m_swx = NULL; }
+ ~wxStyledTextCtrl();
+
+#endif
+
+ bool Create(wxWindow *parent, wxWindowID id=wxID_ANY,
+ const wxPoint& pos = wxDefaultPosition,
+ const wxSize& size = wxDefaultSize, long style = 0,
+ const wxString& name = wxSTCNameStr);
+
+
+//----------------------------------------------------------------------
+// BEGIN generated section. The following code is automatically generated
+// by gen_iface.py. Do not edit this file. Edit stc.h.in instead
+// and regenerate
+
+
+ // Add text to the document at current position.
+ void AddText(const wxString& text);
+
+ // Add array of cells to document.
+ void AddStyledText(const wxMemoryBuffer& data);
+
+ // Insert string at a position.
+ void InsertText(int pos, const wxString& text);
+
+ // Delete all text in the document.
+ void ClearAll();
+
+ // Set all style bytes to 0, remove all folding information.
+ void ClearDocumentStyle();
+
+ // Returns the number of characters in the document.
+ int GetLength();
+
+ // Returns the character byte at the position.
+ int GetCharAt(int pos);
+
+ // Returns the position of the caret.
+ int GetCurrentPos();
+
+ // Returns the position of the opposite end of the selection to the caret.
+ int GetAnchor();
+
+ // Returns the style byte at the position.
+ int GetStyleAt(int pos);
+
+ // Redoes the next action on the undo history.
+ void Redo();
+
+ // Choose between collecting actions into the undo
+ // history and discarding them.
+ void SetUndoCollection(bool collectUndo);
+
+ // Select all the text in the document.
+ void SelectAll();
+
+ // Remember the current position in the undo history as the position
+ // at which the document was saved.
+ void SetSavePoint();
+
+ // Retrieve a buffer of cells.
+ wxMemoryBuffer GetStyledText(int startPos, int endPos);
+
+ // Are there any redoable actions in the undo history?
+ bool CanRedo();
+
+ // Retrieve the line number at which a particular marker is located.
+ int MarkerLineFromHandle(int handle);
+
+ // Delete a marker.
+ void MarkerDeleteHandle(int handle);
+
+ // Is undo history being collected?
+ bool GetUndoCollection();
+
+ // Are white space characters currently visible?
+ // Returns one of SCWS_* constants.
+ int GetViewWhiteSpace();
+
+ // Make white space characters invisible, always visible or visible outside indentation.
+ void SetViewWhiteSpace(int viewWS);
+
+ // Find the position from a point within the window.
+ int PositionFromPoint(wxPoint pt);
+
+ // Find the position from a point within the window but return
+ // INVALID_POSITION if not close to text.
+ int PositionFromPointClose(int x, int y);
+
+ // Set caret to start of a line and ensure it is visible.
+ void GotoLine(int line);
+
+ // Set caret to a position and ensure it is visible.
+ void GotoPos(int pos);
+
+ // Set the selection anchor to a position. The anchor is the opposite
+ // end of the selection from the caret.
+ void SetAnchor(int posAnchor);
+
+ // Retrieve the text of the line containing the caret.
+ // Returns the index of the caret on the line.
+ #ifdef SWIG
+ wxString GetCurLine(int* OUTPUT);
+#else
+ wxString GetCurLine(int* linePos=NULL);
+#endif
+
+ // Retrieve the position of the last correctly styled character.
+ int GetEndStyled();
+
+ // Convert all line endings in the document to one mode.
+ void ConvertEOLs(int eolMode);
+
+ // Retrieve the current end of line mode - one of CRLF, CR, or LF.
+ int GetEOLMode();
+
+ // Set the current end of line mode.
+ void SetEOLMode(int eolMode);
+
+ // Set the current styling position to pos and the styling mask to mask.
+ // The styling mask can be used to protect some bits in each styling byte from modification.
+ void StartStyling(int pos, int mask);
+
+ // Change style from current styling position for length characters to a style
+ // and move the current styling position to after this newly styled segment.
+ void SetStyling(int length, int style);
+
+ // Is drawing done first into a buffer or direct to the screen?
+ bool GetBufferedDraw();
+
+ // If drawing is buffered then each line of text is drawn into a bitmap buffer
+ // before drawing it to the screen to avoid flicker.
+ void SetBufferedDraw(bool buffered);
+
+ // Change the visible size of a tab to be a multiple of the width of a space character.
+ void SetTabWidth(int tabWidth);
+
+ // Retrieve the visible size of a tab.
+ int GetTabWidth();
+
+ // Set the code page used to interpret the bytes of the document as characters.
+ void SetCodePage(int codePage);
+
+ // Set the symbol used for a particular marker number,
+ // and optionally the fore and background colours.
+ void MarkerDefine(int markerNumber, int markerSymbol,
+ const wxColour& foreground = wxNullColour,
+ const wxColour& background = wxNullColour);
+
+ // Set the foreground colour used for a particular marker number.
+ void MarkerSetForeground(int markerNumber, const wxColour& fore);
+
+ // Set the background colour used for a particular marker number.
+ void MarkerSetBackground(int markerNumber, const wxColour& back);
+
+ // Add a marker to a line, returning an ID which can be used to find or delete the marker.
+ int MarkerAdd(int line, int markerNumber);
+
+ // Delete a marker from a line.
+ void MarkerDelete(int line, int markerNumber);
+
+ // Delete all markers with a particular number from all lines.
+ void MarkerDeleteAll(int markerNumber);
+
+ // Get a bit mask of all the markers set on a line.
+ int MarkerGet(int line);
+
+ // Find the next line after lineStart that includes a marker in mask.
+ int MarkerNext(int lineStart, int markerMask);
+
+ // Find the previous line before lineStart that includes a marker in mask.
+ int MarkerPrevious(int lineStart, int markerMask);
+
+ // Define a marker from a bitmap
+ void MarkerDefineBitmap(int markerNumber, const wxBitmap& bmp);
+
+ // Add a set of markers to a line.
+ void MarkerAddSet(int line, int set);
+
+ // Set a margin to be either numeric or symbolic.
+ void SetMarginType(int margin, int marginType);
+
+ // Retrieve the type of a margin.
+ int GetMarginType(int margin);
+
+ // Set the width of a margin to a width expressed in pixels.
+ void SetMarginWidth(int margin, int pixelWidth);
+
+ // Retrieve the width of a margin in pixels.
+ int GetMarginWidth(int margin);
+
+ // Set a mask that determines which markers are displayed in a margin.
+ void SetMarginMask(int margin, int mask);
+
+ // Retrieve the marker mask of a margin.
+ int GetMarginMask(int margin);
+
+ // Make a margin sensitive or insensitive to mouse clicks.
+ void SetMarginSensitive(int margin, bool sensitive);
+
+ // Retrieve the mouse click sensitivity of a margin.
+ bool GetMarginSensitive(int margin);
+
+ // Clear all the styles and make equivalent to the global default style.
+ void StyleClearAll();
+
+ // Set the foreground colour of a style.
+ void StyleSetForeground(int style, const wxColour& fore);
+
+ // Set the background colour of a style.
+ void StyleSetBackground(int style, const wxColour& back);
+
+ // Set a style to be bold or not.
+ void StyleSetBold(int style, bool bold);
+
+ // Set a style to be italic or not.
+ void StyleSetItalic(int style, bool italic);
+
+ // Set the size of characters of a style.
+ void StyleSetSize(int style, int sizePoints);
+
+ // Set the font of a style.
+ void StyleSetFaceName(int style, const wxString& fontName);
+
+ // Set a style to have its end of line filled or not.
+ void StyleSetEOLFilled(int style, bool filled);
+
+ // Reset the default style to its state at startup
+ void StyleResetDefault();
+
+ // Set a style to be underlined or not.
+ void StyleSetUnderline(int style, bool underline);
+
+ // Set a style to be mixed case, or to force upper or lower case.
+ void StyleSetCase(int style, int caseForce);
+
+ // Set a style to be a hotspot or not.
+ void StyleSetHotSpot(int style, bool hotspot);
+
+ // Set the foreground colour of the selection and whether to use this setting.
+ void SetSelForeground(bool useSetting, const wxColour& fore);
+
+ // Set the background colour of the selection and whether to use this setting.
+ void SetSelBackground(bool useSetting, const wxColour& back);
+
+ // Set the foreground colour of the caret.
+ void SetCaretForeground(const wxColour& fore);
+
+ // When key+modifier combination km is pressed perform msg.
+ void CmdKeyAssign(int key, int modifiers, int cmd);
+
+ // When key+modifier combination km is pressed do nothing.
+ void CmdKeyClear(int key, int modifiers);
+
+ // Drop all key mappings.
+ void CmdKeyClearAll();
+
+ // Set the styles for a segment of the document.
+ void SetStyleBytes(int length, char* styleBytes);
+
+ // Set a style to be visible or not.
+ void StyleSetVisible(int style, bool visible);
+
+ // Get the time in milliseconds that the caret is on and off.
+ int GetCaretPeriod();
+
+ // Get the time in milliseconds that the caret is on and off. 0 = steady on.
+ void SetCaretPeriod(int periodMilliseconds);
+
+ // Set the set of characters making up words for when moving or selecting by word.
+ // First sets deaults like SetCharsDefault.
+ void SetWordChars(const wxString& characters);
+
+ // Start a sequence of actions that is undone and redone as a unit.
+ // May be nested.
+ void BeginUndoAction();
+
+ // End a sequence of actions that is undone and redone as a unit.
+ void EndUndoAction();
+
+ // Set an indicator to plain, squiggle or TT.
+ void IndicatorSetStyle(int indic, int style);
+
+ // Retrieve the style of an indicator.
+ int IndicatorGetStyle(int indic);
+
+ // Set the foreground colour of an indicator.
+ void IndicatorSetForeground(int indic, const wxColour& fore);
+
+ // Retrieve the foreground colour of an indicator.
+ wxColour IndicatorGetForeground(int indic);
+
+ // Set the foreground colour of all whitespace and whether to use this setting.
+ void SetWhitespaceForeground(bool useSetting, const wxColour& fore);
+
+ // Set the background colour of all whitespace and whether to use this setting.
+ void SetWhitespaceBackground(bool useSetting, const wxColour& back);
+
+ // Divide each styling byte into lexical class bits (default: 5) and indicator
+ // bits (default: 3). If a lexer requires more than 32 lexical states, then this
+ // is used to expand the possible states.
+ void SetStyleBits(int bits);
+
+ // Retrieve number of bits in style bytes used to hold the lexical state.
+ int GetStyleBits();
+
+ // Used to hold extra styling information for each line.
+ void SetLineState(int line, int state);
+
+ // Retrieve the extra styling information for a line.
+ int GetLineState(int line);
+
+ // Retrieve the last line number that has line state.
+ int GetMaxLineState();
+
+ // Is the background of the line containing the caret in a different colour?
+ bool GetCaretLineVisible();
+
+ // Display the background of the line containing the caret in a different colour.
+ void SetCaretLineVisible(bool show);
+
+ // Get the colour of the background of the line containing the caret.
+ wxColour GetCaretLineBack();
+
+ // Set the colour of the background of the line containing the caret.
+ void SetCaretLineBack(const wxColour& back);
+
+ // Set a style to be changeable or not (read only).
+ // Experimental feature, currently buggy.
+ void StyleSetChangeable(int style, bool changeable);
+
+ // Display a auto-completion list.
+ // The lenEntered parameter indicates how many characters before
+ // the caret should be used to provide context.
+ void AutoCompShow(int lenEntered, const wxString& itemList);
+
+ // Remove the auto-completion list from the screen.
+ void AutoCompCancel();
+
+ // Is there an auto-completion list visible?
+ bool AutoCompActive();
+
+ // Retrieve the position of the caret when the auto-completion list was displayed.
+ int AutoCompPosStart();
+
+ // User has selected an item so remove the list and insert the selection.
+ void AutoCompComplete();
+
+ // Define a set of character that when typed cancel the auto-completion list.
+ void AutoCompStops(const wxString& characterSet);
+
+ // Change the separator character in the string setting up an auto-completion list.
+ // Default is space but can be changed if items contain space.
+ void AutoCompSetSeparator(int separatorCharacter);
+
+ // Retrieve the auto-completion list separator character.
+ int AutoCompGetSeparator();
+
+ // Select the item in the auto-completion list that starts with a string.
+ void AutoCompSelect(const wxString& text);
+
+ // Should the auto-completion list be cancelled if the user backspaces to a
+ // position before where the box was created.
+ void AutoCompSetCancelAtStart(bool cancel);
+
+ // Retrieve whether auto-completion cancelled by backspacing before start.
+ bool AutoCompGetCancelAtStart();
+
+ // Define a set of characters that when typed will cause the autocompletion to
+ // choose the selected item.
+ void AutoCompSetFillUps(const wxString& characterSet);
+
+ // Should a single item auto-completion list automatically choose the item.
+ void AutoCompSetChooseSingle(bool chooseSingle);
+
+ // Retrieve whether a single item auto-completion list automatically choose the item.
+ bool AutoCompGetChooseSingle();
+
+ // Set whether case is significant when performing auto-completion searches.
+ void AutoCompSetIgnoreCase(bool ignoreCase);
+
+ // Retrieve state of ignore case flag.
+ bool AutoCompGetIgnoreCase();
+
+ // Display a list of strings and send notification when user chooses one.
+ void UserListShow(int listType, const wxString& itemList);
+
+ // Set whether or not autocompletion is hidden automatically when nothing matches.
+ void AutoCompSetAutoHide(bool autoHide);
+
+ // Retrieve whether or not autocompletion is hidden automatically when nothing matches.
+ bool AutoCompGetAutoHide();
+
+ // Set whether or not autocompletion deletes any word characters
+ // after the inserted text upon completion.
+ void AutoCompSetDropRestOfWord(bool dropRestOfWord);
+
+ // Retrieve whether or not autocompletion deletes any word characters
+ // after the inserted text upon completion.
+ bool AutoCompGetDropRestOfWord();
+
+ // Register an image for use in autocompletion lists.
+ void RegisterImage(int type, const wxBitmap& bmp);
+
+ // Clear all the registered images.
+ void ClearRegisteredImages();
+
+ // Retrieve the auto-completion list type-separator character.
+ int AutoCompGetTypeSeparator();
+
+ // Change the type-separator character in the string setting up an auto-completion list.
+ // Default is '?' but can be changed if items contain '?'.
+ void AutoCompSetTypeSeparator(int separatorCharacter);
+
+ // Set the maximum width, in characters, of auto-completion and user lists.
+ // Set to 0 to autosize to fit longest item, which is the default.
+ void AutoCompSetMaxWidth(int characterCount);
+
+ // Get the maximum width, in characters, of auto-completion and user lists.
+ int AutoCompGetMaxWidth();
+
+ // Set the maximum height, in rows, of auto-completion and user lists.
+ // The default is 5 rows.
+ void AutoCompSetMaxHeight(int rowCount);
+
+ // Set the maximum height, in rows, of auto-completion and user lists.
+ int AutoCompGetMaxHeight();
+
+ // Set the number of spaces used for one level of indentation.
+ void SetIndent(int indentSize);
+
+ // Retrieve indentation size.
+ int GetIndent();
+
+ // Indentation will only use space characters if useTabs is false, otherwise
+ // it will use a combination of tabs and spaces.
+ void SetUseTabs(bool useTabs);
+
+ // Retrieve whether tabs will be used in indentation.
+ bool GetUseTabs();
+
+ // Change the indentation of a line to a number of columns.
+ void SetLineIndentation(int line, int indentSize);
+
+ // Retrieve the number of columns that a line is indented.
+ int GetLineIndentation(int line);
+
+ // Retrieve the position before the first non indentation character on a line.
+ int GetLineIndentPosition(int line);
+
+ // Retrieve the column number of a position, taking tab width into account.
+ int GetColumn(int pos);
+
+ // Show or hide the horizontal scroll bar.
+ void SetUseHorizontalScrollBar(bool show);
+
+ // Is the horizontal scroll bar visible?
+ bool GetUseHorizontalScrollBar();
+
+ // Show or hide indentation guides.
+ void SetIndentationGuides(bool show);
+
+ // Are the indentation guides visible?
+ bool GetIndentationGuides();
+
+ // Set the highlighted indentation guide column.
+ // 0 = no highlighted guide.
+ void SetHighlightGuide(int column);
+
+ // Get the highlighted indentation guide column.
+ int GetHighlightGuide();
+
+ // Get the position after the last visible characters on a line.
+ int GetLineEndPosition(int line);
+
+ // Get the code page used to interpret the bytes of the document as characters.
+ int GetCodePage();
+
+ // Get the foreground colour of the caret.
+ wxColour GetCaretForeground();
+
+ // In read-only mode?
+ bool GetReadOnly();
+
+ // Sets the position of the caret.
+ void SetCurrentPos(int pos);
+
+ // Sets the position that starts the selection - this becomes the anchor.
+ void SetSelectionStart(int pos);
+
+ // Returns the position at the start of the selection.
+ int GetSelectionStart();
+
+ // Sets the position that ends the selection - this becomes the currentPosition.
+ void SetSelectionEnd(int pos);
+
+ // Returns the position at the end of the selection.
+ int GetSelectionEnd();
+
+ // Sets the print magnification added to the point size of each style for printing.
+ void SetPrintMagnification(int magnification);
+
+ // Returns the print magnification.
+ int GetPrintMagnification();
+
+ // Modify colours when printing for clearer printed text.
+ void SetPrintColourMode(int mode);
+
+ // Returns the print colour mode.
+ int GetPrintColourMode();
+
+ // Find some text in the document.
+ int FindText(int minPos, int maxPos, const wxString& text, int flags=0);
+
+ // On Windows, will draw the document into a display context such as a printer.
+ int FormatRange(bool doDraw,
+ int startPos,
+ int endPos,
+ wxDC* draw,
+ wxDC* target,
+ wxRect renderRect,
+ wxRect pageRect);
+
+ // Retrieve the display line at the top of the display.
+ int GetFirstVisibleLine();
+
+ // Retrieve the contents of a line.
+ wxString GetLine(int line);
+
+ // Returns the number of lines in the document. There is always at least one.
+ int GetLineCount();
+
+ // Sets the size in pixels of the left margin.
+ void SetMarginLeft(int pixelWidth);
+
+ // Returns the size in pixels of the left margin.
+ int GetMarginLeft();
+
+ // Sets the size in pixels of the right margin.
+ void SetMarginRight(int pixelWidth);
+
+ // Returns the size in pixels of the right margin.
+ int GetMarginRight();
+
+ // Is the document different from when it was last saved?
+ bool GetModify();
+
+ // Select a range of text.
+ void SetSelection(int start, int end);
+
+ // Retrieve the selected text.
+ wxString GetSelectedText();
+
+ // Retrieve a range of text.
+ wxString GetTextRange(int startPos, int endPos);
+
+ // Draw the selection in normal style or with selection highlighted.
+ void HideSelection(bool normal);
+
+ // Retrieve the line containing a position.
+ int LineFromPosition(int pos);
+
+ // Retrieve the position at the start of a line.
+ int PositionFromLine(int line);
+
+ // Scroll horizontally and vertically.
+ void LineScroll(int columns, int lines);
+
+ // Ensure the caret is visible.
+ void EnsureCaretVisible();
+
+ // Replace the selected text with the argument text.
+ void ReplaceSelection(const wxString& text);
+
+ // Set to read only or read write.
+ void SetReadOnly(bool readOnly);
+
+ // Will a paste succeed?
+ bool CanPaste();
+
+ // Are there any undoable actions in the undo history?
+ bool CanUndo();
+
+ // Delete the undo history.
+ void EmptyUndoBuffer();
+
+ // Undo one action in the undo history.
+ void Undo();
+
+ // Cut the selection to the clipboard.
+ void Cut();
+
+ // Copy the selection to the clipboard.
+ void Copy();
+
+ // Paste the contents of the clipboard into the document replacing the selection.
+ void Paste();
+
+ // Clear the selection.
+ void Clear();
+
+ // Replace the contents of the document with the argument text.
+ void SetText(const wxString& text);
+
+ // Retrieve all the text in the document.
+ wxString GetText();
+
+ // Retrieve the number of characters in the document.
+ int GetTextLength();
+
+ // Set to overtype (true) or insert mode.
+ void SetOvertype(bool overtype);
+
+ // Returns true if overtype mode is active otherwise false is returned.
+ bool GetOvertype();
+
+ // Set the width of the insert mode caret.
+ void SetCaretWidth(int pixelWidth);
+
+ // Returns the width of the insert mode caret.
+ int GetCaretWidth();
+
+ // Sets the position that starts the target which is used for updating the
+ // document without affecting the scroll position.
+ void SetTargetStart(int pos);
+
+ // Get the position that starts the target.
+ int GetTargetStart();
+
+ // Sets the position that ends the target which is used for updating the
+ // document without affecting the scroll position.
+ void SetTargetEnd(int pos);
+
+ // Get the position that ends the target.
+ int GetTargetEnd();
+
+ // Replace the target text with the argument text.
+ // Text is counted so it can contain NULs.
+ // Returns the length of the replacement text.
+ int ReplaceTarget(const wxString& text);
+
+ // Replace the target text with the argument text after \d processing.
+ // Text is counted so it can contain NULs.
+ // Looks for \d where d is between 1 and 9 and replaces these with the strings
+ // matched in the last search operation which were surrounded by \( and \).
+ // Returns the length of the replacement text including any change
+ // caused by processing the \d patterns.
+ int ReplaceTargetRE(const wxString& text);
+
+ // Search for a counted string in the target and set the target to the found
+ // range. Text is counted so it can contain NULs.
+ // Returns length of range or -1 for failure in which case target is not moved.
+ int SearchInTarget(const wxString& text);
+
+ // Set the search flags used by SearchInTarget.
+ void SetSearchFlags(int flags);
+
+ // Get the search flags used by SearchInTarget.
+ int GetSearchFlags();
+
+ // Show a call tip containing a definition near position pos.
+ void CallTipShow(int pos, const wxString& definition);
+
+ // Remove the call tip from the screen.
+ void CallTipCancel();
+
+ // Is there an active call tip?
+ bool CallTipActive();
+
+ // Retrieve the position where the caret was before displaying the call tip.
+ int CallTipPosAtStart();
+
+ // Highlight a segment of the definition.
+ void CallTipSetHighlight(int start, int end);
+
+ // Set the background colour for the call tip.
+ void CallTipSetBackground(const wxColour& back);
+
+ // Set the foreground colour for the call tip.
+ void CallTipSetForeground(const wxColour& fore);
+
+ // Set the foreground colour for the highlighted part of the call tip.
+ void CallTipSetForegroundHighlight(const wxColour& fore);
+
+ // Find the display line of a document line taking hidden lines into account.
+ int VisibleFromDocLine(int line);
+
+ // Find the document line of a display line taking hidden lines into account.
+ int DocLineFromVisible(int lineDisplay);
+
+ // The number of display lines needed to wrap a document line
+ int WrapCount(int line);
+
+ // Set the fold level of a line.
+ // This encodes an integer level along with flags indicating whether the
+ // line is a header and whether it is effectively white space.
+ void SetFoldLevel(int line, int level);
+
+ // Retrieve the fold level of a line.
+ int GetFoldLevel(int line);
+
+ // Find the last child line of a header line.
+ int GetLastChild(int line, int level);
+
+ // Find the parent line of a child line.
+ int GetFoldParent(int line);
+
+ // Make a range of lines visible.
+ void ShowLines(int lineStart, int lineEnd);
+
+ // Make a range of lines invisible.
+ void HideLines(int lineStart, int lineEnd);
+
+ // Is a line visible?
+ bool GetLineVisible(int line);
+
+ // Show the children of a header line.
+ void SetFoldExpanded(int line, bool expanded);
+
+ // Is a header line expanded?
+ bool GetFoldExpanded(int line);
+
+ // Switch a header line between expanded and contracted.
+ void ToggleFold(int line);
+
+ // Ensure a particular line is visible by expanding any header line hiding it.
+ void EnsureVisible(int line);
+
+ // Set some style options for folding.
+ void SetFoldFlags(int flags);
+
+ // Ensure a particular line is visible by expanding any header line hiding it.
+ // Use the currently set visibility policy to determine which range to display.
+ void EnsureVisibleEnforcePolicy(int line);
+
+ // Sets whether a tab pressed when caret is within indentation indents.
+ void SetTabIndents(bool tabIndents);
+
+ // Does a tab pressed when caret is within indentation indent?
+ bool GetTabIndents();
+
+ // Sets whether a backspace pressed when caret is within indentation unindents.
+ void SetBackSpaceUnIndents(bool bsUnIndents);
+
+ // Does a backspace pressed when caret is within indentation unindent?
+ bool GetBackSpaceUnIndents();
+
+ // Sets the time the mouse must sit still to generate a mouse dwell event.
+ void SetMouseDwellTime(int periodMilliseconds);
+
+ // Retrieve the time the mouse must sit still to generate a mouse dwell event.
+ int GetMouseDwellTime();
+
+ // Get position of start of word.
+ int WordStartPosition(int pos, bool onlyWordCharacters);
+
+ // Get position of end of word.
+ int WordEndPosition(int pos, bool onlyWordCharacters);
+
+ // Sets whether text is word wrapped.
+ void SetWrapMode(int mode);
+
+ // Retrieve whether text is word wrapped.
+ int GetWrapMode();
+
+ // Set the display mode of visual flags for wrapped lines.
+ void SetWrapVisualFlags(int wrapVisualFlags);
+
+ // Retrive the display mode of visual flags for wrapped lines.
+ int GetWrapVisualFlags();
+
+ // Set the location of visual flags for wrapped lines.
+ void SetWrapVisualFlagsLocation(int wrapVisualFlagsLocation);
+
+ // Retrive the location of visual flags for wrapped lines.
+ int GetWrapVisualFlagsLocation();
+
+ // Set the start indent for wrapped lines.
+ void SetWrapStartIndent(int indent);
+
+ // Retrive the start indent for wrapped lines.
+ int GetWrapStartIndent();
+
+ // Sets the degree of caching of layout information.
+ void SetLayoutCache(int mode);
+
+ // Retrieve the degree of caching of layout information.
+ int GetLayoutCache();
+
+ // Sets the document width assumed for scrolling.
+ void SetScrollWidth(int pixelWidth);
+
+ // Retrieve the document width assumed for scrolling.
+ int GetScrollWidth();
+
+ // Measure the pixel width of some text in a particular style.
+ // NUL terminated text argument.
+ // Does not handle tab or control characters.
+ int TextWidth(int style, const wxString& text);
+
+ // Sets the scroll range so that maximum scroll position has
+ // the last line at the bottom of the view (default).
+ // Setting this to false allows scrolling one page below the last line.
+ void SetEndAtLastLine(bool endAtLastLine);
+
+ // Retrieve whether the maximum scroll position has the last
+ // line at the bottom of the view.
+ bool GetEndAtLastLine();
+
+ // Retrieve the height of a particular line of text in pixels.
+ int TextHeight(int line);
+
+ // Show or hide the vertical scroll bar.
+ void SetUseVerticalScrollBar(bool show);
+
+ // Is the vertical scroll bar visible?
+ bool GetUseVerticalScrollBar();
+
+ // Append a string to the end of the document without changing the selection.
+ void AppendText(const wxString& text);
+
+ // Is drawing done in two phases with backgrounds drawn before foregrounds?
+ bool GetTwoPhaseDraw();
+
+ // In twoPhaseDraw mode, drawing is performed in two phases, first the background
+ // and then the foreground. This avoids chopping off characters that overlap the next run.
+ void SetTwoPhaseDraw(bool twoPhase);
+
+ // Make the target range start and end be the same as the selection range start and end.
+ void TargetFromSelection();
+
+ // Join the lines in the target.
+ void LinesJoin();
+
+ // Split the lines in the target into lines that are less wide than pixelWidth
+ // where possible.
+ void LinesSplit(int pixelWidth);
+
+ // Set the colours used as a chequerboard pattern in the fold margin
+ void SetFoldMarginColour(bool useSetting, const wxColour& back);
+ void SetFoldMarginHiColour(bool useSetting, const wxColour& fore);
+
+ // Move caret down one line.
+ void LineDown();
+
+ // Move caret down one line extending selection to new caret position.
+ void LineDownExtend();
+
+ // Move caret up one line.
+ void LineUp();
+
+ // Move caret up one line extending selection to new caret position.
+ void LineUpExtend();
+
+ // Move caret left one character.
+ void CharLeft();
+
+ // Move caret left one character extending selection to new caret position.
+ void CharLeftExtend();
+
+ // Move caret right one character.
+ void CharRight();
+
+ // Move caret right one character extending selection to new caret position.
+ void CharRightExtend();
+
+ // Move caret left one word.
+ void WordLeft();
+
+ // Move caret left one word extending selection to new caret position.
+ void WordLeftExtend();
+
+ // Move caret right one word.
+ void WordRight();
+
+ // Move caret right one word extending selection to new caret position.
+ void WordRightExtend();
+
+ // Move caret to first position on line.
+ void Home();
+
+ // Move caret to first position on line extending selection to new caret position.
+ void HomeExtend();
+
+ // Move caret to last position on line.
+ void LineEnd();
+
+ // Move caret to last position on line extending selection to new caret position.
+ void LineEndExtend();
+
+ // Move caret to first position in document.
+ void DocumentStart();
+
+ // Move caret to first position in document extending selection to new caret position.
+ void DocumentStartExtend();
+
+ // Move caret to last position in document.
+ void DocumentEnd();
+
+ // Move caret to last position in document extending selection to new caret position.
+ void DocumentEndExtend();
+
+ // Move caret one page up.
+ void PageUp();
+
+ // Move caret one page up extending selection to new caret position.
+ void PageUpExtend();
+
+ // Move caret one page down.
+ void PageDown();
+
+ // Move caret one page down extending selection to new caret position.
+ void PageDownExtend();
+
+ // Switch from insert to overtype mode or the reverse.
+ void EditToggleOvertype();
+
+ // Cancel any modes such as call tip or auto-completion list display.
+ void Cancel();
+
+ // Delete the selection or if no selection, the character before the caret.
+ void DeleteBack();
+
+ // If selection is empty or all on one line replace the selection with a tab character.
+ // If more than one line selected, indent the lines.
+ void Tab();
+
+ // Dedent the selected lines.
+ void BackTab();
+
+ // Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
+ void NewLine();
+
+ // Insert a Form Feed character.
+ void FormFeed();
+
+ // Move caret to before first visible character on line.
+ // If already there move to first character on line.
+ void VCHome();
+
+ // Like VCHome but extending selection to new caret position.
+ void VCHomeExtend();
+
+ // Magnify the displayed text by increasing the sizes by 1 point.
+ void ZoomIn();
+
+ // Make the displayed text smaller by decreasing the sizes by 1 point.
+ void ZoomOut();
+
+ // Delete the word to the left of the caret.
+ void DelWordLeft();
+
+ // Delete the word to the right of the caret.
+ void DelWordRight();
+
+ // Cut the line containing the caret.
+ void LineCut();
+
+ // Delete the line containing the caret.
+ void LineDelete();
+
+ // Switch the current line with the previous.
+ void LineTranspose();
+
+ // Duplicate the current line.
+ void LineDuplicate();
+
+ // Transform the selection to lower case.
+ void LowerCase();
+
+ // Transform the selection to upper case.
+ void UpperCase();
+
+ // Scroll the document down, keeping the caret visible.
+ void LineScrollDown();
+
+ // Scroll the document up, keeping the caret visible.
+ void LineScrollUp();
+
+ // Delete the selection or if no selection, the character before the caret.
+ // Will not delete the character before at the start of a line.
+ void DeleteBackNotLine();
+
+ // Move caret to first position on display line.
+ void HomeDisplay();
+
+ // Move caret to first position on display line extending selection to
+ // new caret position.
+ void HomeDisplayExtend();
+
+ // Move caret to last position on display line.
+ void LineEndDisplay();
+
+ // Move caret to last position on display line extending selection to new
+ // caret position.
+ void LineEndDisplayExtend();
+
+ // These are like their namesakes Home(Extend)?, LineEnd(Extend)?, VCHome(Extend)?
+ // except they behave differently when word-wrap is enabled:
+ // They go first to the start / end of the display line, like (Home|LineEnd)Display
+ // The difference is that, the cursor is already at the point, it goes on to the start
+ // or end of the document line, as appropriate for (Home|LineEnd|VCHome)(Extend)?.
+ void HomeWrap();
+ void HomeWrapExtend();
+ void LineEndWrap();
+ void LineEndWrapExtend();
+ void VCHomeWrap();
+ void VCHomeWrapExtend();
+
+ // Copy the line containing the caret.
+ void LineCopy();
+
+ // Move the caret inside current view if it's not there already.
+ void MoveCaretInsideView();
+
+ // How many characters are on a line, not including end of line characters?
+ int LineLength(int line);
+
+ // Highlight the characters at two positions.
+ void BraceHighlight(int pos1, int pos2);
+
+ // Highlight the character at a position indicating there is no matching brace.
+ void BraceBadLight(int pos);
+
+ // Find the position of a matching brace or INVALID_POSITION if no match.
+ int BraceMatch(int pos);
+
+ // Are the end of line characters visible?
+ bool GetViewEOL();
+
+ // Make the end of line characters visible or invisible.
+ void SetViewEOL(bool visible);
+
+ // Retrieve a pointer to the document object.
+ void* GetDocPointer();
+
+ // Change the document object used.
+ void SetDocPointer(void* docPointer);
+
+ // Set which document modification events are sent to the container.
+ void SetModEventMask(int mask);
+
+ // Retrieve the column number which text should be kept within.
+ int GetEdgeColumn();
+
+ // Set the column number of the edge.
+ // If text goes past the edge then it is highlighted.
+ void SetEdgeColumn(int column);
+
+ // Retrieve the edge highlight mode.
+ int GetEdgeMode();
+
+ // The edge may be displayed by a line (EDGE_LINE) or by highlighting text that
+ // goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE).
+ void SetEdgeMode(int mode);
+
+ // Retrieve the colour used in edge indication.
+ wxColour GetEdgeColour();
+
+ // Change the colour used in edge indication.
+ void SetEdgeColour(const wxColour& edgeColour);
+
+ // Sets the current caret position to be the search anchor.
+ void SearchAnchor();
+
+ // Find some text starting at the search anchor.
+ // Does not ensure the selection is visible.
+ int SearchNext(int flags, const wxString& text);
+
+ // Find some text starting at the search anchor and moving backwards.
+ // Does not ensure the selection is visible.
+ int SearchPrev(int flags, const wxString& text);
+
+ // Retrieves the number of lines completely visible.
+ int LinesOnScreen();
+
+ // Set whether a pop up menu is displayed automatically when the user presses
+ // the wrong mouse button.
+ void UsePopUp(bool allowPopUp);
+
+ // Is the selection rectangular? The alternative is the more common stream selection.
+ bool SelectionIsRectangle();
+
+ // Set the zoom level. This number of points is added to the size of all fonts.
+ // It may be positive to magnify or negative to reduce.
+ void SetZoom(int zoom);
+
+ // Retrieve the zoom level.
+ int GetZoom();
+
+ // Create a new document object.
+ // Starts with reference count of 1 and not selected into editor.
+ void* CreateDocument();
+
+ // Extend life of document.
+ void AddRefDocument(void* docPointer);
+
+ // Release a reference to the document, deleting document if it fades to black.
+ void ReleaseDocument(void* docPointer);
+
+ // Get which document modification events are sent to the container.
+ int GetModEventMask();
+
+ // Change internal focus flag.
+ void SetSTCFocus(bool focus);
+
+ // Get internal focus flag.
+ bool GetSTCFocus();
+
+ // Change error status - 0 = OK.
+ void SetStatus(int statusCode);
+
+ // Get error status.
+ int GetStatus();
+
+ // Set whether the mouse is captured when its button is pressed.
+ void SetMouseDownCaptures(bool captures);
+
+ // Get whether mouse gets captured.
+ bool GetMouseDownCaptures();
+
+ // Sets the cursor to one of the SC_CURSOR* values.
+ void SetSTCCursor(int cursorType);
+
+ // Get cursor type.
+ int GetSTCCursor();
+
+ // Change the way control characters are displayed:
+ // If symbol is < 32, keep the drawn way, else, use the given character.
+ void SetControlCharSymbol(int symbol);
+
+ // Get the way control characters are displayed.
+ int GetControlCharSymbol();
+
+ // Move to the previous change in capitalisation.
+ void WordPartLeft();
+
+ // Move to the previous change in capitalisation extending selection
+ // to new caret position.
+ void WordPartLeftExtend();
+
+ // Move to the change next in capitalisation.
+ void WordPartRight();
+
+ // Move to the next change in capitalisation extending selection
+ // to new caret position.
+ void WordPartRightExtend();
+
+ // Set the way the display area is determined when a particular line
+ // is to be moved to by Find, FindNext, GotoLine, etc.
+ void SetVisiblePolicy(int visiblePolicy, int visibleSlop);
+
+ // Delete back from the current position to the start of the line.
+ void DelLineLeft();
+
+ // Delete forwards from the current position to the end of the line.
+ void DelLineRight();
+
+ // Get and Set the xOffset (ie, horizonal scroll position).
+ void SetXOffset(int newOffset);
+ int GetXOffset();
+
+ // Set the last x chosen value to be the caret x position.
+ void ChooseCaretX();
+
+ // Set the way the caret is kept visible when going sideway.
+ // The exclusion zone is given in pixels.
+ void SetXCaretPolicy(int caretPolicy, int caretSlop);
+
+ // Set the way the line the caret is on is kept visible.
+ // The exclusion zone is given in lines.
+ void SetYCaretPolicy(int caretPolicy, int caretSlop);
+
+ // Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE).
+ void SetPrintWrapMode(int mode);
+
+ // Is printing line wrapped?
+ int GetPrintWrapMode();
+
+ // Set a fore colour for active hotspots.
+ void SetHotspotActiveForeground(bool useSetting, const wxColour& fore);
+
+ // Set a back colour for active hotspots.
+ void SetHotspotActiveBackground(bool useSetting, const wxColour& back);
+
+ // Enable / Disable underlining active hotspots.
+ void SetHotspotActiveUnderline(bool underline);
+
+ // Limit hotspots to single line so hotspots on two lines don't merge.
+ void SetHotspotSingleLine(bool singleLine);
+
+ // Move caret between paragraphs (delimited by empty lines).
+ void ParaDown();
+ void ParaDownExtend();
+ void ParaUp();
+ void ParaUpExtend();
+
+ // Given a valid document position, return the previous position taking code
+ // page into account. Returns 0 if passed 0.
+ int PositionBefore(int pos);
+
+ // Given a valid document position, return the next position taking code
+ // page into account. Maximum value returned is the last position in the document.
+ int PositionAfter(int pos);
+
+ // Copy a range of text to the clipboard. Positions are clipped into the document.
+ void CopyRange(int start, int end);
+
+ // Copy argument text to the clipboard.
+ void CopyText(int length, const wxString& text);
+
+ // Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE) or
+ // by lines (SC_SEL_LINES).
+ void SetSelectionMode(int mode);
+
+ // Get the mode of the current selection.
+ int GetSelectionMode();
+
+ // Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line).
+ int GetLineSelStartPosition(int line);
+
+ // Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line).
+ int GetLineSelEndPosition(int line);
+
+ // Move caret down one line, extending rectangular selection to new caret position.
+ void LineDownRectExtend();
+
+ // Move caret up one line, extending rectangular selection to new caret position.
+ void LineUpRectExtend();
+
+ // Move caret left one character, extending rectangular selection to new caret position.
+ void CharLeftRectExtend();
+
+ // Move caret right one character, extending rectangular selection to new caret position.
+ void CharRightRectExtend();
+
+ // Move caret to first position on line, extending rectangular selection to new caret position.
+ void HomeRectExtend();
+
+ // Move caret to before first visible character on line.
+ // If already there move to first character on line.
+ // In either case, extend rectangular selection to new caret position.
+ void VCHomeRectExtend();
+
+ // Move caret to last position on line, extending rectangular selection to new caret position.
+ void LineEndRectExtend();
+
+ // Move caret one page up, extending rectangular selection to new caret position.
+ void PageUpRectExtend();
+
+ // Move caret one page down, extending rectangular selection to new caret position.
+ void PageDownRectExtend();
+
+ // Move caret to top of page, or one page up if already at top of page.
+ void StutteredPageUp();
+
+ // Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
+ void StutteredPageUpExtend();
+
+ // Move caret to bottom of page, or one page down if already at bottom of page.
+ void StutteredPageDown();
+
+ // Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
+ void StutteredPageDownExtend();
+
+ // Move caret left one word, position cursor at end of word.
+ void WordLeftEnd();
+
+ // Move caret left one word, position cursor at end of word, extending selection to new caret position.
+ void WordLeftEndExtend();
+
+ // Move caret right one word, position cursor at end of word.
+ void WordRightEnd();
+
+ // Move caret right one word, position cursor at end of word, extending selection to new caret position.
+ void WordRightEndExtend();
+
+ // Set the set of characters making up whitespace for when moving or selecting by word.
+ // Should be called after SetWordChars.
+ void SetWhitespaceChars(const wxString& characters);
+
+ // Reset the set of characters for whitespace and word characters to the defaults.
+ void SetCharsDefault();
+
+ // Get currently selected item position in the auto-completion list
+ int AutoCompGetCurrent();
+
+ // Enlarge the document to a particular size of text bytes.
+ void Allocate(int bytes);
+
+ // Find the position of a column on a line taking into account tabs and
+ // multi-byte characters. If beyond end of line, return line end position.
+ int FindColumn(int line, int column);
+
+ // Can the caret preferred x position only be changed by explicit movement commands?
+ bool GetCaretSticky();
+
+ // Stop the caret preferred x position changing when the user types.
+ void SetCaretSticky(bool useCaretStickyBehaviour);
+
+ // Switch between sticky and non-sticky: meant to be bound to a key.
+ void ToggleCaretSticky();
+
+ // Enable/Disable convert-on-paste for line endings
+ void SetPasteConvertEndings(bool convert);
+
+ // Get convert-on-paste setting
+ bool GetPasteConvertEndings();
+
+ // Duplicate the selection. If selection empty duplicate the line containing the caret.
+ void SelectionDuplicate();
+
+ // Start notifying the container of all key presses and commands.
+ void StartRecord();
+
+ // Stop notifying the container of all key presses and commands.
+ void StopRecord();
+
+ // Set the lexing language of the document.
+ void SetLexer(int lexer);
+
+ // Retrieve the lexing language of the document.
+ int GetLexer();
+
+ // Colourise a segment of the document using the current lexing language.
+ void Colourise(int start, int end);
+
+ // Set up a value that may be used by a lexer for some optional feature.
+ void SetProperty(const wxString& key, const wxString& value);
+
+ // Set up the key words used by the lexer.
+ void SetKeyWords(int keywordSet, const wxString& keyWords);
+
+ // Set the lexing language of the document based on string name.
+ void SetLexerLanguage(const wxString& language);
+
+ // Retrieve a 'property' value previously set with SetProperty.
+ wxString GetProperty(const wxString& key);
+
+ // Retrieve a 'property' value previously set with SetProperty,
+ // with '$()' variable replacement on returned buffer.
+ wxString GetPropertyExpanded(const wxString& key);
+
+ // Retrieve a 'property' value previously set with SetProperty,
+ // interpreted as an int AFTER any '$()' variable replacement.
+ int GetPropertyInt(const wxString& key);
+
+ // Retrieve the number of bits the current lexer needs for styling.
+ int GetStyleBitsNeeded();
+
+// END of generated section
+//----------------------------------------------------------------------
+// Others...
+
+
+ // Returns the line number of the line with the caret.
+ int GetCurrentLine();
+
+ // Extract style settings from a spec-string which is composed of one or
+ // more of the following comma separated elements:
+ //
+ // bold turns on bold
+ // italic turns on italics
+ // fore:[name or #RRGGBB] sets the foreground colour
+ // back:[name or #RRGGBB] sets the background colour
+ // face:[facename] sets the font face name to use
+ // size:[num] sets the font size in points
+ // eol turns on eol filling
+ // underline turns on underlining
+ //
+ void StyleSetSpec(int styleNum, const wxString& spec);
+
+
+
+ // Set style size, face, bold, italic, and underline attributes from
+ // a wxFont's attributes.
+ void StyleSetFont(int styleNum, wxFont& font);
+
+
+
+ // Set all font style attributes at once.
+ void StyleSetFontAttr(int styleNum, int size,
+ const wxString& faceName,
+ bool bold, bool italic,
+ bool underline,
+ wxFontEncoding encoding=wxFONTENCODING_DEFAULT);
+
+
+ // Set the character set of the font in a style. Converts the Scintilla
+ // character set values to a wxFontEncoding.
+ void StyleSetCharacterSet(int style, int characterSet);
+
+ // Set the font encoding to be used by a style.
+ void StyleSetFontEncoding(int style, wxFontEncoding encoding);
+
+
+ // Perform one of the operations defined by the wxSTC_CMD_* constants.
+ void CmdKeyExecute(int cmd);
+
+
+ // Set the left and right margin in the edit area, measured in pixels.
+ void SetMargins(int left, int right);
+
+
+ // Retrieve the start and end positions of the current selection.
+#ifdef SWIG
+ void GetSelection(int* OUTPUT, int* OUTPUT);
+#else
+ void GetSelection(int* startPos, int* endPos);
+#endif
+
+ // Retrieve the point in the window where a position is displayed.
+ wxPoint PointFromPosition(int pos);
+
+
+ // Scroll enough to make the given line visible
+ void ScrollToLine(int line);
+
+
+ // Scroll enough to make the given column visible
+ void ScrollToColumn(int column);
+
+
+ // Send a message to Scintilla
+ long SendMsg(int msg, long wp=0, long lp=0);
+
+
+ // Set the vertical scrollbar to use instead of the ont that's built-in.
+ void SetVScrollBar(wxScrollBar* bar);
+
+
+ // Set the horizontal scrollbar to use instead of the ont that's built-in.
+ void SetHScrollBar(wxScrollBar* bar);
+
+ // Can be used to prevent the EVT_CHAR handler from adding the char
+ bool GetLastKeydownProcessed() { return m_lastKeyDownConsumed; }
+ void SetLastKeydownProcessed(bool val) { m_lastKeyDownConsumed = val; }
+
+ // Write the contents of the editor to filename
+ bool SaveFile(const wxString& filename);
+
+ // Load the contents of filename into the editor
+ bool LoadFile(const wxString& filename);
+
+#ifdef STC_USE_DND
+ // Allow for simulating a DnD DragOver
+ wxDragResult DoDragOver(wxCoord x, wxCoord y, wxDragResult def);
+
+ // Allow for simulating a DnD DropText
+ bool DoDropText(long x, long y, const wxString& data);
+#endif
+
+ // Specify whether anti-aliased fonts should be used. Will have no effect
+ // on some platforms, but on some (wxMac for example) can greatly improve
+ // performance.
+ void SetUseAntiAliasing(bool useAA);
+
+ // Returns the current UseAntiAliasing setting.
+ bool GetUseAntiAliasing();
+
+
+
+ // The following methods are nearly equivallent to their similarly named
+ // cousins above. The difference is that these methods bypass wxString
+ // and always use a char* even if used in a unicode build of wxWidgets.
+ // In that case the character data will be utf-8 encoded since that is
+ // what is used internally by Scintilla in unicode builds.
+
+ // Add text to the document at current position.
+ void AddTextRaw(constchar* text);
+
+ // Insert string at a position.
+ void InsertTextRaw(int pos, constchar* text);
+
+ // Retrieve the text of the line containing the caret.
+ // Returns the index of the caret on the line.
+#ifdef SWIG
+ wxCharBuffer GetCurLineRaw(int* OUTPUT);
+#else
+ wxCharBuffer GetCurLineRaw(int* linePos=NULL);
+#endif
+
+ // Retrieve the contents of a line.
+ wxCharBuffer GetLineRaw(int line);
+
+ // Retrieve the selected text.
+ wxCharBuffer GetSelectedTextRaw();
+
+ // Retrieve a range of text.
+ wxCharBuffer GetTextRangeRaw(int startPos, int endPos);
+
+ // Replace the contents of the document with the argument text.
+ void SetTextRaw(constchar* text);
+
+ // Retrieve all the text in the document.
+ wxCharBuffer GetTextRaw();
+
+ // Append a string to the end of the document without changing the selection.
+ void AppendTextRaw(constchar* text);
+
+#ifdef SWIG
+ %pythoncode "_stc_utf8_methods.py"
+#endif
+//----------------------------------------------------------------------
+
+
+#ifndef SWIG
+protected:
+ // Event handlers
+ void OnPaint(wxPaintEvent& evt);
+ void OnScrollWin(wxScrollWinEvent& evt);
+ void OnScroll(wxScrollEvent& evt);
+ void OnSize(wxSizeEvent& evt);
+ void OnMouseLeftDown(wxMouseEvent& evt);
+ void OnMouseMove(wxMouseEvent& evt);
+ void OnMouseLeftUp(wxMouseEvent& evt);
+ void OnMouseRightUp(wxMouseEvent& evt);
+ void OnMouseMiddleUp(wxMouseEvent& evt);
+ void OnContextMenu(wxContextMenuEvent& evt);
+ void OnMouseWheel(wxMouseEvent& evt);
+ void OnChar(wxKeyEvent& evt);
+ void OnKeyDown(wxKeyEvent& evt);
+ void OnLoseFocus(wxFocusEvent& evt);
+ void OnGainFocus(wxFocusEvent& evt);
+ void OnSysColourChanged(wxSysColourChangedEvent& evt);
+ void OnEraseBackground(wxEraseEvent& evt);
+ void OnMenu(wxCommandEvent& evt);
+ void OnListBox(wxCommandEvent& evt);
+ void OnIdle(wxIdleEvent& evt);
+
+ virtual wxSize DoGetBestSize() const;
+
+ // Turn notifications from Scintilla into events
+ void NotifyChange();
+ void NotifyParent(SCNotification* scn);
+
+private:
+ DECLARE_EVENT_TABLE()
+ DECLARE_DYNAMIC_CLASS(wxStyledTextCtrl)
+
+protected:
+
+ ScintillaWX* m_swx;
+ wxStopWatch m_stopWatch;
+ wxScrollBar* m_vScrollBar;
+ wxScrollBar* m_hScrollBar;
+
+ bool m_lastKeyDownConsumed;
+
+ friendclass ScintillaWX;
+ friendclass Platform;
+#endif
+};
+
+//----------------------------------------------------------------------
+
+class WXDLLIMPEXP_STC wxStyledTextEvent : public wxCommandEvent {
+public:
+ wxStyledTextEvent(wxEventType commandType=0, int id=0);
+#ifndef SWIG
+ wxStyledTextEvent(const wxStyledTextEvent& event);
+#endif
+ ~wxStyledTextEvent() {}
+
+ void SetPosition(int pos) { m_position = pos; }
+ void SetKey(int k) { m_key = k; }
+ void SetModifiers(int m) { m_modifiers = m; }
+ void SetModificationType(int t) { m_modificationType = t; }
+ void SetText(const wxString& t) { m_text = t; }
+ void SetLength(int len) { m_length = len; }
+ void SetLinesAdded(int num) { m_linesAdded = num; }
+ void SetLine(int val) { m_line = val; }
+ void SetFoldLevelNow(int val) { m_foldLevelNow = val; }
+ void SetFoldLevelPrev(int val) { m_foldLevelPrev = val; }
+ void SetMargin(int val) { m_margin = val; }
+ void SetMessage(int val) { m_message = val; }
+ void SetWParam(int val) { m_wParam = val; }
+ void SetLParam(int val) { m_lParam = val; }
+ void SetListType(int val) { m_listType = val; }
+ void SetX(int val) { m_x = val; }
+ void SetY(int val) { m_y = val; }
+ void SetDragText(const wxString& val) { m_dragText = val; }
+ void SetDragAllowMove(bool val) { m_dragAllowMove = val; }
+#ifdef STC_USE_DND
+ void SetDragResult(wxDragResult val) { m_dragResult = val; }
+#endif
+
+ int GetPosition() const { return m_position; }
+ int GetKey() const { return m_key; }
+ int GetModifiers() const { return m_modifiers; }
+ int GetModificationType() const { return m_modificationType; }
+ wxString GetText() const { return m_text; }
+ int GetLength() const { return m_length; }
+ int GetLinesAdded() const { return m_linesAdded; }
+ int GetLine() const { return m_line; }
+ int GetFoldLevelNow() const { return m_foldLevelNow; }
+ int GetFoldLevelPrev() const { return m_foldLevelPrev; }
+ int GetMargin() const { return m_margin; }
+ int GetMessage() const { return m_message; }
+ int GetWParam() const { return m_wParam; }
+ int GetLParam() const { return m_lParam; }
+ int GetListType() const { return m_listType; }
+ int GetX() const { return m_x; }
+ int GetY() const { return m_y; }
+ wxString GetDragText() { return m_dragText; }
+ bool GetDragAllowMove() { return m_dragAllowMove; }
+#ifdef STC_USE_DND
+ wxDragResult GetDragResult() { return m_dragResult; }
+#endif
+
+ bool GetShift() const;
+ bool GetControl() const;
+ bool GetAlt() const;
+
+ virtual wxEvent* Clone() const { returnnew wxStyledTextEvent(*this); }
+
+#ifndef SWIG
+private:
+ DECLARE_DYNAMIC_CLASS(wxStyledTextEvent)
+
+ int m_position;
+ int m_key;
+ int m_modifiers;
+
+ int m_modificationType; // wxEVT_STC_MODIFIED
+ wxString m_text;
+ int m_length;
+ int m_linesAdded;
+ int m_line;
+ int m_foldLevelNow;
+ int m_foldLevelPrev;
+
+ int m_margin; // wxEVT_STC_MARGINCLICK
+
+ int m_message; // wxEVT_STC_MACRORECORD
+ int m_wParam;
+ int m_lParam;
+
+ int m_listType;
+ int m_x;
+ int m_y;
+
+ wxString m_dragText; // wxEVT_STC_START_DRAG, wxEVT_STC_DO_DROP
+ bool m_dragAllowMove; // wxEVT_STC_START_DRAG
+
+#if wxUSE_DRAG_AND_DROP
+ wxDragResult m_dragResult; // wxEVT_STC_DRAG_OVER,wxEVT_STC_DO_DROP
+#endif
+#endif
+};
+
+
+
+#ifndef SWIG
+BEGIN_DECLARE_EVENT_TYPES()
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_CHANGE, 1650)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_STYLENEEDED, 1651)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_CHARADDED, 1652)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_SAVEPOINTREACHED, 1653)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_SAVEPOINTLEFT, 1654)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_ROMODIFYATTEMPT, 1655)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_KEY, 1656)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_DOUBLECLICK, 1657)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_UPDATEUI, 1658)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_MODIFIED, 1659)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_MACRORECORD, 1660)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_MARGINCLICK, 1661)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_NEEDSHOWN, 1662)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_PAINTED, 1664)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_USERLISTSELECTION, 1665)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_URIDROPPED, 1666)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_DWELLSTART, 1667)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_DWELLEND, 1668)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_START_DRAG, 1669)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_DRAG_OVER, 1670)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_DO_DROP, 1671)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_ZOOM, 1672)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_HOTSPOT_CLICK, 1673)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_HOTSPOT_DCLICK, 1674)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_CALLTIP_CLICK, 1675)
+ DECLARE_EXPORTED_EVENT_TYPE(WXDLLIMPEXP_STC, wxEVT_STC_AUTOCOMP_SELECTION, 1676)
+END_DECLARE_EVENT_TYPES()
+#else
+ enum {
+ wxEVT_STC_CHANGE,
+ wxEVT_STC_STYLENEEDED,
+ wxEVT_STC_CHARADDED,
+ wxEVT_STC_SAVEPOINTREACHED,
+ wxEVT_STC_SAVEPOINTLEFT,
+ wxEVT_STC_ROMODIFYATTEMPT,
+ wxEVT_STC_KEY,
+ wxEVT_STC_DOUBLECLICK,
+ wxEVT_STC_UPDATEUI,
+ wxEVT_STC_MODIFIED,
+ wxEVT_STC_MACRORECORD,
+ wxEVT_STC_MARGINCLICK,
+ wxEVT_STC_NEEDSHOWN,
+ wxEVT_STC_PAINTED,
+ wxEVT_STC_USERLISTSELECTION,
+ wxEVT_STC_URIDROPPED,
+ wxEVT_STC_DWELLSTART,
+ wxEVT_STC_DWELLEND,
+ wxEVT_STC_START_DRAG,
+ wxEVT_STC_DRAG_OVER,
+ wxEVT_STC_DO_DROP,
+ wxEVT_STC_ZOOM,
+ wxEVT_STC_HOTSPOT_CLICK,
+ wxEVT_STC_HOTSPOT_DCLICK,
+ wxEVT_STC_CALLTIP_CLICK,
+ wxEVT_STC_AUTOCOMP_SELECTION
+ };
+#endif
+
+
+
+#ifndef SWIG
+typedefvoid (wxEvtHandler::*wxStyledTextEventFunction)(wxStyledTextEvent&);
+
+#define EVT_STC_CHANGE(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_CHANGE, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_STYLENEEDED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_STYLENEEDED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_CHARADDED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_CHARADDED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_SAVEPOINTREACHED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_SAVEPOINTREACHED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_SAVEPOINTLEFT(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_SAVEPOINTLEFT, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_ROMODIFYATTEMPT(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_ROMODIFYATTEMPT, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_KEY(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_KEY, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_DOUBLECLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DOUBLECLICK, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_UPDATEUI(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_UPDATEUI, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_MODIFIED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_MODIFIED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_MACRORECORD(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_MACRORECORD, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_MARGINCLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_MARGINCLICK, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_NEEDSHOWN(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_NEEDSHOWN, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_PAINTED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_PAINTED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_USERLISTSELECTION(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_USERLISTSELECTION, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_URIDROPPED(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_URIDROPPED, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_DWELLSTART(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DWELLSTART, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_DWELLEND(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DWELLEND, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_START_DRAG(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_START_DRAG, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_DRAG_OVER(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DRAG_OVER, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_DO_DROP(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_DO_DROP, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_ZOOM(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_ZOOM, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_HOTSPOT_CLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_HOTSPOT_CLICK, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_HOTSPOT_DCLICK(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_HOTSPOT_DCLICK, id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_CALLTIP_CLICK(id, fn)) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_CALLTIP_CLICK id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#define EVT_STC_AUTOCOMP_SELECTION(id, fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_STC_AUTOCOMP_SELECTION id, wxID_ANY, (wxObjectEventFunction) (wxEventFunction) wxStaticCastEvent( wxStyledTextEventFunction, & fn ), (wxObject *) NULL ),
+#endif
+
+//----------------------------------------------------------------------
+// Utility functions used within wxSTC
+
+#ifndef SWIG
+#if wxUSE_UNICODE
+
+WXDLLIMPEXP_STC wxString stc2wx(constchar* str);
+WXDLLIMPEXP_STC wxString stc2wx(constchar* str, size_t len);
+WXDLLIMPEXP_STC const wxWX2MBbuf wx2stc(const wxString& str);
+
+#else // not UNICODE
+
+inline wxString stc2wx(constchar* str) {
+ return wxString(str);
+}
+inline wxString stc2wx(constchar* str, size_t len) {
+ return wxString(str, len);
+}
+inlineconst wxWX2MBbuf wx2stc(const wxString& str) {
+ return str.mbc_str();
+}
+
+#endif // UNICODE
+#endif // SWIG
+
+//----------------------------------------------------------------------
+#endif
+
+
+
Hello, this *is* default charset (helvetica, probably) and it is displayed
+with one COLOR CHANGE. Of course we
+can have as many color changes as we can, what about this MADNESS?
+
There was a space above.
+
+
This was a line. (BTW we are in fixed font
+/ typewriter font right now :-)
+ This is in BOLD face. This is ITALIC. This is E
+V E R Y T H I N G.
+
+
+
+
Right now, centered REALLY Big Text,
+how do you like (space) it?
+
+
RIGHT: text-2, text-1,
+text+0,
+text+1,
+text+2,
+text+3,
+text+4
+ we are right now
+
+
we are center now
+we are left now.
+
Blue italic text is displayed there....
+
+
+This is heading one.
+this is normal
+
+
+This is CENTERED heading one
+Yes, hmmmmmmmmm........, right now, we should
+display some tiny nice image, he?
+ and this is text......
+
and
+this is text......
+ (try clicking on the image :-) and
+this is text......
+
+
+
+
+
+
+item 1
+
+
+item 2
+
+
+
+nested item
+
+
+nested item 2
+
+
+
+item 3
+
+
+
+
+item one
+
+
+item two
+
+
+
+nsted item
+
+
+
+last numbered item
+
+
+
+Heading 1
+Italic text now...
+
+Heading 2
+and now?
+
+Heading 3
+
+
+Heading 4
+
+
+Heading 5
+
+
+Heading 6
+And this is normal text, once again :-)
+
+
+
+
+
+
+
+two two two two two two twotwo TWO two two two two two two
+twotwo TWO two two two two two two twotwo TWO two two two two two two twotwo
+TWO two two two two two two twotwo TWO two two two two two two twotwo TWO
+two two two two two two twotwo TWO
+
+
(blockquote)two two two two two two twotwo
+TWO two two two two two two twotwo TWO two two two two two two twotwo TWO
+
two two two two two two twotwo TWO two two two
+two two two twotwo TWO two two two two two two twotwo TWO
+two two two two two two twotwo TWO
+two two two two two two twotwo TWO two two two two two two
+twotwo TWO
+
+two two two two two two twotwo TWO two two two two two two
+twotwo TWO two two two two two two twotwo TWO two two two two two two twotwo
+TWO two two two two two two twotwo TWO two two two two two two twotwo TWO
+two two two two two two twotwo TWO two two two two two two twotwo TWO two
+two two two two two twotwo TWO two two two two two two twotwo TWO two two
+two two two two twotwo TWO two two two two two two twotwo TWO two two two
+two two two twotwo TWO two two two two two two twotwo TWO two two two two
+two two twotwo TWO two two two two two two twotwo TWO
+two two two two two two twotwo TWO two two two two two two
+twotwo TWO two two two two two two twotwo TWO two two two two two two twotwo
+TWO two two two two two two twotwo TWO two two two two two two twotwo TWO
+two two two two two two twotwo TWO two two two two two two twotwo TWO two
+two two two two two twotwo TWO two two two two two two twotwo TWO two two
+two two two two twotwo TWO two two two two two two twotwo TWO two two two
+two two two twotwo TWO two two two two two two twotwo TWO two two two two
+two two twotwo TWO two two two two two two twotwo TWO
+two two two two two two twotwo TWO two two two two two two
+twotwo TWO two two two two two two twotwo TWO two two two two two two twotwo
+TWO two two two two two two twotwo TWO two two two two two two twotwo TWO
+two two two two two two twotwo TWO two two two two two two twotwo TWO two
+two two two two two twotwo TWO two two two two two two twotwo TWO two two
+two two two two twotwo TWO two two two two two two twotwo TWO two two two
+two two two twotwo TWO two two two two two two twotwo TWO two two two two
+two two twotwo TWO two two two two two two twotwo TWO
+two two two two two two twotwo TWO two two two two two two
+twotwo TWO two two two two two two twotwo TWO two two two two two two twotwo
+TWO two two two two two two twotwo TWO two two two two two two twotwo TWO
+two two two two two two twotwo TWO two two two two two two twotwo TWO
+
+
two two two two two two twotwo TWO two two two two
+two two twotwo TWO two two two two two two twotwo TWO two two two two two
+two twotwo TWO
+
two two two two two two twotwo TWO two two two two two
+two twotwo TWO two two two two two two twotwo TWO two two two two two two
+twotwo TWO
+
+This is item nyumber 3.
+
+Now, you will see some PRE text:
+
// This is sample C++ code:
+
+void main(int argc, char *argv[])
+{
+ printf("Go away, man!\n");
+ i = 666;
+ printf("\n\n\nCRASH\n DOWN NOW. . . \n");
+}
+
+
+
+
+
diff --git a/demo/data/testmovie.mpg b/demo/data/testmovie.mpg
new file mode 100644
index 00000000..b95237d0
Binary files /dev/null and b/demo/data/testmovie.mpg differ
diff --git a/demo/data/testtable.txt b/demo/data/testtable.txt
new file mode 100644
index 00000000..dec973e7
--- /dev/null
+++ b/demo/data/testtable.txt
@@ -0,0 +1,38 @@
+Name Type Platform Location Availability Description
+WebReuser Development Windows 95, Windows NT, HPUX 9.05 and 10.2, Solaris 2.4 and 2.5 http://www.stablesoft.com Evaluation WebReuser is a re-use tool from Hitachi Europe Limited. WebReuser is a tool that simplifies software reuse. Its ability to track, schematize and search documents makes it the ideal way to understand C++ code. These features also make WebReuser an ideal tool to classify any Web resource. WebReuser can even be used for more general documentation management tasks.
+MacAnova Development Windows, Motif, Mac http://www.stat.umn.edu/~gary/macanova/macanova.home.html Free A large statistical application from the School of Statistics, University of Minnesota. It is based on a modified version of wxWindows 1.65.
+Hardy Development Win 3.1, WIN32, Motif (Sun only) http://www.aiai.ed.ac.uk/~hardy/ Freeware for personal and academic use A hypertext-based diagramming and knowledge-based system development tool, with NASA's CLIPS built-in. It is a superset of wxCLIPS.
+wxCLIPS Development Win 3.1, WIN32, Motif, XView http://web.ukonline.co.uk/julian.smart/wxclips Freeware A GUI development environment for CLIPS applications.
+wxPython Development wxWindows 2 for the new version http://alldunn.com/wxPython/ Freeware Python/wxWindows combination by Robin Dunn and Harri Pasanen. Python is an elegant object-oriented, interpreted language that runs on many platforms.
+MrEd Development Win 3.1, WIN32, Motif, XView http://www.cs.rice.edu/CS/PLT/packages/mred/ Freeware MrEd is a combined editor and Scheme development environment by Matthew Flatt.
+WXLisp Development Win 3.1, WIN32, Motif, XView http://www.cadlab.de/~lipuser/wxlisp/wxlisp.html Freeware A combination of wxWindows and XLisp.
+Scriptum Development Motif http://www.isoft.com.ar/eng/products/system/scriptum.html Freeware Graphical editor with visual highlighting, navigation/browsing, undo, class browser for C++ and Java, source code management, file locking, remote editing using ftp, configurable.
+WipeOut Development XView/Linux http://www.softwarebuero.de/wipeout-eng.html Giftware WipeOut is an integrated development environment for C++ projects, available for Linux/XView. The authors are working on versions for SunOS/Solaris. Source is available for porting to other platforms.
+OPL Development Win 3.1, WIN32, Motif, XView http://www.ozemail.com.au/~adavison/ Freeware Object Prolog is a portable implementation of Prolog by Andrew Davison, with object-oriented extensions, entirely written in C++. In the initial version, a binding to wxWindows is available. In the revamped version, this binding has not been written yet.
+Dataplore Graphics and sound Windows, other? http://www.datan.de/dataplore Commercial Data visualisation tool, from Datan
+VCG Tool Graphics and sound Win 3.1, WIN32, Motif, XView http://www.cs.uni-sb.de:80/RW/users/sander/html/gsvcg1.html Freeware A graph layout tool similar to GraphPlace, but with extensions. Very nice indeed!
+Y.E.S. Graphics and sound Win 3.1, WIN32, XView (Linux) ftp://ftp.musik.uni-essen.de/pub/EsAC/program/ Shareware Monophonic notation program.
+JAZZ Graphics and sound XView (Linux) http://rokke.aug.hiagder.no/per/jazz.html Freeware A MIDI sequencer for Linux.
+ISP Graphics and sound Win 3.1, WIN32, Motif, XView ftp://www.remstar.com/pub/wxwin/contrib/isp-100/ Freeware Image and sound player educational tool.
+ClockWorks Graphics and sound Win 3.1, WIN32, Motif, XView http://web.ukonline.co.uk/Members/julian.smart/freesoft.html#clockworks Freeware A configurable analogue clock, with a collection of 'fine art' faces. By Julian Smart.
+M Miscellaneous Windows 95, Windows NT, Linux http://www.phy.hw.ac.uk/~karsten/M/index.html GPL M is a cross-platform e-mail application. It will be available for X11/Unix and Windows platforms, supporting a wide range of e-mail transfer protocols as well as including full MIME support. M's wealth of features and ease of use make it one of the most powerful MUAs available, providing a consistent and intuitive interface across all platforms.
+Boolean Miscellaneous Windows 95, Windows NT, Solaris http://www.xs4all.nl/~kholwerd/bool.html Freeware A GDSII CAD file format viewer, and program to perform boolean operations on sets of 2D polygons. By Klaas Holwerda.
+TimeMan Miscellaneous wxGTK, Unix http://www.bgif.no/neureka/TimeMan/ Freeware A time manager, written using wxGTK
+Forty Thieves Miscellaneous Motif, Windows apps/forty/forty.htm Freeware A fiendish patience game, by Chris Breeze. A nice demo of what's possible with wxWindows.
+Lean Integration Platform Miscellaneous Windows NT, various flavours of UNIX http://www.c-lab.de/~lipuser/lip To be decided LIP is a workflow-oriented tool integration system which uses wxLisp (and thus wxWindows) as an implementation basis. Lisp combined with the wxWindows bindings make up the compatible extension language platform of the system.
+wxWeb Miscellaneous Win 3.1, WIN32, Motif ftp://www.remstar.com/pub/wxwin/contrib/wxweb Freeware Andrew Davison's Web browser, with SimSock portable socket library and wxHtml canvas. Includes an http server for UNIX and Windows.
+SANTIS Miscellaneous Win 3.1, Windows 95, Linux, Solaris OpenLook and Motif, Silicon Graphics http://www.physiology.rwth-aachen.de/bs/santis/ Free for non-commercial use SANTIS is a software tool designed for the analysis of signals and time series data of any kind, in particular for scientific purposes. It was developed at the Laboratory of Biomedical Systems Analysis, Institute of Physiology at the University of Aachen, Germany.
+Xbaies Miscellaneous Win 3.1, WIN32, Motif, XView xbaies.htm Freeware A shell for building Bayesian network models, by Robert Cowell.
+wxTinyBB Miscellaneous Win 3.1, WIN32, Motif, XView ftp://www.remstar.com/pub/wxwin/contrib/wxtinybb Freeware/commercial A tiny blackboard shell demo showing an embedded (commercial) Prolog engine. Demo written by Arvindra Sehmi. A good example of a nice interface using wxWindows.
+Gambit Miscellaneous Win 3.1, WIN32, Motif, XView http://www.hss.caltech.edu/~gambit/Gambit.html Freeware A large wxWindows application with source, and features such as a table control with printing.
+Tex2RTF Miscellaneous Win 3.1, WIN32, Motif, XView http://web.ukonline.co.uk/julian.smart/tex2rtf Freeware Converts subset of LaTeX syntax to WinHelp, wordprocessor RTF, HTML, and wxHelp. As used for wxWindows documentation.
+wxPoem Miscellaneous Win 3.1, WIN32, Motif, XView none.htm Freeware A poetry display program for wxWindows. Included as a sample in the wxWindows distribution.
+Sonar tracking software Miscellaneous See Web site http://www.desertstar.com Demonstration Miscellaneous sonar tracking software from Desert Star Systems, who use wxWindows for all their Windows-based software.
+Name Research software Platform Location Availability Description
+DisCo Research software N/A http://www.cs.tut.fi/laitos/DisCo/tool.fm.html N/A A tool for specification of reactive systems.
+CAFE Research software N/A cafe.htm N/A Cellular Analysis of Fire and Extinction
+CODA Research software See Web site http://www.ozemail.com.au/~mbedward/coda/coda.html See Web site CODA assists in the design of networks of nature reserves or protected areas. It has been used for major reserve planning studies, as a teaching resource and for research into conservation planning methods.
+EGRESS Research software N/A http://www.aiai.ed.ac.uk/~jimd/Egress2/projInfo_contents.html N/A An evacuation decision model.
+ACT Research software N/A none.htm N/A A general process and tracker and automator being built at NASA.
+Rectangular nesting program Research software N/A http://www.elec-eng.leeds.ac.uk/een5mpd/research.html N/A Optimized layout of rectangles on a page.
+Finite element post processor Research software N/A http://www.ime.auc.dk/afd3/odessy/manuals/index.htm N/A Finite element postprocessor, produced at Aalborg University in Denmark by John Rasmussen and Erik Lund.
diff --git a/demo/data/tips.txt b/demo/data/tips.txt
new file mode 100644
index 00000000..669f4a9b
--- /dev/null
+++ b/demo/data/tips.txt
@@ -0,0 +1,73 @@
+Each of the leaf items in the tree is a separate demo. Click and learn!
+Use the source Luke!
+Many of the demos have some helpful overview text associated with them. Simply click on the first tab in the notebook control after selecting the demo. You can switch back and forth to the demo page as often as you like.
+You can also view the source code for each demo by clicking on the second notebook tab.
+This demo is a teaching tool. The source code for each sample can be modified and you can see the results immediately!
+Be sure to subscribe to the mail list. Go to http://wxpython.org/maillist.php today!
+The wxPyWiki is a place where wxPython users can help other users, and is a colaborative documentation system. See http://wiki.wxpython.org.
+You shouldn't pee on an electric fence!
+The whole world is a tuxedo and you are a pair of brown shoes.
+Cold hands, no gloves.
+Learn to pause -- or nothing worthwhile can catch up to you.
+Don't kiss an elephant on the lips today.
+Grief can take care of itself; but to get the full value of a joy you must have somebody to divide it with. -- Mark Twain
+Stay away from hurricanes for a while.
+Beware of a dark-haired man with a loud tie.
+Don't ask Robin what these quotes mean, he doesn't remember.
+Your lucky number has been disconnected.
+You single-handedly fought your way into this hopeless mess.
+A few hours grace before the madness begins again.
+Your fly might be open (but don't check it just now).
+Never commit yourself! Let someone else commit you.
+Noise proves nothing. Often a hen who has merely laid an egg cackles as if she laid an asteroid. -- Mark Twain
+The very ink with which all history is written is merely fluid prejudice. -- Mark Twain
+Excellent time to become a missing person.
+Stay away from flying saucers today.
+Look afar and see the end from the beginning.
+Tomorrow, this will be part of the unchangeable past but fortunately, it can still be changed today.
+It has long been an axiom of mine that the little things are infinitely the most important. -- Sir Arthur Conan Doyle
+I don't know half of you half as well as I should like; and I like less than half of you half as well as you deserve. -- J. R. R. Tolkien
+You are only young once, but you can stay immature indefinitely.
+You look like a million dollars. All green and wrinkled.
+The difference between the right word and the almost right word is the difference between lightning and the lightning bug. -- Mark Twain
+The countdown had stalled at 'T' minus 69 seconds when Desiree, the first female ape to go up in space, winked at me slyly and pouted her thick, rubbery lips unmistakably -- the first of many such advances during what would prove to be the longest, and most memorable, space voyage of my career. -- Winning sentence, 1985 Bulwer-Lytton bad fiction contest.
+Q: Why haven't you graduated yet? A: Well, Dad, I could have finished years ago, but I wanted my dissertation to rhyme.
+You are scrupulously honest, frank, and straightforward. Therefore you have few friends.
+Don't you wish you had more energy... or less ambition?
+Are you making all this up as you go along? I am.
+Kindness is a language which the deaf can hear and the blind can read. -- Mark Twain
+Don't let your mind wander -- it's too little to be let out alone.
+Change your thoughts and you change your world.
+Don't you feel more like you do now than you did when you came in?
+Today is the tomorrow you worried about yesterday.
+Caution: breathing may be hazardous to your health.
+You will soon forget this.
+Go not to the elves for counsel, for they will say both yes and no. -- J.R.R. Tolkien
+Today is the first day of the rest of your life.
+Cheer Up! Things are getting worse at a slower rate.
+You are the only person to ever get this message.
+You're almost as happy as you think you are.
+Ships are safe in harbor, but they were never meant to stay there.
+I must have a prodigious quantity of mind; it takes me as much as a week sometimes to make it up. -- Mark Twain
+If you stand on your head, you will get footprints in your hair.
+All generalizations are false, including this one. -- Mark Twain
+You have the body of a 19 year old. Please return it before it gets wrinkled.
+Your ignorance cramps my conversation.
+The brain is a wonderful organ; it starts working the moment you get up in the morning and does not stop until you get into the office. -- Robert Frost
+By working faithfully eight hours a day, you may get to be a boss and work twelve hours a day. -- Robert Frost
+In three words I can sum up everything I've learned about life: it goes on. -- Robert Frost
+If we get involved in a nuclear war, would the electromagnetic pulses from exploding bombs damage my videotapes?
+The earth? Oh the earth will be gone in a few seconds...I'm going to blow it up. It's obstructing my view of Venus. -- Marvin the Martian
+There's that word again, 'heavy'. Why are things so heavy in the future? Is there a problem with the earth's gravitational pull? -- Dr Emmet Brown, "Back To The Future"
+I'm Luke Skywalker, I'm here to rescue you.
+It is good to have an end to journey towards; but it is the journey that matters, in the end. -- Ursula K. Le Guin, "The Left Hand of Darkness"
+I was ready for everything -- except what actually happened.
+Flying is simple. You just throw yourself at the ground and miss. -- Douglas Adams, "So Long, and Thanks for the Fish"
+Man has always assumed that he is more intelligent than dolphins because he has achieved so much--the wheel, New York, wars and so on -- while all the dolphins had ever done was muck about in the water having a good time. But, conversely, the dolphins had always believed that they were far more intelligent than man -- for precisely the same reasons. -- Douglas Adams, "So Long, and Thanks for the Fish"
+I think animal testing is a terrible idea; they get all nervous and give the wrong answers. --A Bit of Fry and Laurie
+All right, brain. You don't like me and I don't like you, but let's just do this and I can get back to killing you with beer. -- Homer Simpson
+The most exciting phrase to hear in science, the one that heralds new discoveries, is not 'Eureka!' (I found it!) but 'That's funny ...' --Isaac Asimov
+Always listen to experts. They'll tell you what can't be done and why. Then do it. --Robert Heinlein
+Still waters run deep.
+Premature optimization is the root of all evil. -- Donald Knuth
+If at first you don't succeed, you must be a programmer.
diff --git a/demo/data/widgetTest.htm b/demo/data/widgetTest.htm
new file mode 100644
index 00000000..ae27d62e
--- /dev/null
+++ b/demo/data/widgetTest.htm
@@ -0,0 +1,70 @@
+
+
+
+
+
+wxHTML does wxPython!
+
+
+
Mixing wxPython and wxHTML
+
+The widgets on this page were created dynamically on the fly by a
+custom wxTagHandler found in wxPython.lib.wxpTag. You can look at the
+sources and doc-string in the wxPython library at wx/lib/wxpTag.py.
+
+
+The button below is added to the page like this:
+
+
+The Shoe What Made the Footprint
+The remarkable footprint is made by a combination of a terrific shoe worn on a fantastic foot propelled by a one-of-a-kind Empress. As can be seen in Figure , the shoe is worthy of an Empress.
+The Terrific Shoe
+The design goals of the shoe were:
+
+
to minimize time-consuming manual tasks such as shoelace tying;
+
to allow different decorations to be placed on the toes; and
+
to enforce a good arch.
+Documenting the Shoe
+Documenting the shoe was the best part for Fred Bloggs. His superior design could be captured for all time in a neutrally-encoded, content-specific manner. An excerpt from his DTD gives an insight into the type of information he captured in his documentation.
+<!DOCTYPE shoedoc [
+<!ELEMENT shoedoc - - (design, mfg, care, recycle) >
+<!ATTLIST shoedoc designer CDATA #REQUIRED
+ date CDATA #REQUIRED>
+<!ELEMENT design - - (specs, desc) >
+etc.
+
+An excerpt from the documentation also gives us insights.
+
+
+The arch shall be high. The toe shall be narrow, but not pinch. The heel shall not come off in grates. Sand shall not get in.]]>
+
+
+
+The authors wish to express our thanks to the Universe for being there and to gravity for holding the sand down long enough to see the footprints.
+
+Barrett 00Barrett, B., Being Empress Made Easy, Galaxy Division of Universal Publishers. 0000
diff --git a/demo/pyTree.py b/demo/pyTree.py
new file mode 100644
index 00000000..24892a90
--- /dev/null
+++ b/demo/pyTree.py
@@ -0,0 +1,229 @@
+"""
+Hello, and welcome to this test of the wxTreeItemData
+class.
+
+The wxTreeItemData class can be used to associate a python
+object with a wxTreeCtrl item. In this sample, its use is
+demonstrated via a tree control that shows the contents of a
+python namespace according to the standard dir()
+command. Every item in the tree has its label taken from the
+dir() output, and 'behind it' a reference to the python
+object is stored in a wxTreeItemData object.
+
+As you may have guessed by now, this sample automatically
+displays '__doc__' strings if the selected python object
+happens to have one. Please expand the pyTree object to
+learn more about the implementation.
+
+Version 1.0, April 4 1999.
+Harm van der Heijden (H.v.d.Heijden@phys.tue.nl)
+
+P.S. Check out the string module. It's imported in this
+sample not because it's used, but because it's so
+beautifully documented...
+"""
+
+import string # Used for demo purposes, nothing more. :-)
+import sys
+
+import wx
+
+#----------------------------------------------------------------------
+
+def _getindent(line):
+ """Returns the indentation level of the given line."""
+ indent = 0
+ for c in line:
+ if c == ' ': indent = indent + 1
+ elif c == '\t': indent = indent + 8
+ else: break
+ return indent
+
+def _sourcefinder(func):
+ """Given a func_code object, this function tries to find and return
+ the python source code of the function."""
+ try:
+ f = open(func.co_filename,"r")
+ except:
+ return "(could not open file %s)" % (func.co_filename,)
+
+ for i in range(func.co_firstlineno):
+ line = f.readline()
+
+ ind = _getindent(line)
+ msg = ""
+
+ while line:
+ msg = msg + line
+ line = f.readline()
+ # the following should be <= ind, but then we get
+ # confused by multiline docstrings. Using == works most of
+ # the time... but not always!
+ if _getindent(line) == ind: break
+
+ return msg
+
+#----------------------------------------------------------------------
+
+class pyTree(wx.TreeCtrl):
+ """
+ This wx.TreeCtrl derivative displays a tree view of a Python namespace.
+ Anything from which the dir() command returns a non-empty list is a branch
+ in this tree.
+ """
+
+ def __init__(self, parent, id, root):
+ """
+ Initialize function; because we insert branches into the tree
+ as needed, we use the ITEM_EXPANDING event handler. The
+ ITEM_COLLAPSED handler removes the stuff afterwards. The
+ SEL_CHANGED handler attempts to display interesting
+ information about the selected object.
+ """
+ wx.TreeCtrl.__init__(self, parent, id)
+ self.root = self.AddRoot(str(root), -1, -1, wx.TreeItemData(root))
+
+ if dir(root):
+ self.SetItemHasChildren(self.root, True)
+
+ self.Bind(wx.EVT_TREE_ITEM_EXPANDING, self.OnItemExpanding, id=self.GetId())
+ self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed, id=self.GetId())
+ self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, id=self.GetId())
+
+ self.output = None
+ self.Expand(self.root)
+
+
+ def SetOutput(self, output):
+ """
+ Set output function (accepts single string). Used to display string
+ representation of the selected object by OnSelChanged.
+ """
+ self.output = output
+
+
+ def OnItemExpanding(self,event):
+ """
+ The real workhorse of this class. First we retrieve the object
+ (parent) belonging to the branch that is to be expanded. This
+ is done by calling GetPyData(parent), which is a short-cut for
+ GetPyItemData(parent).Get().
+
+ Then we get the dir() list of that object. For each item in
+ this list, a tree item is created with associated
+ wxTreeItemData referencing the child object. We get this
+ object using child = getattr(parent, item).
+
+ Finally, we check wether the child returns a non-empty dir()
+ list. If so, it is labeled as 'having children', so that it
+ may be expanded. When it actually is expanded, this function
+ will again figure out what the offspring is.
+ """
+ item = event.GetItem()
+
+ if self.IsExpanded(item): # This event can happen twice in the self.Expand call
+ return
+
+ obj = self.GetPyData( item )
+ lst = dir(obj)
+
+ for key in lst:
+ new_obj = getattr(obj,key)
+ new_item = self.AppendItem( item, key, -1, -1,
+ wx.TreeItemData(new_obj) )
+
+ if dir(new_obj):
+ self.SetItemHasChildren(new_item, True)
+
+ def OnItemCollapsed(self, event):
+ """
+ We need to remove all children here, otherwise we'll see all
+ that old rubbish again after the next expansion.
+ """
+ item = event.GetItem()
+ self.DeleteChildren(item)
+
+ def OnSelChanged(self, event):
+ """
+ If an output function is defined, we try to print some
+ informative, interesting and thought-provoking stuff to it.
+ If it has a __doc__ string, we print it. If it's a function or
+ unbound class method, we attempt to find the python source.
+ """
+ if not self.output:
+ return
+
+ obj = self.GetPyData( event.GetItem() )
+ msg = str(obj)
+
+ if hasattr(obj, '__doc__'):
+ msg = msg+"\n\nDocumentation string:\n\n%s" % ( getattr(obj, '__doc__'),)
+
+ # Is it a function?
+ func = None
+
+ if hasattr(obj, "func_code"): # normal function
+ func = getattr(obj, "func_code")
+
+ elif hasattr(obj, "im_func"): # unbound class method
+ func = getattr(getattr(obj, "im_func"), "func_code")
+
+ if func: # if we found one, let's try to print the source
+ msg = msg+"\n\nFunction source:\n\n" + _sourcefinder(func)
+
+ apply(self.output, (msg,))
+
+#----------------------------------------------------------------------
+
+overview = __doc__
+
+def runTest(frame, nb, log):
+ """
+ This method is used by the wxPython Demo Framework for integrating
+ this demo with the rest.
+ """
+ thisModule = sys.modules[__name__]
+ win = wx.Frame(frame, -1, "PyTreeItemData Test")
+ split = wx.SplitterWindow(win, -1)
+ tree = pyTree(split, -1, thisModule)
+ text = wx.TextCtrl(split, -1, "", style=wx.TE_MULTILINE)
+ split.SplitVertically(tree, text, 200)
+ tree.SetOutput(text.SetValue)
+ tree.SelectItem(tree.root)
+ win.SetSize((800,500))
+ frame.otherWin = win
+ win.Show(1)
+
+
+
+#----------------------------------------------------------------------
+if __name__ == '__main__':
+
+ class MyFrame(wx.Frame):
+ """Very standard Frame class. Nothing special here!"""
+
+ def __init__(self):
+ """Make a splitter window; left a tree, right a textctrl. Wow."""
+ import __main__
+ wx.Frame.__init__(self, None, -1, "PyTreeItemData Test", size=(800,500))
+ split = wx.SplitterWindow(self, -1)
+ tree = pyTree(split, -1, __main__)
+ text = wx.TextCtrl(split, -1, "", style=wx.TE_MULTILINE)
+ split.SplitVertically(tree, text, 200)
+ tree.SetOutput(text.SetValue)
+ tree.SelectItem(tree.root)
+
+ class MyApp(wx.App):
+ """This class is even less interesting than MyFrame."""
+
+ def OnInit(self):
+ """OnInit. Boring, boring, boring!"""
+ frame = MyFrame()
+ frame.Show(True)
+ self.SetTopWindow(frame)
+ return True
+
+ app = MyApp(False)
+ app.MainLoop()
+
+
diff --git a/demo/quotes.xml b/demo/quotes.xml
new file mode 100644
index 00000000..b8f56e34
--- /dev/null
+++ b/demo/quotes.xml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+]>
+We will perhaps eventually be writing only small modules which are identified by name as they are used to build larger ones, so that devices like indentation, rather than delimiters, might become feasible for expressing local structure in the source language. Donald E. Knuth, "Structured Programming with goto Statements", Computing Surveys, Vol 6 No 4, Dec. 1974 The infinities aren't contagious except in that they often appear that way due to to their large size. Tim Peters on the IEEE 754 floating point standard, 27 Apr 1998
diff --git a/demo/run.py b/demo/run.py
new file mode 100755
index 00000000..645f0e88
--- /dev/null
+++ b/demo/run.py
@@ -0,0 +1,164 @@
+#!/usr/bin/env python
+#----------------------------------------------------------------------------
+# Name: run.py
+# Purpose: Simple framework for running individual demos
+#
+# Author: Robin Dunn
+#
+# Created: 6-March-2000
+# RCS-ID: $Id$
+# Copyright: (c) 2000 by Total Control Software
+# Licence: wxWindows license
+#----------------------------------------------------------------------------
+
+"""
+This program will load and run one of the individual demos in this
+directory within its own frame window. Just specify the module name
+on the command line.
+"""
+
+import wx
+import wx.lib.inspection
+import wx.lib.mixins.inspection
+import sys, os
+
+# stuff for debugging
+print "Python", sys.version
+print "wx.version:", wx.version()
+print "pid:", os.getpid()
+##print "executable:", sys.executable; raw_input("Press Enter...")
+
+assertMode = wx.PYAPP_ASSERT_DIALOG
+##assertMode = wx.PYAPP_ASSERT_EXCEPTION
+
+
+#----------------------------------------------------------------------------
+
+class Log:
+ def WriteText(self, text):
+ if text[-1:] == '\n':
+ text = text[:-1]
+ wx.LogMessage(text)
+ write = WriteText
+
+
+class RunDemoApp(wx.App, wx.lib.mixins.inspection.InspectionMixin):
+ def __init__(self, name, module, useShell):
+ self.name = name
+ self.demoModule = module
+ self.useShell = useShell
+ wx.App.__init__(self, redirect=False)
+
+
+ def OnInit(self):
+ wx.Log.SetActiveTarget(wx.LogStderr())
+
+ self.SetAssertMode(assertMode)
+ self.InitInspection() # for the InspectionMixin base class
+
+ frame = wx.Frame(None, -1, "RunDemo: " + self.name, pos=(50,50), size=(200,100),
+ style=wx.DEFAULT_FRAME_STYLE, name="run a sample")
+ frame.CreateStatusBar()
+
+ menuBar = wx.MenuBar()
+ menu = wx.Menu()
+ item = menu.Append(-1, "&Widget Inspector\tF6", "Show the wxPython Widget Inspection Tool")
+ self.Bind(wx.EVT_MENU, self.OnWidgetInspector, item)
+ item = menu.Append(wx.ID_EXIT, "E&xit\tCtrl-Q", "Exit demo")
+ self.Bind(wx.EVT_MENU, self.OnExitApp, item)
+ menuBar.Append(menu, "&File")
+
+ ns = {}
+ ns['wx'] = wx
+ ns['app'] = self
+ ns['module'] = self.demoModule
+ ns['frame'] = frame
+
+ frame.SetMenuBar(menuBar)
+ frame.Show(True)
+ frame.Bind(wx.EVT_CLOSE, self.OnCloseFrame)
+
+ win = self.demoModule.runTest(frame, frame, Log())
+
+ # a window will be returned if the demo does not create
+ # its own top-level window
+ if win:
+ # so set the frame to a good size for showing stuff
+ frame.SetSize((640, 480))
+ win.SetFocus()
+ self.window = win
+ ns['win'] = win
+ frect = frame.GetRect()
+
+ else:
+ # It was probably a dialog or something that is already
+ # gone, so we're done.
+ frame.Destroy()
+ return True
+
+ self.SetTopWindow(frame)
+ self.frame = frame
+ #wx.Log_SetActiveTarget(wx.LogStderr())
+ #wx.Log_SetTraceMask(wx.TraceMessages)
+
+ if self.useShell:
+ # Make a PyShell window, and position it below our test window
+ from wx import py
+ shell = py.shell.ShellFrame(None, locals=ns)
+ frect.OffsetXY(0, frect.height)
+ frect.height = 400
+ shell.SetRect(frect)
+ shell.Show()
+
+ # Hook the close event of the test window so that we close
+ # the shell at the same time
+ def CloseShell(evt):
+ if shell:
+ shell.Close()
+ evt.Skip()
+ frame.Bind(wx.EVT_CLOSE, CloseShell)
+
+ return True
+
+
+ def OnExitApp(self, evt):
+ self.frame.Close(True)
+
+
+ def OnCloseFrame(self, evt):
+ if hasattr(self, "window") and hasattr(self.window, "ShutdownDemo"):
+ self.window.ShutdownDemo()
+ evt.Skip()
+
+ def OnWidgetInspector(self, evt):
+ wx.lib.inspection.InspectionTool().Show()
+
+
+#----------------------------------------------------------------------------
+
+
+def main(argv):
+ useShell = False
+ for x in range(len(sys.argv)):
+ if sys.argv[x] in ['--shell', '-shell', '-s']:
+ useShell = True
+ del sys.argv[x]
+ break
+
+ if len(argv) < 2:
+ print "Please specify a demo module name on the command-line"
+ raise SystemExit
+
+ name, ext = os.path.splitext(argv[1])
+ module = __import__(name)
+
+
+ app = RunDemoApp(name, module, useShell)
+ app.MainLoop()
+
+
+
+if __name__ == "__main__":
+ main(sys.argv)
+
+
diff --git a/demo/snippets/__init__.py b/demo/snippets/__init__.py
new file mode 100644
index 00000000..4534d003
--- /dev/null
+++ b/demo/snippets/__init__.py
@@ -0,0 +1,13 @@
+# snippet list generation
+import os
+
+# list of snippet files
+snip_list = [x[:-3] for x in os.listdir (os.path.dirname (__file__))
+ if not x.startswith('_') and x.endswith('.py')]
+snip_list.sort()
+
+# function used by some or all snippets
+def snippet_normalize (ctx, width, height):
+ size = min(width, height)
+ ctx.scale(size, size)
+ ctx.set_line_width (0.04)
diff --git a/demo/snippets/arc.py b/demo/snippets/arc.py
new file mode 100644
index 00000000..b4e6e5db
--- /dev/null
+++ b/demo/snippets/arc.py
@@ -0,0 +1,21 @@
+xc = 0.5
+yc = 0.5
+radius = 0.4
+angle1 = 45.0 * (M_PI/180.0) #/* angles are specified */
+angle2 = 180.0 * (M_PI/180.0) #/* in radians */
+
+snippet_normalize (cr, width, height)
+
+cr.arc (xc, yc, radius, angle1, angle2)
+cr.stroke ()
+
+#/* draw helping lines */
+cr.set_source_rgba (1,0.2,0.2,0.6)
+cr.arc (xc, yc, 0.05, 0, 2*M_PI)
+cr.fill ()
+cr.set_line_width (0.03)
+cr.arc (xc, yc, radius, angle1, angle1)
+cr.line_to (xc, yc)
+cr.arc (xc, yc, radius, angle2, angle2)
+cr.line_to (xc, yc)
+cr.stroke ()
diff --git a/demo/snippets/arc_negative.py b/demo/snippets/arc_negative.py
new file mode 100644
index 00000000..1d8cd344
--- /dev/null
+++ b/demo/snippets/arc_negative.py
@@ -0,0 +1,21 @@
+xc = 0.5
+yc = 0.5
+radius = 0.4
+angle1 = 45.0 * (M_PI/180.0) #/* angles are specified */
+angle2 = 180.0 * (M_PI/180.0) #/* in radians */
+
+snippet_normalize (cr, width, height)
+
+cr.arc_negative (xc, yc, radius, angle1, angle2)
+cr.stroke ()
+
+#/* draw helping lines */
+cr.set_source_rgba (1,0.2,0.2,0.6)
+cr.arc (xc, yc, 0.05, 0, 2*M_PI)
+cr.fill ()
+cr.set_line_width (0.03)
+cr.arc (xc, yc, radius, angle1, angle1)
+cr.line_to (xc, yc)
+cr.arc (xc, yc, radius, angle2, angle2)
+cr.line_to (xc, yc)
+cr.stroke ()
diff --git a/demo/snippets/clip.py b/demo/snippets/clip.py
new file mode 100644
index 00000000..84562351
--- /dev/null
+++ b/demo/snippets/clip.py
@@ -0,0 +1,13 @@
+snippet_normalize (cr, width, height)
+
+cr.arc (0.5, 0.5, 0.3, 0, 2 * M_PI)
+cr.clip ()
+
+cr.rectangle (0, 0, 1, 1)
+cr.fill ()
+cr.set_source_rgb (0, 1, 0)
+cr.move_to (0, 0)
+cr.line_to (1, 1)
+cr.move_to (1, 0)
+cr.line_to (0, 1)
+cr.stroke ()
diff --git a/demo/snippets/clip_image.py b/demo/snippets/clip_image.py
new file mode 100644
index 00000000..39a84abf
--- /dev/null
+++ b/demo/snippets/clip_image.py
@@ -0,0 +1,13 @@
+snippet_normalize (cr, width, height)
+
+cr.arc (0.5, 0.5, 0.3, 0, 2*M_PI)
+cr.clip ()
+
+image = cairo.ImageSurface.create_from_png ("data/romedalen.png")
+w = image.get_width()
+h = image.get_height()
+
+cr.scale (1.0/w, 1.0/h)
+
+cr.set_source_surface (image, 0, 0)
+cr.paint ()
diff --git a/demo/snippets/curve_rectangle.py b/demo/snippets/curve_rectangle.py
new file mode 100644
index 00000000..eace586b
--- /dev/null
+++ b/demo/snippets/curve_rectangle.py
@@ -0,0 +1,53 @@
+#/* a custom shape, that could be wrapped in a function */
+x0 = 0.1 #/*< parameters like cairo_rectangle */
+y0 = 0.1
+rect_width = 0.8
+rect_height = 0.8
+radius = 0.4 #/*< and an approximate curvature radius */
+
+snippet_normalize (cr, width, height)
+
+x1=x0+rect_width
+y1=y0+rect_height
+#if (!rect_width || !rect_height)
+# return
+if rect_width/2
+
+
+
+
+
and this is text......
+