Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

merged 2.2 branch

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@7748 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Bryan Petty
2000-07-15 19:51:35 +00:00
parent 8a693e6e04
commit f6bcfd974e
1835 changed files with 237729 additions and 67990 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
wxPython/demo/.cvsignore Normal file
View File

@@ -0,0 +1,6 @@
*.pyc
.emacs.desktop
hangman_dict.txt
setup.bat
test.out
tmphtml.txt

64
wxPython/demo/About.py Normal file
View File

@@ -0,0 +1,64 @@
from wxPython.wx import *
from wxPython.html import *
import wxPython.lib.wxpTag
#---------------------------------------------------------------------------
class MyAboutBox(wxDialog):
text = '''
<html>
<body bgcolor="#AC76DE">
<center><table bgcolor="#458154" width="100%%" cellspacing="0"
cellpadding="0" border="1">
<tr>
<td align="center"><h1>wxPython %s</h1></td>
</tr>
</table>
<p><b>wxPython</b> is a Python extension module that
encapsulates the wxWindows GUI classes.</p>
<p>This demo shows off some of the capabilities
of <b>wxPython</b>. 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.</p>
<p><b>wxPython</b> is brought to you by <b>Robin Dunn</b> and<br>
<b>Total Control Software</b>, Copyright (c) 1997-1999.</p>
<p>
<font size="-1">Please see <i>license.txt</i> for licensing information.</font>
</p>
<p><wxp class="wxButton">
<param name="label" value="Okay">
<param name="id" value="wxID_OK">
</wxp></p>
</center>
</body>
</html>
'''
def __init__(self, parent):
wxDialog.__init__(self, parent, -1, 'About the wxPython demo',
size=wxSize(420, 380))
self.html = wxHtmlWindow(self, -1)
self.html.SetPage(self.text % wx.__version__)
self.SetAutoLayout(true)
lc = wxLayoutConstraints()
lc.top.SameAs(self, wxTop, 5)
lc.left.SameAs(self, wxLeft, 5)
lc.bottom.SameAs(self, wxBottom, 5)
lc.right.SameAs(self, wxRight, 5)
self.html.SetConstraints(lc)
self.Layout()
self.CentreOnParent(wxBOTH)
#---------------------------------------------------------------------------

130
wxPython/demo/ActiveXWrapper_Acrobat.py Normal file
View File

