wxPython in Action - 错误提示：发生了异常

wxPython in Action
——
1 / 565

Part1 wxPython 19
1. wxPython 19
1.1 wxPython 20
1.2 wxPython 20
1.2.1 wxPython 21
1.2.2 22
wxPython application 23
23
23
1.3 wxPython 24
1.4 hello.py 26
2wxPython 28
2.1 28
2.2 29
2.2.1 wx.App 29
wx.App 30
2.2.2 31
2.3 wxPython 31
2.3.1 32
2.3.2 34
2.4 wxPython 34
2.4.1 35
2.4.2 35
2.5 36
2.5.1 wx.Frame 36
2 / 565

2.5.2 wxPythonID 37
ID 38
NewID() 38
2.5.3 wx.Sizewx.Point 38
2.5.4 wx.Frame 39
2.6 41
2.6.1 42
2.6.2 44
2.7 45
46
47
47
2.8 48
2.9 49
3 51
3.1 51
3.2 52
3.2.1 54
3.2.2 55
3.2.3 55
3.3 56
3.3.1 wx.EvtHandler 57
3.4 wxPython 61
3.4.1 62
64
64
65
3 / 565

66
67
3.4.2 Skip() 68
3.5 70
3.6 71
3.6.1 71
71
3.7 75
4PyCrustwxPython 76
4.1 wxPython 76
PyCrustPython shell 77
4.2 PyCrust 79
4.2.1 80
4.2.2 80
4.2.3 81
4.2.4 Python 81
4.2.5 82
4.2.6 83
4.2.7 shell 84
4.2.8 85
4.3 PyCrust notebook 87
4.3.1 Namespace 87
4.3.2 Display 89
4.3.3 Calltip 89
4.3.4 Session 90
4.3.5 Dispatcher 90
4.4 PyCrustwxPython 92
4 / 565

4.5 Py 96
4.5.1 GUI 97
4.5.2 97
buffer 98
crust 100
dispatcher 100
editor 102
filling 102
interpreter 103
introspect 103
shell 103
4.6 wxPythonPy 104
4.7 108
5 109
5.1 109
5.1.1 110
5.1.2 113
5.1.3 114
5.2 (Model)(View) 118
5.2.1 MVC(Model-View-Controller) 118
5.2.2 wxPythonPyGridTableBase 120
PyGridTableBase 122
PyGridTableBase 123
PyGridTableBase 123
PyGridTableBase 125
PyGridTableBase 127
5.2.3 129
5 / 565

5.3 GUI 133
5.3.1 unittest 134
5.3.2 unittest 135
5.3.3 137
5.4 138
6 140
6.1 141
6.1.1 141
141
147
6.2 149
6.2.1 149
6.2.2 152
6.3 156
6.3.1 156
6.3.2 160
6.4 161
6.4.1 161
sizer 161
sizer 162
6.4.2 (about) 168
6.4.3 170
6.5 172
Part 2 wxPython 174
7 175
7.1 175
6 / 565

7.1.1 175
176
178
178
7.1.2 179
179
180
7.1.3 181
7.1.4 182
184
7.1.5 186
7.1.6 187
7.1.7 187
7.1.8 188
7.2 189
7.2.1 189
7.2.2 191
7.2.3 toggle button 192
7.2.4 193
7.3 196
7.3.1 196
197
198
7.3.2 199
199
7.3.3 201
7.4 202
7.4.1 202
7 / 565

7.4.2 radio button 204
205
206
7.4.3 209
209
7.4.4 212
7.4.5 213
7.4.6 214
7.5 216
8 218
8.1 218
8.1.1 218
218
219
8.1.2 221
8.1.3 223
223
224
8.1.4 225
226
227
8.2 227
8.2.1 wx.Frame 227
8.2.2 230
8.2.3 231
232
233
8 / 565

234
8.3 235
8.3.1 MDI 235
8.7 236
8.3.2 238
8.3.3 239
8.3.4 242
8.4 244
8.4.1 245
8.4.2 246
8.4.3 249
8.4.4 250
8.4.5 251
8.5 252
9 253
9.1 253
9.1.1 253
9.1.2 255
wx.MessageDialog 256
wx.MessageBox() 257
9.1.3 258
9.1.4 261
9.1.5 262
9.2 264
9.2.1 264
266
267
9 / 565

9.2.2 269
9.2.3 271
9.2.4 273
9.3 274
9.4 278
9.5 validator 279
9.5.1 279
9.5.2 283
9.5.3 287
9.6 290
10wxPython 292
10.1 292
10.1.1 293
10.1.2 293
10.1.3 296
10.1.4 300
10.2 301
10.2.1 301
10.2.2 304
10.2.3 306
308
309
10.2.4 310
10.3 313
10.3.1 313
10.3.2 315
10.3.3 318
10 / 565

10.4 320
10.4.1 321
10.4.2 321
321
321
321
322
322
10.5 323
11 sizer 325
11.1 sizer 325
sizer 326
11.2 sizergrid sizer 327
11.2.1 grid sizer 327
11.2.2 sizer 330
Add() 330
insert() 331
Prepend() 331
11.2.3 sizer 332
11.2.4 sizer 335
11.2.5 sizer 337
11.3 sizer 339
11.3.1 flex grid sizer 339
11.3.2 grid bag sizer 343
grid bag sizerAdd() 345
11.3.3 box sizer 347
11.3.4 static box sizer 351
11 / 565

11.4 sizer 354
11.5 358
12 360
12.1 360
12.1.1 361
363
image 364
bitmap 364
12.1.2 365
367
alpha 367
12.1.3 368
370
12.2 370
12.2.1 371
371
372
374
12.2.2 374
12.2.3 381
382
382
12.2.4 385
12.3 386
12.3.1 386
12.3.2 389
390
12 / 565

12.3.3 390
12.3.4 392
12.4 392
wxPython 394
13 395
13.1 395
13.1.1 396
13.1.2 397
13.1.3 399
13.1.4 401
13.1.5 403
13.2 404
13.2.1 404
404
405
406
13.2.2 407
407
407
408
408
13.3 410
13.3.1 410
13.3.2 411
13.4 417
13.4.1 417
13.4.2 418
13 / 565

419
419
mixin 419
13.4.3 423
13.5 426
13.6 430
14 (grid) 432
14.1 432
14.1.1 433
14.1.2 435
14.2 439
14.2.1 439
14.2.2 440
14.2.3 443
445
445
446
14.2.4 447
14.2.5 449
14.3 452
14.3.1 452
(renderer) 453
454
14.3.2 456
14.3.3 457
457
458
14 / 565

14.4 462
14.4.1 462
14.4.2 465
14.5 466
15 (tree control) 468
15.1 468
15.1.1 root() 481
15.1.2 482
15.1.3 482
15.2 483
15.3 485
15.4 486
15.5 488
15.6 490
15.7 490
491
494
15.8 495
15.9 496
15.10 497
15.11 501
16 HTML 503
16.1 HTML 503
16.1.1 wxPythonHTML 503
16.1.2 URLHTML 506
16.2 HTML 508
15 / 565

16.2.1 508
16.2.2 HTML 509
16.2.3 510
16.2.4 HTML 512
wx.html.HtmlEasyPrinting 512
513
513
513
16.3 HTML 513
16.3.1 HTML(parser) 514
16.3.2 515
16.3.3 519
16.3.4 HTML 520
16.4 521
17 wxPython 522
17.1 wxPython 522
17.1.1 523
17.1.2 524
17.1.3 wx.Printout 531
17.2 532
17.2.1 532
533
533
17.3 535
17.3.1 535
17.3.2 536
17.4 538
16 / 565

538
wx.Printer 538
wx.PrinterPrint () 538
17.5 539
539
539
540
17.6 540
18 wxPython 541
18.1 541
18.1.1 541
18.1.2 542
18.1.3 543
18.1.4 543
18.1.5 546
1 547
2 547
3 548
4 548
18.2.1 548
18.3 551
18.3.1 551
18.3.2 553
18.4 555
18.4.1 555
18.4.2 556
18.4.3 556
17 / 565

18.5 wx.Timer 557
18.5.1 EVT_TIMER 557
557
558
558
559
18.5.2 560
18.6 wxPython 560
18.6.1 wx.CallAfter() 561
18.6.2 564
18.6.3 564
18.7 565
18 / 565

Part1 wxPython
1. wxPython
#!/bin/env python
import wx
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”My Frame”, size=(300, 300))
panel = wx.Panel(self, -1)
panel.Bind(wx.EVT_MOTION, self.OnMove)
wx.StaticText(panel, -1, ”Pos:”, pos=(10, 12))
self.posCtrl = wx.TextCtrl(panel, -1, ””, pos=(40, 10))
def OnMove(self, event):
pos = event.GetPosition()
self.posCtrl.SetValue(“%s, %s” % (pos.x, pos.y))
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = MyFrame()
frame.Show(True)
app.MainLoop()
GUIwxPython
PythonPythongui
19 / 565

1.1 wxPython
1wxPthon
2
3wxPythonlogo
1.2 wxPython
bare.py
import wx #1
class App(wx.App): #2
def OnInit(self): #3
frame = wx.Frame(parent=None, title=’Bare’)
frame.Show()
return True
app = App() #4
app.MainLoop() #5
20 / 565

wxPython
wxPython
1wxPython
2wxPython
3
4
5
1.2.1 wxPython
wxPythonwx:
import wx
wxPythonwx
class App(wx.App):
wxPython
wx
wxPythonwxfrom wxPython import wxwx
from wxPython.wx import *
Pythonwx
wx
21 / 565

import*wxPython
wxPythonPython
import*
from wxPython import wx
wxwx.wxWindow
wxPython
wxPythonwxPython
wxwxPythonwxPython
wxPythonxrcwx
import wx
from wx import xrc
wxPythonPython
import sys
import wx
import os
from wx import xrc
import urllib
1.2.2
wxapplication
framewxPythonapplication
frameapplicationwx.AppOnInit()
OnInit()
wx.App
22 / 565

wx.App
class MyApp(wx.App):
def OnInit(self):
frame = wx.Frame(parent=None, id=-1, title=”Bare”)
frame.Show()
return True
MyAppOnInit()
framewx.Frame
Show()frameShow()
frame
frame.Show(False) # .
frame.Show(True) # True.
frame.Hide() # frame.Show(False)
__init__()Python
wx.App.__init()__
__init__()__init()__
class App(wx.App):
def __init__(self):
wx.App.__init__(self)
wxPythonOnInit()
wx.AppMainLoop()
app = App()
app.MainLoop()
23 / 565

wxPythonwxPython GUI
app.MainLoop()
1.3 wxPython
Python
spare.py
#!/usr/bin/env python #1
“””Spare.py is a starting point for a wxPython program.””” #2
import wx
class Frame(wx.Frame): #3
pass
class App(wx.App):
def OnInit(self):
self.frame = Frame(parent=None, title=’Spare’) #4
self.frame.Show()
self.SetTopWindow(self.frame) #5
return True
if __name__ == ’__main__’: #6
app = App()
app.MainLoop()
14
#1 linuxunix
chmod
24 / 565

% spare.py
#2
__doc__
Python
>>> import spare
>>> print spare.__doc__
Spare.py is a starting point for simple wxPython programs.
>>>
#3 framebare
wx.FramespareFrame
wx.Frame
Frame
#4 frame
#5 OnInit()AppSetTopWindow()
frameSetTopWindow()
wx.AppSetTopWindow()wxPython
wxPython
#6 Python
__name__
if __name__ == ’__main__’:
app = App()
app.MainLoop()
25 / 565

1.4 hello.py
#!/usr/bin/env python
“””Hello, wxPython! program.”””
import wx
class Frame(wx.Frame): #2 wx.Frame
”””Frame class that displays an image.”””
def __init__(self, image, parent=None, id=-1,
pos=wx.DefaultPosition,
title=’Hello, wxPython!’): #3
”””Create a Frame instance and display image.”””
#4
temp = image.ConvertToBitmap()
size = temp.GetWidth(), temp.GetHeight()
wx.Frame.__init__(self, parent, id, title, pos, size)
self.bmp = wx.StaticBitmap(parent=self, bitmap=temp)
class App(wx.App): #5 wx.App
”””Application class.”””
def OnInit(self):
#6
image = wx.Image(‘wxPython.jpg’, wx.BITMAP_TYPE_JPEG)
self.frame = Frame(image)
self.frame.Show()
self.SetTopWindow(self.frame)
return True
def main(): #7
app = App()
app.MainLoop()
26 / 565

if __name__ == ’__main__’:
main()
#2 wx.Frame
#3
wx.Frame.__init__()
#4 wx.StaticBitmap
size
sizewx.Frame.__init__()
#5 OnInit()wx.AppwxPython
#6 hello.pywxPython.jpg
#7 main()wxPython
27 / 565

2wxPython
wxPython
wxPython
2.1
wxPython
wxPython
web
28 / 565

2.2
wxPython
wx.App
wxPython
wxPython
wx.App
wxPython
2.2.1 wx.App
wx.App
wx.App
wx.App
1
2OnInit()
3
4MainLoop()
wxPython
OnInit()
wxPython
False
OnInit()wxPython
OnInit()Python
__init____init__
__init____init__
29 / 565

wx.App.__init__(self)
OnInit()
Show()SetTopWindow()
wx.App
OnInit()
wx.App
wxPythonwx.PySimpleApp
OnInit()wx.PySimpleApp
class PySimpleApp(wx.App):
def __init__(self, redirect=False, filename=None,
useBestVisual=False, clearSigInt=True):
wx.App.__init__(self, redirect, filename, useBestVisual,
clearSigInt)
def OnInit(self):
return True
wx.PySimpleApp
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = MyNewFrame(None)
frame.Show(True)
app.MainLoop()
wx.PySimpleApp
wx.PySimpleAppOnInit
MyNewFrame
30 / 565

wx.PySimpleAppwxPython
wx.PySimpleApp
2.2.2
wxPython
wxPython
PythonPythonwxPython
wxPythonMainLoop()
wxPython
wx.App
OnInit()——
OnInit()
OnInit()MainLoop()wxPython
MainLoop()
2.3 wxPython
Python
sys.stdoutsys.stderrPython
31 / 565

wxPython
Windows
wxPythonUnixwxPython
2.3.1
wxPython
wxPythonwxPyton
Python
stdout/stderr
#!/usr/bin/env python
import wx
import sys
class Frame(wx.Frame):
def __init__(self, parent, id, title):
print ”Frame __init__”
wx.Frame.__init__(self, parent, id, title)
class App(wx.App):
def __init__(self, redirect=True, filename=None):
print ”App __init__”
wx.App.__init__(self, redirect, filename)
def OnInit(self):
print ”OnInit” #stdout
self.frame = Frame(parent=None, id=-1, title=’Startup’) #
self.frame.Show()
self.SetTopWindow(self.frame)
print >> sys.stderr, ”A pretend error message” #stderr
return True
def OnExit(self):
32 / 565

print ”OnExit”
if __name__ == ’__main__’:
app = App(redirect=True) #1
print ”before MainLoop”
app.MainLoop() #2
print ”after MainLoop”
#1 stderrstdout
wxPythonredirect=True
#2
stdoutstderr
App __init__
after MainLoop
2.2“Start Script”
__main__“Application obect created”,
app = App(redirect=True)wx.App.__init__()
OnInit()wxPython
wx.Frame.__init__()wx.Frame
__main__MainLoop()“MainLoop() called”
wx.App.OnExit()wxPython
“Application object destroyed”
33 / 565

OnExit()
wxPython
2.3.2
wxPython
redirectTrueFalse
redirectTruefilename
filenamewxPython
app = App(redirect=True)app = App(False)
App __init__
OnInit
Frame __init__
A pretend error message
before MainLoop
OnExit
after MainLoop
OnExit()
app = App(True, ”output”)
output
“App__init”“after MainLoop”
wx.App
2.4 wxPython
wxPython
SetTopWindow()wxPython
wxPython
SetTopWindow()
Close()
34 / 565

2.4.1
wxPython
wx.AppOnExit()wxPython
OnExit()wxPython
wx.Exit()wxPython
OnExit()
wxPython
wx.AppSetExitOnFrameDelete(flag)
flagFalsewxPython
wx.App
wxPython
wx.Exit()
2.4.2
wxPython
wx.AppExitMainLoop()
MainLoop()
wx.Exit()
wx.EVT_QUERY_END_SESSION
wxPython
eventwx.CloseEvent
CanVeto()CanVeto()Veto()
wx.EVT_QUERY_END_SESSIONClose()
wx.EVT_CLOSE
35 / 565

Close()False
2.5
wx.Framewx.Dialog
wx.Frame
wx.Dialog
“”
SetTopWindow()wxPythonSetTopWindow()
wx.App
SetTopWindow()
2.5.1 wx.Frame
wxPython
wxPythonwx.Frame
wx.Frame
wx.Frame
wx.Frame.__init__()wx.Frame
wx.Frame(parent, id=-1, title=””, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE,
name=”frame”)
36 / 565

parentNone
idwxPython ID-1
wxPythonID
title
poswx.Point
(0,0)(-1,-1)
sizewx.Size(-1,-1)
style
name
wx.Frame.__init__()
wx.Frame
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”My Friendly Window”,
(100, 100), (100, 100))
2.5.2 wxPythonID
wxPythonIDwxPython
ID
ID
IDwxPython
IDwx.ID_OK
wx.ID_CANCELOKCancelID
IDwxPython
ID
37 / 565

ID
1
2wx.NewId()
3wx.ID_ANY-1
IDID
wx.RegisterId()wxPython
IDwxPython ID
wx.ID_LOWESTwx.ID_HIGHESTID
IDwx.NewId()wxPython
ID
id = wx.NewId()
frame = wx.Frame.__init__(None, id)
wx.ID_ANY-1
wxPythonIDIDGetId()
frame = wx.Frame.__init__(None, -1)
id = frame.GetId()
2.5.3 wx.Sizewx.Point
wx.Framewx.Sizewx.Point
wxPython
wx.Pointxyx,y
0Set(x,y)Get()xy
Get()xy
point = wx.Point(10, 12)
x = point.x
38 / 565

y = point.y
wx.PointPython
a = wx.Point(2, 3)
b = wx.Point(5, 7)
c = a + b
bigger = a > b
wx.Point
wx.RealPointwx.Point
wx.Sizewx.Pointwidthheight
wx.Sizewx.Point
wx.Pointwx.Size
wxPythonwx.Pointwx.Size
frame = wx.Frame(None, -1, pos=(10, 10), size=(100, 100))
2.5.4 wx.Frame
wxPython
wx.FramewxPython
SetStyle()
wx.MINIMIZE_BOX
|
wx.DEFAULT_FRAME_STYLE
wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX | wx.RESIZE_BORDER |
wx.SYSTEM_MENU | wx.CAPTION | wx.CLOSE_BOX
^
39 / 565

wx.DEFAULT_FRAME_STYLE ^ (wx.RESIZE_BORDER | wx.MINIMIZE_BOX
|wx.MAXIMIZE_BOX)
&
2.2wx.Frame
wx.CAPTION
wx.CLOSE_BOX
wx.DEFAULT_FRAME_STYLE
wx.FRAME_SHAPEDSetShape()
wx.FRAME_TOOL_WINDOW
Windows
wx.MAXIMIZE_BOX
wx.MINIMIZE_BOX
wx.RESIZE_BORDER
wx.SIMPLE_BORDER
wx.SYSTEM_MENU
wx.MAXIMIZE_BOX, wx.MINIMIZE_BOXwx.CLOSE_BOX
40 / 565

2.4wx.DEFAULT_STYLE
2.5
wx.DEFAULT_FRAME_STYLE ^ (wx.RESIZE_BORDER | wx.MINIMIZE_BOX |
wx.MAXIMIZE_BOX)
2.6
wx.DEFAULT_FRAME_STYLE | wx.FRAME_TOOL_WINDOW
2.7 wx.help.FRAME_EX_CONTEXTHELP
2.6
wx.Frame
41 / 565

2.6.1
2.8wx.FrameInsertFrameclose
2.3InsertFrame
2.3
#!/usr/bin/env python
import wx
class InsertFrame(wx.Frame):
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, ’Frame With Button’,
size=(300, 100))
panel = wx.Panel(self) #
button = wx.Button(panel, label=”Close”, pos=(125, 10),
size=(50, 50)) #
#
self.Bind(wx.EVT_BUTTON, self.OnCloseMe, button)
#
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
def OnCloseMe(self, event):
self.Close(True)
def OnCloseWindow(self, event):
self.Destroy()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = InsertFrame(parent=None, id=-1)
42 / 565

frame.Show()
app.MainLoop()
InsertFrame__init__wx.Panel
wx.Button
wx.Framewx.Panel
tabwx.Panelwx.Frame
UI
wxPython
2.3
2.3wx.Button
wx.PanelwxPython
2.3wx.Panel
panel
panel
wxPythonsizers
43 / 565

2.6.2
2.9
2.4__init__
2.4
#!/usr/bin/env python
import wx
import images
class ToolbarFrame(wx.Frame):
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, ’Toolbars’,
size=(300, 200))
panel = wx.Panel(self)
panel.SetBackgroundColour(‘White’)
statusBar = self.CreateStatusBar() #1
toolbar = self.CreateToolBar() #2
toolbar.AddSimpleTool(wx.NewId(), images.getNewBitmap(),
”New”, ”Long help for ’New’”) #3
toolbar.Realize() #4
menuBar = wx.MenuBar() #
#
menu1 = wx.Menu()
menuBar.Append(menu1, ”&File”)
menu2 = wx.Menu()
#6
menu2.Append(wx.NewId(), ”&Copy”, ”Copy in status bar”)
menu2.Append(wx.NewId(), ”C&ut”, ””)
44 / 565

menu2.Append(wx.NewId(), ”Paste”, ””)
menu2.AppendSeparator()
menu2.Append(wx.NewId(), ”&Options...”, ”Display Options”)
menuBar.Append(menu2, ”&Edit”) #
self.SetMenuBar(menuBar) #
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = ToolbarFrame(parent=None, id=-1)
frame.Show()
app.MainLoop()
#1wx.StatusBar
#2wx.ToolBar
#3
AddSimpleTool()ID
#4Realize()
#6ID
2.7
wxPython
1
2
3
45 / 565

wxPython
9
wx.MessageDialog
wx.MessageDialogOKyes/no
yes/no
dlg = wx.MessageDialog(None, ’Is this the coolest thing ever!’,
’MessageDialog’, wx.YES_NO | wx.ICON_QUESTION)
result = dlg.ShowModal()
dlg.Destroy()
2.10
wx.MessageDialog
wx.MessageDialog(parent, message,
caption=”Message box”,
style=wx.OK | wx.CANCEL,
pos=wx.DefaultPosition)
parentNone
message
caption
style
pos
46 / 565

ShowModal()
ShowModal()
wx.MessageDialog
wx.ID_YES, wx.ID_NO, wx.ID_CANCEL, wx.ID_OK
wx.TextEntryDialogOK
dlg = wx.TextEntryDialog(None, ”Who is buried in Grant’s tomb”,
’A Question’, ’Cary Grant’)
if dlg.ShowModal() == wx.ID_OK:
response = dlg.GetValue()
2.11
wx.TextEntryDialog
“Please enter text”
wx.OK | wx.CANCELwx.MessageDialog
ShowModal()IDGetValue()
SetValue()
wx.SingleChoiceDialog
dlg = wx.SingleChoiceDialog(None,
’What version of Python are you using’,
’Single Choice’,
[‘1.5.2’, ’2.0’, ’2.1.3’, ’2.2’, ’2.3.1’],
47 / 565

if dlg.ShowModal() == wx.ID_OK:
response = dlg.GetStringSelection()
2.12
wx.SingleChoiceDialog
GetSelection()
GetStringSelection()
2.8
wxPython
“unable to import module wx”
wxPythonPYTHONPATHwxPython
PythonwxPythonPython
PythonUnixwhich python
WindowswxPython
Python/Lib/site-packages
wxPython
48 / 565

wx.AppwxPython
wx.App
wx.AppMainLoop()
MainLoop()
MainLoop()
OnInit()OnInit()
__init__()
MainLoop()
redirect=False
2.9
1wxPython
wxPythonwx.App
2OnInit()
wxPython
3wxPython
wxPythonstdoutstderr
wxPython
49 / 565

4wxPythonwx.Frame
wx.FramestylewxWidget
IDIDwxPython
wx.PanelPanel
5
50 / 565

3
wxPython
GUI
wxPython
wxPython
wxPython
wxPython
3.1
event3.1
(event)
(event object)wxPython
wx.Eventwx.CommandEvent
wx.MouseEvent
(event type)wxPythonID
wx.MouseEvent
(event source)wxPython
(event-driven)
(event queue)
51 / 565

(event handler)
(event binder)
wxPython
wx.EvtHandlerwxPython
3.2
wxPython
PythonPython
wxPython
wxPythonwxPython
3.1
52 / 565

1
wxPythonwx.App.MainLoop()
2
wxPython
wx.Event
3
wxPython
4
wxPythonwx.Event
wx.EvtHandler.ProcessEvent()
3.3
53 / 565

wxPython
wxPython
wxPython
“”
3.2.1
wxPython
self.Bind(wx.EVT_BUTTON, self.OnClick, aButton)
wx.EVT_BUTTONaButton
self.OnClickBind()
wx.EvtHandlerwx.EvtHandler
54 / 565

wxPython
wx.App.MainLoop()MainLoop()
Python
while True:
while not self.Pending():
self.ProcessIdle()
self.DoMessage()
3.2.2
wxPython
PythonwxPython
3.2.3
wxPython
wx.ButtonEVT_BUTTON
wx.CommandEvent
wxPythonwx.SizeEvent
wxPythonwx.Event
wx.Event
wx.Event
55 / 565

wxPythonwx.Event3.2
3.2wx.Event
wx.CloseEvent
wx.CommandEvent
wx.CommandEvent
wx.KeyEvent
wx.MouseEvent
wx.PaintEvent
wx.SizeEvent
wx.TimerEventwx.Timer
3.3
wx.PyEventBinder
wx.PyEventBinder
wx.Event
wxPython
wx.EVT_C+
+ wxWidgetswx.EVT
wx.EventGetEventType()
wx.EVTwx.MouseEvent
wx.EVT_LEFT_DOWN
wx.EVT_LEFT_UP
wx.EVT_LEFT_DCLICK
56 / 565

wx.EVT_MIDDLE_DOWN
wx.EVT_MIDDLE_UP
wx.EVT_MIDDLE_DCLICK
wx.EVT_RIGHT_DOWN
wx.EVT_RIGHT_UP
wx.EVT_RIGHT_DCLICK
wx.EVT_MOTION
wx.ENTER_WINDOWwx.LEAVE_WINDOW
wx.EVT_MOUSEWHEEL
wx.EVT_MOUSE_EVENTS
wx.CommandEvent28
Windows
wx.EVT_BUTTONwx.EVT_MENU
part2
wxPython
wxPython
wxPython
wxPython
wxPython
wx.EvtHandlerwx.EvtHandler
wxPythonwx.EvtHandler
wx.App
wxPython
wx.EvtHandler
3.3.1 wx.EvtHandler
wx.EvtHandler
wx.EvtHandlerBind()
Bind(event, handler, source=None, id=wx.ID_ANY, id2=wx.ID_ANY)
Bind()
event3.3wx.PyEventBinder
57 / 565

handlerPython
handlerNonesource
None
wx.Frame
__init__
OKCancel
sourcewxPython
self.Bind(wx.EVT_BUTTON, self.OnClick, button)
3.1sourcesource
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, ’Frame With Button’,
size=(300, 100))
panel = wx.Panel(self, -1)
button = wx.Button(panel, -1, ”Close”, pos=(130, 15),
size=(40, 40))
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow) #1
self.Bind(wx.EVT_BUTTON, self.OnCloseMe, button) #2
def OnCloseMe(self, event):
self.Close(True)
def OnCloseWindow(self, event):
self.Destroy()
#1 self.OnCloseWindow
source
#2 self.OnCloseMe
wxPython
source
3.2
58 / 565

#!/usr/bin/env python
import wx
class MenuEventFrame(wx.Frame):
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, ’Menus’,
size=(300, 200))
menuBar = wx.MenuBar()
menu1 = wx.Menu()
menuItem = menu1.Append(-1, ”&Exit...”)
menuBar.Append(menu1, ”&File”)
self.SetMenuBar(menuBar)
self.Bind(wx.EVT_MENU, self.OnCloseMe, menuItem)
def OnCloseMe(self, event):
self.Close(True)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = MenuEventFrame(parent=None, id=-1)
frame.Show()
app.MainLoop()
Bind()idid2ID
IDsourceID
ID
idid2IDID
ID
Bind()wx.Python2.5EVT_*
wx.EVT_BUTTON(self, self.button.GetId(), self.OnClick)
2.5wx.EVT*
3.3wx.EvtHandler
59 / 565

AddPendingEvent(event)event
ProcessEvent()
Bind(event, handler, source=None, id=wx.ID_ANY, id2=wx.ID_ANY)
3.3.1
GetEvtHandlerEnabled()
SetEvtHandlerEnabled( boolean)True
False
ProcessEvent(event)event
60 / 565

3.4 wxPython
wxPython
3.2
3.3
wxPython
3.3
#!/usr/bin/env python
import wx
class MouseEventFrame(wx.Frame):
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, ’Frame With Button’,
size=(300, 100))
self.panel = wx.Panel(self)
self.button = wx.Button(self.panel,
label=”Not Over”, pos=(100, 15))
self.Bind(wx.EVT_BUTTON, self.OnButtonClick,
self.button) #1
self.button.Bind(wx.EVT_ENTER_WINDOW,
self.OnEnterWindow) #2
self.button.Bind(wx.EVT_LEAVE_WINDOW,
self.OnLeaveWindow) #3
61 / 565

def OnButtonClick(self, event):
self.panel.SetBackgroundColour(‘Green’)
self.panel.Refresh()
def OnEnterWindow(self, event):
self.button.SetLabel(“Over Me!”)
event.Skip()
def OnLeaveWindow(self, event):
self.button.SetLabel(“Not Over”)
event.Skip()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = MouseEventFrame(parent=None, id=-1)
frame.Show()
app.MainLoop()
MouseEventFrame
#1
#2
#3
wxPython
#1wxPython
#2#3
wxPython
3.4.1
wxPython
62 / 565

3.3
wxPython
wxPython
wxPython
wxPython
wxPython
wxPython
3.3
63 / 565

wxPython
wxPython“
”
wx.EvtHandlerSetEvtHandlerEnabled(boolean)
(UI)
UIwx.WindowDisable()
Enable()UI
UI
wx.EvtHandler
ProcessEvent()
wxPython
ProcessEvent()wx.EvtHandler
3.3ProcessEvent()
64 / 565

ProcessEvent()True
wx.EventSkip()
wx.Window
validatorValidator
3.6
ProcessEvent()
65 / 565

wxPython
3.3wx.EVT_ENTER_WINDOW
OnEnterWindow()
OnEnterWindow()
wx.EVT_LEFT_DOWNwxPython
3.7
wxPython
wx.EventSkip()Skip()
Skip()
Skip()
wxPython3.3OnButtonClick()Skip()
Skip()“”
66 / 565

3.8
wxPython
Skip()wxPython
wx.App
wx.DialogProcessEvent()
True
wx.Dialog
wx.CommandEvent
67 / 565

3.3wx.Button
wx.EVT_BUTTONwx.EVT_BUTTON
wx.CommandEventwxPython
panelpanel
panelframeframe
ProcessEvent() OnButtonClick()
wx.CommandEvent
wxPython
wx.App
ProcessEvent()wx.App
GUI
3.4.2 Skip()
Skip()Skip()
3.4.1
3.4
Skip()
68 / 565

3.4
#!/usr/bin/env python
import wx
class DoubleEventFrame(wx.Frame):
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, ’Frame With Button’,
size=(300, 100))
self.panel = wx.Panel(self, -1)
self.button = wx.Button(self.panel, -1, ”Click Me”, pos=(100, 15))
self.Bind(wx.EVT_BUTTON, self.OnButtonClick,
self.button) #1
self.button.Bind(wx.EVT_LEFT_DOWN, self.OnMouseDown) #2
def OnButtonClick(self, event):
self.panel.SetBackgroundColour(‘Green’)
self.panel.Refresh()
def OnMouseDown(self, event):
self.button.SetLabel(“Again!”)
event.Skip() #3
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = DoubleEventFrame(parent=None, id=-1)
frame.Show()
app.MainLoop()
#1 OnButtonClick()
#2 OnMouseDown()
self.button.Bindself.Bind
69 / 565

wx.EVT_BUTTON#3Skip()
DoubleEventFrameSkip()#2
wx.EVT_BUTTONSkip()
wxPython
Skip()
3.5
wx.App
wxPython
3.4wx.App
Dispatch()MainLoop()
Pending()wxPython
True
Yield(onlyIfNeeded=False)wxWidgets
TrueFalse
onlyIfNeededTrue
FalseYield
wx.SafeYield()Yield
Yield
70 / 565

3.6
wxPython
3.6.1
3.9(panel)
TwoButtonEvent
1wxPythonwx.PyEvent
wx.PyCommandEvent
wxPythonpywxWidgetPython
C++
2
3ProcessEvent()
wxPython
71 / 565

3.5
import wx
class TwoButtonEvent(wx.PyCommandEvent): #1
def __init__(self, evtType, id):
wx.PyCommandEvent.__init__(self, evtType, id)
self.clickCount = 0
def GetClickCount(self):
return self.clickCount
def SetClickCount(self, count):
self.clickCount = count
myEVT_TWO_BUTTON = wx.NewEventType() #2
EVT_TWO_BUTTON = wx.PyEventBinder(myEVT_TWO_BUTTON, 1) #3
class TwoButtonPanel(wx.Panel):
def __init__(self, parent, id=-1, leftText=”Left”,
rightText=”Right”):
wx.Panel.__init__(self, parent, id)
self.leftButton = wx.Button(self, label=leftText)
self.rightButton = wx.Button(self, label=rightText,
pos=(100,0))
self.leftClick = False
self.rightClick = False
self.clickCount = 0
#4
self.leftButton.Bind(wx.EVT_LEFT_DOWN, self.OnLeftClick)
self.rightButton.Bind(wx.EVT_LEFT_DOWN, self.OnRightClick)
def OnLeftClick(self, event):
self.leftClick = True
self.OnClick()
event.Skip() #5
72 / 565

def OnRightClick(self, event):
self.rightClick = True
self.OnClick()
event.Skip() #6
def OnClick(self):
self.clickCount += 1
if self.leftClick and self.rightClick:
self.leftClick = False
self.rightClick = False
evt = TwoButtonEvent(myEVT_TWO_BUTTON, self.GetId()) #7
evt.SetClickCount(self.clickCount) #
self.GetEventHandler().ProcessEvent(evt) #8
class CustomEventFrame(wx.Frame):
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, ’Click Count: 0’,
size=(300, 100))
panel = TwoButtonPanel(self)
self.Bind(EVT_TWO_BUTTON, self.OnTwoClick, panel) #9
def OnTwoClick(self, event): #10
self.SetTitle(“Click Count: %s” % event.GetClickCount())
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = CustomEventFrame(parent=None, id=-1)
frame.Show()
app.MainLoop()
#1 wx.PyCommandEvent
wx.PyEventwx.PyCommandEventwxPython
C++Python
wx.EventwxPython
73 / 565

C++Pythonwx.PyEventPython
Python
#2 wx.NewEventType()wx.NewId()
ID
#3
[0,2]wxId
wx.EvtHandler.Bind()
#4
OnLeftClick()OnRightClick()
#5 #6 Skip()
skip(self.OnClick())
Skip()
Skip()wxPython
#7
ID
#8 ProcessEvent()
ProcessEvent()3.4.1GetEventHandler()wx.EvtHandler
wx.EvtHandler()
#9 #3
#10
74 / 565

wxPython
wxPython
3.7
1wxPython
2wxPythonwx.Event
wxPython
wx.CommandEvent
3wxPythonwx.PyEventBinder
wx.PyEventBinder
wxPythonwx.EvtHandlerwx.EvtHandler
Bind()
wxPythonID
Bind()
4
Skip()
wx.App
5wxPython
wx.PyEvent
wx.PyCommandEvent
ProcessEvent()
wxPython
wxPython
wxPython
75 / 565

4PyCrustwxPython
PyCrustshellwxPython
wxPython
PyCrustPatrick O’BrienwxPython
Python shellPyShellPyCrust
PyCrustPyPywxPythonPy
PyFilling, PyAlaMode, PyAlaCarte,
PyShell wxPython
PyCrust
PyCrust
wxPythonPython shell
PyCrustPy
4.1 wxPython
Python
Python
PythonPythonPython
4.1PythonPython
‘>>>’
Python‘...’
4.1 Python
$ Python
Python 2.3.3 (#1, Jan 25 2004, 11:06:18)
[GCC 3.2.2 (Mandrake Linux 9.1 3.2.2-3mdk)] on linux2
Type ”help”, ”copyright”, ”credits” or ”license” for more information.
>>> 2 + 2
4
>>> 7 * 6
42
>>> 5 ** 3
125
>>> for n in range(5):
76 / 565

... print n * 9
...
0
9
18
27
36
>>>
Python
Python
PythonPython
Python
PythonPython shell
shellDOSUnixbash
Python shell4.1
Pythonshell
Python shell
IDLEPython
IDLE4.1
77 / 565

IDLEPython shell
PythonPythonWinBoa Constructor
IDLEPython shellshell
(recall)
PyCrustPyCrust
Python shell
PyCrustGUI
GUIIDLETkinterwxPython
IDLEPython shellwxPython
wxPythonTkinter
78 / 565

wxPythonPython shellwxPython
Python shellPyCrust
4.2 PyCrust
PyCrustshellPyCrustshell
Python shell
4.2PyCrust
PyCrustwx.SplitterWindow
Python shell
Notebook
PyCrust shell
79 / 565

4.2.1
PyCrust
TabPyCrust
4.3PyCrust
4.3
4.2.2
PyCrust
4.4
80 / 565

4.4
4.2.3
shellPyCrust
Python
4.2.4 Python
PyCrustPythonPython
Python4.5
81 / 565

4.5
Python(help)help
helpquitPython
(>>>)
4.2.5
PyCrust shell
Python
PyCrust
Python
4.1
82 / 565

Ctrl+
Alt+P
Ctrl+
Alt+N
Shift+
Shift+
F8F8
Ctrl+Enter
PyCrustwxPythob
EnterPython
Ctrl+Enter
EnterPyCrustPython
Enter
Python
4.2.6
shell
Python shell
PyCrust4.2
Ctrl+C
Ctrl+Shift+C
Ctrl+X
Ctrl+V
Ctrl+Shift+V
83 / 565

PyCrustPyCrust shell
Pythonemail
PyCrust
PyCrust
shellPyCrust
4.2.7 shell
wxPythonPyCrustPython shell
PythonPyCrust shell
PyCrust
>>> while True:
... print ”Hello”
...
EnterPythonPyCrust
PyCrust
Python shellPython shell(Ctrl+C
Python shell
>>> while True:
... print ”Hello”
...
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Traceback (most recent call last):
File ””, line 2, in
84 / 565

KeyboardInterrupt
>>>
GUIPyCrust
shell
PyCrust
PyCrustshellPyCrust shell
Python shell
4.2.8
PyCrustPyCrustshell
“”“”shell
4.64.7
85 / 565

4.6PyCrust
4.6
86 / 565

4.7
4.7PyCrust
4.3 PyCrust notebook
PyCrustnotebooknotebook
PyCrust“Namespace”
4.3.1 Namespace
4.8Namespacewx.SplitterWindow
87 / 565

4.8
Pythonlocals()4.8
wx
PyCrust
wxwxPythonPyCrust__init__.py
wx
88 / 565

PyCrust shellPyCrustlocale
locale/encoding_alias/’en’
PyCrust shell
>>> import locale
>>> locale.encoding_alias[‘en’]
‘ISO8859-1’
>>>
PyCrust locale.encoding_alias[‘en’]
Python[‘en’]encoding_alias
(list)
PyCrust
4.3.2 Display
DisplayPyCrustpp()
Pythonpprint
pprintDisplay
PyCrust shell Display
PyCrust shellpp()
Display Display
4.3.3 Calltip
CalltipPython shell
CalltipwxPython
wx.Button
Calltipwx.Button
__init__(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=ButtonNameStr) -> Button
Create and show a button. The preferred way to create standard buttons
89 / 565

is to use a standard ID and an empty label. In this case wxWigets will
automatically use a stock label that corresponds to the ID given. In
addition, the button will be decorated with stock icons under GTK+2.
wxPythonC++
C++
PythonPyCrust
4.3.4 Session
Sessionshell
4.3.5 Dispatcher
PyCrustdispatcher
PyCrustdispatcher
shellPython4.9Dispatcher
PyCrust
90 / 565

4.9
Dispatcherwx.Notebook
Dispatcher
dispatcher
class DispatcherListing(wx.TextCtrl):
”””Text control containing all dispatches for session.”””
def __init__(self, parent=None, id=-1):
style = (wx.TE_MULTILINE | wx.TE_READONLY |
wx.TE_RICH2 | wx.TE_DONTWRAP)
wx.TextCtrl.__init__(self, parent, id, style=style)
dispatcher.connect(receiver=self.spy)
def spy(self, signal, sender):
”””Receiver for Any signal from Any sender.”””
text = ’%r from %s’ % (signal, sender)
self.SetInsertionPointEnd()
start, end = self.GetSelection()
if start != end:
self.SetSelection(0, 0)
self.AppendText(text + ’\n’)
91 / 565

PyCrustPython shell
wxPythonPyCrust
4.4 PyCrustwxPython
wxPython
PyCrust
PyWrapPyCrust shell
4.2spare.py
PyCrust
4.2
#!/usr/bin/env python
“””Spare.py is a starting point for simple wxPython programs.”””
import wx
class Frame(wx.Frame):
pass
class App(wx.App):
def OnInit(self):
self.frame = Frame(parent=None, id=-1, title=’Spare’)
self.frame.Show()
self.SetTopWindow(self.frame)
return True
if __name__ == ’__main__’:
app = App()
app.MainLoop()
PyCrustPyWrap
Linux
$ pywrap spare.py
92 / 565

windows
F:\>python pywrap.py spare.py
PyWrapPyWrap
wx.AppPyWrap
shellwx.py.crust.CrustFramePyCrust
wxPython
PyWrap4.3
4.3
“””PyWrap is a command line utility that runs a python
program with additional runtime tools, such as PyCrust.”””
__author__ = ”Patrick K. O’Brien ”
__cvsid__ = ”$Id: PyCrust.txt,v 1.15 2005/03/29 23:39:27 robind Exp $”
__revision__ = ”$Revision: 1.15 $”[11:-2]
import os
import sys
import wx
from wx.py.crust import CrustFrame
def wrap(app):
wx.InitAllImageHandlers()
frame = CrustFrame()
frame.SetSize((750, 525))
frame.Show(True)
frame.shell.interp.locals[‘app’] = app
app.MainLoop()
def main(modulename=None):
sys.path.insert(0, os.curdir)
if not modulename:
if len(sys.argv) < 2:
print ”Please specify a module name.”
93 / 565

aise SystemExit
modulename = sys.argv[1]
if modulename.endswith(‘.py’):
modulename = modulename[:-3]
module = __import__(modulename)
# Find the App class.
App = None
d = module.__dict__
for item in d.keys():
try:
if issubclass(d[item], wx.App):
App = d[item]
except (NameError, TypeError):
pass
if App is None:
print ”No App class was found.”
raise SystemExit
app = App()
wrap(app)
if __name__ == ’__main__’:
main()
PyWrapspare(frame)PyCrust
PyCrust in action
PyCrust shellspare.py
4.10wx
>>> import wx
>>> app.frame.panel = wx.Panel(parent=app.frame)
>>> app.frame.panel.SetBackgroundColour(‘White’)
True
>>>
94 / 565

4.10
>>> app.frame.panel.Refresh()
wxPython
>>> app.frame.statusbar = app.frame.CreateStatusBar(number=3)
95 / 565

app.frame.statusbar.SetStatusText(“Left”, 0)
>>> app.frame.statusbar.SetStatusText(“Center”, 1)
>>> app.frame.statusbar.SetStatusText(“Right”, 2)
>>> app.frame.menubar = wx.MenuBar()
>>> menu = wx.Menu()
>>> app.frame.menubar.Append(menu, ”Primary”)
True
>>> app.frame.SetMenuBar(app.frame.menubar)
>>> menu.Append(wx.NewId(), ”One”, ”First menu item”)
>>> menu.Append(wx.NewId(), ”Two”, ”Second menu item”)
>>>
PyCrust shellwxPython
wxPython
PyCrustPy
4.5 Py
PyCrustPyPython
shell.py,crust.py,introspect.pyinterpreter.pyPyCrust
PyCrustPyPyShell
PyAlaMode
Py
96 / 565

wxPython shell
Py
Py
GUIPyCrust,PyShell,PyAlaModePyAlaCarte
4.5.1 GUI
4.3
PyAlaCarte
PyAlaModenotebook
PyCrust
PyCrustwxPython shellnotebooknotebook
PyFilling
PyShellwxPython shellPyCrustnotebook
PyShellwxPython shellPyCrust
PyWrapPyCrust
PyCrust shell
4.5.2
Py4.4Py
buffer
crustPyCrustGUI
dispatcher
documentdocumentDocument
documentread()write()
BufferDocument
editorPyAlaCartePyAlaModeGUI
editwindoweditwindowEditWindow
wx.stc.StyledTextCtrl (STC)PySTC
Python shell,
97 / 565

fillingGUIGUI
frameframeFrameFramePyframes
imagesimagesPy
interpreterInterpreter
introspect
pseudoInterpreter
stdin,stdout,stderr
shellGUIGUIPyCrust,PyShell
PyAlaModePython shell
versionVERSIONVERSIONPy
bufferBufferbuffer
new(), open(), hasChanged(), save(),saveAs()buffer
DocumentDocumentdocument
EditorEditoreditor
buffer
BufferbufferPython
bufferPython
buffer
bufferupdateNamespace()4.4
updateNamespace()
4.4
def updateNamespace(self):
”””Update the namespace for autocompletion and calltips.
Return True if updated, False if there was an error.”””
if not self.interp or not hasattr(self.editor, ’getText’):
return False
syspath = sys.path
sys.path = self.syspath
text = self.editor.getText()
text = text.replace(‘\r\n’, ’\n’)
98 / 565

text = text.replace(‘\r’, ’\n’)
name = self.modulename or self.name
module = imp.new_module(name)
newspace = module.__dict__.copy()
try:
try:
code = compile(text, name, ’exec’)
except:
raise
try:
exec code in newspace
except:
raise
else:
# No problems, so update the namespace.
self.interp.locals.clear()
self.interp.locals.update(newspace)
return True
finally:
sys.path = syspath
for m in sys.modules.keys():
if m not in self.modules:
del sys.modules[m]
Pythoncompile
execnewspace
buffer
99 / 565

crust6GUIPyCrust
CrustFramewx.Frame4.3
PyWrapCrustFramePyCrust
4.5
4.5
Crustwx.SplitterWindowshellnotebook
DisplayPretty Print
Calltipshell
SessionListing
DispatcherListing
CrustFrameCrust
GUIwxPython
dispatcher
dispatcher
dispatcher
4.5dispatcherPy
PyCrustPyShell
PyCrustnotebook
dispatcher
4.5 dispatcher
def push(self, command):
”””Send command to the interpreter to be executed.
Because this may be called recursively, we append a new list
onto the commandBuffer list and then append commands into
that. If the passed in command is part of a multi-line
100 / 565

command we keep appending the pieces to the last list in
commandBuffer until we have a complete command. If not, we
delete that last list.”””
command = str(command) # In case the command is unicode.
if not self.more:
try: del self.commandBuffer[-1]
except IndexError: pass
if not self.more: self.commandBuffer.append([])
self.commandBuffer[-1].append(command)
source = ’\n’.join(self.commandBuffer[-1])
more = self.more = self.runsource(source)
dispatcher.send(signal=’Interpreter.push’, sender=self,
command=command, more=more, source=source)
return more
crustfillingdispatcher,
4.6PyCrustSession
SessionListing
4.6 PyCrust session
class SessionListing(wx.TextCtrl):
”””Text control containing all commands for session.”””
def __init__(self, parent=None, id=-1):
style = (wx.TE_MULTILINE | wx.TE_READONLY |
wx.TE_RICH2 | wx.TE_DONTWRAP)
wx.TextCtrl.__init__(self, parent, id, style=style)
dispatcher.connect(receiver=self.push,
signal=’Interpreter.push’)
def push(self, command, more):
”””Receiver for Interpreter.push signal.”””
if command and not more:
self.SetInsertionPointEnd()
start, end = self.GetSelection()
if start != end:
self.SetSelection(0, 0)
self.AppendText(command + ’\n’)
101 / 565

SessionListingpush()
sendersourcedispatcher
editorPyAlaCartePyAlaModeGUI
Python
4.6
4.6 editor
EditerFramePyAlaCarteEditerFrame
frameFrame
EditorNotebookFrameEditerFramenotebook
EditerFramePyAlaModeframe
EditorNotebookEditorNotebookFrame
EditorbufferEditWindow
EditWindowStyledTextCtrl
fi
filling
GUI
filling4.7
4.7
FillingTreewx.TreeCtrlFillingTree
FillingTexteditwindow.EditWindowFillingTree
Fillingwx.SplitterWindowFillingTree
FillingText
FillingFrameFillingfilling
FillingFrame
Python
Python
102 / 565

interpreterInterpreterPythoncode
Interactive-InterpreterPythonInterpreter
“.”
Interpreter
PyCrust shellinterpreter
PyCrust
introspectInterpreterFillingTree
wx.py.introspect
>>> import wx
>>> L = [1, 2, 3]
>>> wx.py.introspect.getAttributeNames(L, includeDouble=False)
[‘append’, ’count’, ’extend’, ’index’, ’insert’, ’pop’,
‘remove’, ’reverse’, ’sort’]
>>>
getAttributeNames()FillingTree
PythonLib/sitepackages/wx/py/teststest_introspect.py
shellPyCrust, PyShell, PyAlaModePython shell
GUI4.8ShellFrame,
frame.FrameShellShellPython
4.8 shell
ShellPython shellwx.stc.StyleTextCtrlShelleditwindow.EditWindow
Python shell
ShellFacadeshell
shell
103 / 565

ShellFrameShell
ShellFacadePyCrustshellshell
PyCrustPyShellShell
Python shellshellshellabout()
>>> shell.about()
Author: ”Patrick K. O’Brien ”
Py Version: 0.9.4
Py Shell Revision: 1.7
Py Interpreter Revision: 1.5
Python Version: 2.3.3
wxPython Version: 2.4.1.0p7
Platform: linux2
>>>
ShellStyledTextCtrl600
shellShellFacadeshell
shellshell
25
4.6 wxPythonPy
PyCrust
shell
2
shell
fillingfilling
4.11
104 / 565

4.11
4.7
105 / 565

4.7
#!/usr/bin/env python
import wx
#1
from wx.py.shell import ShellFrame
from wx.py.filling import FillingFrame
import images
class ToolbarFrame(wx.Frame):
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, ’Toolbars’,
size=(300, 200))
panel = wx.Panel(self, -1)
panel.SetBackgroundColour(‘White’)
statusBar = self.CreateStatusBar()
toolbar = self.CreateToolBar()
toolbar.AddSimpleTool(wx.NewId(), images.getNewBitmap(),
”New”, ”Long help for ’New’”)
toolbar.Realize()
menuBar = wx.MenuBar()
menu1 = wx.Menu()
menuBar.Append(menu1, ”&File”)
menu2 = wx.Menu()
menu2.Append(wx.NewId(), ”&Copy”, ”Copy in status bar”)
menu2.Append(wx.NewId(), ”C&ut”, ””)
menu2.Append(wx.NewId(), ”Paste”, ””)
menu2.AppendSeparator()
menu2.Append(wx.NewId(), ”&Options...”, ”Display Options”)
menuBar.Append(menu2, ”&Edit”)
#2 Debug
menu3 = wx.Menu()
shell = menu3.Append(-1, ”&wxPython shell”,
”Open wxPython shell frame”)
filling = menu3.Append(-1, ”&Namespace viewer”,
”Open namespace viewer frame”)
menuBar.Append(menu3, ”&Debug”)
#3
106 / 565

self.Bind(wx.EVT_MENU, self.OnShell, shell)
self.Bind(wx.EVT_MENU, self.OnFilling, filling)
self.SetMenuBar(menuBar)
def OnCloseMe(self, event):
self.Close(True)
def OnCloseWindow(self, event):
self.Destroy()
#4 OnShellOnFilling
def OnShell(self, event):
frame = ShellFrame(parent=self)
frame.Show()
def OnFilling(self, event):
frame = FillingFrame(parent=self)
frame.Show()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
app.frame = ToolbarFrame(parent=None, id=-1)
app.frame.Show()
app.MainLoop()
#1 ShellFrameFillingFrame
#2 Debug
#3 wx.EVT_MENU()
#4 DebugPython shellshell
shellfilling
107 / 565

4.7
1wxPythonGUI
PyCrust shell
2PyCrustPython shell
IDLE, Boa Constructor, PythonWinshell
PyCrustwxPythonwxPython
PyCrust
shell
3PyCrustwxPythonwxPython
PyCrust
4Py
shell
5PyCrustwxPython
wxPython
GUI
108 / 565

5
GUI
UI
UIMVCModełView/Controller
wxPython
wxPythonUI
5.1
UI
5.1
5.1
23
PythonPython
Python
109 / 565

Python
5.1.1
5.1Access
5.1
5.1
5.1 5.1
#!/usr/bin/env python
import wx
class RefactorExample(wx.Frame):
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, ’Refactor Example’,
size=(340, 200))
panel = wx.Panel(self, -1)
panel.SetBackgroundColour(“White”)
prevButton = wx.Button(panel, -1, ”>”, pos=(160, 0))
110 / 565

self.Bind(wx.EVT_BUTTON, self.OnNext, nextButton)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
menuBar = wx.MenuBar()
menu1 = wx.Menu()
openMenuItem = menu1.Append(-1, ”&Open”, ”Copy in status bar”)
self.Bind(wx.EVT_MENU, self.OnOpen, openMenuItem)
quitMenuItem = menu1.Append(-1, ”&Quit”, ”Quit”)
self.Bind(wx.EVT_MENU, self.OnCloseWindow, quitMenuItem)
menuBar.Append(menu1, ”&File”)
menu2 = wx.Menu()
copyItem = menu2.Append(-1, ”&Copy”, ”Copy”)
self.Bind(wx.EVT_MENU, self.OnCopy, copyItem)
cutItem = menu2.Append(-1, ”C&ut”, ”Cut”)
self.Bind(wx.EVT_MENU, self.OnCut, cutItem)
pasteItem = menu2.Append(-1, ”Paste”, ”Paste”)
self.Bind(wx.EVT_MENU, self.OnPaste, pasteItem)
menuBar.Append(menu2, ”&Edit”)
self.SetMenuBar(menuBar)
static = wx.StaticText(panel, wx.NewId(), ”First Name”,
pos=(10, 50))
static.SetBackgroundColour(“White”)
text = wx.TextCtrl(panel, wx.NewId(), ””, size=(100, -1),
pos=(80, 50))
static2 = wx.StaticText(panel, wx.NewId(), ”Last Name”,
pos=(10, 80))
static2.SetBackgroundColour(“White”)
text2 = wx.TextCtrl(panel, wx.NewId(), ””, size=(100, -1),
pos=(80, 80))
firstButton = wx.Button(panel, -1, ”FIRST”)
self.Bind(wx.EVT_BUTTON, self.OnFirst, firstButton)
menu2.AppendSeparator()
optItem = menu2.Append(-1, ”&Options...”, ”Display Options”)
self.Bind(wx.EVT_MENU, self.OnOptions, optItem)
lastButton = wx.Button(panel, -1, ”LAST”, pos=(240, 0))
111 / 565

self.Bind(wx.EVT_BUTTON, self.OnLast, lastButton)
# Just grouping the empty event handlers together
def OnPrev(self, event): pass
def OnNext(self, event): pass
def OnLast(self, event): pass
def OnFirst(self, event): pass
def OnOpen(self, event): pass
def OnCopy(self, event): pass
def OnCut(self, event): pass
def OnPaste(self, event): pass
def OnOptions(self, event): pass
def OnCloseWindow(self, event):
self.Destroy()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = RefactorExample(parent=None, id=-1)
frame.Show()
app.MainLoop()
5.2
5.2
“” “
”“/”
(frame)
112 / 565

5.1.2
5.2
5.25.1
5.2
def createButtonBar(self):
firstButton = wx.Button(panel, -1, ”FIRST”)
self.Bind(wx.EVT_BUTTON, self.OnFirst, firstButton)
prevButton = wx.Button(panel, -1, ”>”, pos=(160, 0))
self.Bind(wx.EVT_BUTTON, self.OnNext, nextButton)
lastButton = wx.Button(panel, -1, ”LAST”, pos=(240, 0))
self.Bind(wx.EVT_BUTTON, self.OnLast, lastButton)
5.3
5.3
def createButtonBar(self, panel):
self.buildOneButton(panel, ”First”, self.OnFirst)
self.buildOneButton(panel, ”>”, self.OnNext, (160, 0))
self.buildOneButton(panel, ”Last”, self.OnLast, (240, 0))
def buildOneButton(self, parent, label, handler, pos=(0,0)):
button = wx.Button(parent, -1, label, pos)
self.Bind(wx.EVT_BUTTON, handler, button)
return button
5.35.2
ID
ID
113 / 565

uildOneButton()
5.1.3
5.4
5.4
def buttonData(self):
return ((“First”, self.OnFirst),
(“>”, self.OnNext),
(“Last”, self.OnLast))
def createButtonBar(self, panel, yPos=0):
xPos = 0
for eachLabel, eachHandler in self.buttonData():
pos = (xPos, yPos)
button = self.buildOneButton(panel, eachLabel, eachHandler, pos)
xPos += button.GetSize().width
def buildOneButton(self, parent, label, handler, pos=(0,0)):
button = wx.Button(parent, -1, label, pos)
self.Bind(wx.EVT_BUTTON, handler, button)
return button
5.4buttonData()
114 / 565

createButtonBar()buttonData()
x
XML
createButtonBar
5.5
5.5
#!/usr/bin/env python
import wx
class RefactorExample(wx.Frame):
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, ’Refactor Example’,
size=(340, 200))
panel = wx.Panel(self, -1)
panel.SetBackgroundColour(“White”)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
self.createMenuBar() #init
self.createButtonBar(panel)
self.createTextFields(panel)
def menuData(self): #
return ((“&File”,
(“&Open”, ”Open in status bar”, self.OnOpen),
(“&Quit”, ”Quit”, self.OnCloseWindow)),
(“&Edit”,
(“&Copy”, ”Copy”, self.OnCopy),
115 / 565

(“C&ut”, ”Cut”, self.OnCut),
(“&Paste”, ”Paste”, self.OnPaste),
(“”, ””, ””),
(“&Options...”, ”DisplayOptions”, self.OnOptions)))
#
def createMenuBar(self):
menuBar = wx.MenuBar()
for eachMenuData in self.menuData():
menuLabel = eachMenuData[0]
menuItems = eachMenuData[1:]
menuBar.Append(self.createMenu(menuItems), menuLabel)
self.SetMenuBar(menuBar)
def createMenu(self, menuData):
menu = wx.Menu()
for eachLabel, eachStatus, eachHandler in menuData:
if not eachLabel:
menu.AppendSeparator()
continue
menuItem = menu.Append(-1, eachLabel, eachStatus)
self.Bind(wx.EVT_MENU, eachHandler, menuItem)
return menu
def buttonData(self): #
return ((“First”, self.OnFirst),
(“>”, self.OnNext),
(“Last”, self.OnLast))
#
def createButtonBar(self, panel, yPos = 0):
xPos = 0
for eachLabel, eachHandler in self.buttonData():
pos = (xPos, yPos)
button = self.buildOneButton(panel, eachLabel,
eachHandler, pos)
xPos += button.GetSize().width
def buildOneButton(self, parent, label, handler, pos=(0,0)):
button = wx.Button(parent, -1, label, pos)
self.Bind(wx.EVT_BUTTON, handler, button)
116 / 565

eturn button
def textFieldData(self): #
return ((“First Name”, (10, 50)),
(“Last Name”, (10, 80)))
#
def createTextFields(self, panel):
for eachLabel, eachPos in self.textFieldData():
self.createCaptionedText(panel, eachLabel, eachPos)
def createCaptionedText(self, panel, label, pos):
static = wx.StaticText(panel, wx.NewId(), label, pos)
static.SetBackgroundColour(“White”)
textPos = (pos[0] + 75, pos[1])
wx.TextCtrl(panel, wx.NewId(), ””, size=(100, -1), pos=textPos)
#
def OnPrev(self, event): pass
def OnNext(self, event): pass
def OnLast(self, event): pass
def OnFirst(self, event): pass
def OnOpen(self, event): pass
def OnCopy(self, event): pass
def OnCut(self, event): pass
def OnPaste(self, event): pass
def OnOptions(self, event): pass
def OnCloseWindow(self, event):
self.Destroy()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = RefactorExample(parent=None, id=-1)
frame.Show()
app.MainLoop()
5.15.5——
——
117 / 565

5.5
MVC
5.2 (Model)(View)
1970Smalltalk-80MVC
GUIMVC
5.2.1 MVC(Model-View-Controller)
MVCModel
View
ControllerControllerModel
view5.3
5.3 MVC
Model,
(model)API
View
wxPythonwx.Window(view)
Controller
wxPythonwx.EvtHandler
UIViewController
Controller
wxPython
wx.Windowwx.EvtHandler
118 / 565

ViewControllerwebView
Controller
5.2MVC
Controller
wxPythonwx.EvtHandler
ProcessEvent()MVC
(model)
(controller)
(view)
wxPython
wxPython
MVC
MVC
Model
ViewControllerModel
ModelwxPython
ViewModelView
ControllerViewModel
Python
119 / 565

ModelViewAPIModel
wxPythonModel
wx.grid.PyGridTableBaseMVCgrid
5.2.2 wxPythonPyGridTableBase
wx.grid.GridwxPython5.3
(grid)
5.6
1984
5.6
import wx
import wx.grid
120 / 565

class SimpleGrid(wx.grid.Grid):
def __init__(self, parent):
wx.grid.Grid.__init__(self, parent, -1)
self.CreateGrid(9, 2)
self.SetColLabelValue(0, ”First”)
self.SetColLabelValue(1, ”Last”)
self.SetRowLabelValue(0, ”CF”)
self.SetCellValue(0, 0, ”Bob”)
self.SetCellValue(0, 1, ”Dernier”)
self.SetRowLabelValue(1, ”2B”)
self.SetCellValue(1, 0, ”Ryne”)
self.SetCellValue(1, 1, ”Sandberg”)
self.SetRowLabelValue(2, ”LF”)
self.SetCellValue(2, 0, ”Gary”)
self.SetCellValue(2, 1, ”Matthews”)
self.SetRowLabelValue(3, ”1B”)
self.SetCellValue(3, 0, ”Leon”)
self.SetCellValue(3, 1, ”Durham”)
self.SetRowLabelValue(4, ”RF”)
self.SetCellValue(4, 0, ”Keith”)
self.SetCellValue(4, 1, ”Moreland”)
self.SetRowLabelValue(5, ”3B”)
self.SetCellValue(5, 0, ”Ron”)
self.SetCellValue(5, 1, ”Cey”)
self.SetRowLabelValue(6, ”C”)
self.SetCellValue(6, 0, ”Jody”)
self.SetCellValue(6, 1, ”Davis”)
self.SetRowLabelValue(7, ”SS”)
self.SetCellValue(7, 0, ”Larry”)
self.SetCellValue(7, 1, ”Bowa”)
self.SetRowLabelValue(8, ”P”)
self.SetCellValue(8, 0, ”Rick”)
self.SetCellValue(8, 1, ”Sutcliffe”)
class TestFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self, parent, -1, ”A Grid”,
size=(275, 275))
grid = SimpleGrid(self)
121 / 565

if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = TestFrame(None)
frame.Show(True)
app.MainLoop()
5.6SimpleGridwxPythonwx.grid.Grid
wx.grid.Grid
SetRowLabelValue()SetColLabelValue()SetCellValue()
5.35.6SetCellValue()
set***
wx.grid.PyGridTableBase
PyC++Python
PyEventPyGridTableBasewxWidgets C
++(Python)
PyGridTableBase
PyGridTableBase
wx.grid.PyGridTableBase
PyGridTableBase
5.4
5.4 wx.grid.PyGridTableBase
GetNumberRows()grid
GetNumberCols()grid
IsEmptyCell(row, col)(row,col)True
GetValue(row, col)(row,col)
122 / 565

SetValue(row, col,value)(row,col)
pass
(table)(grid)SetTable()grid
gridgrid
grid
PyGridTableBase
PyGridTableBasePyGridTableBase
wxPython
PyGridTableBase
PyGridTableBase
Python5.7
5.7 PyGridTableBase
import wx
import wx.grid
class LineupTable(wx.grid.PyGridTableBase):
data = ((“CF”, ”Bob”, ”Dernier”), (“2B”, ”Ryne”, ”Sandberg”),
(“LF”, ”Gary”, ”Matthews”), (“1B”, ”Leon”, ”Durham”),
(“RF”, ”Keith”, ”Moreland”), (“3B”, ”Ron”, ”Cey”),
(“C”, ”Jody”, ”Davis”), (“SS”, ”Larry”, ”Bowa”),
(“P”, ”Rick”, ”Sutcliffe”))
colLabels = (“Last”, ”First”)
123 / 565

def __init__(self):
wx.grid.PyGridTableBase.__init__(self)
def GetNumberRows(self):
return len(self.data)
def GetNumberCols(self):
return len(self.data[0]) - 1
def GetColLabelValue(self, col):
return self.colLabels[col]
def GetRowLabelValue(self, row):
return self.data[row][0]
def IsEmptyCell(self, row, col):
return False
def GetValue(self, row, col):
return self.data[row][col + 1]
def SetValue(self, row, col, value):
pass
class SimpleGrid(wx.grid.Grid):
def __init__(self, parent):
wx.grid.Grid.__init__(self, parent, -1)
self.SetTable(LineupTable()) #
class TestFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self, parent, -1, ”A Grid”,
size=(275, 275))
grid = SimpleGrid(self)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = TestFrame(None)
frame.Show(True)
app.MainLoop()
124 / 565

5.7PyGridTableBase
GetColLabelValue()GetRowLabelValue()
(table)
Python
5.8
5.8
import wx
import wx.grid
class GenericTable(wx.grid.PyGridTableBase):
def __init__(self, data, rowLabels=None, colLabels=None):
wx.grid.PyGridTableBase.__init__(self)
self.data = data
self.rowLabels = rowLabels
self.colLabels = colLabels
def GetNumberRows(self):
return len(self.data)
def GetNumberCols(self):
return len(self.data[0])
def GetColLabelValue(self, col):
if self.colLabels:
return self.colLabels[col]
def GetRowLabelValue(self, row):
if self.rowLabels:
return self.rowLabels[row]
125 / 565

def IsEmptyCell(self, row, col):
return False
def GetValue(self, row, col):
return self.data[row][col]
def SetValue(self, row, col, value):
pass
GenericTable
wxPython
5.9
5.9
import wx
import wx.grid
import generictable
data = ((“Bob”, ”Dernier”), (“Ryne”, ”Sandberg”),
(“Gary”, ”Matthews”), (“Leon”, ”Durham”),
(“Keith”, ”Moreland”), (“Ron”, ”Cey”),
(“Jody”, ”Davis”), (“Larry”, ”Bowa”),
(“Rick”, ”Sutcliffe”))
colLabels = (“Last”, ”First”)
rowLabels = (“CF”, ”2B”, ”LF”, ”1B”, ”RF”, ”3B”, ”C”, ”SS”, ”P”)
class SimpleGrid(wx.grid.Grid):
def __init__(self, parent):
wx.grid.Grid.__init__(self, parent, -1)
tableBase = generictable.GenericTable(data, rowLabels,
colLabels)
self.SetTable(tableBase)
class TestFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self, parent, -1, ”A Grid”,
126 / 565

size=(275, 275))
grid = SimpleGrid(self)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = TestFrame(None)
frame.Show(True)
app.MainLoop()
PyGridTableBase
PyGridTableBasePython
getattr()
wxPython
grid
SetTable()grid
PyGridTableBase
5.10PyGridTableBase
5.10
import wx
import wx.grid
class LineupEntry:
def __init__(self, pos, first, last):
self.pos = pos
self.first = first
self.last = last
class LineupTable(wx.grid.PyGridTableBase):
colLabels = (“First”, ”Last”) #
127 / 565

colAttrs = (“first”, ”last”) #1
def __init__(self, entries): #2
wx.grid.PyGridTableBase.__init__(self)
self.entries = entries
def GetNumberRows(self):
return len(self.entries)
def GetNumberCols(self):
return 2
def GetColLabelValue(self, col):
return self.colLabels[col] #
def GetRowLabelValue(self, col):
return self.entries[row].pos #3
def IsEmptyCell(self, row, col):
return False
def GetValue(self, row, col):
entry = self.entries[row]
return getattr(entry, self.colAttrs[col]) #4
def SetValue(self, row, col, value):
pass
#1
#2LineupEntry
#3pos
#4#1
getattr()
128 / 565

.Python
gridwxPython
wxPython
5.2.3
5.10
5.11
——
PyGridTableBase(grid)
5.11
class AbstractModel(object):
def __init__(self):
self.listeners = []
def addListener(self, listenerFunc):
self.listeners.append(listenerFunc)
def removeListener(self, listenerFunc):
self.listeners.remove(listenerFunc)
def update(self):
for eachFunc in self.listeners:
eachFunc(self)
listenerself
eachFunc(self)——self
129 / 565

listenterAbstractModelPython
objectPythonPython2.2
5.4
MVC
5.12
5.12
#!/usr/bin/env python
import wx
import abstractmodel
class SimpleName(abstractmodel.AbstractModel):
def __init__(self, first=””, last=””):
abstractmodel.AbstractModel.__init__(self)
self.set(first, last)
def set(self, first, last):
self.first = first
130 / 565

self.last = last
self.update() #1
class ModelExample(wx.Frame):
def __init__(self, parent, id):
wx.Frame.__init__(self, parent, id, ’Flintstones’,
size=(340, 200))
panel = wx.Panel(self)
panel.SetBackgroundColour(“White”)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
self.textFields = {}
self.createTextFields(panel)
#-------------------------------
#2
self.model = SimpleName()
self.model.addListener(self.OnUpdate)
#-------------------------------
self.createButtonBar(panel)
def buttonData(self):
return ((“Fredify”, self.OnFred),
(“Wilmafy”, self.OnWilma),
(“Barnify”, self.OnBarney),
(“Bettify”, self.OnBetty))
def createButtonBar(self, panel, yPos = 0):
xPos = 0
for eachLabel, eachHandler in self.buttonData():
pos = (xPos, yPos)
button = self.buildOneButton(panel, eachLabel, eachHandler, pos)
xPos += button.GetSize().width
def buildOneButton(self, parent, label, handler, pos=(0,0)):
button = wx.Button(parent, -1, label, pos)
self.Bind(wx.EVT_BUTTON, handler, button)
return button
def textFieldData(self):
return ((“First Name”, (10, 50)),
131 / 565

(“Last Name”, (10, 80)))
def createTextFields(self, panel):
for eachLabel, eachPos in self.textFieldData():
self.createCaptionedText(panel, eachLabel, eachPos)
def createCaptionedText(self, panel, label, pos):
static = wx.StaticText(panel, wx.NewId(), label, pos)
static.SetBackgroundColour(“White”)
textPos = (pos[0] + 75, pos[1])
self.textFields[label] = wx.TextCtrl(panel, wx.NewId(),
””, size=(100, -1), pos=textPos,
style=wx.TE_READONLY)
def OnUpdate(self, model): #3
self.textFields[“First Name”].SetValue(model.first)
self.textFields[“Last Name”].SetValue(model.last)
#-------------------------------------------
#4
def OnFred(self, event):
self.model.set(“Fred”, ”Flintstone”)
def OnBarney(self, event):
self.model.set(“Barney”, ”Rubble”)
def OnWilma(self, event):
self.model.set(“Wilma”, ”Flintstone”)
def OnBetty(self, event):
self.model.set(“Betty”, ”Rubble”)
#---------------------------------------------
def OnCloseWindow(self, event):
self.Destroy()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = ModelExample(parent=None, id=-1)
frame.Show()
app.MainLoop()
132 / 565

#1
#2OnUpdate()
listenerOnUpdate()
#3OnUpdate()
self.modelmodel
#4
Python
AbstractModel5.10
wxPythonMVC
wx.lib.pubsub
AbstractModelPublisher
wx.lib.evtmgr.eventManager
pubsub
5.3 GUI
MVC“”
MVC
133 / 565

UI
wxPython
5.3.1 unittest
2.1Pythonunittestunittest
PyUnithttp://pyunit.sourceforge.net/PyUnit
Test,TestCase,TestSuite5.5
5.5
TestPyUnittest
TestCase
PyUnitTestCase
TestCase
assertEqual
TestSuitetestTestCase
PyUnitTestSuite
PyUnitsuccess, failure,
errorsuccess
Failureerrorfailurefalse
error
Pythonfailure
error
134 / 565

5.3.2 unittest
5.13unittest5.12
5.13
import unittest
import modelExample
import wx
class TestExample(unittest.TestCase): #1 TestCase
def setUp(self): #2
self.app = wx.PySimpleApp()
self.frame = modelExample.ModelExample(parent=None, id=-1)
def tearDown(self): #3
self.frame.Destroy()
def testModel(self): #4 (Test)
self.frame.OnBarney(None)
self.assertEqual(“Barney”, self.frame.model.first,
msg=”First is wrong”) #5
self.assertEqual(“Rubble”, self.frame.model.last)
def suite(): #6 TestSuite
suite = unittest.makeSuite(TestExample, ’test’)
return suite
if __name__ == ’__main__’:
unittest.main(defaultTest=’suite’) #7
#1unittest.TestCase
135 / 565

#2 setUp()
(frame)
#3 tearDown()
Destroy()wxWidgets
#4 test#6
OnBarney
#5 assertEqual()
assertEqual()
PyUnitmsgmsg(msg
#6 makeSuite()
Python
“”
makeSuite()suite()
#7 PyUnit
suite
GUIunittest.TextTestRunner
unittest.main
PyUnit
.
----------------------------------------------------------------------
Ran 1 test in 0.190s
OK
“.”
“.”“F”“E”
136 / 565

OKOK
Python
#5
self.assertEqual(“Fife”, self.frame.model.first)
F
============================================================
==========
FAIL: testModel (__main__.TestExample)
----------------------------------------------------------------------
Traceback (most recent call last):
File ”C:\wxPyBook\book\1\Blueprint\testExample.py”, line 18, in testModel
self.assertEqual(“Fife”, self.frame.model.last)
File ”c:\python23\lib\unittest.py”, line 302, in failUnlessEqual
raise self.failureException, \
AssertionError: ’Fife’ != ’Rubble’
----------------------------------------------------------------------
Ran 1 test in 0.070s
FAILED (failures=1)
“F”“testModel”18
5.3.3
TextField
5.14
5.14
def testEvent(self):
panel = self.frame.GetChildren()[0]
for each in panel.GetChildren():
137 / 565

if each.GetLabel() == ”Wilmafy”:
wilma = each
break
event = wx.CommandEvent(wx.wxEVT_COMMAND_BUTTON_CLICKED, wil
ma.GetId())
wilma.GetEventHandler().ProcessEvent(event)
self.assertEqual(“Wilma”, self.frame.model.first)
self.assertEqual(“Flintstone”, self.frame.model.last)
“Wilmafy”
panel
wx.CommandEvent
wx.wxEVT_COMMAND_BUTTON_CLICKED
EVT_BUTTON
wx.pywilma.GetId()
IDwxPython
ProcessEvent()
firstlast“Wilma” “Flintstone”
wx.Events
5.4
1GUI
2
3
MVCwxPythonV(View)
138 / 565

wx.WindowC(Controller)wx.EvtHandler
M(Model)
4MVCwxPython
wx.grid.PyGridTableBasewx.grid.Grid
5MVC
(view)wxPython
6Python
unittestGUI
wxPython
wxPython
139 / 565

6
wxPython
GUI
wxPython
23
wxPython/samples
6.1
6.1
sizer
140 / 565

6.1
GUI
wxPython
6.1.1
device context
wxPython
wxPythonwx.DC
wx.DC
6.1wx.DCwxPython
wx.DCwxPython
wx.DC
6.1
wx.BufferedDC
wx.BufferedPaintDCwx.BufferedDCwx.PaintEvent
wx.ClientDC
wx.ClientDC
wx.PaintEvent
wx.MemoryDC
wx.DC.Blit()
141 / 565

wx.MetafileDCWindowswx.MetafileDC
wx.PaintDCwx.ClientDCwx.PaintEvent
wx.PostScriptDCPostScript
wx.PrinterDCWindows
wx.ScreenDC
wx.WindowDC
Windows
6.16.1
6.1 SketchWindow
import wx
class SketchWindow(wx.Window):
def __init__(self, parent, ID):
wx.Window.__init__(self, parent, ID)
self.SetBackgroundColour(“White”)
self.color = ”Black”
self.thickness = 1
self.pen = wx.Pen(self.color, self.thickness, wx.SOLID)#1 wx.Pen
self.lines = []
self.curLine = []
self.pos = (0, 0)
self.InitBuffer()
#2
self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
self.Bind(wx.EVT_MOTION, self.OnMotion)
self.Bind(wx.EVT_SIZE, self.OnSize)
142 / 565

self.Bind(wx.EVT_IDLE, self.OnIdle)
self.Bind(wx.EVT_PAINT, self.OnPaint)
def InitBuffer(self):
size = self.GetClientSize()
#3
self.buffer = wx.EmptyBitmap(size.width, size.height)
dc = wx.BufferedDC(None, self.buffer)
#4
dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
dc.Clear()
self.DrawLines(dc)
self.reInitBuffer = False
def GetLinesData(self):
return self.lines[:]
def SetLinesData(self, lines):
self.lines = lines[:]
self.InitBuffer()
self.Refresh()
def OnLeftDown(self, event):
self.curLine = []
self.pos = event.GetPositionTuple()#5
self.CaptureMouse()#6
def OnLeftUp(self, event):
if self.HasCapture():
self.lines.append((self.color,
self.thickness,
self.curLine))
self.curLine = []
self.ReleaseMouse()#7
def OnMotion(self, event):
if event.Dragging() and event.LeftIsDown():#8
143 / 565

dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)#9
self.drawMotion(dc, event)
event.Skip()
#10
def drawMotion(self, dc, event):
dc.SetPen(self.pen)
newPos = event.GetPositionTuple()
coords = self.pos + newPos
self.curLine.append(coords)
dc.DrawLine(*coords)
self.pos = newPos
def OnSize(self, event):
self.reInitBuffer = True #11 resize
def OnIdle(self, event):#12
if self.reInitBuffer:
self.InitBuffer()
self.Refresh(False)
def OnPaint(self, event):
dc = wx.BufferedPaintDC(self, self.buffer)#13 paint
#14
def DrawLines(self, dc):
for colour, thickness, line in self.lines:
pen = wx.Pen(colour, thickness, wx.SOLID)
dc.SetPen(pen)
for coords in line:
dc.DrawLine(*coords)
def SetColor(self, color):
self.color = color
self.pen = wx.Pen(self.color, self.thickness, wx.SOLID)
def SetThickness(self, num):
self.thickness = num
self.pen = wx.Pen(self.color, self.thickness, wx.SOLID)
144 / 565

class SketchFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self, parent, -1, ”Sketch Frame”,
size=(800,600))
self.sketch = SketchWindow(self, -1)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = SketchFrame(None)
frame.Show(True)
app.MainLoop()
#1wx.Pen
wx.SOLIDwx.DOT, wx.LONGDASH, wx.SHORTDASH
#2
#31
(offscreen)2
#4
(dc.Clear())dc.Clear()wx.EVT_PAINT
wx.Brush
#5GetPositionTuple()
Python
#6CaptureMouse()
ReleaseMouse()
#7
145 / 565

#7ReleaseMouse()CaptureMouse()
wxPython
ReleaseMouse()
CaptureMouse()ReleaseMouse()
#8
Dragging()LeftIsDown()wx.MouseEvent
true
#9wx.BufferedDC
wx.ClientDC
#10
coordsself.posnewPos
GetPositionTuple()OnMotion()
self.curLineDrawLine()*coords
coordsx1,y1,x2,y2DrawLine()x1,y1,x2,y2
(x1,y1)(x2,y2)
#11Trueself.reInitBuffer
#12
True
self.reInitBuffer
#13wx.EVT_PAINT
OnPaint
wx.PaintDC
Paintwx.PaintDCwx.ClientDC
dc
(blit)
#14
self.lines
146 / 565

wx.DC
wxPythonwx.BufferDC
wx.ClientDCwx.BufferPaintDCwx.PaintDC
6.1#9wx.ClientDC
wx.Bitmap6.1wx.EmptyBitmap
wx.MemoryDC
C++Blit()
wxPython
(blit)
6.1OnPaintself.buffersketch
wx.PaintDC()DC
wx.PaintDC wx.ClientDC
6.2wx.DC
6.2 wx.DC
Blit(xdest, ydest, width,height, source, xsrc,ysrc)
xdest, ydest
sourcexsrc,ysrc
Clear()
DrawArc(x1, y1, x2, y2,xc, yc)(x1, y1)(x2, y2)
(xc, yc)
DrawEllipticalArc()
DrawBitmap(bitmap, x,y, transparent)wx.Bitmap(x, y)
transparent
147 / 565

DrawCircle(x, y, radius)
DrawCircle(point, radius)
DrawEllipse
DrawIcon(icon, x, y)wx.Icon(x, y)
DrawLine(x1, y1, x2, y2)(x1, y1)(x2, y2)
DrawLines()wx.PointPython
DrawPolygon(points)wx.PointPython
DrawLines()
xy
DrawRectangle(x, y,width, height)(x, y)
widthheight
DrawText(text, x, y)(x, y)
DrawRotatedText()GetTextExtent()
FloodFill(x, y, color,style)(x, y)
stylestylewx.FLOOD_SURFACE
wx.FLOOD_BORDERcolor
GetBackground()
SetBackground(brush)wx.BrushClear()
GetBrush()
SetBrush(brush)wx.Brush
GetFont()
SetFont(font)(font)wx.Font
GetPen()
SetPen(pen)(pen)wx.Pen
GetPixel(x, y)(x, y)wx.Colour
GetSize()
148 / 565

GetSizeTuple()wx.SizePython
6.2
10
6.2.1
wxPythonCreateStatusBar()
wx.StatusBar
SetStatusBar()
wx.StatusBar
SetStatusText()6.26.1SketchFrame
6.2
import wx
from example1 import SketchWindow
class SketchFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self, parent, -1, ”Sketch Frame”,
size=(800,600))
self.sketch = SketchWindow(self, -1)
self.sketch.Bind(wx.EVT_MOTION, self.OnSketchMotion)
self.statusbar = self.CreateStatusBar()
def OnSketchMotion(self, event):
self.statusbar.SetStatusText(str(event.GetPositionTuple()))
149 / 565

event.Skip()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = SketchFrame(None)
frame.Show(True)
app.MainLoop()
wx.EVT_MOTION
Skip()OnMotion()
SetFieldsCount()
SetStatusText()
0
0
wxPython
SetStatusWidth()Python
statusbar.SetStatusWidth([-1, -2,-3])
1:2:36.2
6.2
6.3
6.2
6.3
import wx
from example1 import SketchWindow
150 / 565

class SketchFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self, parent, -1, ”Sketch Frame”,
size=(800,600))
self.sketch = SketchWindow(self, -1)
self.sketch.Bind(wx.EVT_MOTION, self.OnSketchMotion)
self.statusbar = self.CreateStatusBar()
self.statusbar.SetFieldsCount(3)
self.statusbar.SetStatusWidths([-1, -2, -3])
def OnSketchMotion(self, event):
self.statusbar.SetStatusText(“Pos: %s” %
str(event.GetPositionTuple()), 0)
self.statusbar.SetStatusText(“Current Pts: %s” %
len(self.sketch.curLine), 1)
self.statusbar.SetStatusText(“Line Count: %s” %
len(self.sketch.lines), 2)
event.Skip()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = SketchFrame(None)
frame.Show(True)
app.MainLoop()
StatusBar
PushStatusText()PopStatusText()
6.3wx.StatusBar
6.3 wx.StatusBar
GetFieldsCount()
SetFieldsCount(count)
GetStatusText(field=0)
151 / 565

SetStatusText(text, field=0)0
PopStatusText(field=0)
PushStatusText(text, field=0)
SetStatusWidths(widths)widthsPython
10
6.2.2
6.3
6.3
wx.Menu.AppendMenu()
wx.MenuAppendCheckItem()
AppendRadioItem()wx.MenuItemkind
wx.ITEM_NORMAL, wx.ITEM_CHECKBOX, wx.ITEM_RADIO
152 / 565

wx.MenuCheck(id,bool)id
wxPython IDbool
6.4
5.5
6.4
ahWindow
class SketchFrame(wx.Frame):
def __init__(self, parent):
wx.Frame.__init__(self, parent, -1, ”Sketch Frame”,
size=(800,600))
self.sketch = SketchWindow(self, -1)
self.sketch.Bind(wx.EVT_MOTION, self.OnSketchMotion)
self.initStatusBar() #1
self.createMenuBar()
def initStatusBar(self):
self.statusbar = self.CreateStatusBar()
self.statusbar.SetFieldsCount(3)
self.statusbar.SetStatusWidths([-1, -2, -3])
def OnSketchMotion(self, event):
self.statusbar.SetStatusText(“Pos: %s” %
str(event.GetPositionTuple()), 0)
self.statusbar.SetStatusText(“Current Pts: %s” %
len(self.sketch.curLine), 1)
self.statusbar.SetStatusText(“Line Count: %s” %
len(self.sketch.lines), 2)
event.Skip()
def menuData(self): #2
return [(“&File”, (
(“&New”, ”New Sketch file”, self.OnNew),
(“&Open”, ”Open sketch file”, self.OnOpen),
(“&Save”, ”Save sketch file”, self.OnSave),
(“”, ””, ””),
153 / 565

(“&Color”, (
(“&Black”, ””, self.OnColor,
wx.ITEM_RADIO),
(“&Red”, ””, self.OnColor,
wx.ITEM_RADIO),
(“&Green”, ””, self.OnColor,
wx.ITEM_RADIO),
(“&Blue”, ””, self.OnColor,
wx.ITEM_RADIO))),
(“”, ””, ””),
(“&Quit”, ”Quit”, self.OnCloseWindow)))]
def createMenuBar(self):
menuBar = wx.MenuBar()
for eachMenuData in self.menuData():
menuLabel = eachMenuData[0]
menuItems = eachMenuData[1]
menuBar.Append(self.createMenu(menuItems), menuLabel)
self.SetMenuBar(menuBar)
def createMenu(self, menuData):
menu = wx.Menu()
#3
for eachItem in menuData:
if len(eachItem) == 2:
label = eachItem[0]
subMenu = self.createMenu(eachItem[1])
menu.AppendMenu(wx.NewId(), label, subMenu)
else:
self.createMenuItem(menu, *eachItem)
return menu
def createMenuItem(self, menu, label, status, handler,
kind=wx.ITEM_NORMAL):
if not label:
menu.AppendSeparator()
return
menuItem = menu.Append(-1, label, status, kind)#4 kind
self.Bind(wx.EVT_MENU, handler, menuItem)
154 / 565

def OnNew(self, event): pass
def OnOpen(self, event): pass
def OnSave(self, event): pass
def OnColor(self, event):#5
menubar = self.GetMenuBar()
itemId = event.GetId()
item = menubar.FindItemById(itemId)
color = item.GetLabel()
self.sketch.SetColor(color)
def OnCloseWindow(self, event):
self.Destroy()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = SketchFrame(None)
frame.Show(True)
app.MainLoop()
#1__init__
#2(, ())
(, , , kind)
2
34XML
#32
createMenu
#4wx.MenuItemkind
wx.Menu
#5OnColor
idFindItemById()
155 / 565

id
wxPython
6.3
6.3.1
GUI
wxPython
wx.FileDialog6.5sketch
wx.FileDialog
wx.FileDialog(parent, message=”Choose a file”, defaultDir=””,
defaultFile=””, wildcard=”*.*”, style=0)
6.6
156 / 565

6.6 wx.FileDialog
parentNone
messagemessage
defaultDir
defaultFile
wildcard|
“Sketch files (*.sketch)|*.sketch|All files
(*.*)|*.*”
style6.7
6.7 wx.FileDialog
wx.CHANGE_DIR
wx.MULTIPLE
wx.OPEN
wx.OVERWRITE_PROMPT
wx.SAVE
ShowModal()
wx.ID_OKwx.ID_CANCEL
GetFilename(), GetDirectory(), GetPath()
Destroy()
6.6SketchFrame
““““cPickle
oscPickle
6.6 SketchFrame
def __init__(self, parent):
self.title = ”Sketch Frame”
157 / 565

wx.Frame.__init__(self, parent, -1, self.title,
size=(800,600))
self.filename = ””
self.sketch = SketchWindow(self, -1)
self.sketch.Bind(wx.EVT_MOTION, self.OnSketchMotion)
self.initStatusBar()
self.createMenuBar()
self.createToolBar()
def SaveFile(self):#1
if self.filename:
data = self.sketch.GetLinesData()
f = open(self.filename, ’w’)
cPickle.dump(data, f)
f.close()
def ReadFile(self):#2
if self.filename:
try:
f = open(self.filename, ’r’)
data = cPickle.load(f)
f.close()
self.sketch.SetLinesData(data)
except cPickle.UnpicklingError:
wx.MessageBox(“%s is not a sketch file.”
% self.filename, ”oops!”,
style=wx.OK|wx.ICON_EXCLAMATION)
wildcard = ”Sketch files (*.sketch)|*.sketch|All files (*.*)|*.*”
def OnOpen(self, event):#3
dlg = wx.FileDialog(self, ”Open sketch file...”,
os.getcwd(), style=wx.OPEN,
wildcard=self.wildcard)
if dlg.ShowModal() == wx.ID_OK:
self.filename = dlg.GetPath()
self.ReadFile()
self.SetTitle(self.title + ’ -- ’ + self.filename)
dlg.Destroy()
158 / 565

def OnSave(self, event):#4
if not self.filename:
self.OnSaveAs(event)
else:
self.SaveFile()
def OnSaveAs(self, event):#5
dlg = wx.FileDialog(self, ”Save sketch as...”,
os.getcwd(),
style=wx.SAVE | wx.OVERWRITE_PROMPT,
wildcard=self.wildcard)
if dlg.ShowModal() == wx.ID_OK:
filename = dlg.GetPath()
if not os.path.splitext(filename)[1]:#6
filename = filename + ’.sketch’
self.filename = filename
self.SaveFile()
self.SetTitle(self.title + ’ -- ’ +
self.filename)
dlg.Destroy()
#1cPickle
#2cPickle
#3OnOpen()wx.OPEN
.sketchOK
ReadFile()
#4
#5OnSave()wx.SAVE
#6.sketch
159 / 565

6.3.2
sketch
wxPythonwx.ColourDialog
parent()
wx.ColourData
sketch
6.7
6.7 SketchFrame
def menuData(self):
return [(“&File”, (
(“&New”, ”New Sketch file”, self.OnNew),
(“&Open”, ”Open sketch file”, self.OnOpen),
(“&Save”, ”Save sketch file”, self.OnSave),
(“”, ””, ””),
(“&Color”, (
(“&Black”, ””, self.OnColor,
wx.ITEM_RADIO),
(“&Red”, ””, self.OnColor,
wx.ITEM_RADIO),
(“&Green”, ””, self.OnColor,
wx.ITEM_RADIO),
(“&Blue”, ””, self.OnColor,
wx.ITEM_RADIO),
(“&Other...”, ””, self.OnOtherColor,
wx.ITEM_RADIO))),
(“”, ””, ””),
(“&Quit”, ”Quit”, self.OnCloseWindow)))]
def OnOtherColor(self, event):
dlg = wx.ColourDialog(self)
dlg.GetColourData().SetChooseFull(True)#
if dlg.ShowModal() == wx.ID_OK:
self.sketch.SetColor(dlg.GetColourData().GetColour())#
160 / 565

dlg.Destroy()
SetChooseFull()
wx.Colorsketch
6.4
about
6.4.1
wxPython
wxPython
sizerJava AWT
sizersizer
wx.Panelsizersizer
sizer
1panelcontainer()
2sizer
3
4sizerAdd()sizer
sizersizer
5sizersizersizer
161 / 565

6SetSizer(sizer)
6.8wxPythonsizersizer
11
6.8 wxPythonsizer
wx.BoxSizerwx.BoxSizer
sizer
sizerbox
wx.FlexGridSizerwx.GridSizer
wx.GridSizer
grid sizer
wx.GridBagSizerwx.FlexGridSizer
wx.StaticBoxSizerwx.BoxSizerbox
sizersketch
control panelcontrol panel
wx.GridSizerwx.BoxSizer6.6
panelsketchgridbox
162 / 565

6.8control panelsketch
sizer
6.8
def __init__(self, parent):
self.title = ”Sketch Frame”
wx.Frame.__init__(self, parent, -1, self.title,
size=(800,600))
self.filename = ””
self.sketch = SketchWindow(self, -1)
self.sketch.Bind(wx.EVT_MOTION, self.OnSketchMotion)
self.initStatusBar()
self.createMenuBar()
self.createToolBar()
self.createPanel()
def createPanel(self):
controlPanel = ControlPanel(self, -1, self.sketch)
163 / 565

ox = wx.BoxSizer(wx.HORIZONTAL)
box.Add(controlPanel, 0, wx.EXPAND)
box.Add(self.sketch, 1, wx.EXPAND)
self.SetSizer(box)
6.8createPanel()ControlPanel
box sizerwx.BoxSizer
wx.HORIZONTALwx.VERTICALcontrolPanel
SketchWindowAdd()sizer
sizerwx.BoxSizersizer
sizer
sizerstretch
box sizer
stretch0sizer
0sizersizer
wx.StatusBarsizer
0controlPanel1
sketch window
Add()
wx.EXPANDsizer
sizer6.7
box sizer
sketch windowcontrol panel
6.8ControlPanelgridbox sizer6.9
164 / 565

6.9 ControlPanel
class ControlPanel(wx.Panel):
BMP_SIZE = 16
BMP_BORDER = 3
NUM_COLS = 4
SPACING = 4
colorList = (‘Black’, ’Yellow’, ’Red’, ’Green’, ’Blue’, ’Purple’,
’Brown’, ’Aquamarine’, ’Forest Green’, ’Light Blue’,
’Goldenrod’, ’Cyan’, ’Orange’, ’Navy’, ’Dark Grey’,
’Light Grey’)
maxThickness = 16
def __init__(self, parent, ID, sketch):
wx.Panel.__init__(self, parent, ID, style=wx.RAISED_BORDER)
self.sketch = sketch
buttonSize = (self.BMP_SIZE + 2 * self.BMP_BORDER,
self.BMP_SIZE + 2 * self.BMP_BORDER)
colorGrid = self.createColorGrid(parent, buttonSize)
thicknessGrid = self.createThicknessGrid(buttonSize)
self.layout(colorGrid, thicknessGrid)
165 / 565

def createColorGrid(self, parent, buttonSize):#1
self.colorMap = {}
self.colorButtons = {}
colorGrid = wx.GridSizer(cols=self.NUM_COLS, hgap=2, vgap=2)
for eachColor in self.colorList:
bmp = parent.MakeBitmap(eachColor)
b = buttons.GenBitmapToggleButton(self, -1, bmp, size=buttonSize)
b.SetBezelWidth(1)
b.SetUseFocusIndicator(False)
self.Bind(wx.EVT_BUTTON, self.OnSetColour, b)
colorGrid.Add(b, 0)
self.colorMap[b.GetId()] = eachColor
self.colorButtons[eachColor] = b
self.colorButtons[self.colorList[0]].SetToggle(True)
return colorGrid
def createThicknessGrid(self, buttonSize):#2
self.thicknessIdMap = {}
self.thicknessButtons = {}
thicknessGrid = wx.GridSizer(cols=self.NUM_COLS, hgap=2, vgap=2)
for x in range(1, self.maxThickness + 1):
b = buttons.GenToggleButton(self, -1, str(x), size=buttonSize)
b.SetBezelWidth(1)
b.SetUseFocusIndicator(False)
self.Bind(wx.EVT_BUTTON, self.OnSetThickness, b)
thicknessGrid.Add(b, 0)
self.thicknessIdMap[b.GetId()] = x
self.thicknessButtons[x] = b
self.thicknessButtons[1].SetToggle(True)
return thicknessGrid
def layout(self, colorGrid, thicknessGrid):#3
box = wx.BoxSizer(wx.VERTICAL)
box.Add(colorGrid, 0, wx.ALL, self.SPACING)
box.Add(thicknessGrid, 0, wx.ALL, self.SPACING)
self.SetSizer(box)
box.Fit(self)
def OnSetColour(self, event):
color = self.colorMap[event.GetId()]
166 / 565

if color != self.sketch.color:
self.colorButtons[self.sketch.color].SetToggle(False)
self.sketch.SetColor(color)
def OnSetThickness(self, event):
thickness = self.thicknessIdMap[event.GetId()]
if thickness != self.sketch.thickness:
self.thicknessButtons[self.sketch.thickness].SetToggle(False)
self.sketch.SetThickness(thickness)
#1createColorGrid()grid sizer
sizer4
for
wxPython
grid
IDsizer
#2createThicknessGrid()createColorGrid()
grid sizer
sizer
#3box sizer(grid)grid
0grid sizercontrol panel
control panel
Add()self.SPACING
wx.ALL
wx.ALL
box sizerFit()control panelcontrol panel
sizersizer
sizer
wx.Sizersizer6.9
6.9 wx.Sizer
Add(window, proportion=0,flag=0, border=0,userData=None)
167 / 565

Add(sizer, proportion=0,flag=0, border=0,userData=None)
Add(size, proportion=0,flag=0, border=0,userData=None)
wxWindowsizer
proportionwx.BoxSizer
flag
bordersizer
userData
Fit(window)
FitInside(window )windowsizer
sizerFitInside()
scroll panel
GetSize()wx.Sizesizer
GetPosition()wx.Pointsizer
GetMinSize()wx.Sizesizer
Layout()sizer
Prepend(...)Add()sizer
Remove(window)
Remove(sizer)
Remove(nth)sizer
SetDimension(x, y, width,height)sizer
sizersizer11
6.4.2 (about)
about
wx.html.HtmlWindow
wx.html.HtmlWindow
16wx.html.HtmlWindow6.10
HTML rendererabout
168 / 565

6.10 wx.html.HtmlWindowabout
class SketchAbout(wx.Dialog):
text = ’’’
Sketch!
Sketch is a demonstration program for wxPython In Action
Chapter 7. It is based on the SuperDoodle demo included with wxPython,
available at http://www.wxpython.org/
SuperDoodle and wxPython are brought to you by
Robin Dunn and Total Control Software, Copyright
1997-2006.
‘’’
def __init__(self, parent):
wx.Dialog.__init__(self, parent, -1, ’About Sketch’,
size=(440, 400) )
html = wx.html.HtmlWindow(self)
html.SetPage(self.text)
button = wx.Button(self, wx.ID_OK, ”Okay”)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(html, 1, wx.EXPAND|wx.ALL, 5)
sizer.Add(button, 0, wx.ALIGN_CENTER|wx.ALL, 5)
self.SetSizer(sizer)
self.Layout()
169 / 565

HTML
wx.html.HtmlWindowwx.ID_OK ID
box sizer
6.8
6.8
(About)
def OnAbout(self, event):
dlg = SketchAbout(self)
dlg.ShowModal()
dlg.Destroy()
6.4.3
wxPython
170 / 565

wx.SplashScreen
wx.SplashScreen
wx.SplashScreen(bitmap, splashStyle, milliseconds, parent, id,
pos=wx.DefaultPosition, size=wx.DefaultSize,
style=wx.SIMPLE_BORDER|wx.FRAME_NO_TASKBAR|wx.STAY_ON_TOP)
6.10wx.SplashScreen
6.10 wx.SplashScreen
bitmapwx.Bitmap
splashStyle
wx.SPLASH_CENTRE_ON_PARENT,wx.SPLASH_CENTRE_ON_SCREEN,
wx.SPLASH_NO_CENTRE, wx.SPLASH_TIMEOUT, wx.SPLASH_NO_TIMEOUT
millisecondssplashStylewx.SPLASH_TIMEOUTmilliseconds
parentNone
idID-1
possplashStylewx.SPLASH_NO_CENTERpos
size
stylewxPython
6.11wx.App
wx.PySimpleApp
6.11
class SketchApp(wx.App):
def OnInit(self):
171 / 565

mp = wx.Image(“splash.png”).ConvertToBitmap()
wx.SplashScreen(bmp, wx.SPLASH_CENTRE_ON_SCREEN | wx.SPLASH_
TIMEOUT,
1000, None, -1)
wx.Yield()
frame = SketchFrame(None)
frame.Show(True)
self.SetTopWindow(frame)
return True
OnInit
Yield()
Yield()
6.5
1
sketch
about
2wxPython
API
3
4
5wx.FileDialog
wx.ColourDialog
6sizer
sizersizerwx.GridSizer
172 / 565

wx.BoxSizersizersizer
7aboutwx.html.HtmlWindow
wx.SplashScreen
part 1wxPython
part 2
wxPython
173 / 565

Part 2 wxPython
wxPython
wxPython
API
7“”
8“”
9“
”
wxPython
“wxPython”
toggle menus
11“sizer”sizersizer
wxPython6
sizer
12“”
174 / 565

7
wxPython
wxPython API
7.1
7.1.1
UI
wxPythonwx.StaticText7.1
wx.StaticText
wx.html.HTMLWindow
7.1
wx.StaticText
175 / 565

7.17.1
7.1
import wx
class StaticTextFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Static Text Example’,
size=(400, 300))
panel = wx.Panel(self, -1)
#
wx.StaticText(panel, -1, ”This is an example of static text”,
(100, 10))
#
rev = wx.StaticText(panel, -1, ”Static Text With Reversed Colors”,
(100, 30))
rev.SetForegroundColour(‘white’)
rev.SetBackgroundColour(‘black’)
#
center = wx.StaticText(panel, -1, ”align center”, (100, 50),
(160, -1), wx.ALIGN_CENTER)
center.SetForegroundColour(‘white’)
center.SetBackgroundColour(‘black’)
#
right = wx.StaticText(panel, -1, ”align right”, (100, 70),
(160, -1), wx.ALIGN_RIGHT)
right.SetForegroundColour(‘white’)
right.SetBackgroundColour(‘black’)
#
str = ”You can also change the font.”
text = wx.StaticText(panel, -1, str, (20, 100))
font = wx.Font(18, wx.DECORATIVE, wx.ITALIC, wx.NORMAL)
176 / 565

text.SetFont(font)
#
wx.StaticText(panel, -1, ”Your text\ncan be split\n”
”over multiple lines\n\neven blank ones”, (20,150))
#
wx.StaticText(panel, -1, ”Multi-line text\ncan also\n”
”be right aligned\n\neven with a blank”, (220,150),
style=wx.ALIGN_RIGHT)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = StaticTextFrame()
frame.Show()
app.MainLoop()
wx.StaticTextwxWidget
wx.StaticText(parent, id, label, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=0, name=”staticText”)
7.1——wxPython
2
7.1 wx.StaticText
parent
id-1
label
poswx.PointPython
sizewx.SizePython
style
name
177 / 565

7.1wx.Window
wx.StaticText7.2
wx.StaticText
7.2
wx.ALIGN_CENTER
wx.ALIGN_LEFT
wx.ALIGN_RIGHT
wx.ST_NO_AUTORESIZESetLabel()
wx.StaticTextSetLabel()
wx.ST_NO_AUTORESIZE
wxPythonwxPython
wx.ST_NO_AUTORESIZE
wx.lib.stattext.GenStaticText
wx.StaticTextPythonC++
DrawText(text, x,y)DrawRotatedText(text, x, y, angle)
178 / 565

GenStaticText6
12
7.1.2
wxPythonwx.TextCtrl
wx.TextCtrl
7.2wx.TextCtrl
7.27.2
7.2 wx.TextCtrl
import wx
class TextFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Text Entry Example’,
size=(300, 100))
panel = wx.Panel(self, -1)
basicLabel = wx.StaticText(panel, -1, ”Basic Control:”)
basicText = wx.TextCtrl(panel, -1, ”I’ve entered some text!”,
size=(175, -1))
basicText.SetInsertionPoint(0)
179 / 565

pwdLabel = wx.StaticText(panel, -1, ”Password:”)
pwdText = wx.TextCtrl(panel, -1, ”password”, size=(175, -1),
style=wx.TE_PASSWORD)
sizer = wx.FlexGridSizer(cols=2, hgap=6, vgap=6)
sizer.AddMany([basicLabel, basicText, pwdLabel, pwdText])
panel.SetSizer(sizer)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = TextFrame()
frame.Show()
app.MainLoop()
wx.TextCtrlwx.Window
wx.TextCtrl(parent, id, value = ””, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=0, validator=wx.DefaultValidator
name=wx.TextCtrlNameStr)
parent, id, pos, size, style, namewx.Windowvalue
validatorwx.Validatorvalidator
9validator
7.3
7.3 wx.TextCtrl
wx.TE_CENTER
wx.TE_LEFT
wx.TE_NOHIDESELWindows
wx.TE_PASSWORD
180 / 565

wx.TE_PROCESS_ENTER
wx.TE_PROCESS_TABTab
tab
wx.TE_READONLY
wx.TE_RIGHT
|
7.1.3
wx.TextCtrl
7.4wx.TextCtrl
7.4
AppendText(text)
Clear()“”
EmulateKeyPress(event)
GetInsertionPoint()
SetInsertionPoint(pos)
SetInsertionPointEnd()
0
181 / 565

GetRange(from, to)
GetSelection()
GetStringSelection()
SetSelection(from, to)GetSelection()
GetStringSelection()
SetSelection(from, to)
GetValue()
SetValue(value)SetValue()GetValue()
Remove(from, to)
Replace(from, to, value)
WriteText(text)AppendText()
7.1.4
wx.TE_MULTILINE
7.3
182 / 565

7.37.3
wx.TE_MULTILINE
7.3
import wx
class TextFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Text Entry Example’,
size=(300, 250))
panel = wx.Panel(self, -1)
multiLabel = wx.StaticText(panel, -1, ”Multi-line”)
multiText = wx.TextCtrl(panel, -1,
”Here is a looooooooooooooong line of text set in the control.\n\n”
”See that it wrapped, and that this line is after a blank”,
size=(200, 100), style=wx.TE_MULTILINE) #
multiText.SetInsertionPoint(0) #
richLabel = wx.StaticText(panel, -1, ”Rich Text”)
richText = wx.TextCtrl(panel, -1,
”If supported by the native control, this is reversed, and this is a different
font.”,
size=(200, 100), style=wx.TE_MULTILINE|wx.TE_RICH2) #
richText.SetInsertionPoint(0)
richText.SetStyle(44, 52, wx.TextAttr(“white”, ”black”)) #
points = richText.GetFont().GetPointSize()
f = wx.Font(points + 3, wx.ROMAN, wx.ITALIC, wx.BOLD, True) #
richText.SetStyle(68, 82, wx.TextAttr(“blue”, wx.NullColour, f)) #
sizer = wx.FlexGridSizer(cols=2, hgap=6, vgap=6)
sizer.AddMany([multiLabel, multiText, richLabel, richText])
panel.SetSizer(sizer)
183 / 565

if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = TextFrame()
frame.Show()
app.MainLoop()
wx.TE_MULTILINE
7.5
7.5
wx.HSCROLL
GTK+
wx.TE_AUTO_URL
URLURL
wx.TE_DONTWRAPwx.HSCROLL
wx.TE_LINEWRAP
wx.TE_MULTILINE
wx.TE_RICHWindows
wx.TE_RICH2Windows
wx.TE_WORDWRAP
wx.TE_MULTILINE | wx.TE_RICH2
wx.TextCtrlwx.TextAttrwx.TextAttr
wx.TextAttr(colText, colBack=wx.NullColor, font=wx.NullFont)
184 / 565

wxPythonRGB
(, , )wx.NullColorfont
wx.Fontwx.NullFont
wx.TextAttrget*()
GetBackgroundColour(), GetFont(), GetTextColour()
HasBackgroundColour(), HasFont(), HasTextColour()
Has*()False
IsDefault()trueset*()wx.TextAttr
SetDefaultStyle(style)SetStyle(start, end,style)
AppendText() WriteText()
SetStyle()SetDefaultStyle(style)
start end
7.3
richText.SetStyle(44, 52, wx.TextAttr(“white”, ”black”))
7.6wx.TextCtrl
7.6
GetDefaultStyle()
SetDefaultStyle(style)
GetLineLength(lineNo)
GetLineText(lineNo)
GetNumberOfLines()1
IsMultiLine()
185 / 565

IsSingleLine()
PositionToXY(pos)()
0
SetStyle(start, end,style)
ShowPosition(pos)
XYToPosition(x, y)PositionToXY(pos)——
7.1.5
wx.Font
wx.Font(pointSize, family, style, weight, underline=False,
faceName=””, encoding=wx.FONTENCODING_DEFAULT)
pointSizefamily
7.7
7.7
wx.DECORATIVE
wx.DEFAULT
wx.MODERN
wx.ROMANserifTimes New Roman
wx.SCRIPT
wx.SWISSsans-serifHelveticaArial
style
wx.NORMAL, wx.SLANT, wx.ITALICweight
186 / 565

wx.NORMAL, wx.LIGHT,wx.BOLD
underlineWindows
TrueFalse
faceName
encoding
UnicodewxPython8
wx.FontEnumerator
e = wx.FontEnumerator()
e.EnumerateFacenames()
fontList = e.GetFacenames()
e = wx.FontEnumerator(fixedWidth=True)
7.1.6
wxPython
wx.stc.StyledTextCtrlPythonScintillaScintilla
wxWidgetswxPython
APIwx.stc.StyledCtrl
http://wiki.wxpython.org/index.cgi/
wxStyledTextCtrl
7.1.7
wx.TextCtrl
wx.TextCtrl\n
GetValue()
Windows\r\n
187 / 565

GetValue()GetLastPosition()
7.3
print ”getValue”, len(multiText.GetValue())
print ”lastPos”, multiText.GetLastPosition()
Unix
getValue 119
lastPos 119
Windows
getValue 121
lastPos 119
wx.TextCtrl
GetRange()GetSelectedText()
10
aLongString = ”””Any old
multi line string
will do here.
Just as long as
it is multiline”””
text = wx.TextCtrl(panel, -1, aLongString, style=wx.TE_MULTILINE)
x = text.GetInsertionPoint()
selection = aLongString[x : x + 10] ###
WindowsMac
selection = text.GetRange(x, x + 10)
7.1.8
wx.TextCtrl
Bind
188 / 565

frame.Bind(wx.EVT_TEXT, frame.OnText, text)
7.8
7.8 wx.TextCtrl
EVT_TEXT
SetValue()
EVT_TEXT_ENTERwx.TE_PROCESS_ENTER
EVT_TEXT_URLWindowswx.TE_RICHwx.TE_RICH2
wx.TE_AUTO_URLURL
EVT_TEXT_MAXLENSetMaxLength()
7.2
wxPython
toggle buttonsgeneric
7.2.1
part 1
7.4
7.4
189 / 565

7.4
7.4
import wx
class ButtonFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Button Example’,
size=(300, 100))
panel = wx.Panel(self, -1)
self.button = wx.Button(panel, -1, ”Hello”, pos=(50, 20))
self.Bind(wx.EVT_BUTTON, self.OnClick, self.button)
self.button.SetDefault()
def OnClick(self, event):
self.button.SetLabel(“Clicked”)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = ButtonFrame()
frame.Show()
app.MainLoop()
wx.Button
wx.Button(parent, id, label, pos, size=wxDefaultSize, style=0,
validator, name=”button”)
labelSetLabel()
GetLabel()GetDefaultSize()
SetDefault()GetDefaultSize()
SetDefault()
wx.Buttonwx.BU_EXACTFIT
wx.BU_LEFT, wx.BU_RIGHT, wx.BU_TOP, wx.BU_BOTTOM
190 / 565

wx.Button
EVT_BUTTON
7.2.2
7.5
wxPythonwx.BitmapButton
wx.BitmapButton7.57.5
7.5
import wx
class BitmapButtonFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Bitmap Button Example’,
size=(200, 150))
panel = wx.Panel(self, -1)
bmp = wx.Image(“bitmap.bmp”, wx.BITMAP_TYPE_BMP).ConvertToBitmap
()
self.button = wx.BitmapButton(panel, -1, bmp, pos=(10, 20))
self.Bind(wx.EVT_BUTTON, self.OnClick, self.button)
self.button.SetDefault()
self.button2 = wx.BitmapButton(panel, -1, bmp, pos=(100, 20),
style=0)
self.Bind(wx.EVT_BUTTON, self.OnClick, self.button2)
191 / 565

def OnClick(self, event):
self.Destroy()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = BitmapButtonFrame()
frame.Show()
app.MainLoop()
EVT_BUTTON
wx.BU_AUTODRAW
3D7.5
style=07.53D
wxPython
wxPython
SetBitmapDisabled(), SetBitmapFocus(),SetBitmapLabel(), SetBitmap-
Selected()wxPython
wx.Bitmapget*()
wxWidgets C++
wxPython
7.2.3 toggle button
wx.ToggleButtontoggle button
toggle button
toggle button
192 / 565

wx.ToggleButtonwx.Button
1wx.ToggleButtonEVT_TOGGLEBUTTON
2wx.ToggleButtonGetValue()SetValue()
toggle button
wxWidgets
toggle buttonwxPython
7.2.4
Python
wx.lib.buttons. GenButton
1
2
3D
3wxWidget
GenBitmapTextButtonGenBitmapToggleButton
4
Python
7.6
193 / 565

7.6
7.67.6
import wx.lib.buttons as buttons
7.6 wxPython
import wx
import wx.lib.buttons as buttons
class GenericButtonFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Generic Button Example’,
size=(500, 350))
panel = wx.Panel(self, -1)
sizer = wx.FlexGridSizer(1, 3, 20, 20)
b = wx.Button(panel, -1, ”A wx.Button”)
b.SetDefault()
sizer.Add(b)
b = wx.Button(panel, -1, ”non-default wx.Button”)
sizer.Add(b)
sizer.Add((10,10))
b = buttons.GenButton(panel, -1, ’Genric Button’)#
sizer.Add(b)
194 / 565

= buttons.GenButton(panel, -1, ’disabled Generic’)#
b.Enable(False)
sizer.Add(b)
b = buttons.GenButton(panel, -1, ’bigger’)#
b.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
b.SetBezelWidth(5)
b.SetBackgroundColour(“Navy”)
b.SetForegroundColour(“white”)
b.SetToolTipString(“This is a BIG button...”)
sizer.Add(b)
()
bmp = wx.Image(“bitmap.bmp”, wx.BITMAP_TYPE_BMP).ConvertToBitmap
b = buttons.GenBitmapButton(panel, -1, bmp)#
sizer.Add(b)
b = buttons.GenBitmapToggleButton(panel, -1, bmp)#
sizer.Add(b)
b = buttons.GenBitmapTextButton(panel, -1, bmp, ”Bitmapped Text”,
size=(175, 75))#
b.SetUseFocusIndicator(False)
sizer.Add(b)
b = buttons.GenToggleButton(panel, -1, ”Toggle Button”)#
sizer.Add(b)
panel.SetSizer(sizer)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = GenericButtonFrame()
frame.Show()
app.MainLoop()
7.6
EVT_BUTTON EVT_TOGGLEBUTTON
GetBevelWidth()SetBevelWidth()3D7.6
195 / 565

GenBitmapButtonwxPython
GenBitmapTextButton
GenToggleButton,GenBitmapToggleButton,
GenBitmapTextToggleButton
GetToggle() SetToggle()
7.3
wxPython
slider
7.3.1
wxPythonwx.Slider
7.7
7.7
196 / 565

7.77.7
7.7
import wx
class SliderFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Slider Example’,
size=(300, 350))
panel = wx.Panel(self, -1)
self.count = 0
slider = wx.Slider(panel, 100, 25, 1, 100, pos=(10, 10),
size=(250, -1),
style=wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_LABELS )
slider.SetTickFreq(5, 1)
slider = wx.Slider(panel, 100, 25, 1, 100, pos=(125, 70),
size=(-1, 250),
style=wx.SL_VERTICAL | wx.SL_AUTOTICKS | wx.SL_LABELS )
slider.SetTickFreq(20, 1)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = SliderFrame()
frame.Show()
app.MainLoop()
wx.Slider
wx.Slider(parent, id, value, minValue, maxValue,
pos=wxDefaultPosition, size=wx.DefaultSize,
style=wx.SL_HORIZONTAL, validator=wx.DefaultValidator,
name=”slider”)
valueminValuemaxValue
197 / 565

7.9
7.9 wx.Slider
wx.SL_AUTOTICKS
SetTickFreq
wx.SL_HORIZONTAL
wx.SL_LABELS
wx.SL_LEFT
wx.SL_RIGHT
wx.SL_TOP
wx.SL_VERTICAL
8
7.10Set*()Set*()
Get——GetSet*()
7.10
GetRange()
SetRange(minValue, maxValue)
GetTickFreq()
SetTickFreq(n, pos)npos
1
GetLineSize()
SetLineSize(lineSize)
GetPageSize()
SetPageSize(pageSize)PgUpPgDn
198 / 565

GetValue()
SetValue(value)
7.3.2
7.8
wxPython
7.8
wxPythonwx.SpinCtrl
wx.SpinCtrl
7.8wx.SpinCtrl
7.8 wx.SpinCtrl
import wx
class SpinnerFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Spinner Example’,
199 / 565

size=(100, 100))
panel = wx.Panel(self, -1)
sc = wx.SpinCtrl(panel, -1, ””, (30, 20), (80, -1))
sc.SetRange(1,100)
sc.SetValue(5)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
SpinnerFrame().Show()
app.MainLoop()
wx.SpinCtrl(parent, id=-1, value=wx.EmptyString,
pos=wx.DefaultPosition, size=wx.DefaultSize,
style=wx.SP_ARROW_KEYS, min=0, max=100, initial=0,
name=”wxSpinCtrl”)
valueinitialminmax
wx.SpinCtrlwx.SP_ARROW_KEYS
wx.SP_WRAP
EVT_SPINCTRL
EVT_TEXT
7.8SetRange(minVal, maxVal) SetValue(value)
SetValue()
GetValue(), GetMin(), GetMax()
wx.SpinButtonwx.TextCtrl
wx.SpinButtonwx.TextCtrl
200 / 565

7.3.3
wxPythonwx.Gauge
7.9
7.9
7.97.9
7.9 wx.Gauge
import wx
class GaugeFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Gauge Example’,
size=(350, 150))
panel = wx.Panel(self, -1)
self.count = 0
self.gauge = wx.Gauge(panel, -1, 50, (20, 50), (250, 25))
self.gauge.SetBezelFace(3)
self.gauge.SetShadowWidth(3)
self.Bind(wx.EVT_IDLE, self.OnIdle)
def OnIdle(self, event):
self.count = self.count + 1
if self.count >= 50:
self.count = 0
201 / 565

self.gauge.SetValue(self.count)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
GaugeFrame().Show()
app.MainLoop()
wx.Gauge
wx.Gauge(parent, id, range, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=wx.GA_HORIZONTAL,
validator=wx.DefaultValidator, name=”gauge”)
range
0wx.GA_HORIZONTAL90
wx.GA_VERTICALWindows
wx.GA_PROGRESSBARWindows
wx.Gauge
GetValue(), Set-Value(pos), GetRange(), SetRange(range)
Windows
SetBezelFace(width) and SetShadowWidth()3D
7.4
wxPython
7.4.1
7.10
202 / 565

7.10
wxPythonwx.CheckBox
7.10
7.10
7.10
import wx
class CheckBoxFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Checkbox Example’,
size=(150, 200))
panel = wx.Panel(self, -1)
wx.CheckBox(panel, -1, ”Alpha”, (35, 40), (150, 20))
wx.CheckBox(panel, -1, ”Beta”, (35, 60), (150, 20))
wx.CheckBox(panel, -1, ”Gamma”, (35, 80), (150, 20))
if __name__ == ’__main__’:
app = wx.PySimpleApp()
CheckBoxFrame().Show()
app.MainLoop()
wx.CheckBoxwxPython
wx.CheckBox(parent, id, label, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=0, name=”checkBox”)
203 / 565

label
EVT_CHECKBOXwx.CheckBox
GetValue()SetValue(state),
IsChecked()GetValue()
7.4.2 radio button
radio button
wxPython
wx.RadioButtonwx.RadioBox
wx.RadioButton
7.11
wx.RadioButton
7.11
wx.RadioButton
204 / 565

7.117.11
7.11 wx.RadioButton
import wx
class RadioButtonFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Radio Example’,
size=(200, 200))
panel = wx.Panel(self, -1)
#
radio1 = wx.RadioButton(panel, -1, ”Elmo”, pos=(20, 50), style=wx.RB_GRO
UP)
radio2 = wx.RadioButton(panel, -1, ”Ernie”, pos=(20, 80))
radio3 = wx.RadioButton(panel, -1, ”Bert”, pos=(20, 110))
#
text1 = wx.TextCtrl(panel, -1, ””, pos=(80, 50))
text2 = wx.TextCtrl(panel, -1, ””, pos=(80, 80))
text3 = wx.TextCtrl(panel, -1, ””, pos=(80, 110))
self.texts = {“Elmo”: text1, ”Ernie”: text2, ”Bert”: text3}#
for eachText in [text2, text3]:
eachText.Enable(False)
for eachRadio in [radio1, radio2, radio3]:#
self.Bind(wx.EVT_RADIOBUTTON, self.OnRadio, eachRadio)
self.selectedText = text1
def OnRadio(self, event):#
if self.selectedText:
self.selectedText.Enable(False)
radioSelected = event.GetEventObject()
text = self.texts[radioSelected.GetLabel()]
text.Enable(True)
self.selectedText = text
if __name__ == ’__main__’:
205 / 565

app = wx.PySimpleApp()
RadioButtonFrame().Show()
app.MainLoop()
forfor
wx.RadioButtonwx.CheckBox
wx.RadioButton(parent, id, label, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=0,
validator=wx.DefaultValidator, name=”radioButton”)
label
wx.RB_GROUP
wx.RB_GROUP
wx.RB_GROUP7.11
wx.RB_GROUP
wxPythonwx.RadioBox
7.12
206 / 565

7.12
wx.RadioBox7.12
7.12
7.12
import wx
class RadioBoxFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Radio Box Example’,
size=(350, 200))
panel = wx.Panel(self, -1)
sampleList = [‘zero’, ’one’, ’two’, ’three’, ’four’, ’five’,
’six’, ’seven’, ’eight’]
wx.RadioBox(panel, -1, ”A Radio Box”, (10, 10), wx.DefaultSize,
sampleList, 2, wx.RA_SPECIFY_COLS)
wx.RadioBox(panel, -1, ””, (150, 10), wx.DefaultSize,
sampleList, 3, wx.RA_SPECIFY_COLS | wx.NO_BORDER)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
RadioBoxFrame().Show()
app.MainLoop()
207 / 565

wx.RadioBox
wx.RadioBox(parent, id, label, pos=wx.DefaultPosition,
size=wxDefaultSize, choices=None, majorDimension=0,
style=wx.RA_SPECIFY_COLS, validator=wx.DefaultValidator,
name=”radioBox”)
labelchoices
Python
sizer
wx.RadioBoxwxPython
majorDimension
wx.RA_SPECIFY_COLS2
3choices
wx.RA_SPECIFY_ROWS
EVT_RADIOBOX
wx.RadioBox
0
7.11
7.11 wx.RadioBox
EnableItem(n, flag)flagn
Enable()
FindString(string)
-1
GetCount()
GetItemLabel(n)
SetItemLabel(n, string)n
GetSelection()
GetStringSelection()
SetSelection(n)
SetStringSelection( string)GetSelection() SetSelection()
GetStringSelection()
208 / 565

SetStringSelection()set*()
EVT_RADIOBOX
ShowItem(item, show)showitem
7.4.3
7.13
wxPython
wxPythonwx.ListBox
7.137.13
7.13 wx.ListBox
import wx
class ListBoxFrame(wx.Frame):
def __init__(self):
209 / 565

wx.Frame.__init__(self, None, -1, ’List Box Example’,
size=(250, 200))
panel = wx.Panel(self, -1)
sampleList = [‘zero’, ’one’, ’two’, ’three’, ’four’, ’five’,
’six’, ’seven’, ’eight’, ’nine’, ’ten’, ’eleven’,
’twelve’, ’thirteen’, ’fourteen’]
listBox = wx.ListBox(panel, -1, (20, 20), (80, 120), sampleList,
wx.LB_SINGLE)
listBox.SetSelection(3)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
ListBoxFrame().Show()
app.MainLoop()
wx.ListBox
wx.ListBox(parent, id, pos=wx.DefaultPosition,
size=wx.DefaultSize, choices=None, style=0,
validator=wx.DefaultValidator, name=”listBox”)
wx.ListBoxlabel
choices
7.12
7.12
wx.LB_EXTENDEDshift
wx.LB_MULTIPLE
210 / 565

wx.LB_SINGLE
wx.ListBox7.13
7.13
wx.LB_ALWAYS_SB
wx.LB_HSCROLL
wx.LB_HSCROLL
wx.LB_SORT
wx.ListBoxEVT_LISTBOX
EVT_LISTBOX_DCLICK
7.14
0
7.14
Append(item)
Clear()
Delete(n)n
Deselect(n)n
FindString(string)-1
GetCount()
GetSelection()
SetSelection(n, select)
211 / 565

GetStringSelection()
SetStringSelection(string, select)
GetSelections()GetSelection()
GetSelections()
GetStringSelection()set
select
EVT_LISTBOX
GetString(n)
SetString(n, string)n
InsertItems(items, pos)itemspos
0
Selected(n)n
Set(choices)choices
7.4.4
wx.CheckListBox7.14
7.14
wx.CheckListBoxwx.ListBox
wx.EVT_CHECKLISTBOX
Check(n, check)n
IsChecked(item)True
212 / 565

7.4.5
7.157.16
7.15
7.16
7.14
7.14
import wx
class ChoiceFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Choice Example’,
size=(250, 200))
panel = wx.Panel(self, -1)
sampleList = [‘zero’, ’one’, ’two’, ’three’, ’four’, ’five’,
’six’, ’seven’, ’eight’]
wx.StaticText(panel, -1, ”Select one:”, (15, 20))
213 / 565

wx.Choice(panel, -1, (85, 18), choices=sampleList)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
ChoiceFrame().Show()
app.MainLoop()
wx.Choice
wx.Choice(parent, id, pos=wx.DefaultPosition,
size=wx.DefaultSize, choices=None, style=0,
validator=wx.DefaultValidator, name=”choice”)
wx.ChoiceEVT_CHOICE
7.14wx.Choice
7.4.6
7.17
7.17 wx.CB_DropDOWNwx.CB_SIMPLE
Windows
214 / 565

wx.ComboBoxwx.Choice7.157.17
7.15
import wx
class ComboBoxFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Combo Box Example’,
size=(350, 300))
panel = wx.Panel(self, -1)
sampleList = [‘zero’, ’one’, ’two’, ’three’, ’four’, ’five’,
’six’, ’seven’, ’eight’]
wx.StaticText(panel, -1, ”Select one:”, (15, 15))
wx.ComboBox(panel, -1, ”default value”, (15, 30), wx.DefaultSize,
sampleList, wx.CB_DropDOWN)
wx.ComboBox(panel, -1, ”default value”, (150, 30), wx.DefaultSize,
sampleList, wx.CB_SIMPLE)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
ComboBoxFrame().Show()
app.MainLoop()
wx.ComboBox
wx.ComboBox(parent, id, value=””, pos=wx.DefaultPosition,
size=wx.DefaultSize, choices, style=0,
validator=wx.DefaultValidator, name=”comboBox”)
wx.ComboBox4
wx.CB_DropDOWNwx.CB_SIMPLE
Windowswx.CB_SIMPLE
wx.CB_READONLY
wx.CB_SORT
215 / 565

wx.ComboBoxwx.Choicewx.Choice
7.14
wx.TextCtrl7.4)
Copy(), Cut(), GetInsertionPoint(), GetValue(), Paste(), Replace(from,to, text), Remo
ve(from, to), SetInsertionPoint(pos), SetInsertionPointEnd(), SetValue()
7.5
wxPython
1wx.StaticText
wxPythonwx.lib.stattext.GenStaticText
2wx.TextCtrl
wx.TextCtrlwx.Text-Attrwx.Font
wx.stc.StyledTextCtrl
wxPythonScintilla
3wx.Button
wx.lib.buttons.GenButton
wx.BitmapButton
4wx.Slider
wx.SpinCtrl
wx.Gauge
5
wx.CheckBox
wx.RadioButtonwx.RadioBox
wx.ListBoxwx.CheckListBox
wx.Choice. wx.ComboBox
216 / 565

217 / 565

8
wxPython
wxPython
wxPythonwx.Frame
wx.FramewxPython
panel
8.1
8.1.1
wx.Frame8.1
8.1 wx.Frame
import wx
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = wx.Frame(None, -1, ”A Frame”, style=wx.DEFAULT_FRAME_STYLE
,
size=(200, 100))
frame.Show()
app.MainLoop()
(200,100)8.1
8.1
218 / 565

8.1
wx.Frame7
wx.Frame(parent, id=-1, title=””, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE,
name=”frame”)
wx.Frame
wx.Framewx.Frame
wx.Frame
wxPythonwx.Frame
wx.Frame——
8.2wx.Frame
8.2
import wx
class SubclassFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Frame Subclass’,
size=(300, 100))
219 / 565

panel = wx.Panel(self, -1)
button = wx.Button(panel, -1, ”Close Me”, pos=(15, 15))
self.Bind(wx.EVT_BUTTON, self.OnCloseMe, button)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
def OnCloseMe(self, event):
self.Close(True)
def OnCloseWindow(self, event):
self.Destroy()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
SubclassFrame().Show()
app.MainLoop()
8.2
8.2
wx.Frame.__init__wx.Frame
self
panel
panel)wx.Panel
wx.Panel
wx.Panel
MS Windowswx.Panel
panel
220 / 565

panel
tab
8.1.2
wx.Frame
——
8.1
8.1
wx.FRAME_NO_TASKBARWindows
wx.FRAME_SHAPEDSetShape()
wx.FRAME_TOOL_WINDOW
Windows
wx.ICONIZEWindows
wx.MAXIMIZEWindows
wx.MINIMIZEwx.ICONIZE
wx.FRAME_TOOL_WINDOW8.3
wx.FRAME_TOOL_WINDOWwx.CAPTIONwx.SYSTEM_MENU
8.3
221 / 565

8.2
8.3
8.2
wx.FRAME_FLOAT_ON_PARENT
wx.STAY_ON_TOP
wx.DEFAULT_FRAME_STYLE
wx.MINIMIZE_BOX | wx.MAXIMIZE_BOX | wx.CLOSE_BOX | wx.RESIZE_BO
RDER | wx.SYSTEM_MENU |wx.CAPTION
style=wx.DEFAULT_FRAME_STYLE | wx.FRAME_TOOL_WINDOW
^
8.3
wx.CAPTION
wx.FRAME_EX_CONTEXTHELPWindows
wx.MAXIMIZE_BOXWX.MINIMIZE_BOX
wx.FRAME_EX_METALMac OS X
SetExtraStyle
wx.MAXIMIZE_BOX
wx.MINIMIZE_BOX
222 / 565

wx.CLOSE_BOX
wx.RESIZE_BORDER
wx.SIMPLE_BORDER
wx.SYSTEM_MENU
wx.MINIMIZE_BOX
“”
8.1.3
wx.FRAME_EX_CONTEXTHELP
C++
SetExtraStyle
wx.FRAME_EX_CONTEXTHELP
UIwxPython
8.4
8.4
SetExtraStyle()
wxPythonwx.PreFrame
preframe
preframe8.3
two-step
wxPythonC++ wxWidgetstwostep
223 / 565

8.3
import wx
class HelpFrame(wx.Frame):
def __init__(self):
pre = wx.PreFrame() #1
pre.SetExtraStyle(wx.FRAME_EX_CONTEXTHELP)
pre.Create(None, -1, ”Help Context”, size=(300, 100),
style=wx.DEFAULT_FRAME_STYLE ^
(wx.MINIMIZE_BOX | wx.MAXIMIZE_BOX)) #2
self.PostCreate(pre) #3 C++
if __name__ == ’__main__’:
app = wx.PySimpleApp()
HelpFrame().Show()
app.MainLoop()
#1 wx.PreFrame()
wx.PreDialog()——wxWidgets
#2 Create()
#3 wxPythonC++PostCreate
C++
8.4
Python
Python__init__
8.4
def twoStepCreate(instance, preClass, preInitFunc, *args,
**kwargs):
224 / 565

pre = preClass()
preInitFunc(pre)
pre.Create(*args, **kwargs)
instance.PostCreate(pre)
8.4instance
preClass——
wx.PreFramepreInitFunc
pre = preClass()
preInitFunc
pre.Create()
PostCreatepre
instancetwoStepCreate
8.5
8.5
import wx
class HelpFrame(wx.Frame):
def __init__(self, parent, ID, title,
pos=wx.DefaultPosition, size=(100,100),
style=wx.DEFAULT_DIALOG_STYLE):
twoStepCreate(self, wx.PreFrame, self.preInit, parent,
id, title, pos, size, style)
def preInit(self, pre):
pre.SetExtraStyle(wx.FRAME_EX_CONTEXTHELP)
wx.PreFrameself.preInitpreInit
8.1.4
wxPython
225 / 565

wxPython
C++ wxWidgetsC++
wxPython
“”“”——
Close
wxPythonEVT_CLOSEwxPython
EVT_CLOSE
1Destroy()
2——
Destroy()
Destroy()
Destroy()Close()Close()
wx.CloseEvent.Veto()
Close()
226 / 565

Destroy()
wx.App EVT_QUERY_END_SESSION
GUIEVT_END_SESSION
Destroy()
8.2
8.2.1 wx.Frame
wx.Framewx.Window
8.4
wx.Frame
8.4 wx.Frame
GetBackgroundColor()
SetBackgroundColor(wx.Color)
wx.Color
wxPythonwx.NamedColour()
GetId()
SetId(int)
GetMenuBar()
227 / 565

SetMenuBar(wx.MenuBar)
None
GetPosition()
GetPositionTuple()
SetPosition(wx.Point)wx.PointPythonx,y
GetSize()
GetSizeTuple()
SetSize(wx.Size)C++get*set*get*set*
wx.SizeGetSizeTuple()Python
SetDimensions()
GetTitle()
SetTitle(String)
8.5wx.Frame
Refresh()
8.5 wx.Frame
Center(direction=wx.BOTH)Centre
wx.BoTH
wx.HORIZONTALwx.VERTICAL
Enable(enable=true)true
FalseDisable()
GetBestSize()wx.Frame
Iconize(iconize)true
False
IsEnabled()True
IsFullScreen()TrueFalse
ShowFullScreen
IsIconized()TrueFalse
IsMaximized()TrueFalse
228 / 565

IsShown()True
IsTopLevel()True
False
Maximize(maximize)True
Refresh(erase"242.files/">rect=None)rectnone
eraseBackgroundTrueFalse
SetDimensions(x, y, width, height,sizeFlags=wx.SIZE_AUTO)
xywidthheight
-1-1sizeFlags
8.6sizeFlags
Show(show=True)TrueFalse
Show(False)Hide()
ShowFullScreen(show,style=wx.FULLSCREEN_ALL)True
——
Falsestyle
wx.FULLSCREEN_ALLwxPython
wx.FULLSCREEN_NOBORDER, wx.FULLSCREEN_NOCAPTION,wx.FULLSCRE
EN_NOMENUBAR,wx.FULLSCREEN_NOSTATUSBAR,wx.FULLSCREEN_NOTO
OLBAR
8.5SetDimensions()-1
8.6
8.6 SetDimensions
wx.ALLOW_MINUS_ONE
wx.SIZE_AUTOwxPython
229 / 565

wx.SIZE_AUTO_HEIGHTwxPython
wx.SIZE_AUTO_WIDTHwxPython
wx.SIZE_USE_EXISTING
8.2.2
(panel)
6
8.6
7FindItemById()
ID
8.6 ID
def OnColor(self, event):
menubar = self.GetMenuBar()
itemId = event.GetId()
item = menubar.FindItemById(itemId)
color = item.GetLabel()
self.sketch.SetColor(color)
wxPython
(panel)wxPython ID
name
1wx.FindWindowById(id, parent=None)
2wx.FindWindowByName(name, parent=None)
3wx.FindWindowByLabel(label, parent=None)
230 / 565

parent
FindFindWindowByName()
nameFindWindowByLabel()
8.2.3
wxPython
wx.ScrolledWindowwx.Panel
wx.ScrolledWindow8.58.6
8.58.6
8.5
8.6
231 / 565

8.7
8.7
import wx
class ScrollbarFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ’Scrollbar Example’,
size=(300, 200))
self.scroll = wx.ScrolledWindow(self, -1)
self.scroll.SetScrollbars(1, 1, 600, 400)
self.button = wx.Button(self.scroll, -1, ”Scroll Me”, pos=(50, 20))
self.Bind(wx.EVT_BUTTON, self.OnClickTop, self.button)
self.button2 = wx.Button(self.scroll, -1, ”Scroll Back”, pos=(500, 350))
self.Bind(wx.EVT_BUTTON, self.OnClickBottom, self.button2)
def OnClickTop(self, event):
self.scroll.Scroll(600, 400)
def OnClickBottom(self, event):
self.scroll.Scroll(1, 1)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = ScrollbarFrame()
frame.Show()
app.MainLoop()
wx.ScrolledWindowwx.Panel
wx.ScrolledWindow(parent, id=-1, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=wx.HSCROLL | wx.VSCROLL,
name=”scrolledWindow”)
size
232 / 565

8.1
SetScrollBars
SetScrollbars(pixelsPerUnitX, pixelsPerUnitY, noUnitsX, noUnitsY,
xPos=0, yPos=0, noRefresh=False)
pixelsPerUnitXPixelsPerUnitY
noUnitsXnoUnitsY
(pixelsPerUnitX* noUnitsX, pixelsPerUnitY * noUnitsY)8.7
1xPosyPos
noRefreshtrue
SetScrollbars()
SetVirtualSize()
self.scroll.SetVirtualSize((600, 400))
FitInside()
self.scroll.FitInside()
FitInside()
8.7
FitInside()
sizerSetSizer()
sizer
sizer11
233 / 565

SetScrollRate()
self.scroll.SetScrollRate(1, 1)
xy0
8.7Scroll()
xy
7
8.7
8.7
EVT_SCROLL
EVT_SCROLL_BOTTOM
EVT_SCROLL_ENDSCROLLWindows
EVT_SCROLL_LINEDOWN
EVT_SCROLL_LINEUP
EVT_SCROLL_PAGEDOWN
EVT_SCROLL_PAGEUP
EVT_SCROLL_THUMBRELEASE
EVT_SCROLL_THUMBTRACK
EVT_SCROLL_TOP
234 / 565

EVT_SCROLL*EVT_SCROLLWIN*
wx.ScrolledWindow
wxPython
wx.lib.scrolledpanel.ScrolledPanel
sizerwx.lib.scrolledpanel.ScrolledPanel
tab
wx.lib.scrolledpanel.ScrolledPanel
SetupScrolling(self, scroll_x=True, scroll_y=True, rate_x=20,
rate_y=20)
rate_xrate_ysizer
(virtual size)
(virtual size)
8.5Scroll Me
(-277,-237)CalcScrolledPosition(x,y)
CalcUnscrolledPosition(x, y)
(x,y)
CalcUnscrolledPostion(-277, -237) (50, 20)
8.3
MDI
8.3.1 MDI
MDIMDI90
235 / 565

MDI
z
MDI
8.7MDI
wxPythonMDIWindows
MDIMDI8.8
MDI
8.8 MDI
import wx
class MDIFrame(wx.MDIParentFrame):
def __init__(self):
wx.MDIParentFrame.__init__(self, None, -1, ”MDI Parent”,
size=(600,400))
menu = wx.Menu()
menu.Append(5000, ”&New Window”)
menu.Append(5001, ”E&xit”)
menubar = wx.MenuBar()
menubar.Append(menu, ”&File”)
self.SetMenuBar(menubar)
236 / 565

self.Bind(wx.EVT_MENU, self.OnNewWindow, id=5000)
self.Bind(wx.EVT_MENU, self.OnExit, id=5001)
def OnExit(self, evt):
self.Close(True)
def OnNewWindow(self, evt):
win = wx.MDIChildFrame(self, -1, ”Child Window”)
win.Show(True)
if __name__ == ’__main__’:
app = wx.PySimpleApp()
frame = MDIFrame()
frame.Show()
app.MainLoop()
MDIwx.MDIParentFrame
wxPython
wx.MDIChildFramewx.MDIParentFramewx.Frame
wx.MDIParentFrame(parent, id, title, pos = wx.DefaultPosition,
size=wxDefaultSize,
style=wx.DEFAULT_FRAME_STYLE | wx.VSCROLL | wx.HSCROLL,
name=”frame”)
wx.MDIParentFrame
wx.MDIChildFrame8.8
Cascade()Tile()
Cascade()
8.7Tile()
ActivateNext()ActivatePrevious()
237 / 565

8.3.2
WindowsGTK8.8
8.8
wx.MiniFrame8.9
8.9
import wx
class MiniFrame(wx.MiniFrame):
def __init__(self):
wx.MiniFrame.__init__(self, None, -1, ’Mini Frame’,
size=(300, 100))
panel = wx.Panel(self, -1, size=(300, 100))
button = wx.Button(panel, -1, ”Close Me”, pos=(15, 15))
self.Bind(wx.EVT_BUTTON, self.OnCloseMe, button)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
def OnCloseMe(self, event):
self.Close(True)
def OnCloseWindow(self, event):
self.Destroy()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
MiniFrame().Show()
238 / 565

app.MainLoop()
wx.MiniFramewx.Framewx.MiniFrame
8.8
8.8 wx.MiniFrame
wx.THICK_FRAMEWindowsMotif
wx.TINY_CAPTION_HORIZONTALwx.CAPTION
wx.TINY_CAPTION_VERTICALwx.CAPTION
8.3.3
wxPython
8.9
wxPython demoimagesvippi
wxPython
239 / 565

8.9
8.10
8.10
import wx
import images
class ShapedFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”Shaped Window”,
style = wx.FRAME_SHAPED | wx.SIMPLE_BORDER |
wx.FRAME_NO_TASKBAR)
self.hasShape = False
#1
self.bmp = images.getVippiBitmap()
self.SetClientSize((self.bmp.GetWidth(), self.bmp.GetHeight()))
#2
dc = wx.ClientDC(self)
dc.DrawBitmap(self.bmp, 0,0, True)
240 / 565

self.SetWindowShape()
self.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)
self.Bind(wx.EVT_RIGHT_UP, self.OnExit)
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.Bind(wx.EVT_WINDOW_Create, self.SetWindowShape)#3
def SetWindowShape(self, evt=None):#4
r = wx.RegionFromBitmap(self.bmp)
self.hasShape = self.SetShape(r)
def OnDoubleClick(self, evt):
if self.hasShape:
self.SetShape(wx.Region())#5
self.hasShape = False
else:
self.SetWindowShape()
def OnPaint(self, evt):
dc = wx.PaintDC(self)
dc.DrawBitmap(self.bmp, 0,0, True)
def OnExit(self, evt):
self.Close()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
ShapedFrame().Show()
app.MainLoop()
#1 images
wxPython16
#2
#3
SetWindowShape()GTK
241 / 565

UI
#4 wx.RegionFromBitmap
wx.Region
wx.Region
#5
wx.RegionSetShape()
SetShape()wx.Frame
wx.SplashScreen
8.3.4
8.11
8.11
import wx
import images
class ShapedFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”Shaped Window”,
style = wx.FRAME_SHAPED | wx.SIMPLE_BORDER )
self.hasShape = False
self.delta = wx.Point(0,0)
self.bmp = images.getVippiBitmap()
self.SetClientSize((self.bmp.GetWidth(), self.bmp.GetHeight()))
dc = wx.ClientDC(self)
dc.DrawBitmap(self.bmp, 0,0, True)
self.SetWindowShape()
242 / 565

self.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)
#1
self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
self.Bind(wx.EVT_MOTION, self.OnMouseMove)
self.Bind(wx.EVT_RIGHT_UP, self.OnExit)
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.Bind(wx.EVT_WINDOW_Create, self.SetWindowShape)
def SetWindowShape(self, evt=None):
r = wx.RegionFromBitmap(self.bmp)
self.hasShape = self.SetShape(r)
def OnDoubleClick(self, evt):
if self.hasShape:
self.SetShape(wx.Region())
self.hasShape = False
else:
self.SetWindowShape()
def OnPaint(self, evt):
dc = wx.PaintDC(self)
dc.DrawBitmap(self.bmp, 0,0, True)
def OnExit(self, evt):
self.Close()
def OnLeftDown(self, evt):#2
self.CaptureMouse()
pos = self.ClientToScreen(evt.GetPosition())
origin = self.GetPosition()
self.delta = wx.Point(pos.x - origin.x, pos.y - origin.y)
def OnMouseMove(self, evt):#3
if evt.Dragging() and evt.LeftIsDown():
pos = self.ClientToScreen(evt.GetPosition())
newPos = (pos.x - self.delta.x, pos.y - self.delta.y)
self.Move(newPos)
243 / 565

def OnLeftUp(self, evt):#4
if self.HasCapture():
self.ReleaseMouse()
if __name__ == ’__main__’:
app = wx.PySimpleApp()
ShapedFrame().Show()
app.MainLoop()
#1
#2
#3
#4 ReleaseMouse()
8.4
8.10
244 / 565

Mac OS X Finder
8.4.1
wxPythonwx.SplitterWindow
wxPython
8.10
wx.SplitterWindow(parent, id=-1, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=wx.SP_3D,
name=”splitterWindow”)
——parentpos
size
245 / 565

Initialize(window)windowwx.Panel
SplitHorizontally (window1window2sashPosition=0)
SplitVertically(window1, window2, sashPosition=0)
window1window2sashPosition
window1window2
sashPosition
sashPosition
sashPosition0
window1window2
sashPositionwindow1
sashPosition0
sizer
8.4.2
8.12
Hide()
8.12
import wx
class SplitterExampleFrame(wx.Frame):
def __init__(self, parent, title):
wx.Frame.__init__(self, parent, title=title)
self.MakeMenuBar()
self.minpane = 0
self.initpos = 0
self.sp = wx.SplitterWindow(self)#
self.p1 = wx.Panel(self.sp, style=wx.SUNKEN_BORDER)#
246 / 565

self.p2 = wx.Panel(self.sp, style=wx.SUNKEN_BORDER)
self.p1.SetBackgroundColour(“pink”)
self.p2.SetBackgroundColour(“sky blue”)
self.p1.Hide()#
self.p2.Hide()
self.sp.Initialize(self.p1)#
self.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGING,
self.OnSashChanging, self.sp)
self.Bind(wx.EVT_SPLITTER_SASH_POS_CHANGED,
self.OnSashChanged, self.sp)
def MakeMenuBar(self):
menu = wx.Menu()
item = menu.Append(-1, ”Split horizontally”)
self.Bind(wx.EVT_MENU, self.OnSplitH, item)
self.Bind(wx.EVT_Update_UI, self.OnCheckCanSplit, item)
item = menu.Append(-1, ”Split vertically”)
self.Bind(wx.EVT_MENU, self.OnSplitV, item)
self.Bind(wx.EVT_Update_UI, self.OnCheckCanSplit, item)
item = menu.Append(-1, ”Unsplit”)
self.Bind(wx.EVT_MENU, self.OnUnsplit, item)
self.Bind(wx.EVT_Update_UI, self.OnCheckCanUnsplit, item)
menu.AppendSeparator()
item = menu.Append(-1, ”Set initial sash position”)
self.Bind(wx.EVT_MENU, self.OnSetPos, item)
item = menu.Append(-1, ”Set minimum pane size”)
self.Bind(wx.EVT_MENU, self.OnSetMin, item)
menu.AppendSeparator()
item = menu.Append(wx.ID_EXIT, ”E&xit”)
self.Bind(wx.EVT_MENU, self.OnExit, item)
mbar = wx.MenuBar()
mbar.Append(menu, ”Splitter”)
self.SetMenuBar(mbar)
247 / 565

def OnSashChanging(self, evt):
print ”OnSashChanging:”, evt.GetSashPosition()
def OnSashChanged(self, evt):
print ”OnSashChanged:”, evt.GetSashPosition()
def OnSplitH(self, evt):#
self.sp.SplitHorizontally(self.p1, self.p2, self.initpos)
def OnSplitV(self, evt):#
self.sp.SplitVertically(self.p1, self.p2, self.initpos)
def OnCheckCanSplit(self, evt):
evt.Enable(not self.sp.IsSplit())
def OnCheckCanUnsplit(self, evt):
evt.Enable(self.sp.IsSplit())
def OnUnsplit(self, evt):
self.sp.Unsplit()
def OnSetMin(self, evt):
minpane = wx.GetNumberFromUser(
”Enter the minimum pane size”,
””, ”Minimum Pane Size”, self.minpane,
0, 1000, self)
if minpane != -1:
self.minpane = minpane
self.sp.SetMinimumPaneSize(self.minpane)
def OnSetPos(self, evt):
initpos = wx.GetNumberFromUser(
”Enter the initial sash position (to be used in the Split call)”,
””, ”Initial Sash Position”, self.initpos,
-1000, 1000, self)
if initpos != -1:
self.initpos = initpos
248 / 565

def OnExit(self, evt):
self.Close()
app = wx.PySimpleApp(redirect=True)
frm = SplitterExampleFrame(None, ”Splitter Example”)
frm.SetSize((600,500))
frm.Show()
app.SetTopWindow(frm)
app.MainLoop()
FalseTrue
IsSplit()8.12
Unsplit(toRemove=None)toRemove
wx.Window
toRemoveNone
wxPython
unsplitTrue
toRemoveFalse
GetWindow1()
GetWindow2()GetWindow1()
GetWindow2()
ReplaceWindow(winOld, winNew)winOld
wx.WindowwinNew
8.4.3
8.9
249 / 565

8.9
wx.SP_3D
wx.SP_3DBORDER
wx.SP_3DSASH
wx.SP_BORDER
wx.SP_LIVE_Update
wx.SP_NOBORDER
wx.SP_NO_XP_THEME Windows XPXP
wx.SP_PERMIT_UNSPLIT
0
8.4.4
SetSashPosition(position,redraw=True)
position
redrawTrue
GetSashPosition()
0
SetMinimumPaneSize(paneSize)
paneSize
wx.SP_PERMIT_UNSPLIT
GetMinimumPaneSize()
250 / 565

SetSplitMode(mode)mode
wx.SPLIT_VERTICALwx.SPLIT_HORIZONTAL
GetSplitMode()
GetSplitMode()
wx.SP_LIVE_Update
UpdateSize()
8.4.5
wx.SplitterEvent
8.10
8.10
EVT_SPLITTER_DCLICK
Veto()
EVT_SPLITTER_SASH_POS_CHANGED
Veto()
EVT_SPLITTER_SASH_POS_CHANGING
Veto()
EVT_SPLITTER_UNSPLIT
wx.CommandEvent
GetSashPosition()
SetSashPosition(pos)
SetSashPosition(pos)
GetX() GetY()
GetWindowBeingRemoved()
251 / 565

8.5
1wxPythonwx.Framewx.Dialog
wx.Framewx.FramewxPython
wx.Frame
wx.Panel
2wx.Frame
“”
3Close()
Destroy()
4wxPython ID
5wx.ScrolledWindow
sizer
wxPythonvirtual size
6
wx.MDIParentFrameMDIwx.MiniFrame
SetShape()
7wx.SplitterWindow
252 / 565

9
9.1
wxPython
9.1.1
9.1
wxPython
9.1
9.19.1
stdout()
9.1
import wx
class SubclassDialog(wx.Dialog):
def __init__(self):#
wx.Dialog.__init__(self, None, -1, ’Dialog Subclass’,
size=(300, 100))
okButton = wx.Button(self, wx.ID_OK, ”OK”, pos=(15, 15))
okButton.SetDefault()
253 / 565

cancelButton = wx.Button(self, wx.ID_CANCEL, ”Cancel”,
pos=(115, 15))
if __name__ == ’__main__’:
app = wx.PySimpleApp()
app.MainLoop()
dialog = SubclassDialog()
result = dialog.ShowModal()#
if result == wx.ID_OK:
print ”OK”
else:
print ”Cancel”
dialog.Destroy()
wx.Frame__init__
wx.Dialogwx.Panel
wx.Paneltab
wx.Dialog
ShowModal()Show()
ShowModal()
EndModal(retCode)
retCodeShowModal()
9.1
wxDialogwxPython ID
wx.ID_OK IDwx.Button
wx.ID_OKShowModal()
wx.ID_CANCEL ID
ShowModal()wx.ID_CANCEL
254 / 565

9.1
if
wx.ID_OK
C+
+Python
ShowModal()
MainLoop()
9.1.2
wx.MessageDialogwx.TextEntryDialog
wx.SingleChoiceDialog
yes/no
9.2
9.2
9.2
255 / 565

9.2
import wx
if __name__ == ”__main__”:
app = wx.PySimpleApp()
#
dlg = wx.MessageDialog(None, ”Is this explanation OK”,
’A Message Box’,
wx.YES_NO | wx.ICON_QUESTION)
retCode = dlg.ShowModal()
if (retCode == wx.ID_YES):
print ”yes”
else:
print ”no”
dlg.Destroy()
#1
retCode = wx.MessageBox(“Is this way easier”, ”Via Function”,
wx.YES_NO | wx.ICON_QUESTION)
9.2
wx.MessageDialogShowModal()
wx.MessageDialog
wx.MessageDialog(parent, message, caption=”Message box”,
style=wx.OK | wx.CANCEL, pos=wx.DefaultPosition)
message\n
captionpos
——Windows
wx.MessageDialog
9.1
256 / 565

9.1 wx.MessageDialog
wx.CANCELcancelID
wx.ID_CANCEL
wx.NO_DEFAULTwx.YES_NONo
wx.OKOKIDwx.ID_OK
wx.YES_DEFAULTwx.YES_NOYes
wx.YES_NOYesNoIDwx.ID_YESwx.ID_NO
9.2
9.2 wx.MessageDialog
wx.ICON_ERROR
wx.ICON_EXCLAMATION
wx.ICON_HANDwx.ICON_ERROR
wx.ICON_INFORMATIONi
wx.ICON_QUESTION
wx.STAY_ON_TOP
wxPython
9.2ShowModal()
wx.ID_OK, wx.ID_CANCELwx.ID_YES, wx.ID_NO
9.2#1
wx.MessageBox()ShowModal()
wx.YES, wx.NO, wx.CANCEL, wx.OKMessageDialog
257 / 565

wx.MessageBox(message, caption=”Message”, style=wx.OK)
message, caption, style
wxPython
wxPythonwx.lib.dialogs.ScrolledMessageDialog
wx.lib.dialogs.ScrolledMessageDialog(parent, msg, caption,
pos=wx.wxDefaultPosition, size=(500,300))
wxPython
OK
9.1.3
wx.TextEntryDialog
9.3
9.3
9.39.3
258 / 565

9.3
import wx
if __name__ == ”__main__”:
app = wx.PySimpleApp()
dialog = wx.TextEntryDialog(None,
”What kind of text would you like to enter”,
”Text Entry”, ”Default Value”, style=wx.OK|wx.CANCEL)
if dialog.ShowModal() == wx.ID_OK:
print ”You entered: %s” % dialog.GetValue()
dialog.Destroy()
wx.TextEntryDialog
wx.TextEntryDialog(parent, message, caption=”Please enter text”,
defaultValue=””, style=wx.OK | wx.CANCEL | wx.CENTRE,
pos=wx.DefaultPosition)
messagecaption
defaultValuestylewx.OK
wx.CANCEL
wx.TextCtrl
wx.TE_PASSWORD
wx.TE_MULTILINE
wx.TE_LEFT, wx.TE_CENTRE, wx.TE_RIGHT
9.3
GetValue()Cancel
SetValue()
259 / 565

1wx.GetTextFromUser()
2wx.GetPasswordFromUser()
3wx.GetNumberFromUser()
9.3wx.GetTextFromUser()
wx.GetTextFromUser(message, caption=”Input text”,
default_value=””, parent=None)
message, caption, default_value, parentwx.TextEntryDialog
OK
Cancel
wx.GetPasswordFromUser()
wx.GetPasswordFromUser(message, caption=”Input text”,
default_value=””, parent=None)
OKCancel
wx.GetNumberFromUser()
wx.GetNumberFromUser(message, prompt, caption, value, min=0,
max=100, parent=None)
messageprompt
valueminmax
OK
-1
260 / 565

9.1.4
wx.SingleChoiceDialog9.4
9.4
9.49.4
9.4
import wx
if __name__ == ”__main__”:
app = wx.PySimpleApp()
choices = [“Alpha”, ”Baker”, ”Charlie”, ”Delta”]
dialog = wx.SingleChoiceDialog(None, ”Pick A Word”, ”Choices”,
choices)
if dialog.ShowModal() == wx.ID_OK:
print ”You selected: %s\n” % dialog.GetStringSelection()
dialog.Destroy()
wx.SingleChoiceDialog
wx.SingleChoiceDialog(parent, message, caption, choices,
clientData=None, style=wx.OK | wx.CANCEL | wx.CENTRE,
pos=wx.DefaultPosition)
261 / 565

messagecaption
choices
styleOKCancle
centreposWindows
SetSelection(selection)selection
GetSelection()——
GetStringSelection()——
wx.GetSingleChoice
wx.GetSingleChoice(message, caption, aChoices, parent=None)
message, caption, parentwx.SingleChoiceDialog
aChoicesOK
Cancel
wx.GetSingleChoiceIndex:
wx.GetSingleChoiceIndex(message, caption, aChoices, parent=None)
OK
Cancel-1
9.1.5
wxPython9.5
262 / 565

9.5
9.59.5
9.5
import wx
if __name__ == ”__main__”:
app = wx.PySimpleApp()
progressMax = 100
dialog = wx.ProgressDialog(“A progress box”, ”Time remaining”, progressMax,
style=wx.PD_CAN_ABORT | wx.PD_ELAPSED_TIME | wx.PD_REMAIN
ING_TIME)
keepGoing = True
count = 0
while keepGoing and count < progressMax:
count = count + 1
wx.Sleep(1)
keepGoing = dialog.Update(count)
dialog.Destroy()
wx.ProgressDialog(title, message, maximum=100, parent=None,
style=wx.PD_AUTO_HIDE | wx.PD_APP_MODAL)
titlemessage
maximum
263 / 565

9.3 wx.ProgressDialog
9.3 wx.ProgressDialog
wx.PD_APP_MODAL
wx.PD_AUTO_HIDE
wx.PD_CAN_ABORTCancel
wx.PD_ELAPSED_TIME
wx.PD_ESTIMATED_TIME
wx.PD_REMAINING_TIME(-
)
Update(value,newmsg=””)value
update
newmsg
Update()TrueCancel
Update()False
Update()
9.2
wxPython
wxPython
9.2.1
wxPythonwx.FileDialog
Windows9.6
264 / 565

9.6
9.6
9.6 wx.FileDialog
import wx
import os
if __name__ == ”__main__”:
app = wx.PySimpleApp()
wildcard = ”Python source (*.py)|*.py|” \
”Compiled Python (*.pyc)|*.pyc|” \
”All files (*.*)|*.*”
dialog = wx.FileDialog(None, ”Choose a file”, os.getcwd(),
””, wildcard, wx.OPEN)
if dialog.ShowModal() == wx.ID_OK:
print dialog.GetPath()
dialog.Destroy()
265 / 565

wx.FileDialog(parent, message=”Choose a file”, defaultDir=””,
defaultFile=””, wildcard=”*.*”, style=0,
pos=wx.DefaultPosition)
messagedefaultDir
defaultFilewildcard
*
*.py|||——9.6
“Python source (*.py)|*.py|Compiled Python (*.pyc)|*.pyc|
All files (*.*)|*.*”
9.6
pos
wx.FileDialogwx.OPENwx.SAVE
wx.HIDE_READONLY
wx.MULTIPLE
wx.OVERWRITE_PROMPT
wx.CHANGE_DIR
directoryfilename, style, message, wildcard
Get/Set
266 / 565

wx.OK
GetPath()
wx.MULTIPLEGetPaths()
GetPath()Python
GetFilterIndex()
SetFilterIndex()
wx.FileSelector(message, default_path=””, default_filename=””,
default_extension=””, wildcard=”*.*’’, flags=0, parent=None,
x=-1, y=-1)
message, default_path, default_filename, wildcard
flagsstyledefault_extension
OKCancel
wx.DirDialog
9.7
9.7
9.7
import wx
if __name__ == ”__main__”:
app = wx.PySimpleApp()
dialog = wx.DirDialog(None, ”Choose a directory:”,
style=wx.DD_DEFAULT_STYLE | wx.DD_NEW_DIR_BUTTON)
if dialog.ShowModal() == wx.ID_OK:
print dialog.GetPath()
dialog.Destroy()
267 / 565

9.7
wx.DirDialog(parent, message=”Choose a directory”, defaultPath=””,
style=0, pos = wx.DefaultPosition, size = wx.DefaultSize,
name=”wxDirCtrl”)
message
defaultPath
possizeWindowsname
wx.DD_NEW_DIR_BUTTON
Windows
wx.DirDialogpath, message, styleget*set*
GetPath()
wx.DirSelector(message=wx.DirSelectorPromptStr, default_path=””,
style=0, pos=wxDefaultPosition, parent=None)
OK
Cancel
268 / 565

9.2.2
wxPython
9.8Windows
9.8 9.8
9.8
import wx
if __name__ == ”__main__”:
app = wx.PySimpleApp()
dialog = wx.FontDialog(None, wx.FontData())
if dialog.ShowModal() == wx.ID_OK:
data = dialog.GetFontData()
font = data.GetChosenFont()
colour = data.GetColour()
print ’You selected: ”%s”, %d points\n’ % (
font.GetFaceName(), font.GetPointSize())
dialog.Destroy()
9.8
269 / 565

wx.FontDialog
wx.FontDialog(parent, data)
datawx.FontDatawx.FontData
GetFontData()
wx.FontData
9.8wx.FontDataget*
wx.FontData——
9.4
9.4 wx.FontData
GetAllowSymbols()
SetAllowSymbols(allowSymbols)
dingbatsWindowsTrue
GetChosenFont()
SetChosenFont(font)wx.Font
Nonewx.Font12
GetColour()
SetColour(colour)set*
get*wx.Colourset*colour
wx.Colourblack
GetEnableEffects()
EnableEffects(enable)Windows
GetInitialFont()
SetInitialFont(font)
None
SetRange(min, max)Windows
0~0
GetShowHelp()
SetShowHelp()TrueWindows
False
270 / 565

wx.FontData
wx.GetFontFromUser(parent, fontInit)
fontInitwx.Font
wx.FontOKwx.Font.Ok()
TrueFalse
9.2.3
9.9
9.9
9.9
import wx
if __name__ == ”__main__”:
app = wx.PySimpleApp()
dialog = wx.ColourDialog(None)
dialog.GetColourData().SetChooseFull(True)
if dialog.ShowModal() == wx.ID_OK:
data = dialog.GetColourData()
print ’You selected: %s\n’ % str(data.GetColour().Get())
dialog.Destroy()
271 / 565

9.9
wxPythonwx.ColourDialog
wx.ColourDialog(parent, data=None)
datawx.ColourData
1GetChooseFulłSetChooseFull(flag)Windows
2GetColour/SetColour(colour)get*
black
3GetCustomColour(i)/SetCustomColour(i, colour)
ii[0,15]
wx.ColorData
wx.GetColourFromUser(parent, colInit)
272 / 565

colInitwx.Colour
wx.ColourOK
wx.Colour.OK()TrueCancel
wx.Colour.OK()False
9.2.4
wxPython
wx.lib.imagebrowser.ImageDialog9.10
9.10
9.10
import wx
import wx.lib.imagebrowser as imagebrowser
if __name__ == ”__main__”:
app = wx.PySimpleApp()
dialog = imagebrowser.ImageDialog(None)
if dialog.ShowModal() == wx.ID_OK:
print ”You Selected File: ” + dialog.GetFile()
dialog.Destroy()
9.10
273 / 565

wx.lib.imagebrowser.ImageDialog
Python
ImageDialog(parent, set_dir=None)
set_dir
GetFile()
GetDirectory()
9.3
9.11
9.11
wxPythonwx.wizard.Wizard
wx.wizard.WizardPageSimplewx.wizard.WizardPage
wx.Panel
Nextwx.wizard.WizardPage
274 / 565

wx.wizard.WizardPageSimple
9.119.11
9.11
import wx
import wx.wizard
class TitledPage(wx.wizard.WizardPageSimple):#1
def __init__(self, parent, title):
wx.wizard.WizardPageSimple.__init__(self, parent)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.SetSizer(self.sizer)
titleText = wx.StaticText(self, -1, title)
titleText.SetFont(
wx.Font(18, wx.SWISS, wx.NORMAL, wx.BOLD))
self.sizer.Add(titleText, 0,
wx.ALIGN_CENTRE | wx.ALL, 5)
self.sizer.Add(wx.StaticLine(self, -1), 0,
wx.EXPAND | wx.ALL, 5)
if __name__ == ”__main__”:
app = wx.PySimpleApp()
wizard = wx.wizard.Wizard(None, -1, ”Simple Wizard”)#
#
page1 = TitledPage(wizard, ”Page 1”)
page2 = TitledPage(wizard, ”Page 2”)
page3 = TitledPage(wizard, ”Page 3”)
page4 = TitledPage(wizard, ”Page 4”)
page1.sizer.Add(wx.StaticText(page1, -1,
”Testing the wizard”))
page4.sizer.Add(wx.StaticText(page4, -1,
”This is the last page.”))
#2
wx.wizard.WizardPageSimple_Chain(page1, page2)
wx.wizard.WizardPageSimple_Chain(page2, page3)
wx.wizard.WizardPageSimple_Chain(page3, page4)
275 / 565

wizard.FitToPage(page1)#3
if wizard.RunWizard(page1):#4
print ”Success”
wizard.Destroy()
#1
#2 wx.wizard.WizardPageSimple_Chain()
SetNext()SetPrev()
#3 FitToSize()
#4
Finish
RunWizard()True
wx.wizard.Wizard
wx.wizard.Wizard(parent, id=-1, title=wx.EmptyString,
bitmap=wx.NullBitmap, pos=wx.DefaultPosition)
parent, id, title, poswx.Panelbitmap
wx.wizard.WIZARD_EX_HELPBUTTON
8
9.11#3FitToSize()
wx.SizeSetPageSize()
GetPageSize()
GetCurrentPage()
NoneHasNextPage()
HasPrevPage()
276 / 565

RunWizard()9.11#4
9.5
wx.wizard.WizardEvent
GetPage()wx.WizardPage
GetDirection()
TrueGetDirection()False
9.5 wx.wizard.WizardDialog
EVT_WIZARD_CANCELCancelVeto()
EVT_WIZARD_FINISHED Finish
EVT_WIZARD_HELPHelp
EVT_WIZARD_PAGE_CHANGED
EVT_WIZARD_PAGE_CHANGING
wx.wizard.WizardPageSimple
wx.wizard.WizardPageSimple(parent=None, prev=None, next=None)
SetPrev()SetNext()
wx.wizard.WizardPageSimple_Chain()
wx.wizard.WizardPage
wx.WizardPage(parent, bitmap=wx.NullBitmap, resource=None)
bitmap
resourcewxPython
277 / 565

GetPrev()GetNext()
9.4
wxPython9.12
9.12
9.12
9.12
import wx
if __name__ == ”__main__”:
app = wx.PySimpleApp()
provider = wx.CreateFileTipProvider(“tips.txt”, 0)
wx.ShowTip(None, provider, True)
wx.TipProvider
wx.CreateFileTipProvider(filename, currentTip)
278 / 565

filenamecurrentTip
0
#
You can do startup tips very easily.
Feel the force, Luke.
providerwx.PyTipProvider
wx.TipProviderGetTip()
wx.ShowTip():
wx.ShowTip(parent, tipProvider, showAtStartup)
parenttipProvider
wx.CreateFileTipProvidershowAtStartup
9.5 validator
wxPython
wxPython
1
2
3
9.5.1
wx.Validator
C++ wxWidgetwxPython
279 / 565

PythonPython
wx.PyValidator
Clone()
SetValidator(validator)
Validate(parent)
parent
self.GetWindow()
Validate(parent)True
FalseValidate()
x.MessageBox()wxPython
Validate()OK
wx.ID_OK IDOK
wxPythonValidate()
False9.13
9.13
import wx
about_txt = ”””\
The validator used in this example will ensure that the text
controls are not empty when you press the Ok button, and
will not let you leave if any of the Validations fail.”””
class NotEmptyValidator(wx.PyValidator):#
def __init__(self):
wx.PyValidator.__init__(self)
def Clone(self):
280 / 565

”””
Note that every validator must implement the Clone() method.
”””
return NotEmptyValidator()
def Validate(self, win):#1
textCtrl = self.GetWindow()
text = textCtrl.GetValue()
if len(text) == 0:
wx.MessageBox(“This field must contain some text!”, ”Error”)
textCtrl.SetBackgroundColour(“pink”)
textCtrl.SetFocus()
textCtrl.Refresh()
return False
else:
textCtrl.SetBackgroundColour(
wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOW))
textCtrl.Refresh()
return True
def TransferToWindow(self):
return True
def TransferFromWindow(self):
return True
class MyDialog(wx.Dialog):
def __init__(self):
wx.Dialog.__init__(self, None, -1, ”Validators: validating”)
# Create the text controls
about = wx.StaticText(self, -1, about_txt)
name_l = wx.StaticText(self, -1, ”Name:”)
email_l = wx.StaticText(self, -1, ”Email:”)
phone_l = wx.StaticText(self, -1, ”Phone:”)
#2
281 / 565

name_t = wx.TextCtrl(self, validator=NotEmptyValidator())
email_t = wx.TextCtrl(self, validator=NotEmptyValidator())
phone_t = wx.TextCtrl(self, validator=NotEmptyValidator())
# Use standard button IDs
okay = wx.Button(self, wx.ID_OK)
okay.SetDefault()
cancel = wx.Button(self, wx.ID_CANCEL)
# Layout with sizers
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(about, 0, wx.ALL, 5)
sizer.Add(wx.StaticLine(self), 0, wx.EXPAND|wx.ALL, 5)
fgs = wx.FlexGridSizer(3, 2, 5, 5)
fgs.Add(name_l, 0, wx.ALIGN_RIGHT)
fgs.Add(name_t, 0, wx.EXPAND)
fgs.Add(email_l, 0, wx.ALIGN_RIGHT)
fgs.Add(email_t, 0, wx.EXPAND)
fgs.Add(phone_l, 0, wx.ALIGN_RIGHT)
fgs.Add(phone_t, 0, wx.EXPAND)
fgs.AddGrowableCol(1)
sizer.Add(fgs, 0, wx.EXPAND|wx.ALL, 5)
btns = wx.StdDialogButtonSizer()
btns.AddButton(okay)
btns.AddButton(cancel)
btns.Realize()
sizer.Add(btns, 0, wx.EXPAND|wx.ALL, 5)
self.SetSizer(sizer)
sizer.Fit(self)
app = wx.PySimpleApp()
dlg = MyDialog()
dlg.ShowModal()
dlg.Destroy()
282 / 565

app.MainLoop()
#1
9.13
#2
9.13
wxPython
Validate()
wx.WS_EX_VALIDATE_RECURSIVELY
Validate()ValidateFalse
9.5.2
9.14
283 / 565

9.14
TransferToWindow()
TransferFromWindow()OK
9.14
TransferToWindow()
TransferFromWindow()
9.14
import wx
import pprint
about_txt = ”””\
The validator used in this example shows how the validator
can be used to transfer data to and from each text control
automatically when the dialog is shown and dismissed.”””
class DataXferValidator(wx.PyValidator):#
284 / 565

def __init__(self, data, key):
wx.PyValidator.__init__(self)
self.data = data
self.key = key
def Clone(self):
”””
Note that every validator must implement the Clone() method.
”””
return DataXferValidator(self.data, self.key)
def Validate(self, win):#
return True
def TransferToWindow(self):#
textCtrl = self.GetWindow()
textCtrl.SetValue(self.data.get(self.key, ””))
return True
def TransferFromWindow(self):#
textCtrl = self.GetWindow()
self.data[self.key] = textCtrl.GetValue()
return True
class MyDialog(wx.Dialog):
def __init__(self, data):
wx.Dialog.__init__(self, None, -1, ”Validators: data transfer”)
# Create the text controls
about = wx.StaticText(self, -1, about_txt)
name_l = wx.StaticText(self, -1, ”Name:”)
email_l = wx.StaticText(self, -1, ”Email:”)
phone_l = wx.StaticText(self, -1, ”Phone:”)
#
name_t = wx.TextCtrl(self, validator=DataXferValidator(data, ”name”))
email_t = wx.TextCtrl(self, validator=DataXferValidator(data, ”email”))
phone_t = wx.TextCtrl(self, validator=DataXferValidator(data, ”phone”))
285 / 565

# Use standard button IDs
okay = wx.Button(self, wx.ID_OK)
okay.SetDefault()
cancel = wx.Button(self, wx.ID_CANCEL)
# Layout with sizers
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(about, 0, wx.ALL, 5)
sizer.Add(wx.StaticLine(self), 0, wx.EXPAND|wx.ALL, 5)
fgs = wx.FlexGridSizer(3, 2, 5, 5)
fgs.Add(name_l, 0, wx.ALIGN_RIGHT)
fgs.Add(name_t, 0, wx.EXPAND)
fgs.Add(email_l, 0, wx.ALIGN_RIGHT)
fgs.Add(email_t, 0, wx.EXPAND)
fgs.Add(phone_l, 0, wx.ALIGN_RIGHT)
fgs.Add(phone_t, 0, wx.EXPAND)
fgs.AddGrowableCol(1)
sizer.Add(fgs, 0, wx.EXPAND|wx.ALL, 5)
btns = wx.StdDialogButtonSizer()
btns.AddButton(okay)
btns.AddButton(cancel)
btns.Realize()
sizer.Add(btns, 0, wx.EXPAND|wx.ALL, 5)
self.SetSizer(sizer)
sizer.Fit(self)
app = wx.PySimpleApp()
data = { ”name” : ”Jordyn Dunn” }
dlg = MyDialog(data)
dlg.ShowModal()
dlg.Destroy()
wx.MessageBox(“You entered these values:\n\n” +
pprint.pformat(data))
286 / 565

app.MainLoop()
TransDataFromWindow()
TransferDataToWindow()
wx.WS_EX_VALIDATE_RECURSIVELY
9.5.3
9.12
9.15
self.Bind(wx.EVT_CHAR, self.OnChar)
9.15
9.15
import wx
import string
287 / 565

about_txt = ”””\
The validator used in this example will validate the input on the fly
instead of waiting until the okay button is pressed. The first field
will not allow digits to be typed, the second will allow anything
and the third will not allow alphabetic characters to be entered.
“””
class CharValidator(wx.PyValidator):
def __init__(self, flag):
wx.PyValidator.__init__(self)
self.flag = flag
self.Bind(wx.EVT_CHAR, self.OnChar)#
def Clone(self):
”””
Note that every validator must implement the Clone() method.
”””
return CharValidator(self.flag)
def Validate(self, win):
return True
def TransferToWindow(self):
return True
def TransferFromWindow(self):
return True
def OnChar(self, evt):#
key = chr(evt.GetKeyCode())
if self.flag == ”no-alpha” and key in string.letters:
return
if self.flag == ”no-digit” and key in string.digits:
return
evt.Skip()
class MyDialog(wx.Dialog):
def __init__(self):
288 / 565

wx.Dialog.__init__(self, None, -1, ”Validators: behavior modification”)
# Create the text controls
about = wx.StaticText(self, -1, about_txt)
name_l = wx.StaticText(self, -1, ”Name:”)
email_l = wx.StaticText(self, -1, ”Email:”)
phone_l = wx.StaticText(self, -1, ”Phone:”)
#
name_t = wx.TextCtrl(self, validator=CharValidator(“no-digit”))
email_t = wx.TextCtrl(self, validator=CharValidator(“any”))
phone_t = wx.TextCtrl(self, validator=CharValidator(“no-alpha”))
# Use standard button IDs
okay = wx.Button(self, wx.ID_OK)
okay.SetDefault()
cancel = wx.Button(self, wx.ID_CANCEL)
# Layout with sizers
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(about, 0, wx.ALL, 5)
sizer.Add(wx.StaticLine(self), 0, wx.EXPAND|wx.ALL, 5)
fgs = wx.FlexGridSizer(3, 2, 5, 5)
fgs.Add(name_l, 0, wx.ALIGN_RIGHT)
fgs.Add(name_t, 0, wx.EXPAND)
fgs.Add(email_l, 0, wx.ALIGN_RIGHT)
fgs.Add(email_t, 0, wx.EXPAND)
fgs.Add(phone_l, 0, wx.ALIGN_RIGHT)
fgs.Add(phone_t, 0, wx.EXPAND)
fgs.AddGrowableCol(1)
sizer.Add(fgs, 0, wx.EXPAND|wx.ALL, 5)
btns = wx.StdDialogButtonSizer()
btns.AddButton(okay)
btns.AddButton(cancel)
btns.Realize()
sizer.Add(btns, 0, wx.EXPAND|wx.ALL, 5)
self.SetSizer(sizer)
289 / 565

sizer.Fit(self)
app = wx.PySimpleApp()
dlg = MyDialog()
dlg.ShowModal()
dlg.Destroy()
app.MainLoop()
OnChar()
Skip()
Skip()
Skip()
wx.EVT_CHAR
wxPython
9.6
1
wxPython
wx.Dialog
2
ShowModal()
OKCancel
3wxPythonwx.MessageDialog
wx.TextEntryDialogwx.SingleChoiceDialog
4wx.ProgressDialog
wx.FileDialog
290 / 565

wx.DirDialog
5wx.FontDialogwx.ColorDialog
6wxPython
wx.lib.imagebrowser.ImageDialog
7wx.wizard.Wizard
wx.wizard.WizardSimplePage
wx.wizard.WizardPagewx.wizard.WizardSimplePage
wx.wizard.WizardPage
8wx.CreateFileTipProviderwx.ShowTip
9
291 / 565

10wxPython
FileEditHelp
wxPythonwx.MenuBar
wx.Menu
wx.MenuBarwx.Menuwx.MenuItem
wx.Menu
5.5
7
wxPython
10.1
·
·
·
·
·
·
·
292 / 565

5
10.1.1
wx.MenuBar
wx.MenuBar()
SetMenuBar()
wx.Frame__init__OnInit()
menubar = wx.MenuBar()
self.SetMenuBar
wx.Frame.GetMenuBar()
10.1.2
wxPython
wx.Menu
wx.Menu(title=””, style=0)
wx.MenuGTKwx.MENU_TEAROFF
10.1
10.1
293 / 565

10.1
10.1
import wx
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”Simple Menu Example”)
p = wx.Panel(self)
menuBar = wx.MenuBar()#
menu = wx.Menu()#
menuBar.Append(menu, ”Left Menu”)#
menu2 = wx.Menu()
menuBar.Append(menu2, ”Middle Menu”)
menu3 = wx.Menu()
menuBar.Append(menu3, ”Right Menu”)
self.SetMenuBar(menuBar)
if __name__ == ”__main__”:
app = wx.PySimpleApp()
frame = MyFrame()
frame.Show()
app.MainLoop()
wxPythonAPI
wx.Menu
294 / 565

wx.Menuwx.MenuBar
10.1wx.MenuBar
10.1 wx.MenuBar
Append(menu, title)menutitle
TrueFalse
Insert(pos, menu, title)menupos
GetMenu(pos) == menu
0pos0
GetMenuCount()posAppendtitle
True
Remove(pos)pos
Replace(pos, menu, title)menutitlepos
wx.MenuBar
10.2
10.2 wx.MenuBar
EnableTop(pos, enable)pos/enable
TrueFalse
GetMenu(pos)
GetMenuCount()
FindMenu(title)title
wx.NOT_FOUND
GetLabelTop(pos)
SetLabelTop(pos, label)
295 / 565

10.1.3
wx.MenuAppend()
Append(id, string, helpStr=””, kind=wx.ITEM_NORMAL)
idwxPython IDstring
helpStr
kind
Append
10.2 Append()
10.2
import wx
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”Simple Menu Example”)
p = wx.Panel(self)
self.CreateStatusBar()
menu = wx.Menu()
simple = menu.Append(-1, ”Simple menu item”, ”This is some help text”)
menu.AppendSeparator()
exit = menu.Append(-1, ”Exit”)
self.Bind(wx.EVT_MENU, self.OnSimple, simple)
self.Bind(wx.EVT_MENU, self.OnExit, exit)
menuBar = wx.MenuBar()
menuBar.Append(menu, ”Simple Menu”)
self.SetMenuBar(menuBar)
def OnSimple(self, event):
wx.MessageBox(“You selected the simple menu item”)
def OnExit(self, event):
self.Close()
296 / 565

if __name__ == ”__main__”:
app = wx.PySimpleApp()
frame = MyFrame()
frame.Show()
app.MainLoop()
10.2
10.2
Append()
·Prepend(id, string, helpStr=””, kind=wx.ITEM_NORMAL)
·PrependSeparator()
insert
·Insert(pos, id, string, helpStr=””, kind=wx.ITEM_NORMAL)
·InsertSeparator(pos)
pos0
297 / 565

wx.MenuItem
wx.MenuItem
wx.MenuItem(parentMenu=None, id=ID_ANY, text=””,
helpString=””, kind=wx.ITEM_NORMAL, subMenu=None)
parentMenuwx.Menu
wxPythonid
texthelpString
kind
wx.ITEM_NORMAL
subMenunull
10.3
wx.Menu
·AppendItem(aMenuItem)
·InsertItem(pos, aMenuItem)
·PrependItem(aMenuItem)
Remove(id)
wxPython IDRemoveItem(item)
Remove()
wx.Menuget*
GetMenuItemCount()GetMenuItems()
10.3
OnAddItem()
298 / 565

10.3
import wx
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”Add Menu Items”)
p = wx.Panel(self)
self.txt = wx.TextCtrl(p, -1, ”new item”)
btn = wx.Button(p, -1, ”Add Menu Item”)
self.Bind(wx.EVT_BUTTON, self.OnAddItem, btn)#
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(self.txt, 0, wx.ALL, 20)
sizer.Add(btn, 0, wx.TOP|wx.RIGHT, 20)
p.SetSizer(sizer)
self.menu = menu = wx.Menu()
simple = menu.Append(-1, ”Simple menu item”)
menu.AppendSeparator()
exit = menu.Append(-1, ”Exit”)
self.Bind(wx.EVT_MENU, self.OnSimple, simple)
self.Bind(wx.EVT_MENU, self.OnExit, exit)
menuBar = wx.MenuBar()
menuBar.Append(menu, ”Menu”)
self.SetMenuBar(menuBar)
def OnSimple(self, event):
wx.MessageBox(“You selected the simple menu item”)
def OnExit(self, event):
self.Close()
def OnAddItem(self, event):
item = self.menu.Append(-1, self.txt.GetValue())#
self.Bind(wx.EVT_MENU, self.OnNewItemSelected, item)#
299 / 565

def OnNewItemSelected(self, event):
wx.MessageBox(“You selected a new item”)
if __name__ == ”__main__”:
app = wx.PySimpleApp()
frame = MyFrame()
frame.Show()
app.MainLoop()
OnAddItem()Append()
10.1.4
8
wx.CommandEventwx.EVT_MENU
Bind()
wx.EVT_MENUBind()
self.Bind(wx.EVT_MENU, self.OnExit, exit_menu_item)
selfself.OnExitexit_menu_item
wxPython ID
wx.EVT_MENUBind()
300 / 565

wx.EVT_MENU_RANGE
self.Bind(wx.EVT_MENU_RANGE, function, id=menu1, id2=menu2)
[menu1,menu2]
wxPythonwx.MenuEvent10.3
wx.MenuEvent
10.3 wx.MenuEvent
EVT_MENU_CLOSE
EVT_MENU_HIGHLIGHT
ID
EVT_MENU_HIGHLIGHT_ALL
ID——
EVT_MENU_OPEN
10.2
10.2.1
wxPython
301 / 565

10.1
FindItemById()
10.4
import wx
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”Find Item Example”)
p = wx.Panel(self)
self.txt = wx.TextCtrl(p, -1, ”new item”)
btn = wx.Button(p, -1, ”Add Menu Item”)
self.Bind(wx.EVT_BUTTON, self.OnAddItem, btn)
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(self.txt, 0, wx.ALL, 20)
sizer.Add(btn, 0, wx.TOP|wx.RIGHT, 20)
p.SetSizer(sizer)
self.menu = menu = wx.Menu()
simple = menu.Append(-1, ”Simple menu item”)
menu.AppendSeparator()
exit = menu.Append(-1, ”Exit”)
self.Bind(wx.EVT_MENU, self.OnSimple, simple)
self.Bind(wx.EVT_MENU, self.OnExit, exit)
menuBar = wx.MenuBar()
menuBar.Append(menu, ”Menu”)
self.SetMenuBar(menuBar)
def OnSimple(self, event):
wx.MessageBox(“You selected the simple menu item”)
def OnExit(self, event):
self.Close()
def OnAddItem(self, event):
item = self.menu.Append(-1, self.txt.GetValue())
302 / 565

self.Bind(wx.EVT_MENU, self.OnNewItemSelected, item)
def OnNewItemSelected(self, event):
item = self.GetMenuBar().FindItemById(event.GetId()) #
text = item.GetText()
wx.MessageBox(“You selected the ’%s’ item” % text)
if __name__ == ”__main__”:
app = wx.PySimpleApp()
frame = MyFrame()
frame.Show()
app.MainLoop()
FindItemById()
wx.MenuBarwx.Menu
wx.MenuBarwx.Menu
wx.MenuBar
wx.Frame.GetMenuBar()
FindMenu(title)
wx.NOT_FOUND
GetMenu()
def FindMenuInMenuBar(menuBar, title):
pos = menuBar.FindMenu(title)
if pos == wx.NOT_FOUND:
return None
return menuBar.GetMenu(pos)
FindMenutitle
&FileFindMenu(“File”)
10.4wx.MenuBar
303 / 565

10.4 wx.MenuBar
FindMenuItem(menuString,itemString)menuString
itemStringwx.NOT_FOUND
FindItemById(id)wxPython
None
GetHelpString(id)
SetHelpString(id,helpString)id
get*""set*
GetLabel(id)
SetLabel(id, label)id
get*""set*
10.5 wx.Menu
10.5 wx.Menu
FindItem(itemString)itemStringwx.NOT_FOUND
FindItemById(id)wxPython
None
FindItemByPosition(pos)
GetHelpString(id)
SetHelpString(id,helpString)
GetLabel(id)
SetLabel(id, label)
10.2.2
304 / 565

10.5
IsEnabled()Enable()
10.5
import wx
ID_SIMPLE = wx.NewId()
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”Enable/Disable Menu Example”)
p = wx.Panel(self)
self.btn = wx.Button(p, -1, ”Disable Item”, (20,20))
self.Bind(wx.EVT_BUTTON, self.OnToggleItem, self.btn)
menu = wx.Menu()
menu.Append(ID_SIMPLE, ”Simple menu item”)
self.Bind(wx.EVT_MENU, self.OnSimple, id=ID_SIMPLE)
menu.AppendSeparator()
menu.Append(wx.ID_EXIT, ”Exit”)
self.Bind(wx.EVT_MENU, self.OnExit, id=wx.ID_EXIT)
menuBar = wx.MenuBar()
menuBar.Append(menu, ”Menu”)
self.SetMenuBar(menuBar)
def OnSimple(self, event):
wx.MessageBox(“You selected the simple menu item”)
def OnExit(self, event):
self.Close()
def OnToggleItem(self, event):
menubar = self.GetMenuBar()
enabled = menubar.IsEnabled(ID_SIMPLE)
menubar.Enable(ID_SIMPLE, not enabled)
305 / 565

self.btn.SetLabel(
(enabled and ”Enable” or ”Disable”) + ” Item”)
if __name__ == ”__main__”:
app = wx.PySimpleApp()
frame = MyFrame()
frame.Show()
app.MainLoop()
wx.MenuItem.IsEnabled()wx.MenuBar.IsEnabled(id)
wx.Menu.IsEnabled(id)wxPython
True
Falsewx.Menu
wx.MenuItem
wx.MenuBar.Enable(id, enable), wx.Menu.Enable(id,enable), wx.MenuItem.Enabl
e(enable)enableTrueFalse
Enable()IsEnabled()
wx.MenuBarEnableTop(pos,enable)
posenable
10.2.3
10.3
AcceleratedCtrl-A
306 / 565

10.3
10.6
10.6
import wx
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”Accelerator Example”)
p = wx.Panel(self)
menu = wx.Menu()
simple = menu.Append(-1, ”Simple &menu item”) # Creating a mnemonic
accel = menu.Append(-1, ”&Accelerated\tCtrl-A”) # Creating an accelerator
menu.AppendSeparator()
exit = menu.Append(-1, ”E&xit”)
self.Bind(wx.EVT_MENU, self.OnSimple, simple)
self.Bind(wx.EVT_MENU, self.OnAccelerated, accel)
self.Bind(wx.EVT_MENU, self.OnExit, exit)
menuBar = wx.MenuBar()
307 / 565

menuBar.Append(menu, ”&Menu”)
self.SetMenuBar(menuBar)
acceltbl = wx.AcceleratorTable( [ #Using an accelerator table
(wx.ACCEL_CTRL, ord(‘Q’), exit.GetId())
])
self.SetAcceleratorTable(acceltbl)
def OnSimple(self, event):
wx.MessageBox(“You selected the simple menu item”)
def OnAccelerated(self, event):
wx.MessageBox(“You selected the accelerated menu item”)
def OnExit(self, event):
self.Close()
if __name__ == ”__main__”:
app = wx.PySimpleApp()
frame = MyFrame()
frame.Show()
app.MainLoop()
wxPythonmnemonicsaccelerator
&&File, &EditMa&cros
&&&&&
Windowsalt
308 / 565

wxPython
\t\tAlt, Ctrl, Shift
+-New\tctrl-n, SaveAs
\tctrl-shift-s+-
F1~F1210.6
wxPython
menubar.FindMenuItem(“File”, ”SaveAs”)
Save asSave &As\tctrl-shift-s
wx.AccleratorTable
wx.AccelratorEntry
wx.AcceleratorTable
10.6wxPython
(wx.ACCEL_CTRL, ord(‘Q’)exit.GetId())wx.AcceleratorEntry
wx.AcceleratorEntry
wx.AcceleratorEntry(flags, keyCode, cmd)
flags
wx.ACCEL_ALT, wx.ACCEL_CTRL, wxACCEL_NORMAL
, wx.ACCEL_SHIFT
keyCode
ASCIIwxWidgetsKeycodescmd
wxPython
10.6
309 / 565

10.6
del Delete
delete Delete
down Down arrow
end End
enter Enter
esc Escape
escape Escape
home Home
ins Insert
insert Insert
left Left arrow
pgdn Page down
pgup Page Up
return Enter
right Right arrow
space Space bar
tab Tab
up Up arrow
10.2.4
10.4
310 / 565

10.4
10.7
10.7
import wx
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”Toggle Items Example”)
p = wx.Panel(self)
menuBar = wx.MenuBar()
menu = wx.Menu()
exit = menu.Append(-1, ”Exit”)
self.Bind(wx.EVT_MENU, self.OnExit, exit)
menuBar.Append(menu, ”Menu”)
menu = wx.Menu()
menu.AppendCheckItem(-1, ”Check Item 1”)
menu.AppendCheckItem(-1, ”Check Item 2”)
311 / 565

menu.AppendCheckItem(-1, ”Check Item 3”)
menu.AppendSeparator()
menu.AppendRadioItem(-1, ”Radio Item 1”)
menu.AppendRadioItem(-1, ”Radio Item 2”)
menu.AppendRadioItem(-1, ”Radio Item 3”)
menuBar.Append(menu, ”Toggle Items”)
self.SetMenuBar(menuBar)
def OnExit(self, event):
self.Close()
if __name__ == ”__main__”:
app = wx.PySimpleApp()
frame = MyFrame()
frame.Show()
app.MainLoop()
AppendCheckItem(id, item, helpString=””)
Append()wxPython
PrependCheckItem(id,item, helpString=””)
InsertCheckItem(pos, id, item, helpString=””)
AppendRadioItem(id,item,helpString=””)
PrependRadioItem(id,item, helpString=””)
InsertRadioItem(pos, id, item, helpString=””)
Append()Append()kind
wx.ITEM_CHECK, wx.ITEM_NORMAL, wx.ITEM_RADIO
wx.ITEM_SEPARATOR
kindwx.ITEM_SEPARATOR
idwx.ID_SEPARATOR
312 / 565

wx.MenuItem
kind
AppendItem(), PrependItem(), InsertItem()
IsCheckable()
TrueIsChecked()
TrueCheck(check)
checkCheck(check)
IsChecked(id)
idCheck(id, check)
check
10.3
10.3.1
10.5
313 / 565

10.5
10.810.5
10.8
import wx
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”Sub-menu Example”)
p = wx.Panel(self)
menu = wx.Menu()
submenu = wx.Menu()
submenu.Append(-1, ”Sub-item 1”)
submenu.Append(-1, ”Sub-item 2”)
menu.AppendMenu(-1, ”Sub-menu”, submenu)#
menu.AppendSeparator()
exit = menu.Append(-1, ”Exit”)
self.Bind(wx.EVT_MENU, self.OnExit, exit)
menuBar = wx.MenuBar()
menuBar.Append(menu, ”Menu”)
self.SetMenuBar(menuBar)
314 / 565

def OnExit(self, event):
self.Close()
if __name__ == ”__main__”:
app = wx.PySimpleApp()
frame = MyFrame()
frame.Show()
app.MainLoop()
10.8
wx.Menu
AppendMenu(id, text, submenu, helpStr)
Append()id
wxPythontext
submenuhelpStr
PrependMenu(id,text, submenu, helpStr)
InsertMenu(pos, text, submenu, helpStr)
wxPython
10.3.2
10.6
315 / 565

10.6
10.9
10.9
import wx
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”Popup Menu Example”)
self.panel = p = wx.Panel(self)
menu = wx.Menu()
exit = menu.Append(-1, ”Exit”)
self.Bind(wx.EVT_MENU, self.OnExit, exit)
menuBar = wx.MenuBar()
menuBar.Append(menu, ”Menu”)
self.SetMenuBar(menuBar)
wx.StaticText(p, -1,
”Right-click on the panel to show a popup menu”,
(25,25))
self.popupmenu = wx.Menu()#
for text in ”one two three four five”.split():#
316 / 565

item = self.popupmenu.Append(-1, text)
self.Bind(wx.EVT_MENU, self.OnPopupItemSelected, item)
p.Bind(wx.EVT_CONTEXT_MENU, self.OnShowPopup)#
def OnShowPopup(self, event):#
pos = event.GetPosition()
pos = self.panel.ScreenToClient(pos)
self.panel.PopupMenu(self.popupmenu, pos)
def OnPopupItemSelected(self, event):
item = self.popupmenu.FindItemById(event.GetId())
text = item.GetText()
wx.MessageBox(“You selected item ’%s’” % text)
def OnExit(self, event):
self.Close()
if __name__ == ”__main__”:
app = wx.PySimpleApp()
frame = MyFrame()
frame.Show()
app.MainLoop()
for
self.popupmenu
OnShowPopup()wx.EVT_CONTEXT_MENU
WindowsGTK
Mac OScontrol
OnShowPopup()
wx.EVT_CONTEXT_MENU
ScreenToClient()
317 / 565

PopupMenu(menu, pos)
PopupMenuXY(menu, x, y)PopupMenu
Esc
EVT_MENUPopupMenu
PopupMenu
wx.Menu.SetTitle(title)wx.Menu.GetTitle()
10.3.3
Windows
10.7
10.7
10.10Windows
‘wxMSW’wx.PlatformInfo
10.10
import wx
class MyFrame(wx.Frame):
def __init__(self):
318 / 565

wx.Frame.__init__(self, None, -1,
”Fancier Menu Example”)
p = wx.Panel(self)
menu = wx.Menu()
bmp = wx.Bitmap(“open.png”, wx.BITMAP_TYPE_PNG)
item = wx.MenuItem(menu, -1, ”Has Open Bitmap”)
item.SetBitmap(bmp)#
menu.AppendItem(item)
if True or ’wxMSW’ in wx.PlatformInfo:
font = wx.SystemSettings.GetFont(
wx.SYS_DEFAULT_GUI_FONT)
font.SetWeight(wx.BOLD)
item = wx.MenuItem(menu, -1, ”Has Bold Font”)
item.SetFont(font)#
menu.AppendItem(item)
item = wx.MenuItem(menu, -1, ”Has Red Text”)
item.SetTextColour(“red”)#
menu.AppendItem(item)
menu.AppendSeparator()
exit = menu.Append(-1, ”Exit”)
self.Bind(wx.EVT_MENU, self.OnExit, exit)
menuBar = wx.MenuBar()
menuBar.Append(menu, ”Menu”)
self.SetMenuBar(menuBar)
def OnExit(self, event):
self.Close()
if __name__ == ”__main__”:
app = wx.PySimpleApp()
frame = MyFrame()
frame.Show()
319 / 565

app.MainLoop()
WindowsWindows)bitmapGetBitmap()
wx.Bitmapset*
SetBitmap(bmp)
Windows
SetBitmaps(checked, unchecked=wx.NullBitmap)
checked
Windws
10.7
10.7
GetBackgroundColour()
SetBackgroundColour(colour)wx.Colourset*
wxPython
GetFont()
SetFont(font)wx.Font
GetTextColour()
SetTextColour(colour)
10.4
320 / 565

10.4.1
1015
10.4.2
——
FILE
newopensaveprint
quit
EDITundocutcopy
pastefind
HELPwindows
30~40
...
321 / 565

10.8
10.8
Ctrl-a
Ctrl-c
Ctrl-f
Ctrl-g
Ctrl-n
Ctrl-o
Ctrl-p
Ctrl-q
Ctrl-s
Ctrl-v
Ctrl-w
Ctrl-x
Ctrl-z
RedoCtrlyAlt-z
fancy mode on
fancy
Turn fancy mode offfancy
toggle fancy mode
switch fancy mode (now on)
322 / 565

10.5
·wxPython
wx.MenuBar
wx.Menuwx.MenuItem
·wx.EVT_MENU
wx.EVT_MENU
wx.EVT_MENU_RANGE
·ID
·
wx.Menu
·
·
323 / 565

·wx.EVT_CONTEXT_MENU
PopupMenu()
·Windows
324 / 565

11 sizer
·sizer
·sizer
·sizergrid
·box sizer
·sizer
sizersizer
sizer
sizersizer
sizersizer
sizersizer
sizersizer——
grid bagbox
11.1 sizer
wxPython sizer
sizer
sizerwx.SizerwxPython5
sizer11.1sizersizer
11.1 wxPythonsizer
Grid
Flex gridgrid sizer
325 / 565

Grid baggrid sizer
Box
Static boxbox sizer
gridbox,wxPython
gridbox
sizersizer
sizer
wxPythonsizer
sizer
·sizersizerwx.Window
SetSizer(sizer)wx.Window
wxPythonsizersizer
·sizer
sizer
sizerAdd()Add()
·sizersizer
wx.WindowFit()sizer
Fit(window)sizer
Fit()sizer
FitInside()
——
wxPython
sizersizer
grid sizer
sizergrid sizergrid sizer
326 / 565

sizer
11.2 sizergrid sizer
sizer11.1
——
11.1
import wx
class BlockWindow(wx.Panel):
def __init__(self, parent, ID=-1, label=””,
pos=wx.DefaultPosition, size=(100, 25)):
wx.Panel.__init__(self, parent, ID, pos, size,
wx.RAISED_BORDER, label)
self.label = label
self.SetBackgroundColour(“white”)
self.SetMinSize(size)
self.Bind(wx.EVT_PAINT, self.OnPaint)
def OnPaint(self, evt):
sz = self.GetClientSize()
dc = wx.PaintDC(self)
w,h = dc.GetTextExtent(self.label)
dc.SetFont(self.GetFont())
dc.DrawText(self.label, (sz.width-w)/2, (sz.height-h)/2)
sizer
grid sizer
11.2.1 grid sizer
wxPythonsizergridgrid sizer
sizer
327 / 565

11.1
3*3
11.1
grid sizer
11.2
11.2
11.211.111.2
11.2 grid sizer
import wx
from blockwindow import BlockWindow
labels = ”one two three four five six seven eight nine”.split()
328 / 565

class GridSizerFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”Basic Grid Sizer”)
sizer = wx.GridSizer(rows=3, cols=3, hgap=5, vgap=5)#grid sizer
for label in labels:
bw = BlockWindow(self, label=label)
sizer.Add(bw, 0, 0)#sizer
self.SetSizer(sizer)#sizer
self.Fit()
app = wx.PySimpleApp()
GridSizerFrame().Show()
app.MainLoop()
11.2grid sizerwx.GridSizer
grid sizer
wx.GridSizer(rows, cols, vgap, hgap)
rowscols——
0
sizerwx.GridSizer(2, 0, 0, 0)sizer
vgaphgapvgap
hgapvgap
rows, cols, vgap, hgapget*set*——
GetRows(), SetRows(rows), GetCols(),SetCols(cols), GetVGap(), SetVGap(gap), Get
HGap(), SetHGap(gap)
grid sizerFit()
grid——
grid sizer
grid sizergrid
flex grid sizergrid bag sizer
329 / 565

11.2.2 sizer
sizer
sizer
grid sizer
sizer
sizerAdd()
sizer“sizer”
sizer
Add()
Add(window, proportion=0, flag=0, border=0, userData=None)
Add(sizer, proportion=0, flag=0, border=0, userData=None)
Add(size, proportion=0, flag=0, border=0, userData=None)
sizersizer——
box sizersizerwx.Size
sizer
box sizersizer
sizersizer
proportionbox sizer
box sizer
flag
flagborder
sizeruserData
sizer
330 / 565

sizerinsert()
Insert(index, window, proportion=0, flag=0, border=0, userData=None)
Insert(index, sizer, proportion=0, flag=0, border=0, userData=None)
Insert(index, size, proportion=0, flag=0, border=0, userData=None)
sizersizer
Prepend(window, proportion=0, flag=0, border=0, userData=None)
Prepend(sizer, proportion=0, flag=0, border=0, userData=None)
Prepend(size, proportion=0, flag=0, border=0, userData=None)
11.3
11.311.1Add()Prepend()
sizersizer
sizerLayout()sizer
Detach()
sizerDetach()sizer
Detach()
sizer
Detach()
Detach(window)
331 / 565

Detach(sizer)
Detach(index)
Detach()
——sizerfalse
Detach()
sizerLayout()
sizerwx.Window
GetContainingSizer()sizer
None
11.2.3 sizer
sizersizer
sizer
sizersizer
sizer
sizerflag
11.4
grid sizer
332 / 565

11.4
11.311.4sizer
11.3 grid sizer
import wx
from blockwindow import BlockWindow
labels = ”one two three four five six seven eight nine”.split()
#
flags = {“one”: wx.ALIGN_BOTTOM, ”two”: wx.ALIGN_CENTER,
”four”: wx.ALIGN_RIGHT, ”six”: wx.EXPAND, ”seven”: wx.EXPAND,
”eight”: wx.SHAPED}
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”GridSizer Resizing”)
sizer = wx.GridSizer(rows=3, cols=3, hgap=5, vgap=5)
for label in labels:
bw = BlockWindow(self, label=label)
flag = flags.get(label, 0)
sizer.Add(bw, 0, flag)
self.SetSizer(sizer)
self.Fit()
app = wx.PySimpleApp()
TestFrame().Show()
333 / 565

app.MainLoop()
“one,” “two,” “four”
wx.ALIGN_BOTTOM, wx.ALIGN_CENTER, and wx.ALIGN_RIGHT
“three”
“six”“seven”wx.EXPAND
sizer“eight”wx.SHAPED
11.2flag
11.2
wx.ALIGN_BOTTOM
wx.ALIGN_CENTER
wx.ALIGN_CENTER_HORIZONTAL
wx.ALIGN_CENTER_VERTICAL
wx.ALIGN_LEFT
wx.ALIGN_TOP
wx.EXPAND
wx.FIXED_MINSIZE
wx.GROWwx.EXPAND
wx.SHAPED
|
wx.ALIGN_TOP | wx.ALIGN_RIGHT
wx.ALIGN_TOP | wx.ALIGN_BOTTOM
0
334 / 565

sizer
GetSize() GetPosition()sizer——
sizersizersizer
SetDimension(x, y, width, height)
sizersizer
11.2.4 sizer
sizersizer
sizer
sizer
11.5
11.5
11.4grid
SetMinSize()
11.4 grid sizer
import wx
from blockwindow import BlockWindow
labels = ”one two three four five six seven eight nine”.split()
class TestFrame(wx.Frame):
def __init__(self):
335 / 565

wx.Frame.__init__(self, None, -1, ”GridSizer Test”)
sizer = wx.GridSizer(rows=3, cols=3, hgap=5, vgap=5)
for label in labels:
bw = BlockWindow(self, label=label)
sizer.Add(bw, 0, 0)
center = self.FindWindowByName(“five”)
center.SetMinSize((150,50))
self.SetSizer(sizer)
self.Fit()
app = wx.PySimpleApp()
TestFrame().Show()
app.MainLoop()
sizer
“
”sizer
SetMinSize(width, height)
SetSizeHints(minW, minH, maxW, maxH)——
sizersizer
GetMinSize()sizersizer
SetMinSize(width,height)
wx.Size——SetMinSize(size)wxPython
wx.SizeGetMinSize()
sizersizer
SetItemMinSize()
SetItemMinSize(window, size)
SetItemMinSize(sizer, size)
SetItemMinSize(index, size)
336 / 565

windowsizersizer
sizerindexsizer
sizewx.Size()sizer
sizer
SetSizeHints()
11.2.5 sizer
wxPython sizer
sizer
sizer
11.610
11.6
11.511.6grid sizer
Add()10
11.5 grid sizer
import wx
from blockwindow import BlockWindow
labels = ”one two three four five six seven eight nine”.split()
#
flags = {“one”: wx.BOTTOM, ”two”: wx.ALL, ”three”: wx.TOP,
337 / 565

”four”: wx.LEFT, ”five”: wx.ALL, ”six”: wx.RIGHT,
”seven”: wx.BOTTOM | wx.TOP, ”eight”: wx.ALL,
”nine”: wx.LEFT | wx.RIGHT}
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”GridSizer Borders”)
sizer = wx.GridSizer(rows=3, cols=3, hgap=5, vgap=5)
for label in labels:
bw = BlockWindow(self, label=label)
flag = flags.get(label, 0)
sizer.Add(bw, 0, flag, 10)#
self.SetSizer(sizer)
self.Fit()
app = wx.PySimpleApp()
TestFrame().Show()
app.MainLoop()
sizer
sizerflagswx.ALL
wx.BOTTOM, wx.LEFT, wx.RIGHT, wx.TOP
wx.RIGHT | wx.BOTTOM
flags
flags
bordersizer
5
sizer.Add(widget, 0, wx.ALL | wx.EXPAND, 5)
5
338 / 565

11.3 sizer
sizersizer
flex grid sizergrid bag sizergrid
boxstatic box sizer
11.3.1 flex grid sizer
flex grid sizergrid sizergrid sizer
1
2
3
11.7flex grid sizer9
11.7
11.511.5
flex grid sizer
“four”“six”
“five”“two”“seven”
“one,” “three,” “seven,” “nine”
11.8flex grid sizer——
339 / 565

11.8
11.611.8
11.6 flex grid sizer
import wx
from blockwindow import BlockWindow
labels = ”one two three four five six seven eight nine”.split()
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”FlexGridSizer”)
sizer = wx.FlexGridSizer(rows=3, cols=3, hgap=5, vgap=5)
for label in labels:
bw = BlockWindow(self, label=label)
sizer.Add(bw, 0, 0)
center = self.FindWindowByName(“five”)
center.SetMinSize((150,50))
self.SetSizer(sizer)
self.Fit()
app = wx.PySimpleApp()
TestFrame().Show()
app.MainLoop()
flex grid sizerwx.FlexGridSizerwx.FlexGridSizer
wx.GridSizerwx.GridSizerwx.FlexGridSizer
340 / 565

wx.FlexGridSizer(rows, cols, vgap, hgap)
sizer
sizer
AddGrowableCol(idx, proportion=0)
AddGrowableRow(idx, proportion=0)
sizer
proportion
proportion
proportion
212/31/311.9
proportionalflex grid sizer
251
11.9
sizerwx.EXPAND11.711.9
11.7
import wx
from blockwindow import BlockWindow
341 / 565

labels = ”one two three four five six seven eight nine”.split()
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”Resizing Flex Grid Sizer”)
sizer = wx.FlexGridSizer(rows=3, cols=3, hgap=5, vgap=5)
for label in labels:
bw = BlockWindow(self, label=label)
sizer.Add(bw, 0, 0)
center = self.FindWindowByName(“five”)
center.SetMinSize((150,50))
sizer.AddGrowableCol(0, 1)
sizer.AddGrowableCol(1, 2)
sizer.AddGrowableCol(2, 1)
sizer.AddGrowableRow(0, 1)
sizer.AddGrowableRow(1, 5)
sizer.AddGrowableRow(2, 1)
self.SetSizer(sizer)
self.Fit()
app = wx.PySimpleApp()
TestFrame().Show()
app.MainLoop()
flex grid sizer
AddGrowable*flex grid
SetFlexibleDirection(direction)
direction
wx.HORIZONTAL, wx.VERTICAL, wx.BOTH
SetNonFlexibleGrowMode(mode)
SetFlexibleDirection(wx.HORIZONTAL)
AddGrowableCol()SetNonFlexibleGrowMode()
11.3mode
342 / 565

11.3
wx.FLEX_GROWMODE_ALLflex gridSetFlexibleDirection*
AddGrowable*——
wx.FLEX_GROWMODE_NONESetFlexibleDirection*
wx.FLEX_GROWMODE_SPECIFIEDSetFlexibleDirection*
sizer
SetFlexibleDirectionSetNonFlexibleGrowMode
GetFlexibleDirection()GetNonFlexibleGrowMode()
AddGrowableCol()AddGrowableRow()
11.3.2 grid bag sizer
grid bag sizerflex grid sizergrid bag sizer
1
2HTML
11.10
11.10grid bag sizer
11.811.10Add()
343 / 565

11.8 Grid bag sizer
import wx
from blockwindow import BlockWindow
labels = ”one two three four five six seven eight nine”.split()
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”GridBagSizer Test”)
sizer = wx.GridBagSizer(hgap=5, vgap=5)
for col in range(3):
for row in range(3):
bw = BlockWindow(self, label=labels[row*3 + col])
sizer.Add(bw, pos=(row,col))
#
bw = BlockWindow(self, label=”span 3 rows”)
sizer.Add(bw, pos=(0,3), span=(3,1), flag=wx.EXPAND)
#
bw = BlockWindow(self, label=”span all columns”)
sizer.Add(bw, pos=(3,0), span=(1,4), flag=wx.EXPAND)
#
sizer.AddGrowableCol(3)
sizer.AddGrowableRow(3)
self.SetSizer(sizer)
self.Fit()
app = wx.PySimpleApp()
TestFrame().Show()
app.MainLoop()
344 / 565

grid bag sizerwx.GridBagSizerwx.GridBagSizer
wx.FlexGridSizerflex grid sizergrid bag sizer
wx.GridBagSizer
wx.GridBagSizer(vgap=0, hgap=0)
grid bag sizer
——sizer
grid bag sizerAdd()sizer
1 Add(window, pos, span=wx.DefaultSpan, flag=0, border=0,
userData=None)
2 Add(sizer, pos, span=wx.DefaultSpan, flag=0, border=0,
userData=None)
3 Add(size, pos, span=wx.DefaultSpan, flag=0, border=0,
userData=None)
4 AddItem(item)
sizer
window, sizer, size, flag, border, userDatasizer
possizerpos
wx.GBPositionwxPython
(,)grid bag(0,0)
span
wx.GBSpanwxPython(
)(1,1)
Add(widget, (1, 0), (3, 2))
0
345 / 565

Additemitemwx.GBSizerItem
grid bag sizer
wx.GBSizerItem
grid bag sizerAdd()wx.GBSizerItem
get*GetWindow()
grid bag sizer
sizer
11.4
grid bag sizer
11.4 Grid bag sizer
CheckForIntersection(item,excludeItem=None)
CheckForIntersection(pos,span, excludeItem=None)
sizer
TrueexcludeItem
poswx.GBPositionspan
wx.GPSpan
FindItem(window)
FindItem(sizer)sizerwx.GBSizerItem
sizergrid bagNonesizer
FindItemAtPoint(pt)ptwx.Point
Pythonwx.GBSizerItem
sizerNone
FindItemAtPosition(pos)wx.GBSizerItem
poswx.GBPositionPythonsizer
None
FindItemWithData(userData)grid baguserData
wx.GBSizerItem
Grid baggrid bag
GetCellSize(row, col)
sizer
GetEmptyCellSize()
SetEmptyCellSize(sz)szwx.Size
Python
346 / 565

GetItemPosition()GetItemSpan()grid bag
sizer
sizerAdd()grid bag
get*set*
SetItemPosition(window, pos)SetItemSpan(window, span)
window,sizer,indexPython
wx.GBPositionwx.GBSpan
11.3.3 box sizer
box sizerwxPythonsizersizer
box sizer
sizer
sizer
sizersizer
11.11-11.14box sizer
sizer
11.11box sizer11.12box sizer
11.11
11.11
11.12
347 / 565

11.13sizer
11.14sizer
11.13
11.14
sizer11.9
348 / 565

11.9 box sizer
import wx
from blockwindow import BlockWindow
labels = ”one two three four”.split()
class TestFrame(wx.Frame):
title = ”none”
def __init__(self):
wx.Frame.__init__(self, None, -1, self.title)
sizer = self.CreateSizerAndWindows()
self.SetSizer(sizer)
self.Fit()
class VBoxSizerFrame(TestFrame):
title = ”Vertical BoxSizer”
def CreateSizerAndWindows(self):
sizer = wx.BoxSizer(wx.VERTICAL)
for label in labels:
bw = BlockWindow(self, label=label, size=(200,30))
sizer.Add(bw, flag=wx.EXPAND)
return sizer
class HBoxSizerFrame(TestFrame):
title = ”Horizontal BoxSizer”
def CreateSizerAndWindows(self):
sizer = wx.BoxSizer(wx.HORIZONTAL)
for label in labels:
bw = BlockWindow(self, label=label, size=(75,30))
sizer.Add(bw, flag=wx.EXPAND)
return sizer
class VBoxSizerStretchableFrame(TestFrame):
title = ”Stretchable BoxSizer”
def CreateSizerAndWindows(self):
349 / 565

sizer = wx.BoxSizer(wx.VERTICAL)
for label in labels:
bw = BlockWindow(self, label=label, size=(200,30))
sizer.Add(bw, flag=wx.EXPAND)
# Add an item that takes all the free space
bw = BlockWindow(self, label=”gets all free space”, size=(200,30))
sizer.Add(bw, 1, flag=wx.EXPAND)
return sizer
class VBoxSizerMultiProportionalFrame(TestFrame):
title = ”Proportional BoxSizer”
def CreateSizerAndWindows(self):
sizer = wx.BoxSizer(wx.VERTICAL)
for label in labels:
bw = BlockWindow(self, label=label, size=(200,30))
sizer.Add(bw, flag=wx.EXPAND)
# Add an item that takes one share of the free space
bw = BlockWindow(self,
label=”gets 1/3 of the free space”,
size=(200,30))
sizer.Add(bw, 1, flag=wx.EXPAND)
# Add an item that takes 2 shares of the free space
bw = BlockWindow(self,
label=”gets 2/3 of the free space”,
size=(200,30))
sizer.Add(bw, 2, flag=wx.EXPAND)
return sizer
app = wx.PySimpleApp()
frameList = [VBoxSizerFrame, HBoxSizerFrame,
VBoxSizerStretchableFrame,
VBoxSizerMultiProportionalFrame]
for klass in frameList:
frame = klass()
frame.Show()
app.MainLoop()
350 / 565

ox sizerwx.BoxSizerwx.BoxSizerwx.Sizer
wx.Sizerwx.BoxSizerwx.BoxSizer
wx.BoxSizer(orient)
orientsizerwx.VERTICAL
wx.HORIZONTALbox sizer
GetOrientation()orientbox sizer
box sizer
sizer
box sizersizer
proportionsizer
wx.EXPANDsizer
box sizerAdd()
proportionsizer
proportionbox sizer
wx.EXPAND
box sizerwx.EXPAND
6.7
box sizerflex grid sizer
box sizersizerproportion
——flex grid sizer
0box sizer0
wx.EXPAND
box sizer
0
11.3.4 static box sizer
static box sizerbox sizerstatic boxsizer
11.15static box sizer
351 / 565

11.15
11.10
sizer
box sizerstatic box sizerbox sizer
11.10 static box sizer
import wx
from blockwindow import BlockWindow
labels = ”one two three four five six seven eight nine”.split()
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”StaticBoxSizer Test”)
self.panel = wx.Panel(self)
# make three static boxes with windows positioned inside them
box1 = self.MakeStaticBoxSizer(“Box 1”, labels[0:3])
box2 = self.MakeStaticBoxSizer(“Box 2”, labels[3:6])
box3 = self.MakeStaticBoxSizer(“Box 3”, labels[6:9])
# We can also use a sizer to manage the placement of other
# sizers (and therefore the windows and sub-sizers that they
# manage as well.)
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add(box1, 0, wx.ALL, 10)
sizer.Add(box2, 0, wx.ALL, 10)
sizer.Add(box3, 0, wx.ALL, 10)
self.panel.SetSizer(sizer)
sizer.Fit(self)
352 / 565

def MakeStaticBoxSizer(self, boxlabel, itemlabels):
# first the static box
box = wx.StaticBox(self.panel, -1, boxlabel)
# then the sizer
sizer = wx.StaticBoxSizer(box, wx.VERTICAL)
# then add items to it like normal
for label in itemlabels:
bw = BlockWindow(self.panel, label=label)
sizer.Add(bw, 0, wx.ALL, 2)
return sizer
app = wx.PySimpleApp()
TestFrame().Show()
app.MainLoop()
static box sizerwx.StaticBoxSizerwx.StaticBoxSizer
wx.BoxSizer
wx.StaticBoxSizer(box, orient)
orientwx.BoxSizerbox
wx.StaticBoxstatic box sizer
GetStaticBox()sizerwx.StaticBoxsizer
wx.StaticBoxwxPython
wx.StaticBox(parent, id, label, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=0, name=”staticBox”)
static box sizerpos, size, style, name
sizerwx.StaticBox
353 / 565

ox = wx.StaticBox(self.panel, -1, boxlabel)
sizer
11.4 sizer
sizer
sizer11.16
sizer
11.16
11.11
11.11 sizer
import wx
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1, ”Real World Test”)
panel = wx.Panel(self)
# First create the controls
topLbl = wx.StaticText(panel, -1, ”Account Information”)#1
topLbl.SetFont(wx.Font(18, wx.SWISS, wx.NORMAL, wx.BOLD))
354 / 565

nameLbl = wx.StaticText(panel, -1, ”Name:”)
name = wx.TextCtrl(panel, -1, ””);
addrLbl = wx.StaticText(panel, -1, ”Address:”)
addr1 = wx.TextCtrl(panel, -1, ””);
addr2 = wx.TextCtrl(panel, -1, ””);
cstLbl = wx.StaticText(panel, -1, ”City, State, Zip:”)
city = wx.TextCtrl(panel, -1, ””, size=(150,-1));
state = wx.TextCtrl(panel, -1, ””, size=(50,-1));
zip = wx.TextCtrl(panel, -1, ””, size=(70,-1));
phoneLbl = wx.StaticText(panel, -1, ”Phone:”)
phone = wx.TextCtrl(panel, -1, ””);
emailLbl = wx.StaticText(panel, -1, ”Email:”)
email = wx.TextCtrl(panel, -1, ””);
saveBtn = wx.Button(panel, -1, ”Save”)
cancelBtn = wx.Button(panel, -1, ”Cancel”)
# Now do the layout.
# mainSizer is the top-level one that manages everything
#2 sizer
mainSizer = wx.BoxSizer(wx.VERTICAL)
mainSizer.Add(topLbl, 0, wx.ALL, 5)
mainSizer.Add(wx.StaticLine(panel), 0,
wx.EXPAND|wx.TOP|wx.BOTTOM, 5)
# addrSizer is a grid that holds all of the address info
#3
addrSizer = wx.FlexGridSizer(cols=2, hgap=5, vgap=5)
addrSizer.AddGrowableCol(1)
addrSizer.Add(nameLbl, 0,
wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL)
addrSizer.Add(name, 0, wx.EXPAND)
addrSizer.Add(addrLbl, 0,
wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL)
355 / 565

addrSizer.Add(addr1, 0, wx.EXPAND)
#4
addrSizer.Add((10,10)) # some empty space
addrSizer.Add(addr2, 0, wx.EXPAND)
addrSizer.Add(cstLbl, 0,
wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL)
# the city, state, zip fields are in a sub-sizer
#5
cstSizer = wx.BoxSizer(wx.HORIZONTAL)
cstSizer.Add(city, 1)
cstSizer.Add(state, 0, wx.LEFT|wx.RIGHT, 5)
cstSizer.Add(zip)
addrSizer.Add(cstSizer, 0, wx.EXPAND)
#6
addrSizer.Add(phoneLbl, 0,
wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL)
addrSizer.Add(phone, 0, wx.EXPAND)
addrSizer.Add(emailLbl, 0,
wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL)
addrSizer.Add(email, 0, wx.EXPAND)
# now add the addrSizer to the mainSizer
#7 Flex sizer
mainSizer.Add(addrSizer, 0, wx.EXPAND|wx.ALL, 10)
# The buttons sizer will put them in a row with resizeable
# gaps between and on either side of the buttons
#8
btnSizer = wx.BoxSizer(wx.HORIZONTAL)
btnSizer.Add((20,20), 1)
btnSizer.Add(saveBtn)
btnSizer.Add((20,20), 1)
btnSizer.Add(cancelBtn)
btnSizer.Add((20,20), 1)
mainSizer.Add(btnSizer, 0, wx.EXPAND|wx.BOTTOM, 10)
panel.SetSizer(mainSizer)
356 / 565

# Fit the frame to the needs of the sizer. The frame will
# automatically resize the panel as needed. Also prevent the
# frame from getting smaller than this size.
mainSizer.Fit(self)
mainSizer.SetSizeHints(self)
app = wx.PySimpleApp()
TestFrame().Show()
app.MainLoop()
#1
sizer
#2 sizermainSizerbox sizer
mainSizerstatic line
#3 box sizeraddrSizerflex grid sizer
addrSizer
gridnameLbl, name, addrLbl, addr1
flex grid
#4 (10,10)
addr2
#5 “City, State, Zip”
box sizercstSizer
cstSizerbox sizeraddrSizer
#6 flex sizer
#7 flex sizersizer
#8 box sizer
sizermainSizer.Fit(self)
mainSizer.SetSizeHints(self)
357 / 565

sizerbox sizer
0
sizerbox sizer
wx.EXPAND
static linesizerflex grid sizer1
“City, State, Zip”
1citystateZIP
0
1
11.17
11.17
11.5
1SizerwxPython
sizersizer
358 / 565

sizer
2wxPythonsizerwx.Sizer
sizer
sizersizerFit()
sizer
3sizersizer
sizer
4wxPythonsizergrid sizer(wx.GridSizer)
grid sizersizer
sizer
5sizersizer
sizer
sizersizer
sizer
359 / 565

12
wxPython
wxPython
wxPython
wxPython
wxPythondevice context
API
12.1
wxPython
wxPython
(large-scale images)
360 / 565

12.1.1
wxPython
wx.Imagewx.Bitmap
wx.Imagewx.Bitmap
12.1
wx.Image
wx.Image(name, type=wx.BITMAP_TYPE_ANY, index=-1)
12.1
nametypetypeID
wx.BITMAP_TYPE_ANY12.1
wx.BITMAP_TYPE_ANYwxPython
wxPython
12.1wx.BITMAP_TYPE_ANY
12.1
import wx
filenames = [“image.bmp”, ”image.gif”, ”image.jpg”, ”image.png” ]
class TestFrame(wx.Frame):
def __init__(self):
361 / 565

wx.Frame.__init__(self, None, title=”Loading Images”)
p = wx.Panel(self)
fgs = wx.FlexGridSizer(cols=2, hgap=10, vgap=10)
for name in filenames:
#1
img1 = wx.Image(name, wx.BITMAP_TYPE_ANY)
# Scale the original to another wx.Image
w = img1.GetWidth()
h = img1.GetHeight()
img2 = img1.Scale(w/2, h/2)#2
#3
sb1 = wx.StaticBitmap(p, -1, wx.BitmapFromImage(img1))
sb2 = wx.StaticBitmap(p, -1, wx.BitmapFromImage(img2))
# and put them into the sizer
fgs.Add(sb1)
fgs.Add(sb2)
p.SetSizerAndFit(fgs)
self.Fit()
app = wx.PySimpleApp()
frm = TestFrame()
frm.Show()
app.MainLoop()
wx.BITMAP_TYPE_ANYwxPython
wxPython
362 / 565

wx.ImageHandler
wxPython12.1
12.1 wxPython
wx.ANIHandler
wx.BITMAP_TYPE_ANI
wx.BMPHandler wx.BITMAP_TYPE_BMP
WindowsOS/2
wx.CURHandle wx.BITMAP_TYPE_CUR
Windows
wx.GIFHandler wx.BITMAP_TYPE_GIF
wx.ICOHandler wx.BITMAP_TYPE_ICO
Windows
wx.IFFHandler wx.BITMAP_TYPE_IFF
wx.JPEGHandler wx.BITMAP_TYPE_JPEG
wx.PCXHandler wx.BITMAP_TYPE_PCX
PCwxPython
8256
24
363 / 565

wx.PNGHandler wx.BITMAP_TYPE_PNG
wx.PNMHandler wx.BITMAP_TYPE_PNM
ASCIIRGBRGB
wx.TIFFHandler wx.BITMAP_TYPE_TIF
wx.XPMHandler wx.BITMAP_TYPE_XPM
XPixMap
wx.BITMAP_TYPE_ANY
MIMEID
wx.ImageFromMime(name, mimetype, index=-1)name
mimetypeindex
GIF, ICO, TIFF
-1GIFTIFF
index=0ICO
wxPythonwx.Image
wx.EmptyImage(width,height)——
Python
wx.ImageFromStream(stream,type=wx.BITMAP_TYPE_ANY, index=-1)
RGB
wx.ImageFromData(width,height,data)data
width*height*3
wx.Bitmap
wx.Bitmap(name, type=wx.BITMAP_TYPE_ANY)name
type12.1bitmap
364 / 565

wx.Image
wx.Bitmap
wx.EmptyBitmap(width,height,depth=-1)
——widthheightdepth
wx.BitmapFromBits(bits, width, height, depth=-1)bits
Pythonbits1
0Windows
WindowsAPICreateBitmap()
wxBitmapFromXPMData(listOfStrings)Python
XPM
wx.Bitmapwx.BitmapFromImage(image, depth=-1)
imagewx.Imagedepth
wx.ImageFromBitmap(bitmap)
wx.Bitmap12.1
wx.StaticBitmap
wxPython
12.1.2
wxPython
GetWidth()GetHeight()
GetRed(x, y), GetGreen(x, y), GetBlue(x, y)
0~255C
Python
SetRGB(x, y, red, green, blue)xy
0~255
GetData()GetData()
RGB
0~255
(0,0)(0,0)
(0,0)(0,1)
Python
365 / 565

def GetData(self):
result = ””
for y in range(self.GetHeight()):
for x in range(self.GetWidth()):
result.append(chr(self.GetRed(x,y)))
result.append(chr(self.GetGreen(x,y)))
result.append(chr(self.GetBlue(x,y)))
return result
SetData(data)RGB
SetData(data)
C++
GetData()SetData()——
Python
import array
img = wx.EmptyImage(100,100)
a = array.array(‘B’, img.GetData())
for i in range(len(a)):
a[i] = (25+i) % 256
img.SetData(a.tostring())
12.2wx.Image
12.2 wx.Image
ConvertToMono(r, g, b)wx.Image
(r, g, b)
Mirror(horizontally=True)horizontally
True
366 / 565

Replace(r1, g1, b1, r2, g2, b2)r1, g1, b1
r2, g2, b2
Rescale(width, height)
Rotate(angle, rotationCentre, interpolating=True, offestAfterRotation=None)
angle
rotationCentrewx.PointinterpolatingTrue
offsetAfterRotation
mask color
Rotate90(clockwise=True)clockwise
90
Scale(width, height)
SetMaskColor(red, green, blue)
red, green, blue
SetMask(False)SetMask(True)HasMask()
SetMaskFromImage(mask, mr, mg, mb)——
wx.Imagemr, mg, mb
GetMaskRed()GetMaskGreen(), GetMaskBlue()
wx.Bitmapwx.Mask
alpha
alpha0255
SetAlphaData(data)alpha
SetData()
SetData()SetAlphaData()HasAlpha()
alphaGetAlphaData()
367 / 565

SetAlpha(x, y, alpha)alpha
GetAlpha(x, y)
wx.Imagewx.Bitmap
wx.Bitmap
12.1.3
I
wxPython
wxPython
wxPython
wx.Cursor
wx.StockCursor(id)12.3
IDid
12.3
wx.CURSOR_ARROW
wx.CURSOR_ARROWWAIT
Windows
wx.CURSOR_BLANK
wx.CURSOR_BULLSEYEbullseye cursor
wx.CURSOR_CHAR
wx.CURSOR_CROSS
368 / 565

wx.CURSOR_HAND
wx.CURSOR_IBEAMI
wx.CURSOR_LEFT_BUTTON——
wx.CURSOR_MAGNIFIER
wx.CURSOR_MIDDLE_BUTTON
wx.CURSOR_NO_ENTRY
wx.CURSOR_PAINT_BRUSH
wx.CURSOR_PENCIL
wx.CURSOR_POINT_LEFT
wx.CURSOR_POINT_RIGHT
wx.CURSOR_QUESTION_ARROW
wx.CURSOR_RIGHT_ARROW
wx.CURSOR_RIGHT_BUTTON
wx.CURSOR_SIZENESW
45
wx.CURSOR_SIZENS
wx.CURSOR_SIZENWSE
135
wx.CURSOR_SIZEWE
wx.CURSOR_SIZING
wx.CURSOR_SPRAYCAN
wx.CURSOR_WAIT
369 / 565

wx.CURSOR_WATCH
wx.CursorFromImage(image)
imagewx.Image
32*32MacOS16*16
(0,0)
image.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_X, 0)
image.SetOptionInt(wx.IMAGE_OPTION_CUR_HOTSPOT_Y, 22)
wx.Cursor
wx.Cursor(name, type, hotSpotX=0, hotSpotY=0)
nametype
wx.Imagewx.Bitmapwx.BITMAP_TYPE_hotSpotX
hotSpotYwx.BITMAP_TYPE_CUR
.cur.cur
wxPython
SetCursor(cursor)
wx.SetCurso(cursor)
12.2
UI
wxPython
UI
6
370 / 565

wxPython
wxPython
wx.DCwx.DCAPIAPI
6
12.2.1
wxPythonwx.DC
*
*
*
wxPython
wx.ClientDC
wx.PaintDC
wx.WindowDC
wx.ScreenDC
——
371 / 565

wx.ClientDCwx.PaintDC
EVT_PAINT
wx.PaintDC
wx.ClientDCEVT_PAINT
wx.PaintDC
wx.PaintDC
paint)wx.PaintDC
client
paint)wxPython
wx.ClientDC(window)wx.PaintDC(window)
wx.WindowDCwx.WindowDCwx.ClientDC
wx.WindowDC(window)wx.ClientDC
paintwx.WindowDC——
paint
wx.ScreenDC
paint)
——wx.ScreenDC()wx.ScreenDC
wx.MemoryDC
wx.MetafileDC
wx.PostScriptDC
372 / 565

wx.PrinterDC
wx.MemoryDC
wx.MemoryDC()
wx.MemoryDC
wx.BitmapSelectObject(bitmap)
Blit()
Windowsmetafilewx.MetafileDC
Windows
wx.MetafileDC(filename=””)filename
Close()
wxPythonwx.MetafilewxPython
wx.MetafileSetClipboard(width=0,height=0)
wx.PostScriptDC
Encapsulated PostScript files.eps
wx.PostScriptDC——wx.PostScriptDC(printData)printData
wx.PrintData17PostScript
wx.PrintData
.eps
data = wx.PrintData()
data.SetFileName(“/tmp/test.eps”)
data.SetPaperId(wx.PAPER_LETTER)
dc = wx.PostScriptDC(data)
dc.StartDoc(“”)
dc.DrawCircle(300,300, 100)
dc.EndDoc() # the file is written at this point
Windowswx.PrinterDCWindows
——
wx.PrinterDC(printData)17
373 / 565

wx.BufferedDC
wx.BufferedPaintDC
wxPython——wx.BufferedDC
wx.ClientDCwx.BufferedPaintDC
wx.PaintDC
wxBufferedDC
——
wx.BufferedDC(dc, buffer=None)wx.BufferedPaintDC
——wx.BufferedPaintDC(dc, buffer=None)dc
wx.BufferedPaintDC
wx.PaintDCbuffer
buffer
C++
Blit()
12.2.2
——
wxPythonAPI
12.4
374 / 565

12.4
CrossHair(x, y)——y
x(x,y)
DrawArc(x1, y1, x2, y2, xc, yc)(x1,y1)(x2,y2)
(xc,yc)
DrawCheckMark(x, y, width, height)
(x,y)widthheight
DrawCircle(x, y, radius)radius(x,y)
DrawEllipse(x, y, width, height)
(x,y)widthheight
DrawEllipticArc(x, y, width, height, start, end)
DrawEllipsestartend
360start
end
DrawLine(x1, y1, x2, y2(x1,y1)(x2,y2)
DrawLines(points, xoffset=0, yoffset=0)pointswx.Point
wx.Pointpoint
pointoffsetoffset
DrawPolygon(points, xoffset=0, yoffset=0fillstyle=wx.ODDEVEN_RULE)
DrawLines
DrawPoint(x, y)
DrawRectangle(x, y, width, height)(x,y)
widthheight
DrawRoundedRectangle(x, y, width, height, radius=20)DrawRectangle()
90radiusradius
375 / 565

adius
radius * dimension
DrawSpline(points)spline
FloodFill(x, y, color, style=wx.FLOOD_SURFACE)
(x,y)stylewx.FLOOD_SURFACE
stylewx.FLOOD_BORDER
xyDrawDraw...Point
Draw...Pointwx.Point(x,y)
DrawCirclePoint(pt, radius)x,ywidth,height
Draw...PointSizewx.Pointwx.Size
DrawRectanglePointSize(pt, sz)Draw...Rect
wx.RectDrawRectangleRect(rect)
GetSize()wx.Size
GetPixel(x, y)
wx.Color
12.2
12.2draw
376 / 565

12.20-100
12.2
import wx
import math
import random
class RadarGraph(wx.Window):
”””
A simple radar graph that plots a collection of values in the
range of 0-100 onto a polar coordinate system designed to easily
show outliers, etc. You might use this kind of graph to monitor
some sort of resource allocation metrics, and a quick glance at
the graph can tell you when conditions are good (within some
accepted tolerance level) or approaching critical levels (total
resource consumption).
”””
def __init__(self, parent, title, labels):
wx.Window.__init__(self, parent)
self.title = title
self.labels = labels
self.data = [0.0] * len(labels)
self.titleFont = wx.Font(14, wx.SWISS, wx.NORMAL, wx.BOLD)
self.labelFont = wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL)
self.InitBuffer()
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_PAINT, self.OnPaint)
def OnSize(self, evt):
# When the window size changes we need a new buffer.
self.InitBuffer()
377 / 565

def OnPaint(self, evt):
# This automatically Blits self.buffer to a wx.PaintDC when
# the dc is destroyed, and so nothing else needs done.
dc = wx.BufferedPaintDC(self, self.buffer)#1
def InitBuffer(self):#2
# Create the buffer bitmap to be the same size as the window,
# then draw our graph to it. Since we use wx.BufferedDC
# whatever is drawn to the buffer is also drawn to the window.
w, h = self.GetClientSize()
self.buffer = wx.EmptyBitmap(w, h)
dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
self.DrawGraph(dc)
def GetData(self):
return self.data
def SetData(self, newData):
assert len(newData) == len(self.data)
self.data = newData[:]
# ,
dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
self.DrawGraph(dc)
def PolarToCartesian(self, radius, angle, cx, cy):
x = radius * math.cos(math.radians(angle))
y = radius * math.sin(math.radians(angle))
return (cx+x, cy-y)
def DrawGraph(self, dc):#
spacer = 10
scaledmax = 150.0
dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
378 / 565

dc.Clear()
dw, dh = dc.GetSize()
# Find out where to draw the title and do it
dc.SetFont(self.titleFont)
tw, th = dc.GetTextExtent(self.title)
dc.DrawText(self.title, (dw-tw)/2, spacer)#
# find the center of the space below the title
#
th = th + 2*spacer
cx = dw/2
cy = (dh-th)/2 + th
# calculate a scale factor to use for drawing the graph based
# on the minimum available width or height
#
mindim = min(cx, (dh-th)/2)
scale = mindim/scaledmax
# draw the graph axis and ”bulls-eye” with rings at scaled 25,
# 50, 75 and 100 positions
#
dc.SetPen(wx.Pen(“black”, 1))
dc.SetBrush(wx.TRANSPARENT_BRUSH)
dc.DrawCircle(cx,cy, 25*scale)
dc.DrawCircle(cx,cy, 50*scale)
dc.DrawCircle(cx,cy, 75*scale)
dc.DrawCircle(cx,cy, 100*scale)
dc.SetPen(wx.Pen(“black”, 2))
dc.DrawLine(cx-110*scale, cy, cx+110*scale, cy)
dc.DrawLine(cx, cy-110*scale, cx, cy+110*scale)
# Now find the coordinates for each data point, draw the
# labels, and find the max data point
dc.SetFont(self.labelFont)
maxval = 0
angle = 0
polypoints = []
379 / 565

for i, label in enumerate(self.labels):
val = self.data[i]
point = self.PolarToCartesian(val*scale, angle, cx, cy)#
polypoints.append(point)
x, y = self.PolarToCartesian(125*scale, angle, cx,cy)
dc.DrawText(label, x, y)#
if val > maxval:
maxval = val
angle = angle + 360/len(self.labels)
# Set the brush color based on the max value (green is good,
# red is bad)
c = ”forest green”
if maxval > 70:
c = ”yellow”
if maxval > 95:
c = ”red”
# Finally, draw the plot data as a filled polygon
dc.SetBrush(wx.Brush(c))#
dc.SetPen(wx.Pen(“navy”, 3))
dc.DrawPolygon(polypoints) #
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Double Buffered Drawing”,
size=(480,480))
self.plot = RadarGraph(self, ”Sample ’Radar’ Plot”,
[“A”, ”B”, ”C”, ”D”, ”E”, ”F”, ”G”, ”H”])
# Set some random initial data values
data = []
for d in self.plot.GetData():
data.append(random.randint(0, 75))
self.plot.SetData(data)
# Create a timer to update the data values
380 / 565

self.Bind(wx.EVT_TIMER, self.OnTimeout)
self.timer = wx.Timer(self)
self.timer.Start(500)
def OnTimeout(self, evt):
# simulate the positive or negative growth of each data value
data = []
for d in self.plot.GetData():
val = d + random.uniform(-5, 5)
if val < 0:
val = 0
if val > 110:
val = 110
data.append(val)
self.plot.SetData(data)
app = wx.PySimpleApp()
frm = TestFrame()
frm.Show()
app.MainLoop()
#1 wx.BufferedPaintDC
OnPaintself.buffer
wx.PaintDC
#2
wx.BufferedDCInitBuffer
12.2.3
imagebitmap
blit
blit
381 / 565

* Blit()
* DrawBitmap()
* DrawIcon()
Blit()
Blit(xdest, ydest, width, height, source, xsrc, ysrc,
logicalFunc=wx.COPY, useMask=False, xsrcMask=-1,
ysrcMask=-1)
Blit()
Blit()
Blit()
xdest, ydest, width, height
xsrc, ysrcwx.DC
wx.DCwx.DC
logicalFunc——
12.6
useMaskTrueblit
alpha
xsrcMask ysrcMask
xsrcMask ysrcMaskxsrc, ysrc
blitBlitPointSize()wx.Pointblit
wx.Sizewidthheight
DrawBitmap(bitmap,x, y, useMask=False)bitmapwx.Bitmap
(x,y)useMask
FalseTrue
alpha
382 / 565

12.3
12.3
12.3
12.3
12.3
# This one shows how to draw images on a DC.
import wx
import random
random.seed()
class RandomImagePlacementWindow(wx.Window):
def __init__(self, parent, image):
wx.Window.__init__(self, parent)
self.photo = image.ConvertToBitmap()#
# choose some random positions to draw the image at:
#
self.positions = [(10,10)]
383 / 565

for x in range(50):
x = random.randint(0, 1000)
y = random.randint(0, 1000)
self.positions.append( (x,y) )
# Bind the Paint event
self.Bind(wx.EVT_PAINT, self.OnPaint)
def OnPaint(self, evt):
# create and clear the DC
dc = wx.PaintDC(self)
brush = wx.Brush(“sky blue”)
dc.SetBackground(brush)
dc.Clear()#
# draw the image in random locations
for x,y in self.positions:#
dc.DrawBitmap(self.photo, x, y, True)
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Loading Images”,
size=(640,480))
img = wx.Image(“masked-portrait.png”)
win = RandomImagePlacementWindow(self, img)
app = wx.PySimpleApp()
frm = TestFrame()
frm.Show()
app.MainLoop()
DrawIcon(icon, x, y)wx.Icon
(x,y)wx.Icon
wx.Bitmapwx.Icon
384 / 565

12.2.4
DrawText(text, x, y)
textxy
DrawRotatedText(text, x, y, angle)angle
DrawTextPoint(text, pt)
DrawRotatedTextPoint(text, pt, angle)
get*set*
GetTextForeground(), SetTextForegroud(color), GetTextBackground(), SetTextBackg
round(color), GetFont(), and SetFont(font)wxPython
SetBackgroundMode(mode)
modewx.SOLID
modewx.TRANSPARENT
GetCharHeight()GetCharWidth()
GetTextExtent(string)
(width,height)
GetFullTextExtent(string)
(width,height,descent,externalLeading)descent
externalLeading
0
GetPartialTextExtents(text)
widths,
widths[i] = GetTextExtent(text[:i])[0]
385 / 565

12.3
12.3.1
wx.Pen
GetPen()SetPen(pen)
wx.Pen
wx.Pen(colour, width=1, style=wx.SOLID)
colourwx.ColourRGB
RGB“#12C588”width
style12.5
style——
12.5 wx.Pen
wx.BDIAGONAL_HATCH
wx.CROSSDIAG_HATCH wx.BDIAGONAL_HATCHwx.FDIAGONAL_HATCH
X
wx.CROSS_HATCH+
wx.DOT
wx.DOT_DASH
wx.FDIAGONAL_HATCH
wx.HORIZONTAL_HATCH
wx.LONG_DASH
386 / 565

wx.SHORT_DASH
wx.SOLID
wx.STIPPLE
wx.TRANSPARENT
wx.USER_DASH
wx.VERTICAL_HATCH
——
wx.BLACK_DASHED_PEN
wx.BLACK_PEN
wx.CYAN_PEN
wx.GREEN_PEN
wx.GREY_PEN
wx.LIGHT_GREY_PEN
wx.MEDIUM_GREY_PEN
wx.RED_PEN
wx.TRANSPARENT_PEN
wx.WHITE_PEN
——
GetColour(), SetColour(color), GetWidth(), SetWidth(width), GetStyle(),
SetStyle()
“end cap”
GetCap()SetCap(cap)cap
wx.CAP_BUTT
wx.CAP_PROJECTING
wx.CAP_ROUND
wx.GetJoin(), wx.SetJoin(join)join
wx.JOIN_BEVEL
387 / 565

wx.JOIN_MITER
wx.JOIN_ROUND
wx.USER_DASHGetDashes()
SetDashes(dashes)dashes
wx.STIPPLESetStipple(stipple)
GetStipple()
blit
SetLogicalFunction(function)functionwx.COPY
wx.XORwx.INVERTrubberbanding12.3
Python
&
|
^
~
12.6
wx.AND&
wx.AND_INVERT~ &
wx.AND_REVERSE & ~
wx.CLEAR0——
wx.COPY
wx.EQUIV~ ^
wx.INVERT~
wx.NAND~ | ~
388 / 565

wx.NOR~ & ~
wx.NO_OP
wx.OR |
wx.OR_INVERT~ |
wx.OR_REVERSE |
wx.SET1——
wx.SRC_INVERT~
wx.XOR ^
blit
12.3.2
wx.Brush GetBrush()
SetBrush(brush)Clear()
wx.Brush
wx.Brush(colour, style=wx.SOLID)
colourwx.Colour
RGBstyle
wx.BDIAGONAL_HATCH
wx.CROSSDIAG_HATCH
wx.CROSS_HATCH
wx.FDIAGONAL_HATCH
wx.HORIZONTAL_HATCH
wx.SOLID
wx.STIPPLE
389 / 565

wx.TRANSPARENT
wx.VERTICAL_HATCH
get*set*——
GetColour(), SetColour(colour), GetStyle(), SetStyle()
SetStipple(bitmap)stipple
stipplewx.STIPPLEGetStipple()
stipple
wx.BrushFromBitmap(Bitmap)
12.3.3
wxPython
wxPython
(0,0)yxy
SetAxisOrientation(xLeftRight,yBottomUp)
xLeftRightTrue
xyBottomUpTrue
y
SetMapMode(mode)mode
mode12.7
12.7
wx.MM_LOMETRIC
0.1
wx.MM_METRIC
1
wx.MM_POINTS
1
390 / 565

wx.MM_TEXT
1()
wx.MM_TWIPS
1/20
GetPPI()
LogicalToDeviceX(x)LogicalToDeviceY(y)
LogicalToDeviceXRel(x)LogicalToDeviceYRel(y)
DeviceToLogicalX(x), DeviceToLogicalY(y), DeviceToLogicalXRel(x),
DeviceToLogcialYRel(y)
“clipping”
SetClippingRegion(x, y, width, height)x,ywidth
height
DestroyClippingRegion()clip
GetClippingBox()(x, y, width, height)
“bounding box”
“bounding box”wxPython
MaxX(), MaxY(), MinX(), MinY()
“bounding box”
“bounding box”
CalcBoundingBox(x,y)“bounding box”
ResetBoundingBox()
391 / 565

“bounding box”“bounding box”
12.3.4
wxPython
aquamarine black blue
blue violet brown cadet blue
coral cornflower blue cyan
dark gray dark green dark olive green
dark orchid dark slate blue dark slate gray
dark turquoise dim gray firebrick
forest green gold goldenrod
gray green green yellow
indian red khaki light blue
light gray light steel blue lime green
magenta maroon medium aquamarine
medium blue medium forest green medium goldenrod
medium orchid medium sea green medium slate blue
medium spring green medium turquoise
medium violet red midnight blue navy
orange
orange red orchid pale green
pink plum purple red
salmon sea green sienna sky blue
slate blue spring green steel blue tan
thistle turquoise violet violet red
wheat white yellow yellow green
updateColourDB
wx.lib.colourdb
12.4
1wxPython
wx.Image
wx.Bitmap
wx.Image
392 / 565

alpha
2wx.Image
3
4wx.DC
APIwx.DC
EVT_PAINT
5wx.MemoryDCwx.BufferedDC
wx.BufferedDC
wx.BufferedPaintDC
6
wx.Sizewx.Point
7Blit()
8wx.Penwx.Pen
wx.Brush
wx.Penwx.Brush
wx.Pen
9
clipping
“bounding box”
393 / 565

wxPython
wxPython
13“”
Windows
14“grid”grid
grid
15“”
16“HTML”HTML
HTML
HTML17“wxPython”
wxPython
18
“wxPython”
(timer)wxPython
394 / 565

13
wxPython
HTML
8
13.1
* (icon)
* (small icon)
* (list)
* (report)
Windows(Explorer)MacFinder
395 / 565

13.1.1
Windows
13.1
13.113.1.png
13.1
#-*- encoding:UTF-8 -*-
import wx
import sys, glob
class DemoFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”wx.ListCtrl in wx.LC_ICON mode”,
size=(600,400))
# load some images into an image list
il = wx.ImageList(32,32, True)#
for name in glob.glob(“icon.png”):
bmp = wx.Bitmap(name, wx.BITMAP_TYPE_PNG)
il_max = il.Add(bmp)
# create the list control
#
self.list = wx.ListCtrl(self, -1,
style=wx.LC_ICON | wx.LC_AUTOARRANGE)
# assign the image list to it
self.list.AssignImageList(il, wx.IMAGE_LIST_NORMAL)
# create some items for the list
#
for x in range(25):
img = x % (il_max+1)
396 / 565

self.list.InsertImageStringItem(x,
”This is item %02d” % x, img)
app = wx.PySimpleApp()
frame = DemoFrame()
frame.Show()
app.MainLoop()
13.1
13.1DemoFrame“image list”
“image list”
13.1.2
13.2
397 / 565

13.2
13.2
import wx
import sys, glob
class DemoFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”wx.ListCtrl in wx.LC_SMALL_ICON mode”,
size=(600,400))
# load some images into an image list
il = wx.ImageList(16,16, True)
for name in glob.glob(“smicon.png”):
bmp = wx.Bitmap(name, wx.BITMAP_TYPE_PNG)
il_max = il.Add(bmp)
# create the list control
self.list = wx.ListCtrl(self, -1,
style=wx.LC_SMALL_ICON
| wx.LC_AUTOARRANGE
)
398 / 565

# assign the image list to it
self.list.AssignImageList(il, wx.IMAGE_LIST_SMALL)
# create some items for the list
for x in range(25):
img = x % (il_max+1)
self.list.InsertImageStringItem(x,
”This is item %02d” % x,
img)
app = wx.PySimpleApp()
frame = DemoFrame()
frame.Show()
app.MainLoop()
13.1.3
13.3
13.3
399 / 565

13.3
import wx
import sys, glob
class DemoFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”wx.ListCtrl in wx.LC_LIST mode”,
size=(600,400))
# load some images into an image list
il = wx.ImageList(16,16, True)
for name in glob.glob(“smicon.png”):
bmp = wx.Bitmap(name, wx.BITMAP_TYPE_PNG)
il_max = il.Add(bmp)
# create the list control
self.list = wx.ListCtrl(self, -1, style=wx.LC_LIST)
# assign the image list to it
self.list.AssignImageList(il, wx.IMAGE_LIST_SMALL)
# create some items for the list
for x in range(25):
img = x % (il_max+1)
self.list.InsertImageStringItem(x,
”This is item %02d” % x,
img)
app = wx.PySimpleApp()
frame = DemoFrame()
frame.Show()
app.MainLoop()
400 / 565

13.1.4
13.4
13.4
13.213.4
13.2
#!/usr/bin/python
#-*- encoding:UTF-8 -*-
import wx
import sys, glob, random
import data
class DemoFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”wx.ListCtrl in wx.LC_REPORT mode”,
size=(600,400))
il = wx.ImageList(16,16, True)
for name in glob.glob(“smicon.png”):
401 / 565

mp = wx.Bitmap(name, wx.BITMAP_TYPE_PNG)
il_max = il.Add(bmp)
self.list = wx.ListCtrl(self, -1, style=wx.LC_REPORT)#
self.list.AssignImageList(il, wx.IMAGE_LIST_SMALL)
# Add some columns
for col, text in enumerate(data.columns):#
self.list.InsertColumn(col, text)
# add the rows
for item in data.rows:#
index = self.list.InsertStringItem(sys.maxint, item[0])
for col, text in enumerate(item[1:]):
self.list.SetStringItem(index, col+1, text)
# give each item a random image
img = random.randint(0, il_max)
self.list.SetItemImage(index, img, img)
# set the width of the columns in various ways
self.list.SetColumnWidth(0, 120)#
self.list.SetColumnWidth(1, wx.LIST_AUTOSIZE)
self.list.SetColumnWidth(2, wx.LIST_AUTOSIZE)
self.list.SetColumnWidth(3, wx.LIST_AUTOSIZE_USEHEADER)
app = wx.PySimpleApp()
frame = DemoFrame()
frame.Show()
app.MainLoop()
#-
*- encoding:UTF-8 -*-
grid14
402 / 565

13.1.5
wxPythonwx.ListCtrl
wx.ListCtrl(parent, id, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=wx.LC_ICON,
validator=wx.DefaultValidator, name=”listCtrl”)
parent
idwxPython-1pos
sizestyle——
validator9name
style
wx.LC_ICON
13.1
13.1
wx.LC_ICON
wx.LC_LIST
wx.LC_REPORT
wx.LC_SMALL_ICON
wx.LC_ALIGN_TOP
wx.LC_ALIGN_LEFTLC_AUTOARRANGE
13.2
13.2
wx.LC_HRULES
wx.LC_NO_HEADER
403 / 565

wx.LC_VRULES
wx.LC_REPORT|
wx.LC_HRULES|wx.LC_VRULES
wx.LC_SINGLE_SEL
SetSingleStyle(style, add=True)
add
listCtrl.SetSingleStyle(LC_HRULES,True)
listCtrl.SetSingleStyle(LC_HRULES,False)listCtrl
SetWindowStyleFlag(style)
SetWindowStyleFlag(LC_REPORT | LC_NO_HEADER)
13.2
wxPython
13.2.1
wxPython
12
wx.ImageList
wx.ImageList(width, height, mask=True, initialCount=1)
404 / 565

widthheight
maskTrue
initialCount
Add(bitmap, mask=wx.NullBitmap)
bitmapmaskwx.Bitmapmask
mask
AddWithColourMask(bitmapcolour)colour
wxPythonwx.Icon
AddIcon(icon)
13.1
il = wx.ImageList(32, 32, True)
for name in glob.glob(“icon.png”):
bmp = wx.Bitmap(name, wx.BITMAP_TYPE_PNG)
il_max = il.Add(bmp)
self.list.AssignImageList(il, wx.IMAGE_LIST_NORMAL)
Remove(index)index
RemoveAll()
Replace(index, bitmap, mask=wx.NullBitmap)
indexbitmapmaskAdd()
ReplaceIcon(index, icon)
405 / 565

GetImageCount()
GetSize()(width, height)
6
12Draw
Draw(index, dc, x, y, flags=wx.IMAGELIST_DRAW_NORMAL,
solid”302.files/”>
indexdc
wx.DCflagsflags
wx.IMAGELIST_DRAW_NORMAL, wx.IMAGELIST_DRAW_TRANSPARENT,
wx.IMAGELISTDRAW_SelectED, wx.IMAGELIST_DRAW_FOCUSED
solidBackgroundTrue
AssignImage(imageList, which)
SetImage(imageList, which)imageListwhich
wx.IMAGE_LIST_NORMAL wx.IMAGE_LIST_SMALL
C++AssignImage()
SetImage()
Python
wx.IMAGE_LIST_NORMAL
wx.IMAGE_LIST_SMALL
get*GetImageList(which)
which
406 / 565

13.2.2
/
API
InsertItem()
InsertStringItem(index, label)index
InsertImageItem(index, imageIndex)
indeximageIndex
InsertImageStringItem(index, label, imageIndex)
wx.ListItem
InsertItem(index, item)
itemwx.ListItemwx.ListItem
——
get*set*
/
InsertColumn()
InsertColumn(col, heading, format=wx.LIST_FORMAT_LEFT, width=-1)
407 / 565

col
headingformat
wx.LIST_FORMAT_CENTREwx.LIST_FORMAT_LEFT
wx.LIST_FORMAT_RIGHT
width——
wx.ListItem
InsertColumnInfo(info)
SetStringItem()
SetStringItem(index, col, label, imageId=-1)
indexcolcol0
index——
labelimageId
SetStringItem()SetItem(info)SetItem(info)
wx.ListItemwx.ListItem
GetItem(index,col=0)
wx.ListItem
col
get*set*
GetItem()
get*set*SetItemImage(item, image, selImage)
itemimage
selImage
GetItemText(item)SetItemText(item,text)
408 / 565

GetItemState(item,stateMask)
SetItemState(item, state, stateMask)state
stateMask13.3stateGetItemState
stateMask
GetColumn(col)col
wx.ListItem
13.3
wx.LIST_STATE_CUTWindows
wx.LIST_STATE_DONTCAREWindows
wx.LIST_STATE_DropHILITED
Windows
wx.LIST_STATE_FOCUSED
wx.LIST_STATE_SelectED
SetColumn(col, item)
GetColumnWidth(col)
——
SetColumnWidth(col,width)width
wx.LIST_AUTOSIZE
wx.LIST_AUTOSIZE_USEHEADER
Windows
wx.LIST_AUTOSIZE_USEHEADER80
GetColumnCount()GetItemCount()
GetCountPerPage()
DeleteItem(item)item
DeleteAllItems()
ClearAll()DeleteColumn(col)col
409 / 565

13.3
13.3.1
Bind()
wx.ListEvent
wx.ListEventwx.CommandEventwx.ListEventget*
13.4
13.4 wx.ListEvent
GetData()
GetKeyCode()
GetIndex()
GetItem()wx.ListItem
GetImage()
GetMask()
GetPoint()
GetText()
wx.ListEvent
13.5
13.5
EVT_LIST_BEGIN_DRAG
410 / 565

EVT_LIST_BEGIN_RDRAG
EVT_LIST_Delete_ALL_ITEMS DeleteAll()
EVT_LIST_Delete_ITEM Delete()
EVT_LIST_Insert_ITEM
EVT_LIST_ITEM_ACTIVATED
EVT_LIST_ITEM_DESelectED
EVT_LIST_ITEM_FOCUSED
EVT_LIST_ITEM_MIDDLE_CLICK
EVT_LIST_ITEM_RIGHT_CLICK
EVT_LIST_ITEM_SelectED
EVT_LIST_ITEM_KEY_DOWN
13.3
13.3.2
wx.ListEventGetColumn()
113.6
13.6
EVT_LIST_COL_BEGIN_DRAG
EVT_LIST_COL_CLICK
EVT_LIST_COL_RIGHT_CLICK
411 / 565

EVT_LiST_COL_END_DRAG
13.3
13.3
import wx
import sys, glob, random
import data
class DemoFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”Other wx.ListCtrl Stuff”,
size=(700,500))
self.list = None
self.editable = False
self.MakeMenu()
self.MakeListCtrl()
def MakeListCtrl(self, otherflags=0):
# if we already have a listctrl then get rid of it
if self.list:
self.list.Destroy()
if self.editable:
otherflags |= wx.LC_EDIT_LABELS
# load some images into an image list
il = wx.ImageList(16,16, True)
for name in glob.glob(“smicon.png”):
bmp = wx.Bitmap(name, wx.BITMAP_TYPE_PNG)
il_max = il.Add(bmp)
# create the list control
self.list = wx.ListCtrl(self, -1, style=wx.LC_REPORT|otherflags)
# assign the image list to it
412 / 565

self.list.AssignImageList(il, wx.IMAGE_LIST_SMALL)
# Add some columns
for col, text in enumerate(data.columns):
self.list.InsertColumn(col, text)
# add the rows
for row, item in enumerate(data.rows):
index = self.list.InsertStringItem(sys.maxint, item[0])
for col, text in enumerate(item[1:]):
self.list.SetStringItem(index, col+1, text)
# give each item a random image
img = random.randint(0, il_max)
self.list.SetItemImage(index, img, img)
# set the data value for each item to be its position in
# the data list
self.list.SetItemData(index, row)
# set the width of the columns in various ways
self.list.SetColumnWidth(0, 120)
self.list.SetColumnWidth(1, wx.LIST_AUTOSIZE)
self.list.SetColumnWidth(2, wx.LIST_AUTOSIZE)
self.list.SetColumnWidth(3, wx.LIST_AUTOSIZE_USEHEADER)
# bind some interesting events
self.Bind(wx.EVT_LIST_ITEM_SelectED, self.OnItemSelected, self.list)
self.Bind(wx.EVT_LIST_ITEM_DESelectED, self.OnItemDeselected, self.list)
self.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnItemActivated, self.list)
# in case we are recreating the list tickle the frame a bit so
# it will redo the layout
self.SendSizeEvent()
def MakeMenu(self):
mbar = wx.MenuBar()
menu = wx.Menu()
413 / 565

item = menu.Append(-1, ”E&xit\tAlt-X”)
self.Bind(wx.EVT_MENU, self.OnExit, item)
mbar.Append(menu, ”&File”)
menu = wx.Menu()
item = menu.Append(-1, ”Sort ascending”)
self.Bind(wx.EVT_MENU, self.OnSortAscending, item)
item = menu.Append(-1, ”Sort descending”)
self.Bind(wx.EVT_MENU, self.OnSortDescending, item)
item = menu.Append(-1, ”Sort by submitter”)
self.Bind(wx.EVT_MENU, self.OnSortBySubmitter, item)
menu.AppendSeparator()
item = menu.Append(-1, ”Show selected”)
self.Bind(wx.EVT_MENU, self.OnShowSelected, item)
item = menu.Append(-1, ”Select all”)
self.Bind(wx.EVT_MENU, self.OnSelectAll, item)
item = menu.Append(-1, ”Select none”)
self.Bind(wx.EVT_MENU, self.OnSelectNone, item)
menu.AppendSeparator()
item = menu.Append(-1, ”Set item text colour”)
self.Bind(wx.EVT_MENU, self.OnSetTextColour, item)
item = menu.Append(-1, ”Set item background colour”)
self.Bind(wx.EVT_MENU, self.OnSetBGColour, item)
menu.AppendSeparator()
item = menu.Append(-1, ”Enable item editing”, kind=wx.ITEM_CHECK)
self.Bind(wx.EVT_MENU, self.OnEnableEditing, item)
item = menu.Append(-1, ”Edit current item”)
self.Bind(wx.EVT_MENU, self.OnEditItem, item)
mbar.Append(menu, ”&Demo”)
self.SetMenuBar(mbar)
def OnExit(self, evt):
self.Close()
414 / 565

def OnItemSelected(self, evt):
item = evt.GetItem()
print ”Item selected:”, item.GetText()
def OnItemDeselected(self, evt):
item = evt.GetItem()
print ”Item deselected:”, item.GetText()
def OnItemActivated(self, evt):
item = evt.GetItem()
print ”Item activated:”, item.GetText()
def OnSortAscending(self, evt):
# recreate the listctrl with a sort style
self.MakeListCtrl(wx.LC_SORT_ASCENDING)
def OnSortDescending(self, evt):
# recreate the listctrl with a sort style
self.MakeListCtrl(wx.LC_SORT_DESCENDING)
def OnSortBySubmitter(self, evt):
def compare_func(row1, row2):
# compare the values in the 4th col of the data
val1 = data.rows[row1][3]
val2 = data.rows[row2][3]
if val1 < val2: return -1
if val1 > val2: return 1
return 0
self.list.SortItems(compare_func)
def OnShowSelected(self, evt):
print ”These items are selected:”
index = self.list.GetFirstSelected()
if index == -1:
print ”\tNone”
return
415 / 565

while index != -1:
item = self.list.GetItem(index)
print ”\t%s” % item.GetText()
index = self.list.GetNextSelected(index)
def OnSelectAll(self, evt):
for index in range(self.list.GetItemCount()):
self.list.Select(index, True)
def OnSelectNone(self, evt):
index = self.list.GetFirstSelected()
while index != -1:
self.list.Select(index, False)
index = self.list.GetNextSelected(index)
def OnSetTextColour(self, evt):
dlg = wx.ColourDialog(self)
if dlg.ShowModal() == wx.ID_OK:
colour = dlg.GetColourData().GetColour()
index = self.list.GetFirstSelected()
while index != -1:
self.list.SetItemTextColour(index, colour)
index = self.list.GetNextSelected(index)
dlg.Destroy()
def OnSetBGColour(self, evt):
dlg = wx.ColourDialog(self)
if dlg.ShowModal() == wx.ID_OK:
colour = dlg.GetColourData().GetColour()
index = self.list.GetFirstSelected()
while index != -1:
self.list.SetItemBackgroundColour(index, colour)
index = self.list.GetNextSelected(index)
dlg.Destroy()
def OnEnableEditing(self, evt):
self.editable = evt.IsChecked()
self.MakeListCtrl()
416 / 565

def OnEditItem(self, evt):
index = self.list.GetFirstSelected()
if index != -1:
self.list.EditLabel(index)
class DemoApp(wx.App):
def OnInit(self):
frame = DemoFrame()
self.SetTopWindow(frame)
print ”Program output appears here...”
frame.Show()
return True
app = DemoApp(redirect=True)
app.MainLoop()
13.4
13.4.1
wx.LC_EDIT_LABELS
list = wx.ListCtrl(self, -1, style=wx.LC_REPORT | wx.LC_EDIT_LABELS)
Enter
417 / 565

Esc
* EVT_LIST_BEGIN_LABEL_EDIT
* EVT_LIST_END_LABEL_EDIT
Skip()
EVT_LIST_BEGIN_LABEL_EDIT
EnterEscEVT_LIST_END_LABEL_EDIT
(veto)
wx.ListEvent
EVT_LIST_END_LABEL_EDIT
GetLabel()Esc
GetLabel()GetLabel()“
”“”
IsEditCancelled()TrueFalse
EditLabel(item)item
EVT_LIST_BEGIN_LABEL_EDIT
GetEditControl()
NoneWindows
13.4.2
wxPython
418 / 565

wx.LC_SORT_ASCENDING
wx.LC_SORT_DESCENDING
Windows
wxPython
SetItemData(item, data)item
dataC
++
GetItemData(item)
SortItems(func)
funcPythonfunc
——
0
SortItems()
ColumnSorterMixinwxPythonmixin
wx.lib.mixins.listctrl13.5mixin
419 / 565

13.5
mixinPython
import wx.lib.mixins.listctrl as listmix
class ListCtrlPanel(wx.Panel, listmix.ColumnSorterMixin):
def __init__(self, parent, log):
wx.Panel.__init__(self, parent, -1, style=wx.WANTS_CHARS)
self.list = TestListCtrl(self, tID)
self.itemDataMap = musicdata
listmix.ColumnSorterMixin.__init__(self, 3)
13.413.5
13.4mixin
#!/usr/bin/python
#-*- encoding:UTF-8 -*-
import wx
import wx.lib.mixins.listctrl
import sys, glob, random
import data
class DemoFrame(wx.Frame, wx.lib.mixins.listctrl.ColumnSorterMixin):#
420 / 565

def __init__(self):
wx.Frame.__init__(self, None, -1,
”wx.ListCtrl with ColumnSorterMixin”,
size=(600,400))
# load some images into an image list
il = wx.ImageList(16,16, True)
for name in glob.glob(“smicon.png”):
bmp = wx.Bitmap(name, wx.BITMAP_TYPE_PNG)
il_max = il.Add(bmp)
# add some arrows for the column sorter
#
self.up = il.AddWithColourMask(
wx.Bitmap(“sm_up.bmp”, wx.BITMAP_TYPE_BMP), ”blue”)
self.dn = il.AddWithColourMask(
wx.Bitmap(“sm_down.bmp”, wx.BITMAP_TYPE_BMP), ”blue”)
# create the list control
self.list = wx.ListCtrl(self, -1, style=wx.LC_REPORT)
# assign the image list to it
self.list.AssignImageList(il, wx.IMAGE_LIST_SMALL)
# Add some columns
for col, text in enumerate(data.columns):
self.list.InsertColumn(col, text)
# add the rows
#
self.itemDataMap = {}
for item in data.rows:
index = self.list.InsertStringItem(sys.maxint, item[0])
for col, text in enumerate(item[1:]):
self.list.SetStringItem(index, col+1, text)
# give each item a data value, and map it back to the
# item values, for the column sorter
self.list.SetItemData(index, index)#
self.itemDataMap[index] = item
421 / 565

# give each item a random image
img = random.randint(0, il_max)
self.list.SetItemImage(index, img, img)
# set the width of the columns in various ways
self.list.SetColumnWidth(0, 120)
self.list.SetColumnWidth(1, wx.LIST_AUTOSIZE)
self.list.SetColumnWidth(2, wx.LIST_AUTOSIZE)
self.list.SetColumnWidth(3, wx.LIST_AUTOSIZE_USEHEADER)
# initialize the column sorter
wx.lib.mixins.listctrl.ColumnSorterMixin.__init__(self,
len(data.columns))
def GetListCtrl(self):
return self.list
def GetSortImages(self):
return (self.dn, self.up)
app = wx.PySimpleApp()
frame = DemoFrame()
frame.Show()
app.MainLoop()
mixin
1ColumnSorterMixinDemoFrame
GetListCtrl()mixin
2ColumnSorterMixinDemoFrame__init__()
ColumnSorterMixin__init__()
GetListCtrl()mixin__init__()
3SetItemData()
422 / 565

4ColumnSorterMixinDemoFrame
itemDataMap
SetItemData()
itemDataMap
ColumnSorterMixinitemDataMap
itemDataMap
ColumnSorterMixin
13.4.3
13.7
13.8HitTest()
13.7
FindItem(start, str, partial=False)strstart1
startpartialTrue
str
FindItemAtPos(startpoint, direction)pointpoint
wx.Pointdirection
wx.LIST_FIND_DOWN, wx.LIST_FIND_LEFT, wx.LIST_FIND_RIGHT,
wx.LIST_FIND_UP
FindItemData(start,data)SetItemData()data
startFindItem()
423 / 565

HitTest(point)(index, flags)Pythonindex
index1flags
flags13.8
13.8 HitTest()
wx.LIST_HITTEST_ABOVE
wx.LIST_HITTEST_BELOW
wx.LIST_HITTEST_NOWhere
wx.LIST_HITTEST_ONITEM(index, flags)index
wx.LIST_HITTEST_ONITEMICON(index, flags)
index
wx.LIST_HITTEST_ONITEMLABEL(index, flags)
index
wx.LIST_HITTEST_ONITEMRIGHT
wx.LIST_HITTEST_ONITEMSTATEICON
wx.LIST_HITTEST_TOLEFT
wx.LIST_HITTEST_TORIGHT
GetItem()GetItemText()13.9
13.9
GetItemPosition(item)wx.Point
GetItemRect(item,code= wx.LIST_RECT_BOUNDS)item
wx.Rectcodecode
wx.LIST_RECT_BOUNDSwxPythoncode
wx.LIST_RECT_ICON
wx.LIST_RECT_LABEL
424 / 565

GetNextItem(item, geometry=wx.LIST_ALL, state=wx.LIST_STATE_DONTCARE )
geometrystateitem
geometrystate
SetItemPosition(item, pos)itempos
13.10GetNextItem()geometrygeometry
Windows
13.10 GetNextItem()geometry
wx.LIST_NEXT_ABOVE
wx.LIST_NEXT_ALL
wx.LIST_NEXT_BELOW
wx.LIST_NEXT_LEFT
wx.LIST_NEXT_RIGHT
13.11GetNextItem()state
13.11 GetNextItem()state
wx.LIST_STATE_CUT
wx.LIST_STATE_DONTCARE
wx.LIST_STATE_DropHILITED
wx.LIST_STATE_FOCUSED
wx.LIST_STATE_SelectED
13.12
425 / 565

13.2
GetBackgroundColour()
SetBackgroundColour(col)colwx.Colour
GetItemBackgroundColour(item)
SetItemBackgroundColour(item,col)item
GetItemTextColour(item)
SetItemTextColour(item, col)item
GetTextColour()
SetTextColour(col)
13.3
13.3
GetItemSpacing()wx.Size
GetSelectedItemCount()
GetTopItem()
GetViewRect()wx.Rect
ScrollList(dx, dy)dydx
13.5
wxPython
426 / 565

wxPython
13.6
13.6
13.5
13.5
#!/usr/bin/python
#-*- encoding:UTF-8 -*-
import wx
import sys, glob, random
427 / 565

import data
class DataSource:#
”””
A simple data source class that just uses our sample data items.
A real data source class would manage fetching items from a
database or similar.
”””
def GetColumnHeaders(self):
return data.columns
def GetCount(self):
return len(data.rows)
def GetItem(self, index):
return data.rows[index]
def UpdateCache(self, start, end):
pass
class VirtualListCtrl(wx.ListCtrl):#1
”””
A generic virtual listctrl that fetches data from a DataSource.
”””
def __init__(self, parent, dataSource):
wx.ListCtrl.__init__(self, parent,
style=wx.LC_REPORT|wx.LC_SINGLE_SEL|wx.LC_VIRTUAL)#
wx.LC_VIRTUAL
self.dataSource = dataSource
self.Bind(wx.EVT_LIST_CACHE_HINT, self.DoCacheItems)
self.SetItemCount(dataSource.GetCount())#
columns = dataSource.GetColumnHeaders()
for col, text in enumerate(columns):
self.InsertColumn(col, text)
def DoCacheItems(self, evt):
self.dataSource.UpdateCache(
428 / 565

evt.GetCacheFrom(), evt.GetCacheTo())
def OnGetItemText(self, item, col):#
data = self.dataSource.GetItem(item)
return data[col]
def OnGetItemAttr(self, item): return None
def OnGetItemImage(self, item): return -1
class DemoFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, -1,
”Virtual wx.ListCtrl”,
size=(600,400))
self.list = VirtualListCtrl(self, DataSource())
app = wx.PySimpleApp()
frame = DemoFrame()
frame.Show()
app.MainLoop()
wx.LC_VIRTUAL#1wx.ListCtrl
wx.ListCtrl
class MyVirtualList(wx.ListCtrl):
def __init__(self, parent):
wx.ListCtrl.__init__(self, parent, -1,
style=wx.LC_REPORT|wx.LC_VIRTUAL)
429 / 565

SetItemCount()
SetItemCount()
On[0,SetItemCount()1]
OnGetItemText(item, col)item
col
def OnGetItemText(self, item, col):
return ”Item %d, column %d” % (item, col)
OnGetItemImage(item)
OnGetItemImage1
OnGetItemAttr(item)
itemwx.ListItemAttr
get*set*
RefreshItem(item)
RefreshItems(itemFrom,itemTo)itemFromitemTo
EVT_LIST_CACHE_HINT
OnGetItemText()
13.6
1wxPython
wx.ListCtrl
430 / 565

2
3InsertStringItem(index,label)
InsertImageItem(index, imageIndex)
InsertImageStringItem(index,label,
imageIndex)
InsertColumn(col, heading, format=”wx.LIST_FORMAT_LEFT, width=-1)
SetStringItem(index, col, label, imageId=-1)
4
wx.ListEvent
EVT_LIST_Insert_ITEM, EVT_LIST_ITEM_ACTIVATED,
EVT_LIST_ ITEM_SelectED
5wx.LC_EDIT_LABELS
Esc
6wx.LC_SORT_ASCENDING
wx.LC_SORT_DESCENDING
0
SortItems(func)mixin
wx.lib.mixins.listctrl.ColumnSorterMixin
7wx.LC_VIRTUAL
OnGetItemText(item, col)
OnGetItemImage(item)OnGetItemAttr(item)
RefreshItem(item)
RefreshItems(itemFrom, itemTo)
431 / 565

14 (grid)
:
(grid)
(cell),
(cell)(renderer)
wxPython
wxPython
14.1
wxPython
*
432 / 565

* (grid table)
5MVC
14.1.1
14.1
14.1
wx.grid.Grid
wxPython
wx.grid.Grid
wx.grid.Grid(parent, id, pos=wx.DefaultPosition,
433 / 565

size=wx.DefaultSize, style=wx.WANTS_CHARS,
name=wxPanelNameStr)
wx.Window
wx.WANTS_CHARSwx.grid.Grid
wx.grid.Grid
* CreateGrid()
* SetTable()
CreateGrid(numRows, numCols, selmode=wx.grid.Grid.SelectCells)
numRows, numColsselmode
wx.grid.Grid.SelectCells
wx.grid.Grid.SelectRows
wx.grid.Grid.SelectionColumns
GetSelectionMode()
SetSelectionMode(mode)GetNumberCols()
GetNumberRows()
CreateGrid()wxPython
SetCellValue(row, col, s)
row, cols
GetCellValue(row, col)
ClearGrid()14.114.1
14.1 ClearGrid()
import wx
import wx.grid
class TestFrame(wx.Frame):
434 / 565

def __init__(self):
wx.Frame.__init__(self, None, title=”Simple Grid”,
size=(640,480))
grid = wx.grid.Grid(self)
grid.CreateGrid(50,50)
for row in range(20):
for col in range(6):
grid.SetCellValue(row, col,
”cell (%d,%d)” % (row, col))
app = wx.PySimpleApp()
frame = TestFrame()
frame.Show()
app.MainLoop()
CreateGrid()SetCellValue()
14.1.2
*
*
*
5MVC
14.2
435 / 565

14.2
wx.grid.PyGridTableBase
wx.grid.GridTableBase14.214.2
14.2
#-*- encoding:UTF-8 -*-
import wx
import wx.grid
class TestTable(wx.grid.PyGridTableBase):#
def __init__(self):
wx.grid.PyGridTableBase.__init__(self)
self.data = { (1,1) : ”Here”,
(2,2) : ”is”,
(3,3) : ”some”,
(4,4) : ”data”,
}
self.odd=wx.grid.GridCellAttr()
self.odd.SetBackgroundColour(“sky blue”)
self.odd.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
436 / 565

self.even=wx.grid.GridCellAttr()
self.even.SetBackgroundColour(“sea green”)
self.even.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
# these five are the required methods
def GetNumberRows(self):
return 50
def GetNumberCols(self):
return 50
def IsEmptyCell(self, row, col):
return self.data.get((row, col)) is not None
def GetValue(self, row, col):#
value = self.data.get((row, col))
if value is not None:
return value
else:
return ’’
def SetValue(self, row, col, value):#
self.data[(row,col)] = value
# the table can also provide the attribute for each cell
def GetAttr(self, row, col, kind):
attr = [self.even, self.odd][row % 2]
attr.IncRef()
return attr
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Grid Table”,
size=(640,480))
437 / 565

grid = wx.grid.Grid(self)
table = TestTable()
grid.SetTable(table, True)
app = wx.PySimpleApp()
frame = TestFrame()
frame.Show()
app.MainLoop()
14.2
wx.grid.Grid
514.1
14.1 wx.grid.GridTableBase
GetNumberCols()
GetNumberRows()
GetValue(row, col)(row, col)
IsEmptyCell(row, col)(row, col)True
False
SetValue(row, col, value)
pass
SetTable(table,takeOwnership=False,selmode=wx.grid.Grid.SelectCells)
tablewx.grid.PyGridTableBasetakeOwnership
takeOwnershipTrue
wxPythonselmodeCreateGrid()
438 / 565

SetTableCreateGrid()
Clear()ClearGrid()
14.2
14.2.1
AppendCols(numCols=1)
AppendRows(numRows=1)
InsertCols(pos=0, numCols=1)InsertRows(pos=1, numRows=1)
posnumRows
numCols1
DeleteCols(pos=0, numCols=1)
DeleteRows(pos=0, numRows=1)pos
CreateGrid()
SetTable()
InsertCols()
InsertCols(pos=0, numCols=1)True
439 / 565

False50
def AppendRows(self, numRows=1):
return (self.GetRowCount() + numRows)

14.3
import wx
import wx.grid
class TestFrame(wx.Frame):
rowLabels = [“uno”, ”dos”, ”tres”, ”quatro”, ”cinco”]
colLabels = [“homer”, ”marge”, ”bart”, ”lisa”, ”maggie”]
def __init__(self):
wx.Frame.__init__(self, None, title=”Grid Headers”,
size=(500,200))
grid = wx.grid.Grid(self)
grid.CreateGrid(5,5)
for row in range(5):
#1 start
grid.SetRowLabelValue(row, self.rowLabels[row])
grid.SetColLabelValue(row, self.colLabels[row])
#1 end
for col in range(5):
grid.SetCellValue(row, col,
”(%s,%s)” % (self.rowLabels[row], self.colLabels[col]))
app = wx.PySimpleApp()
frame = TestFrame()
frame.Show()
app.MainLoop()
CreateGrid()SetColLabelValue(col, value)
SetRowLabelValue(row, value)#1colrow
value
GetColLabelValue(col)GetRowLabelValue(row)
GetColLabelValue(col)GetRowLabelValue(row)
set*set*——
441 / 565

SetColLabelValue(col, value)SetRowLabelValue(row, value)——
set*14.4
——
14.4
import wx
import wx.grid
class TestTable(wx.grid.PyGridTableBase):
def __init__(self):
wx.grid.PyGridTableBase.__init__(self)
self.rowLabels = [“uno”, ”dos”, ”tres”, ”quatro”, ”cinco”]
self.colLabels = [“homer”, ”marge”, ”bart”, ”lisa”, ”maggie”]
def GetNumberRows(self):
return 5
def GetNumberCols(self):
return 5
def IsEmptyCell(self, row, col):
return False
def GetValue(self, row, col):
return ”(%s,%s)” % (self.rowLabels[row], self.colLabels[col])
def SetValue(self, row, col, value):
pass
def GetColLabelValue(self, col):#
return self.colLabels[col]
def GetRowLabelValue(self, row):#
return self.rowLabels[row]
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Grid Table”,
size=(500,200))
442 / 565

grid = wx.grid.Grid(self)
table = TestTable()
grid.SetTable(table, True)
app = wx.PySimpleApp()
frame = TestFrame()
frame.Show()
app.MainLoop()
SetColumnLabelAlignment(horiz, vert)SetRowLabelAlignment(horiz, vert)
horiz
wx.ALIGN_LEFT, wx.ALIGN_CENTREwx.ALIGN_RIGHTvert
wx.ALIGN_TOP, wx.ALIGN_CENTRE,
wx.ALIGN_BOTTOM
SetLabelBackgroundColour(colour)
, SetLabelFont(font), and SetLabelTextColour(colour)
colourwx.ColourwxPython
fontwx.Fontset*get*
GetLabelBackgoundColour(), GetLabelFont()GetLabelTextFont()
14.2.3
14.4
14.5
443 / 565

14.4
14.5
import wx
import wx.grid
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Grid Sizes”,
size=(600,300))
grid = wx.grid.Grid(self)
grid.CreateGrid(5,5)
for row in range(5):
for col in range(5):
grid.SetCellValue(row, col, ”(%s,%s)” % (row, col))
grid.SetCellSize(2, 2, 2, 3)
grid.SetColSize(1, 125)
grid.SetRowSize(1, 100)
app = wx.PySimpleApp()
frame = TestFrame()
frame.Show()
app.MainLoop()
444 / 565

HTML
rowspancolspanwxPython
SetCellSize(row, col, num_rows, num_cols)row,col
num_rowsnum_cols
num_rows, num_cols1
num_rows, num_cols0
SetCellOverflow(row, col, allow)
passSetCellSize()
SetColSize(col, width)SetRowSize(row, height)
GetColSize(col)GetRowSize(row)
SetDefaultColSize(width, resizeExistingCols=False)
SetDefaultRowSize(height, resizeExistingRows=False)
True
False
CreateGrid()SetTable()
GetDefaultColSize()GetDefaultRowSize()
wxPython
wxPython
445 / 565

wxPython
SetColMinimalAcceptableWidth(width)
SetRowMinimalAcceptableHeight(height)
SetColMinimalWidth(col, width)SetRowMinimalHeight(row, height)
set*get*
* GetColMinimalAcceptableWidth()
* GetRowMinimalAcceptableHeight()
* GetColMinimalWidth(col)
* GetRowMinimalHeight(row)
set*SetRowLabelSize(width)
SetColLabelSize(height)
GetRowLabelSize()GetColLabelSize()
wxPythonAutoSize()
AutoSizeColumn(col, setAsMin=True)
AutoSizeRow(row, setAsMin=True)
setAsMinTrue
AutoSizeColumns(setAsMin=True)AutoSizeRows(setAsMin=True)
* EnableDragColSize(enable=True)
446 / 565

* EnableDragRowSize(enable=True)
* EnableDragGridSize(enable=True)
* DisableDragColSize()
* DisableDragRowSize()
* DisableDragGridSize()
* CanDragColSize()
* CanDragRowSize()
* CanDragGridSize()
14.2.4
wxPython
0
*
*
*
*
IsSelection()TrueIsInSelection(row, col)
True
14.2
447 / 565

14.2
GetSelectedCells()Python
(row, col)
GetSelectedCols()
Python
GetSelectedRows()
Python
GetSelectionBlockTopLeft()
Python(row, col)(row, col)
GetSelectionBlockBottomRight()
Python(row, col)(row, col)
ClearSelection()IsSelection()
FalseSelectAll()
SelectCol(col, addToSelected=False)
SelectRow(row, addToSelected=False)
addToSelectedTrue
addToSelectedFalse
SelectBlock(topRow, leftCol, bottomRow, rightCol, addToSelected=False)
addToSelected
IsVisible(row, col, wholeCellVisible=True)
True
wholeCellVisibleTrue
TruewholeCellVisibleFalse
TrueMakeCellVisible(row, col)
448 / 565

GetGridCursorCol()GetGridCursorRow()
SetGridCursor(row, col)
MakeCellVisible
14.3
14.3
BlockToDeviceRect(topLeft, bottomRight)topLeft, bottomRight
(row, col)wx.Rectwx.Rect
CellToRect(row, col)wx.Rectwx.Rect(row, col)
XToCol(x)x
wx.NOT_FOUND
XToEdgeOfCol(x)x
wx.NOT_FOUND
YToRow(y)y
wx.NOT_FOUND
YToEdgeOfRow(y)y
wx.NOT_FOUND
14.2.5
14.514.614.5
wx.grid.GridCellAttr
449 / 565

14.5
14.6
import wx
import wx.grid
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Grid Attributes”,
size=(600,300))
grid = wx.grid.Grid(self)
grid.CreateGrid(10,6)
for row in range(10):
for col in range(6):
grid.SetCellValue(row, col, ”(%s,%s)” % (row, col))
grid.SetCellTextColour(1, 1, ”red”)
grid.SetCellFont(1,1, wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
grid.SetCellBackgroundColour(2, 2, ”light blue”)
attr = wx.grid.GridCellAttr()
attr.SetTextColour(“navyblue”)
attr.SetBackgroundColour(“pink”)
attr.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))
grid.SetAttr(4, 0, attr)
450 / 565

grid.SetAttr(5, 1, attr)
grid.SetRowAttr(8, attr)
app = wx.PySimpleApp()
frame = TestFrame()
frame.Show()
app.MainLoop()
SetDefaultCellAlignment(horiz, vert)
horizwx.LEFTwx.CENTREwx.RIGHTvert
wx.TOP, wx.CENTRE, wx.BOTTOMGetDefaultCellAlignment()
(horiz, vert)
SetDefaultCellTextColour(colour)
SetDefaultCellBackgroundColour(colour)colour
wx.Colourget*GetDefaultCellTextColour()
GetDefaultCellBackgroundColour()SetDefaultCellFont(font)
GetDefaultCellFont()
GetCellAlignment(row, col)
SetCellAlignment(row, col, horiz, vert)
GetCellBackgroundColour(row, col)
SetCellBackgroundColour(row, col, colour)
GetCellFont(row, col)
SetCellFont(row, col, font)
GetCellTextColour(row, col)
SetCellTextColour(row, col, colour)
SetSelectionBackground(colour)SetSelectionForeground(colour)
get*
GetSelectionBackground()GetSelectionForeground()
451 / 565

SetMargins(extraWidth, extraHeight)
wx.grid.Gridwx.grid.GridCellAttr
wx.grid.GridCellAttrget*set*
GetOrCreateCellAttr(row, col)
attr
wx.grid.GridCellAttr()
SetColAttr(attr)
SetRowAttr(attr)
14.6
GetAttr(row, col)
wx.grid.GridCellAttr
EnableGridLines(enable)enableTrue
False
SetGridLineColor(colour)
14.3
14.3.1
wxPython
wxPython
452 / 565

wx.grid.GridCellRenderer
wx.grid.GridCellRenderer
14.4
get*,set*
14.4
wx.grid.GridCellAutoWrapStringRenderer
wx.grid.GridCellBoolRenderer——
TrueFalse
wx.grid.GridCellDateTimeRenderer
wx.grid.GridCellEnumRenderer
wx.grid.GridCellFloatRenderer
(width=-1, precision=-1)
wx.grid.GridCellNumberRenderer
wx.grid.GridCellStringRenderer
GetCellRenderer(row, col)
SetCellRenderer(row, col, renderer)
renderer
GridCellAttrGetDefaultRenderer
SetDefaultRenderer(renderer)
SetColFormatBool(col), SetColFormatNumber(col)
SetColFormatFloat(col, width, precision)
453 / 565

wx.grid.PyGridCellRenderer
14.6
14.6
14.7
14.714.6
#-*- encoding:UTF-8 -*-
import wx
import wx.grid
import random
class RandomBackgroundRenderer(wx.grid.PyGridCellRenderer):#
def __init__(self):
wx.grid.PyGridCellRenderer.__init__(self)
def Draw(self, grid, attr, dc, rect, row, col, isSelected):#
text = grid.GetCellValue(row, col)
hAlign, vAlign = attr.GetAlignment()
dc.SetFont( attr.GetFont() )
if isSelected:
454 / 565

g = grid.GetSelectionBackground()
fg = grid.GetSelectionForeground()
else:
bg = random.choice([“pink”, ”sky blue”, ”cyan”, ”yellow”, ”plum”])
fg = attr.GetTextColour()
dc.SetTextBackground(bg)
dc.SetTextForeground(fg)
dc.SetBrush(wx.Brush(bg, wx.SOLID))
dc.SetPen(wx.TRANSPARENT_PEN)
dc.DrawRectangleRect(rect)
grid.DrawTextRectangle(dc, text, rect, hAlign, vAlign)
def GetBestSize(self, grid, attr, dc, row, col):
text = grid.GetCellValue(row, col)
dc.SetFont(attr.GetFont())
w, h = dc.GetTextExtent(text)
return wx.Size(w, h)
def Clone(self):
return RandomBackgroundRenderer()
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Grid Renderer”,
size=(640,480))
grid = wx.grid.Grid(self)
grid.CreateGrid(50,50)
# Set this custom renderer just for row 4
attr = wx.grid.GridCellAttr()
attr.SetRenderer(RandomBackgroundRenderer())
grid.SetRowAttr(4, attr)#5
for row in range(10):
for col in range(10):
grid.SetCellValue(row, col,
”cell (%d,%d)” % (row, col))
455 / 565

app = wx.PySimpleApp()
frame = TestFrame()
frame.Show()
app.MainLoop()
Draw()
GetBestSize()
Clone()
Draw(grid, attr, dc, rect, row, col, isSelected)
gridattr
dcrect
row,col
isSelectedTrue
GetBestSize(grid, attr, dc, row, col)wx.Size
Clone()wx.grid.GridCellRenderer
14.3.2
wxPython
EnableEditing(enable)——
enableFalse
IsEditable()
SetReadOnly(row, col, isReadOnly=True)
isReadOnly=TrueFalse
SetReadOnly()wx.grid.GridCellAttr
GetCellAttr(row, col).SetReadOnly(isReadOnly)
456 / 565

SetReadOnlySetRowAttr()SetColAttr()
EnableCellEditControl(enable=True)
DisableCellEditControl()
EnableCellEditControl(False)Enable*
disable*enable*
CanEnableCellControl()true
IsCellEditControlEnabled()true
ShowCellEditControl()
HideCellEditControl()IsCurrentCellReadOnly()
SaveEditControlValue()
GetCellEditor(row, col)
wx.grid.GridCellEditor
SetCellEditor(row, col, editor)editor
wx.grid.GridCellEditorGetDefaultEditor()
SetDefaultEditor(editor)
wx.grid.GridCellAttr
14.3.3
wxPython
wxPythonwx.grid.GridCellEditor14.5
457 / 565

14.5 wxPyhton
wx.grid.GridCellAutoWrapStringEditor
wx.grid.GridCellBooleanEditor
——
10on/off
wx.grid.GridCellChoiceEditor
(choices,allowOthers=False)choices
allowOthersTrue
wx.grid.GridCellEnumEditorwx.grid.GridCellChoiceEditor
wx.grid.GridCellFloatEditor
(width=-1precision=-1)
wx.grid.GridCellNumberEditor
(min=-1, max=-1)minmax
spinner
wx.grid.GridCellTextEditor
wx.grid.PyGridCellEditor
14.6
14.7
14.6 PyGridCellEditor
BeginEdit(row, col, grid)row,colgrid
Clone()
458 / 565

Create(parent, id, evtHandler)parentid
evtHandler
EndEdit(row, col, grid)True
Reset()
14.7 PyGridCellEditor
Destroy()
IsAcceptedKey(evt)evtTrueF2
control,alt,shift
PaintBackground(rect, attr) rectwx.Rectattr
wc.grid.GridCellAttr
SetSize(rect)rectwx.Rect
Show(show, attr)showattr
StartingClick()
StartingKey(evt)
SetCellEditor
14.8
14.8
#-*- encoding:UTF-8 -*-
import wx
import wx.grid
import string
459 / 565

class UpCaseCellEditor(wx.grid.PyGridCellEditor):#
def __init__(self):
wx.grid.PyGridCellEditor.__init__(self)
def Create(self, parent, id, evtHandler):#
”””
Called to create the control, which must derive from wx.Control.
*Must Override*
”””
self._tc = wx.TextCtrl(parent, id, ””)
self._tc.SetInsertionPoint(0)
self.SetControl(self._tc)
if evtHandler:
self._tc.PushEventHandler(evtHandler)
self._tc.Bind(wx.EVT_CHAR, self.OnChar)
def SetSize(self, rect):
”””
Called to position/size the edit control within the cell rectangle.
If you don’t fill the cell (the rect) then be sure to override
PaintBackground and do something meaningful there.
”””
self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2,
wx.SIZE_ALLOW_MINUS_ONE)
def BeginEdit(self, row, col, grid):
”””
Fetch the value from the table and prepare the edit control
to begin editing. Set the focus to the edit control.
*Must Override*
”””
self.startValue = grid.GetTable().GetValue(row, col)
self._tc.SetValue(self.startValue)
self._tc.SetInsertionPointEnd()
self._tc.SetFocus()
self._tc.SetSelection(0, self._tc.GetLastPosition())
460 / 565

def EndEdit(self, row, col, grid):
”””
Complete the editing of the current cell. Returns True if the value
has changed. If necessary, the control may be destroyed.
*Must Override*
”””
changed = False
val = self._tc.GetValue()
if val != self.startValue:
changed = True
grid.GetTable().SetValue(row, col, val) # update the table
self.startValue = ’’
self._tc.SetValue(‘’)
return changed
def Reset(self):
”””
Reset the value in the control back to its starting value.
*Must Override*
”””
self._tc.SetValue(self.startValue)
self._tc.SetInsertionPointEnd()
def Clone(self):
”””
Create a new object which is the copy of this one
*Must Override*
”””
return UpCaseCellEditor()
def StartingKey(self, evt):
”””
If the editor is enabled by pressing keys on the grid, this will be
called to let the editor do something about that first key if desired.
”””
self.OnChar(evt)
if evt.GetSkipped():
461 / 565

self._tc.EmulateKeyPress(evt)
def OnChar(self, evt):
key = evt.GetKeyCode()
if key > 255:
evt.Skip()
return
char = chr(key)
if char in string.letters:
char = char.upper()
self._tc.WriteText(char)#
else:
evt.Skip()
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Grid Editor”,
size=(640,480))
grid = wx.grid.Grid(self)
grid.CreateGrid(50,50)
grid.SetDefaultEditor(UpCaseCellEditor())#
app = wx.PySimpleApp()
frame = TestFrame()
frame.Show()
app.MainLoop()
14.4
14.4.1
wx.grid.GridEvent
wx.CommandEvent
14.8
462 / 565

14.8 wx.grid.GridEvent
AltDown()altTrue
ControlDown()controlTrue
GetCol()
GetPosition()wx.Point
GetRow()
MetaDown()metTrue
Selecting()True
False
ShiftDown()shiftTrue
wx.grid.GridEvent14.9
14.9
wx.grid.EVT_GRID_CELL_CHANGE
wx.grid.EVT_GRID_CELL_LEFT_CLICK
wx.grid.EVT_GRID_CELL_LEFT_DCLICK
wx.grid.EVT_GRID_CELL_RIGHT_CLICK
wx.grid.EVT_GRID_CELL_RIGHT_DCLICK
wx.grid.EVT_GRID_EDITOR_HIDDEN
463 / 565

wx.grid.EVT_GRID_EDITOR_SHOWN
wx.grid.EVT_GRID_LABEL_LEFT_CLICK
wx.grid.EVT_GRID_LABEL_LEFT_DCLICK
wx.grid.EVT_GRID_LABEL_RIGHT_CLICK
wx.grid.EVT_GRID_LABEL_RIGHT_DCLICK
wx.grid.EVT_GRID_Select_CELL
wx.grid.GridSizeEvent
wx.grid.EVT_GRID_COL_SIZE
wx.grid.EVT_GRID_ROW_SIZE
5wx.GridEvent!
AltDown(), ControlDown(), GetPosition(), MetaDow(), ShiftDown
wx.grid.GridSizeEventGetRowOrCol()
wx.grid.EVT_GRID_RANGE_Select
wx.grid.GridRangeSelectEvent
GetBottomRightCoords(), GetBottomRow(), GetLeftCol(), GetRightCol(), GetTop
RightCoords()GetTopRow()(row, col)
EVT_GRID_EDITOR_CreateD
wx.grid.GridEditorCreatedEvent
GetCol(), GetRow(), GetControl()
464 / 565

14.4.2
14.10
expandSelectionexpandSelection
True
False
14.10
MoveCursorDown(expandSelection)expandSelection
False""True"shift-"
MoveCursorDownBlock(expandSelection)expandSelection
False"ctrl-"True"shift-ctrl-"
MoveCursorLeft(expandSelection)expandSelectionFalse
""True"shift-"
MoveCursorLeftBlock(expandSelection)expandSelection
False"ctrl-"True"shift-ctrl-"
MoveCursorRight(expandSelection)expandSelection
False""True"shift-"
MoveCursorRightBlock(expandSelection)expandSelection
False"ctrl-"True"shift-ctrl-"
MoveCursorUp(expandSelection)expandSelectionFalse
""True"shift-"
MoveCursorUpBlock(expandSelection)expandSelection
False"ctrl-"True"shift-ctrl-"
MovePageDown()
MovePageUp()
465 / 565

14.5
1
wx.grid.Grid
__init__
2
CreateGrid(numRows, numCols)
SetCellValue(row, col, s)
wx.grid.PyGridTableBase
wx.grid.PyGridTableBaseGetValue(row, col)
SetTable(table)
3
SetCellSize(row, col, numrows, numcols)
4
select*
MakeCellVisible(row, col)
5
wx.Grid.PyGridCellRenderer
6
466 / 565

wx.grid.GridCellEditor
7
467 / 565

15 (tree control)
*
*
*
*
*
HTMLXML
(DOM)
15.1
wx.TreeCtrl15.1
468 / 565

15.1
15.115.1
data.py
15.1
import wx
import data
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”simple tree”, size=(400,500))
# Create the tree
self.tree = wx.TreeCtrl(self)
# Add a root node
root = self.tree.AddRoot(“wx.Object”)
469 / 565

# Add nodes from our data set
self.AddTreeNodes(root, data.tree)
e)
ee)
# Bind some interesting events
self.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded, self.tre
self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed, self.tr
self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, self.tree)
self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnActivated, self.tree)
# Expand the first level
self.tree.Expand(root)
def AddTreeNodes(self, parentItem, items):
”””
Recursively traverses the data structure, adding tree nodes to
match it.
”””
for item in items:
if type(item) == str:
self.tree.AppendItem(parentItem, item)
else:
newItem = self.tree.AppendItem(parentItem, item[0])
self.AddTreeNodes(newItem, item[1])
def GetItemText(self, item):
if item:
return self.tree.GetItemText(item)
else:
return ””
def OnItemExpanded(self, evt):
print ”OnItemExpanded: ”, self.GetItemText(evt.GetItem())
def OnItemCollapsed(self, evt):
print ”OnItemCollapsed:”, self.GetItemText(evt.GetItem())
470 / 565

def OnSelChanged(self, evt):
print ”OnSelChanged: ”, self.GetItemText(evt.GetItem())
def OnActivated(self, evt):
print ”OnActivated: ”, self.GetItemText(evt.GetItem())
app = wx.PySimpleApp(redirect=True)
frame = TestFrame()
frame.Show()
app.MainLoop()
wx.TreeCtrlwxPython
wx.TreeControl(parent, id=-1, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=wx.TR_HAS_BUTTONS,
validator=wx.DefaultValidator, name=”treeCtrl”)
wx.Window
data.py
# Some sample data for the treectrl samples
tree = [
”wx.AcceleratorTable”,
”wx.BrushList”,
”wx.BusyInfo”,
”wx.Clipboard”,
”wx.Colour”,
”wx.ColourData”,
”wx.ColourDatabase”,
”wx.ContextHelp”,
[“wx.DC”, [
”wx.ClientDC”,
[“wx.MemoryDC”, [
”wx.lib.colourchooser.canvas.BitmapBuffer”,
[“wx.BufferedDC”, [
471 / 565

”wx.BufferedPaintDC”, ]]]],
”wx.MetaFileDC”,
”wx.MirrorDC”,
”wx.PaintDC”,
”wx.PostScriptDC”,
”wx.PrinterDC”,
”wx.ScreenDC”,
”wx.WindowDC”,]],
”wx.DragImage”,
”wx.Effects”,
”wx.EncodingConverter”,
[“wx.Event”, [
”wx.ActivateEvent”,
”wx.CalculateLayoutEvent”,
”wx.CloseEvent”,
[“wx.CommandEvent”, [
”wx.calendar.CalendarEvent”,
”wx.ChildFocusEvent”,
”wx.ContextMenuEvent”,
”wx.gizmos.DynamicSashSplitEvent”,
”wx.gizmos.DynamicSashUnifyEvent”,
”wx.FindDialogEvent”,
”wx.grid.GridEditorCreatedEvent”,
”wx.HelpEvent”,
[“wx.NotifyEvent”,[
[“wx.BookCtrlEvent”, [
”wx.ListbookEvent”,
”wx.NotebookEvent ”,]],
”wx.grid.GridEvent”,
”wx.grid.GridRangeSelectEvent”,
”wx.grid.GridSizeEvent”,
”wx.ListEvent”,
”wx.SpinEvent”,
”wx.SplitterEvent”,
”wx.TreeEvent”,
”wx.wizard.WizardEvent ”,]],
[“wx.PyCommandEvent”, [
”wx.lib.colourselect.ColourSelectEvent”,
”wx.lib.buttons.GenButtonEvent”,
472 / 565

”wx.lib.gridmovers.GridColMoveEvent”,
”wx.lib.gridmovers.GridRowMoveEvent”,
”wx.lib.intctrl.IntUpdatedEvent”,
”wx.lib.masked.combobox.MaskedComboBoxSelectEvent”,
”wx.lib.masked.numctrl.NumberUpdatedEvent”,
”wx.lib.masked.timectrl.TimeUpdatedEvent ”,]],
”wx.SashEvent”,
”wx.ScrollEvent”,
”wx.stc.StyledTextEvent”,
”wx.TextUrlEvent”,
”wx.UpdateUIEvent”,
”wx.WindowCreateEvent”,
”wx.WindowDestroyEvent ”,]],
”wx.DisplayChangedEvent”,
”wx.DropFilesEvent”,
”wx.EraseEvent”,
”wx.FocusEvent”,
”wx.IconizeEvent”,
”wx.IdleEvent”,
”wx.InitDialogEvent”,
”wx.JoystickEvent”,
”wx.KeyEvent”,
”wx.MaximizeEvent”,
”wx.MenuEvent”,
”wx.MouseCaptureChangedEvent”,
”wx.MouseEvent”,
”wx.MoveEvent”,
”wx.NavigationKeyEvent”,
”wx.NcPaintEvent”,
”wx.PaintEvent”,
”wx.PaletteChangedEvent”,
”wx.ProcessEvent”,
[“wx.PyEvent”, [
”wx.lib.throbber.UpdateThrobberEvent ”,]],
”wx.QueryLayoutInfoEvent”,
”wx.QueryNewPaletteEvent”,
”wx.ScrollWinEvent”,
”wx.SetCursorEvent”,
”wx.ShowEvent”,
”wx.SizeEvent”,
473 / 565

”wx.SysColourChangedEvent”,
”wx.TaskBarIconEvent”,
”wx.TimerEvent ”,]],
[“wx.EvtHandler”, [
”wx.lib.gridmovers.GridColMover”,
”wx.lib.gridmovers.GridRowMover”,
”wx.html.HtmlHelpController”,
”wx.Menu”,
”wx.Process”,
[“wx.PyApp”, [
[“wx.App”, [
”wx.py.PyAlaCarte.App”,
”wx.py.PyAlaMode.App”,
”wx.py.PyAlaModeTest.App”,
”wx.py.PyCrust.App”,
”wx.py.PyShell.App”,
[“wx.py.filling.App”, [
”wx.py.PyFilling.App ”,]],
[“wx.PySimpleApp”, [
”wx.lib.masked.maskededit.test”,]],
”wx.PyWidgetTester ”,]]]],
”wx.TaskBarIcon”,
[“wx.Timer”, [
”wx.PyTimer ”,]],
[“wx.Validator”, [
[“wx.PyValidator”,[
”wx.lib.intctrl.IntValidator”,]]]],
[“wx.Window”, [
[“wx.lib.colourchooser.canvas.Canvas”, [
”wx.lib.colourchooser.pycolourslider.PyColourSlider”,
”wx.lib.colourchooser.pypalette.PyPalette”,]],
”wx.lib.gridmovers.ColDragWindow”,
[“wx.Control”,[
[“wx.BookCtrl”, [
”wx.Listbook”,
[“wx.Notebook”,[
”wx.py.editor.EditorNotebook”,
”wx.py.editor.EditorShellNotebook”,]] ]],
[“wx.Button”, [
474 / 565

[“wx.BitmapButton”,[
”wx.lib.colourselect.ColourSelect”,
”wx.ContextHelpButton”,
”wx.lib.foldmenu.FoldOutMenu ”,]] ]],
”wx.calendar.CalendarCtrl”,
”wx.CheckBox”,
[“wx.ComboBox”,[
[“wx.lib.masked.combobox.BaseMaskedComboBox”, [
”wx.lib.masked.combobox.ComboBox”,
”wx.lib.masked.combobox.PreMaskedComboBox”,]] ]],
[“wx.ControlWithItems”, [
[“wx.Choice”,[
”wx.DirFilterListCtrl ”,]],
”wx.ListBox”,
”wx.CheckListBox ”,]],
”wx.Gauge”,
”wx.GenericDirCtrl”,
”wx.gizmos.LEDNumberCtrl”,
[“wx.ListCtrl”,[
”wx.ListView ”,]],
[“wx.PyControl”,[
”wx.lib.calendar.Calendar”,
[“wx.lib.buttons.GenButton”,[
[“wx.lib.buttons.GenBitmapButton”,[
[“wx.lib.buttons.GenBitmapTextButton”,[
”wx.lib.buttons.GenBitmapTextToggleButton
“,]],
”wx.lib.buttons.GenBitmapToggleButton ”,]],
”wx.lib.buttons.GenToggleButton ”,]],
”wx.lib.statbmp.GenStaticBitmap”,
”wx.lib.stattext.GenStaticText”,
”wx.lib.popupctl.PopButton”,
”wx.lib.popupctl.PopupControl”,
”wx.lib.ticker.Ticker ”,]],
”wx.RadioBox”,
”wx.RadioButton”,
”wx.ScrollBar”,
”wx.Slider”,
”wx.SpinButton”,
475 / 565

”wx.SpinCtrl”,
[“wx.StaticBitmap”,[
”wx.lib.fancytext.StaticFancyText ”,]],
”wx.StaticBox”,
”wx.StaticLine”,
”wx.StaticText”,
[“wx.stc.StyledTextCtrl”,[
[“wx.py.editwindow.EditWindow”,[
”wx.py.crust.Display”,
”wx.py.editor.EditWindow”,
”wx.py.filling.FillingText”,
”wx.py.shell.Shell”,]],
”wx.lib.pyshell.PyShellWindow ”,]],
[“wx.TextCtrl”, [
[“wx.lib.masked.textctrl.BaseMaskedTextCtrl”,[
”wx.lib.masked.ipaddrctrl.IpAddrCtrl”,
”wx.lib.masked.numctrl.NumCtrl”,
”wx.lib.masked.textctrl.PreMaskedTextCtrl”,
”wx.lib.masked.textctrl.TextCtrl”,
”wx.lib.masked.timectrl.TimeCtrl ”,]],
”wx.py.crust.Calltip”,
”wx.lib.sheet.CTextCellEditor”,
”wx.py.crust.DispatcherListing”,
”wx.lib.intctrl.IntCtrl”,
”wx.lib.rightalign.RightTextCtrl”,
”wx.py.crust.SessionListing”,]],
”wx.ToggleButton”,
”wx.ToolBar”,
[“wx.TreeCtrl”,[
”wx.py.filling.FillingTree”,
”wx.gizmos.RemotelyScrolledTreeCtrl ”,]],
”wx.gizmos.TreeListCtrl ”,]],
”wx.gizmos.DynamicSashWindow”,
”wx.lib.multisash.EmptyChild”,
”wx.glcanvas.GLCanvas”,
”wx.lib.imagebrowser.ImageView”,
”wx.MDIClientWindow”,
”wx.MenuBar”,
”wx.lib.multisash.MultiClient”,
”wx.lib.multisash.MultiCloser”,
476 / 565

”wx.lib.multisash.MultiCreator”,
”wx.lib.multisash.MultiSash”,
”wx.lib.multisash.MultiSizer”,
”wx.lib.multisash.MultiSplit”,
”wx.lib.multisash.MultiViewLeaf”,
[“wx.Panel”,[
”wx.gizmos.EditableListBox”,
[“wx.lib.filebrowsebutton.FileBrowseButton”,[
”wx.lib.filebrowsebutton.DirBrowseButton”,
”wx.lib.filebrowsebutton.FileBrowseButtonWithHistory”,]],
”wx.lib.floatcanvas.FloatCanvas.FloatCanvas”,
”wx.lib.floatcanvas.NavCanvas.NavCanvas”,
”wx.NotebookPage”,
[“wx.PreviewControlBar”,[
”wx.PyPreviewControlBar ”,]],
”wx.lib.colourchooser.pycolourbox.PyColourBox”,
”wx.lib.colourchooser.pycolourchooser.PyColourChooser”,
[“wx.PyPanel”,[
”wx.lib.throbber.Throbber”,]],
”wx.lib.shell.PyShell”,
”wx.lib.shell.PyShellInput”,
”wx.lib.shell.PyShellOutput”,
[“wx.ScrolledWindow”,[
”wx.lib.editor.editor.Editor”,
[“wx.grid.Grid”,[
”wx.lib.sheet.CSheet ”,]],
[“wx.html.HtmlWindow”,[
”wx.lib.ClickableHtmlWindow.PyClickableHtmlWindow”,]],
”wx.PreviewCanvas”,
”wx.lib.printout.PrintTableDraw”,
[“wx.PyScrolledWindow”,[
”wx.lib.scrolledpanel.ScrolledPanel”,]],
”wx.lib.ogl.ShapeCanvas”,
”wx.gizmos.SplitterScrolledWindow ”,]],
[“wx.VScrolledWindow”,[
[“wx.VListBox”, [
”wx.HtmlListBox ”,]] ]],
[“wx.wizard.WizardPage”, [
”wx.wizard.PyWizardPage”,
”wx.wizard.WizardPageSimple ”,]],
477 / 565

”wx.lib.plot.PlotCanvas”,
”wx.lib.wxPlotCanvas.PlotCanvas”,
[“wx.PopupWindow”,[
”wx.lib.foldmenu.FoldOutWindow”,
[“wx.PopupTransientWindow”,[
”wx.TipWindow ”,]] ]],
[“wx.PyWindow”, [
”wx.lib.analogclock.AnalogClockWindow”,]],
”wx.lib.gridmovers.RowDragWindow”,
[“wx.SashWindow”,[
”wx.SashLayoutWindow ”,]],
”wx.SplashScreenWindow”,
[“wx.SplitterWindow”,[
”wx.py.crust.Crust”,
”wx.py.filling.Filling”,
”wx.gizmos.ThinSplitterWindow ”,]],
”wx.StatusBar”,
[“wx.TopLevelWindow”,[
[“wx.Dialog”,[
”wx.lib.calendar.CalenDlg”,
”wx.ColourDialog”,
”wx.DirDialog”,
”wx.FileDialog”,
”wx.FindReplaceDialog”,
”wx.FontDialog”,
”wx.lib.imagebrowser.ImageDialog”,
”wx.MessageDialog”,
”wx.MultiChoiceDialog”,
”wx.lib.dialogs.MultipleChoiceDialog”,
”wx.PageSetupDialog”,
”wx.lib.popupctl.PopupDialog”,
”wx.PrintDialog”,
”wx.lib.dialogs.ScrolledMessageDialog”,
”wx.SingleChoiceDialog”,
”wx.TextEntryDialog”,
”wx.wizard.Wizard ”,]],
[“wx.Frame”, [
”wx.lib.analogclockopts.ACCustomizationFrame”,
”wx.py.filling.FillingFrame”,
[“wx.py.frame.Frame”,[
478 / 565

”wx.py.crust.CrustFrame”,
[“wx.py.editor.EditorFrame”,[
”wx.py.editor.EditorNotebookFrame”,]],
”wx.py.shell.ShellFrame”,]],
”wx.html.HtmlHelpFrame”,
”wx.MDIChildFrame”,
”wx.MDIParentFrame”,
”wx.MiniFrame”,
[“wx.PreviewFrame”,[
”wx.PyPreviewFrame ”,]],
”wx.ProgressDialog”,
”wx.SplashScreen”,
”wx.lib.splashscreen.SplashScreen”,
”wx.lib.masked.maskededit.test2”,
”wx.lib.plot.TestFrame ”,]] ]],
”wx.gizmos.TreeCompanionWindow ”,]] ]] ]],
”wx.FileHistory”,
”wx.FileSystem”,
”wx.FindReplaceData”,
”wx.FontData”,
”wx.FontList”,
”wx.FSFile”,
[“wx.GDIObject”,[
”wx.Bitmap”,
”wx.Brush”,
”wx.Cursor”,
”wx.Font”,
”wx.Icon”,
”wx.Palette”,
”wx.Pen”,
”wx.Region ”,]],
”wx.glcanvas.GLContext”,
[“wx.grid.GridTableBase”, [
”wx.grid.GridStringTable”,
”wx.grid.PyGridTableBase ”,]],
[“wx.html.HtmlCell”, [
”wx.html.HtmlColourCell”,
”wx.html.HtmlContainerCell”,
”wx.html.HtmlFontCell”,
”wx.html.HtmlWidgetCell”,
479 / 565

”wx.html.HtmlWordCell ”,]],
”wx.html.HtmlDCRenderer”,
”wx.html.HtmlEasyPrinting”,
”wx.html.HtmlFilter”,
”wx.html.HtmlLinkInfo”,
[“wx.html.HtmlParser”, [
”wx.html.HtmlWinParser ”,]],
”wx.html.HtmlTag”,
[“wx.html.HtmlTagHandler”, [
[“wx.html.HtmlWinTagHandler”, [
”wx.lib.wxpTag.wxpTagHandler ”,]] ]],
”wx.Image”,
[“wx.ImageHandler”, [
[“wx.BMPHandler”, [
[“wx.ICOHandler”, [
[“wx.CURHandler”, [
”wx.ANIHandler ”,]] ]] ]],
”wx.GIFHandler”,
”wx.JPEGHandler”,
”wx.PCXHandler”,
”wx.PNGHandler”,
”wx.PNMHandler”,
”wx.TIFFHandler”,
”wx.XPMHandler ”,]],
”wx.ImageList”,
”wx.IndividualLayoutConstraint”,
”wx.LayoutAlgorithm”,
[“wx.LayoutConstraints”, [
”wx.lib.anchors.LayoutAnchors”,
”wx.lib.layoutf.Layoutf”,]],
”wx.ListItem”,
”wx.Mask”,
”wx.MenuItem”,
”wx.MetaFile”,
”wx.PageSetupDialogData”,
”wx.PenList”,
”wx.PrintData”,
”wx.PrintDialogData”,
”wx.Printer”,
[“wx.Printout”, [
480 / 565

]
”wx.html.HtmlPrintout”,
”wx.lib.plot.PlotPrintout”,
”wx.lib.printout.SetPrintout ”,]],
[“wx.PrintPreview”, [
”wx.PyPrintPreview ”,]],
”wx.RegionIterator”,
[“wx.Sizer”, [
”wx.BookCtrlSizer”,
[“wx.BoxSizer”, [
”wx.StaticBoxSizer”, ]],
[“wx.GridSizer”, [
[“wx.FlexGridSizer”, [
”wx.GridBagSizer”,]] ]],
”wx.NotebookSizer”,
”wx.PySizer”,]],
[“wx.SizerItem”, [
”wx.GBSizerItem”,]],
”wx.SystemOptions”,
”wx.ToolBarToolBase”,
”wx.ToolTip”,
”wx.gizmos.TreeListColumnInfo”,
”wx.xrc.XmlDocument”,
”wx.xrc.XmlResource”,
”wx.xrc.XmlResourceHandler ”,
15.1.1 root()
root()
AddRoot(text, image=-1, selImage=-1, data=None)
wxPythontext
imagetext
15.5
data
481 / 565

AddRoot()ID
wx.TreeItemIdID
wx.TreeItemId
wx.TreeItemId——
15.1.2
AppendItem(parent, text, image=-1, selImage=-1, data=None)parent
wx.TreeItemIdtext
imageselImageAddRoot()
wx.TreeItemIdID
rootId = tree.AddRoot(“The Root”)
childId = tree.AppendItem(rootId, ”A Child”)
grandChildId = tree.AppendItem(childId, ”A Grandchild”)
root()
PrependItem(parent, text, image=-1, selImage=-1, data=None)
InsertItem(parent, previous, text,image=-1, selImage=-1, data=None)
previouswx.TreeItemId
InsertItemBefore(parent, before, text, image=-1, selImage=-1, data=None)
beforebefore
ID
wx.TreeItemId
15.1.3
Delete(item)item
wx.TreeItemIdEVT_TREE_Delete_ITEM
482 / 565

DeleteChildren(item)
itemwx.TreeItemId
DeleteAllItems()
Windows
GetItemText(item)
itemwx.TreeItemId
SetItemText(item, text)item
wx.TreeItemIdtext
GetCount()
GetChildrenCount(item, recursively=True)itemwx.TreeItemId
recursivelyFalse
True
15.2
15.1
15.1
wx.TR_HAS_BUTTONSWindows+-
wx.TR_NO_BUTTONS
15.2
15.2
wx.TR_LINES_AT_ROOTroot
wx.TR_HIDE_ROOTroot
wx.TR_NO_LINES
wx.TR_LINES_AT_ROOT
wx.TR_ROW_LINES
483 / 565

15.3
15.3
wx.TR_EXTENDED
wx.TR_MULTIPLE
wx.TR_SINGLE
15.4
15.4
wx.TR_FULL_ROW_HIGHLIGHT
Windows
wx.NO_LINES
wx.TR_HAS_VARIABLE_ROW_HEIGHT
wx.TR_HIDE_ROOTAddRoot()root
root
root
wx.TR_DEFAULT_STYLE
SetWindowStyle(styles)
styles
itemwx.TreeItemId
SetItemBackgroundColor(item, col)col
wx.Colour
SetItemTextColour(item,col)
SetItemFont(item, font)fontwx.Font
SetItemBold(item, bold=True)bold
set*get*
GetItemBackgroundColor(item), GetItemTextColour(item), GetItemFont(item),
IsBold(item)itemwx.TreeItemId
484 / 565

15.3
SortChildren(item)
itemwx.TreeItemId
None
15.1
wx.TreeItemDatawxPython
Python
set*SetItemPyData(item, obj)item
wx.TreeItemIdobjPythonwxPython
GetItemPyData(item)
Python
wx.TreeItemData
wx.TreeItemData(obj)objPython
GetItemData(item)SetItemData(item, obj)Python
SetItemPyData()
SetItemPyData(item, obj)
GetItemPyData(item)
wx.TreeCtrl
OnCompareItems(item1, item2)
item1, item2wx.TreeItemIditem1item2
-1item1item21
0
OnCompareItems()
GetItemPyData()
def OnCompareItems(self, item1, item2);
data1 = self.GetItemPyData(item1)
data2 = self.GetItemPyData(item2)
return cmp(data1, data2)
485 / 565

15.4
13
SetImageList(imageList)AssignImageList(imageList)
GetImageList()
15.2
15.2
15.215.2ArtProvider
15.2
#-*- encoding:UTF-8 -*-
import wx
import data
class TestFrame(wx.Frame):
def __init__(self):
486 / 565

wx.Frame.__init__(self, None,
title=”simple tree with icons”, size=(400,500))
#
il = wx.ImageList(16,16)
#
self.fldridx = il.Add(
wx.ArtProvider.GetBitmap(wx.ART_FOLDER,
wx.ART_OTHER, (16,16)))
self.fldropenidx = il.Add(
wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN,
wx.ART_OTHER, (16,16)))
self.fileidx = il.Add(
wx.ArtProvider.GetBitmap(wx.ART_NORMAL_FILE,
wx.ART_OTHER, (16,16)))
#
self.tree = wx.TreeCtrl(self)
#
self.tree.AssignImageList(il)
root = self.tree.AddRoot(“wx.Object”)
self.tree.SetItemImage(root, self.fldridx,
wx.TreeItemIcon_Normal)#
self.tree.SetItemImage(root, self.fldropenidx,
wx.TreeItemIcon_Expanded)
self.AddTreeNodes(root, data.tree)
self.tree.Expand(root)
def AddTreeNodes(self, parentItem, items):
for item in items:
if type(item) == str:
newItem = self.tree.AppendItem(parentItem, item)
self.tree.SetItemImage(newItem, self.fileidx,
wx.TreeItemIcon_Normal)#
else:
newItem = self.tree.AppendItem(parentItem, item[0])
487 / 565

self.tree.SetItemImage(newItem, self.fldridx,
wx.TreeItemIcon_Normal)#
self.tree.SetItemImage(newItem, self.fldropenidx,
wx.TreeItemIcon_Expanded)
self.AddTreeNodes(newItem, item[1])
def GetItemText(self, item):
if item:
return self.tree.GetItemText(item)
else:
return ””
app = wx.PySimpleApp(redirect=True)
frame = TestFrame()
frame.Show()
app.MainLoop()
GetItemImage(item, which=wx.TreeItemIcon_Normal)item
wx.TreeItemIdwhich
wx.TreeItemIcon_Normalwhich
wx.TreeItemIcon_Selected
wx.TreeItemIcon_ExpandedwxTreeItemIcon_SelectedExpanded
——
SetItemImage(item, image, which=wx.TreeItemIcon_Normal)
itemwx.TreeItemIdimagewhichget*
15.5
15.1Python
488 / 565

GetRootItem()
wx.TreeItemIdGetItemText()
GetItemPyData()
GetFirstChild(item)
(child, cookie)itemwx.TreeItemId
cookie
GetFirstChild()cookie
GetNextChild(item, cookie)itemIDcookie
GetFirstChild()GetNextChild()GetNextChild()
(child, cookie)
ID
wx.TreeItemId.IsOk()__nonzero__
def getChildren(tree, parent):
result = []
item, cookie = tree.GetFirstChild(parent)
while item:
result.append(tree.GetItemText(item))
item, cookie = tree.getNextChild(parent, cookie)
return result
result
GetLastChild(item)
wx.TreeItemId
cookie
GetItemParent(item)ID
GetNextSibling(item)GetPrevSibling(item)
wx.TreeItemId
cookie
489 / 565

item.IsOk() == False
ItemHasChildren(item)
TrueFalseSetItemHasChildren(item, hasChildren=True)
15.7
15.6
SelectItem(item,select=True)
itemwx.TreeItemIdselect
Falseitem
SelectItem()item
ToggleItemSelection(item)
item
Unselect()
UnselectAll()
UnselectItem(item)
IsSelected(item)
TrueFalseGetSelection()
wx.TreeItemIdGetSelections()
wx.TreeItemIdPython
wx.EVT_TREE_SEL_CHANGING,
Veto()
wx.EVT_TREE_SEL_CHANGED
wx.TreeEvent15.8
15.7
Collapse(item)Expand(item)
490 / 565

CollapseAndReset(item)
Toggle(item)
IsExpanded(item)
wx.EVT_TREE_ITEM_COLLAPSING wx.EVT_TREE_ITEM_EXPANDING
Veto()
EVT_TREE_ITEM_COLLAPSED
wx.EVT_TREE_ITEM_EXPANDEDwx.TreeEvent
15.3
15.3
#-*- encoding:UTF-8 -*-
import wx
import data
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”virtual tree with icons”, size=(400,500))
il = wx.ImageList(16,16)
self.fldridx = il.Add(
wx.ArtProvider.GetBitmap(wx.ART_FOLDER, wx.ART_OTHER, (16,16)))
self.fldropenidx = il.Add(
wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_OTHER, (16,
16)))
self.fileidx = il.Add(
wx.ArtProvider.GetBitmap(wx.ART_NORMAL_FILE, wx.ART_OTHER, (1
6,16)))
self.tree = wx.TreeCtrl(self)
self.tree.AssignImageList(il)
root = self.tree.AddRoot(“wx.Object”)
self.tree.SetItemImage(root, self.fldridx,
491 / 565

wx.TreeItemIcon_Normal)
self.tree.SetItemImage(root, self.fldropenidx,
wx.TreeItemIcon_Expanded)
# Instead of adding nodes for the whole tree, just attach some
# data to the root node so that it can find and add its child
# nodes when it is expanded, and mark it as having children so
# it will be expandable.
self.tree.SetItemPyData(root, data.tree)#
self.tree.SetItemHasChildren(root, True)
# Bind some interesting events
#
self.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded, self.tre
e)
self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed, self.tr
ee)
self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, self.tree)
self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnActivated, self.tree)
ree)
self.Bind(wx.EVT_TREE_ITEM_EXPANDING, self.OnItemExpanding, self.t
self.tree.Expand(root)
def AddTreeNodes(self, parentItem):#
”””
Add nodes for just the children of the parentItem
”””
items = self.tree.GetItemPyData(parentItem)
for item in items:
if type(item) == str:
# a leaf node
newItem = self.tree.AppendItem(parentItem, item)
self.tree.SetItemImage(newItem, self.fileidx,
wx.TreeItemIcon_Normal)
else:
# this item has children
newItem = self.tree.AppendItem(parentItem, item[0])
self.tree.SetItemImage(newItem, self.fldridx,
492 / 565

wx.TreeItemIcon_Normal)
self.tree.SetItemImage(newItem, self.fldropenidx,
wx.TreeItemIcon_Expanded)
self.tree.SetItemPyData(newItem, item[1])
self.tree.SetItemHasChildren(newItem, True)
def GetItemText(self, item):
if item:
return self.tree.GetItemText(item)
else:
return ””
def OnItemExpanded(self, evt):
print ”OnItemExpanded: ”, self.GetItemText(evt.GetItem())
def OnItemExpanding(self, evt):#
# When the item is about to be expanded add the first level of child nodes
print ”OnItemExpanding:”, self.GetItemText(evt.GetItem())
self.AddTreeNodes(evt.GetItem())
def OnItemCollapsed(self, evt):
print ”OnItemCollapsed:”, self.GetItemText(evt.GetItem())
# And remove them when collapsed as we don’t need them any longer
self.tree.DeleteChildren(evt.GetItem())#
def OnSelChanged(self, evt):
print ”OnSelChanged: ”, self.GetItemText(evt.GetItem())
def OnActivated(self, evt):
print ”OnActivated: ”, self.GetItemText(evt.GetItem())
app = wx.PySimpleApp(redirect=True)
frame = TestFrame()
frame.Show()
app.MainLoop()
493 / 565

IsVisible(item)
TrueFalseEnsureVisible(item)
ScrollTo(item)
GetFirstVisibleItem()
wx.TreeItemId
GetNextVisible(item)itemGetFirstVisibleItem()
GetNextVisible()
GetPreviousVisible(item)item
GetIndent()SetIndent(indent)
indent
HitTest(point)point
wx.Point(item, flags)
itemwx.TreeItemIdNone
flags
15.5flags
GetBoundingRect(item, textOnly=False)wx.Rect
itemwx.TreeItemId
textOnlyTrue
False
item
None
494 / 565

15.5
wx.TREE_HITTEST_ABOVE
wx.TREE_HITTEST_BELOW
wx.TREE_HITTEST_NOWhere
wx.TREE_HITTEST_ONITEMBUTTON/
wx.TREE_HITTEST_ONITEMICON
wx.TREE_HITTEST_ONITEMINDENT
wx.TREE_HITTEST_ONITEMLABEL
wx.TREE_HITTEST_ONITEMRIGHT
wx.TREE_HITTEST_ONITEMSTATEICON
wx.TREE_HITTEST_TOLEFT
wx.TREE_HITTEST_TORIGHT
15.8
wx.TR_EDIT_LABELS
esc
EditLabel(item)item
wx.TreeItemId
EndEditLabel(cancelEdit)
IDcancelEditTrue
495 / 565

False
GetEditControl()wx.TextCtrl
NoneWindows
EditLabel()
wx.EVT_TREE_BEGIN_LABEL_EDITwx.TreeEvent
Veto()
EndEditLabel()
wx.EVT_TREE_END_LABEL_EDIT
15.9
wx.TreeEvent15.6
15.6 wx.TreeEvent
GetKeyCode()wx.EVT_TREE_KEY_DOWN
CTRL,SHIFT,and ALT
GetItem()wx.TreeItemId
GetKeyEvent()wx.EVT_TREE_KEY_DOWNwx.KeyEvent
GetLabel()wx.EVT_TREE_BEGIN_LABEL_EDIT
wx.EVT_TREE_END_LABEL_EDIT
GetPoint()wx.Point
IsEditCancelled()wx.EVT_TREE_END_LABEL_EDIT
TrueFalse
SetToolTip(tooltip)wx.EVT_TREE_ITEM_GETTOOLTIP
Windows
15.715.6wx.TreeEvent
496 / 565

15.7
wx.EVT_TREE_BEGIN_DRAG
Allow()
wx.EVT_TREE_BEGIN_RDRAG
Allow()
wx.EVT_TREE_ITEM_ACTIVATED
wx.EVT_TREE_ITEM_GETTOOLTIP
wx.EVT_TREE_KEY_DOWN
15.10
wx.TreeCtrlwxPythonwx.gizmos.TreeListCtrl
wx.TreeCtrl
TreeListCtrl15.3
497 / 565

15.3
15.4
15.4
import wx
import wx.gizmos
import data
class TestFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”TreeListCtrl”, size=(400,500))
# Create an image list
il = wx.ImageList(16,16)
# Get some standard images from the art provider and add them
# to the image list
self.fldridx = il.Add(
wx.ArtProvider.GetBitmap(wx.ART_FOLDER, wx.ART_OTHER, (16,16)))
self.fldropenidx = il.Add(
498 / 565

wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_OTHER, (16,
16)))
self.fileidx = il.Add(
wx.ArtProvider.GetBitmap(wx.ART_NORMAL_FILE, wx.ART_OTHER, (1
6,16)))
# Create the tree
#
self.tree = wx.gizmos.TreeListCtrl(self, style =
wx.TR_DEFAULT_STYLE
| wx.TR_FULL_ROW_HIGHLIGHT)
# Give it the image list
self.tree.AssignImageList(il)
# create some columns
#
self.tree.AddColumn(“Class Name”)
self.tree.AddColumn(“Description”)
self.tree.SetMainColumn(0) # the one with the tree in it...
self.tree.SetColumnWidth(0, 200)
self.tree.SetColumnWidth(1, 200)
# Add a root node and assign it some images
root = self.tree.AddRoot(“wx.Object”)
self.tree.SetItemText(root, ”A description of wx.Object”, 1)#
self.tree.SetItemImage(root, self.fldridx,
wx.TreeItemIcon_Normal)
self.tree.SetItemImage(root, self.fldropenidx,
wx.TreeItemIcon_Expanded)
# Add nodes from our data set
self.AddTreeNodes(root, data.tree)
e)
# Bind some interesting events
self.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded, self.tre
499 / 565

ee)
self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed, self.tr
self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, self.tree)
self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnActivated, self.tree)
# Expand the first level
self.tree.Expand(root)
def AddTreeNodes(self, parentItem, items):
”””
Recursively traverses the data structure, adding tree nodes to
match it.
”””
for item in items:
if type(item) == str:
newItem = self.tree.AppendItem(parentItem, item)
self.tree.SetItemText(newItem, ”A description of %s” % item, 1)#
self.tree.SetItemImage(newItem, self.fileidx,
wx.TreeItemIcon_Normal)
else:
newItem = self.tree.AppendItem(parentItem, item[0])
self.tree.SetItemText(newItem, ”A description of %s” % item[0], 1)
self.tree.SetItemImage(newItem, self.fldridx,
wx.TreeItemIcon_Normal)
self.tree.SetItemImage(newItem, self.fldropenidx,
wx.TreeItemIcon_Expanded)
self.AddTreeNodes(newItem, item[1])
def GetItemText(self, item):
if item:
return self.tree.GetItemText(item)
else:
return ””
def OnItemExpanded(self, evt):
print ”OnItemExpanded: ”, self.GetItemText(evt.GetItem())
500 / 565

def OnItemCollapsed(self, evt):
print ”OnItemCollapsed:”, self.GetItemText(evt.GetItem())
def OnSelChanged(self, evt):
print ”OnSelChanged: ”, self.GetItemText(evt.GetItem())
def OnActivated(self, evt):
print ”OnActivated: ”, self.GetItemText(evt.GetItem())
app = wx.PySimpleApp(redirect=True)
frame = TestFrame()
frame.Show()
app.MainLoop()
15.11
1XML
wx.TreeCtrlwx.TreeCtrl
2
AddRoot(text, image=-1, selImage=-1, data=None)
rootwx.TreeItemIdwx.TreeItemId
IDroot
AppendItem(parent, text, image=-1, selImage=-1, data=None)
parentIDwx.TreeItemId
Delete(item)
DeleteChildren(item)
3
root
root
501 / 565

4
SetItemPyData(item, obj)Python
wx.TreeCtrl
OnCompareItems(item1, item2)item1item2ID
5
SetImageList(imageList)AssignImageList(imageList)
6
GetFirstChild(item)
7SelectItem(item, select=True)
ToggleItemSelection(item)
IsSelected(item)Expand(item)
Collapse(item)Toggle(item)
8wx.TR_EDIT_LABELS
esc
wx.EVT_TREE_END_LABEL_EDIT
wx.TreeEvent
502 / 565

16 HTML
* wxPythonHTML
* HTML
* HTML(parser)
*
* HTML
HTML
HTMLHTML
HTML
wxPythonHTML
HTML
wxPythonHTML
16.1 HTML
wxPythonHTML
HTML
URL
16.1.1 wxPythonHTML
wxPythonHTMLwxPython
wx.html.HtmlWindow16.1
503 / 565

16.1
16.116.1
16.1 HtmlWindow
import wx
import wx.html
class MyHtmlFrame(wx.Frame):
def __init__(self, parent, title):
wx.Frame.__init__(self, parent, -1, title)
html = wx.html.HtmlWindow(self)
if ”gtk2” in wx.PlatformInfo:
html.SetStandardFonts()
html.SetPage(
”Here is some formatted text ”
”loaded from a string.”)
app = wx.PySimpleApp()
frm = MyHtmlFrame(None, ”Simple HTML”)
frm.Show()
app.MainLoop()
wx.html.HtmlWindowwx.ScrolledWindow
wx.html.HtmlWindow(parent, id=-1, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=wx.html.HW_SCROLLBAR_AUTO,
504 / 565

name=”htmlWindow”)
wx.html.HW_SCROLLBAR_AUTOHTML
wx.html.HW_SCROLLBAR_NEVER
HTML
wx.html.HW_NO_SelectION
HTMLHTMLHTML
wx.html.HtmlWindow
(css)JavaScript16.1HTML
web
16.1
16.1 HTML
HTMLwx.Image
wx.Image
505 / 565

URLHTML
16.1.2 URLHTML
HTMLHTML
HTML
* SetPage(source)
* AppendToPage(source)
* LoadFile(filename)
* LoadPage(location)
SetPage(source)source
HTML
AppendToPage(source)HTML
SetPage()AppendToPage()sourceHTML
HTML
LoadFile(filename)
MIMEHTML
LoadPage(location)URLlocationURL
MIMEURL
506 / 565

16.2HTML
16.2
16.216.2
16.2 webHTML
import wx
import wx.html
class MyHtmlFrame(wx.Frame):
def __init__(self, parent, title):
wx.Frame.__init__(self, parent, -1, title, size=(600,400))
html = wx.html.HtmlWindow(self)
if ”gtk2” in wx.PlatformInfo:
html.SetStandardFonts()
wx.CallAfter(
html.LoadPage, ”http://www.wxpython.org”)
app = wx.PySimpleApp()
frm = MyHtmlFrame(None, ”Simple HTML Browser”)
frm.Show()
app.MainLoop()
507 / 565

16.2LoadPage()
URLURL
HTML
16.2 HTML
HTML
16.2.1
wx.html.HtmlWindow
wx.html.HtmlWindow
16.2wx.html.HtmlWindow
HTML
16.2 wx.html.HtmlWindow
OnCellClicked(cell, x, y, event)HTMLcell
wx.html.HtmlCell
wx.html.HtmlCellHTMLx,y
eventcell
OnLinkClicked()
OnCellMouseHover(cell, x, y)HTML
OnCellClicked()
OnLinkClicked(link)
URLLoadPageHtmlWindow
Pythonwebbrowser
508 / 565

OnOpeningURL(type, url)URL
type
wx.html.HTML_URL_PAGE, wx.html.HTML_URL_IMAGE,
wx.html.HTML_URL_OTHER——wx.html.HTML_OPEN
;wx.html.HTML_BLOCK;URL
wx.html.HTML_OPEN
OnSetTitle(title)HTML
HTML
16.2.2 HTML
HTML
Web
HTMLHTML
GetOpenedPage()URL
LoadPage()
URL
GetOpenedAnchor()
anchorLoadPage()
HTMLGetOpenedPageTitle()
SelectAll()
SelectLine(pos)SelectWord(pos)
poswx.Point
SelectionToText()
ToText()
wx.html.HtmlWindow16.3
509 / 565

16.3
HistoryBack()False
HistoryCanBack()TrueFalse
HistoryCanForward()TrueFalse
HistoryClear()
HistoryForward()False
SetFonts(normal_face, fixed_face, sizes=None)normal_face
normal_face
fixed_face
fixed_facesizes7
HTML2~
+4None
wx.html.HTML_FONT_SIZE_nn1~7
HTML
SetStandardFonts()
GTK2wxPython
HTMLSetBorders(b)b
HTML
16.2.3
web
wxPython
16.3web
Html
510 / 565

16.316.3
16.3 HTML
16.3 webHTMLWindow
#-*- encoding:UTF-8 -*-
import wx
import wx.html
class MyHtmlFrame(wx.Frame):
def __init__(self, parent, title):
wx.Frame.__init__(self, parent, -1, title, size=(600,400))
self.CreateStatusBar()
html = wx.html.HtmlWindow(self)
if ”gtk2” in wx.PlatformInfo:
html.SetStandardFonts()
html.SetRelatedFrame(self, self.GetTitle() + ” -- %s”) #HTML
html.SetRelatedStatusBar(0) #HTML
wx.CallAfter(
html.LoadPage, ”http://www.wxpython.org”)
511 / 565

app = wx.PySimpleApp()
frm = MyHtmlFrame(None, ”Simple HTML Browser”)
frm.Show()
app.MainLoop()
SetRelatedFrame(frame, format)
frameformat
“My wxPython Browser: %s”:%s
%sHTML
SetRelatedStatusBar(bar)
SetRelatedFrame()bar
0bar
bar1,
URL
16.2.4 HTML
HTMLHTML
wx.html.HtmlEasyPrinting
wx.html.HtmlEasyPrinting
wx.html.HtmlEasyPrinting(name=”Printing”, parentWindow=None)
nameparentWindow
parentWindow
parentWindowNone
wx.html.HtmlEasyPrintingwxPython
PrinterSetup()PageSetup()
GetPrintData()GetPageSetupData()GetPrintData()
512 / 565

wx.PrintDataGetPageSetupData()wx.PageSetupDialogData
17
SetFonts(normal_face, fixed_face, sizes)
HTMLSetFonts()
HTMLSetHeader(header, pg)
SetFooter(footer, pg)headerfooter
@PAGENUM@
@PAGENUM@pg
wx.PAGE_ALLwx.PAGE_EVENwx.PAGE_ODD
pg
PreviewFile(htmlfile)htmlfileHTML
PreviewText(htmlText, basepath=””)htmlText
HTMLbasepathURL
TrueFalse
wx.Printer.GetLastError()
17
HTML
PrintFile(htmlfile)PrintText(htmlText, basepath)
True
HTML
16.3 HTML
HTMLHTML
HTMLwxPython
HTML
513 / 565

16.3.1 HTML(parser)
wxPythonHTML
wx.html.HtmlWindowPython
HTMLPython
htmllibHTMLParserPython
“Beautiful Soup”
wx.html.HtmlParser
wx.html.HtmlWinParserwx.html.HtmlParser
wx.html.HtmlWindowHTML
wx.html.HtmlWinParser
HTML
wx.html.HtmlWinParser()wx.html.HtmlWinParser
wx.html.HtmlParser
wx.html.HtmlWinParser(wnd)wx.html.HtmlWinParser()
wx.html.HtmlWindowwndHTML
Parse(source)source
HTML
wx.html.HtmlWinParserwx.html.HtmlCell
HTMLHTML
wx.html.HtmlCell
wx.html.HtmlContainerCell
wx.html.HtmlContainerCell
Draw(dc, x, y, view_y1, view_y2)HTML
wx.html.HtmlWidgetCell
wxPythonHTML
HTML
wx.html.HtmlWidgetCell
wx.html.HtmlWidgetCell(wnd, w=0)
514 / 565

wndwxPythonww
01100wnd
w%
HTML
wxWidget
16.3.2
HTML
HTML
HTML
HTML
16.4HTML
16.4
16.416.4
16.4
import wx
import wx.html
515 / 565

page = ”””
This silly example shows how custom tags can be defined and used in a
wx.HtmlWindow. We’ve defined a new tag, that will change
the foreground color of the portions of the document that
it encloses to some shade of blue. The tag handler can also use
parameters specifed in the tag, for example:
Sky Blue
Midnight Blue
Dark Blue
Navy Blue
“””
class BlueTagHandler(wx.html.HtmlWinTagHandler):#
def __init__(self):
wx.html.HtmlWinTagHandler.__init__(self)
def GetSupportedTags(self):#
return ”BLUE”
def HandleTag(self, tag):#
old = self.GetParser().GetActualColor()
clr = ”#0000FF”
if tag.HasParam(“SHADE”):
shade = tag.GetParam(“SHADE”)
if shade.upper() == ”SKY”:
clr = ”#3299CC”
if shade.upper() == ”MIDNIGHT”:
clr = ”#2F2F4F”
elif shade.upper() == ”DARK”:
clr = ”#00008B”
elif shade.upper == ”NAVY”:
clr = ”#23238E”
516 / 565

self.GetParser().SetActualColor(clr)
self.GetParser().GetContainer().InsertCell(wx.html.HtmlColourCell(clr))
self.ParseInner(tag)
self.GetParser().SetActualColor(old)
self.GetParser().GetContainer().InsertCell(wx.html.HtmlColourCell(old))
return True
wx.html.HtmlWinParser_AddTagHandler(BlueTagHandler)
class MyHtmlFrame(wx.Frame):
def __init__(self, parent, title):
wx.Frame.__init__(self, parent, -1, title)
html = wx.html.HtmlWindow(self)
if ”gtk2” in wx.PlatformInfo:
html.SetStandardFonts()
html.SetPage(page)
app = wx.PySimpleApp()
frm = MyHtmlFrame(None, ”Custom HTML Tag Handler”)
frm.Show()
app.MainLoop()
wx.Html.TagHTML
16.4wx.Html.Tag
16.4 wx.Html.Tag
GetAllParams()
GetName()
HasParam(param)True
517 / 565

GetParam(param, with_commas=False)param
with_commas True
GetParamAsColour(param)
wx.ColorGetParamAsInt(param)
HasEnding()Truefalse
HTMLwx.html.HtmlWinTagHandler
GetSupportedTags()
GetSupportedTags(self):
return ”MYTAG,MYTAGPARAM”
HandleTag(tag)HandleTag(tag)
GetParser()
HandleTag(tag)
1
2
3
4
GetParser()
Container()
wx.html.HTMLCellInsertCell(cell)
OpenContainer()
InsertCell(cell)
CloseContainer()
OpenContainer()CloseContainer()
HTML
518 / 565

——
parser = self.GetParser()
parser.CloseContainer()#
parser.OpenContainer()#
#
parser.CloseContainer()
parser.OpenContainer()
16.3.3
HTMLMIMEtext/html, text/txt,
image/*wxPython
HTMLHTML
wx.html.HtmlFilter
XMLPython
filterwx.html.HtmlFilter
wx.html.HtmlFilter
CanRead(file)filewx.FSFilewxPython
wx.FSFile
GetMimeType()MIMEMIME
GetLocation()
URLCanRead()
TrueFalsePythonCanRead()
CanRead(self, file):
return file.GetLocation().endswith(‘.py’)
ReadFile(file)file
HTML
519 / 565

wxWidgets C++
file.GetLocation()Python
wx.html.HtmlWindow
wx.html.HtmlWindowAddFilter(filter)filter
wx.html.HtmlFilter
CanRead()
16.3.4 HTML
wx.html.HtmlWindow
HTMLWindows
wx.lib.iewin.IEHtmlWindowInternet Explorer ActiveX
ie
IEwxPythonHTML
wx.lib.iewin.IEHtmlWindow(self, parent, ID=-1,
pos=wx.DefaultPosition, size=wx.DefaultSize, style=0,
name=’IEHtmlWindow’)
parentIDwxPython IDIE
HTMLIELoadString(html)
htmlHTMLLoadStream(stream)
PythonLoadString(URL)
URLGetText(asHTML)
asHTMLTrueHTML
wxMozilla(http://
wxmozilla.sourceforge.net)Mozilla Gecko
wxPythonwxMozillaWindowsLinux
Mac OS X
520 / 565

16.4
1HTMLInternetwxPythonHTML
HTMLHTML
wx.html.HtmlWindowHTMLHTML
2HTMLURL
HTML
HTML
wx.Html.HtmlEasyPrinting
3wxPythonHTML
HTML
4HTML
IEwxPythonWindows
Mozilla Gecko HTMLwxPython
17 wxPython
521 / 565

17 wxPython
* wxPython
*
*
*
*
16wxPython
wx.HtmlEasyPrintingHTMLHTML
wxPython
wx.Printout
wx.Printer
wx.PrintPreview
17.1 wxPython
wx.Printoutwx.Printout
wx.Printoutwx.Printout
7
wxPython17.1
522 / 565

17.1
17.1.1
wx.Printer
wx.Printer(data=None)
datawx.PrintDialogData
wx.PrinterPrint(parent, printout, prompt=True)parent
printoutwx.Printout
promptTruewxPython
Print()wx.Printout
OnPreparePrint()OnPreparePrint()wx.Printout
OnBeginPrinting()
——
OnBeginPrinting()
523 / 565

OnBeginDocument(startPage, endPage)startPage, endPage
wxPython
wx.DC.StartDoc()wxPython
base_OnBeginDocument(startPage, endPage)
OnBeginDocumentFalse
OnPrintPage(pageNum)
pageNum
GetDC()GetDC()
Windows
GetDC()wx.PrinterDC
wx.PostScriptDC
GetDC()wx.MemoryDC
OnEndDocument()
OnEndDocument()
base_OnEndDocument()base_OnEndDocument()wx.DC.EndDoc()
OnEndPrinting()
wx.PrintoutHasPage(pageNum)
pageNum
TrueFalse
17.1.2
17.2
524 / 565

17.1
17.1
17.1
import wx
import os
FONTSIZE = 10
class TextDocPrintout(wx.Printout):
”””
A printout class that is able to print simple text documents.
Does not handle page numbers or titles, and it assumes that no
lines are longer than what will fit within the page width. Those
features are left as an exercise for the reader. ;-)
”””
def __init__(self, text, title, margins):
525 / 565

wx.Printout.__init__(self, title)
self.lines = text.split(‘\n’)
self.margins = margins
def HasPage(self, page):
return page

self.x1 = topLeft.x * self.logUnitsMM
self.y1 = topLeft.y * self.logUnitsMM
self.x2 = dc.DeviceToLogicalXRel(dw) - bottomRight.x * self.logUnitsMM
self.y2 = dc.DeviceToLogicalYRel(dh) - bottomRight.y * self.logUnitsMM
# use a 1mm buffer around the inside of the box, and a few
# pixels between each line
self.pageHeight = self.y2 - self.y1 - 2*self.logUnitsMM
font = wx.Font(FONTSIZE, wx.TELETYPE, wx.NORMAL, wx.NORMAL)
dc.SetFont(font)
self.lineHeight = dc.GetCharHeight()
self.linesPerPage = int(self.pageHeight/self.lineHeight)
def OnPreparePrinting(self):
# calculate the number of pages
dc = self.GetDC()
self.CalculateScale(dc)
self.CalculateLayout(dc)
self.numPages = len(self.lines) / self.linesPerPage
if len(self.lines) % self.linesPerPage != 0:
self.numPages += 1
def OnPrintPage(self, page):
dc = self.GetDC()
self.CalculateScale(dc)
self.CalculateLayout(dc)
# draw a page outline at the margin points
dc.SetPen(wx.Pen(“black”, 0))
dc.SetBrush(wx.TRANSPARENT_BRUSH)
r = wx.RectPP((self.x1, self.y1),
(self.x2, self.y2))
dc.DrawRectangleRect(r)
dc.SetClippingRect(r)
# Draw the text lines for this page
line = (page-1) * self.linesPerPage
x = self.x1 + self.logUnitsMM
527 / 565

y = self.y1 + self.logUnitsMM
while line < (page * self.linesPerPage):
dc.DrawText(self.lines[line], x, y)
y += self.lineHeight
line += 1
if line >= len(self.lines):
break
return True
class PrintFrameworkSample(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, size=(640, 480),
title=”Print Framework Sample”)
self.CreateStatusBar()
# A text widget to display the doc and let it be edited
self.tc = wx.TextCtrl(self, -1, ””,
style=wx.TE_MULTILINE|wx.TE_DONTWRAP)
self.tc.SetFont(wx.Font(FONTSIZE, wx.TELETYPE, wx.NORMAL, wx.NOR
MAL))
filename = os.path.join(os.path.dirname(__file__), ”sample-text.txt”)
self.tc.SetValue(open(filename).read())
self.tc.Bind(wx.EVT_SET_FOCUS, self.OnClearSelection)
wx.CallAfter(self.tc.SetInsertionPoint, 0)
# Create the menu and menubar
menu = wx.Menu()
item = menu.Append(-1, ”Page Setup...\tF5”,
”Set up page margins and etc.”)
self.Bind(wx.EVT_MENU, self.OnPageSetup, item)
item = menu.Append(-1, ”Print Setup...\tF6”,
”Set up the printer options, etc.”)
self.Bind(wx.EVT_MENU, self.OnPrintSetup, item)
item = menu.Append(-1, ”Print Preview...\tF7”,
”View the printout on-screen”)
self.Bind(wx.EVT_MENU, self.OnPrintPreview, item)
item = menu.Append(-1, ”Print...\tF8”, ”Print the document”)
self.Bind(wx.EVT_MENU, self.OnPrint, item)
menu.AppendSeparator()
528 / 565

item = menu.Append(-1, ”E&xit”, ”Close this application”)
self.Bind(wx.EVT_MENU, self.OnExit, item)
menubar = wx.MenuBar()
menubar.Append(menu, ”&File”)
self.SetMenuBar(menubar)
# initialize the print data and set some default values
self.pdata = wx.PrintData()
self.pdata.SetPaperId(wx.PAPER_LETTER)
self.pdata.SetOrientation(wx.PORTRAIT)
self.margins = (wx.Point(15,15), wx.Point(15,15))
def OnExit(self, evt):
self.Close()
def OnClearSelection(self, evt):
evt.Skip()
wx.CallAfter(self.tc.SetInsertionPoint,
self.tc.GetInsertionPoint())
def OnPageSetup(self, evt):
data = wx.PageSetupDialogData()
data.SetPrintData(self.pdata)
data.SetDefaultMinMargins(True)
data.SetMarginTopLeft(self.margins[0])
data.SetMarginBottomRight(self.margins[1])
dlg = wx.PageSetupDialog(self, data)
if dlg.ShowModal() == wx.ID_OK:
data = dlg.GetPageSetupData()
self.pdata = wx.PrintData(data.GetPrintData()) # force a copy
self.pdata.SetPaperId(data.GetPaperId())
self.margins = (data.GetMarginTopLeft(),
data.GetMarginBottomRight())
dlg.Destroy()
529 / 565

def OnPrintSetup(self, evt):
data = wx.PrintDialogData(self.pdata)
dlg = wx.PrintDialog(self, data)
dlg.GetPrintDialogData().SetSetupDialog(True)
dlg.ShowModal();
data = dlg.GetPrintDialogData()
self.pdata = wx.PrintData(data.GetPrintData()) # force a copy
dlg.Destroy()
def OnPrintPreview(self, evt):
data = wx.PrintDialogData(self.pdata)
text = self.tc.GetValue()
printout1 = TextDocPrintout(text, ”title”, self.margins)
printout2 = None #TextDocPrintout(text, ”title”, self.margins)
preview = wx.PrintPreview(printout1, printout2, data)
if not preview.Ok():
wx.MessageBox(“Unable to create PrintPreview!”, ”Error”)
else:
# create the preview frame such that it overlays the app frame
frame = wx.PreviewFrame(preview, self, ”Print Preview”,
pos=self.GetPosition(),
size=self.GetSize())
frame.Initialize()
frame.Show()
def OnPrint(self, evt):
data = wx.PrintDialogData(self.pdata)
printer = wx.Printer(data)
text = self.tc.GetValue()
printout = TextDocPrintout(text, ”title”, self.margins)
useSetupDialog = True
if not printer.Print(self, printout, useSetupDialog) \
and printer.GetLastError() == wx.PRINTER_ERROR:
wx.MessageBox(
”There was a problem printing.\n”
”Perhaps your current printer is not set correctly”,
530 / 565

”Printing Error”, wx.OK)
else:
data = printer.GetPrintDialogData()
self.pdata = wx.PrintData(data.GetPrintData()) # force a copy
printout.Destroy()
app = wx.PySimpleApp()
frm = PrintFrameworkSample()
frm.Show()
app.MainLoop()
17.2
OnPreparePrinting()OnPrintPage()
OnPrint()
wx.Printout
17.1.3 wx.Printout
wx.Printoutget*
17.1
17.1 wx.Printout
GetDC()
GetPageInfo()
(minPage, maxPage, pageFrom, pageTo)minPage, maxPage
132000pageFrom, pageTo
1
GetPageSizeMM()(w, h)
531 / 565

GetPageSizePixels()(w, h)
GetPPIPrinter()(w, h)
GetPPIScreen()(w, h)
GetTitle()
17.2
wxPython
17.2.1
17.3
17.3
532 / 565

wx.PrintDialog
wx.PrintDialog(parent, data=None)
parentdata
wx.PrintDialogData
ShowModal()
ShowModal()wx.ID_OK
wx.ID_CANCEL GetPrintDialogData()
GetPrintDC()
GetPrintDC()
None17.1OnPrintSetup()
wx.PrintData
wx.PrintData
wx.PrintDialogData()wx.PrintDialogData
wx.PrintDialogData
EnableHelp(enable)
EnablePageNumbers(enable)
EnablePrintToFile(enable)EnableSelection(enable)
17.2
17.2 wx.PrintDialogData
GetAllPages()True
SetCollate(flag)
GetCollate()True
533 / 565

SetFromPage(page)
GetFromPage()
SetMaxPage(page)
GetMaxPage()
SetMinPage(page)
GetMinPage()
SetNoCopies()
GetNoCopies()
SetPrintData(printData)
GetPrintData()wx.PrintData
SetPrintToFile(flag)
GetPrintToFile()True“
”wxPython
SetSelection(flag)
GetSelection()True
SetToPage(page)
GetToPage()
GetPrintData()wx.PrintData
17.3
wx.PrintData
17.3 wx.PrintData
SetColour(flag)
GetColour()True
SetDuplex(mode)
GetDuplex()wx.DUPLEX_SIMPLE
wx.DUPLEX_HORIZONTAL
wx.DUPLEX_VERTICAL
SetOrientation(orientation)
GetOrientation()wx.LANDSCAPE
wx.PORTRAIT
534 / 565

SetPaperId(paperId)
GetPaperId()
wx.PAPER_LETTER, wx.PAPER_LEGAL, wx.PAPER_A4
IDwxWidgets
SetPrinterName(printerName)
GetPrinterName()
SetQuality(quality)
GetQuality()set*
wx.PRINT_QUALITY_DRAFT, wx.PRINT_QUALITY_HIGH, wx.PRINT_QUALITY_
MEDIUM, wx.PRINT_QUALITY_LOWget*
17.3
17.4
17.4
17.3.1
wx.PageSetupDialog
535 / 565

wx.PageSetupDialog(parent, data=None)
parentdatawx.PageSetupDialogData
None
ShowModal()
wx.ID_OKwx.ID_CANCEL
GetPageSetupDialogData()
GetPageSetupDialogData()wx.PageSetupDialogData
17.3.2
wx.PageSetupDialogData17.4
True
17.4 wx.PageSetupDialogData
GetDefaultMinMargins()
SetDefaultMinMargins(flag)TrueWindows
GetDefaultInfo()
SetDefaultInfo(flag)TrueWindows
EnableHelp(flag)
GetEnableHelp()True
EnableMargins(flag)
GetEnableMargins()True
EnableOrientation(flag)
GetEnableOrientation()True
EnablePaper(flag)
GetEnablePaper()True
536 / 565

EnablePrinter(flag)
GetEnablePrinter()True
17.5wx.PageSetupDialogData
17.5 wx.PageSetupDialogData
GetMarginTopLeft()
SetMarginTopLeft(pt)get*wx.Pointxy
set*wx.PointPython
GetMarginBottomRight()
SetMarginBottomRight(pt)get*wx.Pointx
yset*wx.PointPython
GetMinMarginTopLeft()
SetMinMarginTopLeft(pt)GetMarginTopLeft()
GetMinMarginBottomRight()
SetMinMarginBottomRight(pt)GetMarginBottomRight()
GetPaperId()
SetPaperId(id)wxPythonwx.PrinterData
GetPaperSize()
SetPaperSize(size)get*wx.Size
GetPrintData()
SetPrintData(printData)get*wx.PrintData
537 / 565

17.4
wx.Printer
17.1
OnPrint()
wx.Printout
wx.PrintDialogData
wx.Printer(data=None)data
wx.PrintDialogData
Print()
Print(parent, printout, prompt=True)
parentprintout
wx.PrintoutpromptTrue
Print()TrueGetLastError()
wx.PRINTER_CANCELLED
wx.PRINTER_ERROR
wx.PRINTER_NO_ERRORPrint()True
wx.Printer
* CreateAbortWindow(parent,printout)
parentprintoutPrint()
Abort()True
* PrintDialog(parent)
GetPrintDialogData()
538 / 565

17.5
wx.PrintPreview
wx.PrintPreviewwx.Printer
wx.PrintPreview(printout, printoutForPrinting, data=None)
printoutwx.Printout
printoutForPrintingwx.PrintoutNone
PrintprintoutForPrinting
printoutForPrintingNonePrint
printoutprintoutForPrintingdatawx.PrintData
wx.PrintDialogDatadata
17.1OnPrintPreview()
wx.PrintPreview
wx.PrintPreviewwx.PreviewFramewx.PreviewFrame
wx.Framewx.Frame
wx.PreviewFrame
wx.PreviewFrame(preview, parent, title, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE,
name=”frame”)
previewwx.PrintPreview
wx.Framewx.PreviewFrame
539 / 565

wx.PreviewFrameInitialize()
Show()
CreateControlBar()
CreateCanvas()wx.PreviewControlBarwx.PreviewCanvas
(canvas)/
17.6
1wxPythonHTML
wx.Printoutwx.Printerwx.PrintPreview
2wx.Printout
OnPrintPage()
3wxPython
wx.PrintDialog
wx.PageSetupDialog
4wx.Printer
wx.PrintPreview
18 wxPython
540 / 565

18 wxPython
*
*
*
* wx.Timer
* wxPython
18.1
wxPython
wx.DataObjectwx.DataObject
* source()
* clipboard()
* target()
source
wx.DataObjectsource
clipboard
targetwx.DataObject
18.1.1
wx.DataObjectwx.DataObject
541 / 565

wxPythonwx.DataObject
wx.TextDataObject
wx.TextDataObject(text=””)
textText(text)
GetText()GetTextLength()
wxPythonwx.TheClipboard
Open()True
False
Close()
18.1.2
SetData(data)data
wx.DataObjectClear()
Flush()
wxPython
text_data = wx.TextDataObject(“hi there”)
if wx.TheClipboard.Open():
wx.TheClipboard.SetData(text_data)
wx.TheClipboard.Close()
542 / 565

18.1.3
GetData(data)datawx.DataObject
True
wx.TextDataObjectTrue
text_data = wx.TextDataObject()
if wx.TheClipboard.Open():
success = wx.TheClipboard.GetData(text_data)
wx.TheClipboard.Close()
if success:
return text_data.GetText()
wxPython
18.1.4
18.1
543 / 565

18.1
18.118.1
18.1
#-*- encoding:UTF-8 -*-
import wx
t1_text = ”””\
The whole contents of this control
will be placed in the system’s
clipboard when you click the copy
button below.
“””
t2_text = ”””\
If the clipboard contains a text
data object then it will be placed
in this control when you click
the paste button below. Try
copying to and pasting from
other applications too!
“””
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Clipboard”,
544 / 565

size=(500,300))
p = wx.Panel(self)
# create the controls
self.t1 = wx.TextCtrl(p, -1, t1_text,
style=wx.TE_MULTILINE|wx.HSCROLL)
self.t2 = wx.TextCtrl(p, -1, t2_text,
style=wx.TE_MULTILINE|wx.HSCROLL)
copy = wx.Button(p, -1, ”Copy”)
paste = wx.Button(p, -1, ”Paste”)
# setup the layout with sizers
fgs = wx.FlexGridSizer(2, 2, 5, 5)
fgs.AddGrowableRow(0)
fgs.AddGrowableCol(0)
fgs.AddGrowableCol(1)
fgs.Add(self.t1, 0, wx.EXPAND)
fgs.Add(self.t2, 0, wx.EXPAND)
fgs.Add(copy, 0, wx.EXPAND)
fgs.Add(paste, 0, wx.EXPAND)
border = wx.BoxSizer()
border.Add(fgs, 1, wx.EXPAND|wx.ALL, 5)
p.SetSizer(border)
# Bind events
self.Bind(wx.EVT_BUTTON, self.OnDoCopy, copy)
self.Bind(wx.EVT_BUTTON, self.OnDoPaste, paste)
def OnDoCopy(self, evt):#Copy
data = wx.TextDataObject()
data.SetText(self.t1.GetValue())
if wx.TheClipboard.Open():
wx.TheClipboard.SetData(data)#
wx.TheClipboard.Close()
else:
wx.MessageBox(“Unable to open the clipboard”, ”Error”)
def OnDoPaste(self, evt):#Paste
success = False
data = wx.TextDataObject()
545 / 565

if wx.TheClipboard.Open():
success = wx.TheClipboard.GetData(data)#
wx.TheClipboard.Close()
if success:
self.t2.SetValue(data.GetText())#
else:
wx.MessageBox(
”There is no data in the clipboard in the required format”,
”Error”)
app = wx.PySimpleApp()
frm = MyFrame()
frm.Show()
app.MainLoop()
18.1.5
wx.BitmapDataObjectget*set*GetBitmap()
SetBitmap(bitmap)wx.Bitmap
wx.FileDataObject
18.2
GetFilenames()
AddFile(file)
18.2
546 / 565

wxPythonwx.DataObject
1
2wx.DropSource
3
4
wx.DataObject
wx.DropSource
wx.DropSource
wx.DropSource(win, iconCopy=wx.NullIconOrCursor,
iconMove=wx.NullIconOrCursor,
iconNone=wx.NullIconOrCursor)
win
Windows
wx.CursorUnixwx.Icon——Mac OS
547 / 565

wx.DropSourceSetData(data)
wx.DropSource
DoDragDrop(flags=wx.Drag_CopyOnly)
flags
wx.Drag_AllowMovewx.Drag_DefaultMove
wx.Drag_CopyOnly
DoDragDrop()
DoDragDrop()
wx.DragCancel
wx.DragCopy
wx.DragMove
wx.DragNone
18.2.1
18.2
Microsoft word18.2
548 / 565

18.2
18.2
#-*- encoding:UTF-8 -*-
import wx
class DragController(wx.Control):
”””
Just a little control to handle dragging the text from a text
control. We use a separate control so as to not interfere with
the native drag-select functionality of the native text control.
”””
def __init__(self, parent, source, size=(25,25)):
wx.Control.__init__(self, parent, -1, size=size,
style=wx.SIMPLE_BORDER)
self.source = source
self.SetMinSize(size)
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
def OnPaint(self, evt):
# draw a simple arrow
dc = wx.BufferedPaintDC(self)
dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
dc.Clear()
w, h = dc.GetSize()
y = h/2
dc.SetPen(wx.Pen(“dark blue”, 2))
dc.DrawLine(w/8, y, w-w/8, y)
549 / 565

dc.DrawLine(w-w/8, y, w/2, h/4)
dc.DrawLine(w-w/8, y, w/2, 3*h/4)
def OnLeftDown(self, evt):
text = self.source.GetValue()
data = wx.TextDataObject(text)
dropSource = wx.DropSource(self)#
dropSource.SetData(data)#
result = dropSource.DoDragDrop(wx.Drag_AllowMove)#
# if the user wants to move the data then we should delete it
# from the source
if result == wx.DragMove:
self.source.SetValue(“”)#
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Drop Source”)
p = wx.Panel(self)
# create the controls
label1 = wx.StaticText(p, -1, ”Put some text in this control:”)
label2 = wx.StaticText(p, -1,
”Then drag from the neighboring bitmap and\n”
”drop in an application that accepts dropped\n”
”text, such as MS Word.”)
text = wx.TextCtrl(p, -1, ”Some text”)
dragctl = DragController(p, text)
# setup the layout with sizers
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(label1, 0, wx.ALL, 5)
hrow = wx.BoxSizer(wx.HORIZONTAL)
hrow.Add(text, 1, wx.RIGHT, 5)
hrow.Add(dragctl, 0)
sizer.Add(hrow, 0, wx.EXPAND|wx.ALL, 5)
sizer.Add(label2, 0, wx.ALL, 5)
p.SetSizer(sizer)
sizer.Fit(self)
550 / 565

app = wx.PySimpleApp()
frm = MyFrame()
frm.Show()
app.MainLoop()
18.3
wx.DropSource
wx.DropTarget
wx.WindowSetDropTarget(target)
wx.Windowwx.Window
wx.DataObjectSetDataObject(data)wx.DataObject
GetDataObject()
wx.TextDataObject
class MyDropTarget(wx.DropTarget):
def __init__(self):
self.data = wx.TextDataObject()
self.SetDataObject(data)
target = MyDataTarget()
win.SetDropTarget(target)
18.3.1
wx.DropTarget
OnData(x, y, default)
x,ydefaultDoDragDrop()
DoDragDrop()
551 / 565

OnData()
GetData()GetData()
GetData()
MyDropTarget.OnData()
def OnData(self, x, y, default):
self.GetData()
actual_data = self.data.GetText()
# Do something with the data here...
return default
OnData()——default
wx.DragNone
OnData()
OnData()
DoDragDrop()
wx.DropTargetOn...
OnData()
OnDrop(x, y)
OnEnter(x, y, default)
OnDragOver(x, y, default)
OnLeave()
x, y, defaultOnData()
OnEnter()
defaultwx.DragNone
wxPython
OnDragOver()
552 / 565

wx.DragNone(drop)OnDrop()
OnData()OnLeave()
wxPython
wx.DataObject
wx.TextDropTargetOnDropText(x, y, data)
OnData()x,ydata
TrueFalse
wx.FileDropTarget
OnDropFiles(x, y, filenames)filenames
TrueFalse
18.3.2
18.3
18.3
18.3
18.3
#-*- encoding:UTF-8 -*-
import wx
553 / 565

class MyFileDropTarget(wx.FileDropTarget):#
def __init__(self, window):
wx.FileDropTarget.__init__(self)
self.window = window
def OnDropFiles(self, x, y, filenames):#
self.window.AppendText(“\n%d file(s) dropped at (%d,%d):\n” %
(len(filenames), x, y))
for file in filenames:
self.window.AppendText(“\t%s\n” % file)
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Drop Target”,
size=(500,300))
p = wx.Panel(self)
# create the controls
label = wx.StaticText(p, -1, ”Drop some files here:”)
text = wx.TextCtrl(p, -1, ””,
style=wx.TE_MULTILINE|wx.HSCROLL)
# setup the layout with sizers
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(label, 0, wx.ALL, 5)
sizer.Add(text, 1, wx.EXPAND|wx.ALL, 5)
p.SetSizer(sizer)
# make the text control be a drop target
dt = MyFileDropTarget(text)#
text.SetDropTarget(dt)
app = wx.PySimpleApp()
frm = MyFrame()
frm.Show()
app.MainLoop()
554 / 565

wxPython
18.4
wxPython
wxPython
18.4.1
wxPython
RTF
Microsoft Word
wxPython
wx.CustomDataObjectwx.CustomDataObject
wx.CustomDataObject(format=wx.FormatInvalid)
formatwx.DataFormat
wxPython
SetData(data)
data
data_object = wx.CustomDataObject(“MyNiftyFormat”)
data = cPickle.dumps(my_object)
data_object.SetData(data)
555 / 565

data_object
18.4.2
pickle
pickle
data_object = wx.CustomDataObject(“MyNiftyFormat”)
if wx.TheClipboard.Open():
success = wx.TheClipboard.GetData(data_object)
wx.TheClipboard.Close()
if success:
pickled_data = data_object.GetData()
object = cPickle.loads(pickled_data)
pickle
OnData()
pickle
wx.DataObject
wx.PyDataObjectSimple
wx.PyTextDataObjectwx.PyBitmapDataObject,
wx.PyFileDataObject
18.4.3
wxPython
wx.DataObjectComposite
wx.DataObjectSimplewx.DataObjectComposite
556 / 565

wx.DataObjectComposite()Add(data, preferred=False)
data_object = wx.CustomDataObject(“MyNiftyFormat”)
data_object.SetData(cPickle.dumps(my_object))
text_object = wx.TextDataObject(str(my_object))
composite = wx.DataObjectComposite()
composite.Add(data_object)
composite.Add(text_object)
pickle
18.5 wx.Timer
wx.Timer
18.5.1 EVT_TIMER
wx.TimerEVT_TIMER
wx.Timer
wx.Timer(owner=None, id=-1)
ownerwx.EvtHandler
wxPythonid
idwxPythonid
owneridSetOwner(owner=None, id=-1)
557 / 565

wx.EVT_TIMER
self.Bind(wx.EVT_TIMER, self.OnTimerEvent)
Bind
ID
timer1 = wx.Timer(self)
timer2 = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.OnTimer1Event, timer1)
self.Bind(wx.EVT_TIMER, self.OnTimer2Event, timer2)
Start(milliseconds=-1, oneShot=False)milliseconds
millisecondswx.EVT_TIMER
milliseconds=-1oneShotTrue
wx.EVT_TIMER
Stop()
18.4
18.4
#-*- encoding:UTF-8 -*-
import wx
import time
class ClockWindow(wx.Window):
def __init__(self, parent):
wx.Window.__init__(self, parent)
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.timer = wx.Timer(self)#
self.Bind(wx.EVT_TIMER, self.OnTimer, self.timer)#
self.timer.Start(1000)#
558 / 565

def Draw(self, dc):#
t = time.localtime(time.time())
st = time.strftime(“%I:%M:%S”, t)
w, h = self.GetClientSize()
dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
dc.Clear()
dc.SetFont(wx.Font(30, wx.SWISS, wx.NORMAL, wx.NORMAL))
tw, th = dc.GetTextExtent(st)
dc.DrawText(st, (w-tw)/2, (h)/2 - th/2)
def OnTimer(self, evt):#
dc = wx.BufferedDC(wx.ClientDC(self))
self.Draw(dc)
def OnPaint(self, evt):
dc = wx.BufferedPaintDC(self)
self.Draw(dc)
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”wx.Timer”)
ClockWindow(self)
app = wx.PySimpleApp()
frm = MyFrame()
frm.Show()
app.MainLoop()
IsRunning()
GetInterval()
IsOneShot()True
wx.TimerEventwx.Event
wx.GetInterval()
GetId()ID
559 / 565

18.5.2
wx.Timer
Notify()
Notify()
wx.FutureCall
wx.FutureCall(interval, callable, *args, **kwargs)
wx.FutureCallinterval
callable*args, **kwargscallable
wx.FutureCall
wxPython
18.6 wxPython
GUI
wxPython
GUI
GUI
UnixGUI
WindowsUIwxPython
wx.Bitmap
wxPythonUI
UIGUIwxPython
560 / 565

wxPython
wx.CallAfter()
Python
18.6.1 wx.CallAfter()
18.5wxPython
wx.CallAfter()
wx.CallAfter()
wx.CallAfter()
18.4
18.4
18.518.4
18.5 wx.CallAfter()
#-*- encoding:UTF-8 -*-
import wx
import threading
import random
class WorkerThread(threading.Thread):
”””
This just simulates some long-running task that periodically sends
a message to the GUI thread.
561 / 565

”””
def __init__(self, threadNum, window):
threading.Thread.__init__(self)
self.threadNum = threadNum
self.window = window
self.timeToQuit = threading.Event()
self.timeToQuit.clear()
self.messageCount = random.randint(10,20)
self.messageDelay = 0.1 + 2.0 * random.random()
def stop(self):
self.timeToQuit.set()
def run(self):#
msg = ”Thread %d iterating %d times with a delay of %1.4f\n” \
% (self.threadNum, self.messageCount, self.messageDelay)
wx.CallAfter(self.window.LogMessage, msg)
for i in range(1, self.messageCount+1):
self.timeToQuit.wait(self.messageDelay)
if self.timeToQuit.isSet():
break
msg = ”Message %d from thread %d\n” % (i, self.threadNum)
wx.CallAfter(self.window.LogMessage, msg)
else:
wx.CallAfter(self.window.ThreadFinished, self)
class MyFrame(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, title=”Multi-threaded GUI”)
self.threads = []
self.count = 0
panel = wx.Panel(self)
startBtn = wx.Button(panel, -1, ”Start a thread”)
stopBtn = wx.Button(panel, -1, ”Stop all threads”)
self.tc = wx.StaticText(panel, -1, ”Worker Threads: 00”)
self.log = wx.TextCtrl(panel, -1, ””,
562 / 565

style=wx.TE_RICH|wx.TE_MULTILINE)
inner = wx.BoxSizer(wx.HORIZONTAL)
inner.Add(startBtn, 0, wx.RIGHT, 15)
inner.Add(stopBtn, 0, wx.RIGHT, 15)
inner.Add(self.tc, 0, wx.ALIGN_CENTER_VERTICAL)
main = wx.BoxSizer(wx.VERTICAL)
main.Add(inner, 0, wx.ALL, 5)
main.Add(self.log, 1, wx.EXPAND|wx.ALL, 5)
panel.SetSizer(main)
self.Bind(wx.EVT_BUTTON, self.OnStartButton, startBtn)
self.Bind(wx.EVT_BUTTON, self.OnStopButton, stopBtn)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
self.UpdateCount()
def OnStartButton(self, evt):
self.count += 1
thread = WorkerThread(self.count, self)#
self.threads.append(thread)
self.UpdateCount()
thread.start()#
def OnStopButton(self, evt):
self.StopThreads()
self.UpdateCount()
def OnCloseWindow(self, evt):
self.StopThreads()
self.Destroy()
def StopThreads(self):#
while self.threads:
thread = self.threads[0]
thread.stop()
self.threads.remove(thread)
def UpdateCount(self):
self.tc.SetLabel(“Worker Threads: %d” % len(self.threads))
563 / 565

def LogMessage(self, msg):#
self.log.AppendText(msg)
def ThreadFinished(self, thread):#
self.threads.remove(thread)
self.UpdateCount()
app = wx.PySimpleApp()
frm = MyFrame()
frm.Show()
app.MainLoop()
Pythonthreading
wx.CallAfter(func,*args)
func(*args)
LogMessage()
ThreadFinished()
18.6.2
CallAfter()
PythonUI
UIwx.EVT_IDLE
wx.WakeUpIdle()wx.CallAfter()
GUI
18.6.3
wxPython
wx.PostEvent(window, event)UI
wx.WakeUpIdlewxPython
564 / 565

wx.CallAfter()
18.7
1wx.DataObject
wx.TheClipboard
2
3wx.Timer
4wxPythonGUI
wx.CallAfter()
565 / 565