@@ -0,0 +1,130 @@
"""
<html><body>
This demo shows how to embed an ActiveX control in a wxPython application, (Win32 only.)
<p>
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.
<p>
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.
</body></html>
"""
from wxPython.wx import *
if wxPlatform == '__WXMSW__':
from wxPython.lib.activexwrapper import MakeActiveXClass
import win32com.client.gencache
try:
acrobat = win32com.client.gencache.EnsureModule('{CA8A9783-280D-11CF-A24D-444553540000}', 0x0, 1, 3)
except:
raise ImportError("Can't load PDF.OCX, install Acrobat 4.0")
#----------------------------------------------------------------------
class TestPanel(wxPanel):
def __init__(self, parent):
wxPanel.__init__(self, parent, -1)
self.pdf = None
sizer = wxBoxSizer(wxVERTICAL)
btnSizer = wxBoxSizer(wxHORIZONTAL)
# this function creates a new class that can be used as
# a wxWindow, but contains the given ActiveX control.
ActiveXWrapper = MakeActiveXClass(acrobat.Pdf)
# create an instance of the new class
self.pdf = ActiveXWrapper( self, -1, style=wxSUNKEN_BORDER)
sizer.Add(self.pdf, 1, wxEXPAND)
btn = wxButton(self, wxNewId(), "Open PDF File")
EVT_BUTTON(self, btn.GetId(), self.OnOpenButton)
btnSizer.Add(btn, 1, wxEXPAND|wxALL, 5)
btn = wxButton(self, wxNewId(), "<-- Previous Page")
EVT_BUTTON(self, btn.GetId(), self.OnPrevPageButton)
btnSizer.Add(btn, 1, wxEXPAND|wxALL, 5)
btn = wxButton(self, wxNewId(), "Next Page -->")
EVT_BUTTON(self, btn.GetId(), self.OnNextPageButton)
btnSizer.Add(btn, 1, wxEXPAND|wxALL, 5)
btnSizer.Add(50, -1, 2, wxEXPAND)
sizer.Add(btnSizer, 0, wxEXPAND)
self.SetSizer(sizer)
self.SetAutoLayout(true)
def __del__(self):
if self.pdf:
self.pdf.Cleanup()
self.pdf = None
def OnOpenButton(self, event):
dlg = wxFileDialog(self, wildcard="*.pdf")
if dlg.ShowModal() == wxID_OK:
wxBeginBusyCursor()
self.pdf.LoadFile(dlg.GetPath())
wxEndBusyCursor()
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)
return win
else:
dlg = wxMessageDialog(frame, 'This demo only works on MSW.',
'Sorry', wxOK | wxICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
overview = __doc__
#----------------------------------------------------------------------
if __name__ == '__main__':
class TestFrame(wxFrame):
def __init__(self):
wxFrame.__init__(self, None, -1, "ActiveX test -- Acrobat", size=(640, 480),
style=wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
self.tp = TestPanel(self, sys.stdout)
EVT_CLOSE(self, self.OnCloseWindow)
def OnCloseWindow(self, event):
self.tp.pdf.Cleanup()
self.Destroy()
app = wxPySimpleApp()
frame = TestFrame()
frame.Show(true)
app.MainLoop()

205
wxPython/demo/ActiveXWrapper_IE.py Normal file
View File

@@ -0,0 +1,205 @@
"""
<html><body>
This demo shows how to embed an ActiveX control in a wxPython
application, (Win32 only.)
<p>
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.
<p>
This demo embeds the Internet Exploer WebBrowser control, and shows
how to receive events from the COM control. (The title bar and status
bar are updated as pages change, in addition to the log messages being
shown.)
</body></html>
"""
from wxPython.wx import *
if wxPlatform == '__WXMSW__':
from wxPython.lib.activexwrapper import MakeActiveXClass
import win32com.client.gencache
try:
browserModule = win32com.client.gencache.EnsureModule("{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}", 0, 1, 1)
except:
raise ImportError("IE4 or greater does not appear to be installed.")
#----------------------------------------------------------------------
class TestPanel(wxWindow):
def __init__(self, parent, log, frame=None):
wxWindow.__init__(self, parent, -1)#, style=wxCLIP_CHILDREN)
self.ie = None
self.log = log
self.current = "http://alldunn.com/"
self.frame = frame
if frame:
self.titleBase = frame.GetTitle()
sizer = wxBoxSizer(wxVERTICAL)
btnSizer = wxBoxSizer(wxHORIZONTAL)
# 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, style=wxSUNKEN_BORDER)
#btn = wxButton(self, wxNewId(), " Open ")
#EVT_BUTTON(self, btn.GetId(), self.OnOpenButton)
#btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
btn = wxButton(self, wxNewId(), " Home ")
EVT_BUTTON(self, btn.GetId(), self.OnHomeButton)
btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
btn = wxButton(self, wxNewId(), " <-- ")
EVT_BUTTON(self, btn.GetId(), self.OnPrevPageButton)
btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
btn = wxButton(self, wxNewId(), " --> ")
EVT_BUTTON(self, btn.GetId(), self.OnNextPageButton)
btnSizer.Add(btn, 0, wxEXPAND|wxALL, 5)
txt = wxStaticText(self, -1, "Location:")
btnSizer.Add(txt, 0, wxCENTER|wxALL, 5)
self.location = wxComboBox(self, wxNewId(), "", style=wxCB_DROPDOWN)
EVT_COMBOBOX(self, self.location.GetId(), self.OnLocationSelect)
EVT_KEY_UP(self.location, self.OnLocationKey)
#EVT_CHAR(self.location, self.IgnoreReturn)
btnSizer.Add(self.location, 1, wxEXPAND|wxALL, 5)
sizer.Add(btnSizer, 0, wxEXPAND)
sizer.Add(self.ie, 1, wxEXPAND)
self.ie.Navigate(self.current)
self.location.Append(self.current)
self.SetSizer(sizer)
self.SetAutoLayout(true)
EVT_SIZE(self, self.OnSize)
def OnSize(self, evt):
self.Layout()
def __del__(self):
if self.ie:
self.ie.Cleanup()
self.ie = None
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.KeyCode() == WXK_RETURN:
URL = self.location.GetValue()
self.location.Append(URL)
self.ie.Navigate(URL)
else:
evt.Skip()
def IgnoreReturn(self, evt):
print 'IgnoreReturn'
if evt.KeyCode() != WXK_RETURN:
evt.Skip()
def OnOpenButton(self, event):
dlg = wxTextEntryDialog(self, "Open Location",
"Enter a full URL or local path",
self.current, wxOK|wxCANCEL)
dlg.CentreOnParent()
if dlg.ShowModal() == wxID_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()
# 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 OnBeforeNavigate2(self, pDisp, URL, *args):
self.log.write('OnBeforeNavigate2: %s\n' % URL)
def OnNavigateComplete2(self, pDisp, URL):
self.log.write('OnNavigateComplete2: %s\n' % URL)
self.current = URL
self.location.SetValue(URL)
def OnTitleChange(self, text):
self.log.write('OnTitleChange: %s\n' % text)
if self.frame:
self.frame.SetTitle(self.titleBase + ' -- ' + text)
def OnStatusTextChange(self, text):
self.log.write('OnStatusTextChange: %s\n' % text)
if self.frame:
self.frame.SetStatusText(text)
#----------------------------------------------------------------------
# for the demo framework...
def runTest(frame, nb, log):
if wxPlatform == '__WXMSW__':
win = TestPanel(nb, log, frame)
return win
else:
dlg = wxMessageDialog(frame, 'This demo only works on MSW.',
'Sorry', wxOK | wxICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
overview = __doc__
#----------------------------------------------------------------------
if __name__ == '__main__':
class TestFrame(wxFrame):
def __init__(self):
wxFrame.__init__(self, None, -1, "ActiveX test -- Internet Explorer",
size=(640, 480),
style=wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
self.CreateStatusBar()
self.tp = TestPanel(self, sys.stdout, self)
EVT_CLOSE(self, self.OnCloseWindow)
def OnCloseWindow(self, event):
self.tp.ie.Cleanup()
self.Destroy()
app = wxPySimpleApp()
frame = TestFrame()
frame.Show(true)
app.MainLoop()

13
wxPython/demo/ColorPanel.py Normal file
View File

@@ -0,0 +1,13 @@
from wxPython.wx import *
#---------------------------------------------------------------------------
class ColoredPanel(wxWindow):
def __init__(self, parent, color):
wxWindow.__init__(self, parent, -1,
wxDefaultPosition, wxDefaultSize, wxRAISED_BORDER)
self.SetBackgroundColour(color)
#---------------------------------------------------------------------------

285
wxPython/demo/CustomDragAndDrop.py Normal file
View File

@@ -0,0 +1,285 @@
from wxPython.wx import *
import cPickle
#----------------------------------------------------------------------
class DoodlePad(wxWindow):
def __init__(self, parent, log):
wxWindow.__init__(self, parent, -1, style=wxSUNKEN_BORDER)
self.log = log
self.SetBackgroundColour(wxWHITE)
self.lines = []
self.x = self.y = 0
self.SetCursor(wxStockCursor(wxCURSOR_PENCIL))
EVT_LEFT_DOWN(self, self.OnLeftDown)
EVT_LEFT_UP(self, self.OnLeftUp)
EVT_RIGHT_UP(self, self.OnRightUp)
EVT_MOTION(self, self.OnMotion)
EVT_PAINT(self, self.OnPaint)
def OnPaint(self, event):
dc = wxPaintDC(self)
self.DrawSavedLines(dc)
def DrawSavedLines(self, dc):
dc.BeginDrawing()
dc.SetPen(wxPen(wxBLUE, 3))
for line in self.lines:
for coords in line:
apply(dc.DrawLine, coords)
dc.EndDrawing()
def OnLeftDown(self, event):
if event.ControlDown():
self.StartDragOpperation()
else:
self.curLine = []
self.x, self.y = event.GetPositionTuple()
self.CaptureMouse()
def OnLeftUp(self, event):
self.lines.append(self.curLine)
self.curLine = []
self.ReleaseMouse()
def OnRightUp(self, event):
self.lines = []
self.Refresh()
def OnMotion(self, event):
if event.Dragging() and not event.ControlDown():
dc = wxClientDC(self)
dc.BeginDrawing()
dc.SetPen(wxPen(wxBLUE, 3))
coords = (self.x, self.y) + event.GetPositionTuple()
self.curLine.append(coords)
apply(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 = wxCustomDataObject(wxCustomDataFormat("DoodleLines"))
ldata.SetData(linesdata)
# Also create a Bitmap version of the drawing
size = self.GetSize()
bmp = wxEmptyBitmap(size.width, size.height)
dc = wxMemoryDC()
dc.SelectObject(bmp)
dc.SetBackground(wxWHITE_BRUSH)
dc.Clear()
self.DrawSavedLines(dc)
dc.SelectObject(wxNullBitmap)
# Now make a data object for the bitmap and also a composite
# data object holding both of the others.
bdata = wxBitmapDataObject(bmp)
data = wxDataObjectComposite()
data.Add(ldata)
data.Add(bdata)
# And finally, create the drop source and begin the drag
# and drop opperation
dropSource = wxDropSource(self)
dropSource.SetData(data)
self.log.WriteText("Begining DragDrop\n")
result = dropSource.DoDragDrop()
self.log.WriteText("DragDrop completed: %d\n" % result)
#----------------------------------------------------------------------
class DoodleDropTarget(wxPyDropTarget):
def __init__(self, window, log):
wxPyDropTarget.__init__(self)
self.log = log
self.dv = window
# specify the type of data we will accept
self.data = wxCustomDataObject(wxCustomDataFormat("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 wxDragCopy
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))
# return wxDragCopy
# 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 out 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)
return d
class DoodleViewer(wxWindow):
def __init__(self, parent, log):
wxWindow.__init__(self, parent, -1, style=wxSUNKEN_BORDER)
self.log = log
self.SetBackgroundColour(wxWHITE)
self.lines = []
self.x = self.y = 0
dt = DoodleDropTarget(self, log)
self.SetDropTarget(dt)
EVT_PAINT(self, self.OnPaint)
def SetLines(self, lines):
self.lines = lines
self.Refresh()
def OnPaint(self, event):
dc = wxPaintDC(self)
self.DrawSavedLines(dc)
def DrawSavedLines(self, dc):
dc.BeginDrawing()
dc.SetPen(wxPen(wxRED, 3))
for line in self.lines:
for coords in line:
apply(dc.DrawLine, coords)
dc.EndDrawing()
#----------------------------------------------------------------------
class CustomDnDPanel(wxPanel):
def __init__(self, parent, log):
wxPanel.__init__(self, parent, -1)
self.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD, false))
sizer = wxBoxSizer(wxHORIZONTAL)
text = wxStaticText(self, -1,
"Draw a little picture in this window\n"
"then Ctrl-Drag it to the lower \n"
"window or to another application\n"
"that accepts BMP's as a drop target.\n\n"
"The lower window is accepting a\n"
"custom data type that is a pickled\n"
"Python list of lines data.")
sizer.Add(text, 1, wxALL, 10)
insizer = wxBoxSizer(wxVERTICAL)
insizer.Add(DoodlePad(self, log), 1, wxEXPAND|wxALL, 5)
insizer.Add(DoodleViewer(self, log), 1, wxEXPAND|wxALL, 5)
sizer.Add(insizer, 1, wxEXPAND)
self.SetAutoLayout(true)
self.SetSizer(sizer)
#----------------------------------------------------------------------
#----------------------------------------------------------------------
class TestPanel(wxPanel):
def __init__(self, parent, log):
wxPanel.__init__(self, parent, -1)
self.SetAutoLayout(true)
sizer = wxBoxSizer(wxVERTICAL)
msg = "Custom Drag-And-Drop"
text = wxStaticText(self, -1, "", style=wxALIGN_CENTRE)
text.SetFont(wxFont(24, wxSWISS, wxNORMAL, wxBOLD, false))
text.SetLabel(msg)
w,h = text.GetTextExtent(msg)
text.SetSize(wxSize(w,h+1))
text.SetForegroundColour(wxBLUE)
sizer.Add(text, 0, wxEXPAND|wxALL, 5)
sizer.Add(wxStaticLine(self, -1), 0, wxEXPAND)
sizer.Add(CustomDnDPanel(self, log), 1, wxEXPAND)
self.SetSizer(sizer)
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestPanel(nb, log)
return win
if __name__ == '__main__':
import sys
class DummyLog:
def WriteText(self, text):
sys.stdout.write(text)
class TestApp(wxApp):
def OnInit(self):
self.MakeFrame()
return true
def MakeFrame(self, event=None):
frame = wxFrame(None, -1, "Custom Drag and Drop", size=(550,400))
menu = wxMenu()
menu.Append(6543, "Window")
mb = wxMenuBar()
mb.Append(menu, "New")
frame.SetMenuBar(mb)
EVT_MENU(frame, 6543, self.MakeFrame)
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 wxDataObjectComposite and the rest is handled by the framework.
"""

127
wxPython/demo/DialogUnits.py Normal file
View File

@@ -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 all of the wxPython GUI package
from wxPython.wx import *
#---------------------------------------------------------------------------
## Create a new frame class, derived from the wxPython Frame.
class MyFrame(wxFrame):
def __init__(self, parent, id, title):
# First, call the base class' __init__ method to create the frame
wxFrame.__init__(self, parent, id, title,
wxPoint(100, 100), wxSize(160, 100))
# Associate some events with methods of this class
EVT_SIZE(self, self.OnSize)
EVT_MOVE(self, self.OnMove)
EVT_CLOSE(self, self.OnCloseWindow)
# Add a panel and some controls to display the size and position
panel = wxPanel(self, -1)
wxStaticText(panel, -1, "Size:",
wxDLG_PNT(panel, wxPoint(4, 4)), wxDefaultSize)
wxStaticText(panel, -1, "Pos:",
wxDLG_PNT(panel, wxPoint(4, 16)), wxDefaultSize)
self.sizeCtrl = wxTextCtrl(panel, -1, "",
wxDLG_PNT(panel, wxPoint(24, 4)),
wxDLG_SZE(panel, wxSize(36, -1)),
wxTE_READONLY)
self.posCtrl = wxTextCtrl(panel, -1, "",
wxDLG_PNT(panel, wxPoint(24, 16)),
wxDLG_SZE(panel, wxSize(36, -1)),
wxTE_READONLY)
#print wxDLG_PNT(panel, wxPoint(24, 4)), wxDLG_SZE(panel, wxSize(36, -1))
#print wxDLG_PNT(panel, wxPoint(24, 16)),wxDLG_SZE(panel, wxSize(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(wxApp):
# wxWindows calls this method to initialize the application
def OnInit(self):
# Create an instance of our customized Frame class
frame = MyFrame(NULL, -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.
"""
#----------------------------------------------------------------------------
#

196
wxPython/demo/DragAndDrop.py Normal file
View File

@@ -0,0 +1,196 @@
from wxPython.wx import *
#----------------------------------------------------------------------
class ClipTextPanel(wxPanel):
def __init__(self, parent, log):
wxPanel.__init__(self, parent, -1)
self.log = log
#self.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD, false))
sizer = wxBoxSizer(wxVERTICAL)
sizer.Add(wxStaticText(self, -1,
"Copy/Paste text to/from\n"
"this window and other apps"), 0, wxEXPAND|wxALL, 2)
self.text = wxTextCtrl(self, -1, "", style=wxTE_MULTILINE|wxHSCROLL)
sizer.Add(self.text, 1, wxEXPAND)
hsz = wxBoxSizer(wxHORIZONTAL)
hsz.Add(wxButton(self, 6050, " Copy "), 1, wxEXPAND|wxALL, 2)
hsz.Add(wxButton(self, 6051, " Paste "), 1, wxEXPAND|wxALL, 2)
sizer.Add(hsz, 0, wxEXPAND)
sizer.Add(wxButton(self, 6052, " Copy Bitmap "), 0, wxEXPAND|wxALL, 2)
EVT_BUTTON(self, 6050, self.OnCopy)
EVT_BUTTON(self, 6051, self.OnPaste)
EVT_BUTTON(self, 6052, self.OnCopyBitmap)
self.SetAutoLayout(true)
self.SetSizer(sizer)
def OnCopy(self, evt):
self.do = wxTextDataObject()
self.do.SetText(self.text.GetValue())
wxTheClipboard.Open()
wxTheClipboard.SetData(self.do)
wxTheClipboard.Close()
def OnPaste(self, evt):
do = wxTextDataObject()
wxTheClipboard.Open()
success = wxTheClipboard.GetData(do)
wxTheClipboard.Close()
if success:
self.text.SetValue(do.GetText())
else:
wxMessageBox("There is no data in the clipboard in the required format",
"Error")
def OnCopyBitmap(self, evt):
dlg = wxFileDialog(self, "Choose a bitmap to copy", wildcard="*.bmp")
if dlg.ShowModal() == wxID_OK:
bmp = wxBitmap(dlg.GetFilename(), wxBITMAP_TYPE_BMP)
bmpdo = wxBitmapDataObject(bmp)
wxTheClipboard.Open()
wxTheClipboard.SetData(bmpdo)
wxTheClipboard.Close()
wxMessageBox("The bitmap is now in the Clipboard. Switch to a graphics\n"
"editor and try pasting it in...")
dlg.Destroy()
#----------------------------------------------------------------------
class OtherDropTarget(wxPyDropTarget):
def __init__(self, window, log):
wxPyDropTarget.__init__(self)
self.log = log
self.do = wxFileDataObject()
self.SetDataObject(self.do)
def OnEnter(self, x, y, d):
self.log.WriteText("OnEnter: %d, %d, %d\n" % (x, y, d))
return wxDragCopy
#def OnDragOver(self, x, y, d):
# self.log.WriteText("OnDragOver: %d, %d, %d\n" % (x, y, d))
# return wxDragCopy
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(wxFileDropTarget):
def __init__(self, window, log):
wxFileDropTarget.__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 FileDropPanel(wxPanel):
def __init__(self, parent, log):
wxPanel.__init__(self, parent, -1)
#self.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD, false))
sizer = wxBoxSizer(wxVERTICAL)
sizer.Add(wxStaticText(self, -1, " \nDrag some files here:"),
0, wxEXPAND|wxALL, 2)
self.text = wxTextCtrl(self, -1, "",
style = wxTE_MULTILINE|wxHSCROLL|wxTE_READONLY)
dt = MyFileDropTarget(self, log)
self.text.SetDropTarget(dt)
sizer.Add(self.text, 1, wxEXPAND)
self.SetAutoLayout(true)
self.SetSizer(sizer)
def WriteText(self, text):
self.text.WriteText(text)
def SetInsertionPointEnd(self):
self.text.SetInsertionPointEnd()
#----------------------------------------------------------------------
#----------------------------------------------------------------------
class TestPanel(wxPanel):
def __init__(self, parent, log):
wxPanel.__init__(self, parent, -1)
self.SetAutoLayout(true)
outsideSizer = wxBoxSizer(wxVERTICAL)
msg = "Clipboard / Drag-And-Drop"
text = wxStaticText(self, -1, "", style=wxALIGN_CENTRE)
text.SetFont(wxFont(24, wxSWISS, wxNORMAL, wxBOLD, false))
text.SetLabel(msg)
w,h = text.GetTextExtent(msg)
text.SetSize(wxSize(w,h+1))
text.SetForegroundColour(wxBLUE)
outsideSizer.Add(text, 0, wxEXPAND|wxALL, 5)
outsideSizer.Add(wxStaticLine(self, -1), 0, wxEXPAND)
inSizer = wxBoxSizer(wxHORIZONTAL)
inSizer.Add(ClipTextPanel(self, log), 1, wxEXPAND)
inSizer.Add(FileDropPanel(self, log), 1, wxEXPAND)
outsideSizer.Add(inSizer, 1, wxEXPAND)
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.
"""

47
wxPython/demo/FileBrowseButton.py Normal file
View File

@@ -0,0 +1,47 @@
from wxPython.wx import *
from wxPython.lib.filebrowsebutton import FileBrowseButton, FileBrowseButtonWithHistory
#----------------------------------------------------------------------
class TestPanel(wxPanel):
def __init__(self, parent, ID, log):
wxPanel.__init__(self, parent, ID)
self.log = log
self.fbb = FileBrowseButton(self, -1, wxPoint(20,20), wxSize(450, -1),
changeCallback = self.fbbCallback)
self.fbbh = FileBrowseButtonWithHistory(self, -1, wxPoint(20, 50),
wxSize(450, -1),
#changeCallback = self.fbbhCallback
)
self.fbbh.SetHistory(['You', 'can', 'put', 'some', 'file', 'names', 'here'])
def fbbCallback(self, evt):
self.log.write('FileBrowseButton: %s\n' % evt.GetString())
def fbbhCallback(self, evt):
if hasattr(self, 'fbbh'):
value = evt.GetString()
self.log.write('FileBrowseButtonWithHistory: %s\n' % value)
history = self.fbbh.GetHistory()
history.append(value)
self.fbbh.SetHistory(history)
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestPanel(nb, -1, log)
return win
#----------------------------------------------------------------------
overview = FileBrowseButton.__doc__

61
wxPython/demo/FontEnumerator.py Normal file
View File

@@ -0,0 +1,61 @@
from wxPython.wx import *
#----------------------------------------------------------------------
## class MyFontEnumerator(wxFontEnumerator):
## def __init__(self, list):
## wxFontEnumerator.__init__(self)
## self.list = list
## def OnFacename(self, face):
## self.list.append(face)
## return true
class TestPanel(wxPanel):
def __init__(self, parent, log):
wxPanel.__init__(self, parent, -1)
## list = []
## e = MyFontEnumerator(list)
## e.EnumerateFacenames()
e = wxFontEnumerator()
e.EnumerateFacenames()
list = e.GetFacenames()
list.sort()
wxStaticText(self, -1, "Face names:", wxPoint(15, 50), wxSize(65, 18))
self.lb1 = wxListBox(self, 60, wxPoint(80, 50), wxSize(200, 250),
list, wxLB_SINGLE)
self.lb1.SetSelection(0)
#----------------------------------------------------------------------
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.
"""

92
wxPython/demo/GenericButtons.py Normal file
View File

@@ -0,0 +1,92 @@
from wxPython.wx import *
from wxPython.lib.buttons import wxGenButton, wxGenBitmapButton, \
wxGenToggleButton, wxGenBitmapToggleButton
#----------------------------------------------------------------------
class TestPanel(wxPanel):
def __init__(self, parent, log):
wxPanel.__init__(self, parent, -1)
self.log = log
b = wxButton(self, -1, "A real button", (10,10))
b.SetDefault()
EVT_BUTTON(self, b.GetId(), self.OnButton)
b = wxButton(self, -1, "non-default", (140, 10))
EVT_BUTTON(self, b.GetId(), self.OnButton)
#wxTextCtrl(self, -1, "", (10,40))
b = wxGenButton(self, -1, 'Hello', (10,65))
EVT_BUTTON(self, b.GetId(), self.OnButton)
b = wxGenButton(self, -1, 'disabled', (140,65))
EVT_BUTTON(self, b.GetId(), self.OnButton)
b.Enable(false)
b = wxGenButton(self, -1, 'bigger', (250,50))
EVT_BUTTON(self, b.GetId(), self.OnButton)
b.SetFont(wxFont(20, wxSWISS, wxNORMAL, wxBOLD, false))
b.SetBezelWidth(5)
b.SetBestSize()
b.SetBackgroundColour(wxNamedColour("Navy"))
b.SetForegroundColour(wxWHITE)
#b.SetUseFocusIndicator(false)
bmp = wxBitmap('bitmaps/test2.bmp', wxBITMAP_TYPE_BMP)
b = wxGenBitmapButton(self, -1, bmp, (10, 130))
EVT_BUTTON(self, b.GetId(), self.OnButton)
b = wxGenBitmapButton(self, -1, None, (140, 130))
EVT_BUTTON(self, b.GetId(), self.OnButton)
bmp = wxBitmap('bitmaps/lb1.bmp', wxBITMAP_TYPE_BMP)
mask = wxMaskColour(bmp, wxBLUE)
bmp.SetMask(mask)
b.SetBitmapLabel(bmp)
bmp = wxBitmap('bitmaps/lb2.bmp', wxBITMAP_TYPE_BMP)
mask = wxMaskColour(bmp, wxBLUE)
bmp.SetMask(mask)
b.SetBitmapSelected(bmp)
b.SetBestSize()
b = wxGenToggleButton(self, -1, "Toggle Button", (10, 230))
EVT_BUTTON(self, b.GetId(), self.OnToggleButton)
b = wxGenBitmapToggleButton(self, -1, None, (140, 230))
EVT_BUTTON(self, b.GetId(), self.OnToggleButton)
bmp = wxBitmap('bitmaps/lb1.bmp', wxBITMAP_TYPE_BMP)
mask = wxMaskColour(bmp, wxBLUE)
bmp.SetMask(mask)
b.SetBitmapLabel(bmp)
bmp = wxBitmap('bitmaps/lb2.bmp', wxBITMAP_TYPE_BMP)
mask = wxMaskColour(bmp, wxBLUE)
bmp.SetMask(mask)
b.SetBitmapSelected(bmp)
b.SetToggle(true)
b.SetBestSize()
def OnButton(self, event):
self.log.WriteText("Button Clicked: %d\n" % event.GetId())
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
#----------------------------------------------------------------------
import wxPython.lib.buttons
overview = wxPython.lib.buttons.__doc__

153
wxPython/demo/GridCustTable.py Normal file
View File

@@ -0,0 +1,153 @@
from wxPython.wx import *
from wxPython.grid import *
import string
#---------------------------------------------------------------------------
class CustomDataTable(wxPyGridTableBase):
"""
"""
def __init__(self, log):
wxPyGridTableBase.__init__(self)
self.log = log
self.colLabels = ['ID', 'Description', 'Severity', 'Priority', 'Platform',
'Opened?', 'Fixed?', 'Tested?']
self.dataTypes = [wxGRID_VALUE_NUMBER,
wxGRID_VALUE_STRING,
wxGRID_VALUE_CHOICE + ':only in a million years!,wish list,minor,normal,major,critical',
wxGRID_VALUE_NUMBER + ':1,5',
wxGRID_VALUE_CHOICE + ':all,MSW,GTK,other',
wxGRID_VALUE_BOOL,
wxGRID_VALUE_BOOL,
wxGRID_VALUE_BOOL]
self.data = [
[1010, "The foo doesn't bar", "major", 1, 'MSW', 1, 1, 1],
[1011, "I've got a wicket in my wocket", "wish list", 2, 'other', 0, 0, 0],
[1012, "Rectangle() returns a triangle", "critical", 5, 'all', 0, 0, 0]
]
#--------------------------------------------------
# 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):
return not self.data[row][col]
# 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):
try:
self.data[row][col] = value
except IndexError:
# add a new row
self.data.append([''] * self.GetNumberCols())
self.SetValue(row, col, value)
# tell the grid we've added a row
msg = wxGridTableMessage(self, # The table
wxGRIDTABLE_NOTIFY_ROWS_APPENDED, # what we did to it
1) # how many
self.GetView().ProcessTableMessage(msg)
#--------------------------------------------------
# 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
# nativly 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 = string.split(self.dataTypes[col], ':')[0]
if typeName == colType:
return true
else:
return false
def CanSetValueAs(self, row, col, typeName):
return self.CanGetValueAs(row, col, typeName)
#---------------------------------------------------------------------------
class CustTableGrid(wxGrid):
def __init__(self, parent, log):
wxGrid.__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)
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(wxFrame):
def __init__(self, parent, log):
wxFrame.__init__(self, parent, -1, "Custom Table, data driven Grid Demo", size=(640,480))
grid = CustTableGrid(self, log)
#---------------------------------------------------------------------------
if __name__ == '__main__':
import sys
app = wxPySimpleApp()
frame = TestFrame(None, sys.stdout)
frame.Show(true)
app.MainLoop()
#---------------------------------------------------------------------------

62
wxPython/demo/GridEnterHandler.py Normal file
View File

@@ -0,0 +1,62 @@
from wxPython.wx import *
from wxPython.grid import *
#---------------------------------------------------------------------------
class NewEnterHandlingGrid(wxGrid):
def __init__(self, parent, log):
wxGrid.__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)
EVT_KEY_DOWN(self, self.OnKeyDown)
def OnKeyDown(self, evt):
if evt.KeyCode() != 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(wxFrame):
def __init__(self, parent, log):
wxFrame.__init__(self, parent, -1, "Simple Grid Demo", size=(640,480))
grid = NewEnterHandlingGrid(self, log)
#---------------------------------------------------------------------------
if __name__ == '__main__':
import sys
app = wxPySimpleApp()
frame = TestFrame(None, sys.stdout)
frame.Show(true)
app.MainLoop()
#---------------------------------------------------------------------------

71
wxPython/demo/GridHugeTable.py Normal file
View File

@@ -0,0 +1,71 @@
from wxPython.wx import *
from wxPython.grid import *
#---------------------------------------------------------------------------
class HugeTable(wxPyGridTableBase):
"""
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 __init__(self, log):
wxPyGridTableBase.__init__(self)
self.log = log
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(wxGrid):
def __init__(self, parent, log):
wxGrid.__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)
#---------------------------------------------------------------------------
class TestFrame(wxFrame):
def __init__(self, parent, log):
wxFrame.__init__(self, parent, -1, "Huge (virtual) Table Demo", size=(640,480))
grid = HugeTableGrid(self, log)
#---------------------------------------------------------------------------
if __name__ == '__main__':
import sys
app = wxPySimpleApp()
frame = TestFrame(None, sys.stdout)
frame.Show(true)
app.MainLoop()
#---------------------------------------------------------------------------

153
wxPython/demo/GridSimple.py Normal file
View File

@@ -0,0 +1,153 @@
from wxPython.wx import *
from wxPython.grid import *
#---------------------------------------------------------------------------
class SimpleGrid(wxGrid):
def __init__(self, parent, log):
wxGrid.__init__(self, parent, -1)
self.log = log
self.CreateGrid(25, 25)
# 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.SetCellFont(0, 0, wxFont(12, wxROMAN, wxITALIC, wxNORMAL))
self.SetCellTextColour(1, 1, wxRED)
self.SetCellBackgroundColour(2, 2, wxCYAN)
# attribute objects let you keep a set of formatting values
# in one spot, and reuse them if needed
attr = wxGridCellAttr()
attr.SetTextColour(wxBLACK)
attr.SetBackgroundColour(wxRED)
attr.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD))
# you can set cell attributes for the whole row (or column)
self.SetRowAttr(5, attr)
# test all the events
EVT_GRID_CELL_LEFT_CLICK(self, self.OnCellLeftClick)
EVT_GRID_CELL_RIGHT_CLICK(self, self.OnCellRightClick)
EVT_GRID_CELL_LEFT_DCLICK(self, self.OnCellLeftDClick)
EVT_GRID_CELL_RIGHT_DCLICK(self, self.OnCellRightDClick)
EVT_GRID_LABEL_LEFT_CLICK(self, self.OnLabelLeftClick)
EVT_GRID_LABEL_RIGHT_CLICK(self, self.OnLabelRightClick)
EVT_GRID_LABEL_LEFT_DCLICK(self, self.OnLabelLeftDClick)
EVT_GRID_LABEL_RIGHT_DCLICK(self, self.OnLabelRightDClick)
EVT_GRID_ROW_SIZE(self, self.OnRowSize)
EVT_GRID_COL_SIZE(self, self.OnColSize)
EVT_GRID_RANGE_SELECT(self, self.OnRangeSelect)
EVT_GRID_CELL_CHANGE(self, self.OnCellChange)
EVT_GRID_SELECT_CELL(self, self.OnSelectCell)
EVT_GRID_EDITOR_SHOWN(self, self.OnEditorShown)
EVT_GRID_EDITOR_HIDDEN(self, self.OnEditorHidden)
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 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():
self.log.write("OnRangeSelect: top-left %s, bottom-right %s\n" %
(evt.GetTopLeftCoords(), evt.GetBottomRightCoords()))
evt.Skip()
def OnCellChange(self, evt):
self.log.write("OnCellChange: (%d,%d) %s\n" %
(evt.GetRow(), evt.GetCol(), evt.GetPosition()))
evt.Skip()
def OnSelectCell(self, evt):
self.log.write("OnSelectCell: (%d,%d) %s\n" %
(evt.GetRow(), evt.GetCol(), evt.GetPosition()))
evt.Skip()
def OnEditorShown(self, evt):
self.log.write("OnEditorShown: (%d,%d) %s\n" %
(evt.GetRow(), evt.GetCol(), evt.GetPosition()))
evt.Skip()
def OnEditorHidden(self, evt):
self.log.write("OnEditorHidden: (%d,%d) %s\n" %
(evt.GetRow(), evt.GetCol(), evt.GetPosition()))
evt.Skip()
#---------------------------------------------------------------------------
class TestFrame(wxFrame):
def __init__(self, parent, log):
wxFrame.__init__(self, parent, -1, "Simple Grid Demo", size=(640,480))
grid = SimpleGrid(self, log)
#---------------------------------------------------------------------------
if __name__ == '__main__':
import sys
app = wxPySimpleApp()
frame = TestFrame(None, sys.stdout)
frame.Show(true)
app.MainLoop()
#---------------------------------------------------------------------------

181
wxPython/demo/GridStdEdRend.py Normal file
View File

@@ -0,0 +1,181 @@
from wxPython.wx import *
from wxPython.grid import *
import string, random
#---------------------------------------------------------------------------
class MyCustomRenderer(wxPyGridCellRenderer):
def __init__(self):
wxPyGridCellRenderer.__init__(self)
def Draw(self, grid, attr, dc, rect, row, col, isSelected):
dc.SetBackgroundMode(wxSOLID)
dc.SetBrush(wxBrush(wxBLACK, wxSOLID))
dc.SetPen(wxTRANSPARENT_PEN)
dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height)
dc.SetBackgroundMode(wxTRANSPARENT)
dc.SetFont(attr.GetFont())
text = grid.GetCellValue(row, col)
colors = [wxRED, wxWHITE, wxCYAN]
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 wxSize(w, h)
def Clone(self):
return MyCustomRenderer()
#---------------------------------------------------------------------------
rendererDemoData = [
('wxGridCellStringRenderer\n(the default)', 'this is a text value', wxGridCellStringRenderer, ()),
('wxGridCellNumberRenderer', '12345', wxGridCellNumberRenderer, ()),
('wxGridCellFloatRenderer', '1234.5678', wxGridCellFloatRenderer, (6,2)),
('wxGridCellBoolRenderer', '1', wxGridCellBoolRenderer, ()),
('MyCustomRenderer', 'This is my renderer', MyCustomRenderer, ()),
]
editorDemoData = [
('wxGridCellTextEditor\n(the default)', 'Here is some more text', wxGridCellTextEditor, ()),
('wxGridCellNumberEditor\nwith min,max', '101', wxGridCellNumberEditor, (5, 10005)),
('wxGridCellNumberEditor\nwithout bounds', '101', wxGridCellNumberEditor, ()),
('wxGridCellFloatEditor', '1234.5678', wxGridCellFloatEditor, ()),
('wxGridCellBoolEditor', '1', wxGridCellBoolEditor, ()),
('wxGridCellChoiceEditor', 'one', wxGridCellChoiceEditor, (['one', 'two', 'three', 'four',
'kick', 'Microsoft', 'out the',
'door'], false)),
]
comboDemoData = [
('wxGridCellNumberRenderer\nwxGridCellNumberEditor', '20792', wxGridCellNumberRenderer, wxGridCellNumberEditor),
('wxGridCellBoolRenderer\nwxGridCellBoolEditor', '1', wxGridCellBoolRenderer, wxGridCellBoolEditor),
]
class EditorsAndRenderersGrid(wxGrid):
def __init__(self, parent, log):
wxGrid.__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 = apply(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 = apply(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 = apply(edClass, ()) #args)
renderer = apply(renClass, ()) #args)
self.SetCellEditor(row, renCol+1, editor)
self.SetCellRenderer(row, renCol+1, renderer)
row = row + 2
font = self.GetFont()
font.SetWeight(wxBOLD)
attr = wxGridCellAttr()
attr.SetFont(font)
attr.SetBackgroundColour(wxLIGHT_GREY)
attr.SetReadOnly(true)
attr.SetAlignment(wxRIGHT, -1)
self.SetColAttr(renCol, attr)
self.SetColAttr(edCol, attr)
# There is a bug in wxGTK for this method...
if wxPlatform != '__WXGTK__':
self.AutoSizeColumns(true)
self.AutoSizeRows(true)
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(wxFrame):
def __init__(self, parent, log):
wxFrame.__init__(self, parent, -1, "Editors and Renderers Demo", size=(640,480))
grid = EditorsAndRenderersGrid(self, log)
#---------------------------------------------------------------------------
if __name__ == '__main__':
import sys
app = wxPySimpleApp()
frame = TestFrame(None, sys.stdout)
frame.Show(true)
app.MainLoop()
#---------------------------------------------------------------------------

62
wxPython/demo/Layoutf.py Normal file
View File

@@ -0,0 +1,62 @@
from wxPython.wx import *
from wxPython.lib.layoutf import Layoutf
#---------------------------------------------------------------------------
class TestLayoutf(wxPanel):
def __init__(self, parent):
wxPanel.__init__(self, parent, -1)
self.SetAutoLayout(true)
EVT_BUTTON(self, 100, self.OnButton)
self.panelA = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
self.panelA.SetBackgroundColour(wxBLUE)
self.panelA.SetConstraints(Layoutf('t=t10#1;l=l10#1;b=b10#1;r%r50#1',(self,)))
self.panelB = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
self.panelB.SetBackgroundColour(wxRED)
self.panelB.SetConstraints(Layoutf('t=t10#1;r=r10#1;b%b30#1;l>10#2', (self,self.panelA)))
self.panelC = wxWindow(self, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
self.panelC.SetBackgroundColour(wxWHITE)
self.panelC.SetConstraints(Layoutf('t_10#3;r=r10#1;b=b10#1;l>10#2', (self,self.panelA,self.panelB)))
b = wxButton(self.panelA, 100, ' Panel A ')
b.SetConstraints(Layoutf('X=X#1;Y=Y#1;h*;w%w50#1', (self.panelA,)))
b = wxButton(self.panelB, 100, ' Panel B ')
b.SetConstraints(Layoutf('t=t2#1;r=r4#1;h*;w*', (self.panelB,)))
self.panelD = wxWindow(self.panelC, -1, wxPyDefaultPosition, wxPyDefaultSize, wxSIMPLE_BORDER)
self.panelD.SetBackgroundColour(wxGREEN)
self.panelD.SetConstraints(Layoutf('b%h50#1;r%w50#1;h=h#2;w=w#2', (self.panelC, b)))
b = wxButton(self.panelC, 100, ' Panel C ')
b.SetConstraints(Layoutf('t_#1;l>#1;h*;w*', (self.panelD,)))
wxStaticText(self.panelD, -1, "Panel D", wxPoint(4, 4)).SetBackgroundColour(wxGREEN)
def OnButton(self, event):
wxBell()
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestLayoutf(nb)
return win
#---------------------------------------------------------------------------
overview = Layoutf.__doc__

53
wxPython/demo/MDIDemo.py Normal file
View File

@@ -0,0 +1,53 @@
#!/usr/bin/env python
from wxPython.wx import *
from wxScrolledWindow import MyCanvas
#----------------------------------------------------------------------
class MyParentFrame(wxMDIParentFrame):
def __init__(self):
wxMDIParentFrame.__init__(self, None, -1, "MDI Parent", size=(600,400))
self.winCount = 0
menu = wxMenu()
menu.Append(5000, "&New Window")
menu.AppendSeparator()
menu.Append(5001, "E&xit")
menubar = wxMenuBar()
menubar.Append(menu, "&File")
self.SetMenuBar(menubar)
#self.CreateStatusBar()
EVT_MENU(self, 5000, self.OnNewWindow)
EVT_MENU(self, 5001, self.OnExit)
def OnExit(self, evt):
self.Close(true)
def OnNewWindow(self, evt):
self.winCount = self.winCount + 1
win = wxMDIChildFrame(self, -1, "Child Window: %d" % self.winCount)
canvas = MyCanvas(win)
win.Show(true)
#----------------------------------------------------------------------
class MyApp(wxApp):
def OnInit(self):
frame = MyParentFrame()
frame.Show(true)
self.SetTopWindow(frame)
return true
app = MyApp(0)
app.MainLoop()

482
wxPython/demo/Main.py Normal file
View File

@@ -0,0 +1,482 @@
#!/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
#----------------------------------------------------------------------------
import sys, os
from wxPython.wx import *
from wxPython.lib.splashscreen import SplashScreen
from wxPython.html import wxHtmlWindow
#---------------------------------------------------------------------------
_treeList = [
('New since last release', ['PyShellWindow',
]),
('Managed Windows', ['wxFrame', 'wxDialog', 'wxMiniFrame']),
('Non-Managed Windows', ['wxGrid', 'wxSashWindow',
'wxScrolledWindow', 'wxSplitterWindow',
'wxStatusBar', 'wxNotebook',
'wxHtmlWindow',
'wxStyledTextCtrl_1', 'wxStyledTextCtrl_2',]),
('Common Dialogs', ['wxColourDialog', 'wxDirDialog', 'wxFileDialog',
'wxSingleChoiceDialog', 'wxTextEntryDialog',
'wxFontDialog', 'wxPageSetupDialog', 'wxPrintDialog',
'wxMessageDialog', 'wxProgressDialog']),
('Controls', ['wxButton', 'wxCheckBox', 'wxCheckListBox', 'wxChoice',
'wxComboBox', 'wxGauge', 'wxListBox', 'wxListCtrl', 'wxTextCtrl',
'wxTreeCtrl', 'wxSpinButton', 'wxSpinCtrl', 'wxStaticText',
'wxStaticBitmap', 'wxRadioBox', 'wxSlider', 'wxToolBar',
'wxCalendarCtrl',
]),
('Window Layout', ['wxLayoutConstraints', 'Sizers', 'OldSizers']),
('Miscellaneous', [ 'DragAndDrop', 'CustomDragAndDrop', 'FontEnumerator',
'wxTimer', 'wxValidator', 'wxGLCanvas', 'DialogUnits',
'wxImage', 'wxMask', 'PrintFramework', 'wxOGL',
'PythonEvents', 'Threads',
'ActiveXWrapper_Acrobat', 'ActiveXWrapper_IE',
'wxDragImage', 'PyShellWindow',
]),
('wxPython Library', ['Layoutf', 'wxScrolledMessageDialog',
'wxMultipleChoiceDialog', 'wxPlotCanvas', 'wxFloatBar',
'PyShell', 'wxCalendar', 'wxMVCTree', 'wxVTKRenderWindow',
'FileBrowseButton', 'GenericButtons', 'wxEditor']),
('Cool Contribs', ['pyTree', 'hangman', 'SlashDot', 'XMLtreeview']),
]
#---------------------------------------------------------------------------
class wxPythonDemo(wxFrame):
def __init__(self, parent, id, title):
wxFrame.__init__(self, parent, -1, title, size = (800, 600),
style=wxDEFAULT_FRAME_STYLE|wxNO_FULL_REPAINT_ON_RESIZE)
self.cwd = os.getcwd()
if wxPlatform == '__WXMSW__':
self.icon = wxIcon('bitmaps/mondrian.ico', wxBITMAP_TYPE_ICO)
self.SetIcon(self.icon)
self.otherWin = None
EVT_IDLE(self, self.OnIdle)
EVT_CLOSE(self, self.OnCloseWindow)
self.Centre(wxBOTH)
self.CreateStatusBar(1, wxST_SIZEGRIP)
splitter = wxSplitterWindow(self, -1, style=wxNO_3D|wxSP_3D)
splitter2 = wxSplitterWindow(splitter, -1, style=wxNO_3D|wxSP_3D)
# Prevent TreeCtrl from displaying all items after destruction
self.dying = false
# Make a File menu
self.mainmenu = wxMenuBar()
menu = wxMenu()
exitID = wxNewId()
menu.Append(exitID, 'E&xit\tAlt-X', 'Get the heck outta here!')
EVT_MENU(self, exitID, self.OnFileExit)
self.mainmenu.Append(menu, '&File')
# Make a Demo menu
menu = wxMenu()
for item in _treeList:
submenu = wxMenu()
for childItem in item[1]:
mID = wxNewId()
submenu.Append(mID, childItem)
EVT_MENU(self, mID, self.OnDemoMenu)
menu.AppendMenu(wxNewId(), item[0], submenu)
self.mainmenu.Append(menu, '&Demo')
# Make a Help menu
helpID = wxNewId()
menu = wxMenu()
menu.Append(helpID, '&About\tCtrl-H', 'wxPython RULES!!!')
EVT_MENU(self, helpID, self.OnHelpAbout)
self.mainmenu.Append(menu, '&Help')
self.SetMenuBar(self.mainmenu)
# set the menu accellerator table...
aTable = wxAcceleratorTable([(wxACCEL_ALT, ord('X'), exitID),
(wxACCEL_CTRL, ord('H'), helpID)])
self.SetAcceleratorTable(aTable)
# Create a TreeCtrl
tID = wxNewId()
self.treeMap = {}
self.tree = wxTreeCtrl(splitter, tID,
style=wxTR_HAS_BUTTONS |
wxTR_EDIT_LABELS |
wxTR_HAS_VARIABLE_ROW_HEIGHT |
wxSUNKEN_BORDER)
#self.tree.SetBackgroundColour(wxNamedColour("Pink"))
root = self.tree.AddRoot("Overview")
firstChild = None
for item in _treeList:
child = self.tree.AppendItem(root, item[0])
if not firstChild: firstChild = child
for childItem in item[1]:
theDemo = self.tree.AppendItem(child, childItem)
self.treeMap[childItem] = theDemo
self.tree.Expand(root)
self.tree.Expand(firstChild)
EVT_TREE_ITEM_EXPANDED (self.tree, tID, self.OnItemExpanded)
EVT_TREE_ITEM_COLLAPSED (self.tree, tID, self.OnItemCollapsed)
EVT_TREE_SEL_CHANGED (self.tree, tID, self.OnSelChanged)
EVT_LEFT_DOWN (self.tree, self.OnTreeLeftDown)
# Create a Notebook
self.nb = wxNotebook(splitter2, -1)
# Set up a TextCtrl on the Overview Notebook page
self.ovr = wxHtmlWindow(self.nb, -1)
self.nb.AddPage(self.ovr, "Overview")
# Set up a TextCtrl on the Demo Code Notebook page
self.txt = wxTextCtrl(self.nb, -1,
style = wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
self.txt.SetFont(wxFont(9, wxMODERN, wxNORMAL, wxNORMAL, false))
self.nb.AddPage(self.txt, "Demo Code")
# Set up a log on the View Log Notebook page
self.log = wxTextCtrl(splitter2, -1,
style = wxTE_MULTILINE|wxTE_READONLY|wxHSCROLL)
# Set the wxWindows log target to be this textctrl
wxLog_SetActiveTarget(wxLogTextCtrl(self.log))
self.Show(true)
# add the windows to the splitter and split it.
splitter2.SplitHorizontally(self.nb, self.log)
splitter2.SetSashPosition(450, true)
splitter2.SetMinimumPaneSize(20)
splitter.SplitVertically(self.tree, splitter2)
splitter.SetSashPosition(180, true)
splitter.SetMinimumPaneSize(20)
# select initial items
self.nb.SetSelection(0)
self.tree.SelectItem(root)
if len(sys.argv) == 2:
try:
selectedDemo = self.treeMap[sys.argv[1]]
except:
selectedDemo = None
if selectedDemo:
self.tree.SelectItem(selectedDemo)
self.tree.EnsureVisible(selectedDemo)
wxLogMessage('window handle: %s' % self.GetHandle())
#---------------------------------------------
def WriteText(self, text):
if text[-1:] == '\n':
text = text[:-1]
wxLogMessage(text)
def write(self, txt):
self.WriteText(txt)
#---------------------------------------------
def OnItemExpanded(self, event):
item = event.GetItem()
wxLogMessage("OnItemExpanded: %s" % self.tree.GetItemText(item))
#---------------------------------------------
def OnItemCollapsed(self, event):
item = event.GetItem()
wxLogMessage("OnItemCollapsed: %s" % self.tree.GetItemText(item))
#---------------------------------------------
def OnTreeLeftDown(self, event):
pt = event.GetPosition();
item, flags = self.tree.HitTest(pt)
if item == self.tree.GetSelection():
self.SetOverview(self.tree.GetItemText(item), self.curOverview)
else:
event.Skip()
#---------------------------------------------
def OnSelChanged(self, event):
if self.dying:
return
item = event.GetItem()
itemText = self.tree.GetItemText(item)
self.RunDemo(itemText)
#---------------------------------------------
def RunDemo(self, itemText):
os.chdir(self.cwd)
if self.nb.GetPageCount() == 3:
if self.nb.GetSelection() == 2:
self.nb.SetSelection(0)
self.nb.DeletePage(2)
if itemText == 'Overview':
self.GetDemoFile('Main.py')
self.SetOverview('Overview', overview)
self.nb.Refresh();
self.window = None
else:
if os.path.exists(itemText + '.py'):
wxBeginBusyCursor()
wxLogMessage("Running demo %s.py..." % itemText)
try:
self.GetDemoFile(itemText + '.py')
module = __import__(itemText, globals())
self.SetOverview(itemText, module.overview)
finally:
wxEndBusyCursor()
# in case runTest is modal, make sure things look right...
self.nb.Refresh();
wxYield()
self.window = module.runTest(self, self.nb, self) ###
if self.window:
self.nb.AddPage(self.window, 'Demo')
wxYield()
self.nb.SetSelection(2)
else:
self.ovr.SetPage("")
self.txt.Clear()
self.window = None
#---------------------------------------------
# Get the Demo files
def GetDemoFile(self, filename):
self.txt.Clear()
try:
self.txt.SetValue(open(filename).read())
except IOError:
self.txt.WriteText("Cannot open %s file." % filename)
self.txt.SetInsertionPoint(0)
self.txt.ShowPosition(0)
#---------------------------------------------
def SetOverview(self, name, text):
self.curOverview = text
lead = text[:6]
if lead != '<html>' and lead != '<HTML>':
text = string.join(string.split(text, '\n'), '<br>')
#text = '<font size="-1"><pre>' + text + '</pre></font>'
self.ovr.SetPage(text)
self.nb.SetPageText(0, name)
#---------------------------------------------
# Menu methods
def OnFileExit(self, event):
self.Close()
def OnHelpAbout(self, event):
from About import MyAboutBox
about = MyAboutBox(self)
about.ShowModal()
about.Destroy()
#---------------------------------------------
def OnCloseWindow(self, event):
self.dying = true
self.window = None
self.mainmenu = None
self.Destroy()
#---------------------------------------------
def OnIdle(self, event):
if self.otherWin:
self.otherWin.Raise()
self.window = self.otherWin
self.otherWin = None
#---------------------------------------------
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)
#---------------------------------------------------------------------------
#---------------------------------------------------------------------------
class MyApp(wxApp):
def OnInit(self):
wxInitAllImageHandlers()
self.splash = SplashScreen(None, bitmapfile='bitmaps/splash.gif',
duration=4000, callback=self.AfterSplash)
self.splash.Show(true)
wxYield()
return true
def AfterSplash(self):
self.splash.Close(true)
frame = wxPythonDemo(None, -1, "wxPython: (A Demonstration)")
frame.Show(true)
self.SetTopWindow(frame)
self.ShowTip(frame)
def ShowTip(self, frame):
try:
showTipText = open("data/showTips").read()
showTip, index = eval(showTipText)
except IOError:
showTip, index = (1, 0)
print showTip, index
if showTip:
tp = wxCreateFileTipProvider("data/tips.txt", index)
showTip = wxShowTip(frame, tp)
index = tp.GetCurrentTip()
open("data/showTips", "w").write(str( (showTip, index) ))
#---------------------------------------------------------------------------
def main():
try:
demoPath = os.path.split(__file__)[0]
os.chdir(demoPath)
except:
pass
app = MyApp(0)
app.MainLoop()
#---------------------------------------------------------------------------
overview = """<html><body>
<h2>Python</h2>
Python is an interpreted, interactive, object-oriented programming
language often compared to Tcl, Perl, Scheme, or Java.
<p> Python combines remarkable power with very clear syntax. It has
modules, classes, exceptions, very high level dynamic data types, and
dynamic typing. There are interfaces to many system calls and
libraries, and new built-in modules are easily written in C or
C++. Python is also usable as an extension language for applications
that need a programmable interface. <p>
<h2>wxWindows</h2>
wxWindows is a free C++ framework designed to make cross-platform
programming child's play. Well, almost. wxWindows 2 supports Windows
3.1/95/98/NT, Unix with GTK/Motif/Lesstif, with a Mac version
underway. Other ports are under consideration. <p>
wxWindows is a set of libraries that allows C++ applications to
compile and run on several different types of computers, with minimal
source code changes. There is one library per supported GUI (such as
Motif, or Windows). As well as providing a common API (Application
Programming Interface) for GUI functionality, it provides
functionality for accessing some commonly-used operating system
facilities, such as copying or deleting files. wxWindows is a
'framework' in the sense that it provides a lot of built-in
functionality, which the application can use or replace as required,
thus saving a great deal of coding effort. Basic data structures such
as strings, linked lists and hash tables are also supported.
<p>
<h2>wxPython</h2>
wxPython is a Python extension module that encapsulates the wxWindows
GUI classes. Currently it is only available for the Win32 and GTK
ports of wxWindows, but as soon as the other ports are brought up to
the same level as Win32 and GTK, it should be fairly trivial to
enable wxPython to be used with the new GUI.
<p>
The wxPython extension module attempts to mirror the class heiarchy
of wxWindows as closely as possible. This means that there is a
wxFrame class in wxPython that looks, smells, tastes and acts almost
the same as the wxFrame class in the C++ version. Unfortunately,
because of differences in the languages, wxPython doesn't match
wxWindows exactly, but the differences should be easy to absorb
because they are natural to Python. For example, some methods that
return multiple values via argument pointers in C++ will return a
tuple of values in Python.
<p>
There is still much to be done for wxPython, many classes still need
to be mirrored. Also, wxWindows is still somewhat of a moving target
so it is a bit of an effort just keeping wxPython up to date. On the
other hand, there are enough of the core classes completed that
useful applications can be written.
<p>
wxPython is close enough to the C++ version that the majority of
the wxPython documentation is actually just notes attached to the C++
documents that describe the places where wxPython is different. There
is also a series of sample programs included, and a series of
documentation pages that assist the programmer in getting started
with wxPython.
"""
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
if __name__ == '__main__':
main()
#----------------------------------------------------------------------------

403
wxPython/demo/OldSizers.py Normal file
View File

@@ -0,0 +1,403 @@
#----------------------------------------------------------------------
# sizer test code
#----------------------------------------------------------------------
from wxPython.wx import *
from wxPython.lib.sizers import *
#----------------------------------------------------------------------
def makeSimpleBox1(win):
box = wxBoxSizer(wxHORIZONTAL)
box.Add(wxButton(win, 1010, "one"), 0)
box.Add(wxButton(win, 1010, "two"), 0)
box.Add(wxButton(win, 1010, "three"), 0)
box.Add(wxButton(win, 1010, "four"), 0)
return box
#----------------------------------------------------------------------
def makeSimpleBox2(win):
box = wxBoxSizer(wxVERTICAL)
box.Add(wxButton(win, 1010, "one"), 0)
box.Add(wxButton(win, 1010, "two"), 0)
box.Add(wxButton(win, 1010, "three"), 0)
box.Add(wxButton(win, 1010, "four"), 0)
return box
#----------------------------------------------------------------------
def makeSimpleBox3(win):
box = wxBoxSizer(wxHORIZONTAL)
box.Add(wxButton(win, 1010, "one"), 0)
box.Add(wxButton(win, 1010, "two"), 0)
box.Add(wxButton(win, 1010, "three"), 0)
box.Add(wxButton(win, 1010, "four"), 0)
box.Add(wxButton(win, 1010, "five"), 1)
return box
#----------------------------------------------------------------------
def makeSimpleBox4(win):
box = wxBoxSizer(wxHORIZONTAL)
box.Add(wxButton(win, 1010, "one"), 0)
box.Add(wxButton(win, 1010, "two"), 0)
box.Add(wxButton(win, 1010, "three"), 1)
box.Add(wxButton(win, 1010, "four"), 1)
box.Add(wxButton(win, 1010, "five"), 1)
return box
#----------------------------------------------------------------------
def makeSimpleBox5(win):
box = wxBoxSizer(wxHORIZONTAL)
box.Add(wxButton(win, 1010, "one"), 0)
box.Add(wxButton(win, 1010, "two"), 0)
box.Add(wxButton(win, 1010, "three"), 3)
box.Add(wxButton(win, 1010, "four"), 1)
box.Add(wxButton(win, 1010, "five"), 1)
return box
#----------------------------------------------------------------------
def makeSimpleBox6(win):
box = wxBoxSizer(wxHORIZONTAL, wxSize(250, 50))
box.Add(wxButton(win, 1010, "10"), 10)
box.Add(wxButton(win, 1010, "20"), 20)
box.Add(wxButton(win, 1010, "30"), 30)
box.Add(wxButton(win, 1010, "15"), 15)
box.Add(wxButton(win, 1010, "5"), 5)
return box
#----------------------------------------------------------------------
def makeSimpleBorder1(win):
bdr = wxBorderSizer(wxALL)
btn = wxButton(win, 1010, "border")
btn.SetSize(wxSize(80, 80))
bdr.Add(btn, 15)
return bdr
#----------------------------------------------------------------------
def makeSimpleBorder2(win):
bdr = wxBorderSizer(wxEAST | wxWEST)
btn = wxButton(win, 1010, "border")
btn.SetSize(wxSize(80, 80))
bdr.Add(btn, 15)
return bdr
#----------------------------------------------------------------------
def makeSimpleBorder3(win):
bdr = wxBorderSizer(wxNORTH | wxWEST)
btn = wxButton(win, 1010, "border")
btn.SetSize(wxSize(80, 80))
bdr.Add(btn, 15)
return bdr
#----------------------------------------------------------------------
def makeShapes(win):
box =wxBoxSizer(wxVERTICAL)
box.Add(wxStaticLine(win, -1), 0)
for line in (
(wxANCHOR_NW, "NorthWest"),
(wxANCHOR_NORTH, "North"),
(wxANCHOR_NE, "NorthEast")
), (
(wxANCHOR_WEST, "West"),
(wxANCHOR_NONE, "Center"),
(wxANCHOR_EAST, "East")
), (
(wxANCHOR_SW, "SouthWest"),
(wxANCHOR_SOUTH, "South"),
(wxANCHOR_SE, "SouthEast")
):
linebox =wxBoxSizer(wxHORIZONTAL)
linebox.Add(wxStaticLine(win, -1, style=wxVERTICAL), 0)
for (anchor, label) in line:
sizer =wxShapeSizer(anchor)
sizer.Add(wxButton(win, -1, label, size=wxSize(100, 50)))
linebox.Add(sizer, 1)
linebox.Add(wxStaticLine(win, -1, style=wxVERTICAL), 0)
box.Add(linebox, 1)
box.Add(wxStaticLine(win, -1), 0)
return box
#----------------------------------------------------------------------
def makeBoxInBox(win):
box = wxBoxSizer(wxVERTICAL)
box.Add(wxButton(win, 1010, "one"))
box2 = wxBoxSizer(wxHORIZONTAL)
box2.AddMany([ wxButton(win, 1010, "two"),
wxButton(win, 1010, "three"),
wxButton(win, 1010, "four"),
wxButton(win, 1010, "five"),
])
box3 = wxBoxSizer(wxVERTICAL)
box3.AddMany([ (wxButton(win, 1010, "six"), 0),
(wxButton(win, 1010, "seven"), 2),
(wxButton(win, 1010, "eight"), 1),
(wxButton(win, 1010, "nine"), 1),
])
box2.Add(box3, 1)
box.Add(box2, 1)
box.Add(wxButton(win, 1010, "ten"))
return box
#----------------------------------------------------------------------
def makeBoxInBorder(win):
bdr = wxBorderSizer(wxALL)
box = makeSimpleBox3(win)
bdr.Add(box, 15)
return bdr
#----------------------------------------------------------------------
def makeBorderInBox(win):
insideBox = wxBoxSizer(wxHORIZONTAL)
box2 = wxBoxSizer(wxHORIZONTAL)
box2.AddMany([ wxButton(win, 1010, "one"),
wxButton(win, 1010, "two"),
wxButton(win, 1010, "three"),
wxButton(win, 1010, "four"),
wxButton(win, 1010, "five"),
])
insideBox.Add(box2, 0)
bdr = wxBorderSizer(wxALL)
bdr.Add(wxButton(win, 1010, "border"), 20)
insideBox.Add(bdr, 1)
box3 = wxBoxSizer(wxVERTICAL)
box3.AddMany([ (wxButton(win, 1010, "six"), 0),
(wxButton(win, 1010, "seven"), 2),
(wxButton(win, 1010, "eight"), 1),
(wxButton(win, 1010, "nine"), 1),
])
insideBox.Add(box3, 1)
outsideBox = wxBoxSizer(wxVERTICAL)
outsideBox.Add(wxButton(win, 1010, "top"))
outsideBox.Add(insideBox, 1)
outsideBox.Add(wxButton(win, 1010, "bottom"))
return outsideBox
#----------------------------------------------------------------------
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 strechable 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 strechable, but one of them has a weighting "
"factor so it gets more of the free space."
),
# ("Percent Sizer", makeSimpleBox6,
# "You can use the wxBoxSizer like a Percent Sizer. Just make sure that all "
# "the weighting factors add up to 100!"
# ),
("", None, ""),
("Simple border sizer", makeSimpleBorder1,
"The wxBorderSizer leaves 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, ""),
("Proportional resize", makeShapes,
"The wxShapeSizer preserves the original proportions of the window."
),
("", 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 withing 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."
),
]
#----------------------------------------------------------------------
class TestFrame(wxFrame):
def __init__(self, parent, title, sizerFunc):
wxFrame.__init__(self, parent, -1, title)
EVT_BUTTON(self, 1010, self.OnButton)
self.sizer = sizerFunc(self)
self.CreateStatusBar()
self.SetStatusText("Resize this frame to see how the sizers respond...")
self.sizer.FitWindow(self)
EVT_CLOSE(self, self.OnCloseWindow)
EVT_SIZE(self, self.OnSize)
def OnSize(self, event):
size = self.GetClientSize()
self.sizer.Layout(size)
def OnCloseWindow(self, event):
self.MakeModal(false)
self.Destroy()
def OnButton(self, event):
self.Close(true)
#----------------------------------------------------------------------
class TestSelectionPanel(wxPanel):
def __init__(self, parent, frame=NULL):
wxPanel.__init__(self, parent, -1)
self.frame = frame
self.list = wxListBox(self, 401,
wxDLG_PNT(self, 10, 10), wxDLG_SZE(self, 100, 60),
[])
EVT_LISTBOX(self, 401, self.OnSelect)
EVT_LISTBOX_DCLICK(self, 401, self.OnDClick)
wxButton(self, 402, "Try it!", wxDLG_PNT(self, 120, 10)).SetDefault()
EVT_BUTTON(self, 402, self.OnDClick)
self.text = wxTextCtrl(self, -1, "",
wxDLG_PNT(self, 10, 80),
wxDLG_SZE(self, 200, 60),
wxTE_MULTILINE | wxTE_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(wxBOTH)
win.Show(true)
win.MakeModal(true)
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestSelectionPanel(nb, frame)
return win
overview = wxSizer.__doc__ + '\n' + '-' * 80 + '\n' + \
wxBoxSizer.__doc__ + '\n' + '-' * 80 + '\n' + \
wxBorderSizer.__doc__
#----------------------------------------------------------------------
if __name__ == '__main__':
class MainFrame(wxFrame):
def __init__(self):
wxFrame.__init__(self, NULL, -1, "Testing...")
self.CreateStatusBar()
mainmenu = wxMenuBar()
menu = wxMenu()
menu.Append(200, 'E&xit', 'Get the heck outta here!')
mainmenu.Append(menu, "&File")
self.SetMenuBar(mainmenu)
EVT_MENU(self, 200, self.OnExit)
self.panel = TestSelectionPanel(self, self)
self.SetSize(wxSize(400, 380))
EVT_CLOSE(self, self.OnCloseWindow)
def OnCloseWindow(self, event):
self.Destroy()
def OnExit(self, event):
self.Close(true)
class TestApp(wxApp):
def OnInit(self):
frame = MainFrame()
frame.Show(true)
self.SetTopWindow(frame)
return true
app = TestApp(0)
app.MainLoop()
#----------------------------------------------------------------------

176
wxPython/demo/PrintFramework.py Normal file
View File

@@ -0,0 +1,176 @@
from wxPython.wx import *
from wxScrolledWindow import MyCanvas
#----------------------------------------------------------------------
class MyPrintout(wxPrintout):
def __init__(self, canvas, log):
wxPrintout.__init__(self)
self.canvas = canvas
self.log = log
def OnBeginDocument(self, start, end):
self.log.WriteText("wxPrintout.OnBeginDocument\n")
return self.base_OnBeginDocument(start, end)
def OnEndDocument(self):
self.log.WriteText("wxPrintout.OnEndDocument\n")
self.base_OnEndDocument()
def OnBeginPrinting(self):
self.log.WriteText("wxPrintout.OnBeginPrinting\n")
self.base_OnBeginPrinting()
def OnEndPrinting(self):
self.log.WriteText("wxPrintout.OnEndPrinting\n")
self.base_OnEndPrinting()
def OnPreparePrinting(self):
self.log.WriteText("wxPrintout.OnPreparePrinting\n")
self.base_OnPreparePrinting()
def HasPage(self, page):
self.log.WriteText("wxPrintout.HasPage\n")
if page == 1:
return true
else:
return false
def GetPageInfo(self):
self.log.WriteText("wxPrintout.GetPageInfo\n")
return (1, 1, 1, 1)
def OnPrintPage(self, page):
self.log.WriteText("wxPrintout.OnPrintPage\n")
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 centring 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)
return true
#----------------------------------------------------------------------
class TestPrintPanel(wxPanel):
def __init__(self, parent, frame, log):
wxPanel.__init__(self, parent, -1)
self.log = log
self.frame = frame
self.printData = wxPrintData()
self.printData.SetPaperId(wxPAPER_LETTER)
self.box = wxBoxSizer(wxVERTICAL)
self.canvas = MyCanvas(self)
self.box.Add(self.canvas, 1, wxGROW)
subbox = wxBoxSizer(wxHORIZONTAL)
btn = wxButton(self, 1201, "Print Setup")
EVT_BUTTON(self, 1201, self.OnPrintSetup)
subbox.Add(btn, 1, wxGROW | wxALL, 2)
btn = wxButton(self, 1202, "Print Preview")
EVT_BUTTON(self, 1202, self.OnPrintPreview)
subbox.Add(btn, 1, wxGROW | wxALL, 2)
btn = wxButton(self, 1203, "Print")
EVT_BUTTON(self, 1203, self.OnDoPrint)
subbox.Add(btn, 1, wxGROW | wxALL, 2)
self.box.Add(subbox, 0, wxGROW)
self.SetAutoLayout(true)
self.SetSizer(self.box)
def OnPrintSetup(self, event):
printerDialog = wxPrintDialog(self)
printerDialog.GetPrintDialogData().SetPrintData(self.printData)
printerDialog.GetPrintDialogData().SetSetupDialog(true)
printerDialog.ShowModal();
self.printData = printerDialog.GetPrintDialogData().GetPrintData()
printerDialog.Destroy()
def OnPrintPreview(self, event):
self.log.WriteText("OnPrintPreview\n")
printout = MyPrintout(self.canvas, self.log)
printout2 = MyPrintout(self.canvas, self.log)
self.preview = wxPrintPreview(printout, printout2, self.printData)
if not self.preview.Ok():
self.log.WriteText("Houston, we have a problem...\n")
return
frame = wxPreviewFrame(self.preview, self.frame, "This is a print preview")
frame.Initialize()
frame.SetPosition(self.frame.GetPosition())
frame.SetSize(self.frame.GetSize())
frame.Show(true)
def OnDoPrint(self, event):
pdd = wxPrintDialogData()
pdd.SetPrintData(self.printData)
printer = wxPrinter(pdd)
printout = MyPrintout(self.canvas, self.log)
if not printer.Print(self.frame, printout):
wxMessageBox("There was a problem printing.\nPerhaps your current printer is not set correctly?", "Printing", wxOK)
else:
self.printData = printer.GetPrintDialogData().GetPrintData()
printout.Destroy()
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestPrintPanel(nb, frame, log)
return win
#----------------------------------------------------------------------
overview = """\
"""

20
wxPython/demo/PyShell.py Normal file
View File

@@ -0,0 +1,20 @@
from wxPython.wx import *
from wxPython.lib.shell import PyShell
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = PyShell(nb)
win.Show(true)
return win
#----------------------------------------------------------------------
overview = """
A simple GUI version of the interactive interpreter.
"""

15
wxPython/demo/PyShellWindow.py Normal file
View File

@@ -0,0 +1,15 @@
from wxPython.lib.pyshell import PyShellWindow
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = PyShellWindow(nb, -1)
return win
#----------------------------------------------------------------------
import wxPython.lib.pyshell
overview = wxPython.lib.pyshell.__doc__

85
wxPython/demo/PythonEvents.py Normal file
View File

@@ -0,0 +1,85 @@
from wxPython.wx import *
import sys
#----------------------------------------------------------------------
myEVT_BUTTON_CLICKPOS = 5015
def EVT_BUTTON_CLICKPOS(win, id, func):
win.Connect(id, -1, myEVT_BUTTON_CLICKPOS, func)
class MyEvent(wxPyCommandEvent):
def __init__(self, evtType, id):
wxPyCommandEvent.__init__(self, evtType, id)
self.myVal = None
#def __del__(self):
# print '__del__'
# wxPyCommandEvent.__del__(self)
def SetMyVal(self, val):
self.myVal = val
def GetMyVal(self):
return self.myVal
class MyButton(wxButton):
def __init__(self, parent, id, txt, pos):
wxButton.__init__(self, parent, id, txt, pos)
EVT_LEFT_DOWN(self, 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(wxPanel):
def __init__(self, parent, log):
wxPanel.__init__(self, parent, -1)
self.log = log
b = MyButton(self, -1, " Click me ", wxPoint(30,30))
EVT_BUTTON(self, b.GetId(), self.OnClick)
EVT_BUTTON_CLICKPOS(self, b.GetId(), self.OnMyEvent)
wxStaticText(self, -1, "Please see the Overview and Demo Code for details...",
wxPoint(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 heirachy for processing.
"""

7
wxPython/demo/README.txt Normal file
View File

@@ -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

587
wxPython/demo/Sizers.py Normal file
View File

@@ -0,0 +1,587 @@
#----------------------------------------------------------------------
# sizer test code
#----------------------------------------------------------------------
from wxPython.wx import *
from wxPython.lib.grids import wxGridSizer, wxFlexGridSizer
#----------------------------------------------------------------------
def makeSimpleBox1(win):
box = wxBoxSizer(wxHORIZONTAL)
box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "four"), 0, wxEXPAND)
return box
#----------------------------------------------------------------------
def makeSimpleBox2(win):
box = wxBoxSizer(wxVERTICAL)
box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "four"), 0, wxEXPAND)
return box
#----------------------------------------------------------------------
def makeSimpleBox3(win):
box = wxBoxSizer(wxHORIZONTAL)
box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "four"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "five"), 1, wxEXPAND)
return box
#----------------------------------------------------------------------
def makeSimpleBox4(win):
box = wxBoxSizer(wxHORIZONTAL)
box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "three"), 1, wxEXPAND)
box.Add(wxButton(win, 1010, "four"), 1, wxEXPAND)
box.Add(wxButton(win, 1010, "five"), 1, wxEXPAND)
return box
#----------------------------------------------------------------------
def makeSimpleBox5(win):
box = wxBoxSizer(wxHORIZONTAL)
box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "three"), 3, wxEXPAND)
box.Add(wxButton(win, 1010, "four"), 1, wxEXPAND)
box.Add(wxButton(win, 1010, "five"), 1, wxEXPAND)
return box
#----------------------------------------------------------------------
def makeSimpleBox6(win):
box = wxBoxSizer(wxHORIZONTAL)
box.Add(wxButton(win, 1010, "one"), 1, wxALIGN_TOP)
box.Add(wxButton(win, 1010, "two"), 1, wxEXPAND)
box.Add(wxButton(win, 1010, "three"), 1, wxALIGN_CENTER)
box.Add(wxButton(win, 1010, "four"), 1, wxEXPAND)
box.Add(wxButton(win, 1010, "five"), 1, wxALIGN_BOTTOM)
return box
#----------------------------------------------------------------------
def makeSimpleBox7(win):
box = wxBoxSizer(wxHORIZONTAL)
box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
box.Add(60, 20, 0, wxEXPAND)
box.Add(wxButton(win, 1010, "five"), 1, wxEXPAND)
return box
#----------------------------------------------------------------------
def makeSimpleBox8(win):
box = wxBoxSizer(wxVERTICAL)
box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
box.Add(0,0, 1)
box.Add(wxButton(win, 1010, "two"), 0, wxALIGN_CENTER)
box.Add(0,0, 1)
box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "four"), 0, wxEXPAND)
# box.Add(wxButton(win, 1010, "five"), 1, wxEXPAND)
return box
#----------------------------------------------------------------------
#----------------------------------------------------------------------
def makeSimpleBorder1(win):
bdr = wxBoxSizer(wxHORIZONTAL)
btn = wxButton(win, 1010, "border")
btn.SetSize(wxSize(80, 80))
bdr.Add(btn, 1, wxEXPAND|wxALL, 15)
return bdr
#----------------------------------------------------------------------
def makeSimpleBorder2(win):
bdr = wxBoxSizer(wxHORIZONTAL)
btn = wxButton(win, 1010, "border")
btn.SetSize(wxSize(80, 80))
bdr.Add(btn, 1, wxEXPAND | wxEAST | wxWEST, 15)
return bdr
#----------------------------------------------------------------------
def makeSimpleBorder3(win):
bdr = wxBoxSizer(wxHORIZONTAL)
btn = wxButton(win, 1010, "border")
btn.SetSize(wxSize(80, 80))
bdr.Add(btn, 1, wxEXPAND | wxNORTH | wxWEST, 15)
return bdr
#----------------------------------------------------------------------
#----------------------------------------------------------------------
def makeBoxInBox(win):
box = wxBoxSizer(wxVERTICAL)
box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
box2 = wxBoxSizer(wxHORIZONTAL)
box2.AddMany([ (wxButton(win, 1010, "two"), 0, wxEXPAND),
(wxButton(win, 1010, "three"), 0, wxEXPAND),
(wxButton(win, 1010, "four"), 0, wxEXPAND),
(wxButton(win, 1010, "five"), 0, wxEXPAND),
])
box3 = wxBoxSizer(wxVERTICAL)
box3.AddMany([ (wxButton(win, 1010, "six"), 0, wxEXPAND),
(wxButton(win, 1010, "seven"), 2, wxEXPAND),
(wxButton(win, 1010, "eight"), 1, wxEXPAND),
(wxButton(win, 1010, "nine"), 1, wxEXPAND),
])
box2.Add(box3, 1, wxEXPAND)
box.Add(box2, 1, wxEXPAND)
box.Add(wxButton(win, 1010, "ten"), 0, wxEXPAND)
return box
#----------------------------------------------------------------------
def makeBoxInBorder(win):
bdr = wxBoxSizer(wxHORIZONTAL)
box = makeSimpleBox3(win)
bdr.Add(box, 1, wxEXPAND | wxALL, 15)
return bdr
#----------------------------------------------------------------------
def makeBorderInBox(win):
insideBox = wxBoxSizer(wxHORIZONTAL)
box2 = wxBoxSizer(wxHORIZONTAL)
box2.AddMany([ (wxButton(win, 1010, "one"), 0, wxEXPAND),
(wxButton(win, 1010, "two"), 0, wxEXPAND),
(wxButton(win, 1010, "three"), 0, wxEXPAND),
(wxButton(win, 1010, "four"), 0, wxEXPAND),
(wxButton(win, 1010, "five"), 0, wxEXPAND),
])
insideBox.Add(box2, 0, wxEXPAND)
bdr = wxBoxSizer(wxHORIZONTAL)
bdr.Add(wxButton(win, 1010, "border"), 1, wxEXPAND | wxALL)
insideBox.Add(bdr, 1, wxEXPAND | wxALL, 20)
box3 = wxBoxSizer(wxVERTICAL)
box3.AddMany([ (wxButton(win, 1010, "six"), 0, wxEXPAND),
(wxButton(win, 1010, "seven"), 2, wxEXPAND),
(wxButton(win, 1010, "eight"), 1, wxEXPAND),
(wxButton(win, 1010, "nine"), 1, wxEXPAND),
])
insideBox.Add(box3, 1, wxEXPAND)
outsideBox = wxBoxSizer(wxVERTICAL)
outsideBox.Add(wxButton(win, 1010, "top"), 0, wxEXPAND)
outsideBox.Add(insideBox, 1, wxEXPAND)
outsideBox.Add(wxButton(win, 1010, "bottom"), 0, wxEXPAND)
return outsideBox
#----------------------------------------------------------------------
def makeGrid1(win):
gs = wxGridSizer(3, 3, 2, 2) # rows, cols, hgap, vgap
gs.AddMany([ (wxButton(win, 1010, 'one'), 0, wxEXPAND),
(wxButton(win, 1010, 'two'), 0, wxEXPAND),
(wxButton(win, 1010, 'three'), 0, wxEXPAND),
(wxButton(win, 1010, 'four'), 0, wxEXPAND),
(wxButton(win, 1010, 'five'), 0, wxEXPAND),
#(75, 50),
(wxButton(win, 1010, 'six'), 0, wxEXPAND),
(wxButton(win, 1010, 'seven'), 0, wxEXPAND),
(wxButton(win, 1010, 'eight'), 0, wxEXPAND),
(wxButton(win, 1010, 'nine'), 0, wxEXPAND),
])
return gs
#----------------------------------------------------------------------
def makeGrid2(win):
gs = wxGridSizer(3, 3) # rows, cols, hgap, vgap
box = wxBoxSizer(wxVERTICAL)
box.Add(wxButton(win, 1010, 'A'), 0, wxEXPAND)
box.Add(wxButton(win, 1010, 'B'), 1, wxEXPAND)
gs2 = wxGridSizer(2,2, 4, 4)
gs2.AddMany([ (wxButton(win, 1010, 'C'), 0, wxEXPAND),
(wxButton(win, 1010, 'E'), 0, wxEXPAND),
(wxButton(win, 1010, 'F'), 0, wxEXPAND),
(wxButton(win, 1010, 'G'), 0, wxEXPAND)])
gs.AddMany([ (wxButton(win, 1010, 'one'), 0, wxALIGN_RIGHT | wxALIGN_BOTTOM),
(wxButton(win, 1010, 'two'), 0, wxEXPAND),
(wxButton(win, 1010, 'three'), 0, wxALIGN_LEFT | wxALIGN_BOTTOM),
(wxButton(win, 1010, 'four'), 0, wxEXPAND),
(wxButton(win, 1010, 'five'), 0, wxALIGN_CENTER),
(wxButton(win, 1010, 'six'), 0, wxEXPAND),
(box, 0, wxEXPAND | wxALL, 10),
(wxButton(win, 1010, 'eight'), 0, wxEXPAND),
(gs2, 0, wxEXPAND | wxALL, 4),
])
return gs
#----------------------------------------------------------------------
def makeGrid3(win):
gs = wxFlexGridSizer(3, 3, 2, 2) # rows, cols, hgap, vgap
gs.AddMany([ (wxButton(win, 1010, 'one'), 0, wxEXPAND),
(wxButton(win, 1010, 'two'), 0, wxEXPAND),
(wxButton(win, 1010, 'three'), 0, wxEXPAND),
(wxButton(win, 1010, 'four'), 0, wxEXPAND),
#(wxButton(win, 1010, 'five'), 0, wxEXPAND),
(175, 50),
(wxButton(win, 1010, 'six'), 0, wxEXPAND),
(wxButton(win, 1010, 'seven'), 0, wxEXPAND),
(wxButton(win, 1010, 'eight'), 0, wxEXPAND),
(wxButton(win, 1010, 'nine'), 0, wxEXPAND),
])
gs.AddGrowableRow(0)
gs.AddGrowableRow(2)
gs.AddGrowableCol(1)
return gs
#----------------------------------------------------------------------
def makeGrid4(win):
bpos = wxDefaultPosition
bsize = wxSize(100, 50)
gs = wxGridSizer(3, 3, 2, 2) # rows, cols, hgap, vgap
gs.AddMany([ (wxButton(win, 1010, 'one', bpos, bsize),
0, wxALIGN_TOP | wxALIGN_LEFT ),
(wxButton(win, 1010, 'two', bpos, bsize),
0, wxALIGN_TOP | wxALIGN_CENTER_HORIZONTAL ),
(wxButton(win, 1010, 'three', bpos, bsize),
0, wxALIGN_TOP | wxALIGN_RIGHT ),
(wxButton(win, 1010, 'four', bpos, bsize),
0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT ),
(wxButton(win, 1010, 'five', bpos, bsize),
0, wxALIGN_CENTER ),
(wxButton(win, 1010, 'six', bpos, bsize),
0, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT ),
(wxButton(win, 1010, 'seven', bpos, bsize),
0, wxALIGN_BOTTOM | wxALIGN_LEFT ),
(wxButton(win, 1010, 'eight', bpos, bsize),
0, wxALIGN_BOTTOM | wxALIGN_CENTER_HORIZONTAL ),
(wxButton(win, 1010, 'nine', bpos, bsize),
0, wxALIGN_BOTTOM | wxALIGN_RIGHT ),
])
return gs
#----------------------------------------------------------------------
def makeShapes(win):
bpos = wxDefaultPosition
bsize = wxSize(100, 50)
gs = wxGridSizer(3, 3, 2, 2) # rows, cols, hgap, vgap
gs.AddMany([ (wxButton(win, 1010, 'one', bpos, bsize),
0, wxSHAPED | wxALIGN_TOP | wxALIGN_LEFT ),
(wxButton(win, 1010, 'two', bpos, bsize),
0, wxSHAPED | wxALIGN_TOP | wxALIGN_CENTER_HORIZONTAL ),
(wxButton(win, 1010, 'three', bpos, bsize),
0, wxSHAPED | wxALIGN_TOP | wxALIGN_RIGHT ),
(wxButton(win, 1010, 'four', bpos, bsize),
0, wxSHAPED | wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT ),
(wxButton(win, 1010, 'five', bpos, bsize),
0, wxSHAPED | wxALIGN_CENTER ),
(wxButton(win, 1010, 'six', bpos, bsize),
0, wxSHAPED | wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT ),
(wxButton(win, 1010, 'seven', bpos, bsize),
0, wxSHAPED | wxALIGN_BOTTOM | wxALIGN_LEFT ),
(wxButton(win, 1010, 'eight', bpos, bsize),
0, wxSHAPED | wxALIGN_BOTTOM | wxALIGN_CENTER_HORIZONTAL ),
(wxButton(win, 1010, 'nine', bpos, bsize),
0, wxSHAPED | wxALIGN_BOTTOM | wxALIGN_RIGHT ),
])
return gs
#----------------------------------------------------------------------
def makeSimpleBoxShaped(win):
box = wxBoxSizer(wxHORIZONTAL)
box.Add(wxButton(win, 1010, "one"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "two"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "three"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "four"), 0, wxEXPAND)
box.Add(wxButton(win, 1010, "five"), 1, wxSHAPED)
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 strechable 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 strechable, 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 wxBoxSizer like a Percent Sizer. Just make sure that all "
# "the weighting factors add up to 100!"
# ),
("", None, ""),
("Simple border sizer", makeSimpleBorder1,
"The wxBoxSizer 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 withing 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 wxGridSizer. 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 horzontal and vertical gaps are set to "
"2 pixels each."
),
("More Grid Features", makeGrid2,
"This is another example of the wxGridSizer. 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 "
"wxSHAPED flag set and will resize proportional to its origingal size."
),
("Proportional resize with Alignments", makeShapes,
"This one shows various alignments as well as proportional resizing for all items."
),
]
#----------------------------------------------------------------------
class TestFrame(wxFrame):
def __init__(self, parent, title, sizerFunc):
wxFrame.__init__(self, parent, -1, title)
EVT_BUTTON(self, 1010, self.OnButton)
self.sizer = sizerFunc(self)
self.CreateStatusBar()
self.SetStatusText("Resize this frame to see how the sizers respond...")
self.sizer.Fit(self)
self.SetAutoLayout(true)
self.SetSizer(self.sizer)
EVT_CLOSE(self, self.OnCloseWindow)
def OnCloseWindow(self, event):
self.MakeModal(false)
self.Destroy()
def OnButton(self, event):
self.Close(true)
#----------------------------------------------------------------------
class TestSelectionPanel(wxPanel):
def __init__(self, parent, frame):
wxPanel.__init__(self, parent, -1)
self.frame = frame
self.list = wxListBox(self, 401,
wxDLG_PNT(self, 10, 10), wxDLG_SZE(self, 100, 100),
[])
EVT_LISTBOX(self, 401, self.OnSelect)
EVT_LISTBOX_DCLICK(self, 401, self.OnDClick)
self.btn = wxButton(self, 402, "Try it!", wxDLG_PNT(self, 120, 10)).SetDefault()
EVT_BUTTON(self, 402, self.OnDClick)
self.text = wxTextCtrl(self, -1, "",
wxDLG_PNT(self, 10, 115),
wxDLG_SZE(self, 200, 50),
wxTE_MULTILINE | wxTE_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(wxBOTH)
win.Show(true)
win.MakeModal(true)
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestSelectionPanel(nb, frame)
return win
overview = ""
#wxSizer.__doc__ + '\n' + '-' * 80 + '\n' + \
#wxBoxSizer.__doc__ + '\n' + '-' * 80 + '\n' + \
#wxBorderSizer.__doc__
#----------------------------------------------------------------------
if __name__ == '__main__':
class MainFrame(wxFrame):
def __init__(self):
wxFrame.__init__(self, NULL, -1, "Testing...")
self.CreateStatusBar()
mainmenu = wxMenuBar()
menu = wxMenu()
menu.Append(200, 'E&xit', 'Get the heck outta here!')
mainmenu.Append(menu, "&File")
self.SetMenuBar(mainmenu)
EVT_MENU(self, 200, self.OnExit)
self.panel = TestSelectionPanel(self, self)
self.SetSize(wxSize(400, 380))
EVT_CLOSE(self, self.OnCloseWindow)
def OnCloseWindow(self, event):
self.Destroy()
def OnExit(self, event):
self.Close(true)
class TestApp(wxApp):
def OnInit(self):
frame = MainFrame()
frame.Show(true)
self.SetTopWindow(frame)
return true
app = TestApp(0)
app.MainLoop()
#----------------------------------------------------------------------

379
wxPython/demo/SlashDot.py Normal file
View File

@@ -0,0 +1,379 @@
#!/usr/bin/python
"""This is SlashDot 1.2
It's the obligatory Slashdot.org headlines reader that
any modern widget set/library must have in order to be taken
seriously :-)
Usage is quite simple; wxSlash attempts to download the
'ultramode.txt' file from http://slashdot.org, which
contains the headlines in a computer friendly format. It
then displays said headlines in a wxWindows list control.
You can read articles using either Python's html library
or an external browser. Uncheck the 'browser->internal' menu
item to use the latter option. Use the settings dialog box
to set which external browser is started.
This code is available under the wxWindows license, see
elsewhere. If you modify this code, be aware of the fact
that slashdot.org's maintainer, CmdrTaco, explicitly asks
'ultramode.txt' downloaders not to do this automatically
more than twice per hour. If this feature is abused,
CmdrTaco may remove the ultramode file completely and that
will make a *lot* of people unhappy.
I want to thank Alex Shnitman whose slashes.pl
(Perl/GTK) script gave me the idea for this applet.
Have fun with it,
Harm van der Heijden (H.v.d.Heijden@phys.tue.nl)
"""
from wxPython.wx import *
from httplib import HTTP
from htmllib import HTMLParser
import os
import re
import formatter
class HTMLTextView(wxFrame):
def __init__(self, parent, id, title='HTMLTextView', url=None):
wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition,
wxSize(600,400))
EVT_CLOSE(self, self.OnCloseWindow)
self.mainmenu = wxMenuBar()
menu = wxMenu()
menu.Append(201, '&Open URL...', 'Open URL')
EVT_MENU(self, 201, self.OnFileOpen)
menu.Append(209, 'E&xit', 'Exit viewer')
EVT_MENU(self, 209, self.OnFileExit)
self.mainmenu.Append(menu, '&File')
self.SetMenuBar(self.mainmenu)
self.CreateStatusBar(1)
self.text = wxTextCtrl(self, -1, "", wxPyDefaultPosition,
wxPyDefaultSize, wxTE_MULTILINE | wxTE_READONLY)
if (url):
self.OpenURL(url)
def logprint(self, x):
self.SetStatusText(x)
def OpenURL(self, url):
self.url = url
m = re.match('file:(\S+)\s*', url)
if m:
f = open(m.groups()[0],'r')
else:
m = re.match('http://([^/]+)(/\S*)\s*', url)
if m:
host = m.groups()[0]
path = m.groups()[1]
else:
m = re.match('http://(\S+)\s*', url)
if not m:
# Invalid URL
self.logprint("Invalid or unsupported URL: %s" % (url))
return
host = m.groups()[0]
path = ''
f = RetrieveAsFile(host,path,self.logprint)
if not f:
self.logprint("Could not open %s" % (url))
return
self.logprint("Receiving data...")
data = f.read()
tmp = open('tmphtml.txt','w')
fmt = formatter.AbstractFormatter(formatter.DumbWriter(tmp))
p = HTMLParser(fmt)
self.logprint("Parsing data...")
p.feed(data)
p.close()
tmp.close()
tmp = open('tmphtml.txt', 'r')
self.text.SetValue(tmp.read())
self.SetTitle(url)
self.logprint(url)
def OnFileOpen(self, event):
dlg = wxTextEntryDialog(self, "Enter URL to open:", "")
if dlg.ShowModal() == wxID_OK:
url = dlg.GetValue()
else:
url = None
if url:
self.OpenURL(url)
def OnFileExit(self, event):
self.Close()
def OnCloseWindow(self, event):
self.Destroy()
def ParseSlashdot(f):
art_sep = re.compile('%%\r?\n')
line_sep = re.compile('\r?\n')
data = f.read()
list = art_sep.split(data)
art_list = []
for i in range(1,len(list)-1):
art_list.append(line_sep.split(list[i]))
return art_list
def myprint(x):
print x
def RetrieveAsFile(host, path='', logprint = myprint):
try:
h = HTTP(host)
except:
logprint("Failed to create HTTP connection to %s... is the network available?" % (host))
return None
h.putrequest('GET',path)
h.putheader('Accept','text/html')
h.putheader('Accept','text/plain')
h.endheaders()
errcode, errmsg, headers = h.getreply()
if errcode != 200:
logprint("HTTP error code %d: %s" % (errcode, errmsg))
return None
f = h.getfile()
# f = open('/home/harm/ultramode.txt','r')
return f
class AppStatusBar(wxStatusBar):
def __init__(self, parent):
wxStatusBar.__init__(self,parent, -1)
self.SetFieldsCount(2)
self.SetStatusWidths([-1, 100])
self.but = wxButton(self, 1001, "Refresh")
EVT_BUTTON(self, 1001, parent.OnViewRefresh)
EVT_SIZE(self, self.OnSize)
self.OnSize(None)
def logprint(self,x):
self.SetStatusText(x,0)
def OnSize(self, event):
rect = self.GetFieldRect(1)
self.but.SetPosition(wxPoint(rect.x+2, rect.y+2))
self.but.SetSize(wxSize(rect.width-4, rect.height-4))
# This is a simple timer class to start a function after a short delay;
class QuickTimer(wxTimer):
def __init__(self, func, wait=100):
wxTimer.__init__(self)
self.callback = func
self.Start(wait); # wait .1 second (.001 second doesn't work. why?)
def Notify(self):
self.Stop();
apply(self.callback, ());
class AppFrame(wxFrame):
def __init__(self, parent, id, title):
wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition,
wxSize(650, 250))
# if the window manager closes the window:
EVT_CLOSE(self, self.OnCloseWindow);
# Now Create the menu bar and items
self.mainmenu = wxMenuBar()
menu = wxMenu()
menu.Append(209, 'E&xit', 'Enough of this already!')
EVT_MENU(self, 209, self.OnFileExit)
self.mainmenu.Append(menu, '&File')
menu = wxMenu()
menu.Append(210, '&Refresh', 'Refresh headlines')
EVT_MENU(self, 210, self.OnViewRefresh)
menu.Append(211, '&Slashdot Index', 'View Slashdot index')
EVT_MENU(self, 211, self.OnViewIndex)
menu.Append(212, 'Selected &Article', 'View selected article')
EVT_MENU(self, 212, self.OnViewArticle)
self.mainmenu.Append(menu, '&View')
menu = wxMenu()
menu.Append(220, '&Internal', 'Use internal text browser',TRUE)
menu.Check(220, true)
self.UseInternal = 1;
EVT_MENU(self, 220, self.OnBrowserInternal)
menu.Append(222, '&Settings...', 'External browser Settings')
EVT_MENU(self, 222, self.OnBrowserSettings)
self.mainmenu.Append(menu, '&Browser')
menu = wxMenu()
menu.Append(230, '&About', 'Some documentation');
EVT_MENU(self, 230, self.OnAbout)
self.mainmenu.Append(menu, '&Help')
self.SetMenuBar(self.mainmenu)
if wxPlatform == '__WXGTK__':
# I like lynx. Also Netscape 4.5 doesn't react to my cmdline opts
self.BrowserSettings = "xterm -e lynx %s &"
elif wxPlatform == '__WXMSW__':
# netscape 4.x likes to hang out here...
self.BrowserSettings = '\\progra~1\\Netscape\\Communicator\\Program\\netscape.exe %s'
else:
# a wild guess...
self.BrowserSettings = 'netscape %s'
# A status bar to tell people what's happening
self.sb = AppStatusBar(self)
self.SetStatusBar(self.sb)
self.list = wxListCtrl(self, 1100, style=wxLC_REPORT)
self.list.InsertColumn(0, 'Subject')
self.list.InsertColumn(1, 'Date')
self.list.InsertColumn(2, 'Posted by')
self.list.InsertColumn(3, 'Comments')
self.list.SetColumnWidth(0, 300)
self.list.SetColumnWidth(1, 150)
self.list.SetColumnWidth(2, 100)
self.list.SetColumnWidth(3, 100)
EVT_LIST_ITEM_SELECTED(self, 1100, self.OnItemSelected)
EVT_LEFT_DCLICK(self.list, self.OnLeftDClick)
self.logprint("Connecting to slashdot... Please wait.")
# wxYield doesn't yet work here. That's why we use a timer
# to make sure that we see some GUI stuff before the slashdot
# file is transfered.
self.timer = QuickTimer(self.DoRefresh, 1000)
def logprint(self, x):
self.sb.logprint(x)
def OnFileExit(self, event):
self.Destroy()
def DoRefresh(self):
f = RetrieveAsFile('slashdot.org','/ultramode.txt',self.sb.logprint)
art_list = ParseSlashdot(f)
self.list.DeleteAllItems()
self.url = []
self.current = -1
i = 0;
for article in art_list:
self.list.InsertStringItem(i, article[0])
self.list.SetStringItem(i, 1, article[2])
self.list.SetStringItem(i, 2, article[3])
self.list.SetStringItem(i, 3, article[6])
self.url.append(article[1])
i = i + 1
self.logprint("File retrieved OK.")
def OnViewRefresh(self, event):
self.logprint("Connecting to slashdot... Please wait.");
wxYield()
self.DoRefresh()
def DoViewIndex(self):
if self.UseInternal:
self.view = HTMLTextView(self, -1, 'slashdot.org',
'http://slashdot.org')
self.view.Show(true)
else:
self.logprint(self.BrowserSettings % ('http://slashdot.org'))
#os.system(self.BrowserSettings % ('http://slashdot.org'))
wxExecute(self.BrowserSettings % ('http://slashdot.org'))
self.logprint("OK")
def OnViewIndex(self, event):
self.logprint("Starting browser... Please wait.")
wxYield()
self.DoViewIndex()
def DoViewArticle(self):
if self.current<0: return
url = self.url[self.current]
if self.UseInternal:
self.view = HTMLTextView(self, -1, url, url)
self.view.Show(true)
else:
self.logprint(self.BrowserSettings % (url))
os.system(self.BrowserSettings % (url))
self.logprint("OK")
def OnViewArticle(self, event):
self.logprint("Starting browser... Please wait.")
wxYield()
self.DoViewArticle()
def OnBrowserInternal(self, event):
if self.mainmenu.Checked(220):
self.UseInternal = 1
else:
self.UseInternal = 0
def OnBrowserSettings(self, event):
dlg = wxTextEntryDialog(self, "Enter command to view URL.\nUse %s as a placeholder for the URL.", "", self.BrowserSettings);
if dlg.ShowModal() == wxID_OK:
self.BrowserSettings = dlg.GetValue()
def OnAbout(self, event):
dlg = wxMessageDialog(self, __doc__, "wxSlash", wxOK | wxICON_INFORMATION)
dlg.ShowModal()
def OnItemSelected(self, event):
self.current = event.m_itemIndex
self.logprint("URL: %s" % (self.url[self.current]))
def OnLeftDClick(self, event):
(x,y) = event.Position();
# Actually, we should convert x,y to logical coords using
# a dc, but only for a wxScrolledWindow widget.
# Now wxGTK derives wxListCtrl from wxScrolledWindow,
# and wxMSW from wxControl... So that doesn't work.
#dc = wxClientDC(self.list)
##self.list.PrepareDC(dc)
#x = dc.DeviceToLogicalX( event.GetX() )
#y = dc.DeviceToLogicalY( event.GetY() )
id = self.list.HitTest(wxPoint(x,y))
#print "Double click at %d %d" % (x,y), id
# Okay, we got a double click. Let's assume it's the current selection
wxYield()
self.OnViewArticle(event)
def OnCloseWindow(self, event):
self.Destroy()
#---------------------------------------------------------------------------
# if running standalone
if __name__ == '__main__':
class MyApp(wxApp):
def OnInit(self):
frame = AppFrame(NULL, -1, "Slashdot Breaking News")
frame.Show(true)
self.SetTopWindow(frame)
return true
app = MyApp(0)
app.MainLoop()
#---------------------------------------------------------------------------
# if running as part of the Demo Framework...
def runTest(frame, nb, log):
win = AppFrame(NULL, -1, "Slashdot Breaking News")
frame.otherWin = win
win.Show(true)
overview = __doc__
#----------------------------------------------------------------------------

244
wxPython/demo/Threads.py Normal file
View File

@@ -0,0 +1,244 @@
from wxPython.wx import *
import thread
import time
from whrandom import random
#----------------------------------------------------------------------
wxEVT_UPDATE_BARGRAPH = 25015
def EVT_UPDATE_BARGRAPH(win, func):
win.Connect(-1, -1, wxEVT_UPDATE_BARGRAPH, func)
class UpdateBarEvent(wxPyEvent):
def __init__(self, barNum, value):
wxPyEvent.__init__(self)
self.SetEventType(wxEVT_UPDATE_BARGRAPH)
self.barNum = barNum
self.value = value
#----------------------------------------------------------------------
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:
evt = UpdateBarEvent(self.barNum, int(self.val))
wxPostEvent(self.win, evt)
del evt
sleeptime = (random() * 2) + 0.5
#print self.barNum, 'sleeping for', sleeptime
time.sleep(sleeptime)
sleeptime = sleeptime * 5
if int(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(wxWindow):
def __init__(self, parent, labels):
wxWindow.__init__(self, parent, -1)
self.values = []
for label in labels:
self.values.append((label, 0))
self.font = wxFont(12, wxSWISS, wxNORMAL, wxBOLD)
self.SetFont(self.font)
self.colors = [ wxRED, wxGREEN, wxBLUE, wxCYAN,
wxNamedColour("Yellow"), wxNamedColor("Navy") ]
EVT_ERASE_BACKGROUND(self, self.OnEraseBackground)
EVT_PAINT(self, 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):
wxWindow.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 Draw(self, dc, size):
dc.SetFont(self.font)
dc.SetTextForeground(wxBLUE)
dc.SetBackground(wxBrush(self.GetBackgroundColour()))
dc.Clear()
dc.SetPen(wxPen(wxBLACK, 3, wxSOLID))
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(wxPen(color))
dc.SetBrush(wxBrush(color))
dc.DrawRectangle(self.linePos+3, ypos, val, bh)
ypos = ypos + 2*bh
if ypos > size.height-10:
break
def OnPaint(self, evt):
size = self.GetSize()
bmp = wxEmptyBitmap(size.width, size.height)
dc = wxMemoryDC()
dc.SelectObject(bmp)
self.Draw(dc, size)
wdc = wxPaintDC(self)
wdc.BeginDrawing()
wdc.Blit(0,0, size.width, size.height, dc, 0,0)
wdc.EndDrawing()
dc.SelectObject(wxNullBitmap)
def OnEraseBackground(self, evt):
pass
#----------------------------------------------------------------------
class TestFrame(wxFrame):
def __init__(self, parent, log):
wxFrame.__init__(self, parent, -1, "Thread Test", size=(450,300))
self.log = log
#self.CenterOnParent()
panel = wxPanel(self, -1)
panel.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD))
wxStaticText(panel, -1,
"This demo shows multiple threads interacting with this\n"
"window by sending events to it.", wxPoint(5,5))
panel.Fit()
self.graph = GraphWindow(self, ['Zero', 'One', 'Two', 'Three', 'Four',
'Five', 'Six', 'Seven'])
sizer = wxBoxSizer(wxVERTICAL)
sizer.Add(panel, 0, wxEXPAND)
sizer.Add(self.graph, 1, wxEXPAND)
self.SetSizer(sizer)
self.SetAutoLayout(true)
#self.graph.SetValue(0, 25)
#self.graph.SetValue(1, 50)
#self.graph.SetValue(2, 75)
#self.graph.SetValue(3, 100)
EVT_UPDATE_BARGRAPH(self, 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()
EVT_CLOSE(self, self.OnCloseWindow)
def OnUpdate(self, evt):
self.graph.SetValue(evt.barNum, evt.value)
self.graph.Refresh(false)
def OnCloseWindow(self, evt):
busy = wxBusyInfo("One moment please, waiting for threads to die...")
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()
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestFrame(frame, log)
frame.otherWin = win
win.Show(true)
return None
#----------------------------------------------------------------------
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 severly 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 wxPostEvent 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.
"""

67
wxPython/demo/XMLtreeview.py Normal file
View File

@@ -0,0 +1,67 @@
import string
from wxPython.wx import *
try:
from xml.parsers import pyexpat
haveXML = true
except ImportError:
haveXML = false
#----------------------------------------------------------------------
if not haveXML:
def runTest(frame, nb, log):
dlg = wxMessageDialog(frame, 'This demo requires the XML package. See http://www.python.org/sigs/xml-sig/',
'Sorry', wxOK | wxICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
else:
class XMLTree(wxTreeCtrl):
def __init__(self, parent, ID):
wxTreeCtrl.__init__(self, parent, ID)
self.nodeStack = [self.AddRoot("Root")]
# Define a handler for start element events
def StartElement(self, name, attrs ):
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 string.strip(data):
self.AppendItem(self.nodeStack[-1], data)
def LoadTree(self, filename):
# Create a parser
Parser = pyexpat.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 = """\
"""

1
wxPython/demo/bitmaps/.cvsignore Normal file
View File

@@ -0,0 +1 @@
new.bmp.test

BIN
wxPython/demo/bitmaps/01c.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 545 B

BIN
wxPython/demo/bitmaps/10s.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 990 B

BIN
wxPython/demo/bitmaps/12h.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.7 KiB

BIN
wxPython/demo/bitmaps/13d.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.7 KiB

BIN
wxPython/demo/bitmaps/Calend.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 630 B

BIN
wxPython/demo/bitmaps/DbDec.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 630 B

BIN
wxPython/demo/bitmaps/DbInc.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 630 B

BIN
wxPython/demo/bitmaps/Dec.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 630 B

BIN
wxPython/demo/bitmaps/Inc.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 630 B

BIN
wxPython/demo/bitmaps/Pt.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 630 B

BIN
wxPython/demo/bitmaps/backgrnd.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
wxPython/demo/bitmaps/copy.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 238 B

BIN
wxPython/demo/bitmaps/image.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 56 KiB

BIN
wxPython/demo/bitmaps/image.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.9 KiB

BIN
wxPython/demo/bitmaps/image.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 7.9 KiB

BIN
wxPython/demo/bitmaps/image.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 18 KiB

BIN
wxPython/demo/bitmaps/lb1.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.6 KiB

BIN
wxPython/demo/bitmaps/lb2.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.7 KiB

BIN
wxPython/demo/bitmaps/mondrian.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 766 B

BIN
wxPython/demo/bitmaps/new.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 238 B

BIN
wxPython/demo/bitmaps/open.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 238 B

BIN
wxPython/demo/bitmaps/paste.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 238 B

BIN
wxPython/demo/bitmaps/smiles.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 246 B

BIN
wxPython/demo/bitmaps/smiles.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 766 B

BIN
wxPython/demo/bitmaps/splash.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 89 KiB

BIN
wxPython/demo/bitmaps/test2.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 12 KiB

BIN
wxPython/demo/bitmaps/test_image.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.3 KiB

BIN
wxPython/demo/bitmaps/test_mask.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.0 KiB

BIN
wxPython/demo/bitmaps/tog1.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 238 B

BIN
wxPython/demo/bitmaps/tog2.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 238 B

2
wxPython/demo/data/.cvsignore Normal file
View File

@@ -0,0 +1,2 @@
golf.pdf
showTips

1749
wxPython/demo/data/grid.i Normal file
View File

File diff suppressed because it is too large Load Diff

20
wxPython/demo/data/imagemap.htm Normal file
View File

@@ -0,0 +1,20 @@
<html>
<head>
<title>ImageMap Test</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>
<body bgcolor="#FFFFFF" text="#FFFFFF">
This is test.
<img src="imagemap.png" width="269" height="249" border="0" usemap="#mymap">
<map name="mymap">
<area shape="poly" coords="187,85,160,121,163,153,180,129,166,225,241,223,230,155,201,121,187,86" href="test.htm">
<area shape="circle" coords="96,89,36" href="fft.html">
<area shape="rect" coords="43,168,124,213" href="tables.htm">
</map>
<img src="imagemap.png" usemap="#mymap">
</body>
</html>

BIN
wxPython/demo/data/imagemap.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.2 KiB

BIN
wxPython/demo/data/pic.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 31 KiB

BIN
wxPython/demo/data/pic2.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 23 KiB

627
wxPython/demo/data/stc.h Normal file
View File

@@ -0,0 +1,627 @@
////////////////////////////////////////////////////////////////////////////
// Name: stc.h
// Purpose: A wxWindows 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>
//----------------------------------------------------------------------
// constants and stuff
enum wxSTC_UndoType {
wxSTC_UndoCollectNone,
wxSTC_UndoCollectAutoStart
};
enum wxSTC_EOL {
wxSTC_EOL_CRLF,
wxSTC_EOL_CR,
wxSTC_EOL_LF
};
enum wxSTC_EDGE {
wxSTC_EDGE_NONE,
wxSTC_EDGE_LINE,
wxSTC_EDGE_BACKGROUND
};
const int wxSTC_LEX_STYLE_MAX = 31;
const int wxSTC_STYLE_DEFAULT = 32;
const int wxSTC_STYLE_LINENUMBER = 33;
const int wxSTC_STYLE_BRACELIGHT = 34;
const int wxSTC_STYLE_BRACEBAD = 35;
const int wxSTC_STYLE_CONTROLCHAR = 36;
const int wxSTC_STYLE_MAX = 127;
const int wxSTC_STYLE_MASK = 31;
const int wxSTC_MARKER_MAX = 31;
const int wxSTC_MARK_CIRCLE = 0;
const int wxSTC_MARK_ROUNDRECT = 1;
const int wxSTC_MARK_ARROW = 2;
const int wxSTC_MARK_SMALLRECT = 3;
const int wxSTC_MARK_SHORTARROW = 4;
const int wxSTC_MARK_EMPTY = 5;
const int wxSTC_MARK_ARROWDOWN = 6;
const int wxSTC_MARK_MINUS = 7;
const int wxSTC_MARK_PLUS = 8;
const int wxSTC_MARKNUM_FOLDER = 30;
const int wxSTC_MARKNUM_FOLDEROPEN= 31;
const int wxSTC_MASK_FOLDERS = ((1 << wxSTC_MARKNUM_FOLDER) | (1 << wxSTC_MARKNUM_FOLDEROPEN));
const int wxSTC_INDIC_MAX = 7;
const int wxSTC_INDIC_PLAIN = 0;
const int wxSTC_INDIC_SQUIGGLE = 1;
const int wxSTC_INDIC_TT = 2;
const int wxSTC_INDIC0_MASK = 32;
const int wxSTC_INDIC1_MASK = 64;
const int wxSTC_INDIC2_MASK = 128;
const int wxSTC_INDICS_MASK = (wxSTC_INDIC0_MASK | wxSTC_INDIC1_MASK | wxSTC_INDIC2_MASK);
const int wxSTC_FOLDLEVELBASE = 0x0400;
const int wxSTC_FOLDLEVELWHITEFLAG = 0x1000;
const int wxSTC_FOLDLEVELHEADERFLAG = 0x2000;
const int wxSTC_FOLDLEVELNUMBERMASK = 0x0FFF;
// key commands
enum {
wxSTC_CMD_LINEDOWN = 2300,
wxSTC_CMD_LINEDOWNEXTEND,
wxSTC_CMD_LINEUP,
wxSTC_CMD_LINEUPEXTEND,
wxSTC_CMD_CHARLEFT,
wxSTC_CMD_CHARLEFTEXTEND,
wxSTC_CMD_CHARRIGHT,
wxSTC_CMD_CHARRIGHTEXTEND,
wxSTC_CMD_WORDLEFT,
wxSTC_CMD_WORDLEFTEXTEND,
wxSTC_CMD_WORDRIGHT,
wxSTC_CMD_WORDRIGHTEXTEND,
wxSTC_CMD_HOME,
wxSTC_CMD_HOMEEXTEND,
wxSTC_CMD_LINEEND,
wxSTC_CMD_LINEENDEXTEND,
wxSTC_CMD_DOCUMENTSTART,
wxSTC_CMD_DOCUMENTSTARTEXTEND,
wxSTC_CMD_DOCUMENTEND,
wxSTC_CMD_DOCUMENTENDEXTEND,
wxSTC_CMD_PAGEUP,
wxSTC_CMD_PAGEUPEXTEND,
wxSTC_CMD_PAGEDOWN,
wxSTC_CMD_PAGEDOWNEXTEND,
wxSTC_CMD_EDITTOGGLEOVERTYPE,
wxSTC_CMD_CANCEL,
wxSTC_CMD_DELETEBACK,
wxSTC_CMD_TAB,
wxSTC_CMD_BACKTAB,
wxSTC_CMD_NEWLINE,
wxSTC_CMD_FORMFEED,
wxSTC_CMD_VCHOME,
wxSTC_CMD_VCHOMEEXTEND,
wxSTC_CMD_ZOOMIN,
wxSTC_CMD_ZOOMOUT,
wxSTC_CMD_DELWORDLEFT,
wxSTC_CMD_DELWORDRIGHT,
wxSTC_CMD_LINECUT,
wxSTC_CMD_LINEDELETE,
wxSTC_CMD_LINETRANSPOSE,
wxSTC_CMD_LOWERCASE,
wxSTC_CMD_UPPERCASE,
wxSTC_CMD_LINESCROLLDOWN,
wxSTC_CMD_LINESCROLLUP
};
enum wxSTC_LEX {
wxSTC_LEX_CONTAINER=0,
wxSTC_LEX_NULL,
wxSTC_LEX_PYTHON,
wxSTC_LEX_CPP,
wxSTC_LEX_HTML,
wxSTC_LEX_XML,
wxSTC_LEX_PERL,
wxSTC_LEX_SQL,
wxSTC_LEX_VB,
wxSTC_LEX_PROPERTIES,
wxSTC_LEX_ERRORLIST,
wxSTC_LEX_MAKEFILE,
wxSTC_LEX_BATCH,
};
const int wxSTC_CARET_SLOP = 0x01;
const int WXSTC_CARET_CENTER = 0x02;
const int wxSTC_CARET_STRICT = 0x04;
const int wxSTC_MARGIN_SYMBOL = 0;
const int wxSTC_MARGIN_NUMBER = 1;
class ScintillaWX; // forward declare
class WordList;
struct SCNotification;
extern const wxChar* wxSTCNameStr;
//----------------------------------------------------------------------
class wxStyledTextCtrl : public wxControl {
public:
#ifdef SWIG
wxStyledTextCtrl(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const char* name = wxSTCNameStr);
#else
wxStyledTextCtrl(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0,
const wxString& name = wxSTCNameStr);
#endif
#ifndef SWIG
~wxStyledTextCtrl();
#endif
// Text retrieval and modification
wxString GetText();
bool SetText(const wxString& text);
wxString GetLine(int line);
void ReplaceSelection(const wxString& text);
void SetReadOnly(bool readOnly);
bool GetReadOnly();
wxString GetTextRange(int startPos, int endPos);
wxString GetStyledTextRange(int startPos, int endPos);
#ifndef SWIG
void GetTextRange(int startPos, int endPos, char* buff);
void GetStyledTextRange(int startPos, int endPos, char* buff);
#endif
void AddText(const wxString& text);
void AddStyledText(const wxString& text);
void InsertText(int pos, const wxString& text);
void ClearAll();
char GetCharAt(int pos);
char GetStyleAt(int pos);
void SetStyleBits(int bits);
int GetStyleBits();
// Clipboard
void Cut();
void Copy();
void Paste();
bool CanPaste();
void ClearClipbrd(); // avoiding name conflict with virtual in wxWindow
// Undo and Redo
void Undo();
bool CanUndo();
void EmptyUndoBuffer();
void Redo();
bool CanRedo();
void SetUndoCollection(wxSTC_UndoType type);
wxSTC_UndoType GetUndoCollection();
void BeginUndoAction();
void EndUndoAction();
// Selection and information
#ifdef SWIG
void GetSelection(int* OUTPUT, int* OUTPUT);
#else
void GetSelection(int* startPos, int* endPos);
#endif
void SetSelection(int startPos, int endPos);
wxString GetSelectedText();
void HideSelection(bool hide);
bool GetHideSelection();
int GetTextLength();
int GetFirstVisibleLine();
bool GetModified();
int GetLineCount();
wxRect GetRect();
int GetLineFromPos(int pos);
int GetLineStartPos(int line);
int GetLineLengthAtPos(int pos);
int GetLineLength(int line);
#ifdef SWIG
wxString GetCurrentLineText(int* OUTPUT);
#else
wxString GetCurrentLineText(int* linePos);
#endif
int GetCurrentLine();
int PositionFromPoint(wxPoint pt);
int LineFromPoint(wxPoint pt);
wxPoint PointFromPosition(int pos);
int GetCurrentPos();
int GetAnchor();
void SelectAll();
void SetCurrentPosition(int pos);
void SetAnchor(int pos);
void GotoPos(int pos);
void GotoLine(int line);
void ChangePosition(int delta, bool extendSelection);
void PageMove(int cmdKey, bool extendSelection);
void ScrollBy(int columnDelta, int lineDelta);
void ScrollToLine(int line);
void ScrollToColumn(int column);
void EnsureCaretVisible();
void SetCaretPolicy(int policy, int slop=0);
int GetSelectionType();
int GetLinesOnScreen();
bool IsSelectionRectangle();
void SetUseHorizontalScrollBar(bool use);
bool GetUseHorizontalScrollBar();
// Searching
int FindText(int minPos, int maxPos, const wxString& text,
bool caseSensitive, bool wholeWord);
void SearchAnchor();
int SearchNext(const wxString& text, bool caseSensitive, bool wholeWord);
int SearchPrev(const wxString& text, bool caseSensitive, bool wholeWord);
// Visible whitespace
bool GetViewWhitespace();
void SetViewWhitespace(bool visible);
// Line endings
wxSTC_EOL GetEOLMode();
void SetEOLMode(wxSTC_EOL mode);
bool GetViewEOL();
void SetViewEOL(bool visible);
void ConvertEOL(wxSTC_EOL mode);
// Styling
int GetEndStyled();
void StartStyling(int pos, int mask);
void SetStyleFor(int length, int style);
void SetStyleBytes(int length, char* styleBytes);
void SetLineState(int line, int value);
int GetLineState(int line);
// Style Definition
void StyleClearAll();
void StyleResetDefault();
void StyleSetSpec(int styleNum, const wxString& spec);
void StyleSetForeground(int styleNum, const wxColour& colour);
void StyleSetBackground(int styleNum, const wxColour& colour);
void StyleSetFont(int styleNum, wxFont& font);
void StyleSetFontAttr(int styleNum, int size, const wxString& faceName, bool bold, bool italic);
void StyleSetBold(int styleNum, bool bold);
void StyleSetItalic(int styleNum, bool italic);
void StyleSetFaceName(int styleNum, const wxString& faceName);
void StyleSetSize(int styleNum, int pointSize);
void StyleSetEOLFilled(int styleNum, bool fillEOL);
// Margins in the edit area
int GetLeftMargin();
int GetRightMargin();
void SetMargins(int left, int right);
// Margins for selection, markers, etc.
void SetMarginType(int margin, int type);
int GetMarginType(int margin);
void SetMarginWidth(int margin, int pixelWidth);
int GetMarginWidth(int margin);
void SetMarginMask(int margin, int mask);
int GetMarginMask(int margin);
void SetMarginSensitive(int margin, bool sensitive);
bool GetMarginSensitive(int margin);
// Selection and Caret styles
void SetSelectionForeground(const wxColour& colour);
void SetSelectionBackground(const wxColour& colour);
void SetCaretForeground(const wxColour& colour);
int GetCaretPeriod();
void SetCaretPeriod(int milliseconds);
// Other settings
void SetBufferedDraw(bool isBuffered);
void SetTabWidth(int numChars);
void SetIndent(int numChars);
void SetUseTabs(bool usetabs);
void SetLineIndentation(int line, int indentation);
int GetLineIndentation(int line);
int GetLineIndentationPos(int line);
void SetWordChars(const wxString& wordChars);
void SetUsePop(bool usepopup);
// Brace highlighting
void BraceHighlight(int pos1, int pos2);
void BraceBadlight(int pos);
int BraceMatch(int pos, int maxReStyle=0);
// Markers
void MarkerDefine(int markerNumber, int markerSymbol,
const wxColour& foreground,
const wxColour& background);
void MarkerSetType(int markerNumber, int markerSymbol);
void MarkerSetForeground(int markerNumber, const wxColour& colour);
void MarkerSetBackground(int markerNumber, const wxColour& colour);
int MarkerAdd(int line, int markerNumber);
void MarkerDelete(int line, int markerNumber);
void MarkerDeleteAll(int markerNumber);
int MarkerGet(int line);
int MarkerGetNextLine(int lineStart, int markerMask);
int MarkerGetPrevLine(int lineStart, int markerMask);
int MarkerLineFromHandle(int handle);
void MarkerDeleteHandle(int handle);
// Indicators
void IndicatorSetStyle(int indicNum, int indicStyle);
int IndicatorGetStyle(int indicNum);
void IndicatorSetColour(int indicNum, const wxColour& colour);
// Auto completion
void AutoCompShow(const wxString& listOfWords);
void AutoCompCancel();
bool AutoCompActive();
int AutoCompPosAtStart();
void AutoCompComplete();
void AutoCompStopChars(const wxString& stopChars);
void AutoCompSetSeparator(char separator);
char AutoCompGetSeparator();
void AutoCompSelect(const wxString& stringtoselect);
// Call tips
void CallTipShow(int pos, const wxString& text);
void CallTipCancel();
bool CallTipActive();
int CallTipPosAtStart();
void CallTipSetHighlight(int start, int end);
void CallTipSetBackground(const wxColour& colour);
// Key bindings
void CmdKeyAssign(int key, int modifiers, int cmd);
void CmdKeyClear(int key, int modifiers);
void CmdKeyClearAll();
void CmdKeyExecute(int cmd);
// Print formatting
int FormatRange(bool doDraw,
int startPos,
int endPos,
wxDC* draw,
wxDC* target, // Why does it use two? Can they be the same?
wxRect renderRect,
wxRect pageRect);
// Document Sharing (multiple views)
void* GetDocument();
void SetDocument(void* document);
// TODO: create a wx wrapper for Scintilla's document class
// Folding
int VisibleFromDocLine(int docLine);
int DocLineFromVisible(int displayLine);
int SetFoldLevel(int line, int level);
int GetFoldLevel(int line);
int GetLastChild(int line, int level);
int GetFoldParent(int line);
void ShowLines(int lineStart, int lineEnd);
void HideLines(int lineStart, int lineEnd);
bool GetLineVisible(int line);
void SetFoldExpanded(int line, bool expanded);
bool GetFoldExpanded(int line);
void ToggleFold(int line);
void EnsureVisible(int line);
void SetFoldFlags(int flags);
// Long Lines
int GetEdgeColumn();
void SetEdgeColumn(int column);
wxSTC_EDGE GetEdgeMode();
void SetEdgeMode(wxSTC_EDGE mode);
wxColour GetEdgeColour();
void SetEdgeColour(const wxColour& colour);
// Lexer
void SetLexer(wxSTC_LEX lexer);
wxSTC_LEX GetLexer();
void Colourise(int start, int end);
void SetProperty(const wxString& key, const wxString& value);
void SetKeywords(int keywordSet, const wxString& keywordList);
#ifndef SWIG
private:
// Event handlers
void OnPaint(wxPaintEvent& evt);
void OnScrollWin(wxScrollWinEvent& evt);
void OnSize(wxSizeEvent& evt);
void OnMouseLeftDown(wxMouseEvent& evt);
void OnMouseMove(wxMouseEvent& evt);
void OnMouseLeftUp(wxMouseEvent& evt);
void OnMouseRightUp(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);
// Turn notifications from Scintilla into events
void NotifyChange();
void NotifyParent(SCNotification* scn);
long SendMsg(int msg, long wp=0, long lp=0);
private:
DECLARE_EVENT_TABLE()
DECLARE_CLASS(wxStyledTextCtrl)
ScintillaWX* m_swx;
wxStopWatch m_stopWatch;
bool m_readOnly;
wxSTC_UndoType m_undoType;
friend class ScintillaWX;
friend class Platform;
#endif
};
//----------------------------------------------------------------------
class wxStyledTextEvent : public wxCommandEvent {
public:
wxStyledTextEvent(wxEventType commandType=0, int id=0);
~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 char* 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; }
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; }
bool GetShift() const;
bool GetControl() const;
bool GetAlt() const;
void CopyObject(wxObject& obj) const;
#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;
#endif
};
enum {
wxEVT_STC_CHANGE = 1650,
wxEVT_STC_STYLENEEDED,
wxEVT_STC_CHARADDED,
wxEVT_STC_UPDATEUI,
wxEVT_STC_SAVEPOINTREACHED,
wxEVT_STC_SAVEPOINTLEFT,
wxEVT_STC_ROMODIFYATTEMPT,
wxEVT_STC_DOUBLECLICK,
wxEVT_STC_MODIFIED,
wxEVT_STC_KEY,
wxEVT_STC_MACRORECORD,
wxEVT_STC_MARGINCLICK,
wxEVT_STC_NEEDSHOWN
};
#ifndef SWIG
typedef void (wxEvtHandler::*wxStyledTextEventFunction)(wxStyledTextEvent&);
#define EVT_STC_CHANGE(id, fn) { wxEVT_STC_CHANGE, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_STYLENEEDED(id, fn) { wxEVT_STC_STYLENEEDED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_CHARADDED(id, fn) { wxEVT_STC_CHARADDED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_UPDATEUI(id, fn) { wxEVT_STC_UPDATEUI, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_SAVEPOINTREACHED(id, fn) { wxEVT_STC_SAVEPOINTREACHED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_SAVEPOINTLEFT(id, fn) { wxEVT_STC_SAVEPOINTLEFT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_ROMODIFYATTEMPT(id, fn) { wxEVT_STC_ROMODIFYATTEMPT, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_DOUBLECLICK(id, fn) { wxEVT_STC_DOUBLECLICK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_MODIFIED(id, fn) { wxEVT_STC_MODIFIED, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_KEY(id, fn) { wxEVT_STC_KEY, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_MACRORECORD(id, fn) { wxEVT_STC_MACRORECORD, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_MARGINCLICK(id, fn) { wxEVT_STC_MARGINCLICK, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#define EVT_STC_NEEDSHOWN(id, fn) { wxEVT_STC_NEEDSHOWN, id, -1, (wxObjectEventFunction) (wxEventFunction) (wxStyledTextEventFunction) & fn, (wxObject *) NULL },
#endif
//----------------------------------------------------------------------
//----------------------------------------------------------------------
#endif

119
wxPython/demo/data/tables.htm Normal file
View File

@@ -0,0 +1,119 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
<META NAME="GENERATOR" CONTENT="Mozilla/4.06 [en] (X11; I; Linux 2.0.35 i686) [Netscape]">
</HEAD>
<BODY TEXT="#000000" BGCOLOR="#FFFFFF" LINK="#0000EF" VLINK="#51188E" ALINK="#FF0000">
<H3>
This is TABLES
tests page...</H3>
(yes, really, see bellow:)
<BR>Click <a href="test.htm">here</a> to go to original testing page...
<BR>Click
<a href="http://www.lpthe.jussieu.fr/~zeitlin/wxWindows/docs/">here</a>
to go to manuals...
<BR>&nbsp;
<CENTER><TABLE CELLSPACING=5 BORDER COLS=2 WIDTH="40%" NOSAVE >
<TR ALIGN=CENTER NOSAVE>
<TD WIDTH="40%" NOSAVE>Top left
<BR>(two lines expression)
<P>paragraph done</TD>
<TD NOSAVE>Top right</TD>
</TR>
<TR>
<TD>Bottom left</TD>
<TD>Bottom right</TD>
</TR>
</TABLE></CENTER>
<P>Subsampling is shown there:
<BR>&nbsp;
<TABLE BORDER COLS=2 WIDTH="100%" NOSAVE >
<TR NOSAVE>
<TD VALIGN=BOTTOM NOSAVE>
<TABLE BORDER COLS=2 WIDTH="50%" NOSAVE >
<TR ALIGN=CENTER BGCOLOR="#3366FF" NOSAVE>
<TD>a</TD>
<TD WIDTH="10%" NOSAVE>b</TD>
</TR>
<TR NOSAVE>
<TD>c</TD>
<TD NOSAVE>d</TD>
</TR>
</TABLE>
</TD>
<TD VALIGN=BOTTOM NOSAVE>2</TD>
</TR>
<TR NOSAVE>
<TD>3 dflkj lkjfl dkjldkfjl flk jflkf lkjflkj ljlf ajlfj alff h khg hgj
gjg jg gjhfg fg gjh gjf jgf jgj f gjfgj kfajg&nbsp;</TD>
<TD ALIGN=CENTER VALIGN=BOTTOM BGCOLOR="#FFFF99" NOSAVE>4
<BR>gh
<BR>gfh
<BR>gh
<BR>hg
<BR>5</TD>
</TR>
</TABLE>
<P>This is "default" table - with no sizes givev:
<BR>&nbsp;
<TABLE BORDER COLS=4 WIDTH="100%" NOSAVE >
<TR NOSAVE>
<TD>Hello</TD>
<TD NOSAVE>lkfdsjlk fj dlfj lkfj lkjflk jlfk lk fjlk elwkf lkejflek f jlekjflkj
ljlk lk jlkf lefjl j flkj ljl lf lfj lfjl lj lwe lekf;eh kfejh lkh kjh
kjhkj hkj hkj lkh kjh kjlh kj</TD>
<TD>shortebn formo lr lk</TD>
<TD>djsf lkjlf poer oi pjr po kpk&nbsp;</TD>
</TR>
<TR>
<TD>a</TD>
<TD>b</TD>
<TD>c</TD>
<TD>d</TD>
</TR>
<TR NOSAVE>
<TD>1</TD>
<TD>2</TD>
<TD COLSPAN="2" ROWSPAN="2" NOSAVE>3</TD>
</TR>
<TR>
<TD>A</TD>
<TD>B</Td>
</TR>
</TABLE>

248
wxPython/demo/data/test.htm Normal file
View File

@@ -0,0 +1,248 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
<META NAME="GENERATOR" CONTENT="Mozilla/4.06 [en] (X11; I; Linux
2.0.35 i686) [Netscape]">
<TITLE>wxPython does wxHTML!</TITLE>
</HEAD>
<BODY TEXT="#000000" BGCOLOR="#007f00" LINK="#0000FF" VLINK="#FF0000" ALINK="#000088">
<b><a href="tables.htm">click here to go to tables test page!</a></b>
<p>
<b><a href="imagemap.htm">click here to go to IMAGEMAPs test page!</a></b>
<p>
This is - - default text, now switching to
<CENTER>
<P>center, now still ctr, now exiting</CENTER>
exited!.<A HREF="#downtown">[link to down]</A>
<P>Hello, this *is* default charset (helvetica, probably) and it is displayed
with one&nbsp; <FONT COLOR="#FF0000">COLOR CHANGE</FONT>. Of course we
can have as many color changes as we can, what about this <FONT COLOR="#FF0000">M</FONT><FONT COLOR="#FFFF00">A</FONT><FONT COLOR="#33FF33">D</FONT><B><FONT COLOR="#FFFFFF"><FONT SIZE=+1>N</FONT></FONT></B>E<FONT COLOR="#999999">S</FONT><FONT COLOR="#CC33CC">S?</FONT>
<P><FONT COLOR="#000000">There was a space above.</FONT>
<BR>
<HR WIDTH="100%">This was a line. <TT>(BTW we are in <B>fixed</B> font
/ <I><U>typewriter</U> font</I> right now :-)</TT>
<BR>This is in <B>BOLD</B> face. This is <I>ITALIC.</I> This is <B><I><U>E
V E R Y T H I N G</U></I></B>.
<BR>&nbsp;
<P><BR>
<CENTER>
<P>Right now, <FONT COLOR="#0000FF"><FONT SIZE=+4>centered REALLY Big Text</FONT></FONT>,
how do you like (space) it?</CENTER>
<DIV ALIGN=right>RIGHT: <FONT SIZE=-2>text-2, </FONT><FONT SIZE=-1>text-1,
</FONT>text+0,
<FONT SIZE=+1>text+1,
</FONT><FONT COLOR="#FF0000"><FONT SIZE=+2>text+2,
</FONT></FONT><FONT SIZE=+3>text+3,
</FONT><FONT SIZE=+4>text+4</FONT>
<BR><U><FONT SIZE=+1>we are right now</FONT></U></DIV>
<CENTER><U><FONT SIZE=+1>we are center now</FONT></U></CENTER>
<U><FONT SIZE=+1>we are left now.</FONT></U>
<P><I><FONT COLOR="#3366FF">Blue italic text is displayed there....</FONT></I>
<H1>
<HR ALIGN=LEFT SIZE=10 WIDTH="50%">This is heading one.</H1>
this is normal
<CENTER>
<H1>
This is <FONT COLOR="#33FF33">CENTERED</FONT> heading one</H1></CENTER>
<FONT COLOR="#FFFF00">Yes, hmmmmmmmmm........, right now, <TT>we should
display some tiny nice image</TT>, he?</FONT>
<BR><IMG SRC="pic.png" ALT="Testing image image" ><IMG SRC="pic2.bmp">and this is text......
<P><IMG SRC="pic.png" ALT="Testing image image" HEIGHT=200 WIDTH=327 ALIGN=CENTER>and
this is text......
<BR><A HREF="pic.png"><IMG SRC="pic.png" ALT="Testing image image" HEIGHT=160 WIDTH=100 ALIGN=TEXTTOP></A> (try clicking on the image :-) and
this is text......
<BR>&nbsp;
<BR>&nbsp;
<UL>
<LI>
item 1</LI>
<LI>
item 2</LI>
<UL>
<LI>
nested item</LI>
<LI>
nested item 2</LI>
</UL>
<LI>
item 3</LI>
</UL>
<OL>
<LI>
item one</LI>
<LI>
item two</LI>
<OL>
<LI>
nsted item</LI>
</OL>
<LI>
last numbered item</LI>
</OL>
<H1>
Heading 1</H1>
<I>Italic text now...</I>
<H2>
<I>Heading 2</I></H2>
<I>and now?</I>
<H3>
Heading 3</H3>
<H4>
Heading 4</H4>
<H5>
Heading 5</H5>
<H6>
Heading 6</H6>
And this is normal text, once again :-)
<BR>&nbsp;
<BR>&nbsp;
<BR>&nbsp;
<BR>&nbsp;
<BR>&nbsp;
<BR>&nbsp;
<P>And yes, we're in <FONT SIZE=+4>HTML DOCUMENT</FONT>
<P>hello?
<BR>&nbsp;
<P><BR>
<CENTER>
<P>This is <A NAME="downtown"></a>centered paragraph</CENTER>
<P>This is new par?
<P><B>We switched to BOLD</B>
<P><B>This is new paragraph</B> Bold is off now.
<P>new par
<P>&nbsp; -----------
<P><FONT SIZE=-2>Hello</FONT>
<OL><FONT SIZE=-2>this is standalone :-)</FONT>
<LI>
<FONT SIZE=-2>This is item number one. iti lkdjfdl kjd lk jlkjdl kjlk jlf
jflkj d lfkjlkf jl jflkj flkwe lkhelf ;fk;fl kw;lfke ;ffj lkjflk wj lfjl
fkw ;k;ekf;lkfe ;kf;lk; ;j ;lrj;wfj;f ;eljfw; lfj;ewlfj dagdja gdj chga
kjegiquw iuqdb qiud iquwd hurray googoo.</FONT></LI>
<LI>
<FONT SIZE=-2>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</FONT></LI>
<BLOCKQUOTE><FONT SIZE=+0><B>(blockquote)</B>two two two two two two twotwo
TWO two two two two two two twotwo TWO two two two two two two twotwo TWO</FONT>
<BLOCKQUOTE><FONT SIZE=+0>two two two two two two twotwo TWO two two two</FONT></BLOCKQUOTE>
<FONT SIZE=+0>two two two twotwo TWO two two two two two two twotwo TWO
two two two two two two twotwo TWO</FONT></BLOCKQUOTE>
<FONT SIZE=-2>two two two two two two twotwo TWO two two two two two two
twotwo TWO</FONT>
<LI>
<FONT SIZE=-2>This is item nyumber 3.</FONT></LI>
<LI>
<FONT SIZE=-2>This is item number one. iti lkdjfdl kjd lk jlkjdl kjlk jlf
jflkj d lfkjlkf jl jflkj flkwe lkhelf ;fk;fl kw;lfke ;ffj lkjflk wj lfjl
fkw ;k;ekf;lkfe ;kf;lk; ;j ;lrj;wfj;f ;eljfw; lfj;ewlfj dagdja gdj chga
kjegiquw iuqdb qiud iquwd hurray googoo.</FONT></LI>
<LI>
<FONT SIZE=-2>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</FONT></LI>
<LI>
<FONT SIZE=-2>This is item nyumber 3.</FONT></LI>
<LI>
<FONT SIZE=-2>This is item number one. iti lkdjfdl kjd lk jlkjdl kjlk jlf
jflkj d lfkjlkf jl jflkj flkwe lkhelf ;fk;fl kw;lfke ;ffj lkjflk wj lfjl
fkw ;k;ekf;lkfe ;kf;lk; ;j ;lrj;wfj;f ;eljfw; lfj;ewlfj dagdja gdj chga
kjegiquw iuqdb qiud iquwd hurray googoo.</FONT></LI>
<LI>
<FONT SIZE=-2>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</FONT></LI>
<LI>
<FONT SIZE=-2>This is item nyumber 3.</FONT></LI>
<LI>
<FONT SIZE=-2>This is item number one. iti lkdjfdl kjd lk jlkjdl kjlk jlf
jflkj d lfkjlkf jl jflkj flkwe lkhelf ;fk;fl kw;lfke ;ffj lkjflk wj lfjl
fkw ;k;ekf;lkfe ;kf;lk; ;j ;lrj;wfj;f ;eljfw; lfj;ewlfj dagdja gdj chga
kjegiquw iuqdb qiud iquwd hurray googoo.</FONT></LI>
<LI>
<FONT SIZE=-2>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</FONT></LI>
<LI>
<FONT SIZE=-2>This is item nyumber 3.</FONT></LI>
<LI>
<FONT SIZE=-2>This is item number one. iti lkdjfdl kjd lk jlkjdl kjlk jlf
jflkj d lfkjlkf jl jflkj flkwe lkhelf ;fk;fl kw;lfke ;ffj lkjflk wj lfjl
fkw ;k;ekf;lkfe ;kf;lk; ;j ;lrj;wfj;f ;eljfw; lfj;ewlfj dagdja gdj chga
kjegiquw iuqdb qiud iquwd hurray googoo.</FONT></LI>
<LI>
<FONT SIZE=-2>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</FONT></LI>
<P><BR><FONT SIZE=-2>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</FONT>
<P><FONT SIZE=-2>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</FONT>
<LI>
<FONT SIZE=-2>This is item nyumber 3.</FONT></LI>
</OL>
Now, you will see some PRE text:<p>
<PRE>// This is sample C++ code:
void main(int argc, char *argv[])
{
&nbsp;&nbsp;&nbsp; printf("Go away, man!\n");
&nbsp;&nbsp;&nbsp; i = 666;
&nbsp;&nbsp;&nbsp; printf("\n\n\nCRASH\n&nbsp; DOWN NOW. . .&nbsp; \n");
}</PRE>
</BODY>
</HTML>

7
wxPython/demo/data/tips.txt Normal file
View File

@@ -0,0 +1,7 @@
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.
wxPython now has a company providing commercial support, consulting and training. Go to http://wxpros.com for details.
You shouldn't pee on an electric fence!
Be sure to subscribe to the mail list. Go to http://wxwindows.org/mailman/listinfo/wxpython-users today!

58
wxPython/demo/data/widgetTest.htm Normal file
View File

@@ -0,0 +1,58 @@
<html>
<head>
<title>wxHTML does wxPython!</title>
</head>
<body bgcolor="#00CCFF">
<h2>Mixing wxPython and wxHTML</h2>
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 <a href="../../lib/wxpTag.py">here</a>.
<p>
The button below is added to the page like this:
<pre>
&lt;center>&lt;wxp class="wxButton" width="50%">
&lt;param name="label" value="It works!">
&lt;param name="id" value="wxID_OK">
&lt;/wxp>&lt;/center>
</pre>
<hr>
<center>
<wxp class="wxButton" width="50%">
<param name="label" value="It works!">
<param name="id" value="wxID_OK">
</wxp>
</center>
<p>
Notice that the <b>button click</b> event is actually caught by the panel
that contains this window, which then logs it in the window below.
<p>
<hr>
<p>
This is the same widget reused three times, each with a different
parameter value. Source code is <a href="../widgetTest.py">here</a>.
<p>
<wxp module="widgetTest" class="TestPanel" width=180 height=100>
</wxp>
<wxp module="widgetTest" class="TestPanel" width=180 height=100>
<param name="bgcolor" value="#00CCFF">
</wxp>
<wxp module="widgetTest" class="TestPanel" width=180 height=100>
<param name="bgcolor" value="#0000FF">
</wxp>
<p><hr><p>
Recognize this one?<br>
<wxp module="wxScrolledWindow" class="MyCanvas" height=300 width=100%>
</wxp>
<p><hr><p>
You can also embed other wxHtmlWindows!<br>
<center>
<wxp module="widgetTest" class="TestHtmlPanel">
</wxp>
</center>
</body></html>

4
wxPython/demo/demo.py Executable file
View File

@@ -0,0 +1,4 @@
#!/usr/bin/env python
import Main
Main.main()

121
wxPython/demo/demoMainLoop.py Executable file
View File

@@ -0,0 +1,121 @@
#!/usr/bin/env python
#---------------------------------------------------------------------------
"""
This demo attempts to override the C++ MainLoop and implement it
in Python. This is not part of the demo framework.
THIS FEATURE IS STILL EXPERIMENTAL...
"""
from wxPython.wx import *
import time
#---------------------------------------------------------------------------
class MyFrame(wxFrame):
def __init__(self, parent, id, title):
wxFrame.__init__(self, parent, id, title,
wxPoint(100, 100), wxSize(160, 150))
EVT_SIZE(self, self.OnSize)
EVT_MOVE(self, self.OnMove)
EVT_CLOSE(self, self.OnCloseWindow)
EVT_IDLE(self, self.OnIdle)
self.count = 0
panel = wxPanel(self, -1)
wxStaticText(panel, -1, "Size:",
wxDLG_PNT(panel, wxPoint(4, 4)), wxDefaultSize)
wxStaticText(panel, -1, "Pos:",
wxDLG_PNT(panel, wxPoint(4, 16)), wxDefaultSize)
wxStaticText(panel, -1, "Idle:",
wxDLG_PNT(panel, wxPoint(4, 28)), wxDefaultSize)
self.sizeCtrl = wxTextCtrl(panel, -1, "",
wxDLG_PNT(panel, wxPoint(24, 4)),
wxDLG_SZE(panel, wxSize(36, -1)),
wxTE_READONLY)
self.posCtrl = wxTextCtrl(panel, -1, "",
wxDLG_PNT(panel, wxPoint(24, 16)),
wxDLG_SZE(panel, wxSize(36, -1)),
wxTE_READONLY)
self.idleCtrl = wxTextCtrl(panel, -1, "",
wxDLG_PNT(panel, wxPoint(24, 28)),
wxDLG_SZE(panel, wxSize(36, -1)),
wxTE_READONLY)
def OnCloseWindow(self, event):
app.keepGoing = false
self.Destroy()
def OnIdle(self, event):
self.idleCtrl.SetValue(str(self.count))
self.count = self.count + 1
def OnSize(self, event):
size = event.GetSize()
self.sizeCtrl.SetValue("%s, %s" % (size.width, size.height))
event.Skip()
def OnMove(self, event):
pos = event.GetPosition()
self.posCtrl.SetValue("%s, %s" % (pos.x, pos.y))
#---------------------------------------------------------------------------
class MyApp(wxApp):
def MainLoop(self):
# This outer loop determines when to exit the application, for
# this example we let the main frame reset this flag when it
# closes.
while self.keepGoing:
# At this point in the outer loop you could do whatever you
# implemented your own MainLoop for. It should be quick and
# non-blocking, otherwise your GUI will freeze. For example,
# call Fnorb's reactor.do_one_event(0), etc.
# call_your_code_here()
# This inner loop will process any GUI events until there
# are no more waiting.
while self.Pending():
self.Dispatch()
# Send idle events to idle handlers. You may want to throtle
# this back a bit so there is not too much CPU time spent in
# the idle handlers. For this example, I'll just snooze a
# little...
time.sleep(0.25)
self.ProcessIdle()
def OnInit(self):
frame = MyFrame(NULL, -1, "This is a test")
frame.Show(true)
self.SetTopWindow(frame)
self.keepGoing = true
return true
app = MyApp(0)
app.MainLoop()

468
wxPython/demo/hangman.py Normal file
View File

@@ -0,0 +1,468 @@
"""Hangman.py, a simple wxPython game, inspired by the
old bsd game by Ken Arnold.
From the original man page:
In hangman, the computer picks a word from the on-line
word list and you must try to guess it. The computer
keeps track of which letters have been guessed and how
many wrong guesses you have made on the screen in a
graphic fashion.
That says it all, doesn't it?
Have fun with it,
Harm van der Heijden (H.v.d.Heijden@phys.tue.nl)"""
import random,re,string
from wxPython.wx import *
class WordFetcher:
builtin_words = ' albatros banana electrometer eggshell'
def __init__(self, filename, min_length = 5):
self.min_length = min_length
print "Trying to open file %s" % (filename,)
try:
f = open(filename, "r")
except:
print "Couldn't open dictionary file %s, using builtins" % (filename,)
self.words = self.builtin_words
self.filename = None
return
self.words = f.read()
self.filename = filename
print "Got %d bytes." % (len(self.words),)
def SetMinLength(min_length):
self.min_length = min_length
def Get(self):
reg = re.compile('\s+([a-zA-Z]+)\s+')
n = 50 # safety valve; maximum number of tries to find a suitable word
while n:
index = int(random.random()*len(self.words))
m = reg.search(self.words[index:])
if m and len(m.groups()[0]) >= self.min_length: break
n = n - 1
if n: return string.lower(m.groups()[0])
return "error"
def stdprint(x):
print x
class URLWordFetcher(WordFetcher):
def __init__(self, url):
self.OpenURL(url)
WordFetcher.__init__(self, "hangman_dict.txt")
def logprint(self,x):
print x
def RetrieveAsFile(self, host, path=''):
from httplib import HTTP
try:
h = HTTP(host)
except:
self.logprint("Failed to create HTTP connection to %s... is the network available?" % (host))
return None
h.putrequest('GET',path)
h.putheader('Accept','text/html')
h.putheader('Accept','text/plain')
h.endheaders()
errcode, errmsg, headers = h.getreply()
if errcode != 200:
self.logprint("HTTP error code %d: %s" % (errcode, errmsg))
return None
f = h.getfile()
return f
def OpenURL(self,url):
from htmllib import HTMLParser
import formatter
self.url = url
m = re.match('http://([^/]+)(/\S*)\s*', url)
if m:
host = m.groups()[0]
path = m.groups()[1]
else:
m = re.match('http://(\S+)\s*', url)
if not m:
# Invalid URL
self.logprint("Invalid or unsupported URL: %s" % (url))
return
host = m.groups()[0]
path = ''
f = self.RetrieveAsFile(host,path)
if not f:
self.logprint("Could not open %s" % (url))
return
self.logprint("Receiving data...")
data = f.read()
tmp = open('hangman_dict.txt','w')
fmt = formatter.AbstractFormatter(formatter.DumbWriter(tmp))
p = HTMLParser(fmt)
self.logprint("Parsing data...")
p.feed(data)
p.close()
tmp.close()
class HangmanWnd(wxWindow):
def __init__(self, parent, id, pos=wxDefaultPosition, size=wxDefaultSize):
wxWindow.__init__(self, parent, id, pos, size)
self.SetBackgroundColour(wxNamedColour('white'))
if wxPlatform == '__WXGTK__':
self.font = wxFont(12, wxMODERN, wxNORMAL, wxNORMAL)
else:
self.font = wxFont(10, wxMODERN, wxNORMAL, wxNORMAL)
self.SetFocus()
EVT_PAINT(self, self.OnPaint)
def StartGame(self, word):
self.word = word
self.guess = []
self.tries = 0
self.misses = 0
self.Draw()
def EndGame(self):
self.misses = 7;
self.guess = map(chr, range(ord('a'),ord('z')+1))
self.Draw()
def HandleKey(self, key):
self.message = ""
if self.guess.count(key):
self.message = 'Already guessed %s' % (key,)
return 0
self.guess.append(key)
self.guess.sort()
self.tries = self.tries+1
if not key in self.word:
self.misses = self.misses+1
if self.misses == 7:
self.EndGame()
return 1
has_won = 1
for letter in self.word:
if not self.guess.count(letter):
has_won = 0
break
if has_won:
self.Draw()
return 2
self.Draw()
return 0
def Draw(self, dc = None):
if not dc:
dc = wxClientDC(self)
dc.SetFont(self.font)
dc.Clear()
(x,y) = self.GetSizeTuple()
x1 = x-200; y1 = 20
for letter in self.word:
if self.guess.count(letter):
dc.DrawText(letter, x1, y1)
else:
dc.DrawText('.', x1, y1)
x1 = x1 + 10
x1 = x-200
dc.DrawText("tries %d misses %d" % (self.tries,self.misses),x1,50)
guesses = ""
for letter in self.guess:
guesses = guesses + letter
dc.DrawText("guessed:", x1, 70)
dc.DrawText(guesses[:13], x1+80, 70)
dc.DrawText(guesses[13:], x1+80, 90)
dc.SetUserScale(x/1000.0, y/1000.0)
self.DrawVictim(dc)
def DrawVictim(self, dc):
dc.SetPen(wxPen(wxNamedColour('black'), 20))
dc.DrawLines([(10, 980), (10,900), (700,900), (700,940), (720,940),
(720,980), (900,980)])
dc.DrawLines([(100,900), (100, 100), (300,100)])
dc.DrawLine(100,200,200,100)
if ( self.misses == 0 ): return
dc.SetPen(wxPen(wxNamedColour('blue'), 10))
dc.DrawLine(300,100,300,200)
if ( self.misses == 1 ): return
dc.DrawEllipse(250,200,100,100)
if ( self.misses == 2 ): return
dc.DrawLine(300,300,300,600)
if ( self.misses == 3) : return
dc.DrawLine(300,300,250,550)
if ( self.misses == 4) : return
dc.DrawLine(300,300,350,550)
if ( self.misses == 5) : return
dc.DrawLine(300,600,350,850)
if ( self.misses == 6) : return
dc.DrawLine(300,600,250,850)
def OnPaint(self, event):
dc = wxPaintDC(self)
self.Draw(dc)
class HangmanDemo(HangmanWnd):
def __init__(self, wf, parent, id, pos, size):
HangmanWnd.__init__(self, parent, id, pos, size)
self.StartGame("dummy")
self.start_new = 1
self.wf = wf
self.delay = 500
self.timer = self.PlayTimer(self.MakeMove)
def MakeMove(self):
self.timer.Stop()
if self.start_new:
self.StartGame(self.wf.Get())
self.start_new = 0
self.left = list('aaaabcdeeeeefghiiiiijklmnnnoooopqrssssttttuuuuvwxyz')
else:
key = self.left[int(random.random()*len(self.left))]
while self.left.count(key): self.left.remove(key)
self.start_new = self.HandleKey(key)
self.timer.Start(self.delay)
def Stop(self):
self.timer.Stop()
class PlayTimer(wxTimer):
def __init__(self,func):
wxTimer.__init__(self)
self.func = func
self.Start(1000)
def Notify(self):
apply(self.func, ())
class HangmanDemoFrame(wxFrame):
def __init__(self, wf, parent, id, pos, size):
wxFrame.__init__(self, parent, id, "Hangman demo", pos, size)
self.demo = HangmanDemo(wf, self, -1, wxDefaultPosition, wxDefaultSize)
EVT_CLOSE(self, self.OnCloseWindow)
def OnCloseWindow(self, event):
self.demo.timer.Stop()
self.Destroy()
class AboutBox(wxDialog):
def __init__(self, parent,wf):
wxDialog.__init__(self, parent, -1, "About Hangman", wxDefaultPosition, wxSize(350,450))
self.wnd = HangmanDemo(wf, self, -1, wxPoint(1,1), wxSize(350,150))
self.static = wxStaticText(self, -1, __doc__, wxPoint(1,160), wxSize(350, 250))
self.button = wxButton(self, 2001, "OK", wxPoint(150,420), wxSize(50,-1))
EVT_BUTTON(self, 2001, self.OnOK)
def OnOK(self, event):
self.wnd.Stop()
self.EndModal(wxID_OK)
class MyFrame(wxFrame):
def __init__(self, parent, wf):
self.wf = wf
wxFrame.__init__(self, parent, -1, "hangman", wxDefaultPosition, wxSize(400,300))
self.wnd = HangmanWnd(self, -1)
menu = wxMenu()
menu.Append(1001, "New")
menu.Append(1002, "End")
menu.AppendSeparator()
menu.Append(1003, "Reset")
menu.Append(1004, "Demo...")
menu.AppendSeparator()
menu.Append(1005, "Exit")
menubar = wxMenuBar()
menubar.Append(menu, "Game")
menu = wxMenu()
#menu.Append(1010, "Internal", "Use internal dictionary", TRUE)
menu.Append(1011, "ASCII File...")
urls = [ 'wxPython home', 'http://alldunn.com/wxPython/main.html',
'slashdot.org', 'http://slashdot.org/',
'cnn.com', 'http://cnn.com',
'The New York Times', 'http://www.nytimes.com',
'De Volkskrant', 'http://www.volkskrant.nl/frameless/25000006.html',
'Gnu GPL', 'http://www.fsf.org/copyleft/gpl.html',
'Bijbel: Genesis', 'http://www.coas.com/bijbel/gn1.htm']
urlmenu = wxMenu()
for item in range(0,len(urls),2):
urlmenu.Append(1020+item/2, urls[item], urls[item+1])
urlmenu.Append(1080, 'Other...', 'Enter an URL')
menu.AppendMenu(1012, 'URL', urlmenu, 'Use a webpage')
menu.Append(1013, 'Dump', 'Write contents to stdout')
menubar.Append(menu, "Dictionary")
self.urls = urls
self.urloffset = 1020
menu = wxMenu()
menu.Append(1090, "About...")
menubar.Append(menu, "Help")
self.SetMenuBar(menubar)
self.CreateStatusBar(2)
EVT_MENU(self, 1001, self.OnGameNew)
EVT_MENU(self, 1002, self.OnGameEnd)
EVT_MENU(self, 1003, self.OnGameReset)
EVT_MENU(self, 1004, self.OnGameDemo)
EVT_MENU(self, 1005, self.OnWindowClose)
EVT_MENU(self, 1011, self.OnDictFile)
EVT_MENU_RANGE(self, 1020, 1020+len(urls)/2, self.OnDictURL)
EVT_MENU(self, 1080, self.OnDictURLSel)
EVT_MENU(self, 1013, self.OnDictDump)
EVT_MENU(self, 1090, self.OnHelpAbout)
EVT_CHAR(self.wnd, self.OnChar)
self.OnGameReset()
def OnGameNew(self, event):
word = self.wf.Get()
self.in_progress = 1
self.SetStatusText("",0)
self.wnd.StartGame(word)
def OnGameEnd(self, event):
self.UpdateAverages(0)
self.in_progress = 0
self.SetStatusText("",0)
self.wnd.EndGame()
def OnGameReset(self, event=None):
self.played = 0
self.won = 0
self.history = []
self.average = 0.0
self.OnGameNew(None)
def OnGameDemo(self, event):
frame = HangmanDemoFrame(self.wf, self, -1, wxDefaultPosition, self.GetSize())
frame.Show(TRUE)
def OnDictFile(self, event):
fd = wxFileDialog(self)
if (self.wf.filename):
fd.SetFilename(self.wf.filename)
if fd.ShowModal() == wxID_OK:
file = fd.GetPath()
self.wf = WordFetcher(file)
def OnDictURL(self, event):
item = (event.GetId() - self.urloffset)*2
print "Trying to open %s at %s" % (self.urls[item], self.urls[item+1])
self.wf = URLWordFetcher(self.urls[item+1])
def OnDictURLSel(self, event):
msg = wxTextEntryDialog(self, "Enter the URL of the dictionary document", "Enter URL")
if msg.ShowModal() == wxID_OK:
url = msg.GetValue()
self.wf = URLWordFetcher(url)
def OnDictDump(self, event):
print self.wf.words
def OnHelpAbout(self, event):
about = AboutBox(self, self.wf)
about.ShowModal()
about.wnd.Stop() # that damn timer won't stop!
def UpdateAverages(self, has_won):
if has_won:
self.won = self.won + 1
self.played = self.played+1
self.history.append(self.wnd.misses) # ugly
total = 0.0
for m in self.history:
total = total + m
self.average = float(total/len(self.history))
def OnChar(self, event):
if not self.in_progress:
#print "new"
self.OnGameNew(None)
return
key = event.KeyCode();
#print key
if key >= ord('A') and key <= ord('Z'):
key = key + ord('a') - ord('A')
key = chr(key)
if key < 'a' or key > 'z':
event.Skip()
return
res = self.wnd.HandleKey(key)
if res == 0:
self.SetStatusText(self.wnd.message)
elif res == 1:
self.UpdateAverages(0)
self.SetStatusText("Too bad, you're dead!",0)
self.in_progress = 0
elif res == 2:
self.in_progress = 0
self.UpdateAverages(1)
self.SetStatusText("Congratulations!",0)
if self.played:
percent = (100.*self.won)/self.played
else:
percent = 0.0
self.SetStatusText("p %d, w %d (%g %%), av %g" % (self.played,self.won, percent, self.average),1)
def OnWindowClose(self, event):
self.Destroy()
class MyApp(wxApp):
def OnInit(self):
if wxPlatform == '__WXGTK__':
defaultfile = "/usr/share/games/hangman-words"
elif wxPlatform == '__WXMSW__':
defaultfile = "c:\\windows\\hardware.txt"
else:
defaultfile = ""
wf = WordFetcher(defaultfile)
frame = MyFrame(NULL, wf)
self.SetTopWindow(frame)
frame.Show(TRUE)
return TRUE
if __name__ == '__main__':
app = MyApp(0)
app.MainLoop()
#----------------------------------------------------------------------
overview = __doc__
def runTest(frame, nb, log):
if wxPlatform == '__WXGTK__' or wxPlatform == '__WXMOTIF__':
defaultfile = "/usr/share/games/hangman-words"
elif wxPlatform == '__WXMSW__':
defaultfile = "c:\\windows\\hardware.txt"
else:
defaultfile = ""
wf = WordFetcher(defaultfile)
win = MyFrame(frame, wf)
frame.otherWin = win
win.Show(true)
#----------------------------------------------------------------------

85
wxPython/demo/paper.xml Normal file
View File

@@ -0,0 +1,85 @@
<?xml version="1.0"?>
<!DOCTYPE gcapaper SYSTEM "gcapap-X.dtd" [
<!ENTITY footprint SYSTEM "footprint.tif" NDATA tiff >
<!ENTITY footprint SYSTEM "footprint.eps" NDATA eps >
<!ENTITY shoes SYSTEM "shoes.tif" NDATA tiff >
<!ENTITY super1 "&#90;">
]>
<gcapaper><front><title>Using SGML to make footprints in the sand
</title><keyword>footprints</keyword><keyword>sand</keyword>
<author><fname>Jane</fname><surname>Doe</surname>
<jobtitle>Empress</jobtitle>
<address><affil>Universe Corporation</affil>
<aline>1 Main Street</aline>
<city>Perfect City</city>
<province>Dorado</province>
<cntry>Neutral</cntry><postcode>999999</postcode>
<phone>+55 555 555 5550</phone>
<fax>+55 555 555 5555</fax>
<email>jane@universe.com</email>
<web>www.universe.com</web>
</address>
<bio><para>Jane Doe is the Empress of the Universe <bibref refloc="jd000"/>, a position to which she has always aspired.</para></bio>
</author>
<author><fname>Fred</fname><surname>Bloggs</surname>
<jobtitle>Designer</jobtitle>
<address><affil>Fred (The Shoe) Bloggs Ltd</affil>
<aline>1 Shoe Lane</aline>
<city>Perfect City</city>
<province>Dorado</province>
<cntry>Neutral</cntry><postcode>999999</postcode>
<phone>+55 555 555 1122</phone>
<fax>+55 555 555 1133</fax>
<email>fred@shoebloggs.com</email>
<web>www.shoebloggs.com</web></address>
<bio><para>Fred has always wanted to create the perfect shoe for making footprints in the sand. Now with SGML and XML, he has been able to document his design.</para></bio>
</author>
<abstract>
<para><keyword>ease</keyword><keyword>documentation</keyword>It's not easy being an Empress of the Universe (<a href="http://www.universe.com"/>), but with the right pair of shoes and the right documentation on how to make footprints in the sand of life, it's easier than it was. Since the introduction of <acronym.grp><acronym>SGML</acronym><expansion>Standard Generalized Markup Language</expansion></acronym.grp> and <acronym.grp><acronym>XML</acronym><expansion>Extensible Markup Language</expansion></acronym.grp> it is now possible to identify and manage the key bits of information on this process.</para>
</abstract>
</front>
<body><section id="jd001"><title>Introduction</title>
<para><keyword>documentation</keyword>Since its inception, the Universe has always had sand, now it has an Empress, a good shoe design, and <acronym>SGML</acronym> / <acronym>XML</acronym> documentation. The time is now ripe for making <highlight style="ital">footprints</highlight> in the sand.</para></section>
<section id="jd002"><title>Footprints - truly a push technology</title><keyword>push</keyword>
<para>One could safely say that making footprints is a push technology. This is even more true when the footprint maker is the Empress of the Universe. </para>
<subsec1 id="jd003"><title>The sands of time</title><keyword>time</keyword>
<para>The 1<super>st</super> think to remember about the Universe is the time/space continuum to which it conforms. This then confuses the sands of time to be something more like the sands of time/space continuum because if you wait on those sands long enough they may be somewhere else - not necessarily because of the time/space continuum but because the winds will <highlight style="ital">push</highlight> them down the beach.</para></subsec1>
<subsec1 id="jd004"><title>Identifying the footprints</title>
<para>In order to truly understand who has walked on the sands and left the footprints, it is important to identify the <keyword>characteristics</keyword>characteristics of the footprint. In the graphic <xref refloc="jd005" type="title"/>, we can see the footprints are large, well shaped, and evenly distributed from front to back and side to side.</para>
<figure id="jd005"><title>Footprint in Sand</title><caption><para>Note the evenly distributed shape and indention</para></caption><graphic figname="footprint"/></figure>
<para>This footprint begs the question, 'What kind of remarkable <keyword>shoe</keyword>shoe could make such a wonderful footprint?'</para>
<table id="t1">
<tgroup cols="2">
<thead><row><entry>Shoe Type</entry><entry>Remarkability Rating</entry></row></thead>
<tbody><row><entry>Acme Shoe</entry><entry>Unremarkable</entry></row>
<row><entry>Budget Shoe</entry><entry>Not worth remarking on</entry></row>
<row><entry>Super Duper Shoe</entry><entry>Absolutely Remarkable</entry></row></tbody>
</tgroup></table></subsec1>
<subsec1 id="jd006"><title>The Shoe What Made the Footprint</title>
<para>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 <xref refloc="jd007" type="number"/>, the shoe is worthy of an Empress.</para>
<figure id="jd007"><title>The Terrific Shoe</title><graphic figname="shoes"/></figure>
<para>The design goals of the shoe were:
<randlist style = "bulleted">
<li><para>to minimize time-consuming manual tasks such as shoelace tying;</para></li>
<li><para>to allow different decorations to be placed on the toes; and</para></li>
<li><para>to enforce a good arch.</para></li></randlist></para></subsec1></section>
<section id="jd008"><title>Documenting the Shoe</title>
<para>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.</para>
<code.block>&lt;!DOCTYPE shoedoc [
&lt;!ELEMENT shoedoc - - (design, mfg, care, recycle) >
&lt;!ATTLIST shoedoc designer CDATA #REQUIRED
date CDATA #REQUIRED>
&lt;!ELEMENT design - - (specs, desc) >
etc.
</code.block>
<para>An excerpt from the documentation also gives us insights.</para>
<code.block><![CDATA[<design>
<specs sizerange="4-12" widthrange="aa-d" color="navy black white red taupe">
<para>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.</para></specs>]]>
</code.block>
</section></body>
<rear><acknowl>
<para>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.</para></acknowl>
<bibliog>
<bibitem id="jd000"><bib>Barrett 00</bib><pub>Barrett, B., Being Empress Made Easy, Galaxy Division of Universal Publishers. 0000</pub></bibitem></bibliog></rear></gcapaper>

211
wxPython/demo/pyTree.py Normal file
View File

@@ -0,0 +1,211 @@
"""
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...
"""
from wxPython import wx
import string # Don't use it, but it's fun expanding :-)
#----------------------------------------------------------------------
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.wxTreeCtrl):
"""
This wxTreeCtrl 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.wxTreeCtrl.__init__(self, parent, id)
self.root = self.AddRoot(str(root), -1, -1, wx.wxTreeItemData(root))
if dir(root):
self.SetItemHasChildren(self.root, wx.TRUE)
wx.EVT_TREE_ITEM_EXPANDING(self, self.GetId(), self.OnItemExpanding)
wx.EVT_TREE_ITEM_COLLAPSED(self, self.GetId(), self.OnItemCollapsed)
wx.EVT_TREE_SEL_CHANGED(self, self.GetId(), self.OnSelChanged)
self.output = None
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()
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.wxTreeItemData(new_obj) )
if dir(new_obj):
self.SetItemHasChildren(new_item, wx.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 = __import__(__name__, globals())
win = wx.wxFrame(frame, -1, "PyTreeItemData Test")
split = wx.wxSplitterWindow(win, -1)
tree = pyTree(split, -1, thisModule)
text = wx.wxTextCtrl(split, -1, "", wx.wxDefaultPosition,
wx.wxDefaultSize, wx.wxTE_MULTILINE)
split.SplitVertically(tree, text, 200)
tree.SetOutput(text.SetValue)
tree.SelectItem(tree.root)
win.SetSize(wx.wxSize(800,500))
frame.otherWin = win
win.Show(1)
#----------------------------------------------------------------------
if __name__ == '__main__':
class MyFrame(wx.wxFrame):
"""Very standard Frame class. Nothing special here!"""
def __init__(self):
"""Make a splitter window; left a tree, right a textctrl. Wow."""
import __main__
wx.wxFrame.__init__(self, wx.NULL, -1, "PyTreeItemData Test",
wx.wxDefaultPosition, wx.wxSize(800,500))
split = wx.wxSplitterWindow(self, -1)
tree = pyTree(split, -1, __main__)
text = wx.wxTextCtrl(split, -1, "", wx.wxDefaultPosition,
wx.wxDefaultSize, wx.wxTE_MULTILINE)
split.SplitVertically(tree, text, 200)
tree.SetOutput(text.SetValue)
tree.SelectItem(tree.root)
class MyApp(wx.wxApp):
"""This class is even less interesting than MyFrame."""
def OnInit(self):
"""OnInit. Boring, boring, boring!"""
frame = MyFrame()
frame.Show(wx.TRUE)
self.SetTopWindow(frame)
return wx.TRUE
app = MyApp(0)
app.MainLoop()

13
wxPython/demo/quotes.xml Normal file
View File

@@ -0,0 +1,13 @@
<?xml version="1.0"?>
<!DOCTYPE quotations [
<!ELEMENT collection (quotation)*>
<!ELEMENT em (#PCDATA) >
<!ELEMENT foreign (#PCDATA) >
<!ELEMENT cite (#PCDATA) >
<!ELEMENT author (#PCDATA)>
<!ELEMENT source (#PCDATA|cite)*>
<!ELEMENT quotation (#PCDATA|author|source)* >
]>
<collection><quotation>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. <source>Donald E. Knuth, "Structured Programming with goto Statements", Computing Surveys, Vol 6 No 4, Dec. 1974</source> </quotation> <quotation> The infinities aren't contagious except in that they often appear that way due to to their large size. <source>Tim Peters on the IEEE 754 floating point standard, 27 Apr 1998</source> </quotation> </collection>

25
wxPython/demo/redemo.py Normal file
View File

@@ -0,0 +1,25 @@
"""Basic regular expression demostration facility (Perl style syntax)."""
from wxPython.wx import *
import re
#----------------------------------------------------------------------
class ReDemoPanel(wxPanel):
def __init__(self, parent):
wxPanel.__init__(self, parent, -1)
rePrompt = wxStaticText(self, -1, "Enter a Perl-style regular expression")
reText = wxTextCtrl(self, 101, "")
options = self.AddOptions()
sPrompt = wxStaticText(self, -1, "Enter a string to search")
sText = wxTextCtrl(self, 102, "", style=wxTE_MULTILINE)
dispPrompt = wxStaticText(self, -1, "Groups:")
dispText = wxTextCtrl(self, 103, "", style=wxTE_MULTILINE|wxTE_READONLY)
#----------------------------------------------------------------------
#----------------------------------------------------------------------

96
wxPython/demo/run.py Executable file
View File

@@ -0,0 +1,96 @@
#!/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 sys
from wxPython.wx import *
#----------------------------------------------------------------------------
class Log:
def WriteText(self, text):
sys.stdout.write(text)
write = WriteText
class RunDemoApp(wxApp):
def __init__(self, name, module):
self.name = name
self.demoModule = module
wxApp.__init__(self, 0)
def OnInit(self):
wxInitAllImageHandlers()
frame = wxFrame(None, -1, "RunDemo: " + self.name, size=(0,0),
style=wxNO_FULL_REPAINT_ON_RESIZE|wxDEFAULT_FRAME_STYLE)
frame.CreateStatusBar()
frame.Show(true)
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()
else:
# otherwise the demo made its own frame, so just put a
# button in this one
if hasattr(frame, 'otherWin'):
wxButton(frame, 1101, " Exit ")
frame.SetSize((200, 100))
EVT_BUTTON(frame, 1101, self.OnButton)
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
return true
def OnButton(self, evt):
self.frame.Close(true)
#----------------------------------------------------------------------------
def main(argv):
if len(argv) != 2:
print "Please specify a demo module name on the command-line"
raise SystemExit
name = argv[1]
if name[-3:] == '.py':
name = name[:-3]
module = __import__(name)
app = RunDemoApp(name, module)
app.MainLoop()
if __name__ == "__main__":
main(sys.argv)

96
wxPython/demo/viewer.py Normal file
View File

@@ -0,0 +1,96 @@
#!/usr/bin/env python
"""
Run wxPython in a second thread.
Overview:
Importing this module creates a second thread and starts
wxPython in that thread. Its single method,
add_cone(), sends an event to the second thread
telling it to create a VTK viewer window with a cone in
it.
This module is meant to be imported into the standard
Python interpreter. It also works with Pythonwin.
It doesn't seem to work with IDLE (on NT anyways).
It should also work in a wxPython application.
Applications already running a wxPython app do not
need to start a second thread. In these cases,
viewer creates the cone windows in the current
thread. You can test this by running shell.py
that comes with wxPython, importing viewer and
calling add_cone.
Usage:
[user]$ python
Python 1.5.2 (#1, Sep 17 1999, 20:15:36) ...
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> import viewer
>>> viewer.add_cone() # pop up a cone window
>>> a = 1
1
>>> viewer.add_cone() # create another cone window
Why would anyone do this?:
When using wxPython, the call to app.Mainloop() takes over
the thread from which it is called. This presents a
problem for applications that want to use the standard
Python command line user interface, while occasionaly
creating a GUI window for viewing an image, plot, etc.
One soultion is to mangage the GUI in a second thread.
wxPython does not behave well if windows are created in
a thread other than the one where wxPython was originally
imported. ( I assume importing wxPython initializes some
info in the thread). The current solution is to make the
original import of wxPython in the second thread and then
create all windows in that second thread.
Methods in the main thread can create a new window by issuing
events to a "catcher" window in the second thread. This
catcher window has event handlers that actually create the
new window.
"""
class viewer_thread:
def start(self):
""" start the GUI thread
"""
import thread,time
thread.start_new_thread(self.run, ())
def run(self):
"""
Note that viewer_basices is first imported ***here***.
This is the second thread. viewer_basics imports
wxPython. if we imported it at
the module level instead of in this function,
the import would occur in the main thread and
wxPython wouldn't run correctly in the second thread.
"""
from viewer_basics import *
try:
self.app = SecondThreadApp(0)
self.app.MainLoop()
except TypeError:
self.app = None
def add_cone(self):
"""
send an event to the catcher window in the
other thread and tell it to create a cone window.
"""
import viewer_basics
if self.app:
evt = viewer_basics.AddCone()
viewer_basics.wxPostEvent(self.app.catcher, evt)
else:
viewer_basics.add_cone()
viewer = viewer_thread()
viewer.start()
def add_cone():
viewer.add_cone()

61
wxPython/demo/viewer_basics.py Normal file
View File

@@ -0,0 +1,61 @@
from wxPython.wx import *
from wxPython.lib import vtk
#---------------------------------------------------------------------------
class VtkFrame(wxFrame):
"""
Simple example VTK window that contains a cone.
"""
def __init__(self, parent, id, title):
wxFrame.__init__(self, parent,id,title, size=(450, 300))
win = vtk.wxVTKRenderWindow(self, -1)
renWin = win.GetRenderWindow()
ren = vtk.vtkRenderer()
renWin.AddRenderer(ren)
cone = vtk.vtkConeSource()
coneMapper = vtk.vtkPolyDataMapper()
coneMapper.SetInput(cone.GetOutput())
coneActor = vtk.vtkActor()
coneActor.SetMapper(coneMapper)
ren.AddActor(coneActor)
#---------------------------------------------------------------------------
wxEVT_ADD_CONE = 25015
def EVT_ADD_CONE(win, func):
win.Connect(-1, -1, wxEVT_ADD_CONE, func)
class AddCone(wxPyEvent):
def __init__(self):
wxPyEvent.__init__(self)
self.SetEventType(wxEVT_ADD_CONE)
class HiddenCatcher(wxFrame):
"""
The "catcher" frame in the second thread.
It is invisible. It's only job is to receive
Events from the main thread, and create
the appropriate windows.
"""
def __init__(self):
wxFrame.__init__(self, NULL,-1,'')
EVT_ADD_CONE(self, self.AddCone)
def AddCone(self,evt):
add_cone()
#---------------------------------------------------------------------------
class SecondThreadApp(wxApp):
"""
wxApp that lives in the second thread.
"""
def OnInit(self):
catcher = HiddenCatcher()
#self.SetTopWindow(catcher)
self.catcher =catcher
return true
#---------------------------------------------------------------------------
def add_cone():
frame = VtkFrame(NULL, -1, "Cone")
frame.Show(true)

49
wxPython/demo/widgetTest.py Normal file
View File

@@ -0,0 +1,49 @@
from wxPython.wx import *
from wxPython.html import *
#----------------------------------------------------------------------
class TestPanel(wxPanel):
def __init__(self, parent, id=-1, size=wxDefaultSize, bgcolor=None):
wxPanel.__init__(self, parent, id, size=size)
if bgcolor:
self.SetBackgroundColour(bgcolor)
wxStaticText(self, -1, 'Name:', wxPoint(10, 10))
wxStaticText(self, -1, 'Email:', wxPoint(10, 40))
self.name = wxTextCtrl(self, -1, '', wxPoint(50, 10), wxSize(100, -1))
self.email = wxTextCtrl(self, -1, '', wxPoint(50, 40), wxSize(100, -1))
wxButton(self, 12121, 'Okay', wxPoint(50, 70))
EVT_BUTTON(self, 12121, self.OnButton)
def OnButton(self, event):
name = self.name.GetValue()
email = self.email.GetValue()
dlg = wxMessageDialog(self,
'You entered:\n %s\n %s' % (name, email),
'Results', style = wxOK | wxICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
#----------------------------------------------------------------------
class TestHtmlPanel(wxPanel):
def __init__(self, parent, id=-1, size=wxDefaultSize):
import About
wxPanel.__init__(self, parent, id, size=size)
self.html = wxHtmlWindow(self, -1, wxPoint(5,5), wxSize(400, 350))
self.html.SetPage(About.MyAboutBox.text % wx.__version__)
self.Fit()
#----------------------------------------------------------------------

56
wxPython/demo/wxButton.py Normal file
View File

@@ -0,0 +1,56 @@
from wxPython.wx import *
#----------------------------------------------------------------------
class TestPanel(wxPanel):
def __init__(self, parent, log):
wxPanel.__init__(self, parent, -1)
self.log = log
b = wxButton(self, 10, "Hello", wxPoint(20, 20))
EVT_BUTTON(self, 10, self.OnClick)
b.SetBackgroundColour(wxBLUE)
b.SetForegroundColour(wxWHITE)
b.SetDefault()
wxButton(self, 20, "HELLO AGAIN!", wxPoint(20, 60), wxSize(90, 45))
EVT_BUTTON(self, 20, self.OnClick)
bmp = wxBitmap('bitmaps/test2.bmp', wxBITMAP_TYPE_BMP)
mask = wxMaskColour(bmp, wxBLUE)
bmp.SetMask(mask)
print bmp.GetWidth(), bmp.GetHeight()
wxBitmapButton(self, 30, bmp, wxPoint(140, 20),
wxSize(bmp.GetWidth()+10, bmp.GetHeight()+10))
EVT_BUTTON(self, 30, self.OnClick)
def OnClick(self, event):
self.log.WriteText("Click! (%d)\n" % event.GetId())
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestPanel(nb, log)
return win
#----------------------------------------------------------------------
overview = """\
"""

721
wxPython/demo/wxCalendar.py Normal file
View File

@@ -0,0 +1,721 @@
#----------------------------------------------------------------------------
# Name: wxCalendar.py
# Purpose: Calendar control display testing on panel for wxPython demo
#
# Author: Lorne White (email: lwhite1@planet.eon.net)
#
# Created:
# Version 0.8 2000/04/16
# Licence: wxWindows license
#----------------------------------------------------------------------------
from wxPython.wx import *
from wxPython.lib.calendar import wxCalendar, Month, PrtCalDraw
import os
dir_path = os.getcwd()
# highlighted days in month
test_days ={ 0: [],
1: [3, 7, 9, 21],
2: [2, 10, 4, 9],
3: [4, 20, 29],
4: [1, 12, 22],
5: [2, 10, 15],
6: [4, 8, 17],
7: [6, 7, 8],
8: [5, 10, 20],
9: [1, 2, 5, 29],
10: [2, 4, 6, 22],
11: [6, 9, 12, 28, 29],
12: [8, 9, 10, 11, 20] }
# test of full window calendar control functions
def GetMonthList():
monthlist = []
for i in range(13):
name = Month[i]
if name != None:
monthlist.append(name)
return monthlist
class TestPanel(wxPanel):
def __init__(self, parent, log, frame):
wxPanel.__init__(self, parent, -1)
self.log = log
self.frame = frame
self.calend = wxCalendar(self, -1, wxPoint(100, 50), wxSize(200, 180))
start_month = 11
start_year = 1999
# month list from DateTime module
monthlist = GetMonthList()
self.date = wxComboBox(self, 10, Month[start_month], wxPoint(100, 20), wxSize(90, -1), monthlist, wxCB_DROPDOWN)
EVT_COMBOBOX(self, 10, self.EvtComboBox)
# set start month and year
self.calend.SetMonth(start_month)
self.calend.SetYear(start_year)
# set attributes of calendar
self.calend.hide_title = TRUE
self.calend.HideGrid()
self.calend.SetWeekColor('WHITE', 'BLACK')
# display routine
self.ResetDisplay()
# mouse click event
self.Connect(self.calend.GetId(), -1, 2100, self.MouseClick)
# scroll bar for month selection
self.scroll = wxScrollBar(self, 40, wxPoint(100, 240), wxSize(200, 20), wxSB_HORIZONTAL)
self.scroll.SetScrollbar(start_month-1, 1, 12, 1, TRUE)
EVT_COMMAND_SCROLL(self, 40, self.Scroll)
# spin control for year selection
self.dtext = wxTextCtrl(self, -1, str(start_year), wxPoint(200, 20), wxSize(60, -1))
h = self.dtext.GetSize().height
self.spin = wxSpinButton(self, 20, wxPoint(270, 20), wxSize(h*2, h))
self.spin.SetRange(1980, 2010)
self.spin.SetValue(start_year)
EVT_SPIN(self, 20, self.OnSpin)
# button for calendar dialog test
wxStaticText(self, -1, "Test Calendar Dialog", wxPoint(350, 50), wxSize(150, -1))
bmp = wxBitmap('bitmaps/Calend.bmp', wxBITMAP_TYPE_BMP)
self.but = wxBitmapButton(self, 60, bmp, wxPoint(380, 80))#, wxSize(30, 30))
EVT_BUTTON(self, 60, self.TestDlg)
# button for calendar window test
wxStaticText(self, -1, "Test Calendar Window", wxPoint(350, 150), wxSize(150, -1))
bmp = wxBitmap('bitmaps/Calend.bmp', wxBITMAP_TYPE_BMP)
self.but = wxBitmapButton(self, 160, bmp, wxPoint(380, 180))#, wxSize(30, 30))
EVT_BUTTON(self, 160, self.TestFrame)
wxStaticText(self, -1, "Test Calendar Print", wxPoint(350, 250), wxSize(150, -1))
bmp = wxBitmap('bitmaps/Calend.bmp', wxBITMAP_TYPE_BMP)
self.but = wxBitmapButton(self, 170, bmp, wxPoint(380, 280))#, wxSize(30, 30))
EVT_BUTTON(self, 170, self.OnPreview)
# calendar dialog
def TestDlg(self, event):
dlg = CalenDlg(self, self.log)
dlg.Centre()
dlg.ShowModal()
dlg.Destroy()
# calendar window test
def TestFrame(self, event):
frame = CalendFrame(self, -1, "Test Calendar", self.log)
frame.Show(true)
return true
# calendar print preview
def OnPreview(self, event):
month = self.calend.GetMonth()
year = self.calend.GetYear()
prt = PrintCalend(self.frame, month, year)
prt.Preview()
# month and year control events
def OnSpin(self, event):
year = event.GetPosition()
self.dtext.SetValue(str(year))
self.calend.SetYear(year)
self.calend.Refresh()
def EvtComboBox(self, event):
name = event.GetString()
self.log.WriteText('EvtComboBox: %s\n' % name)
monthval = self.date.FindString(name)
self.scroll.SetScrollbar(monthval, 1, 12, 1, TRUE)
self.calend.SetMonth(monthval+1)
self.ResetDisplay()
def Scroll(self, event):
value = self.scroll.GetThumbPosition()
monthval = int(value)+1
self.calend.SetMonth(monthval)
self.ResetDisplay()
self.log.WriteText('Month: %s\n' % value)
name = Month[monthval]
self.date.SetValue(name)
# log mouse events
def MouseClick(self, evt):
text = '%s CLICK %02d/%02d/%d' % (evt.click, evt.day, evt.month, evt.year) # format date
self.log.WriteText('Date Selected: ' + text + '\n')
# set the highlighted days for the calendar
def ResetDisplay(self):
month = self.calend.GetMonth()
try:
set_days = test_days[month]
except:
set_days = [1, 5, 12]
self.calend.AddSelect([4, 11], 'BLUE', 'WHITE')
self.calend.SetSelDay(set_days)
self.calend.Refresh()
# increment and decrement toolbar controls
def OnIncYear(self, event):
self.calend.IncYear()
self.ResetDisplay()
def OnDecYear(self, event):
self.calend.DecYear()
self.ResetDisplay()
def OnIncMonth(self, event):
self.calend.IncMonth()
self.ResetDisplay()
def OnDecMonth(self, event):
self.calend.DecMonth()
self.ResetDisplay()
def OnCurrent(self, event):
self.calend.SetCurrentDay()
self.ResetDisplay()
# test the calendar control in a dialog
class CalenDlg(wxDialog):
def __init__(self, parent, log):
self.log = log
wxDialog.__init__(self, parent, -1, "Test Calendar", wxPyDefaultPosition, wxSize(280, 300))
start_month = 2
start_year = 1999
# get month list from DateTime
monthlist = GetMonthList()
# select the month
self.date = wxComboBox(self, 100, Month[start_month], wxPoint(20, 20), wxSize(90, -1), monthlist, wxCB_DROPDOWN)
EVT_COMBOBOX(self, 100, self.EvtComboBox)
# alternate spin button to control the month
h = self.date.GetSize().height
self.m_spin = wxSpinButton(self, 120, wxPoint(120, 20), wxSize(h*2, h), wxSP_VERTICAL)
self.m_spin.SetRange(1, 12)
self.m_spin.SetValue(start_month)
EVT_SPIN(self, 120, self.OnMonthSpin)
# spin button to conrol the year
self.dtext = wxTextCtrl(self, -1, str(start_year), wxPoint(160, 20), wxSize(60, -1))
h = self.dtext.GetSize().height
self.y_spin = wxSpinButton(self, 20, wxPoint(220, 20), wxSize(h*2, h), wxSP_VERTICAL)
self.y_spin.SetRange(1980, 2010)
self.y_spin.SetValue(start_year)
EVT_SPIN(self, 20, self.OnYrSpin)
# set the calendar and attributes
self.calend = wxCalendar(self, -1, wxPoint(20, 60), wxSize(240, 200))
self.calend.SetMonth(start_month)
self.calend.SetYear(start_year)
self.calend.HideTitle()
self.calend.ShowWeekEnd()
self.ResetDisplay()
self.Connect(self.calend.GetId(), -1, 2100, self.MouseClick)
# log the mouse clicks
def MouseClick(self, evt):
text = '%s CLICK %02d/%02d/%d' % (evt.click, evt.day, evt.month, evt.year) # format date
self.log.WriteText('Date Selected: ' + text + '\n')
if evt.click == 'DLEFT':
self.EndModal(wxID_OK)
# month and year spin selection routines
def OnMonthSpin(self, event):
month = event.GetPosition()
if month >= 0 and month <= 12:
self.date.SetValue(Month[month])
self.calend.SetMonth(month)
self.calend.Refresh()
def OnYrSpin(self, event):
year = event.GetPosition()
self.dtext.SetValue(str(year))
self.calend.SetYear(year)
self.calend.Refresh()
def EvtComboBox(self, event):
name = event.GetString()
self.log.WriteText('EvtComboBox: %s\n' % name)
monthval = self.date.FindString(name)
self.m_spin.SetValue(monthval+1)
self.calend.SetMonth(monthval+1)
self.ResetDisplay()
# set the calendar for highlighted days
def ResetDisplay(self):
month = self.calend.GetMonth()
try:
set_days = test_days[month]
except:
set_days = [1, 5, 12]
self.calend.AddSelect([4, 11], 'BLUE', 'WHITE')
self.calend.SetSelDay(set_days)
self.calend.Refresh()
# test of full window calendar control functions
class CalendFrame(wxFrame):
def __init__(self, parent, id, title, log):
wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition, wxSize(400, 400))
EVT_CLOSE(self, self.OnCloseWindow)
self.log = log
self.CreateStatusBar()
self.mainmenu = wxMenuBar()
menu = wxMenu()
menu = self.MakeFileMenu()
self.mainmenu.Append(menu, '&File')
self.MakeToolMenu() # toolbar
self.SetMenuBar(self.mainmenu)
self.calend = wxCalendar(self, -1)
self.calend.SetCurrentDay()
self.calend.grid_color = 'BLUE'
self.calend.SetBusType()
# self.calend.ShowWeekEnd()
self.ResetDisplay()
self.Connect(self.calend.GetId(), -1, 2100, self.MouseClick)
def MouseClick(self, evt):
text = '%s CLICK %02d/%02d/%d' % (evt.click, evt.day, evt.month, evt.year) # format date
self.log.WriteText('Date Selected: ' + text + '\n')
def OnCloseWindow(self, event):
self.Destroy()
def ResetDisplay(self):
month = self.calend.GetMonth()
try:
set_days = test_days[month]
except:
set_days = [1, 5, 12]
self.calend.AddSelect([2, 16], 'GREEN', 'WHITE')
self.calend.SetSelDay(set_days)
self.calend.Refresh()
def OnIncYear(self, event):
self.calend.IncYear()
self.ResetDisplay()
def OnDecYear(self, event):
self.calend.DecYear()
self.ResetDisplay()
def OnIncMonth(self, event):
self.calend.IncMonth()
self.ResetDisplay()
def OnDecMonth(self, event):
self.calend.DecMonth()
self.ResetDisplay()
def OnCurrent(self, event):
self.calend.SetCurrentDay()
self.ResetDisplay()
def MakeFileMenu(self):
menu = wxMenu()
mID = NewId()
menu.Append(mID, 'Decrement', 'Next')
EVT_MENU(self, mID, self.OnDecMonth)
mID = NewId()
menu.Append(mID, 'Increment', 'Dec')
EVT_MENU(self, mID, self.OnIncMonth)
menu.AppendSeparator()
mID = NewId()
menu.Append(mID, 'E&xit', 'Exit')
EVT_MENU(self, mID, self.OnCloseWindow)
return menu
def MakeToolMenu(self):
tb = self.CreateToolBar(wxTB_HORIZONTAL|wxNO_BORDER)
bmp_path = 'bitmaps/'
SetToolPath(self, tb, 10, bmp_path + 'DbDec.bmp', 'Dec Year')
EVT_TOOL(self, 10, self.OnDecYear)
SetToolPath(self, tb, 15, bmp_path + 'Dec.bmp', 'Dec Month')
EVT_TOOL(self, 15, self.OnDecMonth)
SetToolPath(self, tb, 30, bmp_path + 'Pt.bmp', 'Current Month')
EVT_TOOL(self, 30, self.OnCurrent)
SetToolPath(self, tb, 40, bmp_path + 'Inc.bmp', 'Inc Month')
EVT_TOOL(self, 40, self.OnIncMonth)
SetToolPath(self, tb, 45, bmp_path + 'DbInc.bmp', 'Inc Year')
EVT_TOOL(self, 45, self.OnIncYear)
tb.Realize()
#---------------------------------------------------------------------------
# example class for printing/previewing calendars
class PrintCalend:
def __init__(self, parent, month, year):
self.frame = parent
self.month = month
self.year = year
self.SetParms()
self.SetCal()
self.printData = wxPrintData()
def SetCal(self):
self.grid_color = 'BLUE'
self.back_color = 'WHITE'
self.sel_color = 'RED'
self.high_color = 'LIGHT BLUE'
self.font = wxSWISS
self.bold = wxNORMAL
self.sel_key = None # last used by
self.sel_lst = [] # highlighted selected days
self.size = None
self.hide_title = FALSE
self.hide_grid = FALSE
self.set_day = None
def SetParms(self):
self.ymax = 1
self.xmax = 1
self.page = 1
self.total_pg = 1
self.preview = None
self.scale = 1.0
self.pagew = 8.5
self.pageh = 11.0
self.txt_marg = 0.1
self.lf_marg = 0
self.top_marg = 0
self.page = 0
def SetDates(self, month, year):
self.month = month
self.year = year
def SetStyleDef(self, desc):
self.style = desc
def SetCopies(self, copies): # number of copies of label
self.copies = copies
def SetStart(self, start): # start position of label
self.start = start
def Preview(self):
printout = SetPrintout(self)
printout2 = SetPrintout(self)
self.preview = wxPrintPreview(printout, printout2, self.printData)
if not self.preview.Ok():
wxMessageBox("There was a problem printing!", "Printing", wxOK)
return
self.preview.SetZoom(60) # initial zoom value
frame = wxPreviewFrame(self.preview, self.frame, "Print preview")
frame.Initialize()
frame.SetPosition(self.frame.GetPosition())
frame.SetSize(self.frame.GetSize())
frame.Show(true)
def Print(self):
pdd = wxPrintDialogData()
pdd.SetPrintData(self.printData)
printer = wxPrinter(pdd)
printout = SetPrintout(self)
frame = wxFrame(NULL, -1, "Test")
if not printer.Print(frame, printout):
wxMessageBox("There was a problem printing.\nPerhaps your current printer is not set correctly?", "Printing", wxOK)
else:
self.printData = printer.GetPrintDialogData().GetPrintData()
printout.Destroy()
def DoDrawing(self, DC):
size = DC.GetSizeTuple()
DC.BeginDrawing()
cal = PrtCalDraw(self)
if self.preview is None:
cal.SetPSize(size[0]/self.pagew, size[1]/self.pageh)
cal.SetPreview(FALSE)
else:
if self.preview == 1:
cal.SetPSize(size[0]/self.pagew, size[1]/self.pageh)
else:
cal.SetPSize(self.pwidth, self.pheight)
cal.SetPreview(self.preview)
cal.hide_title = self.hide_title # set the calendar parameters
cal.hide_grid = self.hide_grid
cal.grid_color = self.grid_color
cal.high_color = self.high_color
cal.back_color = self.back_color
cal.outer_border = FALSE
cal.font = self.font
cal.bold = self.bold
cal_size = wxSize(3.0, 3.0)
cal.SetSize(cal_size)
year, month = self.year, self.month
x = 1.0
for i in range(2):
y = 0.5
for j in range(3):
cal.SetCal(year, month) # current month
cal.SetPos(x, y)
try:
set_days = test_days[month]
except:
set_days = [1, 5, 12]
cal.AddSelect([2, 16], 'GREEN', 'WHITE')
cal.DrawCal(DC, set_days)
year, month = self.IncMonth(year, month)
y = y + 3.5
x = x + 4.0 # next colum
DC.EndDrawing()
self.ymax = DC.MaxY()
self.xmax = DC.MaxX()
def IncMonth(self, year, month): # next month
month = month + 1
if month > 12:
month = 1
year = year + 1
return year, month
def GetTotalPages(self):
self.pg_cnt = 1
return self.pg_cnt
def SetPage(self, page):
self.page = page
def SetPageSize(self, width, height):
self.pwidth, self.pheight = width, height
def SetTotalSize(self, width, height):
self.ptwidth, self.ptheight = width, height
def SetPreview(self, preview, scale):
self.preview = preview
self.scale = scale
def SetTotalSize(self, width, height):
self.ptwidth = width
self.ptheight = height
def SetToolPath(self, tb, id, bmp, title):
global dir_path
tb.AddSimpleTool(id, wxBitmap(os.path.join(dir_path, bmp), wxBITMAP_TYPE_BMP),
title, title)
class SetPrintout(wxPrintout):
def __init__(self, canvas):
wxPrintout.__init__(self)
self.canvas = canvas
self.end_pg = 1
def OnBeginDocument(self, start, end):
return self.base_OnBeginDocument(start, end)
def OnEndDocument(self):
self.base_OnEndDocument()
def HasPage(self, page):
if page <= self.end_pg:
return true
else:
return false
def GetPageInfo(self):
self.end_pg = self.canvas.GetTotalPages()
str_pg = 1
try:
end_pg = self.end_pg
except:
end_pg = 1
return (str_pg, end_pg, str_pg, end_pg)
def OnPreparePrinting(self):
self.base_OnPreparePrinting()
def OnBeginPrinting(self):
dc = self.GetDC()
self.preview = self.IsPreview()
if (self.preview):
self.pixelsPerInch = self.GetPPIScreen()
else:
self.pixelsPerInch = self.GetPPIPrinter()
(w, h) = dc.GetSizeTuple()
scaleX = float(w) / 1000
scaleY = float(h) / 1000
self.printUserScale = min(scaleX, scaleY)
self.base_OnBeginPrinting()
def GetSize(self):
self.psizew, self.psizeh = self.GetPPIPrinter()
return self.psizew, self.psizeh
def GetTotalSize(self):
self.ptsizew, self.ptsizeh = self.GetPageSizePixels()
return self.ptsizew, self.ptsizeh
def OnPrintPage(self, page):
dc = self.GetDC()
(w, h) = dc.GetSizeTuple()
scaleX = float(w) / 1000
scaleY = float(h) / 1000
self.printUserScale = min(scaleX, scaleY)
dc.SetUserScale(self.printUserScale, self.printUserScale)
self.preview = self.IsPreview()
self.canvas.SetPreview(self.preview, self.printUserScale)
self.canvas.SetPage(page)
self.ptsizew, self.ptsizeh = self.GetPageSizePixels()
self.canvas.SetTotalSize(self.ptsizew, self.ptsizeh)
self.psizew, self.psizeh = self.GetPPIPrinter()
self.canvas.SetPageSize(self.psizew, self.psizeh)
self.canvas.DoDrawing(dc)
return true
class MyApp(wxApp):
def OnInit(self):
frame = CalendFrame(NULL, -1, "Test Calendar")
frame.Show(true)
self.SetTopWindow(frame)
return true
#---------------------------------------------------------------------------
def MessageDlg(self, message, type = 'Message'):
dlg = wxMessageDialog(self, message, type, wxOK | wxICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
#---------------------------------------------------------------------------
def main():
app = MyApp(0)
app.MainLoop()
if __name__ == '__main__':
main()
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestPanel(nb, log, frame)
return win
#---------------------------------------------------------------------------
overview = """\
This control provides a calendar control class for displaying and selecting dates. In addition, the class is extended and can now be used for printing/previewing.
Additional features include weekend highlighting and business type Monday-Sunday format.
See example for various methods used to set display month, year, and highlighted dates (different font and background colours).
by Lorne White
"""

40
wxPython/demo/wxCalendarCtrl.py Normal file
View File

@@ -0,0 +1,40 @@
from wxPython.wx import *
from wxPython.calendar import *
from wxPython.utils import *
#----------------------------------------------------------------------
class TestPanel(wxPanel):
def __init__(self, parent, ID, log):
wxPanel.__init__(self, parent, ID)
self.log = log
cal = wxCalendarCtrl(self, 101, wxDateTime_Now(), pos = (25,50),
style = wxCAL_SHOW_HOLIDAYS | wxCAL_SUNDAY_FIRST)
EVT_CALENDAR(self, 101, self.OnCalSelected)
def OnCalSelected(self, evt):
self.log.write('OnCalSelected: %s\n' % evt.GetDate())
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestPanel(nb, -1, log)
return win
#----------------------------------------------------------------------
overview = """\
<html><body>
<h2>wxCalendarCtrl</h2>
Yet <i>another</i> calendar control. This one is a wrapper around the C++
version described in the docs. This one will probably be a bit more efficient
than the one in wxPython.lib.calendar, but I like a few things about it better,
so I think both will stay in wxPython.
"""

80
wxPython/demo/wxCheckBox.py Normal file
View File

@@ -0,0 +1,80 @@
from wxPython.wx import *
#---------------------------------------------------------------------------
class TestCheckBox(wxPanel):
def __init__(self, parent, log):
self.log = log
wxPanel.__init__(self, parent, -1)
wxStaticText(self, -1, "This example uses the wxCheckBox control.",
wxPoint(10, 10))
cID = NewId()
cb1 = wxCheckBox(self, cID, " Apples", wxPoint(65, 40), wxSize(150, 20), wxNO_BORDER)
cb2 = wxCheckBox(self, cID+1, " Oranges", wxPoint(65, 60), wxSize(150, 20), wxNO_BORDER)
cb2.SetValue(true)
cb3 = wxCheckBox(self, cID+2, " Pears", wxPoint(65, 80), wxSize(150, 20), wxNO_BORDER)
EVT_CHECKBOX(self, cID, self.EvtCheckBox)
EVT_CHECKBOX(self, cID+1, self.EvtCheckBox)
EVT_CHECKBOX(self, cID+2, self.EvtCheckBox)
def EvtCheckBox(self, event):
self.log.WriteText('EvtCheckBox: %d\n' % event.Checked())
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestCheckBox(nb, log)
return win
#---------------------------------------------------------------------------
overview = """\
A checkbox is a labelled box which is either on (checkmark is visible) or off (no checkmark).
wxCheckBox()
-----------------------
Default constructor.
wxCheckBox(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& val, const wxString& name = "checkBox")
Constructor, creating and showing a checkbox.
Parameters
-------------------
parent = Parent window. Must not be NULL.
id = Checkbox identifier. A value of -1 indicates a default value.
label = Text to be displayed next to the checkbox.
pos = Checkbox position. If the position (-1, -1) is specified then a default position is chosen.
size = Checkbox size. If the default size (-1, -1) is specified then a default size is chosen.
style = Window style. See wxCheckBox.
validator = Window validator.
name = Window name.
"""

53
wxPython/demo/wxCheckListBox.py Normal file
View File

@@ -0,0 +1,53 @@
from wxPython.wx import *
#----------------------------------------------------------------------
class TestPanel(wxPanel):
def __init__(self, parent, log):
wxPanel.__init__(self, parent, -1)
self.log = log
sampleList = ['zero', 'one', 'two', 'three', 'four', 'five',
'six', 'seven', 'eight', 'nine', 'ten', 'eleven',
'twelve', 'thirteen', 'fourteen']
wxStaticText(self, -1, "This example uses the wxCheckListBox control.",
wxPoint(45, 15))
lb = wxCheckListBox(self, 60, wxPoint(80, 50), wxSize(80, 120),
sampleList)
EVT_LISTBOX(self, 60, self.EvtListBox)
EVT_LISTBOX_DCLICK(self, 60, self.EvtListBoxDClick)
lb.SetSelection(0)
def EvtListBox(self, event):
self.log.WriteText('EvtListBox: %s\n' % event.GetString())
def EvtListBoxDClick(self, event):
self.log.WriteText('EvtListBoxDClick:\n')
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestPanel(nb, log)
return win
#----------------------------------------------------------------------
overview = """\
"""

76
wxPython/demo/wxChoice.py Normal file
View File

@@ -0,0 +1,76 @@
from wxPython.wx import *
#---------------------------------------------------------------------------
class TestChoice(wxPanel):
def __init__(self, parent, log):
self.log = log
wxPanel.__init__(self, parent, -1)
sampleList = ['zero', 'one', 'two', 'three', 'four', 'five',
'six', 'seven', 'eight']
wxStaticText(self, -1, "This example uses the wxChoice control.",
wxPoint(15, 10))
wxStaticText(self, -1, "Select one:", wxPoint(15, 50), wxSize(75, 20))
wxChoice(self, 40, wxPoint(80, 50), wxSize(95, 20), #wxDefaultSize,
sampleList)
EVT_CHOICE(self, 40, self.EvtChoice)
def EvtChoice(self, event):
self.log.WriteText('EvtChoice: %s\n' % event.GetString())
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestChoice(nb, log)
return win
#---------------------------------------------------------------------------
overview = """\
A choice item is used to select one of a list of strings. Unlike a listbox, only the selection is visible until the user pulls down the menu of choices.
wxChoice()
-------------------
Default constructor.
wxChoice(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, int n, const wxString choices[], long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "choice")
Constructor, creating and showing a choice.
Parameters
-------------------
parent = Parent window. Must not be NULL.
id = Window identifier. A value of -1 indicates a default value.
pos = Window position.
size = Window size. If the default size (-1, -1) is specified then the choice is sized appropriately.
n = Number of strings with which to initialise the choice control.
choices = An array of strings with which to initialise the choice control.
style = Window style. See wxChoice.
validator = Window validator.
name = Window name.
"""

38
wxPython/demo/wxColourDialog.py Normal file
View File

@@ -0,0 +1,38 @@
from wxPython.wx import *
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
data = wxColourData()
data.SetChooseFull(true)
dlg = wxColourDialog(frame, data)
if dlg.ShowModal() == wxID_OK:
data = dlg.GetColourData()
log.WriteText('You selected: %s\n' % str(data.GetColour().Get()))
dlg.Destroy()
#---------------------------------------------------------------------------
overview = """\
This class represents the colour chooser dialog.
wxColourDialog()
------------------------------
wxColourDialog(wxWindow* parent, wxColourData* data = NULL)
Constructor. Pass a parent window, and optionally a pointer to a block of colour data, which will be copied to the colour dialog's colour data.
"""

83
wxPython/demo/wxComboBox.py Normal file
View File

@@ -0,0 +1,83 @@
from wxPython.wx import *
#---------------------------------------------------------------------------
class TestComboBox(wxPanel):
def __init__(self, parent, log):
self.log = log
wxPanel.__init__(self, parent, -1)
sampleList = ['zero', 'one', 'two', 'three', 'four', 'five',
'six', 'seven', 'eight']
wxStaticText(self, -1, "This example uses the wxComboBox control.",
wxPoint(8, 10))
wxStaticText(self, -1, "Select one:", wxPoint(15, 50), wxSize(75, 18))
wxComboBox(self, 500, "default value", wxPoint(80, 50), wxSize(95, -1),
sampleList, wxCB_DROPDOWN)
EVT_COMBOBOX(self, 500, self.EvtComboBox)
EVT_TEXT(self, 500, self.EvtText)
def EvtComboBox(self, event):
self.log.WriteText('EvtComboBox: %s\n' % event.GetString())
def EvtText(self, event):
self.log.WriteText('EvtText: %s\n' % event.GetString())
#---------------------------------------------------------------------------
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.
A combobox permits a single selection only. Combobox items are numbered from zero.
wxComboBox()
-----------------------
Default constructor.
wxComboBox(wxWindow* parent, wxWindowID id, const wxString& value = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, int n, const wxString choices[], long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = "comboBox")
Constructor, creating and showing a combobox.
Parameters
-------------------
parent = Parent window. Must not be NULL.
id = Window identifier. A value of -1 indicates a default value.
pos = Window position.
size = Window size. If the default size (-1, -1) is specified then the window is sized appropriately.
n = Number of strings with which to initialise the control.
choices = An array of strings with which to initialise the control.
style = Window style. See wxComboBox.
validator = Window validator.
name = Window name.
"""

33
wxPython/demo/wxDialog.py Normal file
View File

@@ -0,0 +1,33 @@
from wxPython.wx import *
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
win = wxDialog(frame, -1, "This is a wxDialog", wxDefaultPosition, wxSize(350, 200))
wxStaticText(win, -1, "This is a wxDialog", wxPoint(20, 20))
wxButton(win, wxID_OK, " OK ", wxPoint(75, 120), wxDefaultSize).SetDefault()
wxButton(win, wxID_CANCEL, " Cancel ", wxPoint(200, 120), wxDefaultSize)
val = win.ShowModal()
if val == wxID_OK:
log.WriteText("You pressed OK\n")
else:
log.WriteText("You pressed Cancel\n")
#---------------------------------------------------------------------------
overview = """\
"""

53
wxPython/demo/wxDirDialog.py Normal file
View File

@@ -0,0 +1,53 @@
from wxPython.wx import *
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
dlg = wxDirDialog(frame)
if dlg.ShowModal() == wxID_OK:
log.WriteText('You selected: %s\n' % dlg.GetPath())
dlg.Destroy()
#---------------------------------------------------------------------------
overview = """\
This class represents the directory chooser dialog.
wxDirDialog()
------------------------
wxDirDialog(wxWindow* parent, const wxString& message = "Choose a directory", const wxString& defaultPath = "", long style = 0, const wxPoint& pos = wxDefaultPosition)
Constructor. Use wxDirDialog::ShowModal to show the dialog.
Parameters
-------------------
parent = Parent window.
message = Message to show on the dialog.
defaultPath = The default path, or the empty string.
style = A dialog style, currently unused.
pos = Dialog position.
"""

249
wxPython/demo/wxDragImage.py Normal file
View File

@@ -0,0 +1,249 @@
from wxPython.wx import *
#----------------------------------------------------------------------
class DragShape:
def __init__(self, bmp):
self.bmp = bmp
self.pos = wxPoint(0,0)
self.shown = true
self.text = None
self.fullscreen = false
def HitTest(self, pt):
rect = self.GetRect()
return rect.Inside(pt.x, pt.y)
def GetRect(self):
return wxRect(self.pos.x, self.pos.y,
self.bmp.GetWidth(), self.bmp.GetHeight())
def Draw(self, dc, op = wxCOPY):
if self.bmp.Ok():
memDC = wxMemoryDC()
memDC.SelectObject(self.bmp)
dc.Blit(self.pos.x, self.pos.y,
self.bmp.GetWidth(), self.bmp.GetHeight(),
memDC, 0, 0, op, true)
return true
else:
return false
#----------------------------------------------------------------------
class DragCanvas(wxScrolledWindow):
def __init__(self, parent, ID):
wxScrolledWindow.__init__(self, parent, ID)
self.shapes = []
self.dragImage = None
self.dragShape = None
self.SetCursor(wxStockCursor(wxCURSOR_ARROW))
self.bg_bmp = wxBitmap('bitmaps/backgrnd.png', wxBITMAP_TYPE_PNG)
# Make a shape from an image and mask. This one will demo
# dragging outside the window
bmp = wxBitmap('bitmaps/test_image.png', wxBITMAP_TYPE_PNG)
mask = wxMaskColour(bmp, wxWHITE)
bmp.SetMask(mask)
shape = DragShape(bmp)
shape.pos = wxPoint(5, 5)
shape.fullscreen = true
self.shapes.append(shape)
# Make a shape from some text
text = "Some Text"
font = wxFont(15, wxROMAN, wxNORMAL, wxBOLD)
textExtent = self.GetFullTextExtent(text, font)
bmp = wxEmptyBitmap(textExtent[0], textExtent[1])
dc = wxMemoryDC()
dc.SelectObject(bmp)
dc.Clear()
dc.SetTextForeground(wxRED)
dc.SetFont(font)
dc.DrawText(text, 0, 0)
dc.SelectObject(wxNullBitmap)
del dc
mask = wxMaskColour(bmp, wxWHITE)
bmp.SetMask(mask)
shape = DragShape(bmp)
shape.pos = wxPoint(5, 100)
shape.text = "Some dragging text"
self.shapes.append(shape)
# Make some shapes from some playing card images.
x = 200
for card in ['01c.gif', '10s.gif', '12h.gif', '13d.gif']:
bmp = wxBitmap('bitmaps/'+card, wxBITMAP_TYPE_GIF)
shape = DragShape(bmp)
shape.pos = wxPoint(x, 5)
self.shapes.append(shape)
x = x + 80
EVT_ERASE_BACKGROUND(self, self.OnEraseBackground)
EVT_PAINT(self, self.OnPaint)
EVT_LEFT_DOWN(self, self.OnLeftDown)
EVT_LEFT_UP(self, self.OnLeftUp)
EVT_MOTION(self, self.OnMotion)
def TileBackground(self, dc):
# 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
def DrawShapes(self, dc):
for shape in self.shapes:
if shape.shown:
shape.Draw(dc)
def FindShape(self, pt):
for shape in self.shapes:
if shape.HitTest(pt):
return shape
return None
def EraseShape(self, shape, dc):
r = shape.GetRect()
dc.SetClippingRegion(r.x, r.y, r.width, r.height)
self.TileBackground(dc)
self.DrawShapes(dc)
dc.DestroyClippingRegion()
def OnEraseBackground(self, evt):
dc = evt.GetDC()
if not dc:
dc = wxClientDC(self)
self.TileBackground(dc)
def OnPaint(self, evt):
dc = wxPaintDC(self)
self.PrepareDC(dc)
self.DrawShapes(dc)
def OnLeftDown(self, evt):
shape = self.FindShape(evt.GetPosition())
if shape:
# get ready to start dragging, but wait for the user to
# move it a bit first
self.dragShape = shape
self.dragStartPos = evt.GetPosition()
def OnLeftUp(self, evt):
if not self.dragImage or not self.dragShape:
self.dragImage = None
self.dragShape = None
return
# end the dragging
self.dragImage.Hide()
self.dragImage.EndDrag()
self.dragImage = None
# reposition and draw the shape
pt = evt.GetPosition()
newPos = wxPoint(self.dragShape.pos.x + (pt.x - self.dragStartPos.x),
self.dragShape.pos.y + (pt.y - self.dragStartPos.y))
dc = wxClientDC(self)
self.dragShape.pos = newPos
self.dragShape.shown = true
self.dragShape.Draw(dc)
self.dragShape = None
def OnMotion(self, evt):
if not self.dragShape or not evt.Dragging() or not evt.LeftIsDown():
return
# if we have a shape, but havn't started dragging yet
if self.dragShape and not self.dragImage:
# only start the drag after having moved a couple pixels
tolerance = 4
pt = evt.GetPosition()
dx = abs(pt.x - self.dragStartPos.x)
dy = abs(pt.y - self.dragStartPos.y)
if dx <= tolerance and dy <= tolerance:
return
if self.dragShape.text:
self.dragImage = wxDragString(self.dragShape.text,
wxStockCursor(wxCURSOR_HAND))
else:
self.dragImage = wxDragImage(self.dragShape.bmp,
wxStockCursor(wxCURSOR_HAND))
newPos = wxPoint(self.dragShape.pos.x + (pt.x - self.dragStartPos.x),
self.dragShape.pos.y + (pt.y - self.dragStartPos.y))
if self.dragShape.fullscreen:
newPos = self.ClientToScreen(newPos)
self.dragImage.BeginDrag((0,0), self, true)
else:
self.dragImage.BeginDrag((0,0), self)
# erase the shape since it will be drawn independently now
dc = wxClientDC(self)
self.dragShape.shown = false
self.EraseShape(self.dragShape, dc)
self.dragImage.Move(newPos)
self.dragImage.Show()
# if we have shape and image then move it.
elif self.dragShape and self.dragImage:
pt = evt.GetPosition()
newPos = wxPoint(self.dragShape.pos.x + (pt.x - self.dragStartPos.x),
self.dragShape.pos.y + (pt.y - self.dragStartPos.y))
if self.dragShape.fullscreen:
newPos = self.ClientToScreen(newPos)
self.dragImage.Move(newPos)
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = DragCanvas(nb, -1)
return win
#----------------------------------------------------------------------
overview = """\
"""

43
wxPython/demo/wxEditor.py Normal file
View File

@@ -0,0 +1,43 @@
from wxPython.wx import *
from wxPython.lib.editor import wxEditor, wxPyEditor
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = wxPanel(nb, -1)
ed = wxEditor(win, -1, style=wxSUNKEN_BORDER)
pyed = wxPyEditor(win, -1, style=wxSUNKEN_BORDER)
box = wxBoxSizer(wxVERTICAL)
box.Add(ed, 1, wxALL|wxGROW, 5)
box.Add(pyed, 1, wxALL|wxGROW, 5)
win.SetSizer(box)
win.SetAutoLayout(true)
ed.SetText(["",
"This is a simple text editor, the class name is",
"wxEditor. Type a few lines and try it out.",
""])
pyed.SetText(["# This one is a derived class named wxPyEditor.",
"# It adds syntax highlighting, folding (press",
"# F12 on the \"def\" line below) and other stuff.",
"import sys",
"def hello():",
" print 'hello'",
" for x in sys.path:",
" print x",
""])
return win
#----------------------------------------------------------------------
overview = """\
"""

63
wxPython/demo/wxFileDialog.py Normal file
View File

@@ -0,0 +1,63 @@
from wxPython.wx import *
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
dlg = wxFileDialog(frame, "Choose a file", ".", "", "*.*", wxOPEN|wxMULTIPLE)
if dlg.ShowModal() == wxID_OK:
for path in dlg.GetPaths():
log.WriteText('You selected: %s\n' % path)
dlg.Destroy()
#---------------------------------------------------------------------------
overview = """\
This class represents the file chooser dialog.
wxFileDialog()
----------------------------
wxFileDialog(wxWindow* parent, const wxString& message = "Choose a file", const wxString& defaultDir = ""
, const wxString& defaultFile = "", const wxString& wildcard = "*.*", long style = 0, const wxPoint& pos = wxDefaultPosition)
Constructor. Use wxFileDialog::ShowModal to show the dialog.
Parameters
-------------------
parent = Parent window.
message = Message to show on the dialog.
defaultDir = The default directory, or the empty string.
defaultFile = The default filename, or the empty string.
wildcard = A wildcard, such as "*.*".
style = A dialog style. A bitlist of:
wxOPEN This is an open dialog (Windows only).
wxSAVE This is a save dialog (Windows only).
wxHIDE_READONLY Hide read-only files (Windows only).
wxOVERWRITE_PROMPT Prompt for a conformation if a file will be overridden (Windows only).
pos = Dialog position.
"""

103
wxPython/demo/wxFloatBar.py Normal file
View File

@@ -0,0 +1,103 @@
from wxPython.wx import *
from wxPython.lib.floatbar import *
class TestFloatBar(wxFrame):
def __init__(self, parent, log):
wxFrame.__init__(self, parent, -1, 'Test ToolBar',
wxPoint(0,0), wxSize(500, 300))
self.log = log
win = wxWindow(self, -1)
win.SetBackgroundColour(wxNamedColour("WHITE"))
wxStaticText(win, -1, "Drag the toolbar to float it,\n"
"Toggle the last tool to remove\nthe title.", wxPoint(15,15))
tb = wxFloatBar(self, -1)
self.SetToolBar(tb)
tb.SetFloatable(1)
tb.SetTitle("Floating!")
self.CreateStatusBar()
tb.AddSimpleTool(10, wxBitmap('bitmaps/new.bmp', wxBITMAP_TYPE_BMP),
"New", "Long help for 'New'")
EVT_TOOL(self, 10, self.OnToolClick)
EVT_TOOL_RCLICKED(self, 10, self.OnToolRClick)
tb.AddSimpleTool(20, wxBitmap('bitmaps/open.bmp', wxBITMAP_TYPE_BMP),
"Open")
EVT_TOOL(self, 20, self.OnToolClick)
EVT_TOOL_RCLICKED(self, 20, self.OnToolRClick)
tb.AddSeparator()
tb.AddSimpleTool(30, wxBitmap('bitmaps/copy.bmp', wxBITMAP_TYPE_BMP),
"Copy")
EVT_TOOL(self, 30, self.OnToolClick)
EVT_TOOL_RCLICKED(self, 30, self.OnToolRClick)
tb.AddSimpleTool(40, wxBitmap('bitmaps/paste.bmp', wxBITMAP_TYPE_BMP),
"Paste")
EVT_TOOL(self, 40, self.OnToolClick)
EVT_TOOL_RCLICKED(self, 40, self.OnToolRClick)
tb.AddSeparator()
tb.AddTool(60, wxBitmap('bitmaps/tog1.bmp', wxBITMAP_TYPE_BMP),
wxBitmap('bitmaps/tog2.bmp', wxBITMAP_TYPE_BMP),
shortHelpString="Toggle with 2 bitmaps", toggle=true)
EVT_TOOL(self, 60, self.OnToolClick)
EVT_TOOL_RCLICKED(self, 60, self.OnToolRClick)
tb.Realize()
self.tb = tb
EVT_CLOSE(self, 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.Checked(), 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())
# def test(self, event):
# self.log.WriteText("Button clicked!")
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestFloatBar(frame, log)
frame.otherWin = win
win.Show(true)
#---------------------------------------------------------------------------
overview = """\
wxFloatBar is a subclass of wxToolBar, 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.
"""

40
wxPython/demo/wxFontDialog.py Normal file
View File

@@ -0,0 +1,40 @@
from wxPython.wx import *
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
data = wxFontData()
dlg = wxFontDialog(frame, data)
if dlg.ShowModal() == wxID_OK:
data = dlg.GetFontData()
font = data.GetChosenFont()
log.WriteText('You selected: "%s", %d points, color %s\n' %
(font.GetFaceName(), font.GetPointSize(),
data.GetColour().Get()))
dlg.Destroy()
#---------------------------------------------------------------------------
overview = """\
This class represents the font chooser dialog.
wxFontDialog()
----------------------------
wxFontDialog(wxWindow* parent, wxFontData* data)
Constructor. Pass a parent window and a font data object, which will be copied to the font dialog's font data.
"""

43
wxPython/demo/wxFrame.py Normal file
View File

@@ -0,0 +1,43 @@
from wxPython.wx import *
#---------------------------------------------------------------------------
class MyFrame(wxFrame):
def __init__(self, parent, ID, title, pos, size):
wxFrame.__init__(self, parent, ID, title, pos, size)
panel = wxPanel(self, -1)
button = wxButton(panel, 1003, "Close Me")
button.SetPosition(wxPoint(15, 15))
EVT_BUTTON(self, 1003, self.OnCloseMe)
EVT_CLOSE(self, self.OnCloseWindow)
def OnCloseMe(self, event):
self.Close(true)
def OnCloseWindow(self, event):
self.Destroy()
#---------------------------------------------------------------------------
def runTest(frame, nb, log):
win = MyFrame(frame, -1, "This is a wxFrame", wxDefaultPosition, wxSize(350, 200))
frame.otherWin = win
win.Show(true)
#---------------------------------------------------------------------------
overview = """\
"""

246
wxPython/demo/wxGLCanvas.py Normal file
View File

@@ -0,0 +1,246 @@
from wxPython.wx import *
try:
from wxPython.glcanvas import *
haveGLCanvas = true
except ImportError:
haveGLCanvas = false
try:
# The Python OpenGL package can be found at
# http://starship.python.net:9673/crew/da/Code/PyOpenGL/
from OpenGL.GL import *
from OpenGL.GLUT import *
haveOpenGL = true
except ImportError:
haveOpenGL = false
#----------------------------------------------------------------------
if not haveGLCanvas:
def runTest(frame, nb, log):
dlg = wxMessageDialog(frame, 'The wxGLCanvas has not been included with this build of wxPython!',
'Sorry', wxOK | wxICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
elif not haveOpenGL:
def runTest(frame, nb, log):
dlg = wxMessageDialog(frame,
'The OpenGL package was not found. You can get it at\n'
'http://starship.python.net:9673/crew/da/Code/PyOpenGL/',
'Sorry', wxOK | wxICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
else:
def runTest(frame, nb, log):
win = wxFrame(frame, -1, "GL Demos", wxDefaultPosition, wxSize(300,300))
CubeCanvas(win)
#MySplitter(win)
frame.otherWin = win
win.Show(true)
return None
class MySplitter(wxSplitterWindow):
def __init__(self, parent):
wxSplitterWindow.__init__(self, parent, -1)
cube = CubeCanvas(self)
cone = ConeCanvas(self)
self.SplitVertically(cube, cone)
self.SetSashPosition(300)
class CubeCanvas(wxGLCanvas):
def __init__(self, parent):
wxGLCanvas.__init__(self, parent, -1)
EVT_ERASE_BACKGROUND(self, self.OnEraseBackground)
EVT_SIZE(self, self.OnSize)
EVT_PAINT(self, self.OnPaint)
self.init = false
def OnEraseBackground(self, event):
pass # Do nothing, to avoid flashing.
def OnSize(self, event):
size = self.GetClientSize()
if self.GetContext():
self.SetCurrent()
glViewport(0, 0, size.width, size.height)
def OnPaint(self, event):
dc = wxPaintDC(self)
self.SetCurrent()
if not self.init:
self.InitGL()
self.init = true
# 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()
self.SwapBuffers()
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(30.0, 1.0, 0.0, 0.0);
glRotatef(30.0, 0.0, 1.0, 0.0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
class ConeCanvas(wxGLCanvas):
def __init__(self, parent):
wxGLCanvas.__init__(self, parent, -1)
EVT_ERASE_BACKGROUND(self, self.OnEraseBackground)
EVT_SIZE(self, self.OnSize)
EVT_PAINT(self, self.OnPaint)
self.init = false
def OnEraseBackground(self, event):
pass # Do nothing, to avoid flashing.
def OnSize(self, event):
size = self.GetClientSize()
if self.GetContext():
self.SetCurrent()
glViewport(0, 0, size.width, size.height)
def GLInit( 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]);
glLightModel(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)
def OnPaint( self, event ):
dc = wxPaintDC(self)
if not self.init:
self.GLInit()
self.init = true
### Tell system to use _this_ glcanvas for all commands
self.SetCurrent()
# clear color and depth buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
# position viewer
glMatrixMode(GL_MODELVIEW);
# 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);
### From cone.py
glTranslate(0, -1, 0)
glRotate(250, 1, 0, 0)
glutSolidCone(1, 2, 50, 10)
glPopMatrix()
# push into visible buffer
self.SwapBuffers()
#----------------------------------------------------------------------
overview = """\
"""
#----------------------------------------------------------------------
def _test():
class MyApp(wxApp):
def OnInit(self):
frame = wxFrame(NULL, -1, "GL Demos", wxDefaultPosition, wxSize(600,300))
#win = ConeCanvas(frame)
MySplitter(frame)
frame.Show(TRUE)
self.SetTopWindow(frame)
return TRUE
app = MyApp(0)
app.MainLoop()
if __name__ == '__main__':
_test()

55
wxPython/demo/wxGauge.py Normal file
View File

@@ -0,0 +1,55 @@
from wxPython.wx import *
#----------------------------------------------------------------------
class TestPanel(wxPanel):
def __init__(self, parent, log):
wxPanel.__init__(self, parent, -1)
self.log = log
self.count = 0
wxStaticText(self, -1, "This example uses the wxGauge control.",
wxPoint(45, 15))
#self.g1 = wxGauge(self, -1, 50, wxPoint(40, 50), wxSize(40, 160),
# wxGA_VERTICAL)
#self.g1.SetBezelFace(3)
#self.g1.SetShadowWidth(3)
self.g2 = wxGauge(self, -1, 50, wxPoint(110, 50), wxSize(250, 25),
wxGA_HORIZONTAL)
self.g2.SetBezelFace(5)
self.g2.SetShadowWidth(5)
EVT_IDLE(self, self.IdleHandler)
def IdleHandler(self, event):
self.count = self.count + 1
if self.count >= 50:
self.count = 0
#self.g1.SetValue(self.count)
self.g2.SetValue(self.count)
#----------------------------------------------------------------------
def runTest(frame, nb, log):
win = TestPanel(nb, log)
return win
#----------------------------------------------------------------------
overview = """\
"""

Some files were not shown because too many files have changed in this diff Show More