Wxpython In Action
1 like2,104 views
本书《wxPython in Action》由Harri Pasanen和Robin Dunn撰写，介绍了wxPython的基础知识和高级应用，包括创建最小应用、事件驱动编程、使用对话框和菜单等内容。文档详尽地涵盖了从基本控件到复杂界面的构建和管理技巧，是学习wxPython开发的重要资源。读者将学会如何使用wxPython构建功能丰富的GUI程序。
![ShowModal()方法将对话框以模式框架的方式显示，这意味着在对话框关
闭之前，应用程序中的别的窗口不能响应用户事件。ShowModal()方法的返回
值是一个整数，对于wx.MessageDialog，返回值是下面常量之
一： wx.ID_YES, wx.ID_NO, wx.ID_CANCEL, wx.ID_OK。
文本输入对话框
如果你想从用户那里得到单独一行文本，你可能使用类
wx.TextEntryDialog。下面的片断创建了一个文本输入域，当用户单击OK按钮
退出时，获得用户输入的值：
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.CANCEL。与wx.MessageDialog一
样，ShowModal()方法返回所按下的按钮的ID。GetValue()方法得到用户输入在
文本域中的值（这有一个相应的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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-47-320.jpg)
![为C++事件处理不了解该Python子类。如果你wx.PyEvent，一个对该Python实例
的引用被保存，并且以后被直接传递给事件处理器，使得该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.1节。GetEventHandler()调用返回wx.EvtHandler
的一个实例。大多数情况下，返回的实例是窗口部件对象本身，但是如果其它
的wx.EvtHandler()方法已经被压入了事件处理器堆栈，那么返回的将是堆栈项
的项目。
#9 该自定义的事件的绑定如同其它事件一样，在这里使用#3所创建的绑定
器。
#10 这个例子的事件处理器函数改变窗口的标题以显示敲击数。
74 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-74-320.jpg)
![4、用PyCrust使得wxPython更易处理
PyCrust是一个图形化的shell程序，使用wxPython写成，它可以用来帮助你
分析你的wxPython程序。
为何称它为PyCrust？这是因为当Patrick O’Brien使用wxPython创建一个交
互式的Python shell时，PyShell已被使用了，所以选用了PyCrust这个名字。
PyCrust是Py包中的一部分，Py包目前被包含在wxPython中。这个Py包还
包含了其它相关功能的程序，这包括PyFilling, PyAlaMode, PyAlaCarte, 和
PyShell。这些程序每个都是想成为融图形化、点击环境 、wxPython的交互、
内省运行特点为一体。但是PyCrust表现最完善。
在这章中，我们将说明PyCrust和那些相关程序都干些什么，还有，你如何
使用它们才能使得你用wxPython工作得更流畅。我们以谈论普通的Python shell
作为开始，然后专门针对PyCrust，最后我们将涉及Py包中剩下的程序。
4.1 如何与wxPython程序交互？
与其它编程语言相比，Python的一个显著的特点是你可以以两种方式来使
用它：你可以用它来运行存在的使用Python语言写的程序，或从命令提示符来
交互地运行Python。交互地运行Python如同与Python解释器会话。
在下例4.1中，我们从命令行启动Python，并键入一些数学运算。Python启
动后显示几行信息，然后是它的主提示符‘>>>’。当你键入的东西要求额外的代
码行时，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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-76-320.jpg)
![右边显示的第一行是左边所选择的对象的全名，你可以把它复制并粘贴到
PyCrust shell或你的应用程序源码中。例如，我们在PyCrust中引入locale模块并
选择名字空间树中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标签
Display标签中用于显示一个对象。PyCrust有一个内建函数pp()，这个函数
使用Python的pprint模块为显示一个对象。使用中不需要显式地引入和重复使用
pprint，在Display中，这些信息随对象的更新而每次更新。
例如，如果我们在PyCrust shell中有一个列表，我们要在 Display标签中显
示它的内容，我们可以在PyCrust shell中使用pp()，然后列表的内容就显示
在 Display标签中了。以后每当我们改变了列表的内容， Display标签中的内容
随即改变。
4.3.3 Calltip（调用提示）标签
Calltip标签显示了在Python shell中最近调用提示的内容。如果你的调用要
求大量的参数，那么你可以选择Calltip标签。当使用wxPython包时，存在着大
量的类，这些类有许多方法，这些方法又要求许多参数。例如，为了创建一人
wx.Button，你可能要提供八个参数，有一个是必须提供的，其它七个有默认的
值。Calltip标签显示了关于wx.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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-89-320.jpg)
![在windows下，命令行类似如下：
F:>python pywrap.py spare.py
在开始的时候，PyWrap试图导入命令行所包括的模块。然后PyWrap在模
块中寻找wx.App的子类，并创建子类的一个实例。之后，PyWrap创建一个带
有shell的wx.py.crust.CrustFrame窗口，把这个应用程序对象显示在PyCrust的名
字空间树中，并且启动 wxPython事件循环。
PyWrap的源码显示在例子4.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 <pobrien@orbtech.com>”
__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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-93-320.jpg)
![raise 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()
运行了PyWrap命令之后，来自spare的简单的框架(frame)和PyCrust的框架
都显示出来。
PyCrust in action
现在让我们看看，在PyCrust shell中我们对spare.py应用程序框架做些什
么。图4.10显示了这个结果。我们将通过导入wx和增加一个画板到我们的框架
作为开始：
>>> import wx
>>> app.frame.panel = wx.Panel(parent=app.frame)
>>> app.frame.panel.SetBackgroundColour(‘White’)
True
>>>
94 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-94-320.jpg)
![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]
这个方法使用Python内建的compile方法编译编辑器中的文本，然后使用关
键词exec来执行。如果编译成功，将放置若干变量到newspace名字空间中。通
过用执行的结果重置解释器的局部名字空间，解释器支持访问定义在编辑器的
buffer中的任何类，方法或变量。
99 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-99-320.jpg)
![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
crust中的各有关部分和filling模块在它们的构造器中通过连接到dispatcher,
自己作为信号的接受器。下例4.6显示了关于出现在PyCrust的Session标签中的
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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-101-320.jpg)
![interpreter模块
interpreter模块定义了一个Interpreter类，基于Python标准库中的code模块的
Interactive-Interpreter类。除了负责发送源代码给Python外，Interpreter类还负责
提供自动完成列表，调用提示信息和甚至触发自动完成特性的关键码（通常
是“.”）。
由于这清楚的责任划分，你可以创建你自己的Interpreter的子类并传递其一
个实例到PyCrust shell，从而代替默认的interpreter。这已经应用到了一些程序
中以支持自定义评议种类，而仍然利用PyCrust环境。
introspect模块
introspect模块被Interpreter和FillingTree类使用。它为调用提示和命令自动
完成提供了多种内省类型支持功能。下面显示了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类使用以生成它的名字空间分级。理
解内省模块的最好方法是关注单元测试。查看你的Python安装目录的Lib/site-
packages/wx/py/tests中的test_introspect.py文件。
shell模块
shell模块包含出现在PyCrust, PyShell, 和PyAlaMode定义Python shell界面的
GUI元素。下表4.8提供了每个元素的说明。这最常用的类是ShellFrame,它是
frame.Frame的子类。它包含一个Shell类的实例，Shell类处理提供交互Python环
境的大部分工作。
表4.8 定义在shell模块中的类
Shell：Python shell基于wx.stc.StyleTextCtrl。Shell子类化editwindow.EditWindow，
然后使底层的文本控件的行为像一具Python shell，而非一个源码文件编辑器。
ShellFacade：简化的与所有shell相关的功能的接口。它是半透明的，它仍然是可访
问的，尽管只有一些是对shell用户可见的。
103 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-103-320.jpg)
![(“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),
(“<< PREV”, self.OnPrev),
(“NEXT >>”, 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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-116-320.jpg)
![return 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.1改变到例5.5，没有费多少力，但我们所得到的却是很多——代码
非常的清楚且减少了出错的机会。代码的布置与数据的布置在逻辑上是匹配
的。那些普通的做法（它们劣质的代码结构可能导致错误——如采用大量的复
制和粘贴来创建新的对象）已经被去掉。多数函数现在可以很容易地被移到一
117 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-117-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-124-320.jpg)
![在例5.7中，我们已经定义了所有必须的PyGridTableBase方法，并加上了额
外的方法GetColLabelValue()和GetRowLabelValue()。希望你不要对这两个额外
的方法感到诧异，这两个额外的方法使得表(table)能够分别指定行和列的标
签。在重构一节中，使用模型类的作用是将数据与显示分开。在本例中，我们
已经把数据移入了一个更加结构化的格式，它能够容易地被分离到一个外部文
件或资源中（数据库容易被增加到这里）。
使用PyGridTableBase：一个通用的例子
实际上，上面的例子很接近一个通用的能够读任何二维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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-125-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-126-320.jpg)
![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：这个列表包含了一些属性，它们被引用去按列地显示每列的值。
#2：这个模型要求一个条目的列表，每个条目都是LineupEntry的一个实
例。（这里我们没有做任何的错误检查）。
#3：要得到行头的标签，我们查看条目的pos属性。
#4：第一步是根据行来得到正确的条目。所要求的属性来自于#1中的列
表，然后getattr()被用来引用实际的值。这个机制是可扩展的，即使是在你不知
道该名字是否引用一个属性或方法的情况下，你也可以通过检查
128 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-128-320.jpg)
![<object>.<attribute>来看是否其可调用。如果可调用，那么使用通常的Python函
数语法来调用它，并返回它的值。
grid类是wxPython已有的一个有价值的模型组件来帮助你结构化你的应用
程序的一个例子。下一节我们将讨论如何为别的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)
我们这里的listener应该是可调用的对象，它需要self作为参数
（eachFunc(self)）——很明显，self的实际的类可以是不同的，因此你的
129 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-129-320.jpg)
![(“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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-132-320.jpg)
![单的列表，其中包含测试的数量、总的测试时间和OK，OK表明所有测试通
过。
对于一个失败或错误的测试，你将得到一堆跟踪提示（显示了Python得到
的错误处的情况）。比如，如果你将#5改为
self.assertEqual(“Fife”, self.frame.model.first)，我们将得到如下结果：
F
============================================================
==========
FAIL: testModel (__main__.TestExample)
----------------------------------------------------------------------
Traceback (most recent call last):
File ”C:wxPyBookbook1BlueprinttestExample.py”, line 18, in testModel
self.assertEqual(“Fife”, self.frame.model.last)
File ”c:python23libunittest.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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-137-320.jpg)
![wx.MetafileDC：在Windows操作系统上，wx.MetafileDC使你能够去创建标准窗口图
元文件数据。
wx.PaintDC：等同于wx.ClientDC，除了它仅用于一个wx.PaintEvent的处理中。仅
临时创建该类的实例。
wx.PostScriptDC：用于写压缩的PostScript文件。
wx.PrinterDC：用于Windows操作系统上，写到打印机。
wx.ScreenDC：用于直接在屏幕上绘画，在任何被显示的窗口的顶部或外部。该类
只应该被临时创建。
wx.WindowDC：用于在一个窗口对象的整个区域上绘画，包括边框以及那些没有被
包括在客户区域中的装饰。非Windows系统可能不支持该类。
下例6.1包含了显示图6.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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-142-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-143-320.jpg)
![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:3。图6.2显示了这个结果。
图6.2
例子6.3增加了两个状态域，其中一个显示所绘的当前线条的点数，另一个
显示当前所画的线条的数量。该例所产生的状态条如图6.2所示。
例6.3 支持多个状态域
import wx
from example1 import SketchWindow
150 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-150-320.jpg)
![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.3归纳了wx.StatusBar最常用的方法
表6.3 wx.StatusBar的方法
GetFieldsCount()
SetFieldsCount(count)：得到或设置状态栏中域的数量。
GetStatusText(field=0)
151 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-151-320.jpg)
![程的方法来选择一个菜单项，可以使wx.Menu的Check(id,bool)方法，id是所要
改变项的wxPython ID，bool指定了该项的选择状态。
例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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-153-320.jpg)
![(“&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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-154-320.jpg)
![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()
#1：该方法写文件数据到磁盘中，给定了文件名，使用了cPickle模块。
#2：该方法使用cPickle来读文件。如果文件不是期望的类型，则弹出一个
消息框来警告。
#3：OnOpen()方法使用wx.OPEN样式来创建一个对话框。通配符让用户可
以限定选择.sketch文件。如果用户敲击OK，那么该方法根据所选择的路径调用
ReadFile()方法。
#4：如果已经选择了用于保存当前数据的文件名，那么保存文件，否则，
我们打开保存对话框。
#5：OnSave()方法创建一个wx.SAVE文件对话框。
#6：这行确保文件名后缀为.sketch。
下一节，我们将讨论如何使用文件选择器。
159 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-159-320.jpg)
![6.3.2 如何使用标准的颜色选择器？
如果用户能够在sketch对话框中选择任意的颜色，那么这将是有用。对于
这个目的，我们可以使用wxPython提供的标准wx.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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-160-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-166-320.jpg)
![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)
#1：createColorGrid()方法建造包含颜色按钮的grid sizer。首先，我们创建
sizer本身，指定列为4列。由于列数已被设定，所以按钮将被从左到右的布局，
然后向下。接下来我们要求颜色的列表，并为每种颜色创建一个按钮。在for循
环中，我们为每种颜色创建了一个方形的位图，并使用wxPython库中所定义的
一般的按钮窗口部件类创建了带有位图的切换按钮。然后我们把按钮与事件相
绑定，并把它添加到grid。之后，我们把它添加到字典以便在以后的代码中，
易于关联颜色、ID和按钮。我们不必指定按钮在网格中的位置；sizer将为我们
做这件事。
#2：createThicknessGrid()方法基本上类似于createColorGrid()方法。实际
上，一个有进取心的程序员可以把它们做成一个通用函数。grid sizer被创建，
十六个按钮被一次性添加，sizer确保了它们在屏幕上很好地排列。
#3：我们使用一个坚直的box sizer来放置网格(grid)。每个grid的第二个参
数都是0，这表明grid sizer当control panel在垂直方向伸展时不改变尺寸。（由
于我们已经知道control panel不在水平方向改变尺寸，所以我们不必指定水平方
向的行为。）Add()的第四个参数是项目的边框宽度，这里使用self.SPACING变
量指定。第三个参数wx.ALL是一套标志中的一个，它控制那些边套用第四个
参数指定的边框宽度，wx.ALL表明对象的四个边都套用。最后，我们调用
box sizer的Fit()方法，使用的参数是control panel。这个方法告诉control panel调
整自身尺寸以匹配sizer认为所需要的最小化尺寸。通常这个方法在使用了sizer
的窗口的构造中被调用，以确保窗口的大小足以包含sizer。
基类wx.Sizer包含了几个通用于所有sizer的方法。表6.9列出了最常用的方
法。
表6.9 wx.Sizer的方法
Add(window, proportion=0,flag=0, border=0,userData=None)
167 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-167-320.jpg)
![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.TextCtrl类的构造函数较小且比其父类wx.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, 和 name与wx.Window构造函数的相同。value
是显示在该控件中的初始文本。
validator参数用于一个wx.Validator。validator通常用于过虑数据以确保只能
键入要接受的数据。将在第9章对validator做更详细的讨论。
使用单行文本控件样式
这里，我们将讨论一些唯一无二的文本控件样式。
表7.3说明了用于单行文本控件的样式标记
表7.3 单行wx.TextCtrl的样式
wx.TE_CENTER：控件中的文本居中。
wx.TE_LEFT：控件中的文本左对齐。默认行为。
wx.TE_NOHIDESEL：文本始终高亮显示，只适用于Windows。
wx.TE_PASSWORD：不显示所键入的文本，代替以星号显示。
180 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-180-320.jpg)
![例7.3包含了用于创建图7.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.nn”
”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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-183-320.jpg)
![过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] ### 这将是不正确的
在Windows或Mac系统中要得到正确的结果，最后一行应换为：
selection = text.GetRange(x, x + 10)
7.1.8 如何响应文本事件？
有一个由wx.TextCtrl窗口部件产生的便利的命令事件，你可能想用它。你
需要把相关事件传递给Bind方法以捕获该事件，如下所示：
188 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-188-320.jpg)
![如何创建单选按钮
例7.11显示了图7.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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-205-320.jpg)
![图7.12
要使用wx.RadioBox类，你所需要的全部就是构造函数。例7.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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-207-320.jpg)
![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.ListBox没有label属性。显示在列表中的
元素放置在参数choices中，它是一个字符串的序列。列表框有三种互斥的样
式，它决定用户如何从列表框中选择元素，说明在表7.12中。
用户通常对于多选有一些问题，因为它们一般希望见到的是单选列表，对
于多选来说可能是有挑战性的（就像单选题和多选题一样），尤其是对于那些
易受困扰的用户。如果你使用了一个多选的列表，我们建议你清楚地标明该列
表。
表7.12 列表框的选择类型样式
wx.LB_EXTENDED：用户可以通过使用shift并敲击鼠标来选择一定范围内的连续的
选项，或使用等同功能的按键。
wx.LB_MULTIPLE：用户可以一次选择多个选项（选项可以是不连续的）。实际
上，在这种情况下，列表框的行为就像是一组复选框。
210 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-210-320.jpg)
![7.4.5 如果我想要下拉形式的选择该怎么做？
下拉式选择是一种仅当下拉箭头被敲击时才显示选项的选择机制。它是显
示所选元素的最简洁的方法，当屏幕空间很有限的时候，它是最有用的。图
7.15显示了一个关闭的下拉式选择。图7.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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-213-320.jpg)
![创建组合框的代码与我们已经见过的选择是类似的。该类是
wx.ComboBox，它是wx.Choice的一个子类。例7.15显示了图7.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.ComboBox来说有4种样式。其中的两种决定了如何绘制组合框：
wx.CB_DropDOWN创建一个带有下拉列表的组合框，wx.CB_SIMPLE创建一个
带有列表框的组合框。在Windows上你可以只使用wx.CB_SIMPLE样式。任何
组合框都可以被指定为wx.CB_READONLY样式，它防止用户在文本域中键
入。当组合框被指定为只读时，所做的选择必须来自于选择列表的元素之一，
即使你用程序来设置它也不行。最后wx.CB_SORT样式导致选择列表中的元素
按字母顺序显示。
215 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-215-320.jpg)
![9.1.4 如何用对话框显示选项列表？
如果给你的用户一个空的文本输入域显得太自由了，那么你可以使用
wx.SingleChoiceDialog来让他们在一组选项中作单一的选择。图9.4显示了一个
例子。
图9.4 一个单选对话框
例9.4显示了产生图9.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: %sn” % 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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-261-320.jpg)
![图9.9
用于颜色选择器的wxPython的类是wx.ColourDialog。它的构造函数很简
单，没有太多的参数：
wx.ColourDialog(parent, data=None)
data参数是类wx.ColourData的实例，它比相应字体的更简单。它只包含默
认的没有参数的构造函数和后面的三个属性：
1、GetChooseFulłSetChooseFull(flag)：仅在微软Windows下工作。当设置
后，将显示完整的对话框，包括自定义颜色选择器。如果不设置，则自定义颜
色选择器不被显示。
2、GetColour/SetColour(colour)：当图表被关闭后，调用get*来看用户的选
择。最初它被设置为black。如果在对话框显示之前设置了它，那么对话框最初
显示为该颜色。
3、GetCustomColour(i)/SetCustomColour(i, colour)：根据自定义的颜色数组
中的索引i来返回或设置元素。i位于[0,15]之间。初始时，所有的自定义颜色都
是白色。
一个回避了wx.ColorData的使用颜色对话框的便利函数是：
wx.GetColourFromUser(parent, colInit)
272 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-272-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-285-320.jpg)
![有时，你会有多个菜单项需要被绑定到同一个处理器。例如，一套单选按
钮开关菜单（它们本质上作相同的事情）可能被绑定给同一处理器。如果菜单
项有连续的标识符号的话，为了避免分别的一一绑定，可以使用
wx.EVT_MENU_RANGE事件类型：
self.Bind(wx.EVT_MENU_RANGE, function, id=menu1, id2=menu2)
在这种情况下，所有标识号位于[menu1,menu2]间菜单项都将绑定到给定的
函数。
尽管通常你只关心菜单项命令事件，但是这儿有你能够响应的另外的菜单
事件。在wxPython中，类wx.MenuEvent管理菜单的绘制和高亮事件。表10.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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-301-320.jpg)
![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()
在wxPython中有两种快捷键；mnemonics（助记符）和accelerator（加速
器）。下面，我们将讨论这两种的区别。
使用助记符快捷方式
助记符是一个用来访问菜单项的单个字符，以一个带有下划线的字母表
示。助记符可以通过为菜单或菜单项指定显示的文本来创建，并在你想用来作
为助记符的字符前面放置一个&符号，例如&File, &Edit或Ma&cros。如果你希
望在你的菜单文本中有一个&符号，那么你必须输入两个&&符号，例如&&。
助记符是作为在菜单树中选择的一个备用的方法。它仅在被用户显式地调
用时被激活；在微软Windows下，通过按下alt键来激活它。一旦助记符被激
活，下一步按下顶级菜单的助记符来打开顶级菜单。这样一步打开菜单，直到
一个菜单项被选择，此时一个菜单事件被触发。助记符在菜单中必须是独一无
308 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-308-320.jpg)
![例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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-344-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-350-320.jpg)
![图11.15
例11.10显示了产生上图的代码。这里有三个值得注意的事件。首先你必须
单独于sizer创建静态框对象，第二是这个例子展示了如何使用嵌套的
box sizer。本例中，三个垂直的static box sizer被放置于一个水平的box 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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-352-320.jpg)
![12.1.1 如何载入图像？
在wxPython中，图像处理是一个双主管系统，与平台无关的图像处理由类
wx.Image管理，而与平台有关的图像处理由类wx.Bitmap管理。实际上，意思就
是外部文件格式由wx.Image装载和保存，而wx.Bitmap负责将图像显示到屏幕。
图12.1显示了不同图像和位图的创建，按照不同的文件类型读入。
要从一个文件载入一个图像，使用wx.Image的构造函数：
wx.Image(name, type=wx.BITMAP_TYPE_ANY, index=-1)
图12.1
参数name是图像文件的名字，参数type（类型）是处理器类型。type的ID
可以是wx.BITMAP_TYPE_ANY或表12.1中的一个。如果你使用
wx.BITMAP_TYPE_ANY，那么wxPython将试图自动检测该文件的类型。如果
你使用一个特定的文件类型，那么wxPython将使用该类型转换这个文件。例
12.1显示了如何使用wx.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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-361-320.jpg)
![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.2定义了一些wx.Image的方法，这些方法执行简单的图像处理。
这些方法只是图像处理的开始部分。在接下来的部分，我们将给你展示两
个方法，它们处理透明和半透明图像这一更复杂的主题。
表12.2 wx.Image的图像处理方法
ConvertToMono(r, g, b)：返回一个与原尺寸一致的wx.Image，其中所有颜色值为
(r, g, b)的像素颜色改为白色，其余为黑色。原图像未改变。
Mirror(horizontally=True)：返回原图像的一个镜像图像。如果horizontally参数是
True，那么镜像图像是水平翻转了的，否则是垂直翻转了的。原图像没有改变。
366 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-366-320.jpg)
![例12.2展示了一个简单的雷达图形。它采集0-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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-377-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-378-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-379-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-380-320.jpg)
![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设
备上下文在OnPaint方法结束时销毁，被销毁时它自动传送self.buffer到一个
wx.PaintDC，因此不需要新的绘制
#2 我们创建了一个与窗口大小相同的缓冲位图，然后将我们的图形绘制到
它。由于我们使用wx.BufferedDC，那么当InitBuffer方法完成时，所被绘制到这
个缓冲上的东西都将绘制到窗口。
12.2.3 如何绘制图像到设备上下文？
即便是有了本章开始所提及的image和bitmap对象，你仍将需要使用设备上
下文的方法来绘制图像或从一个设备上下文拷贝到另一个，这个过程称为blit。
这个特性的通常用法是绘制一个图像的一部分到设备上下文。这通常被用来使
一个程序可以一个文件中部署它的所有外部的图像，并且使用单独一个blit来只
绘制相应复杂图像或工具栏图标的一部分。
有三个用于绘制图像到设备上下文的法。
381 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-381-320.jpg)
![是单色的，那么当前文本的前景色和背景色被用于该位图，否则，该位图自己
的颜色方案被使用。图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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-383-320.jpg)
![12.2.4 如何绘制文本到设备上下文？
绘制文本到你的设备上下文的方法是DrawText(text, x, y)。要绘制的字符串
传递给text参数，参数x和y是文本的左上角的坐标。对于有角度的文本，使用
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)指定文本是否有一个背景色。如果说你想要文本有一
个背景色，那么mode的值应该为wx.SOLID，如果不想文本有一个背景色，那
么mode的值应该为wx.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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-385-320.jpg)
![bmp = 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 -*-
在接下来的部分，我们将讨论如何将值插入适当的位置。报告控件是最适
合用于那些包含一两个附加的数据列的简单列表，它的显示逻辑没有打算做得
很复杂。如果你的列表控件复杂的话，或包含更多的数据的话，那么建议你使
用grid控件，说明见第14章。
402 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-402-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-413-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-415-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-421-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-428-320.jpg)
![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标记如#1。通常使用子类wx.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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-429-320.jpg)
![有时在虚列表的初始化期间，必须调用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)。它
的返回值是较早声明的列表控件的图像列中的一个整数索引。如果你没有覆盖
这个方法，那么基类版本的OnGetItemImage将返回－1，这表明不显示图像。
如果你想改变行的一些显示属性，那么你可以覆盖OnGetItemAttr(item)方
法，item是行的索引，该方法返回类wx.ListItemAttr的一个实例。该类有一些
get*和set*方法可以用来设置行的颜色、对齐方式等等显示属性。
如果你的虚列表所基于的数据改变了，而你想更新显示，那么你可以使用
该列表控件的RefreshItem(item)来重绘特定的行。相关的方法
RefreshItems(itemFrom,itemTo)重绘位于索引itemFrom和itemTo间的所有行。
为了对数据源中的数据的获取提供优化帮助，对于要显示一页新的数据，
虚列表控件会发送EVT_LIST_CACHE_HINT事件。这将给你的数据源一个时机
用以从数据库（或另处）一次获取几个记录并保存它们。这样就使得随后的
OnGetItemText()执行的更快。
13.6 本章小结
1、列表控件是wxPython用于显示列表信息的窗口部件。它比简单的列表
框部件要更复杂且有完整的特性。列表控件是类wx.ListCtrl的实例。列表控件
可以显示为图标模式，每个图标下都有一个项目文本，也可以显示为带有小图
标的小图标模式等等。在列表模式中，元素按列显示，在报告模式中，以多列
的格式显示列表，每列都有列标签。
430 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-430-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-437-320.jpg)
![例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)方法来设置标签值，如#1所示。参数col和row是列
和行的索引，value是要显示在标签中的字符串。要得到一行或一列的标签，使
用GetColLabelValue(col)和GetRowLabelValue(row)方法。
对于使用外部网格表的一个网格控件，你可以通过覆盖网格表的
GetColLabelValue(col)和GetRowLabelValue(row)方法来达到相同的作用。为了
消除混淆，网格控件在当它需要显示标签并且网格有一个关联的表时，内在地
调用这些方法。由于返回值是动态地由你在覆盖的方法中所写的代码决定的，
所以这里不需要覆盖或调用set*方法。不过set*方法仍然存在——
441 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-441-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-442-320.jpg)
![bg = 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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-455-320.jpg)
![# Add nodes from our data set
self.AddTreeNodes(root, data.tree)
# 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)
# 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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-470-320.jpg)
![”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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-472-320.jpg)
![”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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-473-320.jpg)
![”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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-474-320.jpg)
![[“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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-475-320.jpg)
![”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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-476-320.jpg)
![”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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-477-320.jpg)
![”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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-478-320.jpg)
![”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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-479-320.jpg)
![”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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-480-320.jpg)
![”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)
你只能添加一个根元素。如果你在已经存在一个根元素后，再添加第二根
元素的话，那么wxPython将引发一个异常。其中的参数text包含用于根元素的
显示字符串。参数image是图像列表中的一个索引，代表要显示在参数text旁边
的图像。这个图像列表将在15.5节中作更详细的讨论，但是现在只要知道它的
行为类似于用于列表控件的图像列表。参数data是一个与项目相关的数据对
象，主要的目的是分类。
481 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-481-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-487-320.jpg)
![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.TreeItemId。参数which控制你将得到了是哪个图像，默认值
wx.TreeItemIcon_Normal，将得到该项目的未选状态的图像的索引。which的另
一个值wx.TreeItemIcon_Selected的使用，将返回选中状态的图
像，wx.TreeItemIcon_Expanded和wxTreeItemIcon_SelectedExpanded返回当该树
项目被展开时所使用的图像。注意，后者的两个图像不能使用添加方法来被设
置——如果你想设置的话，你必须使用方法
SetItemImage(item, image, which=wx.TreeItemIcon_Normal)来实现。其中参数
item是wx.TreeItemId的实例，参数image是新图像的整数索引，参数which同get*
方法。
15.5 使用编程的方式访问树。
在15.1节中，我们谈到没有直接得到一个给定项目的子项目的Python列表
的方法，至于一个特定子项目的索引就更不用说了。要实现这个，我们需要使
用本节所说的遍历方法来访问树的结点。
488 / 565](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-488-320.jpg)
![要开始遍历树，我们首先要使用GetRootItem()来得到根元素。该方法返回
树的根元素的wx.TreeItemId。之后，你就可以使用诸如GetItemText()或
GetItemPyData()之类的方法来获取关于根元素的更多的信息。
一旦你得到了一个项目，你就可以通过迭代器来遍历子项目的列表。你可
以使用方法GetFirstChild(item)来得到子树中的第一个孩子，该方法返回一个二
元元组(child, cookie)。参数item是第一个孩子的wx.TreeItemId。除了告诉你每
一个孩子是什么外，该方法还初始化一个迭代对象，该对象使你能够遍历该
树。cookie值只是一个标志，它使得树控件能够同时保持对多个迭代器的跟
踪，而它们之间不会彼此干扰。
一旦你由GetFirstChild()得到了cookie，你就可以通过反复调用
GetNextChild(item, cookie)来得到其余的孩子。这里的item父项的ID，cookie是
由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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-489-320.jpg)
![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)
self.Bind(wx.EVT_TREE_ITEM_EXPANDING, self.OnItemExpanding, self.t
ree)
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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-492-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-493-320.jpg)
![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)
# 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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-500-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-528-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-529-320.jpg)
![”””
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.4fn”
% (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 %dn” % (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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-562-320.jpg)
![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](https://image.slidesharecdn.com/wxpython-in-action-100425110614-phpapp02/85/Wxpython-In-Action-563-320.jpg)
Wxpython In Action
- 1. wxPython in Action ——译文 本书由 Harri Pasanen 和 Robin Dunn 所著 ・ 由 滴水（www.pythontik.com）翻译 ・ 由 la.onger (la-onger.long-er.name) 整理成pdf版本 1 / 565
- 2. 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 2、给你的wxPython程序一个稳固的基础 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
- 3. 2.5.2 使用wxPython的ID 37 明确地选择ID号 38 使用全局性的NewID()函数 38 2.5.3 使用wx.Size和wx.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
- 4. 第四步 决定是否继续处理 66 第五步 决定是否展开 67 3.4.2 使用Skip()方法 68 3.5 在应用程序对象中还包含哪些其它的属性？ 70 3.6 如何创建自己的事件？ 71 3.6.1 为一个定制的窗口部件定义一个定制的事件。 71 创建自定义事件的步骤： 71 3.7 总结 75 4、用PyCrust使得wxPython更易处理 76 4.1 如何与wxPython程序交互？ 76 PyCrust配置了标准的Python 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 如何将PyCrust应用于wxPython应用程序。 92 4 / 565
- 5. 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 如何在wxPython中使用Py包中的模块? 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 一个wxPython模型：PyGridTableBase 120 PyGridTableBase的方法 122 使用PyGridTableBase 123 使用PyGridTableBase：特定于应用程序（不通用）的子类 123 使用PyGridTableBase：一个通用的例子 125 使用PyGridTableBase：一个独立的模型类 127 5.2.3 自定义模型 129 5 / 565
- 6. 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. 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
- 8. 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
- 9. 滚动条事件 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
- 10. 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 10、创建和使用wxPython菜单 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
- 11. 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 基本的sizer：grid 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 sizer上使用Add()方法 345 11.3.3 什么是box sizer？ 347 11.3.4 什么是static box sizer? 351 11 / 565
- 12. 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
- 13. 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
- 14. 在创建的时候告诉列表去排序 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
- 15. 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 如何在一个wxPython窗口中显示HTML？ 503 16.1.2 如何显示来自一个文件或URL的HTML？ 506 16.2 管理HTML窗口 508 15 / 565
- 16. 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
- 17. 第一步 按顺序得到你的所有数据 538 第二步 创建一个wx.Printer实例 538 第三步 使用wx.Printer的Print ()方法打印 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. 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
- 19. 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() 图示如下： 漂亮的界面是一个GUI程序必不可少的一部分，wxPython可以做到这一 点，加之Python强大的功能和简洁的语法，使用得它在Python的gui中成为一种 主流。 19 / 565
- 20. 1.1 开始wxPython 首先我们创建一个显示一个图像的文件。这将分三步： 1、首先创建一个空的最小的可以工作的wxPthon程序 2、组织和细化 3、显示wxPython的logo 图示如下： 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
- 21. 上面的代码运行的结果如下： 上面的代码的任何一行都不能少，否则将不能工作。这个基本的wxPython 程序说明了开发任一wxPython程序所必须的五个基本步骤： 1、导入必须的wxPython包 2、子类化wxPython应用程序类 3、定义一个应用程序的初始化方法 4、创建一个应用程序类的实例 5、进入这个应用程序的主事件循环 下面让我们看看这个最小的空的程序是如何一步一步实现的。 1.2.1 导入wxPython 你需要做的第一件事就是导入这个主要的wxPython包，这个包名为wx: import wx 一旦这个包被导入，你就可以引用wxPython的类、函数和常量（它们以wx 为前缀），如下所示： class App(wx.App): 注意：老的引入方式仍然被支持，你可能会遇到用这种老的引入方式的代码。因此我 们将会简短地说明这种老的方式及为什么要改变它。老的包的名字是wxPython，它 包含了一个内在的名为wx模块。那时，通常有两种导入必要的代码的方法，一种就 是从wxPython包中导入wx模块：from wxPython import wx；另一种就是直接从wx模 块中导入所有的东西：from wxPython.wx import *。这两种方法都有严重的缺点。这 第二种方法Python中是不建议使用的，这因为可能导致名字空间冲突，而老的wx模 块通过在其属性前加一个wx前缀避免了这个问题。尽管使用这个安全防范，但是 21 / 565
- 22. import*仍然有可能导致问题，但是许多wxPython程序员喜欢这种类型，并且你将在 老的代码中经常看到这种用法。这种风格的坏处是类名以小写字母开头，而大多数 wxPython方法以大写字母开头，这和通常的Python编写程序的习惯相反。 然而如果你试图避免由于使用import*导致的名字空间膨胀，而使用 from wxPython import wx。那么你就不得不为每个类、函数、常数名键入两次 wx，一次是作为包的前缀，另一次是作为通常的前缀，例如wx.wxWindow。 对于导入顺序需要注意的是：你从wxPython导入其它东西之前必须先导入 wx。通常情况下，Python中的模块导入顺序无关。但是wxPython中的不同，它 是一个复杂的模块。当你第一次导入wx模块时，wxPython要对别的wxPython模 块执行一些初始化工作。例如wxPython中的一些子包，如xrc模块，它在wx模 块导入之前不能够正确的工作，我们必须按下面顺序导入： import wx from wx import xrc 以上的导入顺序只针对wxPython的模块，Python的模块导入顺序没关系。 例如： import sys import wx import os from wx import xrc import urllib 1.2.2 使用应用程序和框架工作 一旦你导入了wx模块，你就能够创建你的应用程序（application）对象和 框架（frame）对象。每个wxPython程序必须有一个application对象和至少一个 frame对象。application对象必须是wx.App的一个实例或你在OnInit()方法中定义 的一个子类的一个实例。当你的应用程序启动的时候，OnInit()方法将被 wx.App父类调用。 22 / 565
- 23. 子类化wxPython application类 下面的代码演示了如何定义我们的wx.App的子类： class MyApp(wx.App): def OnInit(self): frame = wx.Frame(parent=None, id=-1, title=”Bare”) frame.Show() return True 上面我们定义了一个名为MyApp的子类。我们通常在OnInit()方法中创建 frame对象。上面的wx.Frame接受三个参数，仅第一个是必须的，其余的都有默 认值。 调用Show()方法使frame可见，否则不可见。我们可以通过给Show()一个布 尔值参数来设定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) 如果你忘了这样做，wxPython不将被初始化并且你的OnInit()方法也不将得到调用。 创建一个应用程序实例并进入它的主事件循环 这步是创建wx.App子类的实例，并调用它的MainLoop()方法： app = App() app.MainLoop() 23 / 565
- 24. 一旦进入主事件循环，控制权将转交给wxPython。wxPython 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 这行看似注释，但是在如linux和unix等操作系统上，它告诉操作系统如 何找到执行程序的解释器。如果这个程序被给予的可执行权限（例如使用 chmod命令），我们可以在命令行下仅仅键入该程序的名字来运行这个程序： 24 / 565
- 25. % spare.py 这行在其它的操作系统上将被忽略。但是包含它可以实现代码的跨平台。 #2 这是文档字符串，当模块中的第一句是字符串的时候，这个字符串就成 了该模块的文档字符串并存储在该模块的__doc__属性中。你能够在你的代码 中、某些开发平台、甚至交互模式下运行的Python解释器中访问文档字符串： >>> import spare >>> print spare.__doc__ Spare.py is a starting point for simple wxPython programs. >>> #3 我们改变了你们创建frame对象的方法。bare版的程序简单地创建了一个 wx.Frame类的实例。在spare版中，我们定义了我们自己的Frame类作为 wx.Frame的子类。此时，最终的结果没有什么不同，但是如果你想在你的框架 中显示诸如文本、按钮、菜单的话，你可能就想要你自己的Frame类了。 #4 我们将对frame实例的引用作为应用程序实例的一个属性 #5 在OnInit()方法中，我们调用了这个App类自己的SetTopWindow()方法， 并传递给它我们新创建的frame实例。我们不必定义SetTopWindow()方法，因为 它继承自wx.App父类。SetTopWindow()方法是一个可选的方法，它让wxPython 方法知道哪个框架或对话框将被认为是主要的。一个wxPython程序可以有几个 框架，其中有一个是被设计为应用程序的顶级窗口的。 #6 这个是Python中通常用来测试该模块是作为程序独立运行还是被另一模 块所导入。我们通过检查该模块的__name__属性来实现： if __name__ == ’__main__’: app = App() app.MainLoop() 25 / 565
- 26. 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
- 27. if __name__ == ’__main__’: main() 说明： #2 定义一个wx.Frame的子类，以便我们更容量控制框架的内容和外观。 #3 给我们的框架的构造器增加一个图像参数。这个值通过我们的应用程序 类在创建一个框架的实例时提供。同样，我们可以传递必要的值 wx.Frame.__init__() #4 我们将用wx.StaticBitmap控件来显示这个图像，它要求一个位图。所以 我们转换图像到位图。我们也使用图像的宽度和高度创建一个size元组。这个 size元组被提供给wx.Frame.__init__()调用，以便于框架的尺寸匹配位图尺寸。 #5 定义一个带有OnInit()方法的wx.App的子类，这是wxPython应用程序最 基本的要求。 #6 我们使用与hello.py在同一目录下的名为wxPython.jpg的文件创建了一个 图像对象。 #7 main()函数创建一个应用程序的实例并启动wxPython的事件循环。 27 / 565
- 28. 2、给你的wxPython程序一个稳固的基础 房屋的基础是混凝土结构，它为其余的建造提供了坚固的基础。你的 wxPython程序同样有一个基础，它由两个必要的对象组成，用于支持你的应用 程序的其余部分。它们是应用程序对象和顶级窗口对象。适当地使用这两个对 象将给你的wxPython应用程序一个稳固的开始并使得构造你的应用程序的其余 部分更容易。 2.1 关于所要求的对象我们需要知道些什么？ 让我们来说明一下这两个基础对象。这个应用程序对象管理主事件循环， 主事件循环是你的wxPython程序的动力。启动主事件循环是应用程序对象的工 作。没有应用程序对象，你的wxPython应用程序将不能运行。 顶级窗口通常管理最重要的数据，控制并呈现给用户。例如，在词处理程 序中，主窗口是文档的显示部分，并很可能管理着该文档的一些数据。类似 地，你的web浏览器的主窗口同时显示你所关注的页面并把该页作为一个数据 对象管理。 下图显示了这两个基础对象和你的应用程序的其它部分这间的关系： 28 / 565
- 29. 如图所示，这个应用程序对象拥有顶级窗口和主事件循环。顶级窗口管理 其窗口中的组件和其它的你分配给它的数据对象。窗口和它的组件的触发事件 基于用户的动作，并接受事件通知以便改变显示。 2.2 如何创建和使用一个应用程序对象？ 任何wxPython应用程序都需要一个应用程序对象。这个应用程序对象必须 是类wx.App或其定制的子类的一个实例。应用程序对象的主要目的是管理幕后 的主事件循环。这个事件循环响应于窗口系统事件并分配它们给适当的事件处 理器。这个应用程序对象对wxPython进程的管理如此的重要以至于在你的程序 没有实例化一个应用程序对象之前你不能创建任何的wxPython图形对象。 父类wx.App也定义了一些属性，它们对整个应用程序是全局性的。很多时 候，它们就是你对你的应用程序对象所需要的全部东西。假如你需要去管理另 外的全局数据或连接（如一个数据库连接），你可以定制应用程序子类。在某 些情况下，你可能想为专门的错误或事件处理而扩展这个主事件循环。然而， 默认的事件循环几乎适合所有的你所要写的wxPython应用程序。 2.2.1 创建一个wx.App的子类 创建你自己的wx.App的子类是很简单的。当你开始你的应用程序的时候， 创建你自己的wx.App的子类通常是一个好的想法，即使是你不定制任何功能。 创建和使用一个wx.App子类，你需要执行四个步骤： 1、定义这个子类 2、在定义的子类中写一个OnInit()方法 3、在你的程序的主要部分创建这个类的一个实例 4、调用应用程序实例的MainLoop()方法。这个方法将程序的控制权转交 给wxPython 我们在第一章中看到过OnInit()方法。它在应用程序开始时并在主事件循环 开始前被wxPython系统调用。这个方法不要求参数并返回一个布尔值，如果所 返回的值是False，则应用程序将立即退出。大多数情况下，你将想要该方法返 回的结果为真。处理某些错误条件，退出可能是恰当的方法，诸如所一个所需 的资源缺失。 由于OnInit()方法的存在，并且它是wxPython架构的一部分，所以任何关于 你的定制的类的所需的初始化通常都由OnInit()方法管理，而不在Python的 __init__方法中。如果由于某些原因你决定需要__init__方法，那么你必须在你 的__init__方法中调用父类的__init__方法，如下所示： 29 / 565
- 30. wx.App.__init__(self) 通常，你在OnInit()方法中将至少创建一个框架对象，并调用该框架的 Show()方法。你也可以有选择地通过调用SetTopWindow()方法来为应用程序指 定一个框架作为顶级窗口。顶级窗口被作为那些没有指定父窗口的对话框的默 认父窗口。 何时省略wx.App的子类 你没有必要创建你自己的wx.App子类，你通常想这样做是为了能够在 OnInit()方法中创建你的顶级框架。 通常，如果在系统中只有一个框架的话，避免创建一个wx.App子类是一个 好的主意。在这种情况下，wxPython提供了一个方便的类wx.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.PySimpleApp类，所以我们没有定制OnInit方 法。第二行我们定义了一个没有父亲的框架，它是一个顶级的框架。（很显 然，这个MyNewFrame类需要在别处被定义）这第三行显示框架，最后一行调 用应用程序主循环。 30 / 565
- 31. 正如你所看到的，使用wx.PySimpleApp让你能够运行你的wxPython程序而 无需创建你自己定制的应用程序类。如果你的应用程序十分简单的话，你应该 只使用wx.PySimpleApp，且不需要任何其它的全局参数。 2.2.2 理解应用程序对象的生命周期 你的wxPython应用程序对象的生命周期开始于应用程序实例被创建时，在 最后一个应用程序窗口被关闭时结束。这个没有必要与你的wxPython应用程序 所在的Python脚本的开始和结束相对应。Python脚本可以在wxPython应用程序 创建之前选择做一动作，并可以在wxPython应用程序的MainLoop()退出后做一 些清理工作。然而所有的wxPython动作必须在应用程序对象的生命周期中执 行。正如我们曾提到过的，这意味你的主框架对象在wx.App对象被创建之前不 能被创建。（这就是为什么我们建议在OnInit()方法中创建顶级框架——因为这 样一来，就确保了这个应用程序已经存在。） 下图所示，创建应用程序对象触发OnInit()方法并允许新的窗口对象被创 建。在OnInit()之后，这个脚本调用MainLoop()方法，通知wxPython事件现在正 在被处理。在窗口被关闭之前应用程序继续它的事件处理。当所有顶级窗口被 关闭后，MainLoop()函数返回同时应用程序对象被注销。这之后，这个脚本能 够关闭其它的可能存丰的连接或线程。 2.3 如何定向wxPython程序的输出? 所有的Python程序都能够通过两种标准流来输出文本：分别是标准输出流 sys.stdout和标准错误流sys.stderr。通常，Python脚本定向标准输出流到它所运 31 / 565
- 33. print ”OnExit” if __name__ == ’__main__’: app = App(redirect=True) #1 文本重定向从这开始 print ”before MainLoop” app.MainLoop() #2 进入主事件循环 print ”after MainLoop” 说明： #1 这行创建了应用程序对象。这行之后，所有发送到stderr或stdout的文本 都可被wxPython重定向到一个框架。参数redirect=True决定了是否重定向。 #2 运行的时候，应用程序创建了一个空的框架和也生成了一个用于重定向 输出的框架。图示如下： 注意：stdout和stderr都定向到这个窗口。 当你运行了这个程序之后，你将会看到你的控制台有下面的输出： 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
- 34. 为什么来自OnExit()的消息既没显示在窗口中也没显示在控制台中呢？其 实它是在窗口关闭之前显示在wxPython的框架中，但窗口消失太快，所以无法 被屏幕捕获。 2.3.2 修改默认的重定向行为 为了修改这个行为，wxPython允许你在创建应用程序时设置两个参数。第 一个参数是redirect，如果值为True，则重定向到框架，如果值为False，则输出 到控制台。如果参数redirect为True，那么第二个参数filename也能够被设置，这 样的话，输出被重定向到filename所指定的文件中而不定向到wxPython框架。 因此，如果我们将上例中的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
- 35. 2.4.1 管理正常的关闭 在关闭的过程期间，wxPython关心的是删除所有的它的窗口和释放它们的 资源。你可以在退出过程中定义一个钩子来执行你自己的清理工作。由于你的 wx.App子类的OnExit()方法在最后一个窗口被关闭后且在wxPython的内在的清 理过程之前被调用，你可以使用OnExit()方法来清理你创建的任何非wxPython 资源（例如一个数据库连接）。即使使用了wx.Exit()来关闭wxPython程 序，OnExit()方法仍将被触发。 如果由于某种原因你想在最后的窗口被关闭后wxPython应用程序仍然可以 继续，你可以使用wx.App的SetExitOnFrameDelete(flag)方法来改变默认的行 为。如果flag参数设置为False，那么最后的窗口被关闭后wxPython应用程序仍 然会继续运行。这意味着wx.App实例将继续存活，并且事件循环将继续处理事 件，比如这时你还可以创建所有新的这里所谓的顶级窗口。wxPython应用程序 将保持存活直到全局函数wx.Exit()被明确地调用。 2.4.2 管理紧急关闭 你不能总是以一个可控的方法关闭你的程序。有时候，你需要立即结束应 用程序并不考虑清理工作。例如一个必不可少的资源可能已被关闭或被损坏。 如果系统正在关闭，你可能不能做所有的清理工作。 这里有两种在紧急情况下退出你的wxPython应用程序的方法。你可以调用 wx.App的ExitMainLoop()方法。这个方法显式地使用主消息循环终止，使用控 制离开MainLoop()函数。这通常将终止应用程序，这个方法实际上等同于关闭 所有这里所谓顶级窗口。 你也可以调用全局方法wx.Exit()。正常使用情况下，两种方法我们都不推 荐，因为它将导致一些清理函数被跳过。 有时候，你的应用程序由于一个控制之外的事件而需要关闭。例如操作系 统的关闭或注销。在这种情况下，你的应用程序将试图做一些保存文档或关闭 连接等等。如果你的应用程序为wx.EVT_QUERY_END_SESSION事件绑定了 一个事件处理器，那么当wxPython得到关闭通知时这个事件处理器将被调用。 这个event参数是wx.CloseEvent。我们可以通过关闭事件来否决关闭。这可以使 用关闭事件的CanVeto()方法，CanVeto()方法决定是否可以否决，Veto()执行否 决。如果你不能成功地保存或关闭所有的资源，你可能想使用该方 法。wx.EVT_QUERY_END_SESSION事件的默认处理器调用顶级窗口的Close() 方法，这将依次向顶层窗口发送wx.EVT_CLOSE事件，这给了你控制关闭过程 35 / 565
- 36. 的另一选择。如果任何一个Close()方法返回False，那么应用程序将试图否决关 闭。 2.5 如何创建和使用顶级窗口对象? 在你的应用程序中一个顶级窗口对象是一个窗口部件（通常是一个框 架），它不被别的窗口部件所包含。顶级窗口对象通常是你的应用程序的主窗 口，它包含用户与之交互的窗口部件和界面对象。当所有的顶级窗口被关闭时 应用程序退出。 你的应用程序至少必须有一个顶级窗口对象。顶级窗口对象通常是类 wx.Frame的子类，尽管它也可以是wx.Dialog的子类。大多数情况下，你将为了 使用为你的应用程序定义定制的wx.Frame的子类。然而，这儿也存在一定数量 的预定义的wx.Dialog的子类，它们提供了许多你可能会在一个应用程序中遇到 的典型的对话框。 这儿可能有一个名称上的混淆，那就是“顶级窗口”。一般意义上的顶级窗 口是指在你的应用程序中任何没有父容器的窗口部件。你的应用程序必须至少 有一个，但是，只要你喜欢可以有多个。但是它们中只有一个可以通过使用 SetTopWindow()被wxPython作为主顶级窗口。如果你没有使用SetTopWindow() 指定主顶级窗口，那么在wx.App的顶级窗口列表中的第一个框架将被认为是这 个主顶级窗口。因此，明确地定义一个主顶级窗口不总是必要的，例如，你只 有一个顶级窗口的时候。反复调用SetTopWindow()将反复改变当前的主顶级窗 口，因为一个应用程序一次只能有一主顶级窗口。 2.5.1 使用wx.Frame 按照wxPython中的说法，框架就是用户通常称的窗口。那就是说，框架是 一个容器，用户可以将它在屏幕上任意移动，并可将它缩放，它通常包含诸如 标题栏、菜单等等。在wxPython中，wx.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
- 37. 我们在别的窗口部件的构造器中将会看到类似的参数。参数的说明如下： parent：框架的父窗口。对于顶级窗口，这个值是None。框架随其父窗口的销毁而 销毁。取决于平台，框架可被限制只出现在父窗口的顶部。在多文档界面的情况下， 子窗口被限制为只能在父窗口中移动和缩放。 id：关于新窗口的wxPython ID号。你可以明确地传递一个。或传递-1，这将导致 wxPython自动生成一个新的ID。 title：窗口的标题。 pos：一个wx.Point对象，它指定这个新窗口的左上角在屏幕中的位置。在图形用户 界面程序中，通常(0,0)是显示器的左上角。这个默认的(-1,-1)将让系统决定窗口的位 置。 size：一个wx.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 使用wxPython的ID 在wxPython中，ID号是所有窗口部件的特征。在一个wxPython应用程序 中，每个窗口部件都有一个窗口标识。在每一个框架内，ID号必须是唯一的， 但是在框架之间你可以重用ID号。然而，我们建议你在你的整个应用程序中保 持ID号的唯一性，以防止处理事件时产生错误和混淆。在wxPython中也有一些 标准的预定义的ID号，它们有特定的意思（例如，wx.ID_OK和 wx.ID_CANCEL是对话框中的OK和Cancel按钮的ID号）。在你的应用程序中重 用标准的ID号一般没什么问题，只要你在预期的方式中使用它们。在wxPython 中，ID号的最重要的用处是在指定的对象发生的事件和响应该事件的回调函数 之间建立唯一的关联。 37 / 565
- 38. 有三种方法来创建一个窗口部件使用的ID号： 1、明确地给构造器传递一个正的整数 2、使用wx.NewId()函数 3、传递一个全局常量wx.ID_ANY或-1给窗口部件的构造器 明确地选择ID号 第一个或最直接的方法是明确地给构造器传递一个正的整数作为该窗口部 件的ID。如果你这样做了，你必须确保在一个框架内没有重复的ID或重用了一 个预定义的常量。你可以通过调用wx.RegisterId()来确保在应用程序中wxPython 不在别处使用你的ID。要防止你的程序使用相同的wxPython ID，你应该避免 使用全局常量wx.ID_LOWEST和wx.ID_HIGHEST之间的ID号。 使用全局性的NewID()函数 自己确保ID号的唯一性十分麻烦，你可以使用wx.NewId()函数让wxPython 来为你创建ID： id = wx.NewId() frame = wx.Frame.__init__(None, id) 你也可以给窗口部件的构造器传递全局常量wx.ID_ANY或-1，然后 wxPython将为你生成新的ID。然后你可以在需要这个ID时使用GetId()方法来得 到它： frame = wx.Frame.__init__(None, -1) id = frame.GetId() 2.5.3 使用wx.Size和wx.Point wx.Frame构造器的参数也引用了类wx.Size和wx.Point。这两个类在你的 wxPython编程中将频繁被使用。 wx.Point类表示一个点或位置。构造器要求点的x和y值。如果不设置x,y 值，则值默认为0。我们可以使用Set(x,y)和Get()函数来设置和得到x和y 值。Get()函数返回一个元组。x和y值可以像下面这样作为属性被访问： point = wx.Point(10, 12) x = point.x 38 / 565
- 39. y = point.y 另外，wx.Point的实例可以像其它Python对象一样作加、减和比较运算， 例如： a = wx.Point(2, 3) b = wx.Point(5, 7) c = a + b bigger = a > b 在wx.Point的实参中，坐标值一般为整数。如果你需要浮点数坐标，你可 以使用类wx.RealPoint，它的用法如同wx.Point。 wx.Size类几乎和wx.Point完全相同，除了实参的名字是width和height。对 wx.Size的操作与wx.Point一样。 在你的应用程序中当一个wx.Point或wx.Size实例被要求的时候（例如在另 一个对象的构造器中），你不必显式地创建这个实例。你可以传递一个元组给 构造器，wxPython将隐含地创建这个wx.Point或wx.Size实例： frame = wx.Frame(None, -1, pos=(10, 10), size=(100, 100)) 2.5.4 使用wx.Frame的样式 每个wxPython窗口部件都要求一个样式参数。这部分我们将讨论用于 wx.Frame的样式。它们中的一些也适用于别的wxPython窗口部件。一些窗口部 件也定义了一个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
- 41. 图2.4是使用wx.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
- 43. frame.Show() app.MainLoop() 类InsertFrame的方法__init__创建了两子窗口。第一个是wx.Panel，它是其 它窗口的容器，它自身也有一点功能。第二个是wx.Button，它是一个平常按 钮。接下来，按钮的单击事件和窗口的关闭事件被绑定到了相应的函数，当事 件发生时这相应的函数将被调用执行。 大多数情况下，你将创建一个与你的wx.Frame大小一样的wx.Panel实例以 容纳你的框架上的所有的内容。这样做可以让定制的窗口内容与其他如工具栏 和状态栏分开。 通过tab按钮，可以遍历wx.Panel中的元素，wx.Frame不能。 你不必像使用别的UI工具包那样，你不需要显式调用一个增加方法来向双 亲中插入一个子窗口。在wxPython中，你只需在子窗口被创建时指定父窗口， 这个子窗口就隐式地增加到父对象中了，例如例2.3所示。 你可能想知道在例2.3中，为什么wx.Button被创建时使用了明确的位置和 尺寸，而wx.Panel没有。在wxPython中，如果只有一个子窗口的框架被创建， 那么那个子窗口（例2.3中是wx.Panel）被自动重新调整尺寸去填满该框架的客 户区域。这个自动调整尺寸将覆盖关于这个子窗口的任何位置和尺寸信息，尽 管关于子窗口的信息已被指定，这些信息将被忽略。这个自动调整尺寸仅适用 于框架内或对话框内的只有唯一元素的情况。这里按钮是panel的元素，而不是 框架的，所以要使用指定的尺寸和位置。如果没有为这个按钮指定尺寸和位 置，它将使用默认的位置（panel的左上角）和基于按钮标签的长度的尺寸。 显式地指定所有子窗口的位置和尺寸是十分乏味的。更重要的是，当用户 调整窗口大小的时候，这使得子窗口的位置和大小不能作相应调整。为了解决 这两个问题，wxPython使用了称为sizers的对象来管理子窗口的复杂布局。 43 / 565
- 44. 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
- 45. 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() 说明： #1：这行创建了一个状态栏，它是类wx.StatusBar的实例。它被放置在框架 的底部，宽度与框架相同，高度由操作系统决定。状态栏的目的是显示在应用 程序中被各种事件所设置的文本。 #2：创建了一个wx.ToolBar的实例，它是命令按钮的容器。它被自动放置 在框架的顶部 #3：有两种方法来为你工具栏增加工具，这行使用了参数较少的一种： AddSimpleTool()。参数分别是ID，位图，该工具的短的帮助提示文本，显示在 状态栏中的该工具的长的帮助文本信息。（此刻不要考虑位图从哪儿来） #4：Realize()方法告诉工具栏这些工具按钮应该被放置在哪儿。这是必须 的。 #6：创建菜单的项目，其中参数分别代表ID，选项的文本，当鼠标位于其 上时显示在状态栏的文本。 2.7 如何使用一般的对话框? wxPython提供了一套丰富的预定义的对话框。这部分，我们将讨论三种用 对话框得到来自用户的信息： 1、消息对话框 2、文本输入对话框 3、从一个列表中选择 45 / 565
- 46. 在wxPython中有许多别的标准对话框，包括文件选择器、色彩选择器、进 度对话框、打印设置和字体选择器。这些将在第9章介绍。 消息对话框 与用户通信最基本的机制是wx.MessageDialog，它是一个简单的提示 框。wx.MessageDialog可用作一个简单的OK框或yes/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) 参数说明： parent：对话框的父窗口，如果对话框是顶级的则为None。 message：显示在对话框中的字符串。 caption：显示在对话框标题栏上的字符串。 style：对话框中按钮的样式。 pos：对话框出现的位置。 46 / 565
- 47. ShowModal()方法将对话框以模式框架的方式显示，这意味着在对话框关 闭之前，应用程序中的别的窗口不能响应用户事件。ShowModal()方法的返回 值是一个整数，对于wx.MessageDialog，返回值是下面常量之 一： wx.ID_YES, wx.ID_NO, wx.ID_CANCEL, wx.ID_OK。 文本输入对话框 如果你想从用户那里得到单独一行文本，你可能使用类 wx.TextEntryDialog。下面的片断创建了一个文本输入域，当用户单击OK按钮 退出时，获得用户输入的值： 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.CANCEL。与wx.MessageDialog一 样，ShowModal()方法返回所按下的按钮的ID。GetValue()方法得到用户输入在 文本域中的值（这有一个相应的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
- 48. if dlg.ShowModal() == wx.ID_OK: response = dlg.GetStringSelection() 图2.12显示了上面代码片断的结果。 wx.SingleChoiceDialog的参数类似于文本输入对话框，只是以字符串的列 表代替了默认的字符串文本。要得到所选择的结果有两种方法，GetSelection() 方法返回用户选项的索引，而GetStringSelection()返回实际所选的字符串。 2.8 一些最常见的错误现象及解决方法? 有一些错误它们可能会发生在你的wxPython应用程序对象或初始的顶级窗 口在创建时，这些错误可能是很难诊断的。下面我们列出一些最常见的错误现 象及解决方法： 错误现象： 程序启动时提示“unable to import module wx。” 原因： wxPython模块不在你的PYTHONPATH中。这意味着wxPython没有被正确地安装。 如果你的系统上有多个版本的Python，wxPython可能安装在了你没有使用的Python 版本中。 解决方法： 首先，确定你的系统上安装了哪些版本的Python。在Unix系统上，使用which python 命令将告诉你默认的安装。在Windows系统上，如果wxPython被安装到了相应的 Python版本中，它将位于<python-home>/Lib/site-packages子目录下。然后重装 wxPython。 48 / 565
- 49. 错误现象： 应用程序启动时立即崩溃，或崩溃后出现一空白窗口。 原因： 在wx.App创建之前，创建或使用了一个wxPython对象。 解决方法： 在启动你的脚本时立即创建wx.App对象。 错误现象： 顶级窗口被创建同时又立刻关闭。应用程序立即退出。 原因： 没有调用wx.App的MainLoop()方法。 解决方法： 在你的所有设置完成后调用MainLoop()方法。 错误现象： 顶级窗口被创建同时又立刻关闭。应用程序立即退出。但我调用了MainLoop()方 法。 原因： 你的应用程序的OnInit()方法中有错误，或OnInit()方法调用了某些方法（如帧的 __init__()方法）。 解决方法： 在MainLoop()被调用之前出现错误的话，这将触发一个异常且程序退出。如果你的 应用程序设置了重定向输出到窗口，那么那些窗口将一闪而过，你不能看到显示在窗 口中的错误信息。这种情况下，你要使用 redirect=False关闭重定向选项，以便看到 错误提示。 2.9 总结 1、wxPython程序的实现基于两个必要的对象：应用程序对象和顶级窗 口。任何wxPython应用程序都需要去实例化一个wx.App，并且至少有一个顶级 窗口。 2、应用程序对象包含OnInit()方法，它在启动时被调用。在这个方法中， 通常要初始化框架和别的全局对象。wxPython应用程序通常在它的所有的顶级 窗口被关闭或主事件循环退出时结束。 3、应用程序对象也控制wxPython文本输出的位置。默认情况 下，wxPython重定向stdout和stderr到一个特定的窗口。这个行为使得诊断启动 时产生的错误变得困难了。但是我们可以通过让wxPython把错误消息发送到一 个文件或控制台窗口来解决。 49 / 565
- 51. 3、在事件驱动环境中工作 事件处理是wxPython程序工作的基本机制。主要执行事件处理的工作称为 事件驱动。在这章中我们将讨论什么是事件驱动应用程序，它与传统的应用程 序有什么不同。我们将对在GUI编程中所使用的概念和术语提供一些介绍，包 括与用户交互，工具包和编程逻辑。也将包括典型事件驱动程序的生命周期。 事件就是发生在你的系统中的事，你的应用程序通过触发相应的功能以响 应它。事件可以是低级的用户动作，如鼠标移动或按键按下，也可以是高级的 用户动作（定义在wxPython的窗口部件中的），如单击按钮或菜单选择。事件 可以产生自系统，如关机。你甚至可以创建你自己的对象去产生你自己的事 件。wxPython应用程序通过将特定类型的事件和特定的一块代码相关联来工 作，该代码在响应事件时执行。事件被映射到代码的过程称为事件处理。 本章将说明事件是什么，你如何写响应一个事件的代码，以及wxPython在 事件发生的时候是如何知道去调用你的代码的。我们也将说明如何将定制的事 件增加到wxPython库中，该库包含了关于用户和系统行为的标准事件的一个列 表。 3.1 要理解事件，我们需要知道哪些术语？ 本章包含了大量的术语，很多都是以event开头的。下表3.1是我们将要用 到的术语的一个快速参考： 事件(event)：在你的应用程序期间发生的事情，它要求有一个响应。 事件对象(event object)：在wxPython中，它具体代表一个事件，其中包括了事件的 数据等属性。它是类wx.Event或其子类的实例，子类如wx.CommandEvent和 wx.MouseEvent。 事件类型(event type)：wxPython分配给每个事件对象的一个整数ID。事件类型给出 了关于该事件本身更多的信息。例如，wx.MouseEvent的事件类型标识了该事件是 一个鼠标单击还是一个鼠标移动。 事件源(event source)：任何wxPython对象都能产生事件。例如按钮、菜单、列表框 和任何别的窗口部件。 事件驱动(event-driven)：一个程序结构，它的大部分时间花在等待或响应事件上。 事件队列(event queue)：已发生的但未处理的事件的一个列表。 51 / 565
- 52. 事件处理器(event handler)：响应事件时所调用的函数或方法。也称作处理器函数或 处理器方法。 事件绑定器(event binder)：一个封装了特定窗口部件，特定事件类型和一个事件处 理器的wxPython对象。为了被调用，所有事件处理器必须用一个事件绑定器注册。 wx.EvtHandler：一个wxPython类，它允许它的实例在一个特定类型，一个事件源， 和一个事件处理器之间创建绑定。注意，这个类与先前定义的事件处理函数或方法不 是同一个东西。 3.2 什么是事件驱动编程? 事件驱动程序主要是一个控制结构，它接受事件并响应它们。wxPython程 序（或任何事件驱动程序）的结构与平常的Python脚本不同。标准的Python脚 本有一个特定的开始点和结束点，程序员使用条件、循环、和函数来控制执行 顺序。 从用户的角度上来看，wxPython程序大部分时间什么也不做，一直闲着直 到用户或系统做了些什么来触发这个wxPython程序动作。wxPython程序的结构 就是一个事件驱动程序体系的例子。图3.1是事件处理循环的示意，它展示了主 程序的生命、用户事件、和分派到的处理器函数。 事件驱动系统的主循环类似于客户服务呼叫中心的操作者。当没有呼叫的 进入的时候，这个操作者处于等待状态。当一个事件发生的时候，如电话铃响 52 / 565
- 53. 了，这个操作者开始一个响应过程，他与客户交谈直到他获得足够的信息以分 派该客户给一个合适的回答者。然后操作者等待下一个事件。 尽管每个事件驱动系统之间有一些不同，但它们有很多相似的地方。下面 列出了事件驱动程序结构的主要特点： 1、在初始化设置之后，程序的大部分时间花在了一个空闭的循环之中。 进入这个循环就标志着程序与用户交互的部分的开始，退出这个循环就标志结 束。在wxPython中，这个循环的方法是：wx.App.MainLoop()，并且在你的脚本 中显式地被调用。当所有的顶级窗口关闭时，主循环退出。 2、程序包含了对应于发生在程序环境中的事情的事件。事件通常由用户 的行为触发，但是也可以由系统的行为或程序中其他任意的代码。在wxPython 中，所有的事件都是类wx.Event或其子类的一个实例。每个事件都有一个事件 类型属性，它使得不同的事件能够被辨别。例如，鼠标释放和鼠示按下事件都 被认为是同一个类的实例，但有不同的事件类型。 3、作为这个空闭的循环部分，程序定期检查是否有任何请求响应事情发 生。有两种机制使得事件驱动系统可以得到有关事件的通知。最常被wxPython 使用的方法是，把事件传送到一个中心队列，由该队列触发相应事件的处理。 另一种方法是使用轮询的方法，所有可能引发事件的事件主被主过程定期查询 并询问是否有没有处理的事件。 4、当事件发生时，基于事件的系统试着确定相关代码来处理该事件，如 果有，相关代码被执行。在wxPython中，原系统事件被转换为wx.Event实例， 然后使用wx.EvtHandler.ProcessEvent()方法将事件分派给适当的处理器代码。图 3.3呈现了这个过程： 53 / 565
- 54. 事件机制的组成部分是事件绑定器对象和事件处理器。事件绑定器是一个 预定义的wxPython对象。每个事件都有各自的事件绑定器。事件处理器是一个 函数或方法，它要求一个wxPython事件实例作为参数。当用户触发了适当的事 件时，一个事件处理器被调用。 下面我们将讨论有关wxPython更多的细节，我们把事件响应的基本单 元“事件处理器”作为开始。 3.2.1 编写事件处理器 在你的wxPython代码中，事件和事件处理器是基于相关的窗口部件的。例 如，一个按钮被单击被分派给一个基于该按钮的专用的事件处理器。为了要把 一个来自特定窗口部件的事件绑定到一个特定的处理器方法，你要使用一个绑 定器对象来管理这个连接。例如： self.Bind(wx.EVT_BUTTON, self.OnClick, aButton) 上例使用了预定义的事件绑定器对象wx.EVT_BUTTON来将aButton对象上 的按钮单击事件与方法self.OnClick相关联起来。这个Bind()方法是 wx.EvtHandler的一个方法，wx.EvtHandler是所有可显示对象的父类。因此上例 代码行可以被放置在任何显示类。 54 / 565
- 55. 即使你的wxPython程序表面上看起来在被动地等待事件，但它仍在做事。 它在运行方法wx.App.MainLoop()，该方法是一个无限的循环。MainLoop()方法 可以使用Python伪代码表示如下： while True: while not self.Pending(): self.ProcessIdle() self.DoMessage() 上面的伪代码意思是如果没有未处理的消息，则做一些空闲时做的事；如 果有消息进入，那么将这个消息分派给适当的事件处理方法。 3.2.2 设计事件驱动程序 对于事件驱动程序的设计，由于没有假设事件何时发生，所以程序员将大 量的控制交给了用户。你的wxPython程序中的大多数代码通过用户或系统的行 为被直接或间接地执行。例如在用户选择了一个菜单项、或按下一个工具栏按 钮、或按下了特定的按键组合后，你的程序中有关保存工作的代码被执行了。 另一方面，事件驱动体系通常是分散性的。响应一个窗口部件事件的代码 通常不是定义在该部件的定义中的。例如，响应一个按钮单击事件的代码不必 是该按钮定义的一部分，而可以存在在该按钮所附的框架中或其它地方。当与 面向对象设计结合时，这个体系导致了松散和高度可重用的代码。你将会发现 Python的灵活使得重用不同的wxPython应用程序的通常的事件处理器和结构变 得非常容易。 3.2.3 事件触发 在wxPython中，大部分窗口部件在响应低级事件时都导致高级事件发生。 例如，在一个wx.Button上的鼠标单击导致一个EVT_BUTTON事件的生成，该 事件是wx.CommandEvent的特定类型。类似的，在一个窗口的角中拖动鼠标将 导致wxPython为你自动创建一个wx.SizeEvent事件。高级事件的用处是让你的 系统的其它部分更容易聚焦于最有关联的事件上，而不是陷于追踪每个鼠标单 击。高级事件能够封装更多关于事件的有用的信息。当你创建你自已的定制的 窗口部件时，你能定义你自己的定制事件以便管理事件的处理。 在wxPython中，代表事件的是事件对象。事件对象是类wx.Event或其子类 的一个实例。父类wx.Event相对小且抽象，它只是包含了对所有事件的一些通 常的信息。wx.Event的各个子类都添加了更多的信息。 55 / 565
- 56. 在wxPython中，有一些wx.Event的子类。表3.2包含了你将最常遇到的一些 事件类。记住，一个事件类可以有多个事件类型，每个都对应于一个不同的用 户行为。下表3.2是wx.Event的重要的子类。 wx.CloseEvent：当一个框架关闭时触发。这个事件的类型分为一个通常的框架关闭 和一个系统关闭事件。 wx.CommandEvent：与窗口部件的简单的各种交互都将触发这个事件，如按钮单 击、菜单项选择、单选按钮选择。这些交互有它各自的事件类型。许多更复杂的窗口 部件，如列表等则定义wx.CommandEvent的子类。事件处理系统对待命令事件与其 它事件不同。 wx.KeyEvent：按按键事件。这个事件的类型分按下按键、释放按键、整个按键动 作。 wx.MouseEvent：鼠标事件。这个事件的类型分鼠标移动和鼠标敲击。对于哪个鼠 标按钮被敲击和是单击还是双击都有各自的事件类型。 wx.PaintEvent：当窗口的内容需要被重画时触发。 wx.SizeEvent：当窗口的大小或其布局改变时触发。 wx.TimerEvent：可以由类wx.Timer类创建，它是定期的事件。 通常，事件对象需要使用事件绑定器和事件处理系统将它们传递给相关的 事件处理器。 3.3 如何将事件绑定到处理器? 事件绑定器由类wx.PyEventBinder的实例组成。一个预定义的 wx.PyEventBinder的实例被提供给所有支持的事件类型，并且在你需要的时候 你可以为你定制的事件创建你自己的事件绑定器。每个事件类型都有一个事件 绑定器，这意味着一个wx.Event的子类对应多个绑定器。 在wxPython中，事件绑定器实例的名字是全局性的。为了清楚地将事件类 型与处理器联系起来，它们的名字都是以wx.EVT_开头并且对应于使用在C+ + wxWidgets代码中宏的名字。值得强调的是，wx.EVT绑定器名字的值不是你 通过调用一个wx.Event实例的GetEventType()方法得到的事件类型的实际的整数 码。事件类型整数码有一套完全不同的全局名，并且在实际中不常被使用。 作为wx.EVT名字的例子，让我们看看wx.MouseEvent的事件类型。正如我 们所提到的，它们有十四个，其中的九个涉及到了基于在按钮上的敲击，如鼠 标按下、鼠标释放、或双击事件。这九个事件类型使用了下面的名字： wx.EVT_LEFT_DOWN wx.EVT_LEFT_UP wx.EVT_LEFT_DCLICK 56 / 565
- 57. 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_WINDOW和wx.LEAVE_WINDOW产生于当鼠标进入或离开一个窗 口部件时。类型wx.EVT_MOUSEWHEEL被绑定到鼠标滚轮的活动。最后，你 可以使用类型wx.EVT_MOUSE_EVENTS一次绑定所有的鼠标事件到一个函 数。 同样，类wx.CommandEvent有28个不同的事件类型与之关联；尽管有几个 仅针对老的Windows操作系统。它们中的大多数是专门针对单一窗口部件的， 如wx.EVT_BUTTON用于按钮敲击，wx.EVT_MENU用于菜单项选择。用于专 门窗口部件的命令事件在part2中讨论。 绑定机制的好处是它使得wxPython可以很细化地分派事件，而仍然允许同 类的类似事件发生并且共享数据和功能。这使得在wxPython中写事件处理比在 其它界面工具包中清细得多。 事件绑定器被用于将一个wxPython窗口部件与一个事件对象和一个处理器 函数连接起来。这个连接使得wxPython系统能够通过执行处理器函数中的代码 来响应相应窗口部件上的事件。在wxPython中，任何能够响应事件的对象都是 wx.EvtHandler的子类。所有窗口对象都是wx.EvtHandler的子类，因些在 wxPython应用程序中的每个窗口部件都能够响应事件。类wx.EvtHandler也能够 被非窗口部件对象所使用，如wx.App，因此事件处理功能不是限于可显示的窗 口部件。我们所说的窗口部件能响应事件的意思是：该窗口部件能够创建事件 绑定，在分派期间wxPython能够识别该事件绑定。由绑定器调用的在事件处理 器函数中的实际代码不是必须位于一个wx.EvtHandler类中。 3.3.1 使用wx.EvtHandler的方法工作 wx.EvtHandler类定义的一些方法在一般情况下用不到。你会经常使用的 wx.EvtHandler的方法是Bind()，它创建事件绑定。该方法的用法如下： Bind(event, handler, source=None, id=wx.ID_ANY, id2=wx.ID_ANY) Bind()函数将一个事件和一个对象与一个事件处理器函数关联起来。参数 event是必选的，它是我们在3.3节中所说的wx.PyEventBinder的一个实例。参数 57 / 565
- 58. handler也是必选的，它是一个可调用的Python对象，通常是一个被绑定的方法 或函数。处理器必须是可使用一个参数（事件对象本身）来调用的。参数 handler可以是None，这种情况下，事件没有关联的处理器。参数source是产生 该事件的源窗口部件，这个参数在触发事件的窗口部件与用作事件处理器的窗 口部件不相同时使用。通常情况下这个参数使用默认值None，这是因为你一般 使用一个定制的wx.Frame类作为处理器，并且绑定来自于包含在该框架内的窗 口部件的事件。父窗口的__init__是一个用于声明事件绑定的方便的位置。但是 如果父窗口包含了多个按钮敲击事件源（比如OK按钮和Cancel按钮），那么就 要指定source参数以便wxPython区分它们。下面是该方法的一个例子： self.Bind(wx.EVT_BUTTON, self.OnClick, button) 下例3.1演示了使用参数source和不使用参数source的方法，它改编自第二 章中的代码： 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
- 59. #!/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()方法中的参数id和id2使用ID号指定了事件的源。一般情况下这没必 要，因为事件源的ID号可以从参数source中提取。但是某些时候直接使用ID是 合理的。例如，如果你在使用一个对话框的ID号，这比使用窗口部件更容易。 如果你同时使用了参数id和id2，你就能够以窗口部件的ID号形式将这两个ID号 之间范围的窗口部件绑定到事件。这仅适用于窗口部件的ID号是连续的。 注意：Bind()方法出现在wx.Python2.5中，以前版本的事件绑定中，EVT_*的用法如 同函数对象，因此你会看到如下的绑定调用： wx.EVT_BUTTON(self, self.button.GetId(), self.OnClick) 这个方式的缺点是它不像是面向对象的方法调用。然而，这个老的样式仍 可工作在2.5的版本中（因为wx.EVT*对象仍是可调用的）。 下表3.3列出了最常使用的wx.EvtHandler的方法： 59 / 565
- 61. 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
- 62. 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中的事件处理的一 些问题。#1中，按钮事件由附着在框架上的按钮触发，那么wxPython怎么知道 在框架对象中查找绑定而不是在按钮对象上呢？在#2和#3中，鼠标的进入和离 开事件被绑定到了按钮，为什么这两个事件不能被绑到框架上呢。这些问题将 通过检查wxPython用来决定如何响应事件的过程来得到回答。 3.4.1 理解事件处理过程 wxPython的事件处理过程被设计来简化程序员关于事件绑定的创建，使他 们不必考虑哪些不重要的事件。 隐藏在简化设计之下的底层机制是有些复杂的。接下来，我们将跟踪关于 按钮敲击和鼠标进入事件的过程。 62 / 565
- 63. 图3.3显示了事件处理过程的一个基本的流程。矩形代表过程的开始和结 束，环形代表各种wxPython对象（它们是这个过程的一部分），棱形代表判断 点，带条的矩形代表实际的事件处理方法。 事件处理过程开始于触发事件的对象。通常，wxPython首先在触发对象中 查找匹配事件类型的被绑定的处理器函数。如果找到，则相应的方法被执行。 否则，wxPython将检查该事件是否传送到了上一级的容器。如果是的话，父窗 口部件将被检查，这样一级一级向上寻找，直到wxPython找到了一个处理器函 数或到达了顶级窗口。如果事件没有传播，在处理过程完成之前，wxPython仍 将为了处理器函数而检查应用程序对象。 当事件处理器运行时，过程通常就结束了。然而，函数可以告诉wxPython 去继续查找处理器。 下面让我们仔细观察一下这个过程的每一个步骤。我们的每步分析都有图 3.3的一个相关略图。 63 / 565
- 64. 第一步，创建事件 这个过程开始于事件被创建时。 在wxPython架构中已经创建了大多数的事件类型，它们用于响应特定的用 户动作或系统通知。例如，当wxPython通知“鼠标移进了一个新窗口部件对象 时”，鼠标进入事件被触发，鼠标敲击事件在鼠标按下或释放后被创建。 事件首先被交给创建事件的对象。对于按钮敲击，这个对象是按钮；对于 鼠标进入事件，这个对象是所进入的窗口部件。 第二步，确定事件对象是否被允许处理事件。 事件处理过程检查的下一步是看相关窗口部件当前是否被允许去处理事 件。 通过调用wx.EvtHandler的SetEvtHandlerEnabled(boolean)方法，一个窗口可 以被设置为允许或不允许事件处理。不允许事件处理的结果是该窗口部件在事 件处理中被完全绕过，与该对象关联的绑定对象也不会被搜索，并且在这步中 的处理没有向下的分支。 在事件处理器级使一个窗口部件有效或无效与在用户界面级(UI)不一样。 在UI级使一个窗口部件无效或有效，使用wx.Window的方法Disable()和 Enable()。在UI级使一个窗口部件无效意味用户不能与这个无效的窗口部件交 互。通常无效的窗口部件在屏幕上以灰化的状态表示。一个在UI级无效的窗口 不能产生任何事件；但是，如果它对于别的事件是容器的级别，它仍然能够处 理它接受到的事件。本节的剩余内容，我们将在wx.EvtHandler层面上使用有效 和无效，这涉及到窗口部件是否被允许处理事件。 对于初始对象有效或无效状态的检查，这发生在ProcessEvent()方法中，该 方法由wxPython系统调用以开始和处理事件分配机制。我们将在事件处理过程 中一再看到ProcessEvent()方法，它是类wx.EvtHandler中的方法，它实际上执行 图3.3所描绘的大量事件处理。如果ProcessEvent()方法最后完成了事件处理，则 64 / 565
- 66. 如果对象自身的绑定器没有被找到，那么向上到该对象的超类中去寻找。 如果一个绑定器对象被发现，wxPython调用相关的处理器函数。在处理器被调 用后，该事件的事件处理停止，除非处理器函数显式地要求作更多的处理。 在例子3.3中，因为在按钮对象，绑定器对象wx.EVT_ENTER_WINDOW， 和相关的方法OnEnterWindow()之间定义了绑定，所以鼠标进入事件被捕 获，OnEnterWindow()方法被调用。由于我们没有绑定鼠标敲击事件 wx.EVT_LEFT_DOWN，在这种情况下，wxPython将继续搜索。 第四步 决定是否继续处理 如图3.7所示 在调用了第一个事件处理器之后，wxPython查看是否有进一步的处理要 求。事件处理器通过调用wx.Event的方法Skip()要求更多的处理。如果Skip()方 法被调用，那么处理将继续，并且任何定义在超类中的处理器在这一步中被发 现并执行。Skip()方法在处理中的任一点或处理器所调用的任何代码中都可以 被调用。Skip()方法在事件实例中设置一个标记，在事件处理器方法完成 后，wxPython检查这个标记。在例3.3中，OnButtonClick()不调用Skip()，因此 在那种情况下，处理器方法结束后，事件处理完成。在另两个事件处理器中调 用了Skip()，所以系统将保持搜索“匹配事件绑定”，最后对于原窗口部件的鼠标 进入和离开事件调用默认的功能，如鼠标位于其上的事件。 66 / 565
- 67. 第五步 决定是否展开 如图3.8所示 最后，wxPython决定是否将事件处理向上展开到容器级以发现一个事件处 理器。所谓的容器级是从一个特定的窗口部件到顶层框架的路径，这个路径是 从窗口部件到它的父容器，一直向上沿升。 如果当前对象没有关于该事件的一个处理器，或如果处理器调用了 Skip()，wxPython将决定是否这个事件将沿容器级向上展开。如果决定不，那 么在wx.App实例中再找寻一次处理器，然后停止。如果决定是，则事件处沿该 窗口的容器级向上搜索，直到发现适当的绑定，或到达顶层框架对象，或到达 一个wx.Dialog对象（即使这个对话框不是顶级的）。如果ProcessEvent()返回 True，事件则被认为发现了一个适当的绑定，这表示处理完成。到达一个 wx.Dialog停止的目的是防止父框架被来自对话框的无关的或未预期的假事件干 扰。 一个事件是否向上展开至容器级，这是每个事件实例的一个动态属性，尽 管实际上默认值几乎总是使用那几个。默认情况，只有wx.CommandEvent及其 子类的实例向上展开至容器级。其它的所有事件不这样做。 67 / 565
- 68. 在例3.3中，按钮敲击事件得到处理。在wx.Button上敲击鼠标产生一个命 令类型的事件wx.EVT_BUTTON。由于wx.EVT_BUTTON属于一个 wx.CommandEvent，所以wxPython在这个按钮对象中找寻绑定失败后，它将向 上展开至容器级，先是按钮的父窗口panel。由于panel中没有相匹配的绑定，所 以又向上至panel的父窗口frame。由于frame中有匹配的绑定，所以 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
- 69. 例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.Bind）而非框架（self.Bind）。 69 / 565
- 70. 当用户在按钮上敲击鼠标时，通过直接与底层操作系统交互，鼠标左键按 下事件首先被产生。通常情况下，鼠标左键按下事件改变按钮的状态，随着鼠 标左键的释放，产生了wx.EVT_BUTTON敲击事件。由于行#3的Skip()语 句，DoubleEventFrame维持处理。没有Skip()语句，事件处理规则发现在#2创建 的绑定，而在按钮能产生wx.EVT_BUTTON事件之前停止。由于Skip()的调 用，事件处理照常继续，并且按钮敲击被创建。 记住，当绑定低级事件时如鼠标按下或释放，wxPython期望捕获这些低级 事件以便生成进一步的事件，为了进一步的事件处理，你必须调用Skip()方 法，否则进一步的事件处理将被阻止。 3.5 在应用程序对象中还包含哪些其它的属性？ 要更直接地管理主事件循环，你可以使用一些wx.App方法来修改它。例 如，按你的计划，你可能想开始处理下一个有效的事件，而非等待wxPython去 开始处理。如果你正在执行一个长时间的过程，并且不想图形界面被冻结，那 么这个特性是必要的，通常你不需要使用这节中的这些方法，但是，这些性能 有时是很重要的。 下表3.4列出了你可以用来修改主循环的wx.App方法： Dispatch()：迫使事件队列中的下一个事件被发送。通过MainLoop()使用或使用在定 制的事件循环中。 Pending()：如果在wxPython应用程序事件队列中有等待被处理的事件，则返回 True。 Yield(onlyIfNeeded=False)：允许等候处理的wxWidgets事件在一个长时间的处理期 间被分派，否则窗口系统将被锁定而不能显示或更新。如果等候处理的事件被处理 了，则返回True，否则返回False。 onlyIfNeeded参数如果为True，那么当前的处理将让位于等候处理的事件。 如果该参数为False，那么递归调用Yield是错误的。 这里也有一个全局函数wx.SafeYield()，它阻止用户在Yield期间输入数据 （这通过临时使用来输入的窗口部件无效来达到目的），以免干扰Yield任务。 另一管理事件的方法是通过定制的方式，它创建你自己的事件类型，以匹 配你的应用程序中特定的数据和窗口部件。下一节我们将讨论如何创建你自己 的定制事件。 70 / 565
- 71. 3.6 如何创建自己的事件？ 尽管这是一个更高级的主题，但是我们将在这里讨论定制事件。当你第一 次阅读的时候，你可以跳过并且以后再回过头来读。 为了要与wxPython提供的事件类相区别，你可以创建你自己定制的事件。 你可以定制事件以响应哪些针对你的应用程序的数据更新或其它改变，此处定 制的事件必须负责你的自定义数据。创建定制的事件类的另一个原因是：你可 以针对所定制的窗口部件，使用它自己独特的命令事件类型。下一节中，我们 将看一个定制窗口部件的例子。 3.6.1 为一个定制的窗口部件定义一个定制的事件。 图3.9显示了这个窗口部件，一个画板(panel)包含了两个按钮。自定义的事 件TwoButtonEvent仅当用户敲击了这两个按钮之后被触发。这个事件包含了一 个关于用户在该部件上敲击次数的计数。 创建自定义事件的步骤： 1、定义一个新的事件类，它是wxPython的wx.PyEvent类的子类。如果你 想这个事件被作为命令事件，你可以创建wx.PyCommandEvent的子类。像许多 wxPython中的覆盖一样，一个类的py版本使得wxWidget系统明白用Python写的 覆盖C++方法的方法。 2、创建一个事件类型和一个绑定器对象去绑定该事件到特定的对象。 3、添加能够建造这个新事件实例的代码，并且使用ProcessEvent()方法将 这个实例引入事件处理系统。一旦该事件被创建，你就可以像使用其它的 wxPython事件一样创建绑定和处理器方法。 71 / 565
- 72. 下例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
- 74. 为C++事件处理不了解该Python子类。如果你wx.PyEvent，一个对该Python实例 的引用被保存，并且以后被直接传递给事件处理器，使得该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.1节。GetEventHandler()调用返回wx.EvtHandler 的一个实例。大多数情况下，返回的实例是窗口部件对象本身，但是如果其它 的wx.EvtHandler()方法已经被压入了事件处理器堆栈，那么返回的将是堆栈项 的项目。 #9 该自定义的事件的绑定如同其它事件一样，在这里使用#3所创建的绑定 器。 #10 这个例子的事件处理器函数改变窗口的标题以显示敲击数。 74 / 565
- 75. 至此，你的自定义的事件可以做任何预先存在的wxPython事件所能做的 事，比如创建不同的窗口部件，它们响应同样的事件。创建事件是wxPython的 定制的一个重要部分。 3.7 总结 1、wxPython应用程序使用基于事件的控制流。应用程序的大部分时间花 费在一个主循环中，等待事件并分派它们到适当的处理器函数。 2、所有的wxPython事件是wx.Event类的子类。低级的事件，如鼠标敲击， 被用来建立高级的事件，如按钮敲击或菜单项选择。这些由wxPython窗口部件 引起的高级事件是类wx.CommandEvent的子类。大多的事件类通过一个事件类 型字段被进一步分类，事件类型字段区分事件。 3、为了捕获事件和函数之间的关联，wxPython使用类wx.PyEventBinder的 实例。类wx.PyEventBinder有许多预定义的实例，每个都对应于一个特定的事 件类型。每个wxPython窗口部件都是类wx.EvtHandler的子类。类wx.EvtHandler 有一个方法Bind()，它通常在初始化时被调用，所带参数是一个事件绑定器实 例和一个处理器函数。根据事件的类型，别的wxPython对象的ID可能也需要被 传递给Bind()调用。 4、事件通常被发送给产生它们的对象，以搜索一个绑定对象，这个绑定 对象绑定事件到一个处理器函数。如果事件是命令事件，这个事件沿容器级向 上传递直到一个窗口部件被发现有一个针对该事件类型的处理器。一旦一个事 件处理器被发现，对于该事件的处理就停止，除非这个处理器调用了该事件的 Skip()方法。你可以允许多个处理器去响应一个事件，或去核查该事件的所有 默认行为。主循环的某些方面可以使用wx.App的方法来控制。 5、在wxPython中可以创建自定义事件，并作为定制（自定义）的窗口部 件的行为的一部分。自定义的事件是类wx.PyEvent的子类，自定义的命令事件 是类wx.PyCommandEvent的子类。为了创建一个自定义事件，新的类必须被定 义，并且关于每个事件类型（这些事件类型被这个新类所管理）的绑定器必须 被创建。最后，这个事件必须在系统的某处被生成，这通过经由ProcessEvent() 方法传递一个新的实例给事件处理器系统来实现。 在本章中，我们已经讨论了应用程序对象，它们对于你的wxPython应用程 序是最重要的。在下一章，我们将给你看一个有用的工具，它是用wxPython写 成的，它将帮助你使用wxPython进行开发工作。 75 / 565
- 76. 4、用PyCrust使得wxPython更易处理 PyCrust是一个图形化的shell程序，使用wxPython写成，它可以用来帮助你 分析你的wxPython程序。 为何称它为PyCrust？这是因为当Patrick O’Brien使用wxPython创建一个交 互式的Python shell时，PyShell已被使用了，所以选用了PyCrust这个名字。 PyCrust是Py包中的一部分，Py包目前被包含在wxPython中。这个Py包还 包含了其它相关功能的程序，这包括PyFilling, PyAlaMode, PyAlaCarte, 和 PyShell。这些程序每个都是想成为融图形化、点击环境 、wxPython的交互、 内省运行特点为一体。但是PyCrust表现最完善。 在这章中，我们将说明PyCrust和那些相关程序都干些什么，还有，你如何 使用它们才能使得你用wxPython工作得更流畅。我们以谈论普通的Python shell 作为开始，然后专门针对PyCrust，最后我们将涉及Py包中剩下的程序。 4.1 如何与wxPython程序交互？ 与其它编程语言相比，Python的一个显著的特点是你可以以两种方式来使 用它：你可以用它来运行存在的使用Python语言写的程序，或从命令提示符来 交互地运行Python。交互地运行Python如同与Python解释器会话。 在下例4.1中，我们从命令行启动Python，并键入一些数学运算。Python启 动后显示几行信息，然后是它的主提示符‘>>>’。当你键入的东西要求额外的代 码行时，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
- 77. ... print n * 9 ... 0 9 18 27 36 >>> 交互式的Python不仅仅是一个好的桌面计算器，它也是一个好的学习工 具，因为它提供了及时的反馈。当你有疑问时，你可以运行Python，键入几行 试验性的代码，看Python如何反应，据此调整你的主要代码。学习Python或学 习现有的Python代码是如何工作的，最好的方法之一就是交互式地调试。 PyCrust配置了标准的Python shell 当你交互式的使用Python工作时，你工作在一个称为Python shell的环境 中，它类似于其它的shell环境，如微软平台的DOS窗口，或类Unix系统的bash 命令行。 所有Python shell中最基本的是例4.1中所出现的，它是你从命令行启动 Python时所见到的。虽然它是一个有用的shell，但是它基于文本的，而非图形 化的，并且它不提供快捷方式或有帮助的提示。有几个图形化的Python shell已 经被开发出来了，它们提供了这些额外的功能。最著名的是IDLE，它是Python 发布版的标准部分。IDLE如下图4.1所示： 77 / 565
- 78. IDLE看起来很像命令行Python shell，但是它有额外的特性如调用提示。 其它的Python开发工具，如PythonWin和Boa Constructor，包括了类似于 IDLE中的图形化Python shell。虽然每种工具的shell各有一些有用的特性，如命 令再调用(recall)、自动完成、调用提示，但是没有一个工具完整包含了所有的 特性 。在这种情况下，PyCrust产生了，PyCrust的目的之一就是提供所有现存 的Python shell的特性。 创建PyCrust的另一个动机是：使用一个GUI工具包所写的代码不能工作在 另一个不同的GUI工具包上。例如，IDLE是用Tkinter写的，而不是wxPython。 由于这样，如果你试图在IDLE的Python shell中引入和使用wxPython模块，那么 你将陷入wxPython的事件循环与Tkinter事件循环间的冲突，结果将导致程序的 冻结或崩溃。 78 / 565
- 79. 事实上，这两个工具包将在控制事件循环上产生冲突。因此，如果你使用 wxPython模块工作时想要内省运行特性，你的Python shell必须是用wxPython写 的。由于没有现存的Python shell支持完整的特性，PyCrust被创建来填补这种需 要。 4.2 PyCrust的有用特性是什么？ 现在，我们将关注PyCrust提供的shell的一些特性。PyCrust的shell看起来有 些熟悉，这是因为它也显示了如同命令行Python shell相同的信息行和提示符。 下图4.2显示了一个打开着的PyCrust的屏幕： 你应该注意一下这个PyCrust框架，它包含了一个wx.SplitterWindow控件， 框架被分成两个区域：上部的区域看起来像通常的Python shell；底部的区域包 含了一个Notebook控件，这个控件包含了不同的标签，默认标签显示的信息是 有关当前的名字空间的。上部区域是PyCrust shell，它有几个有用的特性，我们 将在下面几节讨论。 79 / 565
- 80. 4.2.1 自动完成 当你在一个对象名后键入一点号时将引发自动完成功能。PyCrust将按字母 顺序显示关于该对象的所有已知的属性的一个列表。当你在点号后输入字母 时，在列表中的高亮选项将改变去匹配你所输入的字母。如果高亮选项正是你 所要的，这时按下Tab键，PyCrust将为你补全该属性名的其余部分。 在下图4.3中，PyCrust显示一个字符串对象的属性的列表。这个自动完成 的列表包含了该对象的所有属性和方法。 图4.3 4.2.2 调用提示和参数默认 当你在一个可调用的对象名后键入左括号时，PyCrust显示一个调用提示窗 口（如图4.4），该窗口包含了所能提供的参数信息和文档字符串（如果可调用 对象中定义了文档字符串的话）。 80 / 565
- 81. 可调用对象可以是函数、方法、内建的或类。可调用对象的定义都可以有 参数，并且可以有用来说明功能的文档字符串，以及返回值的类型。如果你知 道如何使用该可调用对象，那么你可以忽略调用提示并继续键入。 图4.4 4.2.3 语法高亮 当你在shell中键入代码时，PyCrust根据它的重要性改变文本的颜色。例 如，Python的关键词用一种颜色显示，原义字符串用另一种颜色，注释用另一 种颜色。这就使得你可以通过颜色来确认你的输入是否有误。 4.2.4 Python 帮助 PyCrust完整地提供了关于Python的帮助功能。Python的帮助功能显示了几 乎所有Python方面的信息，如下图4.5所示 81 / 565
- 82. 图4.5 Python的帮助功能提供了另外一个提示符(help)。在使用了help之后，你可 以通过在help提示符之后键入quit来退出帮助模式，返回到通常的Python提示符 (>>>)。 4.2.5 命令重调用 在PyCrust shell中有多种方法可以用来减少重复输入。它们大都通过捕获你 先前的键入来实现，如果有必要，你可以修改所捕获的内容，之后它们将之发 送给Python解释器。 例如，PyCrust维护着当前会话中你所键入的所有命令的一个历史记录。你 可以从命令历史记录中重调用你先前键入的任何Python命令（一行或多行）。 下表4.1显示了一个关于该功能的快捷键列表。 82 / 565
- 83. Ctrl+上箭头：获取前一个历史项 Alt+P：获取前一个历史项 Ctrl+下箭头：获取下一个历史项 Alt+N：获取下一个历史项 Shift+上箭头：插入前一个历史项 Shift+下箭头：插入下一个历史项 F8：历史项命令补全（键入先前命令的少量字符并按F8） Ctrl+Enter：在多行命令中插入新行 正如你所看到的，这儿有不同的命令用于获取和插入旧命令，它们通过 PyCrust如何处理当前wxPythob提示符中所键入的文本被区分。要替换你的键入 或插入一个旧的命令，可以使用快捷键来获取或插入一个历史项。 插入一行到一个多行命令中的工作与插入到一单行命令不同。要插入一行 到一个多行命令，你不能只按Enter键，因为这样将把当前的命令发送给Python 解释器。替代的方法是，按下Ctrl+Enter来插入一个中断到当前行。如果你处于 行尾，那么一个空行被插入当前行之后。这个过程类似于你在一个通常的文本 编辑中剪切和粘帖文本的方法。 最后一种重调用命令的方法是简单地将光标移到想要使用的命令，然后按 Enter键。PyCrust复制该命令到当前的Python提示符。然后你可以修改该命令或 按Enter键以将该命令提交给解释器。 快捷键让你可以快速地开发代码，并做每步的测试。例如，你可以定义一 个新的Python类，创建该类的一个实例，并看它的行为如何。然后，你可以返 回到这个类的定义，增加更多的方法或编辑已有的方法，并创建一个新的实 例。通过这样的反复，你可以将你的类的定义做得足够好，然后将它粘帖到你 的源代码中。 4.2.6 剪切和粘贴 你可能想重用在shell中已开发的代码，而避免重新键入。有时，你可能找 到一些样例代码（可能来自在线的教程），你想把它用到一个Python shell中。 PyCrust提供了一些简单的剪切和粘贴选项，列表于下表4.2 Ctrl+C：复制所选的文本，去掉提示符 Ctrl+Shift+C：复制所选的文本，保留提示符 Ctrl+X：剪切所选的文本 Ctrl+V：粘贴自剪贴板 Ctrl+Shift+V：粘贴自剪贴板的多个命令并运行 83 / 565
- 84. 粘贴的另一个特性是：PyCrust从所粘贴到PyCrust shell中的代码中识别并 自动去掉标准的Python提示符。这使得复制教程或email信息中的例子代码，把 它粘贴到PyCrust中，并测试它变得简单了，省去了手工的清理。 某些时候，当你复制代码时，你可能想去除PyCrust提示符，如当你复制代 码到你的源文件中时。另一些时候，你可能想保留这个提示符，如录你复制例 子到一个文档中，或把它发送到一个新闻组。当从shell复制时，PyCrust对这两 种情况都提供了支持。 4.2.7 标准shell环境 在wxPython环境中，PyCrust的行为尽可能地与命令行的Python shell相同。 不同的是，一旦Python代码被输入到了PyCrust shell中，就没有办法来中断该代 码的运行。例如，假定你在PyCrust中写了一个无限循环，如下所示： >>> while True: ... print ”Hello” ... 在你按下Enter之后，上面的代码被传送到Python解释器，PyCrust停止响 应。要中断这个无限的循环，必须关闭PyCrust程序。这个缺点是与命令行的 Python shell对比而言的。命令行的Python 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 ”<stdin>”, line 2, in ? 84 / 565
- 85. KeyboardInterrupt >>> 在GUI环境中的事件处理的本质，使得设计出能够让PyCrust中断一个无限 循环或在shell提示符中键入的长时间运行的代码序列的方法有很大的不同。将 来的PyCrust版本可能会提供对这个缺点的一个解决办法。幸运的是，在 PyCrust和标准命令shell之间只有这一个不同点。在其它方面，PyCrust shell和 命令行的Python shell工作的完全一样。 4.2.8 动态更新 当你在运行PyCrust时，PyCrust的shell的所有特性都是动态地被更新的，这 意味着，诸如“自动完成”和“调用提示”等特性是有效的，即使是在shell提示符 中定义的对象。例如图4.6和4.7所显示的会话，那么我们定义并使用了一个 类。 85 / 565
- 86. 在图4.6中，PyCrust为新类显示了自动完成选项。 图4.6 86 / 565
- 87. 在图4.7中，PyCrust显示了关于类所定义的新的方法的调用提示。 图4.7 4.3 PyCrust notebook的标签是干什么的？ PyCrust界面的下半部是一个notebook控件，notebook控件包括了几个带有 有用信息的标签。PyCrust开始时，你所看到的标签是“Namespace”标签。 4.3.1 Namespace标签 如图4.8所示，Namespace标签又被用wx.SplitterWindow控件分成两部分。 左边包含一个树控件，它显示当前的名字空间，而右边显示在名字空间树中当 前被选择的对象的细节。 87 / 565
- 89. 右边显示的第一行是左边所选择的对象的全名，你可以把它复制并粘贴到 PyCrust shell或你的应用程序源码中。例如，我们在PyCrust中引入locale模块并 选择名字空间树中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标签 Display标签中用于显示一个对象。PyCrust有一个内建函数pp()，这个函数 使用Python的pprint模块为显示一个对象。使用中不需要显式地引入和重复使用 pprint，在Display中，这些信息随对象的更新而每次更新。 例如，如果我们在PyCrust shell中有一个列表，我们要在 Display标签中显 示它的内容，我们可以在PyCrust shell中使用pp()，然后列表的内容就显示 在 Display标签中了。以后每当我们改变了列表的内容， Display标签中的内容 随即改变。 4.3.3 Calltip（调用提示）标签 Calltip标签显示了在Python shell中最近调用提示的内容。如果你的调用要 求大量的参数，那么你可以选择Calltip标签。当使用wxPython包时，存在着大 量的类，这些类有许多方法，这些方法又要求许多参数。例如，为了创建一人 wx.Button，你可能要提供八个参数，有一个是必须提供的，其它七个有默认的 值。Calltip标签显示了关于wx.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
- 90. 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. 由于wxPython的类实际上是封装的C++的类，所以调用提示信息完全基于 类的文档字符串。它们显示了底层C++类所需要的参数和类型信息。对于完全 用Python语言定义的对象，PyCrust检查它们以确定它的参数特性。 4.3.4 Session标签 Session标签是一个简单的文本控件，它列出了在当前shell会话中所键入的 所有命令。这使得剪切和粘贴命令以用在别处更为简单。 4.3.5 Dispatcher 标签 PyCrust包括了一个名为dispatcher的模块，它提供了在一个应用程序中联系 对象的机制。PyCrust使用dispatcher来维持它的界面的更新，主要是在命令从 shell传送到Python解释器时。图4.9中的Dispatcher标签列出了关于信号经过分配 机制后的路由。当使用PyCrust工作时，这是它的主要用处。 90 / 565
- 91. 图4.9 这里的Dispatcher标签也演示了如何增加另一个标签到一个wx.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
- 92. 现在我们已经看到了PyCrust作为独立的Python shell和名子空间检查器能够 做些什么，下面让我们关注在你的wxPython程序中，PyCrust的其它一些用法。 4.4 如何将PyCrust应用于wxPython应用程序。 让我们假设你已经用wxPython创建了一个程序，并且你的程序正在工作， 现在你想更好地了解它是如何工作的。在这章的前面你已经看到了PyCrust的特 性，它们看起来对于理解你的程序的功能是非常有用的。 通过将你的程序的名字传递给PyWrap，你能够用PyCrust shell来启动你的 程序，不需要对你的程序作任何的改变。下例4.2显示了一个名为spare.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() 为了运行这个程序时使用PyCrust，要将该程序的全路径传递给PyWrap。 在Linux上，命令行类似如下： $ pywrap spare.py 92 / 565
- 93. 在windows下，命令行类似如下： F:>python pywrap.py spare.py 在开始的时候，PyWrap试图导入命令行所包括的模块。然后PyWrap在模 块中寻找wx.App的子类，并创建子类的一个实例。之后，PyWrap创建一个带 有shell的wx.py.crust.CrustFrame窗口，把这个应用程序对象显示在PyCrust的名 字空间树中，并且启动 wxPython事件循环。 PyWrap的源码显示在例子4.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 <pobrien@orbtech.com>” __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
- 94. raise 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() 运行了PyWrap命令之后，来自spare的简单的框架(frame)和PyCrust的框架 都显示出来。 PyCrust in action 现在让我们看看，在PyCrust shell中我们对spare.py应用程序框架做些什 么。图4.10显示了这个结果。我们将通过导入wx和增加一个画板到我们的框架 作为开始： >>> import wx >>> app.frame.panel = wx.Panel(parent=app.frame) >>> app.frame.panel.SetBackgroundColour(‘White’) True >>> 94 / 565
- 95. 图4.10 增加到框架的画板开始时是默认的银灰色，然后它被改变到白色。然而， 设置画板背景色不立即改变它的显示。这需要去触发一个事件来导致画板重 绘，以使用它的新颜色属性。一个触发这样事件的方法是要求画板刷新自身： >>> app.frame.panel.Refresh() 现在一个白色的画板显示了，我们对于理解wxPython如何工作的细节又进 了一步。 接下来，让我们增加一个状态栏： >>> app.frame.statusbar = app.frame.CreateStatusBar(number=3) 95 / 565
- 96. >>> 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”) <wx.core.MenuItem; proxy of C++ wxMenuItem instance at _d8043d08_p_wxMenuItem> >>> menu.Append(wx.NewId(), ”Two”, ”Second menu item”) <wx.core.MenuItem; proxy of C++ wxMenuItem instance at _40a83e08_p_wxMenuItem> >>> 当你在PyCrust shell中处理你自己的wxPython对象时，注意改变对你正在 运行的程序的影响。试试回答后面的问题。在框架中菜单何时才实际显示出来 的？在程序运行的时候，你能改变菜单的哪些属性？你能够让它们无效吗？交 互地探究这些可以帮助你更好的理解wxPython，同时当你写真实的代码时给你 带来更大的自信。 到目前，我们已经花了很多节讨论PyCrust，我们下面准备看一看Py包的其 余的东西。 4.5 在Py包中还有其它什么？ 所有PyCrust中的程序都利用了Py包中的Python模块，诸如 shell.py,crust.py,introspect.py和interpreter.py。这些程序是用来做PyCrust的建造 块，你可以分别或一起使用它们。 PyCrust代表了组装包含在Py包中功能模块的一各方法。PyShell是另一方 法，PyAlaMode是第三种。在这些方法中，它们的底层代码大多数是相同的， 只是外包装有所变化而已。因此，你可以把Py当做一个模块库，你可以随意地 96 / 565
- 97. 在你的程序中的任何地方组装其中的模块，用来显示一个wxPython shell、一个 代码编辑器或运行时内省信息。 在Py包中，提供给用户界面功能的模块和没有这功能的模块有明显的区 别。这个区别使得在你的程序中很容易使用这些模块。以Py开头的模块是终端 用户GUI程序，如PyCrust,PyShell,PyAlaMode和PyAlaCarte。在你的程序中，你 不会想导入这些模块。下节说明终端用户模块。 4.5.1 使用GUI程序工作 下表4.3说明了用户级程序。 PyAlaCarte：简单的源代码编辑器。一次编辑一个文件。 PyAlaMode：多文件源代码编辑器。每个文件分别显示在一个notebook标签中。第 一个标签包含一个PyCrust分隔窗口。 PyCrust：合并了wxPython shell和notebook标签，notebook包含一个名字空间树查 看器。 PyFilling：简单的名字空间树查看器。这个程序自己不是很有用。它的存在只是作为 如何使用底层库的一个例子。 PyShell：简单的wxPython shell界面，没有PyCrust中的notebook。功能 上，PyShell中的wxPython shell和PyCrust中的是一样的。 PyWrap：命令行工具，用以运行一个存在的程序和PyCrust框架，让你能够在 PyCrust shell中处理这个应用程序。 4.5.2 使用支持模块工作 支持模块为终端用户提供了基本的功能，可以被导入你的程序中。这些模 块是用来创建用户级Py程序的建造块。下表4.4列出了这些支持模块，它们是Py 包的一部分，说明如下： buffer：支持文件编辑。 crust：包含PyCrust应用程序独有的GUI元素。 dispatcher：提供全局信号分派服务。 document：document模块包含一个非常简单的Document类，这个类是一个小的文 件类。document跟踪不同的文件属性，如名字和路径，并提供read()和write()方 法。Buffer类委托这些低级的读写操作给一个Document实例。 editor：包含所有显示在PyAlaCarte和PyAlaMode程序中的GUI编辑部分。 editwindow：这个editwindow模块包含了一个简单的EditWindow类。这个类继承自 wx.stc.StyledTextCtrl (STC)，并且提供了Py包中的STC的三种主要用法的所有共同 的特性，这三种主要用法是：作为一个Python shell,作为一个源代码编辑器和作为一 个只读源码显示器。 97 / 565
- 98. filling：包含所有的GUI控件，这些GUI控件让用户能够浏览对象名字空间并显示那些 对象运行时的信息。 frame：frame模块定义了一个Frame类，这个Frame类是Py包中所有其它frames的 基类。菜单项根据当前状态和上下文不断地自我更新。 images：images模块包含被不同Py程序使用的图标。 interpreter：Interpreter类负责提供自动完成列表，调用提示信息等。 introspect：为一些方面提供多种内省类型，像调用提示和命令自动完成。 pseudo：这个模块定义文件类类，文件类允许Interpreter类去重定向 stdin,stdout,stderr。 shell：这个模块包含GUI元素，这些GUI元素定义显示在PyCrust,PyShell和 PyAlaMode中的Python shell的界面。 version：这个模块包含一个名为VERSION的字符串变量，VERSION代表Py当前的 版本。 下面我们讨论更复杂的模块。 buffer模块 buffer模块包含一个Buffer类，这个类支持文件的通常编辑。buffer有一些 方法，例如new(), open(), hasChanged(), save(),和saveAs()。文件操作基于buffer 所委托的Document类的实例，Document类定义在document模块中。文件内容的 实际编辑是通过Editor类的一个或多个实例发生的，Editor类定义在editor模块 中。buffer扮演一个在一个或多个编辑器和实际物理文件之间的中间人。 Buffer类的一个独特的手法是每个buffer实例都分配了它自己的Python解释 器实例。这个特点使得buffer能够被用在那些当编辑Python源代码文件时需要提 供自动完成，调用提示和其它运行时帮助的应用程序中。每个buffer解释器都 是完全独立的，并且在buffer的updateNamespace()方法被调用时更新。下例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(‘rn’, ’n’) 98 / 565
- 99. 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] 这个方法使用Python内建的compile方法编译编辑器中的文本，然后使用关 键词exec来执行。如果编译成功，将放置若干变量到newspace名字空间中。通 过用执行的结果重置解释器的局部名字空间，解释器支持访问定义在编辑器的 buffer中的任何类，方法或变量。 99 / 565
- 100. crust 模块 crust模块包含6个GUI元素，它们专门用于PyCrust应用程序的。这最常用 的类是CrustFrame，它是wx.Frame的子类。如果你再看一下例4.3，你能看到 PyWrap程序是如何导入CrustFrame并创建其一个实例的。这是嵌入一个PyCrust 框架到你自己的程序中的最简单的方法。如果你想要比一个完整的框架更小的 东西，你可以使用下表4.5所列的一个或多个类。 表4.5 Crust：基于wx.SplitterWindow并包含一个shell和带有运行时信息的notebook。 Display：样式文本控件，使用Pretty Print显示一个对象。 Calltip：文本控件，包含最近shell调用帮助。 SessionListing：文本控件，包含关于一个会话的所有命令。 DispatcherListing：文本控件，包含关于一个会话的所有分派。 CrustFrame：一个框架，包含一个Crust分隔窗口。 这些GUI元素可以被用在任何wxPython程序中，以提供有用的可视化内 省。 dispatcher模块 dispatcher提供了全局信号分派服务。那意味它扮演着一个中间人，使得对 象能够发送和接受消息，而无须知道彼此。所有它们需要知道的是这个正在发 送的信号（通常是一个简单的字符串）。一个或多个对象可以要求这个 dispatcher，当信号已发出时去通知它们，并且一个或多个对象可以告诉这个 dispatcher去发送特殊的信号。 下例4.5是关于为什么dispatcher是如此有用的一个例子。因为所有的Py程 序都是建造在相同的底层模块之上的，所以PyCrust和PyShell使用几乎相同的代 码。这唯一的不同是，PyCrust包括了一个带有额外功能的notebook，如名字空 间树查看器，当命令被发送到解释器时，名字空间树查看器更新。在一个命令 通过解释器时，解释器使用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
- 101. 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 crust中的各有关部分和filling模块在它们的构造器中通过连接到dispatcher, 自己作为信号的接受器。下例4.6显示了关于出现在PyCrust的Session标签中的 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
- 102. 注意SessionListing的接受器（push()方法）是如何忽略由解释器发送来的 sender和source参数的。dispatcher非常灵活，并且只发送接受器能接受的参数。 editor模块 editor模块包含了出现在PyAlaCarte和PyAlaMode程序中的所有GUI编辑组 件。如果你愿意在你的程序中包括一个Python源代码编辑器，那么使用在下表 4.6中所说明的类。 这些类可以被使用在任何程序中以提供有用的代码风格编辑功能。 表4.6 定义在editor模块中的类 EditerFrame：被PyAlaCarte用来支持一次一个文件的编辑。EditerFrame是来自 frame模块的较一般的Frame类的子类。 EditorNotebookFrame：EditerFrame的子类，它通过增加一个notebook界面和同时 编辑多个文件的能力扩展了EditerFrame。它是一个被PyAlaMode使用的frame类。 EditorNotebook：这个控件被EditorNotebookFrame用来在各自的标签中显示各自的 文件。 Editor：管理一个buffer和与之相关的EditWindow之间的关联。 EditWindow：基于StyledTextCtrl的文本编辑控件。 filling模块 filling模块包含所有使用户能够浏览对象的名字空间和显示关于那些对象 的运行时信息的GUI控件。 定义在filling模块中的四个类的说明见下表4.7 表4.7 FillingTree：基于wx.TreeCtrl，FillingTree提供对象名字空间的分级树。 FillingText：editwindow.EditWindow的子类，用以显示当前在FillingTree所选择的对 象的细节。 Filling：一个wx.SplitterWindow，它的左边包括一个FillingTree，右边包括一个 FillingText。 FillingFrame：一个包含Filling分隔窗口的框架。双击filling树中的一项将打开一个新 的FillingFrame，其中被选择的项作为树的根。 使用这些类，使你能够容量地创建Python名字空间的分级树。如果你设置 你的数据为Python对象，这能够用作一个快速的数据浏览器。 102 / 565
- 103. interpreter模块 interpreter模块定义了一个Interpreter类，基于Python标准库中的code模块的 Interactive-Interpreter类。除了负责发送源代码给Python外，Interpreter类还负责 提供自动完成列表，调用提示信息和甚至触发自动完成特性的关键码（通常 是“.”）。 由于这清楚的责任划分，你可以创建你自己的Interpreter的子类并传递其一 个实例到PyCrust shell，从而代替默认的interpreter。这已经应用到了一些程序 中以支持自定义评议种类，而仍然利用PyCrust环境。 introspect模块 introspect模块被Interpreter和FillingTree类使用。它为调用提示和命令自动 完成提供了多种内省类型支持功能。下面显示了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类使用以生成它的名字空间分级。理 解内省模块的最好方法是关注单元测试。查看你的Python安装目录的Lib/site- packages/wx/py/tests中的test_introspect.py文件。 shell模块 shell模块包含出现在PyCrust, PyShell, 和PyAlaMode定义Python shell界面的 GUI元素。下表4.8提供了每个元素的说明。这最常用的类是ShellFrame,它是 frame.Frame的子类。它包含一个Shell类的实例，Shell类处理提供交互Python环 境的大部分工作。 表4.8 定义在shell模块中的类 Shell：Python shell基于wx.stc.StyleTextCtrl。Shell子类化editwindow.EditWindow， 然后使底层的文本控件的行为像一具Python shell，而非一个源码文件编辑器。 ShellFacade：简化的与所有shell相关的功能的接口。它是半透明的，它仍然是可访 问的，尽管只有一些是对shell用户可见的。 103 / 565
- 104. ShellFrame：一个包含一个Shell窗口的框架。 ShellFacade类在PyCrust的开发期间被创建，它作为在shell中访问shell对象 自身时去简化事情的一个方法。当你启动PyCrust或PyShell时，Shell类的实例在 Python shell中的有效的。例如，你可以在shell提示符下调用shell的about()方 法，如下所示： >>> shell.about() Author: ”Patrick K. O’Brien <pobrien@orbtech.com>” 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 >>> 由于Shell继承自StyledTextCtrl，所以它包含超过600个属性。大部分属性 对shell提示符是没用的，因此，ShellFacade被创建来限制当你进入shell时出现 在自动完成列表中的属性的数量。目前，shell对象只显示最有用的shell属性的 25个。 4.6 如何在wxPython中使用Py包中的模块? 如果你不想在你的应用程序使用一个完整的PyCrust框架，那么该怎么做 呢？如果你在一个框架中仅仅只想要shell界面，而在另一个框架中要一个名字 空间查看器，该怎么办呢？如果你想把它们永久添加到你的程序中以该怎么办 呢？这些方案不仅是可能的，而且也是十分简单的。我们将用一个例子来说明 这该怎么做来结束本章。 我们将再看一下在第2章中所创建的程序，它带有一个菜单栏，工具栏和 状态栏。我们将添加一个菜单，它的一个菜单项用以显示一个shell框架，另一 个用来显示一个filling框架。最后我们将把filling树的根设置给我们的主程序的 框架对象。结果显示在图4.11中。 104 / 565
- 105. 图4.11 下例4.7显示了修改过的源码。正如你的看到的，我们只增加了几行就实现 了所要求的功能。 105 / 565
- 107. 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 OnShell菜单项和OnFilling菜单项处理器 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 这里我们导入了ShellFrame和FillingFrame类 #2 我们添加了第三个菜单Debug到框架的菜单栏 #3 绑定一个函数给wx.EVT_MENU()，使我们能够将一个处理器与菜单项 关联，以便当这个菜单项被选择时调用所关联的处理器。 #4 当用户从Debug菜单中选择Python shell时，shell框架被创建，它的双亲 是工具栏框架。当工具栏框架被关闭时，任何打开的shell或filling框架也被关 闭。 107 / 565
- 108. 4.7 本章小结 1、像wxPython这样的工具包本身是大而复杂的。GUI控件之间的交互并不 总是直观的，整个的处理决定于事件并响应于事件，而非一个线性的执行序 列。使用如PyCrust shell能够很大程度上提高你对事件驱动环境的理解。 2、PyCrust仅仅是另一个Python shell，它类似于 IDLE, Boa Constructor, PythonWin和其它开发工具所包括的shell。然 而，PyCrust是用wxPython创建的，当你使用wxPython开发程序时，它是很有用 的。尤其是，你不会有任何事件循环冲突方面的问题，并且你可以在PyCrust的 shell和名字空间查看器中处理你的程序运行时的所有方面。 3、由于PyCrust是wxPython发行版的一部分，所以它随同wxPython一同被 安装，包括了所有的源码。这使得PyCrust容易使用，并且减少了摸清如何在你 自己的程序中提供内省功能的学习曲线。 4、另外，Py包的模块化的设计，使你很容易去挑选最有益于你程序的模 块，如源代码编辑、名字空间查看、或shell 5、PyCrust减少了wxPython学习的曲线，并帮助你掌握你的程序运行时的 细微之处。 下一章，我们将应用我们所学到的关于wxPython方面的知识，并且提供一 些关于如何组织你的GUI程序的实用的建议。 108 / 565
- 109. 5、创建你的蓝图 众所周知，GUI代码是难于阅读和维护的，并且看上去总是一塌糊涂。本 章我们将讨论三个驯服你的UI代码的技术。我们将讨论重构代码以使其易于阅 读、管理和维护。另一个方面是显示代码和基本的处理对象之间的处理，这也 是UI程序员头痛的地方。MVC（ModełView/Controller）设计模式是这样一种 结构，它保持显示和数据分离以便各自的改变相互不影响。最后，我们讨论对 你的wxPython代码进行单元测试的技术。尽管本章的所有例子将使用 wxPython，但是其中的多数原则是可以应用到任何UI工具的，代码的设计和体 系结构就是所谓的蓝图。一个深思熟虑的蓝图将使得你的应用程序建造起来更 简单和更易维护。本章的建议将帮助你为你的程序设计一个可靠的蓝图。 5.1 重构如何帮我改进我的代码？ 好的程序员为什么也会写出不好的界面或界面代码？这有很多原因。甚至 一个简单的用户界面可能都要求很多行来显示屏幕上的所有元素。程序员通常 试图用单一的方法来实现这些，这种方法迅速变得长且难于控制。此外界面代 码是很容易受到不断改变的影响的，除非你对管理这些改变训练有素。由于写 界面代码可能是很枯燥的，所以界面程序员经常会使用设计工具来生成代码。 机器生成的代码相对于手工代码来说是很差。 原则上讲，保持UI代码在控制之下是不难的。关键是重构或不断改进现有 代码的设计和结构。重构的目的是保持代码在以后易读和易于维护。下表5.1说 明了在重构时需要记住的一些原则。最重要的是要记住，某人以后可能会不得 不读和理解你的代码。努力让他人的生活更容易些，毕竟那有可能是你。 表5.1 重构的一些重要原则 不要重复：你应该避免有多个相同功能的段。当这个功能需要改变时，这维护起来会 很头痛。 一次做一件事情：一个方法应该并且只做一件事情。各自的事件应该在各自的方法 中。方法应该保持短小。 嵌套的层数要少：尽量使嵌套代码不多于2或3层。对于一个单独的方法，深的嵌套 也是一个好的选择。 避免字面意义上的字符串和数字：字面意义上的字符串和数字应使其出现在代码中的 次数最小化。一个好的方法是，把它们从你的代码的主要部分中分离出来，并存储于 一个列表或字典中。 这些原则在Python代码中特别重要。因为Python的缩进语法、小而简洁的 方法是很容易去读的。然而，长的方法对于理解来说是更困难的，尤其是如果 它们在一个屏幕上不能完全显示出来时。类似的，Python中的深的嵌套使得跟 109 / 565
- 110. 踪代码块的开始和结尾很棘手。然而，Python在避免重复方面是十分好的一种 语言，特别是因为函数和方法或以作为参数传递。 5.1.1 一个重构的例子 为了展示给你如何在实际工作中应用这些原则，我们将看一个重构的例 子。图5.1显示了一个窗口，它可用作访问微软Access类数据库的前端。 图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, ”<< PREV”, pos=(80, 0)) self.Bind(wx.EVT_BUTTON, self.OnPrev, prevButton) nextButton = wx.Button(panel, -1, ”NEXT >>”, pos=(160, 0)) 110 / 565
- 112. 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
- 113. 避免避免字面意义上的字符串和数字：在构造器中每个按钮、菜单项和文本框都有一 个文字字符串和坐标常量 5.1.2 开始重构 例5.2中只包含了前面用于创建按键栏的代码。作为重构的第一步，我们在 例5.2中把例5.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, ”<< PREV”, pos=(80, 0)) self.Bind(wx.EVT_BUTTON, , self.OnPrev, prevButton) nextButton = wx.Button(panel, -1, ”NEXT >>”, 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, ”<< PREV”, self.OnPrev, (80, 0)) self.buildOneButton(panel, ”NEXT >>”, 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.3代替例5.2有两个好处。第一，简短的方法和有意义的方法名使得代 码的可读性更清晰了。第二，它避免了局部变量（诚然，你也可以通过使用ID 来避免使用局部变量，但那容易导致重复的ID问题）。不使用局部变量是有好 113 / 565
- 114. 处的，它减少了代码的复杂程序，并且也因为这样几乎排除了通常由剪切和粘 贴部分代码而忘记了改变所有变量的名字带来的错误。（在实际的应用中，你 可能需要存储按钮为实例变量以备后来访问，但是本例不需要。）另 外，buildOneButton()方法容易放进一个工具模块中并可以在别的框架或项目中 重用。 5.1.3 进一步重构 上面的例子，已经得到了很多的改善。但是在多处仍有许多常量。其一， 就是用于定位的点坐标，当另一 个按钮被添加到按钮栏时可能使代码产生错误，尤其是新的按钮被放置在 按钮栏的中间。因此让我们再往 前进一步，我们把这些字面意义上的数据从处理中分离出来。下例5.4展示 了一个用于创建按钮的数据驱 动机制。 例5.4 使用分离自代码的数据创建按钮 def buttonData(self): return ((“First”, self.OnFirst), (“<< PREV”, self.OnPrev), (“NEXT >>”, 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.4中，用于不同按钮的数据被存储在内嵌于buttonData()方法的元组 中。所选的数据结构及常量方法的使用不是必然的。数据也可以被存储在一个 类级的变量或模块级的变量中，而非一个方法的结果，或存储于一个外部的文 114 / 565
- 115. 件中。使用方法的好处就是，如果你的按钮数据存储在另一个地方而不是方法 中的话，只需要改变这个方法而使它返回外部的数据。 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
- 118. 个超类或公用模块中，以保存代码便于以后继续利用。另外，数据的分离使得 把这个布局作为不同数据的模板很容易，包括国际化的数据。 重构虽说完成了，但是例5.5中的代码仍然忽略了一些重要的事情：实际用 户的数据。你的应用程序要做很多事依赖于处理数据响应用户要求。你的程序 的结构还可以向着灵活性和稳定性方向发展。MVC模式对于管理界面和数据之 间的交互是公认的标准。 5.2 如何保持模型(Model)与视图(View)分离？ 最早可追溯到1970年代后期和Smalltalk-80语言，MVC模式大概是最早明 确指出面向对象设计的模式。它 是最流行的一种，被几乎所有GUI工具包所采用。MVC模式是结构化程序 的标准，包括处理和显示信息。 5.2.1 MVC(Model-View-Controller)系统是什么？ MVC系统有三个子系统。Model包含经常被调用的业务逻辑或由你的系统 处理的所有数据和信息。View包含 显示数据的对象，Controller管理与用户的交互（Controller处于Model和 view中间）。下表5.3归纳了这 些组分。 表5.3 标准MVC体系的组成 组分 Model：包含业务逻辑,包含所有由系统处理的数据。它包括一个针对外部存储（如一 个数据库）的接口。通常模型(model)只暴露一个公共的API给其它的组分。 View：包含显示代码。这个窗口部件实际用于放置用户在视图中的信息。在 wxPython中，处于wx.Window层级中的所有的东西都是视图(view)子系统的一部 分。 Controller：包含交互逻辑。该代码接受用户事件并确保它们被系统处理。在 wxPython中，这个子系统由wx.EvtHandler层级所代表。 在现代的UI工具包中，View和Controller组分是被集成在一起的。这是因为 Controller组分自身需要被显示在屏幕上，并且因为经常性的你想让显示数据的 窗口部件也响应用户事件。在wxPython中，这种关系实际上已经被放置进去了 （所有的wx.Window对象也都是wx.EvtHandler的子类），这意味着它们同时具 118 / 565
- 119. 有View元素和Controller元素的功能。相比之下，大部分web应用架构对于View 和Controller有更严格的分离，因为其交互逻辑发生在服务器的后台。 图5.2中显示了数据和信息是如何在MVC体系中传递的。 一个事件通知被Controller系统处理（它把事件通知放到一个合适的地 方）。如我们在第三章中所看到的，wxPython使用wx.EvtHandler的方法 ProcessEvent()管理这个机制。在一个严格的MVC设计中，你的处理器函数可能 被声明在一个单独的控制器对象中，而非在框架类自身中。 对于事件的响应，这个模型(model)对象可以对应用程序数据做一些处理。 当处理完成时，模型对象发送一个更新通知。如果这儿有一个控制器 (controller)对象，那么该通知通常发送回这个控制器，同时这个控制器对象通 知视图(view)对象自我更新。在一个较小的系统或一个较简单的体系中，通知 通常直接被视图对象所接受。在wxPython中，来自于模型的更新的关键在于 你。你的选择包括从模型或控制器显式地引发自定义的wxPython事件，使模型 维护的对象的列表接受更新通知，或使与模型关联的视图接受更新通知 。 一个成功的MVC设计的关键不在于每个对象都彼此了解。相反，一个成功 的MVC程序，它的不同部分之间显式地隐藏了一些东西。其目的是使系统最低 限度地交互，和方法之间的明确的界定。尤其，这个Model组分应该被完全从 View和Controller中脱离出来。你应该只改变那些系统而不改变你的Model类。 理想上来讲，你甚至应该能够使用相同Model类来驱动非wxPython的界面，但 是那很难。 从View方面，你应该能够在Model对象的实现中做改变而不改变View或 Controller。而View依赖于某些公共的方法的存在，它不应该看见Model内私有 的东西。无可否认，这在Python中实施是有困难的，但有一个方法可以帮助我 119 / 565
- 120. 们，那就是创建一个抽象的Model类，它定义View可以看见的API。Model的子 类可以扮演一个内部的类的代理而被改变，或可以简单地自身包含内部的工 作。这第一个方案更结构化些，第二个更容易实现。 下一节，我们将看一看内建于wxPython中的Model类中的一个： wx.grid.PyGridTableBase。这个类使得在一个MVC设计架构中使用grid控件成为 可能。这之后，我们将关注一下对于一个定制的窗口部件建造和使用定制的模 型类。 5.2.2 一个wxPython模型：PyGridTableBase 类wx.grid.Grid是一个电子表格式样的wxPython控件。下图5.3显示了它的 外观。 这个网格(grid)控件有很多有趣的特点，包括能够在一个单元一个单元的基 础上创建自定义的渲染器和编辑器，以及可拖拽的行和列。这些特性将在第十 三章中做更详细的讨论。在这一章，我们将针对基础和展示如何使用一个模型 去填充网格。例5.6显示在一个网格中设置单元值的简单的非模型方法。在此例 中，网格中的值是1984年芝加哥小熊队的阵容。 例5.6 填充网格（没有使用模型） import wx import wx.grid 120 / 565
- 122. if __name__ == ’__main__’: app = wx.PySimpleApp() frame = TestFrame(None) frame.Show(True) app.MainLoop() 在例5.6中，我们产生了SimpleGrid类，它是wxPython类wx.grid.Grid的子 类。如前所述，wx.grid.Grid有很多种方法，这我们以后再讨论。现在，我们只 关心方法SetRowLabelValue()，SetColLabelValue()和SetCellValue()，它们实际上 设置显示在网格中的值。通过对比图5.3和例5.6你可以明白，SetCellValue()方法 要求一个行索引、一个列索引和一个值。而其它两个方法要求一个索引和一个 值。 上面的代码使用了set***的方法直接把值赋给了网格。然而如果对于一个 较大的网格使用这种方法，代码将冗长乏味，并很容易导致错误的出现。即使 我们创建公用程序以减轻负担，但是根据重构的原则，代码仍有问题。数据与 显示混在一起，对于将来代码的修改是困难的，如增加一列或更换数据。 解决的答案就是wx.grid.PyGridTableBase。根据之前我们所见过的其它的 类，前缀Py表明这是一个封装了C++类的特定的Python类。就像我们在第三章 中所见的PyEvent类，PyGridTableBase的实现是基于简单封装一个wxWidgets C ++类，这样的目的是使得能够继续声明该类(Python形式的类)的子 类。PyGridTableBase对于网格是一个模型类。也就是说，网格对象可能使用 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
- 123. SetValue(row, col,value)：设置单元(row,col)中的值。如果你想要只读模式，你仍必 须包含这个方法，但是你可以在该函数中使用pass。 表(table)通过使用网格(grid)的SetTable()方法被附加在grid上。在属性被设 置后，grid对象将调用表的方法来得到它绘制网格所需要的信息。grid不再显式 使用grid的方法来设置值。 使用PyGridTableBase 一般情况下，有两种使用PyGridTableBase的方法。你可以显式地使你的模 型类是PyGridTableBase的子类，或你可以创建一个单独的PyGridTableBase的子 类，它关联你的实际的模型类。当你的数据不是太复杂的时候，第一种方案较 简单并且直观。第二种方案需要对模型和视图做很好的分离，如果你的数据复 杂的话，这第二种方案是更好的。如果你有一个预先存在的数据类，你想把它 用于wxPython，那么这第二种方案也是更好的，因为这样你可以创建一个表而 不用去改变已有的代码。在下面一节我们将展示包含这两种方案的一个例子。 使用PyGridTableBase：特定于应用程序（不通用）的子类 我们的第一个例子将使用PyGridTableBase的一个特定于应用程序的子类作 为我们的模型。由于我们小熊队阵容的相对简单些，所以我们使用它。我们把 这些数据组织到一个派生自PyGridTableBase的类。我们把这些实际的数据配置 在一个二维Python列表中，并且配置另外的方法来从列表中读。下例5.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
- 127. size=(275, 275)) grid = SimpleGrid(self) if __name__ == ’__main__’: app = wx.PySimpleApp() frame = TestFrame(None) frame.Show(True) app.MainLoop() 使用PyGridTableBase：一个独立的模型类 至于避免重复性，有另一种使用PyGridTableBase的方法值得在这展示给大 家。这就是我们早先提到的第二种方案，数据在一个单独的模型类中，通过 PyGridTableBase来访问。Python的自我检查功能在这是非常有用的，使你能够 在每列显示一个属性的列表，然后使用内建函数getattr()去获取实际的值。在这 种情况下，模型要求一个元素的列表。在wxPython中，使用单独的模型对象结 构化你的程序有一个大的优势。在通常的情形下，对于一个grid，你只能调用 SetTable()一次，如果你想去改变表，你需要创建一个新的grid，那是烦人的。 然而，在接下来的例子中，你的PyGridTableBase仅存储了对于你的实际数据类 的实例的引用，这样一来，以后你就只需通过改变表中基本的数据对象，就可 以更新表中的数据为新的数据了。 下例5.10展示使用了关于阵容条目的单独的数据类的PyGridTableBase。我 们省去了框架的另一列表和数据创建，它们是与前一例子十分类似的。 例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
- 128. 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：这个列表包含了一些属性，它们被引用去按列地显示每列的值。 #2：这个模型要求一个条目的列表，每个条目都是LineupEntry的一个实 例。（这里我们没有做任何的错误检查）。 #3：要得到行头的标签，我们查看条目的pos属性。 #4：第一步是根据行来得到正确的条目。所要求的属性来自于#1中的列 表，然后getattr()被用来引用实际的值。这个机制是可扩展的，即使是在你不知 道该名字是否引用一个属性或方法的情况下，你也可以通过检查 128 / 565
- 129. <object>.<attribute>来看是否其可调用。如果可调用，那么使用通常的Python函 数语法来调用它，并返回它的值。 grid类是wxPython已有的一个有价值的模型组件来帮助你结构化你的应用 程序的一个例子。下一节我们将讨论如何为别的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) 我们这里的listener应该是可调用的对象，它需要self作为参数 （eachFunc(self)）——很明显，self的实际的类可以是不同的，因此你的 129 / 565
- 130. listenter很灵活了。同样，我们已经将AbstractModel配置成一个Python的新型的 类，事实上它是object的子类。因此本例要求Python的版本是Python2.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
- 133. 说明： #1：这行执行更新 #2：这两行创建这个模型对象，并且把OnUpdate()方法注册为一个 listener。现在当更新被调用时，OnUpdate()方法将被调用。 #3：OnUpdate()方法本身简单地使用模型更新后的值来设置文本域中的 值。该方法的代码中可以使用self.model这个实例来代替model（它们是同一个 对象）。使用方法作为参数，代码是更健壮的，在这种情况下，同样的代码可 以监听多个对象。 #4：按钮敲击的处理器改变模型对象的值，它触发更新。 在这样一个小的例子中，使用模型更新机制似乎有点大才小用了。为什么 按钮处理器不能直接设置文本域的值呢。然而，当这个模型类存在一个更复杂 的内部状况和处理时，这个模型机制就变得更有价值了。例如，你将能够将内 部的分配从一个Python字典改变为一个外部的数据库，而不在视图中做任何改 变。 假如你正在处理一个已有的类，而不能或不愿对其做改变，那么 AbstractModel可以用作该类的代理，方法与例5.10中的阵容所用的方法大致相 同。 另外，wxPython包含两个单独的类似MVC更新机制的实现，它们比我们这 里说明的这个有更多的特性。第一个是模块wx.lib.pubsub，它在结构上与我们 先前给出的类AbstractModel十分相似。名为Publisher的模型类使得对象能够监 听仅特定类型的消息。另一个更新系统是wx.lib.evtmgr.eventManager，它建立 在pubsub之上，并且有一些额外的特性，包括一个更精心的面向对象的设计和 事件关联的连接或去除的易用性。 5.3 如何对一个GUI程序进行单元测试？ 好的重构和MVC设计模式的一个主要的好处是，它使得使用“单元测试”来 验证你程序的性能更容易了。单元测试是对你的程序的单个的特定功能的测 试。由于重构和MVC设计模式两者的使用，使得你的程序被分成了小的块，因 此你更容易针对你程序的个别的部分写特定的单元测试。当重构的时候，结合 使用单元测试是特别有用的，因为完整的单元测试使得在你移动你的代码后， 你能够检验你是否引入了任何错误。 133 / 565
- 134. 接下来的难题是在单元测试中如何测试UI代码。测试一个模型是相对简单 的，因为模型的大部分功能不依赖于用户的输入。测试界面本身的功能比较困 难，因为界面的行为依赖于用户的行为，而用户的行为又是难以封装在内的。 在这一节，我们将给你展示如何在wxPython中使用单元测试。尤其是在单元测 试期间手工产生事件去触发行为的用法。 5.3.1 unittest模块 当写用户测试的时候，使用已有的测试引擎来节省减少重复的写代码的运 行你的测试是有帮助的。自2.1版以来，Python已发布了unittest模块。unittest模 块使用一名为PyUnit的测试框架（参见http://pyunit.sourceforge.net/）。PyUnit模 块由Test,TestCase,TestSuite组成。下表5.5说明了这三个组成。 表5.5 Test：被PyUnit引擎调用的一个单独的方法。根据约定，一个测试方法的名字以test 开头。测试方法通常执行一些代码，然后执行一个或多个断定语句来测试结果是否是 预期的。 TestCase：一个类，它定义了一个或多个单独的测试，这些测试共享一个公共的配 置。这个类定义在PyUnit中以管理一组这样的测试。TestCase在测试前后对每个测 试都提供了公共配置支持，确保每个测试分别运行。TestCase也定义了一些专门的 断定方法，如assertEqual。 TestSuite：为了同时被执行而组合在一起的一个或多个test方法或TestCase对象。当 你告诉PyUnit去执行测试时，你传递给它一个TestSuite对象去执行。 单个的PyUnit测试可能有三种结果：success（成功）, failure（失败）, 或 error（错误）。success表明测试完成，所有的断定都为真（通过），并且没有 引发错误。也就是说得到了我们所希望的结果。 Failure和error表明代码存在问题。failure意味着你的断定之一返回false，表 明代码执行成功了，但是没有做你预期的事。error意味着测试执行到某处，触 发了一个Python异常，表明你的代码没有运行成功。在单个的测试中，failure 或error一出现，整个测试就终止了，即使在代码中还有多个断定要测试，然后 测试的执行将移到到下一个单个的测试。 134 / 565
- 136. #2： setUp()方法在每个测试被执行前被调用。这使得你能够保证每个对你 的应用程序的测试都处在相同的状态下。这里我们创建了一个用于测试的框架 (frame)的实例。 #3 ：tearDown()方法在每个测试执行完后被调用。这使得你能够做一些清 理工作，以确保从一个测试转到另一个测试时系统状态保持一致。通常这里包 括重置全局数据，关闭数据库连接等诸如此类的东东。这里我们对框架调用了 Destroy()，以强制性地使wxWidgets退出，并且为下一个测试保持系统处在一个 良好的状态。 #4 ：测试方法通常以test作为前缀，尽管这处于你的控制之下（看#6）。 测试方法不要参数。我们这里的测试方法中，通过调用OnBarney事件处理器方 法来开始测试行为。 #5 ：这行使用assertEqual()方法来测试模型对象的改变是否正 确。assertEqual()要两个参数，如果这两个参数不相等，则测试失败。所有的 PyUnit断定方法都有一个可选的参数msg，如果断定失败则显示msg(msg的默认 值几乎够表达意思了） #6： 这个方法通过简单有效的机制创建一组测试。makeSuite()方法要求一 个Python的类的对象和一个字符串前缀作为参数，并返回一组测试（包含该类 中所有前缀为参数“前缀”的方法）。还有其它的机制，它们使得可以更明确设 置测试组中的内容，但是makeSuite()方法通过足够了。我们这里写的suite()方 法是一个样板模板，它可被用在你的所有测试模块中。 #7 ：这行调用了PyUnit的基于文本的执行器。参数是一个方法的名字（该 方法返回一测试组）。然后suite被执行，并且结果被输出到控制台。如果你想 使用GUI测试执行器，那么这行调用应使用unittest.TextTestRunner的方法而非 unittest.main。 在控制台中PyUnit测试的结果如下： . ---------------------------------------------------------------------- Ran 1 test in 0.190s OK 这是一个成功的测试。第一行的“.”号表明测试成功。每个测试都得到一个 字符并显示在这行。“.”表明成功，“F”表明失败，“E”表明错误。然后是一个简 136 / 565
- 137. 单的列表，其中包含测试的数量、总的测试时间和OK，OK表明所有测试通 过。 对于一个失败或错误的测试，你将得到一堆跟踪提示（显示了Python得到 的错误处的情况）。比如，如果你将#5改为 self.assertEqual(“Fife”, self.frame.model.first)，我们将得到如下结果： F ============================================================ ========== FAIL: testModel (__main__.TestExample) ---------------------------------------------------------------------- Traceback (most recent call last): File ”C:wxPyBookbook1BlueprinttestExample.py”, line 18, in testModel self.assertEqual(“Fife”, self.frame.model.last) File ”c:python23libunittest.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
- 138. 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.py文件中发现这个整数常量）。wilma.GetId()的作用是设置产生该事件的按 钮ID。至此，该事件已具有了实际wxPython事件的所有相关特性。然后我们调 用ProcessEvent()来将该事件发送到系统中。如果代码按照计划工作的话，那么 模型的first和last中的名字将被改变为“Wilma” 和 “Flintstone”。 通过生成事件，你能够从头到尾地测试你的系统的响应性。理论上，你可 以生成一个鼠标按下和释放事件以确保响应按钮敲击的按钮敲击事件被创建。 但是实际上，这不会工作，因为低级的wx.Events没有被转化为本地系统事件并 发送到本地窗口部件。然而，当测试自定义的窗口部件时，可以用到类似于第 三章中两个按钮控件的处理。此类单元测试，对于你的应用程序的响应性可以 给你带来信心。 5.4 本章小结 1、众所周知，GUI代码看起来很乱且难于维护。这一点可以通过一点努力 来解决，当代码以后要变动时，我们所付出的努力是值得的。 2、重构是对现存代码的改进。重构的目的有：避免重复、去掉无法理解 的字面值、创建短的方法（只做一件事情）。为了这些目标不断努力将使你的 代码更容易去读和理解。另外，好的重构也几乎避免了某类错误的发生（如剪 切和粘贴导致的错误）。 3、把你的数据从代码中分离出来，使得数据和代码更易协同工作。管理 这种分离的标准机制是MVC机制。用wxPython的术语来说，V(View)是 138 / 565
- 139. wx.Window对象，它显示你的数据；C(Controller)是wx.EvtHandler对象，它分 派事件；M(Model)是你自己的代码，它包含被显示的信息。 4、或许MVC结构的最清晰的例子是wxPython的核心类中的 wx.grid.PyGridTableBase，它被用于表示数据以在一个wx.grid.Grid控件中显 示。表中的数据可以来自于该类本身，或该类可以引用另一个包含相关数据的 对象。 5、你可以使用一个简单的机制来创建你自己的MVC设置，以便在模型被 更新时通知视图(view)。在wxPython中也有现成的模块可以帮助你做这样的事 情。 6、单元测试是检查你的程序的正确性的一个好的方法。在Python 中，unittest模块是执行单元测试的标准方法中的一种。使一些包，对一个GUI 进行单元测试有点困难，但是wxPython的可程序化的创建事件使得这相对容易 些了。这使得你能够从头到尾地去测试你的应用程序的事件处理行为。 在下一章中，我们将给你展示如何去建造一个小型的应用程序以及如何去 做一些事情，这些对你将建造的wxPython应用程序将是通用的。 139 / 565
- 140. 6、使用基本的建造部件 即使是一个简单的wxPython程序也需要使用标准的元素，诸如菜单和对话 框。这儿有对于任一GUI应用程序的基本的建造部件。使用这些建造部件，还 有像启动画面、状态栏或关于框等这些窗口部件，它们给你提供了一个更友好 的用户环境，并且给了你的应用程序一个专业的感观。为了要结束本书的第一 部分，我们将指导你通过一个程序的创建来使用所有所学的部分。我们将建造 一个简单的绘画程序，然后添加这些建造部件元素并说明使用它们时的一些问 题。我们将巩固前面章节的基本原理和概念，并且最后我们将产生这个简单但 专业的应用程序。本章位于先前基本概念章节和后面对wxPython功能更详细讨 论的2、3部分之间。 我们在本章将建造的这个应用程序基本上基于wxPython/samples目录中的 涂鸦例子。这个应用程序是一个非常简单的绘画程序，当鼠标左键按下时它跟 踪鼠标指针，并画线。图6.1显示了一个简单的初始绘画窗口。 图6.1 我们之所以要选择这样一个绘画例子，是因为它是十分简单的程序，它演 示了在创建更复杂的应用程序时所引出的许多问题。在本章，我们将给你展示 如何在屏幕上画线、添加状态栏、工具样以及菜单栏。你将会看到如何使用通 用对话框，如文件选择器和颜色选择器。我们将使用sizer来布置窗口部件，并 140 / 565
- 141. 且我们也将增加一个关于框和一个启动画面。本章的最后，你将有一个很好看 的绘画程序。 6.1 在屏幕上绘画 你的绘画程序的首先的工作是勾画线条并显示出来。像其它的GUI工具一 样， wxPython提供了一套独立于设备的工具用于绘画。下面，我们将讨论如何 在屏幕上绘画。 6.1.1 如何在屏幕上绘画 要在屏幕上绘画，我们要用到一个名为device context（设备上下文）的 wxPython对象。设备上下文代表抽象的设备，它对于所有的设备有一套公用的 绘画方法，所以对于不同的设备，你的代码是相同的，而不用考虑你所在的具 体设备。设备上下文使用抽象的wxPython的类wx.DC和其子类来代表。由于 wx.DC是抽象的，所以对于你的应用程序，你需要使用它的子类。 使用设备上下文 表6.1显示了wx.DC的子类及其用法。设备上下文用来在wxPython窗口部件 上绘画，它应该是局部的，临时性的，不应该以实例变量、全局变量或其它形 式在方法调用之间保留。在某些平台上，设备上下文是有限的资源，长期持有 wx.DC可能导致你的程序不稳定。由于wxPython内部使用设备上下文的方式， 对于在窗口部件中绘画，就存在几个有着细微差别的wx.DC的子类。第十二章 将更详细地说明这些差别。 表6.1 wx.BufferedDC：用于缓存一套绘画命令，直到命令完整并准备在屏幕上绘画。这防 止了显示中不必要的闪烁。 wx.BufferedPaintDC：和wx.BufferedDC一样，但是只能用在一个wx.PaintEvent的处 理中。仅临时创建该类的实例。 wx.ClientDC：用于在一个窗口对象上绘画。当你想在窗口部件的主区域上（不包括 边框或别的装饰）绘画时使用它。主区域有时也称为客户区。wx.ClientDC类也应临 时创建。该类仅适用于wx.PaintEvent的处理之外。 wx.MemoryDC：用于绘制图形到内存中的一个位图中，此时不被显示。然后你可以 选择该位图，并使用wx.DC.Blit()方法来把这个位图绘画到一个窗口中。 141 / 565
- 145. 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() 说明： #1：wx.Pen实例决定绘画到设备上下文的线条的颜色、粗细和样式。样式 除了wx.SOLID还有wx.DOT, wx.LONGDASH, 和wx.SHORTDASH。 #2：窗口需要去响应几个不同的鼠标类型事件以便绘制图形。响应的事件 有鼠标左键按下和释放、鼠标移动、窗口大小变化和窗口重绘。这里也指定了 空闲时的处理。 #3：用两步创建了缓存的设备上下文：（1）创建空的位图，它作为画面 外(offscreen)的缓存（2）使用画面外的缓存创建一个缓存的设备上下文。这个 缓存的上下文用于防止我勾画线的重绘所引起的屏幕闪烁。在这节的较后面的 部分，我们将更详细地讨论这个缓存的设备上下文。 #4：这几行发出绘制命令到设备上下文；具体就是，设置背景色并清空设 备上下文(dc.Clear())。必须调用dc.Clear()，其作用是产生一个wx.EVT_PAINT 事件，这样，设置的背景就显示出来了，否则屏幕颜色不会改变。wx.Brush对 象决定了背景的颜色和样式。 #5：事件方法GetPositionTuple()返回一个包含鼠标敲击的精确位置的 Python元组。 #6：CaptureMouse()方法控制了鼠标并在窗口的内部捕获鼠标，即使是你 拖动鼠标到窗口边框的外面，它仍然只响应窗口内的鼠标动作。在程序的后面 必须调用ReleaseMouse()来取消其对鼠标的控制。否则该窗口将无法通过鼠标 关闭等，试将#7注释掉。 145 / 565
- 146. #7：ReleaseMouse()方法将系统返回到调用CaptureMouse()之前的状 态。wxPython应用程序使用一个椎栈来对捕获了鼠标的窗口的跟踪，调用 ReleaseMouse()相当于从椎栈中弹出。这意味着你需要调用相同数据的 CaptureMouse()和ReleaseMouse()。 #8：这行确定移动事件是否是线条绘制的一部分，由移动事件发生时鼠标 左键是否处于按下状态来确定。Dragging()和LeftIsDown()都是wx.MouseEvent 的方法，如果移动事件发生时所关联的条件成立，方法返回true。 #9：由于wx.BufferedDC是一个临时创建的设备上下文，所以在我们绘制 线条之前需要另外创建一个。这里，我们创建一个新的wx.ClientDC作为主要的 设备上下文，并再次使用我们的实例变量位图作为缓存。 #10：这几行实际是使用设备上下文去绘画新近的勾画线到屏幕上。首 先，我们创建了coords元组，它合并了self.pos和newPos元组。这里，新的位置 来自于事件GetPositionTuple()，老的位置是最后对OnMotion()调用所得到的。 我们把该元组保存到self.curLine列表中，然后调用DrawLine()。*coords返回元 组coords中的元素x1,y1,x2,y2。DrawLine()方法要求的参数形如x1,y1,x2,y2，并 从点(x1,y1)到(x2,y2)绘制一条线。勾画的速度依赖于底层系统的速度。 #11：如果窗口大小改变了，我们存储一个True值到self.reInitBuffer实例属 性中。我们实际上不做任何事直到下一个空闲事件。 #12：当一个空闲产生时，如果已发生了一个或多个尺寸改变事件，这个 应用程序抓住时机去响应一个尺寸改变事件。我们存储一个True值到 self.reInitBuffer实例属性中，并在一个空闲产生时响应的动机是避免对于接二 连三的尺寸改变事件都进行屏幕刷新。 #13：对于所有的显示要求，都将产生wx.EVT_PAINT事件（描绘事件）， 并调用我们这里的方法OnPaint进行屏幕刷新（重绘），你可以看到这是出乎意 料的简单：创建一个缓存的画图设备上下文。实际上wx.PaintDC被创建（因为 我们处在一个Paint请求里，所以我们需要wx.PaintDC而非一个wx.ClientDC实 例），然后在dc实例被删除后（函数返回时被销毁），位图被一块块地传送 (blit)给屏幕并最终显示。关于缓存的更详细的信息将在随后的段落中提供。 #14：当由于尺寸改变（和由于从文件载入）而导致应用程序需要根据实 际数据重绘线条时，被使用。这里，我们遍历存储在实例变量self.lines中行的 列表，为每行重新创建画笔，然后根据坐标绘制每一条线。 146 / 565
- 147. 这个例子使用了两个特殊的wx.DC的子类，以使用绘画缓存。一个绘画缓 存是一个不显现的区域，其中存储了所有的绘画命令（这些命令能够一次被执 行），并且一步到位地复制到屏幕上。缓存的好处是用户看不到单个绘画命令 的发生，因此屏幕不会闪烁。正因如此，缓存被普遍地用于动画或绘制是由一 些小的部分组成的场合。 在wxPython中，有两个用于缓存的类：wx.BufferDC（通常用于缓存一个 wx.ClientDC）、wx.BufferPaintDC（用于缓存一个wx.PaintDC）。它们工作方 式基本上一样。缓存设备上下文的创建要使用两个参数。第一个是适当类型的 目标设备上下文（例如，在例6.1中的#9，它是一个新的wx.ClientDC实例）。 第二个是一个wx.Bitmap对象。在例6.1中，我们使用函数wx.EmptyBitmap创建 一个位图。当绘画命令到缓存的设备上下文时，一个内在的wx.MemoryDC被用 于位图绘制。当缓存对象被销毁时，C++销毁器使用Blit()方法去自动复制位图 到目标。在wxPython中，销毁通常发生在对象退出作用域时。这意味缓存的设 备上下文仅在临时创建时有用，所以它们能够被销毁并能用于块传送(blit)。 例如例6.1的OnPaint（）方法中，self.buffer位图在建造勾画（sketch）期间 已经被写了。只需要创建缓存对象，从而建立关于窗口的已有的位图与临时 wx.PaintDC()之间的连接。方法结束后，缓存DC立即退出作用域，触发它的销 毁器，同时将位图复制到屏幕。 设备上下文的函数 当你使用设备上下文时，要记住根据你的绘制类型去使用恰当的上下文 （特别要记住wx.PaintDC和 wx.ClientDC的区别）。一旦你有了适当的设备上 下文，然后你就可以用它们来做一些事情了。表6.2列出了wx.DC的一些方法。 表6.2 wx.DC的常用方法 Blit(xdest, ydest, width,height, source, xsrc,ysrc)：从源设备上下文复制块到调用该 方法的设备上下文。参数xdest, ydest是复制到目标上下文的起始点。接下来的两个 参数指定了要复制的区域的宽度和高度。source是源设备上下文，xsrc,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
- 149. GetSizeTuple()：以一个wx.Size对象或一个Python元组的形式返回设备上下文的像 素尺寸。 上面的列表并没有囊括所有的方法。另外的一些方法将在第十二章中说 明。 6.2 添加窗口装饰 尽管绘制到屏幕是一个画图程序不可或缺的部分，但是它距美观的程序还 差的远。在这一节，我们将谈及常用的窗口装饰：状态栏、菜单和工具栏。我 们将在第10章对这些做更详细的讨论。 6.2.1 如何添加和更新一个状态栏 在wxPython中，你可以通过调用框架的CreateStatusBar()方法添加并放置一 个状态栏到一个框架的底部。当父框架调整大小的时候，状态栏自动的自我调 整大小。默认情况下，状态栏是类wx.StatusBar的一个实例。要创建一个自定义 的状态栏，要使用SetStatusBar()方法并要求你的新类的实例作为参数来将状态 栏附着到你的框架上。 要在你的状态栏上显示单一的一段文本，你可以使用wx.StatusBar的 SetStatusText()方法。例6.2扩展了在例6.1中所演示的SketchFrame类来在状态栏 中显示当前鼠标的位置。 例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
- 150. 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:3。图6.2显示了这个结果。 图6.2 例子6.3增加了两个状态域，其中一个显示所绘的当前线条的点数，另一个 显示当前所画的线条的数量。该例所产生的状态条如图6.2所示。 例6.3 支持多个状态域 import wx from example1 import SketchWindow 150 / 565
- 152. SetStatusText(text, field=0)：得到或设置指定域中的文本。0是默认值，代表最左端 的域。 PopStatusText(field=0)：弹出堆栈中的文本到指定域中，以改变域中的文本为弹出 值。 PushStatusText(text, field=0)：改变指定的域中的文本为给定的文本，并将改变前的 文本压入堆栈的顶部。 SetStatusWidths(widths)：指定各状态域的宽度。widths是一个整数的Python列表。 在第10章中，我们将对状态栏作更详细的说明。下面我们将讨论菜单。 6.2.2 如何添加菜单？ 本节，我们将说明如何添加子菜单和复选或单选菜单。子菜单是顶级菜单 中的菜单。复制菜单或单选菜单是一组菜单项，它们的行为类似于一组复选框 或单选按钮。图6.3显示了一个菜单栏，其中的一个子菜单包含了单选菜单项。 图6.3 要创建一个子菜单，首先和创建别的菜单方法一样创建一个菜单，然后再 使用wx.Menu.AppendMenu()将它添加给父菜单。 带有复选或单选菜单的菜单可以通过使用wx.Menu的AppendCheckItem()和 AppendRadioItem()方法来创建，或通过在wx.MenuItem的创建器中使参数kind 的属性值为下列之一来创建： wx.ITEM_NORMAL, wx.ITEM_CHECKBOX, 或 wx.ITEM_RADIO。要使用编 152 / 565
- 153. 程的方法来选择一个菜单项，可以使wx.Menu的Check(id,bool)方法，id是所要 改变项的wxPython ID，bool指定了该项的选择状态。 例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
- 155. 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，项目的长度 是3或4。对于更复杂的产品数据，我建议使用XML或别的外部格式。 #3：如果数据块的长度是2，这意味它是一个菜单，将之分开，并递归调 用createMenu，然后将之添加。 #4：创建菜单项。对wx.MenuItem的构造器使用kind参数的方法比使用 wx.Menu的特定方法更容易。 #5：OnColor方法根据所选菜单项来改变画笔的颜色。代码根据事件得到 项目的id，再使用FindItemById()来得到正确的菜单项（注意我们这里使用菜单 155 / 565
- 156. 栏作为数据结构来访问，而没有使用项目id的哈希表），这个方法是以标签是 wxPython颜色名为前提的。 6.3 得到标准信息 你的应用程序经常需要从用户那里得到基本的信息，这通常通过对话框。 在这一节，我们将讨论针对标准用户信息的标准文件和颜色对话框。 6.3.1 如何使用标准文件对话框？ 大部分的GUI应用程序都要保存和载入这样那样的数据。考虑到你和你的 用户，应该有一个简单的，方便的机制来选择文件。很高兴，为此wxPython提 供了标准的文件对话框wx.FileDialog。图6.5显示了这个用于sketch程序的文件 对话框。 wx.FileDialog最重要的方法是它的构造器，语法如下： wx.FileDialog(parent, message=”Choose a file”, defaultDir=””, defaultFile=””, wildcard=”*.*”, style=0) 表6.6对构造器的参数进行了说明。 156 / 565
- 157. 表6.6 wx.FileDialog构造器的参数 parent：对话框的父窗口。如果没有父窗口则为None。 message：message显示在对话框的标题栏中。 defaultDir：当对话框打开时，默认的目录。如果为空，则为当前工作目录。 defaultFile：当对话框打开时，默认选择的文件。如果为空，则没有文件被选择。 wildcard：通配符。指定要选择的文件类型。格式是<display>|<wildcard>。可以指定 多种类型的文件，例如：“Sketch files (*.sketch)|*.sketch|All files (*.*)|*.*”。 style：样式。见下表6.7。 表6.7 wx.FileDialog的样式 wx.CHANGE_DIR：在用户选择了一个文件之后，当前工作目录相应改变到所选文 件所在的目录。 wx.MULTIPLE：仅适用于打开对话框。这个样式使得用户可以选择多个文件。 wx.OPEN：这个样式用于打开一个文件。 wx.OVERWRITE_PROMPT：仅适用于保存文件对话框。显示一个提示信息以确认 是否覆盖一个已存在的文件。 wx.SAVE：这个样式用于保存一个文件。 要使用文件对话框，要对一个对话框实例调用ShowModal()方法。这个方 法根据用户所敲击的对话框上的按钮来返回wx.ID_OK或wx.ID_CANCEL。选 择之后。使用GetFilename(), GetDirectory(), 或GetPath()方法来获取数据。之 后，调用Destroy()销毁对话框是一个好的观念。 下例6.6显了对SketchFrame所作的修改以提供保存和装载（完整的附书源 码请到论坛的“相关资源“的“教程下载“中下载）。这些改变要求导入cPickle和 os模块。我们使用cPickle来将数据的列表转换为可用于文件读写的数据格式。 例6.6 SketchFrame的保存和装载方法 def __init__(self, parent): self.title = ”Sketch Frame” 157 / 565
- 159. 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() #1：该方法写文件数据到磁盘中，给定了文件名，使用了cPickle模块。 #2：该方法使用cPickle来读文件。如果文件不是期望的类型，则弹出一个 消息框来警告。 #3：OnOpen()方法使用wx.OPEN样式来创建一个对话框。通配符让用户可 以限定选择.sketch文件。如果用户敲击OK，那么该方法根据所选择的路径调用 ReadFile()方法。 #4：如果已经选择了用于保存当前数据的文件名，那么保存文件，否则， 我们打开保存对话框。 #5：OnSave()方法创建一个wx.SAVE文件对话框。 #6：这行确保文件名后缀为.sketch。 下一节，我们将讨论如何使用文件选择器。 159 / 565
- 160. 6.3.2 如何使用标准的颜色选择器？ 如果用户能够在sketch对话框中选择任意的颜色，那么这将是有用。对于 这个目的，我们可以使用wxPython提供的标准wx.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
- 161. dlg.Destroy() 颜色数据实例的SetChooseFull()方法告诉对话框去显示整个调色板，其中 包括了自定义的颜色信息。对话框关闭后，我们根据得到的颜色来拾取颜色数 据。颜色数据作为一个wx.Color的实例返回并传递给sketch程序来设置颜色。 6.4 给应用程序一个好看的外观 在这一节中，我们将讨论如何让你的程序有一个好的外观。从重要性来 说，储如你如何作安排以便用户调整窗口的大小，从细节来说，储如你如何显 示一个about框。在本书的第二部分，我们将更详细地对这些主题进行进一步的 讨论。 6.4.1 如何布局窗口部件？ 在你的wxPython应用程序中布局你的窗口部件的方法之一是，在每个窗口 部件被创建时显式地指定它的位置和大小。虽然这个方法相当地简单，但是它 一直存在几个缺点。其中之一就是，因为窗口部件的尺寸和默认字体的尺寸不 同，对于在所有系统上要得到一个正确的定位是非常困难的。另外，每当用户 调整父窗口的大小时，你必须显式地改变每个窗口部件的定位，要正确地实现 它是十分痛苦的。 幸运的是，这儿有一个更好的方法。在wxPython中的布局机制是一个被称 为sizer的东西，它类似于Java AWT和其它的界面工具包中的布局管理器。每个 不同的sizer基于一套规则管理它的窗口的尺寸和位置。sizer属于一个容器窗口 （比如wx.Panel）。在父中创建的子窗口必须被添加给sizer，sizer管理每个窗 口部件的尺寸和位置。 创建一个sizer 创建一个sizer的步骤： 1、创建你想用来自动调用尺寸的panel或container(容器)。 2、创建sizer。 3、创建你的子窗口。 4、使用sizer的Add()方法来将每个子窗口添加给sizer。当你添加窗口时， 给了sizer附加的信息，这包括窗口周围空间的度量、在由sizer所管理分配的空 间中如何对齐窗口、当容器窗口改变大小时如何扩展子窗口等。 5、sizer可以嵌套，这意味你可以像窗口对象一样添加别的sizer到父sizer。 你也可以预留一定数量的空间作为分隔。 161 / 565
- 162. 6、调用容器的SetSizer(sizer)方法。 表6.8列出了在wxPython中有效的最常用的sizer。对于每个专门的sizer的更 完整的说明见第11章。 表6.8 最常用的wxPython的sizer wx.BoxSizer：在一条线上布局子窗口部件。wx.BoxSizer的布局方向可以是水平或坚 直的，并且可以在水平或坚直方向上包含子sizer以创建复杂的布局。在项目被添加 时传递给sizer的参数控制子窗口部件如何根据box的主体或垂直轴线作相应的尺寸调 整。 wx.FlexGridSizer：一个固定的二维网格，它与wx.GridSizer的区别是，行和列根据 所在行或列的最大元素分别被设置。 wx.GridSizer：一个固定的二维网格，其中的每个元素都有相同的尺寸。当创建一个 grid sizer时，你要么固定行的数量，要么固定列的数量。项目被从左到右的添加， 直到一行被填满，然后从下一行开始。 wx.GridBagSizer：一个固定的二维网格，基于wx.FlexGridSizer。允许项目被放置在 网格上的特定点，也允许项目跨越多和网格区域。 wx.StaticBoxSizer：等同于wx.BoxSizer，只是在box周围多了一个附加的边框（有 一个可选的标签）。 使用sizer 为了演示sizer的用法，我们将给sketch应用程序增加一个 control panel。control panel包含用来设置线条颜色和粗细的按钮。这个例子使 用了wx.GridSizer（用于按钮）和wx.BoxSizer（用于其余的布局部分）。图6.6 显示了使用了panel的sketch应用程序，并图解了grid和box的实际布局。 162 / 565
- 164. box = wx.BoxSizer(wx.HORIZONTAL) box.Add(controlPanel, 0, wx.EXPAND) box.Add(self.sketch, 1, wx.EXPAND) self.SetSizer(box) 在例6.8中，createPanel()方法创建了ControlPanel（在下面的列表中说明） 的实例，并且与box sizer放在一起。wx.BoxSizer的构造器的唯一参数是方向， 取值可以是wx.HORIZONTAL或wx.VERTICAL。接下来，这个新的controlPanel 和先前创建的SketchWindow被使用Add()方法添加给了sizer。第一个参数是要 被添加给sizer的对象。第二个参数是被wx.BoxSizer用作因数去决定当sizer的大 小改变时，sizer应该如何调整它的孩子的尺寸。我们这里使用的是水平方向调 整的sizer，stretch因数决定每个孩子的水平尺寸如何改变（坚直方向的改变由 box sizer基于第三个参数来决定）。 如果第二个参数（stretch因数）是0，对象将不改变尺寸，无论sizer如何变 化。如果第二个参数大于0，则sizer中的孩子根据因数分割sizer的总尺寸（类似 于wx.StatusBar管理文本域的宽度的做法）。如果sizer中的所有孩子有相同的因 数，那么它们按相同的比例分享放置了固定尺寸的元素后剩下的空间。这里的 0表示假如用户伸展框架时，controlPanel不改变水平的尺寸，而1表示绘画窗口 （sketch window）的尺寸要随框架的改变而改变。 Add()的第三个参数是另一个位掩码标志。完整的说明将在以后的章节中 给出。wx.EXPAND指示sizer调整孩子的大小以完全填满有效的空间。其它的可 能的选项允许孩子被按比例的调整尺寸或根据sizer的特定部分对齐。图6.7将帮 助阐明参数及其控制的调整尺寸的方向。 这些设置的结果是当你运行这个带有box sizer的框架的时候，任何在水平 方向的改变都将导致sketch window的尺寸在该方向上的改变，control panel不会 在该方向上改变。在坚直方向的尺寸改变导致这两个子窗口都要在坚直方向缩 放。 例6.8中涉及的类ControlPanel结合使用了grid和box sizer。例6.9包含了这个 类的代码。 164 / 565
- 167. 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) #1：createColorGrid()方法建造包含颜色按钮的grid sizer。首先，我们创建 sizer本身，指定列为4列。由于列数已被设定，所以按钮将被从左到右的布局， 然后向下。接下来我们要求颜色的列表，并为每种颜色创建一个按钮。在for循 环中，我们为每种颜色创建了一个方形的位图，并使用wxPython库中所定义的 一般的按钮窗口部件类创建了带有位图的切换按钮。然后我们把按钮与事件相 绑定，并把它添加到grid。之后，我们把它添加到字典以便在以后的代码中， 易于关联颜色、ID和按钮。我们不必指定按钮在网格中的位置；sizer将为我们 做这件事。 #2：createThicknessGrid()方法基本上类似于createColorGrid()方法。实际 上，一个有进取心的程序员可以把它们做成一个通用函数。grid sizer被创建， 十六个按钮被一次性添加，sizer确保了它们在屏幕上很好地排列。 #3：我们使用一个坚直的box sizer来放置网格(grid)。每个grid的第二个参 数都是0，这表明grid sizer当control panel在垂直方向伸展时不改变尺寸。（由 于我们已经知道control panel不在水平方向改变尺寸，所以我们不必指定水平方 向的行为。）Add()的第四个参数是项目的边框宽度，这里使用self.SPACING变 量指定。第三个参数wx.ALL是一套标志中的一个，它控制那些边套用第四个 参数指定的边框宽度，wx.ALL表明对象的四个边都套用。最后，我们调用 box sizer的Fit()方法，使用的参数是control panel。这个方法告诉control panel调 整自身尺寸以匹配sizer认为所需要的最小化尺寸。通常这个方法在使用了sizer 的窗口的构造中被调用，以确保窗口的大小足以包含sizer。 基类wx.Sizer包含了几个通用于所有sizer的方法。表6.9列出了最常用的方 法。 表6.9 wx.Sizer的方法 Add(window, proportion=0,flag=0, border=0,userData=None) 167 / 565
- 168. Add(sizer, proportion=0,flag=0, border=0,userData=None) Add(size, proportion=0,flag=0, border=0,userData=None)：第一个添加一个 wxWindow，第二个添加一个嵌套的sizer，第三个添加空的空间，用作分隔符。参数 proportion管理窗口总尺寸，它是相对于别的窗口的改变而言的，它只对wx.BoxSizer 有意义。参数flag是一个位图，针对对齐、边框位置，增长有许多不同的标志，完整 的列表见第十一章。参数border是窗口或sizer周围以像素为单位的空间总 量。userData使你能够将对象与数据关联，例如，在一个子类中，可能需要更多的 用于尺寸的信息。 Fit(window) FitInside(window )：调整window尺寸以匹配sizer认为所需要的最小化尺寸。这个参 数的值通常是使用sizer的窗口。FitInside()是一个类似的方法，只不过将改变窗口在 屏幕上的显示替换为只改变它的内部实现。它用于scroll panel中的窗口以触发滚动 栏的显示。 GetSize()：以wx.Size对象的形式返回sizer的尺寸。 GetPosition()：以wx.Point对象的形式返回sizer的位置。 GetMinSize()：以wx.Size对象的形式返回完全填充sizer所需的最小尺寸。 Layout()：强迫sizer去重新计算它的孩子的尺寸和位置。在动态地添加或删除了一个 孩子之后调用。 Prepend(...)：与Add()相同（只是为了布局的目的，把新的对象放在sizer列表的开 头）。 Remove(window) Remove(sizer) Remove(nth)：从sizer中删除一个对象。 SetDimension(x, y, width,height)：强迫sizer按照给定的参数重新定位它的所有孩 子。 有关sizer和嵌套sizer的更详细的信息请参考第11章。 6.4.2 如何建造一个关于(about)框？ about框是显示对话框的一个好的例子，它能够显示比纯信息框更复杂的信 息。这里，你可以使用wx.html.HtmlWindow作为一个简单的机制来显示样式文 本。实际上，wx.html.HtmlWindow远比我们这里演示的强大，它包括了管理用 户交互以及绘制的方法。第16章涵盖了wx.html.HtmlWindow的特性。例6.10展 示了一个类，它使用HTML renderer创建一个about框。 168 / 565
- 170. 上面的HTML字符串中，有一些布局和字体标记。这里的对话框合并了 wx.html.HtmlWindow和一个wx.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
- 171. 使用类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.10说明了wx.SplashScreen构造函数的参数 表6.10 wx.SplashScreen构造函数的参数 bitmap：一个wx.Bitmap，它被显示在屏幕上。 splashStyle：另一个位图样式，可以是下列的结合： wx.SPLASH_CENTRE_ON_PARENT,wx.SPLASH_CENTRE_ON_SCREEN, wx.SPLASH_NO_CENTRE, wx.SPLASH_TIMEOUT, wx.SPLASH_NO_TIMEOUT milliseconds：如果splashStyle指定为wx.SPLASH_TIMEOUT，milliseconds是保持 显示的毫秒数。 parent：父窗口，通常为None。 id：窗口ID，通常使用-1比较好。 pos：如果splashStyle取值wx.SPLASH_NO_CENTER的话，pos指定画面在屏幕上 的位置。 size：尺寸。通常你不需要指定这个参数，因为通常使用位图的尺寸。 style：常规的wxPython框架的样式，一般使用默认值就可以了。 例6.11显示了启动画面的代码。这里我们用一具自定义的wx.App子类来替 代了wx.PySimpleApp。 例6.11 一个启动画面的代码 class SketchApp(wx.App): def OnInit(self): 171 / 565
- 172. bmp = 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框和启动画面来逐步 对它作了改进。 2、你可以使用一个设备上下文来直接对wxPython的显示进行绘制。不同 的显示要求不同的设备上下文，然而它们共享一个通用API。为了平滑的显 示，设备上下文可以被缓存。 3、一个状态栏能够被自动地创建在框架的底部。它可以包含一个或多个 文本域，各文本域可被独立调整尺寸和设置。 4、菜单可以包含嵌套的子菜单，菜单项可以有切换状态。工具栏产生与 菜单栏同种的事件，并且被设计来更易于对工具按钮分组布局。 5、可以使用标准wx.FileDialog来管理打开和保存数据。可以使用 wx.ColourDialog来选择颜色。 6、使用sizer可以进行窗口部件的复杂布局，而不用明确地指定具体位 置。sizer根据规则自动放置它的孩子对象。sizer包括的wx.GridSizer按二维网格 172 / 565
- 173. 来布局对象。wx.BoxSizer在一条线上布局项目。sizer可以嵌套，并且当sizer伸 展时可以，它可以控制其孩子的行为。 7、about框或别的简单的对话框可以使用wx.html.HtmlWindow来创建。启 动画面用wx.SplashScreen来创建。 在第一部分（part 1）中，我们已经涵盖了wxPython的基本概念，并且我们 已经涉及了一些最常见的任务。在接下来的第二部分（part 2）中，我们将使用 目前常见的问答的格式，但是我们将涉及有关wxPython工具包的组成和功能方 面的更详细的问题。 173 / 565
- 174. Part 2 基本的wxPython 在本书的这一部分，我们将浏览基本的窗口部件，它们组成了wxPython工 具包的核心。它们是你写wxPython程序要用到的关键的部分。对于其中的每个 元素，我们将给你展示关于该元素的最重要的那些API，还有例子代码和关于 如何在实际程序中使用该元素的技巧。 第7章，“使用基本的窗口部件”中，我们从基本窗口部件的设置开始。我 们将涉及文本标签，文本域，按钮、和数字及列表选择窗口部件。我们将给你 展示如何使用每个元素，如何自定义它们的外观以匹配你的应用程序，以及如 何去响应用户的交互。在第8章，“在框架中放入窗口部件”中，我们将上升到容 器级并谈论框架。我们将给你展示如何添加窗口部件到框架中，并说明有效的 框架样式。我们也将涉及框架从创建到销毁的生命周期。在第9章，“使用对话 框给用户选择”中，我们将聚焦于对话框，以对话框与框架的区别作为开始。 我们也将展示一系列在wxPython中有效的预定义的对话框，以及方便使用它们 的捷径。 在第十章“创建和使用wxPython菜单”中，重点是菜单。我们将讨论如何去 创建菜单项，菜单项可以被附着到菜单上，可以被放置到菜单栏上。我们也将 涉及切换菜单（toggle menus）、弹出菜单，以及各种自定义菜单显示的方法。 在第11章“使用sizer放置窗口部件”中，我们将揭秘sizer技术。sizer被用来在 wxPython框架和对话框中简化窗口部件的布局。我们将涉及6种预定义的 sizer，给你展示它们的行为，并给出关于何时使用它们才最恰当的一些提示。 最后，在第12章“处理基本的图像”中，我们将讨论经由设备上下文来在屏幕上 绘图的一些基础知识，我们列出了原始的绘图方法，你可以用它们来绘制你自 己的窗口部件或支持用户的绘画，或仅用于装饰。 174 / 565
- 175. 7、使用基本的控件工作 wxPython工具包提供了多种不同的窗口部件，包括了本章所提到的基本控 件。我们涉及静态文本、可编辑的文本、按钮、微调、滑块、复选框、单选按 钮、选择器、列表框、组合框和标尺。对于每种窗口部件，我们将提供一个关 于如何使用它的简短例子，并附上相关的wxPython API的说明。 7.1 显示文本 这一节以在屏幕上显示文本的例子作为开始，包括用作标签的静态文本 域，有样式和无样式的都使用了。你可以创建用于用户输入的单行和多行文本 域。另外，我们将讨论如何选择文本的字体。 7.1.1 如何显示静态文本？ 大概对于所有的UI工具来说，最基本的任务就是在屏幕上绘制纯文本。在 wxPython中，使用类wx.StaticText来完成。图7.1显示了这个静态文本控件。 在wx.StaticText中，你能够改变文本的对齐方式、字体和颜色。简单的静 态文本控件可以包含多行文本，但是你不能处理多种字体或样式。处理多种字 体或样式，要使用更精细的文本控件，如wx.html.HTMLWindow，它在第十六 章中说明。为了在静态文本控件中显示多行文本，我们要包括其中有换行符的 字符串，并使控件的大小足够显示所有的文本。有一个特点是你在图7.1中所不 能看到的，那就是wx.StaticText窗口不会接受或响应鼠标事件。 175 / 565
- 176. 如何显示静态文本 例子7.1显示了产生图7.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
- 177. text.SetFont(font) # 显示多行文本 wx.StaticText(panel, -1, ”Your textncan be splitn” ”over multiple linesnneven blank ones”, (20,150)) #显示对齐的多行文本 wx.StaticText(panel, -1, ”Multi-line textncan alson” ”be right alignednneven with a blank”, (220,150), style=wx.ALIGN_RIGHT) if __name__ == ’__main__’: app = wx.PySimpleApp() frame = StaticTextFrame() frame.Show() app.MainLoop() wx.StaticText的构造函数和基本的wxWidget构造函数相同，如下所示： 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：你想显示在静态控件中的文本。 pos：一个wx.Point或一个Python元组，它是窗口部件的位置。 size：一个wx.Size或一个Python元组，它是窗口部件的尺寸。 style：样式标记。 name：对象的名字，用于查找的需要。 177 / 565
- 178. 接下来我们更详细地讨论样式标记。 使用样式工作 所有在例7.1中静态文本实例所调用的方法都是属于基父类wx.Window的； wx.StaticText没有定义任何它自己的新方法。表7.2列出了一些专用于 wx.StaticText的样式。 表7.2 wx.ALIGN_CENTER：静态文本位于静态文本控件的中心。 wx.ALIGN_LEFT：文本在窗口部件中左对齐。这是默认的样式。 wx.ALIGN_RIGHT：文本在窗口部件中右对齐。 wx.ST_NO_AUTORESIZE：如果使用了这个样式，那么在使用了SetLabel()改变文 本之后，静态文本控件不将自我调整尺寸。你应结合使用一个居中或右对齐的控件来 保持对齐。 wx.StaticText控件覆盖了SetLabel()，以便根据新的文本来调整自身，除非 wx.ST_NO_AUTORESIZE样式被设置了。 当创建了一个居中或右对齐的单行静态文本时，你应该显式地在构造器中 设置控件的尺寸。指定尺寸以防止wxPython自动调整该控件的尺寸。wxPython 的默认尺寸是刚好包容了文本的矩形尺寸，因此对齐就没有什么必要。要在程 序中动态地改变窗口部件中的文本，而不改变该窗口部件的尺寸，就要设置 wx.ST_NO_AUTORESIZE样式。这样就防止了在文本被重置后，窗口部件自动 调整尺寸到刚好包容了文本。如果静态文本是位于一个动态的布局中，那么改 变它的尺寸可能导致屏幕上其它的窗口部件移动，这就对用户产生了干扰。 其它显示文本的技术 还有其它的方法来显示文本。其中之一就是wx.lib.stattext.GenStaticText 类，它是wx.StaticText的纯Python实现。它比标准C++版的跨平台性更好，并且 它接受鼠标事件。当你想子类化或创建你自己的静态文本控件时，它是更可取 的。 你可以使用DrawText(text, x,y)和DrawRotatedText(text, x, y, angle)方法直接 绘制文本到你的设备上下文。后者是显示有一定角度的文本的最容易的方法， 178 / 565
- 179. 尽管GenStaticText的子类也能处理旋转问题。设备上下文在第6章中做了简短的 说明，我们将在第12章中对它做更详细的说明。 7.1.2 如何让用户输入文本？ 超越纯粹显示静态文本，我们将开始讨论当输入文本时的用户交 互。wxPython的文本域窗口部件的类是wx.TextCtrl，它允许单行和多行文本输 入。它也可以作为密码输入控件，掩饰所按下的按键。如果平台支持的 话，wx.TextCtrl也提供丰富格式文本的显示，通过使用所定义和显示的多文本 样式。图7.2显示了一个作为单行控件的wx.TextCtrl的样板。其中的密码输入框 对密码进行了掩饰。 接下来，我们将演示如何创建文本，然后讨论文本控件的样式选项。 如何创建文本输入控件 例子7.2显示了用于生成图7.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
- 180. 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.TextCtrl类的构造函数较小且比其父类wx.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, 和 name与wx.Window构造函数的相同。value 是显示在该控件中的初始文本。 validator参数用于一个wx.Validator。validator通常用于过虑数据以确保只能 键入要接受的数据。将在第9章对validator做更详细的讨论。 使用单行文本控件样式 这里，我们将讨论一些唯一无二的文本控件样式。 表7.3说明了用于单行文本控件的样式标记 表7.3 单行wx.TextCtrl的样式 wx.TE_CENTER：控件中的文本居中。 wx.TE_LEFT：控件中的文本左对齐。默认行为。 wx.TE_NOHIDESEL：文本始终高亮显示，只适用于Windows。 wx.TE_PASSWORD：不显示所键入的文本，代替以星号显示。 180 / 565
- 181. wx.TE_PROCESS_ENTER：如果使用了这个样式，那么当用户在控件内按下回车 键时，一个文本输入事件被触发。否则，按键事件内在的由该文本控件或该对话框管 理。 wx.TE_PROCESS_TAB：如果指定了这个样式，那么通常的字符事件在Tab键按下 时创建（一般意味一个制表符将被插入文本）。否则，tab由对话框来管理，通常是 控件间的切换。 wx.TE_READONLY：文本控件为只读，用户不能修改其中的文本。 wx.TE_RIGHT：控件中的文本右对齐。 像其它样式标记一样，它们可以使用|符号来组合使用，尽管其中的三个对 齐标记是相互排斥的。 对于添加文本和移动插入点，该文本控件自动管理用户的按键和鼠标事 件。对于该文本控件可用的命令控制组合说明如下： <ctrl-x>：剪切 <ctrl-c>：复制 <ctrl-v>：粘贴 <ctrl-z>：撤消 7.1.3 不输入的情况下如何改变文本？ 除了根据用户的输入改变显示的文本外，wx.TextCtrl提供了在程序中改变 显示的文本的一些方法。你可以完全改变文本或仅移动插入点到文本中不同的 位置。表7.4列出了wx.TextCtrl的文本处理方法。 表7.4 AppendText(text)：在尾部添加文本。 Clear()：重置控件中的文本为“”。并且生成一个文本更新事件。 EmulateKeyPress(event)：产生一个按键事件，插入与事件相关联的控制符，就如 同实际的按键发生了。 GetInsertionPoint() SetInsertionPoint(pos) SetInsertionPointEnd()：得到或设置插入点的位置，位置是整型的索引值。控件的 开始位置是0。 181 / 565
- 182. 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
- 184. 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：如果丰富文本选项被设置并且平台支持的话，那么当用户的鼠 标位于文本中的一个URL上或在该URL上敲击时，这个样式将导致一个事件被生成。 wx.TE_DONTWRAP：wx.HSCROLL的别名。 wx.TE_LINEWRAP：对于太长的行，以字符为界换行。某些操作系统可能会忽略该 样式。 wx.TE_MULTILINE：文本控件将显示多行。 wx.TE_RICH：用于Windows下，丰富文本控件用作基本的窗口部件。这允许样式文 本的使用。 wx.TE_RICH2：用于Windows下，把最新版本的丰富文本控件用作基本的窗口部 件。 wx.TE_WORDWRAP：对于太长的行，以单词为界换行。许多操作系统会忽略该样 式。 记住，上面这些样式可以组合使用，所以上面例子中的多行丰富文本控件 使用wx.TE_MULTILINE | wx.TE_RICH2来声明。 用在wx.TextCtrl窗口部件中的文本样式是类wx.TextAttr的例。wx.TextAttr 实例的属性有文本颜色、背景色、和字体，它们都能够在构造函数中被指定， 如下所示： wx.TextAttr(colText, colBack=wx.NullColor, font=wx.NullFont) 184 / 565
- 185. 文本色和背景色是wxPython对象，它们可以使用颜色名或颜色的RGB值 (红, 绿, 蓝)来指定。wx.NullColor指明使用控件目前的背景色。font是一个 wx.Font对象，我们将在下一小节讨论。wx.NullFont对象指明使用当前默认字 体。 类wx.TextAttr有相关属性的get*()方法： GetBackgroundColour(), GetFont(), 和 GetTextColour()，也有返回布尔值的验证 存在性的方法：HasBackgroundColour(), HasFont(), 和 HasTextColour()。如果属 性包含一个默认值，则Has*()方法返回False。如果所有这三个属性都包含默认 值，则IsDefault()方法返回true。这个类没有set*()方法，因为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.6列出了wx.TextCtrl的方法，它们在处理多行控件和丰富文本中是有用 的。 表7.6 GetDefaultStyle() SetDefaultStyle(style)：上面已作了说明。 GetLineLength(lineNo)：返回给定行的长度的整数值。 GetLineText(lineNo)：返回给定行的文本。 GetNumberOfLines()：返回控件中的行的数量。对于单行，返回1。 IsMultiLine() 185 / 565
- 186. 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) pointSize是字体的以磅为单位的整数尺寸。family用于快速指定一个字体 而无需知道该字体的实际的名字。字体的准确选择依赖于系统和具体可用的字 体。可用的字体类别的示例显示在表7.7中。你所得到的精确的字体将依赖于你 的系统。 表7.7 wx.DECORATIVE：一个正式的，老的英文样式字体。 wx.DEFAULT：系统默认字体。 wx.MODERN：一个单间隔（固定字符间距）字体。 wx.ROMAN：serif字体，通常类似于Times New Roman。 wx.SCRIPT：手写体或草写体 wx.SWISS：sans-serif字体，通常类似于Helvetica或Arial。 style参数指明字体的是否倾斜，它的值有： wx.NORMAL, wx.SLANT, 和 wx.ITALIC。同样，weight参数指明字体的醒目程 186 / 565
- 187. 度，可选值有：wx.NORMAL, wx.LIGHT,或wx.BOLD。这些常量值的行为根据 它的名字就可以知道了。underline参数仅工作在Windows系统下，如果取值为 True，则加下划线，False为无下划线。 faceName参数指定字体名。 encoding参数允许你在几个编码中选择一个，它映射内部的字符和字本显 示字符。编码不是Unicode编码，只是用于wxPython的不同的8位编码。大多数 情况你可以使用默认编码。 为了获取系统的有效字体的一个列表，并使用户可用它们，要使用专门的 类wx.FontEnumerator，如下所示： e = wx.FontEnumerator() e.EnumerateFacenames() fontList = e.GetFacenames() 要限制该列表为固定宽度，就要将上面的第一行改为 e = wx.FontEnumerator(fixedWidth=True)。 7.1.6 如果我们系统不支持丰富文本，那么我还能使用样式文本吗？ 可以。在wxPython中有一个跨平台的样式文本窗口部件，名为 wx.stc.StyledTextCtrl，它是Python对Scintilla丰富文本组件的封装。因为Scintilla 不是wxWidgets的一部分，而是作为一个独立的第三方组被合并到了wxPython 中，所以它不与我们已经讨论过的类共享相同的API。wx.stc.StyledCtrl的完整 说明超过了我们要讲的范围，但是你可以在http://wiki.wxpython.org/index.cgi/ wxStyledTextCtrl找到相关的文档。 7.1.7 如果我的文本控件不匹配我的字符串该怎么办？ 当使用多行wx.TextCtrl的时候，要知道的一点是，该文本控件是以何种方 式存储字符串的。在内部，存储在该wx.TextCtrl中的多行字符是以n作为行的 分隔符的。这与基本的操作系统无关，即使某些系统使用了不同的字符组合作 为一行的分隔符。当你使用GetValue()来获取该字符串时，原来的行分隔符被还 原，因此你不必考虑手工转换。这个的好处就是控件中的文本不依赖于任何特 定的操作系统。 缺点是，文本控件中的行的长度和行的索引与它们在文本控件外的可能是 不同的。例如，如果你在一个Windows系统上，系统所用的行分隔符是rn，通 187 / 565
- 188. 过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] ### 这将是不正确的 在Windows或Mac系统中要得到正确的结果，最后一行应换为： selection = text.GetRange(x, x + 10) 7.1.8 如何响应文本事件？ 有一个由wx.TextCtrl窗口部件产生的便利的命令事件，你可能想用它。你 需要把相关事件传递给Bind方法以捕获该事件，如下所示： 188 / 565
- 189. frame.Bind(wx.EVT_TEXT, frame.OnText, text) 表7.8说明了这些命令事件。 表7.8 wx.TextCtrl的事件 EVT_TEXT：当控件中的文本改变时产生该事件。文本因用户的输入或在程序中使 用SetValue()而被改变，都要产生该事件。 EVT_TEXT_ENTER：当用户在一个wx.TE_PROCESS_ENTER样式的文本控件中 按下了回车键时，产生该事件。 EVT_TEXT_URL：如果在Windows系统上，wx.TE_RICH或wx.TE_RICH2样式被设 置了，并且wx.TE_AUTO_URL样式也被设置了，那么当在文本控件内的URL上发生 了一个鼠标事件时，该事件被触发。 EVT_TEXT_MAXLEN：如果使用SetMaxLength()指定了该控件的最大长度，那么当 用户试图输入更长的字符串时，该事件被触发。你可能会用这个，例如，这时给用户 显示一个警告消息。 接下来，让我们来讨论被主要设计来得到鼠标输入的控件。其中最简单的 就是按钮。 7.2 使用按钮工作 在wxPython中有很多不同类型的按钮。这一节，我们将讨论文本按钮、位 图按钮、开关按钮（toggle buttons）和通用（generic）按钮。 7.2.1 如何生成一个按钮？ 在第一部分（part 1）中，我们已经说明了几个按钮的例子，所以这里我们 只简短的涉及它的一些基本的东西。图7.4显示了一个简单的按钮。 图7.4 189 / 565
- 190. 使用按钮是非常简单的。例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”) 参数label是显示在按钮上的文本。它可以在程序运行期间使用SetLabel()来 改变，并且使用GetLabel()来获取。另外两个有用的方法是GetDefaultSize()和 SetDefault()。GetDefaultSize()返回系统默认按钮的尺寸（对于框架间的一致性 是有用的）；SetDefault()设置按钮为对话框或框架的默认按钮。默认按钮的绘 制不同于其它按钮，它在对话框获得焦点时，通常按下回车键被激活。 wx.Button类有一个跨平台的样式标记：wx.BU_EXACTFIT。如果定义了 这个标记，那么按钮就不把系统默认的尺寸作为最小的尺寸，而是把能够恰好 填充标签的尺寸作为最小尺寸。如果本地窗口部件支持的话，你可以使用标记 wx.BU_LEFT, wx.BU_RIGHT, wx.BU_TOP, 和 wx.BU_BOTTOM来改变按钮中 190 / 565
- 191. 标签的对齐方式。每个标记对齐标签到边，该边你根据标记的名字可以知道。 正如我们在第一部分中所讨论过的，wx.Button在被敲击时触发一个命令事件， 事件类型是EVT_BUTTON。 7.2.2 如何生成一个位图按钮？ 有时候，你可能想在你的按钮上显示一个图片，而非一个文本标签，如图 7.5所示。 在wxPython中，使用类wx.BitmapButton来创建一个位图按钮。处理一个 wx.BitmapButton的代码是与通用按钮的代码非常类似的，例7.5显示了产生7.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
- 192. def OnClick(self, event): self.Destroy() if __name__ == ’__main__’: app = wx.PySimpleApp() frame = BitmapButtonFrame() frame.Show() app.MainLoop() 与普通按钮的主要的区别是你需要提供一个位图，而非一个标签。否则， 构造器和大部分代码是与文本按钮的例子相同的。位图按钮在被敲击时同样产 生EVT_BUTTON事件。 关于位图按钮有几个有趣的特性。首先，一个样式标记 wx.BU_AUTODRAW，它是默认的。如果该标记是打开的，那么位图将带有一 个3D的边框，这使它看起来像一个文本按钮（图7.5中的左按钮），并且按钮 比原位图大几个像素。如果该标记是关闭的，则位图被简单地绘制为按钮而没 有边框。通过设置style=0使图7.5中右边的按钮关闭默认设置，它没有了3D的 效果。 默认情况下，给wxPython传递单个位图作为主显示的位图，在当按钮被按 下或获得焦点或无效时，wxPython自动创建一个标准的派生自主显示的位图的 位图作为此时显示在按钮上的位图。如果自动创建的位图不是你想要的，你可 以使用下面的方法： SetBitmapDisabled(), SetBitmapFocus(),SetBitmapLabel(), 和SetBitmap- Selected()显式地告诉wxPython你要使用哪个位图。这些方法都要求一个 wx.Bitmap对象作为参数，并且它们都有相应的get*()方法。 你不能通过使用标准的wxWidgets C++库来合并一个位图和文本。你可以 创建一个包含文本的位图。然而，正如我们将在通用按钮问题讨论中所看到 的，wxPython有额外的方法来实现这一合并行为。 7.2.3 如何创建开关按钮（toggle button）？ 你可以使用wx.ToggleButton创建一个开关按钮（toggle button）。开关按钮 （toggle button）看起来十分像文本按钮，但它的行为更像复选框，它的选择或 非选择状态是可视化的。换句话说，当你按下一个开关按钮（toggle button） 时，它将一直保持被按下的状态直到你再次敲击它。 192 / 565
- 193. 在wx.ToggleButton与父类wx.Button之间只有丙个区别： 1、当被敲击时，wx.ToggleButton发送一个EVT_TOGGLEBUTTON事件。 2、wx.ToggleButton有GetValue()和SetValue()方法，它们处理按钮的二进制 状态。 开关按钮（toggle button）是有用的，它相对于复选框是另一好的选择，特 别是在工具栏中。记住，你不能使用wxWidgets提供的对象来将开关按钮 （toggle button）与位图按钮合并，但是wxPython有一个通用按钮类，它提供了 这种行为，我们将在下一节对其作讨论。 7.2.4 什么是通用按钮，我为什么要使用它？ 通用按钮是一个完全用Python重新实现的一个按钮窗口部件，回避了本地 系统窗口部件的用法。它的父类是wx.lib.buttons. GenButton。通用按钮有通用 位图和切换按钮。 这儿有几个使用通用按钮的原因： 1、通用按钮比本地按钮具有更好的跨平台的外观。另一方面，通用按钮 可能在具体的系统上看起来与本地按钮有些微的不同。 2、使用通用按钮，你对它的外观有更多的控制权，并且能改变属性，如 3D斜面的宽度和颜色，而这对于本地控件可能是不允许的。 3、通用按钮类允许特性的合并，而wxWidget按钮不行。比如 GenBitmapTextButton允许文本标签和位图的组合，GenBitmapToggleButton实现 一个位图切换按钮。 4、如果你正在创建一个按钮类，使用通用按钮是较容易的。由于其代码 和参数是用Python写的，所以当创建一个新的子类的时候，对于检查和覆盖， 它们的可用性更好。 图7.6显示了实际的通用按钮和常规按钮的对照。 193 / 565
- 194. 图7.6 例7.6显示了产生图7.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
- 195. b = 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()方法来改变3D斜面效果。它们用在了图7.6中 大按钮上。 195 / 565
- 196. 通用位图按钮类GenBitmapButton工作的像标准的wxPython版本。在构造 器中。GenBitmapTextButton要求先要一个位图，然后是文本。通用类 GenToggleButton,GenBitmapToggleButton,和 GenBitmapTextToggleButton与非开关版的一样，并且对于处理按钮的开关 状态响应于GetToggle() 和 SetToggle()。 在下一节，我们将讨论关于使你的用户能够输入或观看一个数字值的方 案。 7.3 输入并显示数字 有时你想要显示图形化的数字信息，或你想让用户不必使用键盘来输入一 个数字量。在这一节，我们将浏览wxPython中用于数字输入和显示的工具：滑 块（slider）、微调控制框和显示量度的标尺。 7.3.1 如何生成一个滑块？ 滑块是一个窗口部件，它允许用户通过在该控件的尺度内拖动指示器来选 择一个数值。在wxPython中，该控件类是wx.Slider，它包括了滑块的当前值的 只读文本的显示。图7.7显示了水平和垂直滑块的例子。 图7.7 滑块的基本使用是十分简单的，但是你可以增加许多事件。 196 / 565
- 197. 如何使用滑块 例7.7是产生图7.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”) value是滑块的初始值，而minValue和maxValue是两端的值。 197 / 565
- 198. 使用滑块样式工作 滑块的样式管理滑块的位置和方向，如下表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.10列出了你可用于滑块的Set*()方法。每个Set*()方法都有一个对应的 Get方法——Get方法的描述参考其对应的Set*()方法。 表7.10 GetRange() SetRange(minValue, maxValue)：设置滑块的两端值。 GetTickFreq() SetTickFreq(n, pos)：使用参数n设置刻度的间隔。参数pos没有被使用，但是它仍然 是必要的，将它设置为1。 GetLineSize() SetLineSize(lineSize)：设置你每按一下方向键，滑块所增加或减少的值。 GetPageSize() SetPageSize(pageSize)：设置你每按一下PgUp或PgDn键，滑块所增加或减少的 值。 198 / 565
- 199. GetValue() SetValue(value)：设置滑块的值。 尽管滑块提供了一个可能范围内的值的快速的可视化的表示，但是它们也 有两个缺点。其一是它们占据了许多的空间，另外就是使用鼠标精确地设置滑 块是困难的。下面我们将讨论的微调控制器解决了上面的这两个问题。 7.3.2 如何得到那些灵巧的上下箭头按钮？ 微调控制器是文本控件和一对箭头按钮的组合，它用于调整数字值，并且 在你要求一个最小限度的屏幕空间的时候，它是替代滑块的最好选择。图7.8显 示了wxPython的微调控制器控件。 图7.8 在wxPython中，类wx.SpinCtrl管理微调按钮和相应的文本显示。在接下来 的部分，我们将创建一个微调控制器。 如何创建一个微调控制器 要使用wx.SpinCtrl来改变值，可通过按箭头按钮或通过在文本控件中输 入。键入的非数字的文本将被忽略，尽管控件显示的是键入的非数字的文本。 一个超出范围的值将被认作是相应的最大或最小值，尽管显示的是你输入的 值。例7.8显示了wx.SpinCtrl的用法。 例7.8 使用wx.SpinCtrl import wx class SpinnerFrame(wx.Frame): def __init__(self): wx.Frame.__init__(self, None, -1, ’Spinner Example’, 199 / 565
- 200. 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”) 参数value是虚设的。使用initial参数来设置该控件的值，并使用min和max 来设置该控件的范围。 对于wx.SpinCtrl有两个样式标记。默认样式是wx.SP_ARROW_KEYS，它 允许用户通过键盘上的上下箭头键来改变控件的值。样式wx.SP_WRAP使得控 件中的值可以循环改变，也就是说你通过箭头按钮改变控件中的值到最大或最 小值时，如果再继续，值将变为最小或最大，从一个极端到另一个极端。你也 可以捕获EVT_SPINCTRL事件，它在当控件的值改变时产生（即使改变是直接 由文本输入引起的）。如果文本改变了，将引发一个EVT_TEXT事件，就如同 你使用一个单独的文本控件时一样。 如例7.8所示，你可以使用SetRange(minVal, maxVal) 和 SetValue(value)方法 来设置范围和值。SetValue()函数要求一个字符串或一个整数。要得到值，使用 方法：GetValue()（它返回一个整数）, GetMin(), 和 GetMax()。 当你需要对微调控制器的行为有更多的控制时，如允许浮点数或一个字符 串的列表，你可以把一个wx.SpinButton和一个wx.TextCtrl放到一起，并在它们 之间建立一个联系。然后捕获来自wx.SpinButton的事件，并更新wx.TextCtrl中 的值。 200 / 565
- 201. 7.3.3 如何生成一个进度条？ 如果你只想图形化地显示一个数字值而不允许用户改变它，那么使用相应 的wxPython窗口部件wx.Gauge。 相关的例子就是图7.9所显示的进度条。 图7.9 例7.9显示了产生图7.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
- 202. 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来指定数字值时，该值代表标尺的上限，而下限总是 0。默认样式wx.GA_HORIZONTAL提供了一个水平条。要将它旋转90度，使用 wx.GA_VERTICAL样式。如果你是在Windows上，那么样式 wx.GA_PROGRESSBAR给你的是来自Windows工具包的本地化的进度条。 作为一个只读控件，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
- 203. 图7.10 在wxPython中复选框很容易使用。它们是wx.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.CheckBox有一个典型的wxPython构造函数： wx.CheckBox(parent, id, label, pos=wx.DefaultPosition, size=wx.DefaultSize, style=0, name=”checkBox”) 203 / 565
- 204. label参数是复选框的标签文本。复选框没有样式标记，但是它们产生属于 自己的独一无二的命令事件：EVT_CHECKBOX。wx.CheckBox的开关状态可 以使用GetValue()和SetValue(state)方法来访问,并且其值是一个布尔 值。IsChecked()方法等同于GetValue()方法，只是为了让代码看起来更易明白。 7.4.2 如何创建一组单选按钮（radio button）? 单选按钮是一种允许用户从几个选项中选择其一的窗口部件。与复选框不 同，单选按钮是显式地成组配置，并且只能选择其中一个选项。当选择了新的 选项时，上次的选择就关闭了。单选按钮的使用比复选框复杂些，因为它需要 被组织到一组中以便使用。radio button的名字得自于老式轿车上有着同样行为 的成组的选择按钮。 在wxPython中，有两种方法可以创建一组单选按钮。其 一，wx.RadioButton，它要求你一次创建一个按钮，而wx.RadioBox使你可以使 用单一对象来配置完整的一组按钮，这些按钮显示在一个矩形中。 wx.RadioButton类更简单些，在单选按钮对其它窗口部件有直接影响或单 选按钮不是布置在一个单一的矩形中的情况下，它是首选。图7.11显示了一组 wx.RadioButton对象的列子。 图7.11 我们在这个例子中使用wx.RadioButton的原因是因为每个单选按钮控制着 一个关联的文本控件。由于窗口部件是位于这组单选按钮之外的，所以我们不 能只用一个单选按钮框。 204 / 565
- 205. 如何创建单选按钮 例7.11显示了图7.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
- 206. app = wx.PySimpleApp() RadioButtonFrame().Show() app.MainLoop() 我们创建了单选按钮和文本框，然后使用字典来建立它们间的连接。一个 for循环使得两个文本框无效，另一个for循环绑定单选按钮命令事件。当事件发 生的时候，当前活动的文本框变为无效，与被敲击的按钮相匹配的文本框变为 有效。 wx.RadioButton的使用类似于是wx.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_GROUP被创建，并开始下一个组。在例7.11中， 第一个单选按钮是使用wx.RB_GROUP声明的，而后来的没有。结果导致所有 的按钮都被认为在同一组中，这样一来，敲击它们中的一个时，先前被选中按 钮将关闭。 使用单选框 通常，如果你想去显示一组按钮，分别声明它们不是最好的方法。取而代 之，wxPython使用wx.RadioBox类让你能够创建一个单一的对象，该对象包含 了完整的组。如图7.12所示，它看起来非常类似一组单选按钮。 206 / 565
- 207. 图7.12 要使用wx.RadioBox类，你所需要的全部就是构造函数。例7.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
- 208. 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”) label参数是静态文本，它显示在单选框的边框上。这些按钮使用choices参 数指定，它是一个Python的字符串标签的序列。 如同网格的sizer一样，你通过使用规定一个维数的尺寸来指定 wx.RadioBox的尺度，wxPython在另一维度上自动填充。维度的主尺寸使用 majorDimension参数指定。哪一维是主要的由样式标记决定。默认值是 wx.RA_SPECIFY_COLS。在本例中，左框的列数被设置为2，右框的列数被设 置为3，行数由choices列表中的元素数量动态的决定。如果你想得到相反的行 为，你要将样式设置为wx.RA_SPECIFY_ROWS。如果你想在单选框被敲击时 响应命令事件，那么这个命令事件是EVT_RADIOBOX。 wx.RadioBox类有许多方法来管理框中的不同的单选按钮。这些方法使你 能够处理一个特定的内部按钮，传递该按钮的索引。索引以0为开始，并按严 格的顺序展开，它的顺序就是按钮标签传递给构造函数的顺序。表7.11列出了 这些方法。 表7.11 wx.RadioBox的方法 EnableItem(n, flag)：flag参数是一个布尔值，它用于使索引为n的按钮有效或无效。 要使整个框立即有效，使用Enable()。 FindString(string)：根据给定的标签返回相关按钮的整数索引值，如果标签没有发现 则返回-1。 GetCount()：返回框中按钮的数量。 GetItemLabel(n) SetItemLabel(n, string)：返回或设置索引为n的按钮的字符串标签。 GetSelection() GetStringSelection() SetSelection(n) SetStringSelection( string)：GetSelection() 和 SetSelection()方法处理当前所选择的 单选按钮的整数索引。GetStringSelection()返回当前所选择的按钮的字符串标 208 / 565
- 209. 签，SetStringSelection()改变所选择的按钮的字符串标签为给定值。没有set*()产生 EVT_RADIOBOX事件。 ShowItem(item, show)：show参数是一个布尔值，用于显示或隐藏索引为item的按 钮。 单选按钮不是给用户一系列选择的唯一方法。列表框和组合框占用的空间 也少，也可以被配置来让用户从同一组中作多个选择。 7.4.3 如何创建一个列表框？ 列表框是提供给用户选择的另一机制。选项被放置在一个矩形的窗口中， 用户可以选择一个或多个。列表框比单选按钮占据较少的空间，当选项的数目 相对少的时候，列表框是一个好的选择。然而，如果用户必须将滚动条拉很远 才能看到所有的选项的话，那么它的效用就有所下降了。图7.13显示了一个 wxPython列表框。 在wxPython中，列表框是类wx.ListBox的元素。该类的方法使你能够处理 列表中的选择。 如何创建一个列表框 例7.13显示了产生图7.13的代码 例7.13 使用wx.ListBox import wx class ListBoxFrame(wx.Frame): def __init__(self): 209 / 565
- 210. 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.ListBox没有label属性。显示在列表中的 元素放置在参数choices中，它是一个字符串的序列。列表框有三种互斥的样 式，它决定用户如何从列表框中选择元素，说明在表7.12中。 用户通常对于多选有一些问题，因为它们一般希望见到的是单选列表，对 于多选来说可能是有挑战性的（就像单选题和多选题一样），尤其是对于那些 易受困扰的用户。如果你使用了一个多选的列表，我们建议你清楚地标明该列 表。 表7.12 列表框的选择类型样式 wx.LB_EXTENDED：用户可以通过使用shift并敲击鼠标来选择一定范围内的连续的 选项，或使用等同功能的按键。 wx.LB_MULTIPLE：用户可以一次选择多个选项（选项可以是不连续的）。实际 上，在这种情况下，列表框的行为就像是一组复选框。 210 / 565
- 211. wx.LB_SINGLE：用户一次只能选一个选项。实际上，在这种情况下，列表框的行为 就像是一组单选按钮。 有三种控制wx.ListBox中滚动条的显示的样式，如表7.13所示。 表7.13 列表框的滚动条类型样式 wx.LB_ALWAYS_SB：列表框将始终显示一个垂直的滚动条，不管有没有必要。 wx.LB_HSCROLL：如果本地控支持，那么列表框在选择项太多时，将创建一个水平 滚动条。 wx.LB_HSCROLL：列表框只在需要的时候显示一个垂直的滚动条。这是默认样式。 还有一个样式wx.LB_SORT，它使得列表中的元素按字母顺序排序。 有两个专用于wx.ListBox的命令事件。EVT_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
- 212. GetStringSelection() SetStringSelection(string, select) GetSelections()：GetSelection()得到当前选择项的整数索引（仅对于单选列表）。 对于多选列表，使用GetSelections()来返回包含所选项目的整数位置的元组。对于单 选列表，GetStringSelection()返回当前选择的字符串。相应的set方法使用布尔值参 数select设置指定字符串或索引选项的状态。使用这种方法改变选择不触发 EVT_LISTBOX事件。 GetString(n) SetString(n, string)：得到或设置位置n处的字符串。 InsertItems(items, pos)：插入参数items中的字符串列表到该列表框中pos参数所指 定的位置前。位置0表示把项目放在列表的开头。 Selected(n)：返回对应于索引为n的项目的选择状态的布尔值。 Set(choices)：重新使用choices的内容设置列表框。 7.4.4 如何合并复选框和列表框？ 你可以使用类wx.CheckListBox来将复选框与列表框合并。图7.14显示了列 表框和复选框在合并在一起的例子。 图7.14 wx.CheckListBox的构造函数和大多数方法与wx.ListBox的相同。它有一个 新的事件：wx.EVT_CHECKLISTBOX，它在当列表中的一个复选框被敲击时 触发。它有两个管理复选框的新的方法：Check(n, check)设置索引为n的项目的 选择状态，IsChecked(item)在给定的索引的项目是选中状态时返回True。 212 / 565
- 213. 7.4.5 如果我想要下拉形式的选择该怎么做？ 下拉式选择是一种仅当下拉箭头被敲击时才显示选项的选择机制。它是显 示所选元素的最简洁的方法，当屏幕空间很有限的时候，它是最有用的。图 7.15显示了一个关闭的下拉式选择。图7.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
- 214. 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.Choice没有专门的样式，但是它有独特的命令事件：EVT_CHOICE。 几乎表7.14中所有适用于单选列表框的方法都适用于wx.Choice对象。 7.4.6 我能够将文本域与列表合并在一起吗？ 将文本域与列表合并在一起的窗口部件称为组合框，其本质上是一个下拉 选择和文本框的组合。图7.17显示了一个组合框。 图7.17 左边是wx.CB_DropDOWN样式，右边是wx.CB_SIMPLE样式 在Windows上，你可以使用右边的样式，它是一个列表框和文本框的组 合。 214 / 565
- 215. 创建组合框的代码与我们已经见过的选择是类似的。该类是 wx.ComboBox，它是wx.Choice的一个子类。例7.15显示了图7.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.ComboBox来说有4种样式。其中的两种决定了如何绘制组合框： wx.CB_DropDOWN创建一个带有下拉列表的组合框，wx.CB_SIMPLE创建一个 带有列表框的组合框。在Windows上你可以只使用wx.CB_SIMPLE样式。任何 组合框都可以被指定为wx.CB_READONLY样式，它防止用户在文本域中键 入。当组合框被指定为只读时，所做的选择必须来自于选择列表的元素之一， 即使你用程序来设置它也不行。最后wx.CB_SORT样式导致选择列表中的元素 按字母顺序显示。 215 / 565
- 216. 由于wx.ComboBox是wx.Choice的子类，所有的wx.Choice的方法都能被组 合框调用，如表7.14所示。另外，还有许多方法被定义来处理文本组件，它们 的行为同wx.TextCtrl（参见表7.4)，所定义的方法有 Copy(), Cut(), GetInsertionPoint(), GetValue(), Paste(), Replace(from,to, text), Remo ve(from, to), SetInsertionPoint(pos), SetInsertionPointEnd(),和 SetValue()。 7.5 本章小结 在这一章中，我们给你展示了如何使用wxPython中许多最基本和常用的控 件。这些通用的版本在跨平台使用时显得一致性较好。 1、对于静态文本标签的显示，你可以使用wx.StaticText类。还有一个完全 用wxPython实现的版本，名为wx.lib.stattext.GenStaticText。 2、如果你需要一个控件以让用户输入文本，那么使用类wx.TextCtrl。它允 许单行和多行的输入，还有密码掩饰和其它的功用。如果本地控支持它，你可 以使用wx.TextCtrl来得到样式文本。样式是wx.Text-Attr类的实例，wx.Font包含 字体信息。对于所有的系统，你可以使用类wx.stc.StyledTextCtrl（它是 wxPython对开源Scintilla文本组件的封装）在一个可编辑的文本组件中实现颜色 和字体样式。 3、创建按钮，使用wx.Button类，它也有一个通用版 wx.lib.buttons.GenButton。按钮可以使用位图来代替一个文本标签 （wx.BitmapButton），或在按下和未按下之间有一个开关状态。还有一个等价 于位图和开关按钮的通用版，它比标准版有更全面的特性。 4、有一些方法用于选择或显示数字值。你可以使用wx.Slider类来显示一个 垂直或水平的滑块。wx.SpinCtrl显示一个可以使用上下按钮来改变数字值的文 本控件。wx.Gauge控件显示一个进度条指示器。 5、你可以从一系列的控件中选出让用户从列表选项作出选择的最佳控 件，最佳控件所应考虑的条件是选项的数量，用户能否多选和你想使用的屏幕 空间的总量。复选框使用wx.CheckBox类。这儿有两个方法去得到单选按钮： wx.RadioButton给出单个单选按钮，而wx.RadioBox给出显示在一起的一组按 钮。这儿有几个列表显示控件，它们的用法相似。列表框的创建使用 wx.ListBox，并且你可以使用wx.CheckListBox来增加复选框。对于更简洁的下 拉式，使用wx.Choice. wx.ComboBox合并了列表和文本控件的特性。 216 / 565
- 218. 8、把窗口部件放入框架中 在你的wxPython中，所有的用户交互行为都发生在一个窗口部件容器中， 它通常被称作窗口，在wxPython 中被称为框架。在这一章中，我们将讨论 wxPython中的几个不同样式的框架。这个主要的wx.Frame有几个不同的框架样 式，这些样式可以改变wx.Frame的外观。另外，wxPython提供了小型框架和实 现多文档界面的框架。框架可以使用分隔条来划分为不同的部分，并且可以通 过滚动条的使用来包含比框架本身大的面板（panel）。 8.1 框架的寿命 我们将通过讨论框架最基本的元素：创建和除去它们，来作为我们的开 始。创建框架包括了解可以应用的所有样式元素；框架的去除可能比你原本想 像的要复杂。 8.1.1 如何创建一个框架？ 在本书中我们已经见过了许多的框架创建的例子，但是我们仍将再回顾一 下框架创建的初步原则。 创建一个简单的框架 框架是类wx.Frame的实例。例8.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
- 219. 图8.1 wx.Frame的构造函数类似于我们在第7章见到的其它窗口部件的构造函 数： wx.Frame(parent, id=-1, title=””, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE, name=”frame”) 这里有超过十余种之多的专用于wx.Frame的样式标记，我们将在下一部分 涵盖它们。默认样式为你提供了最小化和最大化框、系统下拉菜单、可调整尺 寸的粗边框和一个标题。 这里没有与一个wx.Frame挂钩的事件类型。但是，由于一个wx.Frame是你 的屏幕上用户最可能去关闭的元素，所以你通常想去为关闭事件定义一个处理 器，以便子窗口和数据被妥善的处理。 创建框架的子类 你将很少直接创建wx.Frame的实例。正如我们在本书中所见过的其它例子 一样，一个典型的wxPython应用程序创建wx.Frame的子类并创建那些子类的实 例。这是因为wx.Frame的独特的情形——虽然它自身定义了很少的行为，但是 带有独自的初始化程序的子类是放置有关你的框架的布局和行为的最合理的地 方。不创建子类而构造你应用程序的特定的布局是有可能，但除了最简单的应 用程序以外，那是不容易的。例8.2展示了wx.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
- 220. 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 Windows操作系统下，wx.Panel实例的默认 背景色以白色代替了灰色。其二，面板（panel）可以有一个默认的项目，该项 220 / 565
- 221. 目在当回车键被按下时自动激活，并且面板（panel）以与对话框大致相同的办 法响应tab键盘事件，以改变或选择默认项目。 8.1.2 有些什么不同的框架样式？ wx.Frame有许多的可能的样式标记。通常，默认样式就是你想要的，但也 有一些有用的变种。我们将讨论的第一组样式控制框架的形状和尺寸。尽管不 是强制性的，但是这些标记应该被认为是互斥的——一个给定的框架应该只使 用它们中的一个。表8.1说明了形状和尺寸标记。 表8.1 框架的形状和尺寸标记 wx.FRAME_NO_TASKBAR：一个完全标准的框架，除了一件事：在Windows系统 和别的支持这个特性的系统下，它不显示在任务栏中。当最小化时，该框架图标化到 桌面而非任务栏。 wx.FRAME_SHAPED：非矩形的框架。框架的确切形状使用SetShape()方法来设 置。窗口的形状将在本章后面部分讨论。 wx.FRAME_TOOL_WINDOW：该框架的标题栏比标准的小些，通常用于包含多种 工具按钮的辅助框架。在Windows操作系统下，工具窗口将不显示在任务栏中。 wx.ICONIZE：窗口初始时将被最小化显示。这个样式仅在Windows系统中起作用。 wx.MAXIMIZE：窗口初始时将被最大化显示（全屏）。这个样式仅在Windows系统 中起作用。 wx.MINIMIZE：同wx.ICONIZE。 上面这组样式中，屏幕画面最需要的样式是 wx.FRAME_TOOL_WINDOW。图8.3显示了一个小的结合使用了 wx.FRAME_TOOL_WINDOW、wx.CAPTION和wx.SYSTEM_MENU样式的例 子。 图8.3 221 / 565
- 222. 这里有两个互斥的样式，它们控制一个框架是否位于别的框架的上面，无 论别的框架是否获得了焦点。这对于那些小的不是始终可见的对话框是有用 的。表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_CONTEXTHELP：这是用于Windows操作系统的，它在标题栏的右 角放置问号帮助图标。这个样式是与wx.MAXIMIZE_BOX和WX.MINIMIZE_BOX样 式互斥的。它是一个扩展的样式，并且必须使用两步来创建，稍后说明。 wx.FRAME_EX_METAL：在Mac OS X上，使用这个样式的框架有一个金属质感的 外观。这是一个附加样式，必须使用SetExtraStyle方法来设置。 wx.MAXIMIZE_BOX：在标题栏的标准位置放置一个最大化框。 wx.MINIMIZE_BOX：在标题栏的标准位置放置一个最小化框。 222 / 565
- 223. 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，必须在本地 UI（用户界面）对象被创建之前被设置。在wxPython中，这需要使用稍微笨拙 的方法来完成，即分两步构建。之后标题栏中带有我们熟悉的问号图标的框架 就被创建了。如图8.4所示。 图8.4 标记值必须使用SetExtraStyle()方法来设置。有时，额外样式信息必须在框 架被实例化前被设置，这就导致了一个问题：你如何对于一个不存在的实例调 用一个方法？在接下来的部分，我们将展示实现这种操作的两个机制。 添加额外样式信息 在wxPython中，额外样式信息在创建之前通过使用专门的类wx.PreFrame 来被添加，它是框架的一种局部实例。你可以在预框架（preframe）上设置额 外样式位，然后使用这个预框架（preframe）来创建实际的框架。例8.3显示了 在一个子类的构造器中如何完成这两步（two-step）的构建。注意，在 wxPython中它实际上是三步（在C++ wxWidgets工具包中，它是两步（two- step），我们只是沿用这个叫法而已）。 223 / 565
- 224. 例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 这是特定于wxPython的，并且不由C++完成。PostCreate方法做一些内 部的内务处理，它实例化一个你在第一步中创建的封装了C++的对象。 添加额外样式信息的通用方法 先前的算法有点笨拙，但是它可以被重构得容易一点，以便于管理维护。 第一步是创建一个公用函数，它可以管理任何分两步的创建。例8.4提供了一个 例子，它使用Python的内省性能来调用以变量形式被传递的函数。这个例子用 于在Python的一个新的框架实例化期间的__init__方法中被调用。 例8.4 一个公用的两步式创建函数 def twoStepCreate(instance, preClass, preInitFunc, *args, **kwargs): 224 / 565
- 225. pre = preClass() preInitFunc(pre) pre.Create(*args, **kwargs) instance.PostCreate(pre) 在例8.4中，函数要求三个必须的参数。instance参数是实际被创建的实 例。preClass参数是临时的预类的类对象——对框架预类是 wx.PreFrame。preInitFunc是一个函数对象，它通常作为回调函数用于该实例的 初始化。这三个参数之后，我们可以再增加任意数量的其它可选参数。 这个函数的第一行，pre = preClass()，内省地实例化这个预创建对象，使 用作为参数传递过来的类对象。下面一行根据参数preInitFunc内省地调用回调 函数，它通常设置扩展样式标记。然后pre.Create()方法被调用，它使用了可选 的参数。最后，PostCreate方法被调用来将内在的值从pre移给实例。至 此，instance参数已经完全被创建了。假设twoStepCreate已被导入，那么上面的 公用函数可以如例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.PreFrame和函数self.preInit被传递给公用函数，并且preInit方法被定 义为回调函数。 8.1.4 当关闭一个框架时都发生了什么？ 当你关闭一个框架时，它最终消失了。除非这个框架被明确地告诉不关 闭。换句话说，那关闭不是直接了当的。在wxPython的窗口部件关闭体系之后 的用意是，给正在关闭的窗口部件充足的机会来关闭或释放它所占用任何非 225 / 565
- 226. wxPython资源。如果你占用了某种昂贵的外部资源，如一个大的数据结构或一 个数据库连接，那么该意图是特别受欢迎的。 诚然，在C++ wxWidgets世界里，由于C++不为你管理内在分配的清理工 作，管理资源是更严肃的问题。在wxPython中，对于多步的关闭过程的显式需 求就很少，但它对于在过程中使用额外的钩子仍然是有用的。（随便说一下， 我们在这一节中从单词“框架”切换到单词“窗口部件”是故意的——因为在本节 中的所有内容都适用于所有顶级窗口部件，如框架或对话框）。 何时用户触发关闭过程 关闭过程最常由用户触发，如敲击一个关闭框或选择系统菜单中的关闭项 或当应用程序响应其它某个事件而调用框架的Close方法。当上述情况发生 时，wxPython架构引发一个EVT_CLOSE事件。像wxPython 架构中的其它别的 事件一样，你可以在绑定一个事件处理器以便一个EVT_CLOSE事件发生时调 用。 如果你不声明你自己的事件处理器，那么默认的行为将被调用。默认的行 为对于框架和对话框是不同的。 1、默认情况下，框架处理器调用Destroy()方法并删除该框架和它的所有的 组件。 2、默认情况下，对话框的关闭处理器不销毁该对话框——它仅仅模拟取 消按钮的按下，并隐藏对话框。该对话框对象仍继续存在在内存中。因此，如 果需要的话，应用程序可以从它的数据输入部件获取值。当应用程序完成了对 对话框的使用后，应该调用对话框的Destroy()方法。 如果你编写你自己的关闭处理器，那么你可以使用它来关闭或删除任何外 部的资源，但是，如果你选择去删除框架的话，显式地调用Destroy()方法是你 的责任。尽管Destroy()经常被Close()调用，但是只调用Close()方法不能保证框 架的销毁。在一定的情形下，决定不销毁框架是完全可以的，如当用户取消了 关闭。然而，你仍然需要一个方法来销毁该框架。如果你选择不去销毁窗口， 那么调用关闭事件的wx.CloseEvent.Veto()方法来通知相关部分：框架拒绝关 闭，是一个好的习惯。 如果你选择在你的程序的别处而非关闭处理器中关闭你的框架，例如从一 个不同的用户事件像一个菜单项，那么我们建议使用的机制是调用框架的 Close()方法。这将启动一个和系统关闭行为相同的过程。如果你要确保框架一 226 / 565
- 227. 定被删除，那么你可以直接调用Destroy()方法；然而，如果你这样做了，可能 会导致框架所管理的资源或数据没有被释放或保存。 什么时候系统触发关闭过程 如果关闭事件是由系统自己触发的，对于系统关闭或类似情况，你也有一 种办法管理该事件。wx.App 类接受一个EVT_QUERY_END_SESSION事件，如 果需要的话，该事件使你能够否决应用程序的关闭，如果所有运行的应用已经 批准了系统或GUI环境的关闭的话，那么随后会有一个EVT_END_SESSION事 件。你选择去否决关闭的行为是与依赖于具体系统的。 最后，值得注意的是，调用一个窗口部件的Destroy()方法不意味该部件被 立即销毁。销毁实际上是当事件循环在未来空闲时（任何未被处理的事件被处 理之后）才被处理的。这就防止了处理已不存在的窗口部件的事件。 在接下来的两节，我们的讨论将从一个框架的生命周期切换到在框架生命 周期里，你能够用框架来做些什么。 8.2 使用框架 框架包含了许多方法和属性。其中最重要的是那些查找框架中任意窗口部 件的方法，和滚动框架中内容的方法。在这一节，我们将讨论如何实现这些。 8.2.1 wx.Frame有那些方法和属性？ 这部分中的表包含了wx.Frame和它的父类wx.Window的最基本的属性。这 些属性和方法的许多在本书中的其它地方有更详细的说明。表8.4包含了 wx.Frame的一些公共的可读、可修改的属性。 表8.4 wx.Frame的公共属性 GetBackgroundColor() SetBackgroundColor(wx.Color)：背景色是框架中没有被其子窗口部件覆盖住的那些 部分的颜色。你可以传递一个wx.Color或颜色名给设置方法。任何传递给需要颜色的 wxPython方法的字符串，都被解释为对函数wx.NamedColour()的调用。 GetId() SetId(int)：返回或设置窗口部件的标识符。 GetMenuBar() 227 / 565
- 228. SetMenuBar(wx.MenuBar)：得到或设置框架当前使用的的菜单栏对象，如果没有菜 单栏，则返回None。 GetPosition() GetPositionTuple() SetPosition(wx.Point)：以一个wx.Point或Python元组的形式返回窗口左上角的x,y的 位置。对于顶级窗口，该位置是相对于显示区域的坐标，对于子窗口，该位置是相对 于父窗口的坐标。 GetSize() GetSizeTuple() SetSize(wx.Size)：C++版的get*或set*方法被覆盖。默认的get*或set*使用一个 wx.Size对象。GetSizeTuple()方法以一个Python元组的形式返回尺寸。也可以参看 访问该信息的另外的方法SetDimensions()。 GetTitle() SetTitle(String)：得到或设置框架标题栏的字符串。 表8.5显示了一些wx.Frame的非属性类的更有用的方法。其中要牢记的是 Refresh()，你可以用它来手动触发框架的重绘。 表8.5 wx.Frame的方法 Center(direction=wx.BOTH)：框架居中（注意，非美语的拼写Centre，也被定义了 的）。参数的默认值是wx.BoTH，在此情况下，框是在两个方向都居中的。参数的 值若是wx.HORIZONTAL或wx.VERTICAL，表示在水平或垂直方向居中。 Enable(enable=true)：如果参数为true，则框架能够接受用户的输入。如果参数为 False，则用户不能在框架中输入。相对应的方法是Disable()。 GetBestSize()：对于wx.Frame，它返回框架能容纳所有子窗口的最小尺寸。 Iconize(iconize)：如果参数为true，最小化该框架为一个图标（当然，具体的行为与 系统有关）。如果参数为False，图标化的框架恢复到正常状态。 IsEnabled()：如果框架当前有效，则返回True。 IsFullScreen()：如果框架是以全屏模式显示的，则返回True，否则False。细节参看 ShowFullScreen。 IsIconized()：如果框架当前最小化为图标了，则返回True，否则False。 IsMaximized()：如果框架当前是最大化状态，则返回True，否则False。 228 / 565
- 229. IsShown()：如果框架当前可见，则返回True。 IsTopLevel()：对于顶级窗口部件如框架或对话框，总是返回True，对于其它类型的 窗口部件返回False。 Maximize(maximize)：如果参数为True，最大化框架以填充屏幕（具体的行为与系 统有关）。这与敲击框架的最大化按钮所做的相同，这通常放大框架以填充桌面，但 是任务栏和其它系统组件仍然可见。 Refresh(erase"242.files/">rect=None)：触发该框架的重绘事件。如果rect是none， 那么整个框架被重画。如果指定了一个矩形区域，那么仅那个矩形区域被重画。如果 eraseBackground为True，那么这个窗口的北影也将被重画，如果为False，那么背 景将不被重画。 SetDimensions(x, y, width, height,sizeFlags=wx.SIZE_AUTO)：使你能够在一个方 法调用中设置窗口的尺寸和位置。位置由参数x和y决定，尺寸由参数width和height 决定。前四个参数中，如果有的为-1，那么这个-1将根据参数sizeFlags的值作相应的 解释。表8.6包含了参数sizeFlags的可能取值。 Show(show=True)：如果参数值为True，导致框架被显示。如果参数值为False，导 致框架被隐藏。Show(False)等同于Hide()。 ShowFullScreen(show,style=wx.FULLSCREEN_ALL)：如果布尔参数是True，那么 框架以全屏的模式被显示——意味着框架被放大到填充整个显示区域，包括桌面上的 任务栏和其它系统组件。如果参数是False，那么框架恢复到正常尺寸。style参数是 一个位掩码。默认值wx.FULLSCREEN_ALL指示wxPython当全屏模式时隐藏所有窗 口的所有样式元素。后面的这些值可以通过使用按位运算符来组合，以取消全屏模式 框架的部分装饰： wx.FULLSCREEN_NOBORDER, wx.FULLSCREEN_NOCAPTION,wx.FULLSCRE EN_NOMENUBAR,wx.FULLSCREEN_NOSTATUSBAR,wx.FULLSCREEN_NOTO OLBAR。 表8.5中说明的SetDimensions()方法在用户将一个尺寸指定为-1时，使用尺 寸标记的一个位掩码来决定默认行为。表8.6说明了这些标记。 这些方法没有涉及框架所包含的孩子的位置问题。这个问题要求框架的孩 子自已去说明它。 表8.6 关于SetDimensions方法的尺寸标记 wx.ALLOW_MINUS_ONE：一个有效的位置或尺寸。 wx.SIZE_AUTO：转换为一个wxPython默认值。 229 / 565
- 230. wx.SIZE_AUTO_HEIGHT：一个有效的高度，或一个wxPython默认高度。 wx.SIZE_AUTO_WIDTH：一个有效的宽度，或一个wxPython默认宽度。 wx.SIZE_USE_EXISTING：使用现有的尺寸。 8.2.2 如何查找框架的子窗口部件？ 有时候，你将需要查找框架或面板(panel)上的一个特定的窗口部件，并且 你没有它的相关引用。如第6章所示的这种情况的一个公用的应用程序，它查 找与所选菜单相关的实际的菜单项对象（因为事件不包含对它的一个引用）。 另一种情况就是，当你想基于一个项的事件去改变系统中其它任一窗口部件的 状态时。例如，你可能有一个按钮和一个菜单项，它们互相改变彼此的开关状 态。当按钮被敲击时，你需要去得到菜单项以触发它。例8.6显示了一个摘自第 7章的一个小的例子。在这个代码中，FindItemById()方法用来去获得与事件对 象所提供的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参数中），或通过文本标签来查寻。文本标签被定义 为相应窗口部件的标题，如按钮和框架。 这三种方法是： 1、wx.FindWindowById(id, parent=None) 2、wx.FindWindowByName(name, parent=None) 3、wx.FindWindowByLabel(label, parent=None) 230 / 565
- 231. 这三种情况中，parent参数可以被用来限制为对一个特殊子层次的搜索 （也就是，它等同于父类的Find方法）。还有，FindWindowByName()首先按 name参数查找，如果没有发现匹配的，它就调用FindWindowByLabel()去查找 一个匹配。 8.2.3 如何创建一个带有滚动条的框架？ 在wxPython中，滚动条不是框架本身的一个元素，而是被类 wx.ScrolledWindow控制。你可以在任何你要使用wx.Panel的地方使用 wx.ScrolledWindow，并且滚动条移动所有在滚动窗口中的项目。图8.5和图8.6 显示了滚动条，包括它的初始状态和滚动后的状态。从图8.5到图8.6，左上的 按钮移出了视野，右下的按钮移进了视野。 在这一节，我们将讨论如何去创建一个带有滚动条的窗口以及如何在你的 程序中处理滚动行为。 图8.5 图8.6 231 / 565
- 232. 如何创建滚动条 例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.ScrolledWindow的构造函数几乎与wx.Panel的相同： wx.ScrolledWindow(parent, id=-1, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.HSCROLL | wx.VSCROLL, name=”scrolledWindow”) 所有的这些属性的行为都如你所愿，尽管size属性是它的父亲中的面板的 物理尺寸，而非滚动窗口的逻辑尺寸。 232 / 565
- 233. 指定滚动区域的尺寸 有几个自动指定滚动区域尺寸的方法。手工指定最多的方法如例8.1所示， 使用了方法SetScrollBars： SetScrollbars(pixelsPerUnitX, pixelsPerUnitY, noUnitsX, noUnitsY, xPos=0, yPos=0, noRefresh=False) 其中关键的概念是滚动单位，它是滚动条的一次移动所引起的窗口中的转 移距离。前面的两个参数pixelsPerUnitX和PixelsPerUnitY使你能够在两个方向 设置滚动单位的大小。接下来的两个参数noUnitsX和noUnitsY使你能够按滚动 单位设置滚动区域的尺寸。换句话说，滚动区域的象素尺寸是 (pixelsPerUnitX* noUnitsX, pixelsPerUnitY * noUnitsY)。例8.7通过将滚动单位设 为1像素而避免了可能造成的混淆。参数xPos和yPos以滚动单位（非像素）为单 位，它设置滚动条的初始位置，如果参数noRefresh为true，那么就阻止了在因 SetScrollbars()的调用而引起的滚动后的窗口的自动刷新。 还有另外的三个方法，你可以用来设置滚动区域的尺寸，然后单独设置滚 动率。你可能发现这些方法更容易使用，因为它们使你能够更直接地指定尺 寸。你可以如下以像素为单位使用滚动窗口的SetVirtualSize()方法来直接设置 尺寸。 self.scroll.SetVirtualSize((600, 400)) 使用方法FitInside()，你可以在滚动区域中设置窗口部件，以便滚动窗口绑 定它们。这个方法设置滚动窗口的边界，以使滚动窗口刚好适合其中的所有子 窗口： self.scroll.FitInside() 通常使用FitInside()的情况是，当在滚动窗口中正好有一个窗口部件（如文 本域），并且该窗口部件的逻辑尺寸已被设置。如果我们在例8.7中使用了 FitInside()，那么一个更小的滚动区域将被创建，因为该区域将正好匹配右下按 钮的边缘，而没有多余的内边距。 最后，如果滚动窗口中有一个sizer设置，那么使用SetSizer()设置滚动区域 为sizer所管理的窗口部件的尺寸。这是在一个复杂的布局中最常用的机制。关 于sizer的更多细节参见第11章。 233 / 565
- 234. 对于上述所有三种机制，滚动率需要去使用SetScrollRate()方法单独设置， 如下所示： self.scroll.SetScrollRate(1, 1) 参数分别是x和y方向的滚动单位尺寸。大于0的尺寸都是有效的。 滚动条事件 在例8.7中的按钮事件处理器，使用Scroll()方法程序化地改变滚动条的位 置。这个方法需要滚动窗口的x和y坐标，使用的是滚动单位。 在第7章中，我们答应了你可以捕获的来自滚动条的事件列表，因为它们 也被用来去控制滑块。表8.7列出了所有被滚动窗口内在处理的滚动事件。通 常，许多你不会用到，除非你建造自定义窗口部件。 表8.7 滚动条的事件 EVT_SCROLL：当任何滚动事件被触发时发生。 EVT_SCROLL_BOTTOM：当用户移动滚动条到它的范围的最末端时触发（底边或 右边，依赖于方向）。 EVT_SCROLL_ENDSCROLL：在微软的Windows中，任何滚动会话的结束都将触 发该事件，不管是因鼠标拖动或按键按下。 EVT_SCROLL_LINEDOWN：当用户向下滚动一行时触发。 EVT_SCROLL_LINEUP：当用户向上滚动一行时触发。 EVT_SCROLL_PAGEDOWN：当用户向下滚动一页时触发。 EVT_SCROLL_PAGEUP：当用户向上滚动一页时触发。 EVT_SCROLL_THUMBRELEASE：用户使用鼠标拖动滚动条滚动不超过一页的范 围，并释放鼠标后，触发该事件。 EVT_SCROLL_THUMBTRACK：滚动条在一页内被拖动时不断的触发。 EVT_SCROLL_TOP：当用户移动滚动条到它的范围的最始端时触发，可能是顶端 或左边，依赖于方向而定。 234 / 565
- 235. 行和页的准确定义依赖于你所设定的滚动单位，一行是一个滚动单位，一 页是滚动窗口中可见部分的全部滚动单位的数量。对于表中所列出的每个 EVT_SCROLL*事件，都有一个相应的EVT_SCROLLWIN*事件（它们由 wx.ScrolledWindow产生）来回应。 还有一个wxPython的特殊的滚动窗口子类： wx.lib.scrolledpanel.ScrolledPanel，它使得你能够在面板上自动地设置滚动，该 面板使用一个sizer来管理子窗口部件的布局。wx.lib.scrolledpanel.ScrolledPanel 增加的好处是，它让用户能够使用tab键来在子窗口部件间切换。面板自动滚 动，使新获得焦点的窗口部件进入视野。要使用 wx.lib.scrolledpanel.ScrolledPanel，就要像一个滚动窗口一样声明它，然后，在 所有的子窗口被添加后，调用下面的方法： SetupScrolling(self, scroll_x=True, scroll_y=True, rate_x=20, rate_y=20) rate_x和rate_y是窗口的滚动单位，该类自动根据sizer所计算的子窗口部件 的尺寸设定虚拟尺寸(virtual size)。 记住，当确定滚动窗口中的窗口部件的位置的时候，该位置总是窗口部件 的物理位置，它相对于显示器中的滚动窗口的实际原点，而非窗口部件相对于 显示器虚拟尺寸(virtual size)的逻辑位置。这始终是成立的，即使窗口部件不再 可见。例如，在敲击了图8.5中的Scroll Me按钮后，该按钮所报告的它的位置是 (-277,-237)。如果这不的你所想要的，那么使用CalcScrolledPosition(x,y) 和。CalcUnscrolledPosition(x, y)方法在显示器坐标和逻辑坐标之间切换。在这 两种情况中，在按钮敲击并使滚动条移动到底部后，你传递指针的坐标，并且 滚动窗口返回一个(x,y)元组，如下所示： CalcUnscrolledPostion(-277, -237) 返回(50, 20) 8.3 可选的框架类型 框架不限于其中带有窗口部件的普通的矩形，它可以呈现其它的形状。你 也可以创建MDI（多文档界面）框架，它其中包含别的框架。或者你也可以去 掉框架的标题栏，并且仍然可以使用户能拖动框架。 8.3.1 如何创建一个MDI框架？ 还记得MDI吗？许多人都不记得了。MDI是微软90年代初的创新，它使得 一个应用程序中的多个子窗口能被一个单一的父窗口控制，本质上为每个应用 235 / 565
- 237. 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() MDI的基本概念是十分简单的。父窗口是wx.MDIParentFrame的一个子 类，子窗口如同任何其它的wxPython窗口部件一样被添加，除了它们是 wx.MDIChildFrame的子类。wx.MDIParentFrame的构造函数与wx.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.MDIChildFrame的构造函数是相同的，除了它没有滚动条。如例8.8所 示，添加一个子框架是通过创建一个以父框架为父亲的框架来实现的。 你可以通过使用父框架的Cascade()或Tile()方法来同时改变所有子框架的位 置和尺寸，它们模拟相同名字的菜单项。调用Cascade()，导致一个窗口显示在 其它的上面，如图8.7的所示，而Tile()使每个窗口有相同的尺寸并移动它们以 使它们不重叠。要以编程的方式在子窗口中移动焦点，要使用父亲的方法 ActivateNext()和ActivatePrevious() 237 / 565
- 238. 8.3.2 什么是小型框架，我们为何要用它？ 小型框架是一个有两个例外的矩形框架：它有一个较小的标题区域，并且 在微软的Windows下或GTK下，它不在任务栏中显示。图8.8显示了一个较小标 题域的一个例子。 图8.8 一个小型框架 创建小型框架的代码基本上等同于创建一个矩形框架，唯一的不同是父类 是wx.MiniFrame。例8.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
- 239. app.MainLoop() wx.MiniFrame的构造函数等同于wx.Frame的，然而，wx.MiniFrame支持额 外的样式标记。如表8.8所示。 表8.8 wx.MiniFrame的样式标记 wx.THICK_FRAME：在Windows或Motif下，使用粗边框绘制框架。 wx.TINY_CAPTION_HORIZONTAL：代替wx.CAPTION而显示一个较小的水平标 题。 wx.TINY_CAPTION_VERTICAL：代替wx.CAPTION而显示一个较小的垂直标题。 典型的，小型框架被用于工具框窗口中，在工具框窗口中始终是有效的， 它们不影响任务栏。较小的标题使得它们更有效的利用空间，并且明显地区别 于标准的框架。 8.3.3 如何创建一个非矩形的框架？ 在大多数应用程序中，框架都是矩形，因为矩形有一个不错的规则的形 状，并且绘制和维护相对简单。可是，有时候你需要打破直线的制约。在 wxPython中，你可以给框架一个任一的形状。如果一个备用的形状被定义了， 那么框架超出该形状的部分不将被绘制，并且不响应鼠标事件；对于用户而 言，它们不是框架的一部分。图8.9显示了一个非矩形的窗口，显示的背景是文 本编辑器中的代码。 事件被设置来以便双击时开关这个非标准形状，鼠标右键单击时关闭这个 窗口。这个例子使用了来自wxPython demo的images模块作为vippi的图像的资 源，wxPython的吉祥物。 239 / 565
- 241. 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模块得到图像后，我们将窗口内部的尺寸设置为位图的尺 寸。你也可以根据一个标准的图像文件来创建这个wxPython位图，这将在第16 章中作更详细的讨论。 #2 这里，我们在窗口中绘制这个图像。这决不是一个必然的选择。你可以 像其它窗口一样在该形状窗口中放置窗口部件和文本（尽管它们必须在该形状 的区域内）。 #3 这个事件在大多数平台上是多余的，它强制性地在窗口被创建后调用 SetWindowShape()。但是，GTK的实现要求在该形状被设置以前，窗口的本地 241 / 565
- 242. UI对象被创建和确定，因此当窗口创建发生时我们使用窗口创建事件去通知并 在它的处理器中设置形状。 #4 我们使用全局方法wx.RegionFromBitmap去创建设置形状所需的 wx.Region对象。这是创建不规则形状的最容易的方法。你也可以根据一个定义 多边形的点的列表来创建一个wx.Region。图像的透明部分的用途是定义区域的 边界。 #5 双击事件开关窗口的形状。要回到标准的矩形，要使用一个空的 wx.Region作为参数来调用SetShape()。 除了没有标准的关闭框或标题栏等外，不规则形状框架的行为像一个普通 的框架一样。任何框架都可以改变它的形状，因为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
- 244. 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
- 245. 当你有两个信息面板并且想让用户自主决定每个面板的尺寸时，可以使用 分割窗。Mac OS X Finder窗口就是一个分割窗的例子，并且许多的文本编辑器 或制图软件都用它来维护一个打开的文件的列表。 8.4.1 创建一个分割窗 在wxPython中，分割窗是类wx.SplitterWindow的实例。和大多数其它的 wxPython窗口部件不一样，分隔窗口在被创建后，可使用前要求进一步的初始 化。它的构造函数是十分简单的。 图8.10 wx.SplitterWindow(parent, id=-1, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.SP_3D, name=”splitterWindow”) 它的这些参数都有标准的含义——parent是窗口部件的容器，pos是窗口部 件在它的父容器中位置，size是它的尺寸。 245 / 565
- 246. 在创建了这个分割窗后，在它可以被使用前，你必须对这个窗口调用三个 方法中的一处。如果你想初始时只显示一个子窗口，那么调用 Initialize(window)，参数window是这个单一的子窗口（通常是一种wx.Panel）。 在这种情况下，窗口将在以后响应用户的动作时再分割。 要显示两个子窗口，使用 SplitHorizontally (window1，window2，sashPosition=0)或 SplitVertically(window1, window2, sashPosition=0)。两个方法的工作都是相似 的，参数window1和window2包含两个子窗口，参数sashPosition包含分割条的 初始位置。对于水平分割（水平分割条）来说，window1被放置在window2的 顶部。如果sashPosition是一个正数，它代表顶部窗口的初始高度（也就是分割 条距顶部的像素值）。如果sashPosition是一个负数，它定义了底部窗口的尺 寸，或分割条距底部的像素值。如果sashPosition是0，那么这个分割条位于正 中。对于垂直分割（垂直分割条），window1位于左边，window2位于右边。 正值的sashPosition设置window1的尺寸，也就是分割条距左边框的像素值。类 似的，负值sashPosition设置右边子窗口的尺寸，0值将分割条放置在正中。如 果你的子窗口复杂的话，我们建议你在布局中使用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
- 249. 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() 分割窗只能分割一次，对已分割的窗口再分割将会失败，从而导致分割方 法返回False（成功时返回True）。要确定窗口当前是否被分割了，调用方法 IsSplit()。在例8.12中，为了确保相应的菜单项有效，就采用这个方法。 如果你想不分割窗口，那么使用Unsplit(toRemove=None)。参数toRemove 是实际要移除的wx.Window对象，并且必须是这两个子窗口中的一个。如果 toRemove是None，那么底部或右部的窗口将被移除，这根据分割的方向而定。 默认情况下，被移除的窗口是没有被wxPython删除的，所以以后你可以再把它 添加回来。unsplit方法在取消分割成功时返回True。如果分割窗当前没有被分 割，或toRemove参数不是两个子窗口中的一个，那么该方法返回False。 要确保你对想要的子窗口有一个正确的引用，那么使用GetWindow1()和 GetWindow2()方法。GetWindow1()方法返回顶部或左边的子窗口，而 GetWindow2()方法返回底部或右边的窗口。由于没有一个直接的设置方法来改 变一个子窗口，所以使用方法ReplaceWindow(winOld, winNew)，winOld是你要 替换的wx.Window对象，winNew是要显示的新窗口。 8.4.3 改变分割的外观 有许多样式标记用来控制显示在屏幕上的分割窗的外观。注意，由于分割 与平台有关，所以不是所有列出的标记都将对任何平台起作用。表8.9说明了这 些有效的标记。 我们将在接下来的部分看到，你也可以用你的程序来改变分割的显示，以 响应用户的动作或你自己的要求。 249 / 565
- 250. 表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 XP系统下，分割条不使用XP的主题样式， 它给窗口一个更经典的外观。 wx.SP_PERMIT_UNSPLIT：如果设置了这个样式，那么窗口始终不被分割。如果不 设置，你可以通过设置大于0的最小化的窗格尺寸来防止窗口被分割。 8.4.4 以程序的方式处理分割 一旦分割窗被创建，你就可以使用窗口的方法来处理分割条的位置。特别 是，你可以使用方法SetSashPosition(position,redraw=True)来移动分割 条。position是以像素单位的新的位置，它是分割条距窗口顶部或左边的距离。 用在分割方法中的负值，表示位置从底部或右边算起。如果redraw为True，则 窗口立即更新。否则它等待常规窗口的刷新。如果你的像素值在范围外的话， 设置方法的行为将不被定义。要得到当前分割条的位置，使用GetSashPosition() 方法。 在默认的分割行为下，用户可以在两个边框间随意移到分割条。移动分割 条到一边，使得别一子窗口的尺寸为0，这导致窗口此时成未分割状态。要防 止这种情况，你可以使用方法SetMinimumPaneSize(paneSize)来指定子窗口的最 小尺寸。paneSize参数是子窗口的最小像素尺寸。这样，用户就不能通过拖放 来使子窗口更小，程序同样也不能使子窗口更小。如前所述，你可以使用 wx.SP_PERMIT_UNSPLIT样式来达到相同的效果。要得到当前最小子窗口尺 寸，使用方法GetMinimumPaneSize()。 250 / 565
- 251. 改变窗口的分割模式，使用方法SetSplitMode(mode)，参数mode取下列常 量值之一：wx.SPLIT_VERTICAL、wx.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
- 252. 8.5 本章小结 1、wxPython中的大部分用户交互都发生在wx.Frame或wx.Dialog 中。wx.Frame代表用户调用的窗口。wx.Frame实例的创建就像其它的wxPython 窗口部件一样。wx.Frame的典型用法包括创建子类，子类通过定义子窗口部 件，布局和行为来扩展基类。通常，一个框架包含只包含一个wx.Panel的顶级 子窗口部件或别的容器窗口。 2、这儿还有各种特定于wx.Frame的样式标记。其中的一些影响框架的尺 寸和形状，另一些影响在系统中相对于其它的框架，它将如何被绘制，还有一 些定义了在框架边框上有那些界面装饰。在某种情况下，定义一个样式标记需 要“两步”的创建过程。 3、通过调用Close()方法可以产生关闭框架的请求。这给了框架一个关闭 它所占用的资源的机会。框架也能否决一个关闭请求。调用Destroy()方法将迫 使框架立即消失而没有任何延缓。 4、框架中的一个特定的子窗口部件可以使用它的wxPython ID、名字或它 的文本标签来发现。 5、通过包括wx.ScrolledWindow类的容器部件可以实现滚动。这儿有几个 方法来设置滚动参数，最简单的是在滚动窗口中使用sizer，在这种情况 下，wxPython自动确定滚动面板的虚拟尺寸（virtual size）。如果想的话，虚 拟尺寸可以被手动设置。 6、这儿有一对不同的框架子类，它们允许不同的外观。类 wx.MDIParentFrame可以被用来创建MDI，而wx.MiniFrame可以创建一个带有 较小标题栏的工具框样式的窗口。使用SetShape()方法，框架可以呈现出非矩形 的形状。形状的区域可以被任何位图定义，并使用简单的颜色掩码来决定区域 的边缘。非矩形窗口通常没有标准的标题栏，标题栏使得框架可以被拖动， 但 这可以通过显式地处理鼠标事件来管理。 7、位于两个子窗口间的可拖动的分割条能够使用wx.SplitterWindow来实 现，分割条可以被用户以交互的方式处理，或以编程的方式处理（如果需要的 话）。 在下一章，我们将讨论对话框，它的行为类似于框架。 252 / 565
- 253. 9、对话框 9.1 使用模式对话框工作 模式对话框用于与用户进行快速的交互或在用户可以执行程序的下一步之 前，对话框中的信息必须被输入的时候。在wxPython中，有几个标准的函数用 来显示基本的模式对话框。这些对话框包括警告框，单行文本域，和从列表中 选择。在随后的部分，我们将给你展示这些对话框，以及如何使用这些预定义 的函数来减轻你的工作量。 9.1.1 如何创建一个模式对话框？ 模式对话框阻塞了别的窗口部件接收用户事件，直到该模式对话框被关 闭；换句话说，在它存在期间，用户一直被置于对话模式中。如图9.1所示，你 不能总是根据外观来区别对话框和框架。在wxPython中，对话框与框架间的区 别不是基于它们的外观的，而主要是它们处理事件的办法的实质。 图9.1 一个模式对话框 对话框的创建和配置与框架稍微有些不同。例9.1显示了产生图9.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
- 254. 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.Dialog，而非wx.Panel。面板在对话框中的使 用比在框架中少的多，部分原因是因为对话框与框架相比倾向简单化，但主要 是因为wx.Panel特性（标准系统背景和tab键横向切换控件焦点）已经默认存在 于wx.Dialog中。 要显示为模式对话框，使用ShowModal()方法。这与用于框架的的Show() 方法在对程序的执行上有不同的作用。在调用ShowModal()后你的应用程序将 处于等待中，直到对话框被取消。 模式将保持到对话框方法EndModal(retCode)被调用，该方法关闭对话框。 参数retCode是由ShowModal()方法返回的一个整数值。典型的，应用程序利用 这个返回值来知道用户是如何关闭对话框的，以控制以后的操作。但是结束这 个模式并没有销毁或甚至关闭对话框。保持对话框的存在可能是一件好事，因 为这意味你可以把用户选择的信息存储为对话框实例的数据成员，并且即使在 对话框被关闭后也能从对话框重新获得那些信息。在接下来的部分，我们将看 一些我们使用对话框处理程序中用户输入的数据的例子。 由于例9.1中没有定义事件处理器，你可能会惊奇对话框是如何响应按钮敲 击的。这个行为已经定义在wxDialog中了。有两个预定义的wxPython ID号，它 们在对话框中有特殊的意思。当对话框中的一个使用wx.ID_OK ID的wx.Button 被敲击时，模式就结束了，对话框也关闭了，wx.ID_OK就是ShowModal()调用 返回的值。同样，一个使用wx.ID_CANCEL ID的按钮做相同的事情，但是 ShowModal()的返回值是wx.ID_CANCEL。 254 / 565
- 255. 例9.1显示了处理模式对话框的一个典型的方法。在对话框被调用后，返回 值被用作if语句中的测试。在这种情况下，我们简单地打印结果，在更复杂的 例子中，wx.ID_OK将执行用户在对话框中所要求的动作，如打开文件或选择 颜色。 典型的，你在完成对对话框的使用后，你应该显式地销毁它。这通知C+ +对象它应该自我销毁，然后这将使得它的Python部分被作为垃圾回收。如果你 希望在你的应用程序中，以后再次使用该对话框时不重建它，以加速对话框的 响应时间，那么你可以保持对该对话框的一个引用，并当你需要再次激活它 时，简单地调用它的ShowModal()方法。当应用程序准备退出时，确保已销毁 了它，否则MainLoop()将仍将它作为一个存在的顶级窗口，并且程序将不能正 常退出。 9.1.2 如何创建一个警告框？ 经由一个对话框与用户交互的最简单的三个办法分别是： wx.MessageDialog，它是一个警告框、wx.TextEntryDialog，它提示用户去输入 一些短的文本、wx.SingleChoiceDialog，它使用户能够从一个有效选项列表中 进行选择。在接下来的三个小节中，我们将论这些简单的对话框。 消息对话框显示一个短的消息，并使用户通过按下按钮来作响应。通常， 消息框被用作去显示重要的警告、yes/no问题、或询问用户是否继续某种操 作。图9.2显示了一个典型的消息框。 图9.2 使用消息框是十分的简单。例9.2显示了创建一个消息框的两种办法。 255 / 565
- 256. 例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.MessageDialog的一个实例，并使用ShowModal()来显示它。 使用wx.MessageDialog类 使用wx.MessageDialog的构造函数，你可以设置对话框的消息和按钮，构 造函数如下： wx.MessageDialog(parent, message, caption=”Message box”, style=wx.OK | wx.CANCEL, pos=wx.DefaultPosition) message参数是实际显示在对话框中的文本。如果消息字符串包含n字符， 那么文本将在此换行。caption参数显示在对话框的标题栏中。pos参数使你可以 指定对话框显示在屏幕上的位置——在微软Windows下，这个参数将被忽略。 wx.MessageDialog的样式标记分为两类。第一类控制显示在对话框中的按 钮。表9.1说明了这些样式。 256 / 565
- 257. 表9.1 wx.MessageDialog的按钮样式 wx.CANCEL：包括一个cancel（取消）按钮。这个按钮有一个ID值 wx.ID_CANCEL。 wx.NO_DEFAULT：在一个wx.YES_NO对话框中，No（否）按钮是默认的。 wx.OK：包括一个OK按钮，这个按钮有一个ID值wx.ID_OK。 wx.YES_DEFAULT：在一个wx.YES_NO对话框中，Yes按钮是默认的。这是默认行 为。 wx.YES_NO：包括Yes和No按钮，各自的ID值分别是wx.ID_YES和wx.ID_NO。 第二套样式标记控制紧挨着消息文本的图标。它们显示在表9.2中。 表9.2 wx.MessageDialog的图标样式 wx.ICON_ERROR：表示一个错误的图标。 wx.ICON_EXCLAMATION：表示警告的图标。 wx.ICON_HAND：同wx.ICON_ERROR。 wx.ICON_INFORMATION：信息图标，字母i。 wx.ICON_QUESTION：问号图标。 最后，你可以使用样式wx.STAY_ON_TOP将对话框显示在系统中任何其它 窗口的上面，包括系统窗口和wxPython应用程序窗口。 你在例9.2所见到的，对话框通过使用ShowModal()被调用。根据所显示的 按钮，返回的结果是以下值之一： wx.ID_OK, wx.ID_CANCEL，wx.ID_YES, 或 wx.ID_NO。如同其它对话框的情 况，你通常使用这些值来控制程序的执行。 使用wx.MessageBox()函数 例9.2中的#1显示了一个调用消息框的更简短的方法。这个便利的函数 wx.MessageBox()创建对话框，调用ShowModal()，并且返回下列值之一： wx.YES, wx.NO, wx.CANCEL, 或 wx.OK。函数的形式比MessageDialog的构造 函数更简单，如下所示： 257 / 565
- 258. wx.MessageBox(message, caption=”Message”, style=wx.OK) 在这个例子中，参数message, caption, style的意思和构造函数中的相同，你 可以使用所有相同的样式标记。正如我们贯穿本章将看到的，在wxPython预定 义的几个对话框都有便利的函数。在你为单一的使用创建对话框的时候，你的 选择有一个优先的问题。如果你计划束缚住对话框以便多次调用它，那么你可 能会优先选择去实例化对象以便你能够束缚该引用，而不使用函数的方法，尽 管这对于这些简单的对话框来说，所节约的时间可以忽略不计。 要在你的消息框中显示大量的文本（例如，终端用户许可证的显示），你 可以使用wxPython特定的类wx.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.3显示了产生图9.3的代码 258 / 565
- 259. 例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) message参数是显示在对话框中的文本提示，而caption显示在标题栏 中。defaultValue显示在文本框中的默认值。style可以包括wx.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
- 260. 下面这些是使用文本对话框的便利函数： 1、wx.GetTextFromUser() 2、wx.GetPasswordFromUser() 3、wx.GetNumberFromUser() 其中和例9.3的用处最近似的是wx.GetTextFromUser()： wx.GetTextFromUser(message, caption=”Input text”, default_value=””, parent=None) 这里的message, caption, default_value, 和 parent与wx.TextEntryDialog的构造 函数中的一样。如果用户按下OK，该函数的返回值是用户所输入的字符串。 如果用户按下Cancel，该函数返回空字符串。 如果你希望用户输入密码，你可以使用wx.GetPasswordFromUser()函数： wx.GetPasswordFromUser(message, caption=”Input text”, default_value=””, parent=None) 这里的参数意义和前面的一样。用户的输入被显示为星号，如果用户按下 OK，该函数的返回值是用户所输入的字符串。如果用户按下Cancel，该函数返 回空字符串。 最后，你可以使用wx.GetNumberFromUser()要求用户输入一个数字： wx.GetNumberFromUser(message, prompt, caption, value, min=0, max=100, parent=None) 这里的参数的意义有一点不同，message是显在prompt上部的任意长度的消 息，value参数是默认显示在文本框中的长整型值。min和max参数为用户的输 入限定一个范围。如果用户按下OK按钮退出的话，该方法返回所输入的值， 并转换为长整型。如果这个值不能转换为一个数字，或不在指定的范围内，那 么该函数返回-1，这意味如果你将该函数用于负数的范围的话，你可能要考虑 一个转换的方法。 260 / 565
- 261. 9.1.4 如何用对话框显示选项列表？ 如果给你的用户一个空的文本输入域显得太自由了，那么你可以使用 wx.SingleChoiceDialog来让他们在一组选项中作单一的选择。图9.4显示了一个 例子。 图9.4 一个单选对话框 例9.4显示了产生图9.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: %sn” % 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
- 262. message和caption参数的意义与前面的一样，分别显示在对话框和标题栏 中。choices参数要求一个字符串的列表，它们是你呈现在对话框中的选 项。style参数有三个项，这是默认的，分别是OK按钮、Cancle按钮和使对话框 在屏幕中居中。centre选项和pos参数在Windows操作系统上不工作。 如果你想在用户看见对话框之前，设置它的默认选项，使用 SetSelection(selection)方法。参数selection是选项的索引值，而非实际选择的字 符串。在用户选择了一个选项后，你即可以使用GetSelection()——它返回所选 项的索引值，也可以使用GetStringSelection()——它返回实际所选的字符串，来 得到它。 有两个用于单选对话框的便利函数。第一个是wx.GetSingleChoice，它返回 用户所选的字符串： wx.GetSingleChoice(message, caption, aChoices, parent=None) 参数message, caption, 和parent的意义和wx.SingleChoiceDialog构造函数的 一样。aChoices参数是选项的列表。如果用户按下OK，则返回值是所选的字符 串，如果用户按下Cancel，则返回值是空字符串。这意味如果空字符是一个有 效的选择的话，那么你就不该使用这个函数。 第二个是wx.GetSingleChoiceIndex: wx.GetSingleChoiceIndex(message, caption, aChoices, parent=None) 这个函数与第一个有相同的参数，但是返回值不同。如果用户按下OK， 则返回值是所选项的索引，如果用户按下Cancel，则返回值是-1。 9.1.5 如何显示进度条？ 在许多程序中，程序需要自己做些事情而不受用户输入的干扰。这时就需 要给用户一些可见的显示，以表明程序正在做一些事情及完成的进度。在 wxPython中，这通常使用一个进度条来管理，如图9.5所示。 262 / 565
- 263. 图9.5 例9.5显示了产生图9.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) 这些参数不同于其它对话框的。参数title被放置在窗口的标题栏，message 被显示在对话框中。maximum是你用来显示进度计数的最大值。 263 / 565
- 264. 表9.3 列出了特定于wx.ProgressDialog六个样式，它们影响进度条的行为。 表9.3 wx.ProgressDialog的样式 wx.PD_APP_MODAL：如果设置了这个样式，进度条对整个应用程序是模式的，这 将阻塞所有的用户事件。如果没有设置这个样式，那么进度条仅对它的父窗口是模式 的。 wx.PD_AUTO_HIDE：进度条将自动隐藏自身直到它达到它的最大值。 wx.PD_CAN_ABORT：在进度条上放上一个Cancel按钮，以便用户停止。如何响应 来自该对话框的取消将在以后说明。 wx.PD_ELAPSED_TIME：显示该对话框已经出现了多长时间。 wx.PD_ESTIMATED_TIME：显示根据已花的时间、当前的计数值和计数器的最大值 所估计出的完成进度所需的总时间。 wx.PD_REMAINING_TIME：显示要完成进度所估计的剩余时间，或(所需总时间-已 花时间)。 要使用进度条，就要调用它的唯一的方法Update(value,newmsg=””)。value 参数是进度条的新的内部的值，调用update将导致进度条根据新的计数值与最 大计算值的比例重绘。如果使用可选的参数newmsg，那么进度条上的文本消息 将变为该字符串。这让你可以给用户一个关于当前进度的文本描述。 这个Update()方法通常返回True。但是，如果用户通过Cancel按钮已经取消 了该对话框，那么下次的Update()将返回False。这是你响应用户的取消请求的 机会。要检测用户的取消请求，我们建议你尽可能频繁地Update()。 9.2 使用标准对话框 大多数操作系统都为像文件选择、字体选择和颜色选择这些任务提供了标 准对话框。这为平台提供了一致感观。你也可以使用来自于wxPython的这些对 话框，它们也为你的应用程序提供了一致的感观。如果你使用wxPython，那么 它为你提供了类似的对话框，即使所在的平台没有提供系统对话框。 9.2.1 如何使用文件选择对话框？ 在wxPython中，wx.FileDialog为主流的平台使用本地操作系统对话框，对 其它操作系统使用非本地相似的外观。微软Windows的版本如图9.6所示。 264 / 565
- 266. 文件对话框是我们这章已见过的最复杂的对话框，它有几个属性可以通过 编程的方式读写。它的构造函数使得你能够设置它的一些属性： wx.FileDialog(parent, message=”Choose a file”, defaultDir=””, defaultFile=””, wildcard=”*.*”, style=0, pos=wx.DefaultPosition) message参数出现在窗口的标题栏中。defaultDir参数告诉对话框初始的时 候显示哪个目录。如果这个参数为空或表示的目录不存在，那么对话框开始在 当前目录。defaultFile是默认保存为的文件。wildcard参数使你可以基于给定的 模式来过滤列表，使用通常的*和?作为通配符。通配符可以是单个模式，如 *.py或格式如<描述>|<模式>|<描述>|<模式>的一系列模式——类似于例9.6中所 用。 “Python source (*.py)|*.py|Compiled Python (*.pyc)|*.pyc| All files (*.*)|*.*” 如果有一个多个项目的模式，那么它们显示在图9.6所示的下拉菜单 中。pos参数不保证被基本的系统所支持。 选择一个文件 wx.FileDialog的两个最重要的样式标记是wx.OPEN和wx.SAVE，它们表明 对话框的类型并影响对话框的行为。 用于打开文件的对话框有两个标记，它们进一步影响对话框的行 为。wx.HIDE_READONLY标记灰化复选框，使用户以只读模式打开文 件。wx.MULTIPLE标记使用户可以在一个目录中选择打开多个文件。 保存文件对话框有一个有用的标记wx.OVERWRITE_PROMPT，它使得保 存文件时，如果有相同的文件存在，则提示用户是否覆盖。 两种文件对话框都可以使用wx.CHANGE_DIR标记。当使用这个标记时， 文件的选择也可改变应用程序的工作目录为所选文件所在的目录。这使得下次 文件对话框打开在相同的目录，而不需要应用程序再在别处存储该值。 和本章迄今为止我人们所见过的其它对话框不一样，文件对话框的属性 directory，filename, style, message, 和wildcard是可以通过方法来得到和设置的。 这些方法使用Get/Set命名习惯。 266 / 565
- 267. 在用户退出对话框后，如果返回值是wx.OK，那么你可以使用方法 GetPath()来得到用户的选择，该函数的返回值是字符串形式的文件全路径名。 如果对话框是一个使用了wx.MULTIPLE标记的打开对话框，则用GetPaths()代 替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参数意义与构造函数的基 本相同，尽管参数的名字不同。flags参数通常被称作style，default_extension参 数是保存为文件时默认的后缀（如果用户没有指定后缀的情况下）。如果用户 按下OK，返回值是字符串形式的路径名，如果用户按下Cancel则返回一个空字 符串。 选择一个目录 如果用户想去选择一个目录而非一个文件，使用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
- 268. 图9.7 这个对话框的所有的功能几乎都在构造函数中： wx.DirDialog(parent, message=”Choose a directory”, defaultPath=””, style=0, pos = wx.DefaultPosition, size = wx.DefaultSize, name=”wxDirCtrl”) 由于message参数显示在对话框中，所以你不需要一个钩子去改变标题 栏。defaultPath告诉对话框选择的默认路径，如果它为空，那么对话框显示文 件系统的根目录。pos和size参数在微软Windows下被忽略，name参数在所有的 操作系统下都被忽略。该对话框的样式标记wx.DD_NEW_DIR_BUTTON给对 话框一个用于创建目录的一个按钮。这个标记在老版的微软Windows中不工 作。 wx.DirDialog类的path, message, 和style属性都有相应的get*和set*方法。你 可以使用GetPath()方法来在对话框被调用后获取用户的选择。这个对话框也有 一个便利的函数： wx.DirSelector(message=wx.DirSelectorPromptStr, default_path=””, style=0, pos=wxDefaultPosition, parent=None) 所有的参数和前面的构造函数相同。如果OK被按下，则该函数返回所选 择的字符串形式的目录名，如果按下Cancel，则返回空字符串。 268 / 565
- 269. 9.2.2 如何使用字体选择对话框？ 在wxPython中，字体选择对话框与文件对话框是不同的，因为它使用了一 个单独的帮助类来管理它所呈现的信息。图9.8显示了微软Windows版的字体对 话框。 例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 pointsn’ % ( font.GetFaceName(), font.GetPointSize()) dialog.Destroy() 图9.8 269 / 565
- 270. wx.FontDialog 的构造函数比前面的那些简单的多： wx.FontDialog(parent, data) 你不能为该对话框设置一个消息或标题，并且被通常作为样式标记传递的 信息被包含在data参数中，该参数是类wx.FontData。wx.FontData类自己只有一 个有用的方法：GetFontData()，该方法返回字体数据的实例。 wx.FontData的实例使你能够设置管理字体对话框显示的值，并且也能够容 纳用户输入的信息。例如，在例9.8中的代码调用了wx.FontData实例的两个get* 方法来确定所选字体的细节。wx.FontData的构造函数没有参数——所有的属性 必须通过使用表9.4中的方法来设置。 表9.4 wx.FontData的方法 GetAllowSymbols() SetAllowSymbols(allowSymbols)：决定是否在对话框中仅显示符号字体（如 dingbats）。参数是布尔值。只在Windows中有意义。该属性的初始值是True。 GetChosenFont() SetChosenFont(font)：以wx.Font对象的方式返回用户所选的字体。如果用户选择了 取消，那么返回None。wx.Font类将在第12章作更详细的讨论。 GetColour() SetColour(colour)：返回在对话框的颜色选择部分所选的颜色。set*方法使你可以预 先设定默认值。get*方法返回一个wx.Colour实例。set*方法中的colour只能是一个 wx.Colour或一个颜色的字符串名。该属性的初始值是black。 GetEnableEffects() EnableEffects(enable)：在该对话框的Windows版本中，该属性控制是否显示字体的 所选颜色、中间是否有直线通过、是否带下划线等特性。 GetInitialFont() SetInitialFont(font)：返回对话框初值的字体值（即当前所用的字体）。这个属性可 以在对话框显示之前通过应用程序显式的来设置。它的初始值是None。 SetRange(min, max)：设置字体尺寸（磅）的有效范围。仅用于微软的Windows系 统。最初值是0~0，意味没有范围的限制。 GetShowHelp() SetShowHelp()：如果为True，那么该对话框的微软Windows版本将显示一个帮助按 钮。初始值为False。 270 / 565
- 271. 有一个使用字体对话框的便利的函数，它回避了wx.FontData类： wx.GetFontFromUser(parent, fontInit) fontInit参数是wx.Font的一个实例，它用作对话框的初始值。该函数的返回 值是一个wx.Font实例。如用户通过OK关闭了对话框，则方法wx.Font.Ok()返回 True，否则返回False。 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: %sn’ % str(data.GetColour().Get()) dialog.Destroy() 271 / 565
- 272. 图9.9 用于颜色选择器的wxPython的类是wx.ColourDialog。它的构造函数很简 单，没有太多的参数： wx.ColourDialog(parent, data=None) data参数是类wx.ColourData的实例，它比相应字体的更简单。它只包含默 认的没有参数的构造函数和后面的三个属性： 1、GetChooseFulłSetChooseFull(flag)：仅在微软Windows下工作。当设置 后，将显示完整的对话框，包括自定义颜色选择器。如果不设置，则自定义颜 色选择器不被显示。 2、GetColour/SetColour(colour)：当图表被关闭后，调用get*来看用户的选 择。最初它被设置为black。如果在对话框显示之前设置了它，那么对话框最初 显示为该颜色。 3、GetCustomColour(i)/SetCustomColour(i, colour)：根据自定义的颜色数组 中的索引i来返回或设置元素。i位于[0,15]之间。初始时，所有的自定义颜色都 是白色。 一个回避了wx.ColorData的使用颜色对话框的便利函数是： wx.GetColourFromUser(parent, colInit) 272 / 565
- 273. colInit是wx.Colour的一个实例，并且当对话框显示时它是对话框的初始的 值。函数的返回值也是一个wx.Colour的实例。如果用户通过OK关闭了对话 框，那么方法wx.Colour.OK()返回True。如果用户通过Cancel关闭了对话框，那 么方法wx.Colour.OK()返回False。 9.2.4 如何使用户能够浏览图像？ 如果你在你的程序中做图形处理，那么在他们浏览文件树时使用缩略图是 有帮助的。用于该目的的wxPython对话框被称为 wx.lib.imagebrowser.ImageDialog。图9.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
- 274. wx.lib.imagebrowser.ImageDialog类是十分简单的，并有相对较少的选项供 程序员去设置。要改变该对话框的行为的话，请查阅改变显示的文件类型的 Python源码。类的构造函数要求两个参数。 ImageDialog(parent, set_dir=None) set_dir参数是对话框显示时所在的目录。如果不设置，那么使用应用程序 当前的工作目录。在对话框被关闭后，GetFile()返回所选文件的完整路径字符 串，GetDirectory()只返回目录部分。 9.3 创建向导 向导是一系列被链接在一起的简单对话框，它使得用户一步步地跟随它 们。通常它们被用于指导用户的安装或一个复杂的配置过程。图9.11显示了一 个向导示例。 图9.11 在wxPython中，一个向导是一系列的页面，它由类wx.wizard.Wizard的一 个实例控制。向导实例管理用户的页面切换事件。这些页面自身也是类 wx.wizard.WizardPageSimple或wx.wizard.WizardPage的实例。这两种类的实 例，它们只不过是附加了必要的管理页面链接逻辑的wx.Panel的实例。已证明 这两个实例之间的区别仅当用户按下Next按钮时。wx.wizard.WizardPage的实例 274 / 565
- 276. 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, pos和wx.Panel的意义相同。如果设置了bitmap参 数，那么该参数将显示在每一页上。这儿只有一个样式标记： wx.wizard.WIZARD_EX_HELPBUTTON，它显示一个帮助按钮。这是一个扩展 的标记，需要使用第8章所说的两步创建过程。 通常，你将调用例9.11的#3中所示的FitToSize()来管理窗口的尺寸，但是你 也可以通过调用带有一个元组或wx.Size实例的SetPageSize()来设置一个最小的 尺寸。GetPageSize()方法返回当前的尺寸，在这两种情况下，该尺寸仅用于对 话框中的单个的页面部分，而作为一个整体的对话框将更大一些。 你可以管理该类中的页面。方法GetCurrentPage()返回当前被显示的页面， 如果该向导当前没有被显示，该方法返回None。你可以通过调用HasNextPage() 和HasPrevPage()来确定当前页是否有下一页或上一页。 276 / 565
- 277. 使用RunWizard()来运行该向导，如例9.11中#4的说明。 向导产生的命令事件如表9.5所示，你可以捕获这些事件，以便作专门的处 理。这些事件对象属于类wx.wizard.WizardEvent，它们提供了两个可用的方 法。GetPage()返回wx.WizardPage的实例，该实例在向导事件产生时是有效，而 非作为事件结果被显示的实例。如果事件是前进一页，那么GetDirection()返回 True，如果事件是后退一页，那么GetDirection()返回False。 表9.5 wx.wizard.WizardDialog的事件 EVT_WIZARD_CANCEL：当用户按下Cancel按钮时产生。该事件可以使用Veto()来 否决，这种情况下，对话框将不会消失。 EVT_WIZARD_FINISHED ：当用户按下Finish按钮时产生。 EVT_WIZARD_HELP：当用户按下Help按钮时产生。 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参数被设置了，那么该参数覆盖父向导中所设置的位 图。resource参数从一个wxPython资源装载页面。要处理页面逻辑，就要覆盖 277 / 565
- 278. GetPrev()和GetNext()方法来返回你想要向导下一步的位置。该类的一个典型的 用法是根据用户对当前页的响应动态地决定接下来的页面。 9.4 显示启动提示 许多应用程序都使用启动提示来作为一种向用户介绍该程序的特性等信息 的方法。在wxPython中有一个非常简单的机制用来显示启动提示。图9.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
- 279. filename是包含提示字符串的文件的名字。currentTip是该文件中用于一开 始显示的提示字符的索引，该文件中的第一个提示字符串的索引是0。 提示文件是一个简单的文本文件，其中的每一行是一个不同的提示。空白 行被忽略，以#开始的行被当作注释并也被忽略。下面是上例所使用的提示文 件中的内容： You can do startup tips very easily. Feel the force, Luke. 提示的提供者（provider）是类wx.PyTipProvider的一个实例。如果你需要 更细化的功能，你可以创建你自己的wx.TipProvider的子类并覆盖GetTip()函 数。 显示提示的函数是wx.ShowTip(): wx.ShowTip(parent, tipProvider, showAtStartup) parent是父窗口，tipProvider通常创建自 wx.CreateFileTipProvider。showAtStartup控制启动提示显示时，复选框是否被 选择。该函数的返回值是复选框的状态值，以便你使用该值来决定你的应用程 序下次启动时是否显示启动提示。 9.5 使用验证器（validator）来管理对话框中的数据 验证器是一个特殊的wxPython对象，它简化了对话框中的数据管理。当我 们在第三章中讨论事件时，我们简要的提及到如果一个窗口部件有一个验证 器，那么该验证器能够被事件系统自动调用。我们已经见过了几个wxPython窗 口部件类的构造函数中将验证器作为参数，但是我们还没有讨论它们。 验证器有三个不相关的功能： 1、在对话框关闭前验证控件中的数据 2、自动与对话框传递数据 3、验证用户键入的数据 9.5.1 如何使用验证器来确保正确的数据？ 验证器对象是wx.Validator的子类。父类是抽象的，不能直接使用。尽管在 C++ wxWidget集中有一对预定义的验证器类，但是在wxPython中，你需要定义 279 / 565
- 280. 你自己的验证器类。正如我们在别处所见的，你的Python类需要继承自Python 特定的子类：wx.PyValidator，并且能够覆盖该父类的所有方法。一个自定义的 验证器子类必须覆盖方法Clone()，该方法应该返回验证器的相同的副本。 一个验证器被关联到你的系统中的一个特定的窗口部件。这可以用两种方 法之一来实现。第一种方法，如果窗口部件许可的话，验证器可以被作为一个 参数传递给该窗口部件的构造函数。如果该窗口部件的构造函数没有一个验证 器参数，你仍然可以通过创建一个验证器实例并调用该窗口部件的 SetValidator(validator)方法来关联一个验证器。 要验证控件中的数据，你可以先在你的验证器子类中覆盖Validate(parent) 方法。parent参数是验证器的窗口部件的父窗口（对话框或面板）。如果必 要，可以使用这个来从对话框中其它窗口部件得到数据，或者你可以完全忽略 该参数。你可以使用self.GetWindow()来得到正在被验证的窗口部件的一个引 用。你的Validate(parent)方法的返回值是一个布尔值。True值表示验证器的窗口 部件中的数据已验证了。False表示有问题。你可以根据Validate()方法来使用 x.MessageBox()去显示一个警告，但是你不应该做其它的任何可以在wxPython 应用程序中引发事件的事情。 Validate()的返回值是很重要的。它在你使用OK按钮（该按钮使用 wx.ID_OK ID）企图关闭一个对话框时发挥作用。作为对OK按钮敲击处理的一 部分，wxPython调用对话框中有验证器的窗口部件的Validate()函数。如果任一 验证器返回False，那么对话框不将关闭。例9.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
- 283. app.MainLoop() #1 该方法测试基本的控件有无数据。如果没有，相应的控件的背景色变为 粉红色。 #2 这几行，对话框中的每个文本控件都关联一个验证器。 图9.13显示了一个文本域为空就企图关闭的对话框。 图9.13 明确地告诉对话框去核对验证器的代码没有出现在示例中，因为它是 wxPython事件系统的一部分。对话框与框架之间的另一区别是对话框有内建的 验证器行为，而框架没有。如果你喜欢将验证器用于不在对话框内的控件，那 么调用父窗口的Validate()方法。如果父窗口已设置了 wx.WS_EX_VALIDATE_RECURSIVELY额外样式，那么所有的子窗口的 Validate()方法也被调用。如果任一验证失败，那么Validate返回False。接下来， 我们将讨论如何将验证器用于数据传输。 9.5.2 如何使用验证器传递数据？ 验证器的第二个重要的功能是，当对话框打开时，它自动将数据传送给对 话框显示，当该对话框关闭时，自动从对话框把数据传输到一个外部资源。图 9.14显示了一个示例对话框。 283 / 565
- 284. 图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
- 287. 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
- 290. 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()方法来 被调用，它的返回值依据用户所按的按钮而定（OK或Cancel）。关闭模式对话 框并不会销毁它，该对话框的实例可以被再用。 3、在wxPython中有三个通用的简单对话框。wx.MessageDialog显示一个消 息对话框。wx.TextEntryDialog使用户能够键入文本，wx.SingleChoiceDialog给 用户一个基于列表项的选择。 4、当正在执行一个长时间的后台的任务时，你可以使用wx.ProgressDialog 来给用户显示进度信息。用户可以通过wx.FileDialog使用标准文件对话框来选 290 / 565
- 291. 择一个文件。可以使用wx.DirDialog来创建一个标准目录树，它使得用户可以 选择一个目录。 5、你可以使用wx.FontDialog和wx.ColorDialog来访问标准的字体选择器和 颜色选择器。在这两种情况中，对话框的行为和用户的响应是由一个单独的数 据类来控制的。 6、要浏览缩略图，可以使用wxPython特定的类 wx.lib.imagebrowser.ImageDialog。这个类使用户能够通过文件系统并选择一个 图像。 7、你可以通过使用wx.wizard.Wizard创建一个向导来将一组相关的对话框 表单链接起来。对话框表单是wx.wizard.WizardSimplePage或 wx.wizard.WizardPage的实例。两者的区别是，wx.wizard.WizardSimplePage的 页到页的路线需要在向导被显示之前就安排好，而wx.wizard.WizardPage使你能 够在运行时管理页到页的路线的逻辑。 8、使用wx.CreateFileTipProvider和wx.ShowTip函数可以很容易地显示启动 提示。 9、验证器是很有用的对象，如果输入的数据不正确的话，它可以自动阻 止对话框的关闭。他们也可以在一个显示的对话框和一个外部的对象之间传输 数据，并且能够实时地验证数据的输入。 291 / 565
- 292. 10、创建和使用wxPython菜单 本章内容包括： 创建菜单 使用菜单项工作 添加子菜单、弹出菜单和自定义菜单 菜单的设计准则 难以想象一个应用程序的顶部没有我们常见的以File和Edit开头，以Help结 尾的栏目。这太糟糕了。菜单是那些隐藏在背后并不太重视绘制的标准界面工 具的一个公共的部分，由于菜单使得用户能够快速而容易地访问所有的功能， 所以它实实在在是一个革命。 在wxPython中有三个主要的类，它们管理菜单的功能。类wx.MenuBar管理 菜单栏自身，而wx.Menu管理一个单独的下拉或弹出菜单。当然，一个 wx.MenuBar实例可以包含多个wx.Menu实例。类wx.MenuItem代表一个 wx.Menu中的一个特定项目。 在第二章中我们对菜单作了一个简要的介绍，在例5.5中我们提供了一个容 易创建菜单项的机制，在第7章中我对特殊的菜单效果作了一些介绍。在这一 章，我们将对wxPython菜单的创建和使用提供更多的细节。 10.1 创建菜单 首先，我们将讨论菜单栏。要使用一个菜单栏，就要执行下面这些行动： ·创建菜单栏 ·把菜单栏附加给框架 ·创建单个的菜单 ·把菜单附加给菜单栏或一个父菜单 ·创建单个的菜单项 ·把这些菜单项附加给适当的菜单 ·为每个菜单项创建一个事件绑定 上面行动的执行顺序可以灵活点，只要你在使用之前创建所有项目，并且 所有行动在框架的初始化方法中完成就可以了。在这个过程中你可以以后来处 理菜单，但是在框架可见后，你的执行顺序将影响用户所见到的东西。例如， 如果你在框架创建后将菜单栏附加给框架，或等到直到所有其它的过程完成 292 / 565
- 293. 了。考虑到可读性和维护的目的，我们推荐你将相关的部分分整理在一起。对 于如何组织菜单的创建的建议，请看第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.Menu只有一个有效的样式。在GTK下，样式wx.MENU_TEAROFF 使得菜单栏上的菜单能够被分开并作为独立的选择器。在其它平台下，这个样 式没有作用。如果平台支持，那么菜单被创建时可以有一个标题。图10.1显示 了一个带有三个菜单的空白窗口。例10.1显示了被添到一个菜单栏上的一系列 菜单，这些菜单没有被添加菜单项。 293 / 565
- 296. 10.1.3 如何给下拉菜单填加项目？ 这里有一对机制用于将新的菜单项添加给一个下拉菜单。较容易的是使用 wx.Menu的Append()方法： Append(id, string, helpStr=””, kind=wx.ITEM_NORMAL) 参数id是一个wxPython ID。参数string是将被显示在菜单上的字符串。当 某个菜单高亮时，如果设置了参数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
- 297. 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) 参数pos是菜单项要插入的位置的索引，所以如果索引为0，则新的项被放 置在开头，如果索引值为菜单的尺寸，那么新的项被放置在尾部。所以在插入 点后的菜单项将被向下移动。 297 / 565
- 298. 所有的这些插入方法都隐含地创建一个wx.MenuItem类的实例。你也可以 使用该类的构造函数显式地创建该类的一个实例，以便设置该菜单项的除了标 签以外的其它的属性。比如你可以设置自定义的字体或颜色。wx.MenuItem的 构造函数如下： wx.MenuItem(parentMenu=None, id=ID_ANY, text=””, helpString=””, kind=wx.ITEM_NORMAL, subMenu=None) 参数parentMenu必须是一个wx.Menu实例（如果设置了的话）。当构造 时，这个新的菜单项不是自动被添加到父菜单上显示的。你必须自己来实现。 这个行为与wxPython窗口部件和它们的容器的通常的行为不同。参数id是新项 的标识符。参数text是新项显示在菜单中的字符串，参数helpString是当该菜单 项高亮时显示在状态栏中的字符串。kind是菜单项的类 型，wx.ITEM_NORMAL代表纯菜单项；我们以后会看到开关菜单项有不同的 类型值。如果参数subMenu的值不是null，那么这个新的菜单项实际上就是一个 子菜单。我们不推荐你使用这个机制来创建子菜单；替而代之，可以使用在 10.3节中说明的机制来装扮你的菜单。 不像大多数窗口部件，创建菜单项并不将它添加到指定的父菜单。要将新 的菜单项添加到一个菜单中，使用下面的wx.Menu方法之一： ·AppendItem(aMenuItem) ·InsertItem(pos, aMenuItem) ·PrependItem(aMenuItem) 要从菜单中删除一个菜单项，使用方法Remove(id)，它要求一个 wxPython ID，或RemoveItem(item)，它要求一个菜单项作为参数。删除一个菜 单项后，后面的菜单项将上移。Remove()方法将返回所删除的实际的菜单项。 这使你能够存储该菜单项以备后用。与菜单栏不同，菜单没有直接替换菜单项 的方法。替换必须通过先删除再插入来实现。 wx.Menu类也有两个用来获取它的菜单项的信息的get*方 法。GetMenuItemCount()返回菜单中项目的数量，GetMenuItems()返回菜单中项 目的一个列表，项目在列表中的顺序与菜单中的位置相一致。这个列表是菜单 中实际列表的一个拷贝，意味着改变所返回的列表，不会改变菜单本身。 对于有效的菜单，你可以在运行时继续添加或删除菜单项。例10.3显示了 在运行时添加菜单的示例代码。当按钮被按下时，调用OnAddItem()的方法来 插入一个新的项到菜单的尾部。 298 / 565
- 300. 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.CommandEvent的一个实例。在此处，该类型是wx.EVT_MENU。 菜单项事件在两个方面与系统中其它的命令事件不同。首先，用于关联菜 单项事件与特定回调函数的Bind()函数是在包含菜单栏的框架上的。第二，由 于框架通常有多个与wx.EVT_MENU触发相对应的菜单项，所以Bind()方法需 要第三个参数，它就是菜单项本身。这使得框架能区分不同的菜单项事件。 一个典型的绑定一个菜单事件的调用如下所示： self.Bind(wx.EVT_MENU, self.OnExit, exit_menu_item) self是框架，self.OnExit是处理方法，exit_menu_item是菜单项自身。 尽管通过框架绑定菜单事件的主意似乎有一点古怪，但是它是有原因的。 通过框架绑定事件使你能够透明地绑定一个工具栏按钮到与菜单项相同的处理 器。如果该工具栏按钮有与一个菜单项相同的wxPython ID的话，那么这个单个 的对wx.EVT_MENU的Bind()调用将同时绑定该菜单选择和该工具栏按钮敲 击。这是可行的，因为菜单项事件与工具事件都经由该框架得到。如果菜单项 事件在菜单栏中被处理，那么菜单栏将不会看到工具栏事件。 300 / 565
- 301. 有时，你会有多个菜单项需要被绑定到同一个处理器。例如，一套单选按 钮开关菜单（它们本质上作相同的事情）可能被绑定给同一处理器。如果菜单 项有连续的标识符号的话，为了避免分别的一一绑定，可以使用 wx.EVT_MENU_RANGE事件类型： self.Bind(wx.EVT_MENU_RANGE, function, id=menu1, id2=menu2) 在这种情况下，所有标识号位于[menu1,menu2]间菜单项都将绑定到给定的 函数。 尽管通常你只关心菜单项命令事件，但是这儿有你能够响应的另外的菜单 事件。在wxPython中，类wx.MenuEvent管理菜单的绘制和高亮事件。表10.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
- 303. 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.MenuBar和wx.Menu对于查找特定的菜单项有着本质上相同的方法。其 主要的区别是，wx.MenuBar的方法将查找整个菜单栏上的菜单项，而wx.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) FindMenu方法的title参数匹配菜单的标题（不管菜单的标题有无修饰标签 字符）。例如，即使菜单的标题是&File，FindMenu(“File”)仍将匹配该菜单 项。在菜单类中的所有基于标签字符串发现一个菜单项的方法都有这个功能。 表10.4指出了wx.MenuBar的这些方法，它们能够被用于查找或处理一个特 定的菜单项。 303 / 565
- 304. 表10.4 wx.MenuBar的菜单项处理方法 FindMenuItem(menuString,itemString)：在一个名为menuString的菜单中查找名为 itemString的菜单项。返回找到的菜单项或wx.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)：返回与给定的itemString相关的菜单项或wx.NOT_FOUND。 FindItemById(id)：返回与给定的wxPython标识符相关联的菜单项。如果没有，返回 None。 FindItemByPosition(pos)：返回菜单中给定位置的菜单项 GetHelpString(id) SetHelpString(id,helpString)：与菜单栏的对应方法相同。 GetLabel(id) SetLabel(id, label)：与菜单栏的对应方法相同。 10.2.2 如何使一个菜单项有效或无效？ 类似于其它的窗口部件，菜单和菜单项也可以有有效或无效状态。一个无 效的菜单或菜单项通常显示为灰色文本，而非黑色。无效的菜单或菜单项不触 发高亮或选择事件，它对于系统来说是不可见的。 304 / 565
- 306. 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，如果该菜单 项不存在或无效，那么这两个方法都返回False。唯一的区别是wx.Menu的方法 只在特定的菜单中搜索，而菜单栏方法搜索整个菜单栏。wx.MenuItem方法不 要求参数，它返回特定菜单项的状态。 要改变有效状态，使用 wx.MenuBar.Enable(id, enable), wx.Menu.Enable(id,enable), 或 wx.MenuItem.Enabl e(enable)。enable参数是布尔值。如果为True，相关菜单项有效，如果为False， 相关菜单项无效。Enable()方法的作用域和IsEnabled()方法相同。你也可以使用 wx.MenuBarEnableTop(pos,enable)方法来让整个顶级菜单有效或无效。在这 里，pos参数是菜单栏中菜单的整数位置，enable参数是个布尔值。 10.2.3 如何将一个菜单项与一个快捷键关联起来？ 图10.3显示了一个示例菜单。注意该菜单的菜单名中有一个带下划线的字 符，其中的标签为Accelerated的菜单项的快捷键是Ctrl-A。 306 / 565
- 307. 图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, ”&AcceleratedtCtrl-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
- 308. 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() 在wxPython中有两种快捷键；mnemonics（助记符）和accelerator（加速 器）。下面，我们将讨论这两种的区别。 使用助记符快捷方式 助记符是一个用来访问菜单项的单个字符，以一个带有下划线的字母表 示。助记符可以通过为菜单或菜单项指定显示的文本来创建，并在你想用来作 为助记符的字符前面放置一个&符号，例如&File, &Edit或Ma&cros。如果你希 望在你的菜单文本中有一个&符号，那么你必须输入两个&&符号，例如&&。 助记符是作为在菜单树中选择的一个备用的方法。它仅在被用户显式地调 用时被激活；在微软Windows下，通过按下alt键来激活它。一旦助记符被激 活，下一步按下顶级菜单的助记符来打开顶级菜单。这样一步打开菜单，直到 一个菜单项被选择，此时一个菜单事件被触发。助记符在菜单中必须是独一无 308 / 565
- 309. 二的，但在整个菜单栏中可以不是独一无二。通常菜单文本的第一个字符被用 作助记符。如果你有多个菜单项有相同的开头字母，那么就没有特定的准则来 决定那个字符用作助记符（最常用的选择是第二个和最后一个，这要看哪个更 合理）。菜单文本清晰的含义比有一个好的助记符更重要。 使用加速器快捷方式 在wxPython中加速器是一个更加典型的键盘快捷方式，它意味能够随时调 用的按键组合，这些按键组合直接触发菜单项。加速器可以用两种方法创建。 最简单的方法是，在菜单或菜单项的显示文本中包括加速器按键组合（当菜单 或菜单项被添加到其父中时）。实现的方法是，在你的菜单项的文本后放置一 个t。在t之后定义组合键。组合键的第一部分是一个或多个Alt, Ctrl, 或Shift， 由一个+或一个-分隔，随后是实际的加速器按键。例如：Newtctrl-n, SaveAs tctrl-shift-s。即使在第一部分你只有一个专用的键，你仍可使用+或-来将该部 分与实际的按键分隔。这不区分按键组合的大小写。 实际的键可以是任何数字、字母或功能键（如F1~F12），还有表10.6所列 出的专用词。 wxPython的方法在通过名字查找一个菜单或菜单项时忽略助记符和加速 器。换句话说，对menubar.FindMenuItem(“File”, ”SaveAs”)的调用将仍匹配 Save as菜单项，即使菜单项的显示名是以Save &Astctrl-shift-s形式输入的。 加速器也可能使用加速器表被直接创建，加速器表是类wx.AccleratorTable 的一个实例。一个加速器表由wx.AccelratorEntry对象的一个列表组 成。wx.AcceleratorTable的构造函数要求一个加速器项的列表，或不带参数。在 例10.6中，我们利用了wxPython将隐式使用参数 (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参数代表按下来触发加速器的常规键，它是对应于一个字符的 ASCII数字，或在wxWidgets文本中的Keycodes下的一个专用字符。cmd参数是 菜单项的wxPython标识符，该菜单项当加速器被调用时触发其命令事件。正如 你从例10.6所能看到的，使用这种方法声明一个加速器，不会在这个带菜单项 显示名的菜单上列出组合键。你仍需要单独实现它。 309 / 565
- 310. 表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
- 311. 图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
- 312. 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，其中的每个值创建一个适当类型的菜单项。这是有用 的，如果你正在使用某种数据驱动过程自动创建这些菜单项的话。所有类型的 菜单项都可以使用这同种方法来创建，尽管指定kind为wx.ITEM_SEPARATOR 来生成一个分隔符必须给id参数传递wx.ID_SEPARATOR。 312 / 565
- 313. 当你使用wx.MenuItem构造函数时你也可以创建一个开关菜单项（给参数 kind一个相应的常量值）。所得的菜单项可以使用 AppendItem(), PrependItem(), InsertItem()之一的方法被添加到一个菜单。 要确定一个菜单项的开关状态，使用IsCheckable()，如果该项是一个复选 或单选项，函数返回True，使用IsChecked()，如果该项是可开关的且处于选中 状态，那么返回True。你也可以使用Check(check)方法来设置一个菜单项的开 关状态，check是一个布尔参数。使用Check(check)方法设置时，被设置的菜单 项是单选的，那么将影响同一组别的项。 你也可以使用IsChecked(id)从菜单或菜单栏得到一个菜单项的开关状态， 它要求相应菜单项的id。你也可以使用Check(id, check)来设置菜单栏或菜单中 的菜单项，参数check是布尔值。 10.3 进一步构建菜单 在接下来的几节，我们将通过使你的菜单更杂化来让它更有用。首先我们 将讨论嵌套的子菜单，然后是在你的程序中加入弹出菜单。最后是构建喜爱样 式的菜单项。 10.3.1 如何创建一个子菜单？ 如果你的应用程序变得太复杂，你可以在顶级菜单中创建子菜单，这使你 能够在一个项级菜单中嵌套菜单项且装入更多的项目。对于将一系列的属于同 一逻辑的选项组成一组，子菜单是十分有用的，尤其是要将太多的选项地放入 顶级菜单的时候。图10.5显示了一个使用子菜单的示例。 313 / 565
- 314. 图10.5 例10.8显示了产生图10.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
- 315. 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是要添加到 的菜单的wxPython标识符。参数text是子菜单显示在父菜单中的字符串。参数 submenu是子菜单自身，helpStr是显示在状态栏中的文本。另外还有子菜单的 插入方法：PrependMenu(id,text, submenu, helpStr)和 InsertMenu(pos, text, submenu, helpStr)。这些方法的行为与这章前面我们所讨论 的菜单项的插入方法的行为类似。 记住，子菜单创建的步骤的顺序相对于单纯的菜单项来说是较为重要的， 我们推荐你先将项目添加给子菜单，然后将子菜单附加给父菜单。这使得 wxPython能够正确地为菜单注册快捷键。你可以嵌套子菜单到任意深度，这通 过给已有的子菜单添加子菜单来实现，而非将子菜单添加到顶级菜单，在添加 新的子菜单之前，你仍需要创建创建它。 10.3.2 如何创建弹出式菜单？ 菜单不仅能够从框架顶部的菜单栏向下拉，而且它们也可以在框架的任一 处弹出。多数情况下，一个弹出菜单用于根据上下文和用户所敲击位置的对象 来提供相应的行为。图10.6显示了一个弹出式菜单的例子。 315 / 565
- 316. 图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
- 317. 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。该事 件被操作系统的触发弹出菜单的标准机制所触发。在微软Windows和GTK下， 这个机制是鼠标右键敲击，在Mac OS下，它是一个control敲击。 当用户在框架上执行一个弹出触发敲击的时候，处理器OnShowPopup()被 调用。该方法所做的第一件事是确定显示菜单的位置。传递给该方法的事件的 位置（在wx.EVT_CONTEXT_MENU的实例中）是以屏幕的绝对坐标存储的， 所以我们需要将位置坐标转换为相对于包含弹出菜单的面板的坐标，我们使用 方法ScreenToClient()。 317 / 565
- 318. 此后，使用方法PopupMenu(menu, pos)调用弹出菜单，你也可以使用相关 的方法PopupMenuXY(menu, x, y)。PopupMenu函数不返回，直到一个菜单项被 选择或通过按下Esc或在该弹出菜单之外敲击使该弹出菜单消失。如果一个菜 单项被选择，那么它的事件被正常处理（这意味它必须有一个方法与事件 EVT_MENU绑定），并且在PopupMenu方法返回前该事件也被完 成。PopupMenu的返回值是布尔值，没什么意思。 弹出菜单可以有一个标题，当弹出菜单被激活时它显示在弹出菜单的顶 部。这个标题使用属性wx.Menu.SetTitle(title)和wx.Menu.GetTitle()来处理。 10.3.3 如何创建自己个性的菜单？ 如果普通的菜单项引不起你足够的兴趣，你可以添加自定义的位图到菜单 项的旁边（或用作自定义的检查符号）。在微软Windows下，你也可以调整菜 单项的字体和颜色。图10.7显示了一个个性菜单的例子。 图10.7 例10.10显示了产生这种菜单的代码。要确定程序是否运行在Windows下， 你可以检查‘wxMSW’是否在wx.PlatformInfo元组中。 例10.10 个性菜单项的示例代码 import wx class MyFrame(wx.Frame): def __init__(self): 318 / 565
- 320. app.MainLoop() 处理控制显示属性的主要的内容是给一个菜单项添加颜色或样式。适合除 了Windows外（包括Windows)的平台的唯一的属性是bitmap，由GetBitmap()管 理，该函数返回一个wx.Bitmap类型的项。这儿有两个set*方法。第一个是 SetBitmap(bmp)，它工作于所有的平台上。它总是在菜单项的旁边设置一个显 示的位图。如果你是在微软Windows上，并且你想为一个开关菜单设置一个自 定义的位图，你可以使用SetBitmaps(checked, unchecked=wx.NullBitmap)，它使 得当该项被选中时显示一个位图，该项未选中时显示另一个位图。如果该菜单 项不是一个开关菜单项，那么checked参数是没有用的。 在微软Windws下，有三个另外的属性，你可以用来改变菜单项的外观，如 表10.7所示。我们建议你谨慎地使用它们，并且仅在它们能够明显地增强用户 的体验的情况下。 表10.7 菜单项的外观属性 GetBackgroundColour() SetBackgroundColour(colour)：属性类型是wx.Colour，该set*方法的参数也可以是 一个wxPython颜色的名称字符串。管理项目的背景色。 GetFont() SetFont(font)：项目的显示字体。类型是wx.Font。 GetTextColour() SetTextColour(colour)：管理显示在项目中的文本的颜色。类型和背景色的相同。 目前我们已经讨论了使用菜单功能方面的内容，接下来我们将对如何更好 的使用菜单以及如何使你的应用程序对用户来说更容易使用的问题作一个纲要 性的说明，以结束本章。 10.4 菜单设计的适用性准则 对于大多数复杂的应用程序，菜单栏是用户访问应用程序功能的主要入 口。正确的设计菜单对你的程序的易用性有很大的帮助。本着这一想法，我们 提供了一些关于菜单设计的适用性准则。 320 / 565
- 321. 10.4.1 使菜单有均衡的长度 建议菜单所包含的项目的最大数量在10到15之间。超过这个最大长度的菜 单将会看不全。你应该学习创建长度基本一致的菜单，记住，这有时是不可能 或不必要的。 10.4.2 创建合理的项目组 你不应该创建一个没有分隔符的多于五个项目的组，除非你有非常合理的 理由这样做——如一个历史列表，或一个插件列表。多于五个项目的组，用户 处理起来非常困难。要有一个更大的组，项目需要被强有力地联系在一起并且 要有用户期望长于五个项目的列表的原因。 菜单的顺序要遵循标准 对于菜单的顺序，你应该遵循公认的标准。最左边的菜单应该是FILE（文 件），并且它包含new（新建），open（打开），save（保存），print（打印） 和quit（退出）功能，所包含的功能的顺也是这样，另外的一些功能通常添加 在打印和退出之间。几乎每个应用程序都要使用到这些功能。下一个菜单是 EDIT（编辑），它包含undo（撤消），cut（剪切），copy（拷 贝），paste（粘贴）和常用的find（查找），这些依赖于你的程序的应用范 围。HELP（帮助）菜单总是在最右边，并且windows（窗口）菜单经常是挨着 它的。中间的其它菜单通常由你自己来决定。 对通常使用的项目提供方便的访问 用户总是会更先访问到菜单中更上面的项目。这就说明了更常用的选项应 放在顶部。有一个例外就是多数研究显示，第二项先于第一项。 使用有含义的菜单名称 记住，位于菜单栏上的菜单的宽度是与它的名称成正比的，并且当菜单打 开时它的宽度与它所包含的项目的最长的名字成正比。尽量避免使顶级菜单的 名字少于四个字母。除了通常的名称外，我们建议只要有可能，名字再长点， 但意义要清楚。不要害怕给一个菜单项较长的文本，尽管30~40个字符可能难 读。 当一个项目会调用一个对话框时，记住带有省略号 任何会导致一个对话框被显示的菜单项，都应该有一个以省略号（...）结 尾的标签。 321 / 565
- 322. 使用标准的快捷键 对快捷键，使用通常功能的公认的标准，如表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 撤消 这里没有列出Redo（重做）的公认的快捷键，你有时会看到用于它的Ctrl- y，Alt-z或其它的组合。如果你给通常功能提供了更多的快捷键，那么建议你 给用户提供一个方案来改变它们。快捷键在用户做大量的输入工作时是很有用 的，例如一个文本编辑器。但是对于大部分用鼠标完成的工作，它们的作用就 很少了。 反映出开关状态 当创建一个开关菜单时，有两个事情需要注意。第一，记住，一个未选中 的复选菜单项看起来与一个通常的菜单项相同。如果该菜单项的文本如 fancy mode on的话，那么用户就有可能不知道选择这个菜单项会改变样式。另 一个要注意的是，菜单项文本要反映出当前不是被激活的状态，而非激活状 态。比如菜单文本说明如果选择它会执行什么动作。例如，如果fancy样式是打 开的，那么文本使用Turn fancy mode off。菜单中没有语句表明fancy样式实际 是什么样的，这可以引起混淆。要避免这个问题，对于一个未被选择的菜单， 使用一个自定义的位图以视觉的方式说明这个菜单是一个开关菜单，是一个好 的主意（平台允许的话）。如果你的平台不支的话，使用像 toggle fancy mode 或switch fancy mode (now on)这样的文本意思会更清楚。 322 / 565
- 323. 慎重地使用嵌套 嵌套层次的菜单对于浏览来说不方便。 避免使用字体和颜色 你记得有哪一个应用程序在它的菜单项中使用了字体和颜色的。我们也不 这要使用（但是用于选择字体或颜色的菜单是例外）。很明显，这种使用非常 少见。 10.5 本章小结 ·在图形用户界面中，菜单是最常用来让用户触发命令的机制。在wxPython 中，创建菜单使用三个主要的类：wx.MenuBar，它表示菜单栏并包含菜单，菜 单使用wx.Menu。菜单由菜单项组成，菜单项使用wx.MenuItem。对于菜单部 分的创建，首先创建菜单栏并将它附加到框架。然后分别创建个个菜单，并添 加菜单项。再将菜单添加到菜单栏。菜单项可以被添加到菜单的任意位置。一 个菜单项也可以是一个菜单分隔符，而非普通的菜单项。当菜单项被添加到其 父菜单时，菜单项对象可以被显式地或隐含地创建。 ·选择一个菜单将触发一个wx.EVT_MENU类型的命令事件。菜单事件经由 框架绑定，而非菜单项，菜单或菜单栏。这让工具栏按钮可以触发与一个菜单 项相同的wx.EVT_MENU事件。如果你有多个有着连续标识符的菜单项，它们 有相同的处理器的话，那么它们可以使用wx.EVT_MENU_RANGE事件类型被 绑定在一起调用。 ·菜单项能够从包含它们的菜单或菜单栏使用ID或标签来查找。也可以被设 置成有效或无效。 ·一个菜单可以被附加给另一个菜单，而非菜单栏，从而形成一个嵌套的子 菜单。wx.Menu有特定的方法使你能够添加子菜单，同样也能够添加一个菜单 项。 ·菜单可以用两种方法与按键关联。助记符和加速器。 ·一个菜单项可以有一个开关状态。它可以是一个复选菜单项，也可以是一 个单选菜单项。菜单项的选择状态可以经由包含它的菜单或菜单来查询或改 变。 323 / 565
- 325. 11 使用sizer放置窗口部件 本章内容 ·理解sizer ·使用sizer分隔窗口部件 ·使用sizer的grid系列 ·使用box sizer ·看看sizer的实际应用 传统上，在用户界面编程中的最苦恼的一个问题是管理窗口中的窗口部件 的实际布局。因为它涉及到与绝对位置直接打交到，这是很痛苦的一件事情。 所以你需要一个结构，它根据预设的模式来决定如何调整和移动窗口部 件。目前推荐用来处理复杂布局的方法是使用sizer。sizer是用于自动布局一组 窗口部件的算法。sizer被附加到一个容器，通常是一个框架或面板。在父容器 中创建的子窗口部件必须被分别地添加到sizer。当sizer被附加到容器时，它随 后就管理它所包含的孩子的布局。 使用sizer的好处是很多的。当子窗口部件的容器的尺寸改变时，sizer将自 动计算它的孩子的布局并作出相应的调整。同样，如果其中的一个孩子改变了 尺寸，那么sizer能够自动地刷新布局。此外，当你想要改变布局时，sizer管理 起来很容易。最大的弊端是sizer的布局有一些局限性。但是，最灵活sizer—— grid bag和box，能够做你要它们做的几乎任何事。 11.1 sizer是什么？ 一个wxPython sizer是一个对象，它唯一的目的就是管理容器中的窗口部件 的布局。sizer本身不是一个容器或一个窗口部件。它只是一个屏幕布局的算 法。所有的sizer都是抽象类wx.Sizer的一个子类的实例。wxPython提供了5个 sizer，定义在表11.1中。sizer可以被放置到别的sizer中以达到更灵活的管理。 表11.1 wxPython中预定义的sizer Grid：一个十分基础的网格布局。当你要放置的窗口部件都是同样的尺寸且整齐地放 入一个规则的网格中是使用它。 Flex grid：对grid sizer稍微做了些改变，当窗口部件有不同的尺寸时，可以有更好的 结果。 325 / 565
- 326. Grid bag：grid sizer系列中最灵活的成员。使得网格中的窗口部件可以更随意的放 置。 Box：在一条水平或垂直线上的窗口部件的布局。当尺寸改变时，在控制窗口部件的 的行为上很灵活。通常用于嵌套的样式。可用于几乎任何类型的布局。 Static box：一个标准的box sizer。带有标题和环线。 如果你想要你的布局类似grid或box,wxPython可以变通；实际上，任何有 效的布局都能够被想像为一个grid或一系列box。 所有的sizer都知道它们的每个孩子的最小尺寸。通常，sizer也允许有关布 局的额外的信息，例如窗口部件之间有多少空间，它能够使一个窗口部件的尺 寸增加多以填充空间，以及当窗口部件比分配给它们的空间小时如何对齐这些 窗口部件等。根据这些少量的信息sizer用它的布局算法来确定每个孩子的尺寸 和位置。wxPython中的每种sizer对于同组子窗口部件所产生的最终布局是不同 的。贯穿本章，你都会看到，我们使用非常相似的布局来演示每个sizer类型。 下面是使用一个sizer的三个基本步骤： ·创建并关联sizer到一个容器。sizer被关联到容器使用wx.Window的 SetSizer(sizer)方法。由于这是一个wx.Window的方法，所以这意味着任何 wxPython窗口部件都可以有一个sizer，尽管sizer只对容器类的窗口部件有意 义。 ·添加每个孩子到这个sizer。所有的孩子窗口部件需要被单独添加到该 sizer。仅仅创建使用容器作为父亲的孩子窗口部件是不够的。还要将孩子窗口 部件添加到一个sizer，这个主要的方法是Add()。Add()方法有一对不同的标 记，我们将在下一节讨论。 ·（可选的）使sizer能够计算它的尺寸。告诉sizer去根据它的孩子来计算它 的尺寸，这通过在父窗口对象上调用wx.Window的Fit()方法或该sizer的 Fit(window)方法。（这个窗口方法重定向到sizer方法。）两种情况下，这个 Fit()方法都要求sizer根据它所掌握的它的孩子的情况去计算它的尺寸，并且它 调整父窗口部件到合适的尺寸。还有一个相关的方法：FitInside()，它不改变父 窗口部件的显示尺寸，但是它改变它虚拟尺寸——这意味着如果窗口部件是在 一个可滚动的面板中，那么wxPython会重新计算是否需要滚动条。 我们既要讨论特定的sizer的行为，也要讨论所有sizer的共同行为。这就有 个先后的问题。我们将以介绍grid sizer作为开始，它是最容易理解的。之后， 我们将讨论所有sizer的共同行为，使用grid sizer作为一个例子。（使用grid sizer 326 / 565
- 327. 作为例子使得最共同的行为更形象化。）之后我们将讨论其它的特定类型的 sizer。 11.2 基本的sizer：grid sizer 后面所有的例子使用了一个有点无聊的窗口部件，目的是占据布局中的空 间，这样你可以看到sizer是如何工作的。例11.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？ wxPython提供的最简单的sizer是grid。顾名思义，一个grid sizer把它的孩子 放置在一个二维网格中。位于这个sizer的孩子列表中的第一个窗口部件放置在 网格的左上角，其余的按从左到右，从上到下的方式排列，直到最后一个窗口 327 / 565
- 328. 部件被放置在网格的右底部。图11.1显示了一个例子，有九个窗口部件被放置 在一个3*3的网格中。注意每个部件之间有一些间隙。 图11.1 当你调整grid sizer的大小时，每个部件之间的间隙将随之改变，但是默认 情况下，窗口部件的尺寸不会变，并且始终按左上角依次排列。图11.2显示了 调整尺寸后的同一窗口。 图11.2 例11.2显示了用于产生图11.1和11.2的代码。 例11.2 使用grid sizer import wx from blockwindow import BlockWindow labels = ”one two three four five six seven eight nine”.split() 328 / 565
- 329. 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.2看到，一个grid sizer是类wx.GridSizer的一个实例。构造函 数显式地设置四个属性，这些属性是grid sizer独一无二的： wx.GridSizer(rows, cols, vgap, hgap) 这个构造函数中的rows和cols是整数，它们指定了网格的尺寸——所能放 置的窗口部件的数量。如果这两个参数之一被设置为0，那么它的实际的值根 据sizer中的孩子的数量而定。例如如果使用wx.GridSizer(2, 0, 0, 0)，且sizer有八 个孩子，那么它就需要有四列来填充这些孩子。 vgap和hgap使你可以决定窗口控件间的间隔的多少。vgap是两相邻列间的 间隔的象素量，hgapvgap是两相邻行间的间隔的象素量。这些象素量是除了窗 口控件边框的量。属性rows, cols, vgap, hgap都有各自的get*和set*方法—— GetRows(), SetRows(rows), GetCols(),SetCols(cols), GetVGap(), SetVGap(gap), Get HGap(), 和SetHGap(gap) 。 grid sizer的尺寸和位置的算法是十分简单的。当Fit()第一次被调用时，创 建初始化的网格布局。如果有必要，行和列的数量根据列表中元素的数量来计 算。在grid中每个空格的尺寸是相同的——即使每个窗口部件的尺寸不同。这 个最大的尺度是根据网格中宽度最宽的孩子的宽度和高度最高的孩子的高度来 计算的。所以，grid sizer最适合用于所有孩子相同尺寸的情况。有着不同尺寸 窗口部件的grid sizer看起来有点怪异。如果你仍想要一个类似grid的布局，但是 你又有不同尺寸的窗口部件的话，那么可以使用flex grid sizer或grid bag sizer。 329 / 565
- 330. 11.2.2 如何对sizer添加或移除孩子？ 添加孩子部件到sizer中的次序是非常重要的。这与将孩子添加到一个父窗 口部件中的通常情况是不一样的。sizer的通常的布局算法要求一次添加一个孩 子，以便于决定它们的显示位置。下一项的位置是依赖于前一被添加项的位置 的。例如，grid sizer基于窗口部件的次序来从左到右，从上到下的添加并显 示。在多数情况下，当你在父窗口部件的构造器中创建sizer时，你将会按正确 的次序添加这些项目。但是有时候，如果你在运行时动态地改变你的布局，那 么你需要更灵活和更细致。 使用Add()方法 添加一个窗口部件到一个sizer中的最常用的方法是Add()，它将新的窗口部 件添加到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) 这每一个版本是你最常要用到的，它使你能够将一个窗口部件添加到 sizer。这第二个版本用于将一个sizer嵌套在另一个中——这最常用于 box sizer，但可用于任何类型的sizer。第三个版本使你能够添加一个wx.Size对 象的空的空白尺寸或一个（宽，高）元组到sizer，通常用作一个分隔符（例 如，在一个工具栏中）。另外，这在box sizer中最常使用，但也可在任何sizer 中使用以用于形成窗口的一个空白区域或分隔不同的窗口部件。 其它的参数影响sizer中的项目如何显示。其中的一些只对某种sizer有 效。proportion仅被box sizer使用，并当父窗口尺寸改变时影响一个项目如何被 绘制。这个稍后我们将在box sizer时讨论。 flag参数用于放置位标记，它控制对齐、边框和调整尺寸。这些项将在后 面的章节中讨论。如果在flag参数中指定了边框，那么border参数包含边框的宽 度。如果sizer的算法需要，userData参数可被用来传递额外的数据。如果你正 在设计一个自定义的sizer，那么你可以使用该参数。 330 / 565
- 331. 使用insert()方法 这里有用于将新的窗口部件插入到sizer中不同位置的方法。insert()方法使 你能够按任意的索引来放置新的窗口部件。它也有三个形式： 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) 使用Prepend()方法 该方法将新的窗口部件、sizer或空白添加到sizer的列表的开头，这意味所 添加的东西将被显示到左上角： 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.1中如果Add()替换为Prepend()后的布局。 图11.3 如果sizer已在屏幕上显示了，而你又要给sizer添加一个新的项目，那么你 需要调用sizer的Layout()方法来迫使sizer自己重新排列，以容纳新的项。 使用Detach()方法 为了从sizer中移除一项，你需要调用Detach()方法，它从sizer中移除项目， 但是没有销毁该项目。这对于你以后再使用它是有用的。使用Detach()有三种 方法。你可以将你想要移除的窗口、sizer对象、对象的索引作为参数传递给 Detach()： Detach(window) 331 / 565
- 332. Detach(sizer) Detach(index) 在这三种情况中，Detach()方法返回一个布尔值，它表明项目是否真的被 删除了——如果你试图移除sizer中没有的项，将返回false。和你曾见过的其它 的删除方法不同，Detach()不返回被删除的项目，所以如果你想要得到它的 话，你需要之前用一个变量来存储对它的引用。 从sizer中删除项目，不会自动改变在屏幕上的显示。你需要调用Layout() 方法来执行重绘。 你可以得到一个包含了窗口的sizer的引用，这通过使用wx.Window的 GetContainingSizer()方法。如果该窗口部件没有被包含在sizer中，那么该方法 返回None。 11.2.3 sizer是如何管理它的孩子的尺寸和对齐的？ 当一个新的项目被添加到一个sizer时，sizer就使用这个项目的初始尺寸或 根据它的布局计算给出恰当的尺寸（如果它的初始尺寸没有设置）。换句话 说，sizer不调整一个项目的大小，除非要求，这通常发生在一个窗口尺寸的改 变时。 当sizer的父窗口部件改变了尺寸时，sizer需要改变它的组分的尺寸。默认 情况下，sizer保持这些窗口部件的对齐方式不变。 当你添加一个窗口部件到sizer时，可以通过给flag参数一个特定值来调整 该窗口部件的尺寸改变行为。图11.4展示了在用户放大窗口后，几个不同标记 应用于这个基本的grid sizer的结果。 332 / 565
- 334. 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.2显示与尺寸调整和对齐相关的flag的值。 表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.GROW：与wx.EXPAND相同。但比之少两个字符，节约了时间。 wx.SHAPED：窗口部件的尺寸改变时，只在一个方向上填满格子，另一个方向上按 窗口部件原先的形状尺寸的比列填充。 这些标记可以使用|来组合，有时，这些组合会很有意 思。wx.ALIGN_TOP | wx.ALIGN_RIGHT使得窗口部件位于格子的右上角。 （注意，互相排斥的标记组合如wx.ALIGN_TOP | wx.ALIGN_BOTTOM中，默 认的标记不起作用，这是因为默认标记的相应位上是0，在或操作中没有什么 影响）。 334 / 565
- 335. 还有一些方法，你可以用来在运行时处理sizer或它的孩子的尺寸和位置。 你可以使用方法GetSize()和 GetPosition()来得到sizer的当前尺寸和位置——这个 位置是sizer相对于它所关联的容器的。如果sizer嵌套在另一个sizer中，那么这 些方法是很有用的。你可以通过调用SetDimension(x, y, width, height)方法来指 定一个sizer的尺寸，这样sizer将根据它的新尺寸和位置重新计算它的孩子的尺 寸。 11.2.4 能够为sizer或它的孩子指定一个最小的尺寸吗？ sizer的窗口部件的布局中的另一个重要的要素是为sizer或它的孩子指定一 个最小尺寸的能力。一般你不想要一个控件或一个sizer小于一个特定的尺寸， 通常因为这样会导致文本被窗口部件的边缘截断。或在一个嵌套的sizer中，控 件在窗口中不能被显示出来。为了避免诸如此类的情况，你可以使用最小尺 寸。 图11.5显示了对一个特定的窗口部件设置最小尺寸的一个例子。该窗口的 尺寸已被用户改变了。 图11.5 例11.4展示了产生该图的代码。它类似于基本的grid的代码，其中增加了一 个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
- 336. 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)来设置——第二个方法使你也能够指定 一个最大尺寸。如果一个窗口部件的属性（通常是所显示的字体或文本标签） 改变，该窗口部件通常将调整它的最佳尺寸。 如果一个窗口有相关的sizer，那么这个容器窗口的最佳尺寸由它的sizer来 确定。如果没有，那么该窗口的最佳尺寸就是足够大到显示所有子控件的尺 寸。如果该窗口没有孩子，那么它使用所设置的最小尺寸为最佳尺寸。如果上 述都没有，那么该容器窗口的当前尺寸作为其最佳尺寸。 你可以使用GetMinSize()来访问整个sizer的最小尺寸。如果你想为整个sizer 设置一个较大的最小尺寸，那么你可以使用SetMinSize(width,height)，该函数也 可以使用一个wx.Size实例作为参数——SetMinSize(size)，尽管在wxPython中你 很少显式地创建一个wx.Size。在最小尺寸已被设置后，GetMinSize()返回设置 的尺寸或孩子的综合的尺寸。 如果你只想设置sizer内的一个特定的孩子的最小尺寸，那么使用sizer的 SetItemMinSize()方法。它也有三个形式： SetItemMinSize(window, size) SetItemMinSize(sizer, size) SetItemMinSize(index, size) 336 / 565
- 337. 这里，参数window和sizer必须是一个sizer实例的孩子。如果需要的话，方 法将在整个嵌套树中搜索特定的子窗口或子sizer。参数index是sizer的孩子列表 中的索引。参数size是一个wx.Size对象或一个(宽，高)元组，它是sizer中的项目 被设置的最小尺寸。如果你设置的最小尺寸比窗口部件当前的尺寸大，那么它 自动调整。你不能根据sizer来设置最大尺寸，只能根据窗口部件来使用 SetSizeHints()设置。 11.2.5 sizer如何管理每个孩子的边框？ wxPython sizer能够使它的一个或所有孩子有一个边框。边框是连续数量的 空白空间，它们分离相邻的窗口部件。当sizer计算它的孩子的布置时，边框的 尺寸是被考虑进去了的，孩子的尺寸不会小于边框的宽度。当sizer调整尺寸 时，边框的尺寸不会改变。 图11.6显示了一个10像素的边框。在每行中，中间的元素四边都有边框围 绕，而其它的只是部分边有边框。增加边框不会使窗口部件更小，而是使得框 架更大了。 图11.6 例11.5是产生图11.6的相关代码。它和基本的grid 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
- 338. ”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中的窗口部件周围放置边框，需要两步。第一步是当窗口部 件被添加到该sizer时，传递额外的标记给flags参数。你可以使用标记wx.ALL来 指定边框围绕整个窗口部件，或使用 wx.BOTTOM, wx.LEFT, wx.RIGHT, wx.TOP来指定某一边有边框。这些标记当 然可以组合成你想要的，如wx.RIGHT | wx.BOTTOM将使你的窗口部件的右边 和底边有边框。由于边框、尺寸调整、对齐这些信息都是经由flags参数，所以 对于同一个窗口部件，你通常必须将三种标记组合起来使用。 在你传递了边框信息到flags参数后，你也需要传递边框宽度的像素值给 border参数。例如，下面的调用将添加窗口部件到sizer列表的尾部，并使该窗 口部件的周围有5个像素宽度的边框： sizer.Add(widget, 0, wx.ALL | wx.EXPAND, 5) 该部件然后将扩展以填充它的有效空间，且四周始终留有5个像素的空 白。 338 / 565
- 339. 11.3 使用其它类型的sizer 我们已经讨论了基本的sizer，现在我们可以转向更复杂和更灵活的sizer 了。其中两个（flex grid sizer和grid bag sizer）本质上是grid的变种。另外两个 （box和static box sizer）使用一个不同的和更灵活的布局结构。 11.3.1 什么是flex grid sizer？ flex grid sizer是grid sizer的一个更灵活的版本。它与标准的grid sizer几乎相 同，除了下面的例外： 1、每行和每列可以有各自的尺寸。 2、默认情况下，当尺寸调整时，它不改变它的单元格的尺寸。如果需要 的话，你可以指定哪行或哪列应该增长。 3、它可以在两个方向之一灵活地增长，意思是你可以为个别的子元素指 定比列量，并且你可以指定固定方向上的行为。 图11.7显示了一个flex grid sizer，它的布局也是9个单元格。这里的中间单 元格更大。 图11.7 与图11.5相比较，对于相同的布局，图11.5中每个单元格的尺寸与中间对 象的相同，在flex grid sizer中，单元格的尺寸大小根据它所在的行和列来定。 它们宽度是该列中宽度最大的项目的宽度，它们的高度是该行中宽度最高的项 目的宽度。在这里，项目“four”和项目“six”的单元格的高度比项目本身的高度 更高，因为其同行中的项目“five”，而“two”和“seven”的单元格的宽度也更 宽。“one,” “three,” “seven,” 和“nine”的单元格是正常的尺寸，并且不受较大的 窗口部件的影响。 图11.8展示了当调整窗口尺寸时，flex grid sizer的默认行为——单元格的尺 寸不改变。 339 / 565
- 340. 图11.8 例11.6显示了产生了图11.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 sizer是wx.FlexGridSizer的一个实例。类wx.FlexGridSizer是 wx.GridSizer的子类，所以wx.GridSizer的属性方法依然有效。wx.FlexGridSizer 的构造函数与其父类的相同： 340 / 565
- 341. wx.FlexGridSizer(rows, cols, vgap, hgap) 为了当sizer扩展时，使一行或列也扩展，你需要使用适当的方法显式地告 诉该sizer该行或列是可扩展的： AddGrowableCol(idx, proportion=0) AddGrowableRow(idx, proportion=0) 当sizer水平扩展时，关于新宽度的默认行为被等同地分配给每个可扩展的 列。同样，一个垂直的尺寸调整也被等同地分配给每个可扩展的行。要改变这 个默认的行为并且使不同的行和列有不现的扩展比率，你需要使用proportion参 数。如果proportion参数被使用了，那么与该参数相关的新的空间就被分配给了 相应的行或列。例如，如果你有两个尺寸可调整的行，并且它们的proportion分 别是2和1，那么这第一个行将得到新空间的2/3，第二行将得到1/3。图11.9显示 使用proportional（比列）空间的flex grid sizer。在这里，中间行和列所占的比 例是2和5，两端的行和列所占的比例是1。 图11.9 正如你可以看到的，当所有的单元格增大时，中间的行和列的增大是两端 的两倍。窗口部件的没有改变尺寸以填表充它们的单元格，虽然可以通过在当 它们被添加到sizer时使用wx.EXPAND来实现。例11.7显示了产生图11.9的代 码。 例11.7 import wx from blockwindow import BlockWindow 341 / 565
- 342. 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.3显示了mode参数的有效值。 342 / 565
- 343. 表11.3 wx.FLEX_GROWMODE_ALL：flex grid在没有使用SetFlexibleDirection*的方向上等 同地调整所有单元格的尺寸。这将覆盖使用AddGrowable*方法设置的任何行为—— 所有的单元格都将被调整尺寸，不管它们的比例或它们是否被指定为可扩展（增长） 的。 wx.FLEX_GROWMODE_NONE：在没有使用SetFlexibleDirection*的方向上的单元 格的尺寸不变化，不管它们是否被指定为可增长的。 wx.FLEX_GROWMODE_SPECIFIED：在没有使用SetFlexibleDirection*的方向上， 只有那些可增长的单元格才增长。但是sizer将忽略任何的比例信息并等同地增长那 些单元格。这是一个默认行为。 上面段落中所讨论的SetFlexibleDirection和SetNonFlexibleGrowMode方法都 有对应的方法：GetFlexibleDirection()和GetNonFlexibleGrowMode()，它们返回 整型标记。在上表中要强调的是，任何使用这些方法来指定的设置将取代通过 AddGrowableCol()和AddGrowableRow()创建的设置。 11.3.2 什么是grid bag sizer? grid bag sizer是对flex grid sizer进一步的增强。在grid bag sizer中有两个新 的变化： 1、能够将一个窗口部件添加到一个特定的单元格。 2、能够使一个窗口部件跨越几个单元格（就像HTML表单中的表格所能做 的一样）。 图11.10 图11.10显示了一个grid bag sizer的示例。它与本章前面的例子很相似，只 是增加了新的窗口部件以展示跨行和跨列。 例11.8显示了产生图11.10的代码。注意这里的Add()方法与以前的看起来有 点不同。 343 / 565
- 345. grid bag sizer是wx.GridBagSizer的实例，wx.GridBagSizer是 wx.FlexGridSizer的一个子类。这意味着所有flex grid sizer的属性，grid bag sizer 都适用。 wx.GridBagSizer的构造函数与它的父类有点不同： wx.GridBagSizer(vgap=0, hgap=0) 在一个grid bag sizer中，你不必去指定行和列的数量，因为你可以直接将 子项目添加进特定的单元格——sizer将据此计算出网格的尺度。 在grid bag sizer上使用Add()方法 对于grid bag sizer，Add()方法与别的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, 和userData参数的行为与通常sizer的方法中 的是相同的。pos参数代表sizer中的窗口部件要赋予的单元格。技术上讲，pos 参数是类wx.GBPosition的一个实例，但是通过wxPython变换，你可以仅传递一 个(行,列)形式的元组，grid bag的左上角是(0,0)。 同样，span参数代表窗口部件应该占据的行和列的数量。它是类 wx.GBSpan的一个实例，但是，wxPython也使你能够传递一个(行的范围，列的 范围)形式的元组。如果跨度没有指定，那么默认值是(1,1)，这意味该窗口部件 在两个方向都只能占据一个单元格。例如，要在第二行第一列放置一个窗口部 件，并且使它占据三行两列，那么你将这样调用：Add(widget, (1, 0), (3, 2)) （索引是从0开始的）。 345 / 565
- 346. Additem方法的item参数是类wx.GBSizerItem的一个实例，它包含了 grid bag sizer放置项目所需要的全部信息。你不太可能需要直接去创建一个 wx.GBSizerItem。如果你想去创建一个，那么它的构造函数的参数与 grid bag sizer的其它Add()方法相同。一旦你有了一个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中的项目进行比对。如果有任一项与给定项目的位置或给定的位置和 跨度重叠，则返回True。excludeItem是一个可选的项，它不被包括在比对中（或许 是因为它正在测试中）。pos参数是一个wx.GBPosition或一个元组。span参数是一 个wx.GPSpan或一个元组。 FindItem(window) FindItem(sizer)：返回对应于给定的窗口或sizer的wx.GBSizerItem。如果窗口或 sizer不在grid bag中则返回None。这个方法不递归检查其中的子sizer。 FindItemAtPoint(pt)：pt参数是对应于所包含的框架的坐标的一个wx.Point实例或一 个Python元组。这个方法返回位于该点的wx.GBSizerItem 。如果这个位置在框架的 边界之外或如果该点没有sizer项目，则返回None。 FindItemAtPosition(pos)：该方法返回位于给定单元格位置的wx.GBSizerItem，参数 pos是一个wx.GBPosition或一个Python元组。如果该位置在sizer的范围外或该位置 没有项目，则返回None。 FindItemWithData(userData)：返回grid bag中带有给定的userData对象的一个项目 的wx.GBSizerItem。 Grid bag也有一对能够用于处理单元格尺寸和项目位置的属性。在grid bag 被布局好并显示在屏幕上后，你可以使用方法GetCellSize(row, col)来获取给定 的单元格显示在屏幕上的尺寸。这个尺寸包括了由sizer本身所管理的水平和垂 直的间隔。你可以使用方法GetEmptyCellSize()得到一个空单元格的尺寸，并且 你可以使用SetEmptyCellSize(sz)改变该属性，这里的sz是一个wx.Size对象或一 个Python元组。 346 / 565
- 347. 你也可以使用方法GetItemPosition()和GetItemSpan()来得到grid bag中的一 个对象的位置或跨度。这两个方法要求一个窗口，一个sizer或一个索引作为参 数。这个索引参数与sizer的Add()列表中的索引相对应，这个索引在grid bag的 上下文中没多大意思。上面的两个get*方法都有对应的set*方 法，SetItemPosition(window, pos)和SetItemSpan(window, span)，这两个方法的第 一个参数可以是window,sizer,或index，第二个参数是一个Python元组或一个 wx.GBPosition或wx.GBSpan对象。 11.3.3 什么是box sizer？ box sizer是wxPython所提供的sizer中的最简单和最灵活的sizer。一个 box sizer是一个垂直列或水平行，窗口部件在其中从左至右或从上到下布置在 一条线上。虽然这听起来好像用处太简单，但是来自相互之间嵌套sizer的能力 使你能够在每行或每列很容易放置不同数量的项目。由于每个sizer都是一个独 立的实体，因此你的布局就有了更多的灵活性。对于大多数的应用程序，一个 嵌套有水平sizer的垂直sizer将使你能够创建你所需要的布局。 图11.11-11.14展示了几个简单的box sizer的例子。图中所展示的各个框架我 们都是手动调整了大小的，以便展示每个sizer是如何响应框架的增大的。图 11.11显示了一个水平的box sizer，图11.12在一个垂直的box sizer显示了现图 11.11相同的窗口部件。 图11.11 图11.12 347 / 565
- 348. 图11.13显示了一个垂直的sizer，其中一个窗口部件被设置成可扩展并填充 有效的垂直空间。图11.14展示了一个垂直的sizer，其中的两个窗口部件设置为 按不同的比例占据有效的垂直空间。 图11.13 图11.14 生成以上四个sizer框架的示例代码如例11.9所示。 348 / 565
- 351. box sizer是类wx.BoxSizer的实例，wx.BoxSizer是wx.Sizer的子类，相对于 wx.Sizer，wx.BoxSizer几乎没有增加新的方法。wx.BoxSizer的构造函数有一个 参数： wx.BoxSizer(orient) 参数orient代表该sizer的方向，它的取值可以是wx.VERTICAL或 wx.HORIZONTAL。对于box sizer所定义的唯一一个新的方法是 GetOrientation()，它返回构造函数中orient的整数值。一旦一个box sizer被创建 后，你就不能改变它的方向了。box sizer的其它的函数使用本章早先所讨论的 一般的sizer的方法。 box sizer的布局算法对待该sizer的主方向（当构建的时候已被它的方向参 数所定义）和次要方向是不同的。特别地，proportion参数只适用于当sizer沿主 方向伸缩时，而wx.EXPAND标记仅适用于当sizer的尺寸在次方向上变化时。换 句话说，当一个垂直的box sizer被垂直地绘制时，传递给每个Add()方法调用的 参数proportion决定了每个项目将如何垂直地伸缩。除了影响sizer和它的项目的 水平增长外，参数proportion以同样的方式影响水平的box sizer。在另一方面， 次方向的增长是由对项目所使用的wx.EXPAND标记来控制的，所以，在一个 垂直的box sizer中的项目将只在水平方向增长，如果它们设置了wx.EXPAND标 记的话，否则这些项目保持它们的最小或最合适的尺寸。图6.7演示了这个过 程。 在box sizer中，项目的比例增长类似于flex grid sizer，但有一些例外。第 一，box sizer的比例行为是在窗口部件被添加到该sizer时，使用proportion参数 被确定的——你无需像flex grid sizer那样单独地指定它的增长性。第二，比例 为0的行为是不同的。在box sizer中，0比例意味着该窗口部件在主方向上不将 根据它的最小或最合适尺寸被调整尺寸，但是如果wx.EXPAND标记被使用了 的话，它仍可以在次方向上增长。当box sizer在主方向上计算它的项目的布局 时，它首先合计固定尺寸的项目所需要的空间，这些固定尺寸的项目，它们的 比例为0。余下的空间按项目的比例分配。 11.3.4 什么是static box sizer? 一个static box sizer合并了box sizer和静态框（static box），静态框在sizer 的周围提供了一个漂亮的边框和文本标签。图11.15显示了三个static box sizer。 351 / 565
- 352. 图11.15 例11.10显示了产生上图的代码。这里有三个值得注意的事件。首先你必须 单独于sizer创建静态框对象，第二是这个例子展示了如何使用嵌套的 box sizer。本例中，三个垂直的static box sizer被放置于一个水平的box 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
- 353. 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 sizer是类wx.StaticBoxSizer的实例，wx.StaticBoxSizer是 wx.BoxSizer的子类。它的构造函数要求的参数是静态框和方向： wx.StaticBoxSizer(box, orient) 在这个构造函数中，orient的意义与原wx.BoxSizer相同，box参数是一个 wx.StaticBox。对于static box sizer所定义的别的方法只有一个： GetStaticBox()，它返回用于建造该sizer的wx.StaticBox。一旦该sizer被创建，那 么你就不能再改变这个静态框了。 wx.StaticBox类有一个用于wxPython控件的标准的构造函数，但是其中许 多参数都有默认值，可以忽略。 wx.StaticBox(parent, id, label, pos=wx.DefaultPosition, size=wx.DefaultSize, style=0, name=”staticBox”) 使用一个static box sizer，你不需要去设置pos, size, style, 或name参数，因 为位置和尺寸将由sizer管理，并且没用单独用于wx.StaticBox的样式。这使得构 造更简单： 353 / 565
- 354. box = wx.StaticBox(self.panel, -1, boxlabel) 到目前为止，我们已经展示了各种sizer，我们将给你展示如何在实际的布 局中使用它们。对于另外一个用于创建一个复杂布局的例子，请参看第六章。 11.4 一个现实中使用sizer的例子 迄今为止，我们所展示的有关sizer的例子都是在显示它们的功能方面。下 面，我们将展示一个如何使用sizer来建造一个真实的布局。图11.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
- 357. # 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 在这个布局中的主sizer是mainSizer，它是一个竖直的box sizer。被添加 到mainSizer的第一个元素是顶部的静态文本标签和一个static line。 #3 在box sizer中接下来的元素是addrSizer，它是一个flex grid sizer，它有两 列，它两列用于容纳其余的地址信息。addrSizer的左列被设计用于静态文本标 签，而右列用于得到文本控件。这意味着标签和控件需要被交替的添加，以保 证grid的正确。你可以看到nameLbl, name, addrLbl, 和addr1是首先被添加到该 flex grid中的四个元素。 #4 这接下来的行是不同的，因为这第二个地址行没有标签，一个(10,10)尺 寸的空白块被添加，然后是addr2控件。 #5 接下来的行又有所不同，包括“City, State, Zip”的行要求三个不同的文本 控件，基于这种情况，我们创建了一个水平的box sizer：cstSizer。这三个控件 被添加给cstSizer，然后这个box sizer被添加到addrSizer。 #6 电话和电子邮箱行被添加到flex sizer。 #7 有关地址的flex sizer被正式添加到主sizer。 #8 按钮行作为水平box sizer被添加，其中有一些空白元素以分隔按钮。 在调整了sizer（mainSizer.Fit(self)）和防止框架变得更小之后 （mainSizer.SetSizeHints(self)），元素的布局就结束了。 357 / 565
- 358. 在读这接下来的段落或运行这个例子之前，请试着想出该框架将会如何在 水平和竖直方向上响应增长。 如果该窗口在竖直方向上的大小改变了，其中的元素不会移动。这是因为 主sizer是一个垂直的box sizer，你是在它的主方向上改变尺寸，它没有一个顶 级元素是以大于0的比列被添加的。如果这个窗口在水平方向被调整尺寸，由 于这个主sizer是一个垂直的box sizer，你是在它的次方向改变尺寸，因此它的 所有有wx.EXPAND标记的元素将水平的伸展。这意味着顶部的标签不增长， 但是static line和子sizer将水平的增长。用于地址的flex grid sizer指定列1是可增 长的，这意味着包含文本控件的第二列将增长。在“City, State, Zip” 行内，比列 为1的city元素将伸展，而state和ZIP控件将保持尺寸不变。按钮将保持原有的尺 寸，因为它们的比列是0，但是按钮所在行的空白空间将等分地占据剩下的空 间，因为它们每个的比列都是1。 因此如果你想出的窗口伸展的样子和下图11.17相同，那么你是正确的。 图11.17 11.5 本章小结 1、Sizer是对wxPython程序中管理布局问题的解决方法。不用手动指定每 个元素在布局中的位置和尺寸，你可以将元素添加到一个sizer中，由sizer负责 358 / 565
- 359. 将每个元素放置到屏幕上。当用户调整框架的尺寸时，sizer管理布局是相当好 的。 2、所有的wxPython的sizer都是类wx.Sizer的一个子类的实例。要使用一个 sizer，你需要把它与一个容器型的窗口部件关联起来。然后，对于要添加到容 器中的子窗口部件，你也必需将它们添加到该sizer。最后，调用该sizer的Fit() 方法来触发该sizer的算法，以便布局和放置。 3、所有的sizer开始都给它们的孩子以最小的尺寸。每种sizer各自使用不同 的机制来放置窗口部件，所以相同组的窗口部件放置在不同的sizer中时，它们 的外观也是不同的。 4、或许在wxPython中，最简单的sizer是grid sizer(wx.GridSizer)。在 grid sizer中，元素按照它们被添加给sizer的顺序被放置在一个二维的网格中， 按照从左到右，从上到下的方式排列。通常你负责设定列数，sizer确定行数。 你能够同时指定行和列，如果你愿意的话。 5、所有的sizer都有各自不同的用来将窗口部件添加到sizer的方法。由于窗 口部件添加到sizer中的顺序对于最后的布局是重要的，所以有不同的方法用来 添加一个新的窗口部件到列表中的前面、后面或任意点。在一个窗口部件被添 加到sizer时，另外的属性可以被设置，它们控制当sizer增减时，其中的子元素 如何变化。sizer也能够被配置来在对象的某些或全部边上放置一个边界间隙。 359 / 565
- 360. 12 处理基本的图像 本章内容： 装载图像和创建图像对象 创建设备上下文 绘制到设备上下文 绘制文本到设备上下文 管理画刷、画笔和设备坐标 任何用户界面工具的最基本的行为就是在屏幕上绘制。在最基本的层面上 来说，定义在wxPython中的每个窗口部件都是由发送给屏幕的一系列命令构成 的。那些绘制命令是否是在wxPython代码库中，这依赖于相关窗口部件对于本 地操作系统是否是本地化的或完全由wxPython所定义的。在这一章，我们将给 你展示如何在基本绘制命令层面上控制wxPython。我们也将给你展示如何管理 和显示其它的图形化元素如图像和字体。 被wxPython用于绘制的主要的概念是设备上下文（device context）。设备 上下文使用一个标准的API来管理对设备（如屏幕或打印机）的绘制。设备上 下文类用于最基本的绘制功能，如绘制一条直线、曲线或文本。 12.1 使用图像工作 大多数的应用程序都需要载入至少一个图像，这些图像存储在外部的文件 中。样例包括工具栏图片、光标、图标、启始画面或仅仅用于装饰以增加一些 时髦感的图像。传统上，使用图像工作的复杂性是不得不处理用于储存图像的 不同的图片文件格式。幸运的是，wxPython内部为你做了所有的这些。你将使 用相同的抽象概念来处理任何图像，而不用关心它的原始格式。 在随后的几节中，我们将讨论wxPython用来管理图像的那么抽象概念，这 包括大尺寸图像(large-scale images)，以及光标图像。你将看到如何装载图像到 你的程序中，然后如何操作它们。 360 / 565
- 361. 12.1.1 如何载入图像？ 在wxPython中，图像处理是一个双主管系统，与平台无关的图像处理由类 wx.Image管理，而与平台有关的图像处理由类wx.Bitmap管理。实际上，意思就 是外部文件格式由wx.Image装载和保存，而wx.Bitmap负责将图像显示到屏幕。 图12.1显示了不同图像和位图的创建，按照不同的文件类型读入。 要从一个文件载入一个图像，使用wx.Image的构造函数： wx.Image(name, type=wx.BITMAP_TYPE_ANY, index=-1) 图12.1 参数name是图像文件的名字，参数type（类型）是处理器类型。type的ID 可以是wx.BITMAP_TYPE_ANY或表12.1中的一个。如果你使用 wx.BITMAP_TYPE_ANY，那么wxPython将试图自动检测该文件的类型。如果 你使用一个特定的文件类型，那么wxPython将使用该类型转换这个文件。例 12.1显示了如何使用wx.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
- 363. 指定一个图像文件格式 图像由所用的图像处理器管理。一个图像处理器是wx.ImageHandler的一个 实例，它为管理图像格式提供了一个插入式的结构。在通常的情况下，你不需 要考虑图像处理器是如何工作的。你所需要知道的是每个处理器都有它自己唯 一的wxPython标识符，用以载入相关格式的文件。表12.1列出了所支持的格 式。 表12.1 wxPython支持的图像文件格式 处理器类：wx.ANIHandler 类型标记：wx.BITMAP_TYPE_ANI 说明：动画光标格式。这个处理器只载入图像而不保存它们。 处理器类：wx.BMPHandler 类型标记：wx.BITMAP_TYPE_BMP 说明：Windows和OS/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 说明：PC画刷格式。当以这种格式保存时，wxPython计算在这个图像中的不同颜色 的数量。如果可能的话，这个图像被保存为一个8位图像（也就是说，如果它有256 种或更少的颜色）。否则它保存为24位。 363 / 565
- 364. 处理器类：wx.PNGHandler 类型标记：wx.BITMAP_TYPE_PNG 说明：便携式网络图形格式。 处理器类：wx.PNMHandler 类型标记：wx.BITMAP_TYPE_PNM 说明：只能载入ASCII或原始的RGB图像。图像被该处理器保存为原始的RGB。 处理器类：wx.TIFFHandler 类型标记：wx.BITMAP_TYPE_TIF 说明：标签图像文件格式。 处理器类：wx.XPMHandler 类型标记：wx.BITMAP_TYPE_XPM 说明：XPixMap格式。 处理器类：自动 类型标记：wx.BITMAP_TYPE_ANY 说明：自动检测使用的格式，然后调用相应的处理器。 要使用一个MIME类型来标识文件，而不是一个处理器类型ID的话，请使 用函数wx.ImageFromMime(name, mimetype, index=-1)，其中的name是文件 名，mimetype是有关文件类型的字符串。参数index表示在图像文件包含多个图 像的情况下要载入的图像的索引。这仅仅被GIF, ICO, 和TIFF处理器使用。默认 值-1表示选择默认的图像，被GIF和TIFF处理顺解释为每一个图像 （index=0），被ICO处理器解释为最大且最多色彩的一个。 创建image（图像）对象 wxPython使用不同的全局函数来创建不同种类的wx.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。 创建bitmap（位图）对象 有几个方法可以创建一个位图对象。其中最基本的wx.Bitmap构造函数是 wx.Bitmap(name, type=wx.BITMAP_TYPE_ANY)。参数name是一个文件 名，type可以是表12.1中的一个。如果bitmap类能够本地化地处理这个文件格 364 / 565
- 365. 式，那么它就处理，否则这个图像将自动地经由wx.Image载入并被转换为一个 wx.Bitmap实例。 你可以使用方法wx.EmptyBitmap(width,height,depth=-1)来创建一个空的位 图——参数width和height是位图的尺度，depth是结果图像的颜色深度。有两个 函数使你能够根据原始的数据来创建一个位图。函数 wx.BitmapFromBits(bits, width, height, depth=-1)创建一个位图，参数bits是一个 Python字节列表。这个函数的行为依赖于平台。在大多数平台上，bits要么是1 要么是0，并且这个函数创建一个单色的位图。在Windows平台上，数据被直接 传递给Windows的API函数CreateBitmap()。函数 wxBitmapFromXPMData(listOfStrings)一个Python字符串列表作为一个参数，以 XPM格式读该字符串。 通过使用wx.Bitmap的构造函数wx.BitmapFromImage(image, depth=-1)，你 可以将一个图像转换为一个位图。参数image是一个实际wx.Image对象，depth 是结果位图的颜色深度。如果这个深度没有指定，那么使用当前显示器的颜色 深度。你可以使用函数wx.ImageFromBitmap(bitmap)将位图转回为一个图像， 通过传递一个实际的wx.Bitmap对象。在例12.1中，位图对象的创建使用了位图 的构造函数，然后被用于构建wx.StaticBitmap窗口部件，这使得它们能够像别 的wxPython项目一样被放入一个容器部件中。 12.1.2 我们能够对图像作些什么？ 一旦你在wxPython中使用了图像，你就可以使用许多有用的方法来处理 它，并且可以写一些强大的图像处理脚本。 你可以使用GetWidth()和GetHeight()方法来查询图像的尺寸。你也可以使 用方法GetRed(x, y), GetGreen(x, y), 和GetBlue(x, y)方法得到任意象素点的颜色 值。这些颜色方法的返回值是一个位于0~255之间的整数（用C的术语，它是一 个无符号整数，但是这个区别在Python中没有多大的意义）。同样，你能够使 用SetRGB(x, y, red, green, blue)来设置一个像素点的颜色，其中的x和y是这个像 素点的坐标，颜色的取值位于0~255之间。 你可以使用GetData()方法得到一大块区域中的所有数据。GetData()方法的 返回值是一个大的字符串，其中的每个字符代表一个RGB元组，并且每个字符 都可被认为是一个0~255之间整数值。这些值是有顺序的，第一个是位于像素 点(0,0)的红色值，接下来的是位于像素点(0,0)的绿色值，然后是位于像素点 (0,0)的蓝色值。再接下来的三个是像素点(0,1)的颜色值，如此等等。这个算法 可以使用下面的Python伪代码来定义： 365 / 565
- 366. 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.2定义了一些wx.Image的方法，这些方法执行简单的图像处理。 这些方法只是图像处理的开始部分。在接下来的部分，我们将给你展示两 个方法，它们处理透明和半透明图像这一更复杂的主题。 表12.2 wx.Image的图像处理方法 ConvertToMono(r, g, b)：返回一个与原尺寸一致的wx.Image，其中所有颜色值为 (r, g, b)的像素颜色改为白色，其余为黑色。原图像未改变。 Mirror(horizontally=True)：返回原图像的一个镜像图像。如果horizontally参数是 True，那么镜像图像是水平翻转了的，否则是垂直翻转了的。原图像没有改变。 366 / 565
- 367. Replace(r1, g1, b1, r2, g2, b2)：改变调用该方法的图像的所有颜色值为r1, g1, b1的 像素的颜色为r2, g2, b2。 Rescale(width, height)：改变图像的尺寸为新的宽度和高度。原图像也作了改变，并 且颜色按比例地调整到新的尺寸。 Rotate(angle, rotationCentre, interpolating=True, offestAfterRotation=None)：返回 旋转原图像后的一个新的图像。参数angle是一个浮点数，代表所转的弧 度。rotationCentre是一个wx.Point，代表旋转的中心。如果interpolating为True，那 么一个较慢而精确的算法被使用。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.Image中有着颜色mr, mg, mb的所有像 素，而不管在主图像中那些像素是什么颜色。这使得你在创建一个遮罩中有了 很大的灵活性，因为你不必再担心在你原图像中的像素的颜色。你可以使用 GetMaskRed()，GetMaskGreen(), 和GetMaskBlue()获取遮罩色。如果一个有遮 罩的图像被转换为一个wx.Bitmap，那么遮罩被自动转换为一个wx.Mask对象并 赋给该位图。 设置alpha值来指定一个透明的图像 alpha值是指定一个透明或部分透明图像的另一个方法。每个像素都有一个 alpha值，取值位于0（如果图像在该像素是完全透明的）到255（如果图像在该 像素点是完全不透明的）之间。你可以使用SetAlphaData(data)方法来设置alpha 值，它要求类似于SetData()的字符串字节值，但是每个像素只有一个值。和 SetData()一样，SetAlphaData()不进行范围检查。你可以使用HasAlpha()来看是 否设置了alpha值，你也可以使用GetAlphaData()来得到全部的数据集。你也可 367 / 565
- 368. 以使用SetAlpha(x, y, alpha)来设定一个特定的像素的alpha值，并使用 GetAlpha(x, y)来得到该值。 与wx.Image的图像处理功能相对照，wx.Bitmap的相对少些。几乎所有 wx.Bitmap的方法都是简单得得到诸如宽度、高度和颜色深度这类的属性。 12.1.3 如何改变光标？ 光标是屏幕上用户存在的最直接的体现。同样，它被用来向用户提供所访 问区域的及时反馈。通常它是一个用于指示用户的下一次鼠标敲击将作用的位 置的指针，但是这依赖于光标当前位于什么窗口部件之上，它可以是一个定向 箭头，一个代表文本位置的I，或十字线。通常，一个应用程序通过改变光标为 某种繁忙符号来表示它很忙，如典型的沙漏。 你可能想在你的应用程序中使用光标来表示状态，尽管对于通常的窗口部 件，wxPython会处理这些基本的东西，但是你有时候也想定制它，要么是因为 你有一个自定义的窗口部件，要么是因为你的应用程序需要覆盖标准的光标来 表示一个新的状态。或许你只是想让你的应用程序有一个属于自己的独特的光 标。在这一节，我们将给你展示如何去使用光标表示状态以及如何在wxPython 中定制光标。 在wxPython中，你可以用不同的方法创建光标对象。这个光标类是 wx.Cursor，有两个不同的方法创建它的实例。最简单的方法是 wx.StockCursor(id)，它返回预定义的系统光标的一个实例。表12.3显示了这些 预定义的系统光标的ID。参数id可以是任意数量的标记。 表12.3 预定义的光标 wx.CURSOR_ARROW：标准的箭头光标。 wx.CURSOR_ARROWWAIT：一个表示繁忙的光标，它同时显示标准箭头和一个沙 漏。只在Windows系统有效。 wx.CURSOR_BLANK：不可见的光标。当你想欺骗用户时是有用的。 wx.CURSOR_BULLSEYE：一个bullseye cursor（在较大的光标里面有小的园 环）。有时对于精确指向是有用的。 wx.CURSOR_CHAR：一个字符光标。不是在所平台上有效。 wx.CURSOR_CROSS：十字叉丝光标。 368 / 565
- 370. wx.CURSOR_WATCH：手表型等待光标。 我们已经讨论了预定义的光标，我们将给你展示如何使用你自己的图像来 创建自定义的光标。 创建自定义的光标 你可以使用wx.CursorFromImage(image)方法从一个图像创建一个自定义的 光标。参数image是一个wx.Image实例。所使用的图像自动被调整尺寸为 32*32（在MacOS上是16*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) 参数name是要载入的光标的文件名。参数type是要载入的图标类型，这使 用与wx.Image和wx.Bitmap相同的wx.BITMAP_TYPE_标记。hotSpotX和 hotSpotY设置图标的热点。如果位图类型使用wx.BITMAP_TYPE_CUR来从一 个.cur文件载入，那么热点将根据定义在.cur文件中的热点自动被设置。 一旦你创建了光标，那么使用它就是一个简单的事了，在任何wxPython窗 口部件上调用SetCursor(cursor)就可以了。这个方法使得当光标位于该窗口部件 上时改变为新的形状。还有一个全局性的方法wx.SetCurso(cursor)，它设置整个 应用程序的光标。 图像是很有用，但是它只是简单的表面填充。在下一节，我们将展示如何 发送绘制命令到屏幕或文件或其它的显示设备。 12.2 处理设备上下文 正如我们本章早先所说的，绘制到屏幕是一个UI工具包所做的最基本的事 情。wxPython所做的大多数绘制都被封装进了每个窗口部件的绘制方法中。因 一个UI工具包所做的第二最本的事情大概就是封装了。然而，对你来说，这并 不终是能满足你的要求。有时，如第6章中，你需要响应用户的命令来进行绘 370 / 565
- 371. 制。有时你想要一些喜受的动画。有时你想像一台打印机一样在屏幕上绘制一 个非标准的显示。有时，你希望一个自定义外观的窗口部件，有时你仅仅想要 一些装饰。在wxPython中，所有这些任务都通过操作一个适当的设备上下文来 管理。 设备上下文是一个抽象的东西，wxPython用以使你能够在一个图形设备上 下进行绘制，诸如屏幕或打印机，而不用知道相关设备的细节。这通过提供一 个抽象的父类：wx.DC来得到管理，wx.DC定义了一个公共的API，这个API被 它的一系列子类的所使用，每个子类代表一个不同的图形设备。第6章所述的 设备上下文使用了关于如何使用它们的一个扩展的例子。在随后的部分，我们 将更详细的讨论设备上下文。 12.2.1 什么是设备上下文，以及如何创建它？ 在wxPython中有十个wx.DC的子类，分成下面的三组： * 用于绘制到屏幕的上下文 * 用于绘制到另一个地方，而非屏幕的上下文 * 用于缓冲一个设备上下文，直到你准备将它绘制到一个屏幕的上下文 基于屏幕的设备上下文 第一级代表了绘制到屏幕的设备上下文。你可能认为只需要它们中的一个 就可以了，但实际上wxPython根据你的确切绘制对象和确切的绘制时机提供了 四个。 wx.ClientDC wx.PaintDC wx.WindowDC wx.ScreenDC 屏幕设备上下文是指临时创建的。这意味你无论你何时需要它们时只应该 局部地创建它们，并且使它们能够被正常垃圾回收。你不应该试图以一个实例 变量的形式占有一个设备上下文——这是不安全的，并可能导致程序的不稳 定。 371 / 565
- 372. 通常，你会使用wx.ClientDC或wx.PaintDC来绘制到屏幕上的一个窗口。使 用哪个取决于你执行绘制的时机。如果你在一个EVT_PAINT事件处理期间绘制 到屏幕，那么你必须使用wx.PaintDC。在其它的时间，你必须使用 wx.ClientDC。实际上，无论你何时绑定一个处理器到EVT_PAINT事件，你都 必须在该处理器方法中创建一个wx.PaintDC对象，即使你不使用它（不创建一 个wx.PaintDC会导致平台认为该事件并未完全处理，并因此会发送另一个事 件）。描绘（paint)事件要求不同的设备上下文的原因是，这个wx.PaintDC实例 是被优化来只在重绘事件期间的窗口刷新区域中进行绘制的，以便重绘更快。 你可以经由一个简单的构造函数来创建一个客户区（client）或描绘 （paint)上下文，构造函数的一个参数是你希望在其上进行绘制的wxPython窗口 部件，两者的构造函数分别是wx.ClientDC(window)和wx.PaintDC(window)。当 你使用这两个上下文时，你将只能在该窗口部件的客户区中进行绘制。这意味 在一个框架中，你不能在边框、标题栏或其它装饰物上进行绘制。 如果你需要在框架的整个区域上进行绘制，包括边框和装饰物，那么你应 该使用wx.WindowDC。创建一个wx.WindowDC的方法和wx.ClientDC相似，相 应的构造函数是wx.WindowDC(window)。和wx.ClientDC一样，你不应该在一 个描绘（paint）事件期间创建一个wx.WindowDC——边框绘制行为与描绘 （paint）设备上下文的局部优化是不兼容的。 有时，你不愿被限制于只绘制到一个单一的窗口，你想让整个屏幕作为你 的画布。在这种情况下，你可以使用wx.ScreenDC。同样地，你不能在一描绘 （paint)事件期间创建它。这个构造函数没有参数（因为你不需要再指定绘制到 的对象）——wx.ScreenDC()。创建了一个wx.ScreenDC之后，你就可以像使用 其它的设备上下文一样使用它了。你绘制的图像将显示在你的显示器中的所有 的窗口的上层。 非屏幕设备上下文 第二组设备上下文用于绘制到项目，而非屏幕。这是不同事物的聚合，它 们可被认为在逻辑上等同于屏幕显示。 wx.MemoryDC wx.MetafileDC wx.PostScriptDC 372 / 565
- 373. wx.PrinterDC 第一个是wx.MemoryDC，它使你能够绘制到一个储存在内存中位图而非正 显示的。你可以使用一个不带参数的构造函数wx.MemoryDC()来创建一个 wx.MemoryDC，但在使用它之前，你必须将它与一个位图相关联。这通过调用 一个带有一个wx.Bitmap类型的参数的方法SelectObject(bitmap)来实现。一旦你 这样做了，你就可以绘制到这个内存设备上下文，并且内部的位图被改变。当 你完成绘制时，你可以使用Blit()方法将位图绘制到一个窗口。在随后的部分， 我们将更详细地讨论内存设备上下文。 微软Windows图元文件（metafile）的创建通过使用wx.MetafileDC上下文被 简化了。这个上下文只在Windows系统上有效。创建一个图元文件设备上下 文，使用wx.MetafileDC(filename=””)。如果filename为空，那么图元文件被创建 在内存中。创建之后，发送给这个设备上下文的绘制命令被写到这个文件。当 你完成绘制后，你可以选择调用Close()方法，它对文件本身没有影响，只是返 回一个wxPython的wx.Metafile对象。对于当前版本的wxPython，你对一个 wx.Metafile对象能做的唯一的事情是使用SetClipboard(width=0,height=0)方法把 它发送到剪贴板。 类似的功能是更广泛使用的跨平台的对象wx.PostScriptDC，它创建 Encapsulated PostScript files（.eps）文件。你可以根据一个打印数据对象创建一 个wx.PostScriptDC文件——wx.PostScriptDC(printData)。参数printData是一个 wx.PrintData，我们将在第17章对它进行讨论。一旦创建后，PostScript设备上 下文可以像其它的设备上下文一样被使用。你保存到的文件名可在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 在Windows系统上，你可以使用wx.PrinterDC访问任何的Windows打印机的 驱动。这个类也是根据一个打印数据对象来创建的—— wx.PrinterDC(printData)。我们将在第17章进一步讨论打印。 373 / 565
- 374. 缓冲设备上下文 第三组设备上下文使你能够缓冲一个设备上下文，直到你准备将之绘制到 屏幕。 wx.BufferedDC wx.BufferedPaintDC 缓冲使你能够发送单独的绘制命令到缓冲区，然后一次性地把它们绘制到 屏幕。当你一下做几个重绘时，这防止了屏幕的闪烁。因此，当做动画或其它 屏幕密集绘制时，缓冲是一个常见的技术。 在wxPython中有两个缓冲设备上下文——wx.BufferedDC，它可被用于缓 冲任何的设备上下文（但是通常只用于wx.ClientDC）；wx.BufferedPaintDC， 它专门被设计用来缓冲一个wx.PaintDC。作为内存设备上下文的一个简单包 装，这两个缓冲上下文的工作方式基本上是一样。wxBufferedDC的构造函数要 求一个设备上下文和一个可选的位图作为参数—— wx.BufferedDC(dc, buffer=None)。另一方面，wx.BufferedPaintDC要求一个窗口 和一个可选的位图作为参数——wx.BufferedPaintDC(dc, buffer=None)。参数dc 是最终你想要绘制到的设备上下文，对于wx.BufferedPaintDC，窗口参数被用 于内在地创建一个wx.PaintDC，buffer参数是一个位图，它被作为临时的缓冲。 如果buffer参数没有指定，那么该设备上下文内在地创建它自己的位图。一旦 缓冲设备上下文被创建，你就可以像其它的设备上下文样使用它。在内部，缓 冲上下文使用一个内存设备上下文和该位图来储存绘制。这样的捷径就是你不 需要做任何特别的事来得到缓冲以绘制到实际的设备上下文。当缓冲设备上下 文被垃圾回收时（通常当该方法结束且它已经退出作用域时），C++销毁函数 触发Blit()，这将绘制缓冲区的内容到实际的设备上下文，而没有更多的工作需 要你做。 12.2.2 如何绘制到设备上下文？ 现在，你已经有了你的设备上下文，你可能想去实际的绘制你自己的一些 图片到它上面。设备上下文概念的一个好处是你应用程序不关心哪种设备上下 文正在被使用——不管是何种设备上下文，绘制命令都一样。 使用wxPython，有许多绘制到设备上下文的方法。设备上下文API定义了 十八种不同的方法，使用你能够在屏幕上绘制。表12.4列出了第一批：它们让 你能够绘制几何图形。除非另作说明，所有这些方法使用当前的画笔绘制线 374 / 565
- 376. 为单位的半径。如果radius为负，那么这个圆的尺寸取值是根据矩形的较小边按比列 来计算的。（准确的公式是radius * dimension） DrawSpline(points)：绘制spline曲线。不使用画刷填充。 FloodFill(x, y, color, style=wx.FLOOD_SURFACE)：使用当前画刷的颜色填充空间。 该算法开始于点(x,y)。如果样式style是wx.FLOOD_SURFACE，那么所有匹配给定 颜色的像素将被重绘。如是样式style是wx.FLOOD_BORDER，那么边框（边界）内 的所有像素都用给定的颜色绘制。 对于所有要求参数x和y的Draw方法，都有相应的Draw...Point方 法，Draw...Point方法使用一个wx.Point的实例参数代替(x,y)；例如 DrawCirclePoint(pt, radius)。如果方法的参数同时有x,y和width,height，那么有 对应的方法Draw...PointSize使用wx.Point和wx.Size代替，例如 DrawRectanglePointSize(pt, sz)。其它的方法也有相应的Draw...Rect版，参数使 用了wx.Rect来代替，如DrawRectangleRect(rect)。 你可以使用GetSize()方法得到设备上下文的尺寸，它返回一个wx.Size实 例。你也可以使用方法GetPixel(x, y)来得到一个特定像素的颜色值，它返回一 个wx.Color实例。 图12.2显示了我们将要使用draw方法和双缓冲构造的图片的一个截图。 图12.2 376 / 565
- 381. 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设 备上下文在OnPaint方法结束时销毁，被销毁时它自动传送self.buffer到一个 wx.PaintDC，因此不需要新的绘制 #2 我们创建了一个与窗口大小相同的缓冲位图，然后将我们的图形绘制到 它。由于我们使用wx.BufferedDC，那么当InitBuffer方法完成时，所被绘制到这 个缓冲上的东西都将绘制到窗口。 12.2.3 如何绘制图像到设备上下文？ 即便是有了本章开始所提及的image和bitmap对象，你仍将需要使用设备上 下文的方法来绘制图像或从一个设备上下文拷贝到另一个，这个过程称为blit。 这个特性的通常用法是绘制一个图像的一部分到设备上下文。这通常被用来使 一个程序可以一个文件中部署它的所有外部的图像，并且使用单独一个blit来只 绘制相应复杂图像或工具栏图标的一部分。 有三个用于绘制图像到设备上下文的法。 381 / 565
- 382. * 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, ysrc），宽高同目标矩形。目标上下文是wx.DC的一个实例， 源是另一个wx.DC实例，它可以是任何其它的wx.DC的子类。 参数logicalFunc是算法，用于合并旧的和新的像素——默认为覆盖，但是 也可以通过或运算来定义不同的行为。在表12.6中，我们将显示一个算法的完 整列表。如果参数useMask为True，那么blit的执行将通过遮罩来控制哪些像素 真正拷贝。在这种情况下，被选择的源区域必须是一个带有相关遮罩或alpha值 的位图。如果设置了参数xsrcMask 和ysrcMask，那么它们控制从遮罩的何处开 始拷贝。如果没有设置xsrcMask 和ysrcMask，那么参数xsrc, ysrc被使用。这里 还有一个blit方法的另一个版本：BlitPointSize()，它使用wx.Point实例代替了blit 中的三个点坐标，使用一个wx.Size代替了width和height。 绘制一个位图 假设你想绘制一个完整的位图到你的设备上下文上，这儿有一对简单的方 法供你使用。要绘制一个位图，你可以使用 DrawBitmap(bitmap,x, y, useMask=False)。参数bitmap是一个wx.Bitmap对象，它 被绘制到设备上下文中的(x,y)处。useMask参数是一个布尔值。如果它是 False，那么该图像被正常绘制。如果为True，并且如果位图有一个相关的遮罩 或alpha值，那么这个遮罩被用来确定位图的哪个部分是透明的。如果这个位图 382 / 565
- 383. 是单色的，那么当前文本的前景色和背景色被用于该位图，否则，该位图自己 的颜色方案被使用。图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
- 385. 12.2.4 如何绘制文本到设备上下文？ 绘制文本到你的设备上下文的方法是DrawText(text, x, y)。要绘制的字符串 传递给text参数，参数x和y是文本的左上角的坐标。对于有角度的文本，使用 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)指定文本是否有一个背景色。如果说你想要文本有一 个背景色，那么mode的值应该为wx.SOLID，如果不想文本有一个背景色，那 么mode的值应该为wx.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
- 386. 12.3 图形处理 图形处理不单单是限于图像和设备上下文。还有另外的抽象的东西使你能 够控制你的绘制。在这一节，我们将讨论用于绘制线条的画笔，用于描绘背景 的画刷，以及像素处理和颜色的名字。 12.3.1 如何使用画笔处理前景色？ 你所绘制在设备上下文上的线条的颜色和样式是通过当前的画笔来控制 的，画笔是类wx.Pen的一个实例。要得到当前的画笔，使用设备上下文的方法 GetPen()。你可以使用SetPen(pen)来设置当前的画笔。 wx.Pen是一个简单的结构，它有几个与绘制线条相关的属性。它的构造函 数让你可以设置一些属性。 wx.Pen(colour, width=1, style=wx.SOLID) 参数colour是一个wx.Colour对象或其它能够被自动转换为RGB值的一个元 组，或一个颜色名，或一个RGB十六进制值的字符串如“#12C588”。参数width 是画笔线条的宽度（像素单位）。参数style控制线条的样式。表12.5显示了参 数style的取值——注意这不是所有平台都支持的样式。 表12.5 wx.Pen的绘制样式 <演示代码> wx.BDIAGONAL_HATCH：画笔将绘制反斜线。 wx.CROSSDIAG_HATCH： wx.BDIAGONAL_HATCH和wx.FDIAGONAL_HATCH 组合，换句话说，它创建一个X的形状。 wx.CROSS_HATCH：+形状的线。 wx.DOT：小点。 wx.DOT_DASH：点划线。 wx.FDIAGONAL_HATCH：正斜线。 wx.HORIZONTAL_HATCH：水平线。 wx.LONG_DASH：虚线。 386 / 565
- 387. 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
- 388. wx.JOIN_MITER：端点延伸，直至相交，中间区域填充。 wx.JOIN_ROUND：端点圆弧连接，中间区域填充。这是默认值。 如果你使用wx.USER_DASH样式创建画笔，那么你可以通过GetDashes()和 SetDashes(dashes)方法设置线条的特殊样式。参数dashes是整数的一个列表。如 果画笔使用了wx.STIPPLE样式，那么你可以使用SetStipple(stipple)来为笔触设 置一个位图，你还可以通过GetStipple()来得到这个位图。 当你正在使用一个画笔绘制的时候（或从另一个位图blit时），在目标上下 文中用来设置像素的算法被称为逻辑功能，并且你可以使用 SetLogicalFunction(function)来设置它。function参数的默认值是wx.COPY，它将 源的颜色放置到目标上。另一个逻辑功能使用源和目标的颜色值执行各种位操 作。最常用的操作是wx.XOR和wx.INVERT，这两个都能被用来管理rubber- banding或者其它的图表机制（像素颜色的临时性设置，之后恢复）。表12.3显 示了算法的一个完整列表 下面的Python位操作符的一个快速复习： &：按位与 |：按位或 ^：按位异或 ~：按位反 表12.6 逻辑复制功能 wx.AND：源&目标 wx.AND_INVERT：~源 & 目标 wx.AND_REVERSE：源 & ~目标 wx.CLEAR：所有像素都设置为0——黑色 wx.COPY：源 wx.EQUIV：~源 ^ 目标 wx.INVERT：~目标 wx.NAND：~源 | ~目标 388 / 565
- 389. wx.NOR：~源 & ~目标 wx.NO_OP：目标 wx.OR：源 | 目标 wx.OR_INVERT：~源 | 目标 wx.OR_REVERSE：源 | 目标 wx.SET：所有像素被设置为1——白 wx.SRC_INVERT：~源 wx.XOR：源 ^ 目标 此外，无论是使用绘制函数或blit，这些逻辑功能可以随时应用于被绘制到 设备上下文的像素。 12.3.2 如何管理背景画刷？ 任何种类的填充操作都是使用设备上下文的当前画刷来管理的，画刷是 wx.Brush的一个实例。你可以使用 GetBrush()得到当前的画刷，使用 SetBrush(brush)设置一个画刷。调用设备上下文的Clear()方法来使用当前的背景 画刷重绘整个设备上下文。 画刷的实现比画笔简单一点。wx.Brush的构造函数如下： wx.Brush(colour, style=wx.SOLID) 参数colour是画刷使用的颜色，通常它可以是一个wx.Colour实例，或一个 RGB元组，或一个字符串。参数style控制画刷如何填充空间，它的取值如下， 它们的含义与对画笔的相同。 wx.BDIAGONAL_HATCH wx.CROSSDIAG_HATCH wx.CROSS_HATCH wx.FDIAGONAL_HATCH wx.HORIZONTAL_HATCH wx.SOLID wx.STIPPLE 389 / 565
- 390. wx.TRANSPARENT wx.VERTICAL_HATCH 颜色和样式可以通过get*和set*方法来处理—— GetColour(), SetColour(colour), GetStyle(), SetStyle()。使用画刷所能做的唯一另 一件事就是使用SetStipple(bitmap)设置stipple模式。如果你为画刷创建了一个 stipple，那么样式也被设置为wx.STIPPLE了。你可以使用GetStipple()来得到 stipple。 自定义样式 我们没有被限制只能使用预定义的样式。我们可以通过使用下面的函数很 容易地创建我们自己的画刷样式，它使用一个位图来创建一个自定义的画刷。 wx.BrushFromBitmap(Bitmap) 12.3.3 如何管理逻辑和物理设备坐标？ 在这一节，我们将讨论wxPython中管理坐标、尺寸等诸如此类的方法。我 们从坐标轴的管理开始。通常，wxPython设备上下文的坐标系是以左上角的 (0,0)为起点的，y坐标向下增长，x坐标向右增长。y轴的方向与你在几何学课 本中所学的相反。你可以使用SetAxisOrientation(xLeftRight,yBottomUp)方法来 改变坐标轴的方向；其中的两个参数都是布尔值。如果xLeftRight为True，那么 x轴的方向是从左到右，否则是从右到左。同样，如果yBottomUp为True，那么 y轴是向上的，否则是向下的。 坐标轴以像素为量度。然而，有时你会想使用非像素单位的量度。你可以 使用SetMapMode(mode)方法，并通过设置参数mode来相应的映射模式来处理 量度的转换。映射模式是设备上下文用于在屏幕的物理坐标和以你所指定量度 单位为单位的逻辑坐标之间作换算的。参数mode的取值见下表12.7。 表12.7 设备上下文映射模式 模式：wx.MM_LOMETRIC 逻辑单位：0.1毫米 模式：wx.MM_METRIC 逻辑单位：1毫米 模式：wx.MM_POINTS 逻辑单位：1磅 390 / 565
- 391. 模式：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,y是左上角的坐标，width和 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
- 392. 开始“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 本章小结 1、在wxPython中，你可以很容易地实现图形的操作，包括图像处理和在 屏幕上绘制。图像是由类wx.Image来管理的，该类是负责处理与平台无关的图 像操作的工具，诸如载入通常图像文件格式的图像。而类wx.Bitmap，它负责 处理与平台相关的图像操作，诸如绘制图像到屏幕。最常用的图像文件格式都 有预定义的图像处理器。一旦你有了一个wx.Image的实例，那么你就能对其做 392 / 565
- 393. 各种有用的过滤操作。你能定义一个透明遮罩色，你也可以定义一系列的alpha 值。 2、位图可以创建自位图文件，或转化自wx.Image对象。把你的图像转化 为位图的唯一的作用是这样才可以将你的图像绘制到屏幕上。 3、你可以创建你自己的光标或使用已有的光标。 4、绘制到屏幕或其它的虚拟设备是由设备上下文的类wx.DC来管理的，它 是一个抽象的类，它定义了与绘制有关的常用API。wx.DC的不同子类使你能 够绘制到屏幕、内存或一个文件、或一个打印机。设备上下文在你的程序中只 应该是局部性的，不应该被存储为全局性的。当绘制到屏幕时，你要根据你是 否在一个EVT_PAINT处理器中来决定你所使用的哪种设备上下文。还有一些设 备上下文，使你能够在一个窗口的客户区域之外绘制或在屏幕上的任一位置绘 制。 5、其它的设备上下文，诸如wx.MemoryDC和wx.BufferedDC，它们使你能 够先绘制到内存，直到你准备将完整的图像显示到屏幕上。wx.BufferedDC和 wx.BufferedPaintDC类是处理缓冲绘制的一种简捷方式。 6、一些不同的方法使你能够绘制线条或几何图形到一个设备上下文。它 们中的许多都有第二个种形式，以接受wx.Size或wx.Point对象参数。你能够绘 制文本到设备上下文，并可以旋转任意的角度。帮助性的方法使你能够管理字 体，并确定你的文本在屏幕中将占据多少空间。 7、除了可以绘制位图到设备上下文，你还可以执行Blit()，这使你能够快 速地将一个设备上下文的部分内容拷贝到另一处。你也可以绘制一个图标到设 备上下文。 8、使用一个wx.Pen实例来控制你的绘制颜色和样式，wx.Pen处理前景绘 制。wx.Brush处理背景填充。在这两种情况中，设备上下文维护对象的当前 值，这个值你将来可以改变。你可以设置wx.Pen和wx.Brush对象的颜色和样 式，对于wx.Pen，你可以管理它的宽度和线条模式。 9、设备上下文是按物理坐标来绘制的，意思是坐标的单位是像素，但是 你能够设置一个对应的英寸或毫米的尺度，并且当你绘制时，再将它们转换为 像素值。你也能够设置clipping区域，它是在你的设备上下文中设置一个矩形区 域，实际的绘制都只是在该区域中发生。“bounding box”则代表已经绘制了的 设备上下文区域，是矩形区域。 393 / 565
- 394. 第三部分 高级wxPython 在这一部分，我们以三个更复杂的窗口部件对象作为开始，并转到并不是 每个wxPython程序都有的特性上来。 在第13章“建造列表控件并管理项目”中，我们涉及到了列表控件。较简单 的列表框更为高级的是，这个列表控件可以用来产生一个十分类似于Windows 资源管理器的东西，包括不同的模式。你将看到如何在模式间进行切换，添加 文本和图像到列表，还有响应用户事件。14章“协调grid控件”为列表增加了grid 控件。grid是十分灵活的，我们将给你展示管理网格中数据的所有方法，以及 自定义网格显示和编辑的机制。第15章“树形控件”处理树形控件，它使你能够 显示树的层次。我们将展示如何管理树的数据，遍历树和自定义树的显示。 在第16章“在你的应用程序中加入HTML”中，我们将展示用HTML来指定 文本标签和打印的样式是多么的便利。我们将给你展示HTML窗口部件是如何 工作的，以及它们关于标准HTML的局限性。第17章“wxPython的打印框架”涉 及到了打印，如何绘制到一个打印机，以及如何管理在wxPython和底层打印系 统间通信的标准打印对话框。我们也将展示如何添加打印预览功能。第18 章“使用wxPython的其它功能”所涉及的东西不是无论哪都适用。这章涉及了通 过剪贴板传递数据以及如何管理拖放操作等方面。我们还将展示如何使用计时 器(timer)创建定时的行为，并提供少量在wxPython应用程序中关于线程方面的 想法。 394 / 565
- 395. 13 建造列表控件并管理项目 本章内容： 创建不同样式的列表控件 处理列表中的项目 响应列表中用户的选择 编辑标签和对列表排序 创建大的列表控件 在wxPython中，有两个控件，你可以用来显示基于列表的信息。较简单的 是列表框，它是可滚动的单列列表，类似于使用HTML的<select>标记所得到 的。列表框已经在第8章中讨论过了，本章不再作进一步的讨论。 本章讨论较为复杂的列表：列表控件，它是一个完整特性的列表窗口部 件。这个列表控件可以每行显示多列信息，并可基于任一行进行排序，还能以 不同的样式显示。对于列表控件的每个部分的细节显示，你有很大的灵活性。 13.1 建造一个列表控件 列表控件能够以下面四种不同模式建造： * 图标(icon) * 小图标(small icon) * 列表(list) * 报告(report) 如果你用过微软Windows的资源管理器(Explorer)或Mac的Finder，那么这些 方式你应该熟悉。我们将通过说明如何建立四种不同模式的列表作为开始来介 绍列表控件。 395 / 565
- 396. 13.1.1 什么是图标模式？ 列表控件看起来类似于微软的Windows资源管理器的一个文件树系统的显 示面板。它以四种模式之一的一种显示一个信息的列表。默认模式是图标模 式，显示在列表中的每个元素都是一个其下带有文本的一个图标。图13.1显示 了一个图标模式的列表。 例13.1是产生图13.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
- 397. self.list.InsertImageStringItem(x, ”This is item %02d” % x, img) app = wx.PySimpleApp() frame = DemoFrame() frame.Show() app.MainLoop() 图13.1 在例13.1中，DemoFrame创建了一个“image list（图像列表）”来包含对要 显示的图像的引用，然后它建造并扩充了这个列表控件。我们将在本章稍后的 部分讨论“image list（图像列表）”。 13.1.2 什么是小图标模式？ 小图标模式类似标准的图标模式，但是图标更小点。图13.2以小图标模式 显示了相同的列表。 当你想在窗口部件中放入更多的显示项目时，小图标模式是最有用的，尤 其是当图标不够精细时。 397 / 565
- 399. # 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
- 401. 13.1.4什么是报告模式 在报告模式中，列表显示为真正的多列格式，每行可以有任一数量的列， 如图13.4所示。 图13.4 报告模式与图标模式不尽相同。例13.2显示了图13.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
- 402. bmp = 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 -*- 在接下来的部分，我们将讨论如何将值插入适当的位置。报告控件是最适 合用于那些包含一两个附加的数据列的简单列表，它的显示逻辑没有打算做得 很复杂。如果你的列表控件复杂的话，或包含更多的数据的话，那么建议你使 用grid控件，说明见第14章。 402 / 565
- 403. 13.1.5 如何创建一个列表控件？ 一个wxPython列表控件是类wx.ListCtrl的一个实例。它的构造函数与其它 的窗口部件的构造函数相似： wx.ListCtrl(parent, id, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.LC_ICON, validator=wx.DefaultValidator, name=”listCtrl”) 这些参数我们在其它的窗口部件的构造函数中见过。参数parent是容器部 件，id是wxPython标识符，使用-1表明自动创建标识符。具体的布局由参数pos 和size来管理。style控制模式和其它的显示方案——贯穿本章，我们都将看到 这些值。参数validator用于验证特定的输入，我们在第9章讨论过。参数name我 们很少使用。 样式（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_LEFT。样式LC_AUTOARRANGE使得当图标排列到达窗口 右或底边时自动换行或换列。 表13.2显示了作用于报告列表显示的样式。 表13.2 报告列表的显示样式 wx.LC_HRULES：在列表的行与行间显示网格线（水平分隔线） wx.LC_NO_HEADER：不显示列标题 403 / 565
- 404. 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
- 405. 参数width和height指定了添加到列表中的图像的像素尺寸。比指定大小大 的图像是不允许的。参数mask是一个布尔值。如果为True，假如图像有遮罩， 则使用遮罩绘制图像。参数initialCount设置列表的初始的内在尺寸。如果你知 道列表会很大，那么指定初始量可以获得更多的内存分配以便稍后使用。 添加及移去图像 你可以使用方法Add(bitmap, mask=wx.NullBitmap)来将一个图像添加到列 表，参数bitmap和mask都是wx.Bitmap的实例。mask参数是一个单色位图，它 代表该图像的透明部分，如果指定了mask参数的话。如果位图已经有一个与之 相关的遮罩，那么该遮罩被默认使用。如果位图没有一个遮罩，并且你不使用 单色透明映射，但设置了该位图的一个特定颜色作为这个透明色的话，那么你 可以使用AddWithColourMask(bitmap，colour)方法，其中参数colour是用作遮罩 的wxPython颜色（或它的颜色名）。如果你有一个wx.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)修改特定索引相关的位图，其中 index是列表中要修改处的索引，bitmap和mask与Add()方法中的一样。如果要 修改的项目是一个图标，可以使用方法ReplaceIcon(index, icon)。这里没有处理 颜色遮罩的替换方法。 405 / 565
- 406. 使用图像列表 通过使用方法GetImageCount()，你能够得到图像列表的长度，使用 GetSize()方法，你可以得到其中个个图像的尺寸，它返回一个(width, height)元 组。 在列表控件上下文中没有直接相关的图像的时候，你也可以根据图像列表 绘制一个图像到设备上下文中。关于设备上下文的更多信息，请看第6章和第 12章。这个方法是Draw，如下所示： Draw(index, dc, x, y, flags=wx.IMAGELIST_DRAW_NORMAL, solid”302.files/”> 在这个调用中，参数index是要绘制的项目在图像列表中的索引，参数dc是 要绘制到的一个wx.DC设备上下文。flags控制图像被如何绘制，flags的可取值 有 wx.IMAGELIST_DRAW_NORMAL, wx.IMAGELIST_DRAW_TRANSPARENT, wx.IMAGELISTDRAW_SelectED, 和 wx.IMAGELIST_DRAW_FOCUSED。如果 solidBackground为True，那么该绘制方法使用一个更快的算法工作。 一旦你有了一个图像列表，你就需要将它附给列表控件。这个以通过后面 的任一个方法来实现：AssignImage(imageList, which)或 SetImage(imageList, which)。imageList参数是一个图像列表，参数which是标记 值：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
- 407. 13.2.2 如何对一个列表添加或删除项目？ 在你能显示一个列表之前，你需要给它增加文本信息。在一个图标列表 中，你可以增加新的项目如图标、字符串或两个都添加。在一个报告视图中， 你也可以在设置了初始图标和/或字符串后，为一行中的不同的列设置信息。用 于处理列表控件项目的方法的API及其命名习惯与迄今为止我们所见过的其它 一些控件的是有区别的，因此，尽管你已经理解了菜单或列表框是如何工作 的，但是你仍将需要读这一节。 对于一个图标列表，增加文本信息到列表控件是一个单步的处理过程，但 是对于一个报告列表就需要多步才行。通常对于每个列表，第一步是在行中增 加第一个项目。对于报告列表，你必须分别地增加列和列中的信息，而非最左 边的一个。 增加一个新行 要增加一个新行，使用InsertItem()这类的一种方法。具体所用的方法依赖 于你所插入的项目的类型。如果你仅仅插入一个字符串到列表中，使用 InsertStringItem(index, label)，其中的index是要插入并显示新项目的行的索引。 如果你只插入一个图像，那么使用InsertImageItem(index, imageIndex)。在这种 情况下，这index是要插入图像的行的索引，imageIndex是附加到该列表控件的 图像列表中的图像的索引。要插入一个图像项目，图像列表必须已经被创建并 赋值。如果你使用的图像索引超出了图像列表的边界，那么你将得到一个空图 像。如果你想增加一个既有图像又有字符串标签的项目，使用 InsertImageStringItem(index, label, imageIndex)。这个方法综合了前面两个方法 的参数，参数的意义不变。 在内部，列表控件使用类wx.ListItem的实例来管理有关它的项目的信息。 我还要说的是，最后一种插入项目到列表控件中方法是InsertItem(index, item)， 其中的item是wx.ListItem的一个实例。对于wx.ListItem，这里我们不将做很详 细的说明，这是因为你几乎不会用到它并且该类也不很复杂——它几乎都是由 get*和set*方法组成的。一个列表项的几乎所有属性都可通过列表控件的方法来 访问。 增加列 要增加报告模式的列表控件的列，先要创建列，然后设置每行/列对的单独 的数据单元格。使用InsertColumn()方法创建列，它的语法如下： InsertColumn(col, heading, format=wx.LIST_FORMAT_LEFT, width=-1) 407 / 565
- 408. 在这个方法中，参数col是列表中的新列的索引，你必须提供这个值。参数 heading是列标题。参数format控件列中文本的对齐方式，取值有： wx.LIST_FORMAT_CENTRE、wx.LIST_FORMAT_LEFT、 和 wx.LIST_FORMAT_RIGHT。 参数width是列的初始显示宽度（像素单位）——用户可以通过拖动列的头 部的边来改变它的宽度。要使用一个wx.ListItem对象来设置列的话，也有一个 名为InsertColumnInfo(info)的方法，它要求一个列表项作为参数。 设置多列列表中的值 你可能已经注意到使用前面说明的行的方法来插入项目，对于一个多列的 报告列表来说只能设置最初的那列。要在另外的列中设置字符串，可以使用方 法SetStringItem()。 SetStringItem(index, col, label, imageId=-1) 参数index和col是你要设置的单元格的行和列的索引。你可以设定col为0来 设置第一列，但是参数index必须对应列表控件中已有的行——换句话说，这个 方法只能对已有的行使用。参数label是显示在单元格中文本，参数imageId是图 像列表中的索引（如果你想在单元格中显示一个图像的话可以设置这个参 数）。 SetStringItem()是SetItem(info)方法的一种特殊情况，SetItem(info)方法要求 一个wx.ListItem实例。要使用这个方法，在将wx.ListItem实例增加到一个列表 之前，要先设置它行，列和其它的参数。你也可以使用GetItem(index,col=0)方 法来得到单元格处的wx.ListItem实例，默认情况下，该方法返回一行的第一 列，你可以通过设置参数col来选择其它列的一项。 项目属性 有许多的get*和set*方法使你能够指定部分项目。通常这些方法工作在一行 的第一列上。要得工作在其它的列上，你需要使用GetItem()来得到项目，并使 用项目类的get*和set*方法。你可以使用SetItemImage(item, image, selImage)来 为一个项目设置图像，其中的item参数是该项目在列表中的索引，image和 selImage都是图像列表中的索引，分别代表通常显示的图像和被选中时显示的 图像。你可以通过使用GetItemText(item)和SetItemText(item,text)方法来得到或 设置一个项目的文本。 408 / 565
- 409. 你可以使用GetItemState(item,stateMask)和 SetItemState(item, state, stateMask)来得到或设置单独一个项目的状态。state和 stateMask的取值见表13.3。参数state（及GetItemState的返回值）是项目的实际 状态，stateMask是当前关注的所有可能值的一个掩码。 你可以使用GetColumn(col)来得到一个指定的列，它返回索引col处的列的 wx.ListItem实例。 表13.3 状态掩码参数 状态及说明如下： wx.LIST_STATE_CUT：被剪切状态。这个状态只在微软Windows下有效。 wx.LIST_STATE_DONTCARE：无关状态。这个状态只在微软Windows下有效。 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_USEHEADER可能只自动地将列宽度设置到80像素。 如果你对已有的索引不清楚了，你可以查询列表中项目的数量。方法有 GetColumnCount()，它返回列表中所定义的列的数量，GetItemCount()返回行的 数量。如果你的列表是列表模式，那么方法GetCountPerPage()返回每列中项目 的数量。 要从列表中删除项目，使用DeleteItem(item)方法，参数item是项目在列表 中的索引。如果你想一次删除所有的项目，可以使用DeleteAllItems()或 ClearAll()。你可以使用DeleteColumn(col)删除一列，col是列的索引。 409 / 565
- 410. 13.3 响应用户 通常，一个列表控件在当用户选择了列表中的一个项目后都要做一些事 情。在接下来的部分， 我们将展示一个列表控件都能响应哪些事件，并提供一 个使用列表控件事件的例子。 13.3.1 如何响应用户在列表中的选择？ 像别的控件一样，列表控件也触发事件以响应用户的动作。你可以像我们 在第三章那样使用Bind()方法为这些 事件设置处理器。所有这些事件处理器都接受一个wx.ListEvent实 例，wx.ListEvent是wx.CommandEvent的子类。wx.ListEvent有少量专用的get* 方法。某些属性只对特定的事件类型有效，这些特定的事件类型在本章的另外 部分说明。适用于所有事件类型的属性见表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
- 411. 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.ListEvent对象有另一个方法：GetColumn()，该方 法返回产生事件的列的索引。如果事件是一个列边框的拖动事件，那么这个索 引是所拖动的边框的左边位置。如果事件是一个敲击所触发的，且敲击不在列 内，那么该方法返回－1。表13.6包含了列事件类型的列表。 表13.6 列表控件列事件类型 EVT_LIST_COL_BEGIN_DRAG：当用户开始拖动一个列的边框时，触发该事件 EVT_LIST_COL_CLICK：列表首部内的一个敲击将触发该事件 EVT_LIST_COL_RIGHT_CLICK：列表首部内的一个右击将触发该事件 411 / 565
- 412. 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
- 417. 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
- 418. 个编辑会话）。按下Esc键则取消编辑会话，这样的话，新输入的文本就没有 用了。 下面的两个事件类型是由编辑会话触发的。 * EVT_LIST_BEGIN_LABEL_EDIT * EVT_LIST_END_LABEL_EDIT 记住，如果你想事件在被你的自定义的事件处理器处理后继续被处理，那 么你需要在你的事件处理器中包括Skip()调用。当用户开始一个编辑会话时， 一个EVT_LIST_BEGIN_LABEL_EDIT类型的列表事件被触发，当会话结束时 （通过使用Enter或Esc），EVT_LIST_END_LABEL_EDIT类型的列表事件被触 发。你可以否决(veto)编辑事件的开始，这样编辑会话就不会开始了。否决编辑 事件的结束将阻止列表文本的改变。 wx.ListEvent类有两个属性，这两个属性只在当处理一个 EVT_LIST_END_LABEL_EDIT事件时才会用到。如果编辑结束并确认 后，GetLabel()返回列表项目标签的新文本，如果编辑被Esc键取消了，那么 GetLabel()返回一个空字符串。这意味着你不能使用GetLabel()来区别“取 消”和“用户故意输入的空字符串标签”。如果必须的话，可以使用 IsEditCancelled()，它在因取消而导致的编辑结束时返回True，否则返回False。 如果你想通过其它的用户事件来启动一个编辑会话的话，你可以在程序中 使用列表控件的EditLabel(item)方法来触发一个编辑。其中的item参数是是要被 编辑的列表项的索引。该方法触发EVT_LIST_BEGIN_LABEL_EDIT事件。 如果你愿意直接处理用于列表项编辑控件，你可以使用列表控件的方法 GetEditControl()来得到该编辑控件。该方法返回用于当前编辑的文本控件。如 果当前没有编辑，该方法返回None。目前该方法只工作于Windows操作系统 下。 13.4.2 如何对列表排序？ 在wxPython中有三个有用的方法可以对列表进行排序，在这一节，我们将 按照从易到难的顺序来讨论。 418 / 565
- 419. 在创建的时候告诉列表去排序 对一个列表控件排序的最容易的方法，是在构造函数中告诉该列表控件对 项目进行排序。你可以通过使用样式标记wx.LC_SORT_ASCENDING或 wx.LC_SORT_DESCENDING来实现。这两个标记导致了列表在初始显示的时 候被排序，并且在Windows上，当新的项目被添加时，依然遵循所样式标记来 排序。对于每个列表项的数据的排序，是基于其字符串文本的，只是简单的对 字符串进行比较。如果列表是报告模式的，则排序是基于每行的最左边的列的 字符串的。 基于数据而非所显示的文本来排序 有时，你想根据其它方面而非列表标签的字符串来对列表排序。在 wxPython中，你可以做到这一点，但这是较为复杂的。首先，你需要为列表中 的每个项目设置项目数据，这通过使用SetItemData(item, data)方法。参数item是 项目在未排序的列表中的索引，参数data必须是一个整形或长整形的值（由于C ++的数据类型的限制），这就有点限制了该机制的作用。如果要获取某行的项 目数据，可以使用方法GetItemData(item)。 一旦你设置了项目数据，你就可以使用方法SortItems(func)来排序项目。参 数func是一个可调用的Python对象（函数），它需要两个整数。func函数对两个 列表项目的数据进行比较——你不能得到行自身的引用。如果第一项比第二项 大的话，函数将返回一个正整数，如果第一项比第二项小的话，返回一个负 值，如果相等则返回0。尽管实现这个函数的最显而易见的方法是只对这两个 项目做一个数字的比较就可以了，但是这并不唯一的排序方法。比如，数据项 可能是外部字典或列表中的一个关键字，与该关键字相应的是一个更复杂的数 据项，这种情况下，你可以通过比较与该关键字相应的数据项来排序。 使用mixin类进行列排序 关于对一个列表控件进行排序的常见的情况是，让用户能够通过在报告模 式的列表的任一列上进行敲击来根据该列进行排序。你可以使用SortItems()机 制来实现，但是它在保持到列的跟踪方面有点复杂。幸运的是，一个名为 ColumnSorterMixin的wxPython的mixin类可以为你处理这些信息，它位于 wx.lib.mixins.listctrl模块中。图13.5显示了使用该mixin类对列进行的排序。 419 / 565
- 420. 图13.5 声明这个mixin就和Python中声明任何其它的多重继承一样，如下所示： 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.4是图13.5的例子代码 例13.4 使用mixin对一个报告列表进行排序 #!/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
- 422. # 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工作，你需要执行下面的东西： 1、扩展自ColumnSorterMixin的类（这里是DemoFrame）必须有一个名为 GetListCtrl()的方法，它返回实际要被排序的列表控件。该方法被这个mixin用 来得到控件的一个索引。 2、在扩展自ColumnSorterMixin的类（这里是DemoFrame）的__init__()方 法中，在你调用ColumnSorterMixin的__init__()方法之前，你必须创建 GetListCtrl()所要引用的列表控件。该mixin的__init__()方法要求一个代表列表 控件中的列号的整数值。 3、你必须使用SetItemData()为列表中的每行设置一个唯一的数据值。 422 / 565
- 423. 4、扩展自ColumnSorterMixin的类（这里是DemoFrame）必须有一个名为 itemDataMap的属性。该属性必须是一个字典。字典中的关键性的东西是由 SetItemData()设置的数据值。这些值是你想用来对每列进行排序的值的一个元 组。（典型情况下，这些值将是每列中的文本）。按句话说，itemDataMap本 质上是将控件中的数据复制成另一种易于排序的形式。 在ColumnSorterMixin的通常用法中，你要么创建itemDataMap用来添加项 目到你的列表控件，要么你首先创建itemDataMap，并用它来建造列表控件本 身。 尽管配置可能有点复杂，但ColumnSorterMixin对于列的排序是一个不错的 选择。 13.4.3 进一步了解列表控件 有时候，在你的程序中的某处你需要确定列表中的哪个项目被选择了，或 者你需要通过编程来改变当前的选择以响应用户事件，或其它发生在你的程序 中的一些事情。 有几个与查找列表中的一个项目的索引相关的方法，它们提供了项目的一 些信息，如表13.7所示。 表13.8显示出了由HitTest()方法返回的可能的标记。实际应用中，可能返回 不止一个标记。 表13.7 查找列表中的项目的方法 FindItem(start, str, partial=False)：查找第一个与str匹配的项目。如果start为－1，那 么搜索从头开始，否则搜索从start的指定的索引处开始。如果partial为True，那么这 个匹配是匹配以str头的字符串，而非完全匹配。返回值是所匹配的字符串的索引。 FindItemAtPos(start，point, direction)：查找与最接近位置点point的项目，point是一 个wx.Point，它是相对于列表控件左上角的位置。参数direction是查找进行的方向。 可能的取值 有 wx.LIST_FIND_DOWN, wx.LIST_FIND_LEFT, wx.LIST_FIND_RIGHT, 和 wx.LIST_FIND_UP。 FindItemData(start,data)：查找项目数据（使用SetItemData()设置的）与参数data匹 配的项目。参数start同FindItem()。 423 / 565
- 425. GetNextItem(item, geometry=wx.LIST_ALL, state=wx.LIST_STATE_DONTCARE ) ：根据geometry和state参数，返回列表中位于item所指定的项目之后的下一个项 目。其中的geometry和state参数，它们都有自己的取值，后面的列表将有说明。 SetItemPosition(item, pos)：将item所指定的项目移动到pos所指定的位置处。只对 图标或小图标模式的列表有意义。 表13.10列出了用于GetNextItem()的geometry参数的取值。geometry参数只 用于微软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.11列出了用于GetNextItem()的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
- 426. 表13.2 列表控件的显示属性 GetBackgroundColour() SetBackgroundColour(col)：处理整个列表控件的背景色。参数col是一个wx.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)：使用控件滚动。参数dy是垂直量，dx是水平量，单位是像素。对 于图标、小图标或报告模式，单位是像素。如果是列表模式，那么单位是列数。 上面的这些表涉及了一个列表控件的大多数功能。然而到目前为止，我们 所见过的所有的列表控件，它们被限制为：在程序的运行期间，它们的所有数 据必须存在于内存中。在下一节，我们将讨论一个机制，这个机制仅在数据需 要被显示时，才提供列表数据。 13.5 创建一个虚列表控件 让我们设想你的wxPython应用程序需要去显示包含你所有客户的一个列 表。开始时你使用一个标准的列表控件，并且它工作的很好。后来人的客户列 426 / 565
- 427. 表变得越来越大，太多的客户使得你的应用程序开始出现了效率问题。这时你 的程序起动所需的时间变得较长了，并占用越来越多的内存。你怎么办呢？你 可以创建一个虚的列表控件。 问题的实质就是列表控件的数据处理。通常，这些数据都是从数据产生的 地方将数据拷贝到列表控件中。这是潜在地浪费资源，对于一个小的列表，这 好象看不出任何问题，但对于创建一个较大的列表控件，这将占用很多的内 存，并导致启动变慢。 为了将一个列表控件所占的内存和启动所需的时间降到最小化，wxPython 允许你去声明一个虚的列表控件，这意味关于每项的信息只在控件需要去显示 该项时才生成。这就防止了控件一开始就将每项存储到它的内存空间中，并且 这也意味着在启动时，并没有声明完整的列表控件。同时这个方案的缺点就是 虚列表中的列表项的恢复可能变得较慢。图13.6显示了一个虚列表。 例13.5显示了产生该虚列表控件的完整代码 图13.6 例13.5 一个虚列表控件 #!/usr/bin/python #-*- encoding:UTF-8 -*- import wx import sys, glob, random 427 / 565
- 429. 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标记如#1。通常使用子类wx.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
- 430. 有时在虚列表的初始化期间，必须调用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)。它 的返回值是较早声明的列表控件的图像列中的一个整数索引。如果你没有覆盖 这个方法，那么基类版本的OnGetItemImage将返回－1，这表明不显示图像。 如果你想改变行的一些显示属性，那么你可以覆盖OnGetItemAttr(item)方 法，item是行的索引，该方法返回类wx.ListItemAttr的一个实例。该类有一些 get*和set*方法可以用来设置行的颜色、对齐方式等等显示属性。 如果你的虚列表所基于的数据改变了，而你想更新显示，那么你可以使用 该列表控件的RefreshItem(item)来重绘特定的行。相关的方法 RefreshItems(itemFrom,itemTo)重绘位于索引itemFrom和itemTo间的所有行。 为了对数据源中的数据的获取提供优化帮助，对于要显示一页新的数据， 虚列表控件会发送EVT_LIST_CACHE_HINT事件。这将给你的数据源一个时机 用以从数据库（或另处）一次获取几个记录并保存它们。这样就使得随后的 OnGetItemText()执行的更快。 13.6 本章小结 1、列表控件是wxPython用于显示列表信息的窗口部件。它比简单的列表 框部件要更复杂且有完整的特性。列表控件是类wx.ListCtrl的实例。列表控件 可以显示为图标模式，每个图标下都有一个项目文本，也可以显示为带有小图 标的小图标模式等等。在列表模式中，元素按列显示，在报告模式中，以多列 的格式显示列表，每列都有列标签。 430 / 565
- 431. 2、用于列表控件的图像是由一个图像列表管理的，图像列表是一个可经 由索引来访问的一个图像的数组。列表控件可以为不同的列表模式维护各自的 图像列表，这使得能够容易地在模式间切换。 3、你可以使用InsertStringItem(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。 5、如果列表控件声明时使用了wx.LC_EDIT_LABELS标记，那么用户就可 以编辑列表项的文本。编辑的确认是通过按下回车键或在列表中敲击完成的， 也可以通过按下Esc键来取消编辑。 6、你可以通过在声明列表时使用wx.LC_SORT_ASCENDING或 wx.LC_SORT_DESCENDING来排序列表。这将按照项目的字符串的顺序来排 序列表。在报告模式中，这将根据0列的字符串来排序。你也可以使用 SortItems(func)方法来创建你自定义的排序方法。对于报告模式的列表，mixin 类wx.lib.mixins.listctrl.ColumnSorterMixin给了你根据用户所选择的列来排序的 能力。 7、使用了标记wx.LC_VIRTUAL声明的列表控件是一个虚列表控件。这意 味着它的数据是当列表中的项目被显示时动态地确定的。对于虚列表控件，你 必须覆盖OnGetItemText(item, col)方法以返回适当的文本给所显示的行和列。 你也可以使用OnGetItemImage(item)和OnGetItemAttr(item)方法来返回关于每行 的图像或列表的显示属性。如果数据源的数据改变了，你可以使用 RefreshItem(item)方法来更新列表的某个行或使用 RefreshItems(itemFrom, itemTo)方法来更新多个行。 最终，你的数据将变得复杂得不能放在一个简单的列表中。你将会需要类 似二维的电子表格样式的东西，这就是网格控件，我们将在下一章进行讨论。 431 / 565
- 432. 14 网格(grid)控件 本章内容包括: 创建网格(grid) 添加行和单元格(cell),并且处理列的首部 使用一个自定义的单元格(cell)描绘器(renderer) 创建自定义的编辑器 捕获用户事件 网格控件大概是wxPython中最复杂和最灵活的一个窗口部件。在这一章， 你将有机会接触到这个控件的许多特性。我们将讨论如何输入数据到网格控件 以及如何处理该控件的显示属性，并且我们还将讨论自定义编辑器和描绘器。 网格控件使你能够在一个类似电子表格格式的网格中显示表格数据。该控件允 许你为行和列指定标签，以及通过拖动网格线来改变网格的大小，并且可以为 每个单元格单独指定字体和颜色属性。 在最常见的情况下，你一般会显示一个简单的字符串值。然而，你也能为 任一单元格指定一个自定义的描绘器，以使你能够显示不同的数据；你可以有 编辑表中的单元格，并且对不同的数据使用不同类型的编辑器。你还能够创建 你自己自定义的描绘器和编辑器，这使得你在单元格数据的显示和处理上可以 非常的灵活，几乎没有什么限制。网格控件还有大量的鼠标和键盘事件，你可 以程序中捕获它们并用来触发相关的代码。 我们将通过展示两个创建wxPython网格的方法来作为我们讨论的开始。 14.1 创建你的网格 网格控件是用以显示一个二维的数据集的。要使用该控件显示有用的信 息，你需要告诉该控件它工作所基于的是什么数据。在wxPython中，有两种不 同的机制用于在网格控件中处理数据，它们之间在处理数据的添加，删除和编 辑的方式上有些许的不同。 * 网格控件可以直接处理每行和每列中的值。 432 / 565
- 433. * 数据可以通过使用一个网格表(grid table)来间接地处理。 较简单的一种是使用网格控件直接处理值。在这种情况下，网格维护着数 据的一份拷贝。在这种情况下，如果有大量的数据或你的应用程序已经有了一 个现存的网格类的数据结构，那么这可能显得比较笨拙。如果是这样，你可以 使用一个网格表来处理该网格的数据。参见第5章来回顾一下在MVC架构中， 网格表是如何被作为一个模型的。 14.1.1 如何创建一个简单的网格？ 尽管网格控件有大量的方法用于控件精确的显示和数据的管理，但时开始 使用一个网格控件是十分简单的。图14.1显示了一个简单的网格，其中的单元 格中添加了一些字符串数据。 图14.1 网格控件是类wx.grid.Grid的实例。由于网格类及相关类的尺寸的原因，实 际中许多的程序都不使用它，wxPython的网格类存在于它们自己的模块中，它 们不会被自动导入到核心的名字空间中。wx.grid.Grid的构造函数类似于其它的 控件的构造函数。 wx.grid.Grid(parent, id, pos=wx.DefaultPosition, 433 / 565
- 434. size=wx.DefaultSize, style=wx.WANTS_CHARS, name=wxPanelNameStr) 其中的所有的参数与wx.Window的构造函数是相同的，并且有相同的意 义。wx.WANTS_CHARS样式是网格的默认样式，除此之外，wx.grid.Grid没有 为自己定义特别的样式。由于网格类的复杂性，所以在程序中，你一般要自定 义网格类的一个子类来实现一个网格，而非直接使用wx.grid.Grid的一个实例。 和我们所见过的别的控件不同，调用该构造函数不足以创建一个可用的网 格。有两个方法用以初始化网格 * CreateGrid() * SetTable() 在这一节，我们将讨论一个方法，第二个方法将在网格表的讨论中提及。 要显式地初始化网格，可以使用方法 CreateGrid(numRows, numCols, selmode=wx.grid.Grid.SelectCells)。这个方法应 该在构造函数之后被直接地调用，并用必须在网格被显示之前调用。参数 numRows, numCols指定了网格的初始大小。参数selmode指定了网格中单元格 的选择模式，默认值是wx.grid.Grid.SelectCells，意思是一次只选择一个单元 格。其它的值有wx.grid.Grid.SelectRows，意思是一次选择整个 行，wx.grid.Grid.SelectionColumns，意思是一次选择整个列。创建之后，你可 以使用方法GetSelectionMode()来访问选择模式，并且你可以使用方法 SetSelectionMode(mode)来重置模式。你还可以使用方法GetNumberCols()和 GetNumberRows()来得到行和列数。 在内部，使用CreateGrid()初始化网格之后，wxPython设置了一个二维的字 符串数组。一旦网格被初始化了，你就可以使用方法SetCellValue(row, col, s)来 放置数据。其中参数row, col是要设置的单元格的坐标，s是要在该坐标处显示 的字符串文本。如果你想获取特定坐标处的值，你可以使用函数 GetCellValue(row, col)，该函数返回字符串。要一次清空整个网格，你可以使用 方法ClearGrid()。例14.1显示了产生图14.1的代码。 例14.1 使用ClearGrid()创建的一个示例网格 import wx import wx.grid class TestFrame(wx.Frame): 434 / 565
- 435. 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 如何使用网格表来创建一个网格？ 对于较复杂的情况，你可以将你的数据保存在一个网格表中，网格表是一 个单独的类，它存储数据并与网格控件交互以显示数据。推荐在下列情况下使 用网格表： * 网格的数据比较复杂 * 数据存储在你的系统中的另外的对象中 * 网格太大以致于不能一次整个被存储到内存中 在第5章中，我们在MVC设计模式中讨论了网格表以及在你的应用程序中 实现一个网格表的不同方法。在本章，我们将重点放在对网格表的使用上。图 14.2显示了使用网格表创建的一个网格。 435 / 565
- 438. 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的子类。 要使网格表有效，你必须覆盖5个方法。表14.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)方法。 其中参数table是你的wx.grid.PyGridTableBase的实例。参数takeOwnership使得网 格控件拥有这个表。如果takeOwnership为True，那么当网格被删除时，该表也 被wxPython系统删除。参数selmode作用等同于在CreateGrid()中的作用。 还有一些其它的方法你可以覆盖，以处理网格的各部分，而非表的数据。 在本章的稍后部分，我们将讨论这些方法中的一些。并且，我们将看到在某些 438 / 565
- 439. 情况中，使用SetTable创建的表的行为与使用CreateGrid()创建的表的行为是不 同的。 你能够覆盖的另一个方法是Clear()，它在当对网格调用ClearGrid()时被调 用，如果适当的话，你可以覆盖该方法来清除潜在的数据源。在网格中置入数 据了以后，你现在可以开始对网格作各种有兴趣的事情了。在下一节，我们将 给你展示如何处理网格的外观。 14.2 使用网格工作 一旦网格被创建并初始化了，你就可以用很多不同的方法来处理它了。单 元格、行或列可以被添加和删除。你可以增加首部，改变一行或一列的大小， 并可以用代码的方式来改变网格的可见部分或被选择的部分。下面的几节，我 们将涉及这些内容。 14.2.1 如何添加、删除行，列和单元格？ 在网格被创建之后，你仍然可以添加新的行和列。注意，依据网格的创建 方法不同，该机制的工作也不同。你可以使用AppendCols(numCols=1)方法在你 的网格的右边增加一列。使用AppendRows(numRows=1)在网格的底部增加一 行。 如果不是想在网格的行或列的最后添加一行或一列，你可以使用方法 InsertCols(pos=0, numCols=1)或InsertRows(pos=1, numRows=1)来在指定位置添 加。其中参数pos代表被添加的新元素中第一个的索引。如果参数numRows或 numCols大于1 ，那么有更多的元素被添加到起始位置的右边（对于列来说）， 或起始位置的下边（对于行来说）。 要删除一行或一列，你可以使用方法DeleteCols(pos=0, numCols=1)和 DeleteRows(pos=0, numRows=1)。其中参数pos是要被删除的行或列的第一个的 索引。 如果网格是使用CreateGrid()方法被初始化的，那么上面讨论的方法总是可 以工作的，并且在新的行或列中创建的单元格是以一个空字符串从为初始值 的。如果网是使用SetTable()方法被初始化的，那么网格表必须支持对表的改 变。 要支持改变，你的网格表要对同样的改变方法进行覆盖。例如，如果你对 你的网格调用了InsertCols()方法，那么网格表也必须声明一个 InsertCols(pos=0, numCols=1)方法。该网格表的这个方法返回布尔值True表示支 439 / 565
- 440. 持改变，返回False则否决改变。例如，要创建一个只允许被扩展到50行的一个 表，可以在你的网格表中写上下面的方法。 def AppendRows(self, numRows=1): return (self.GetRowCount() + numRows) <= 50 某些对网格的改变不会立即被显示出来，而是要等待网格被刷新。你可能 通过使用ForceRefresh()方法来触发一个即时的刷新。在通常情况下，如果你用 代码的方式来改变你的网格，则改变不会立即显示出来，那么插入对 ForceRefresh()方法的调用可以确保你的改变即时的显示出来。 如果你在对一个网格作一个大量的改变，而你在改变期间不想让网格的显 示产生闪烁的话，你可以通过使用BeginBatch()方法来告诉该网格去作一个批量 的处理。该方法将针对网格作一个内在的增量计数。你也必须在批量的任务之 后调用EndBatch()——该方法针对网格作一个内在的减量计数。当计数值比0大 时，表明正处于开始和结束计数之间，网格这时不会重绘。如果必要的话，你 还可以在批量处理中再嵌套批量处理。同样，在全部的批量处理没有完成时， 网格不会重绘。 14.2.2 如何处理一个网格的行和列的首部？ 在一个wxPython的网格控件中，每行和每列都有它们自己的标签。默认情 况下，行的标签是数字，从1开坮。列的标签是字母，从A开始。wxPython提供 了一些方法来改变这些标签。图14.3显示了一个带有首部标签的网格。 图14.3 例子14.3显示了产生图14.3的代码。其中网格是用CreateGrid()初始化的。 440 / 565
- 441. 例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)方法来设置标签值，如#1所示。参数col和row是列 和行的索引，value是要显示在标签中的字符串。要得到一行或一列的标签，使 用GetColLabelValue(col)和GetRowLabelValue(row)方法。 对于使用外部网格表的一个网格控件，你可以通过覆盖网格表的 GetColLabelValue(col)和GetRowLabelValue(row)方法来达到相同的作用。为了 消除混淆，网格控件在当它需要显示标签并且网格有一个关联的表时，内在地 调用这些方法。由于返回值是动态地由你在覆盖的方法中所写的代码决定的， 所以这里不需要覆盖或调用set*方法。不过set*方法仍然存在—— 441 / 565
- 443. 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_CENTRE或wx.ALIGN_RIGHT。参数vert用以控 制垂直对齐方式，取值有wx.ALIGN_TOP, wx.ALIGN_CENTRE,或 wx.ALIGN_BOTTOM。 行和列的标签区域共享一套颜色和字体属性。你可以使用 SetLabelBackgroundColour(colour) , SetLabelFont(font), and SetLabelTextColour(colour)方法来处理这些属性。 参数colour是wx.Colour的一个实例或wxPython会转换为颜色的东西，如颜色的 字符串名。参数font是wx.Font的一个实例。与set*相应的get*方法有 GetLabelBackgoundColour(), GetLabelFont()，和GetLabelTextFont()。 14.2.3 如何管理网格元素的尺寸？ 网格控件提供了几个不同的方法来管理单元格、行和列的尺寸。在这一 节，我们将讨论这些方法。图14.4显示了一些用来改变一个特定的单元格的尺 寸的方法。 例14.5显示了创建了一个带有可调节大小的单元格、行和列的网格。 443 / 565
- 445. 改变单元格的尺寸 一个作用于单元格尺寸的基本的方法是使它跨多行或多列，类似于HTML 的rowspan和colspan。要达到这种效果，在wxPython中可以使用方法 SetCellSize(row, col, num_rows, num_cols)。该方法设置坐标row,col处的单元格 跨num_rows行和num_cols列。在通常的情形下，每个单元格占据一行和一列， 要使用单元格不止占据一行或一列，你需要给参数num_rows, num_cols大于1的 值。参数num_rows, num_cols的值小于等于0会导致错误。如果你的设置使得一 个单元格的尺寸与另一个早先声明为跨越的单元格的尺寸相重叠时，早先的这 个单元格的尺寸会重置为占据一行和一列。你也能够使用方法 SetCellOverflow(row, col, allow)方法来关闭单元格的跨越显示。只要在该方法中 使用pass就可以阻止单元格跨越了，即使已经使用了SetCellSize()方法来设置它 的尺寸。 调整网格的尺寸的一个更加典型的方法是基于一行或一列来处理其像素尺 寸。你可以使用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
- 446. 有时，你想为一行或一列设置一个最小的尺寸，以便不用担心程序的某个 方法的调用或用户对网格线的拖动会致使该行或列变得更小。 在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()方法来得到这些尺寸。 通常，你不会关心单元格的实际的像素尺寸，你希望它们被自动调整到足 够显示你的数据的大小。在wxPython中，你可以通过使用AutoSize()方法来自 动调整整个网格的尺寸。该方法使得所有的行和列的尺寸与它们中的内容相适 应。你也可以对单个的行或列使用AutoSizeColumn(col, setAsMin=True)和 AutoSizeRow(row, setAsMin=True)来使它们的尺寸自动与其中的内容相适应。 如果参数setAsMin为True，那么新的自动的尺寸将作为该行或列的最小尺 寸。AutoSizeColumns(setAsMin=True)和AutoSizeRows(setAsMin=True)自动调整 所有的列和行的尺寸。 你也可以让用户通过拖动标签单元格的边框来调整行的尺寸。用于实现这 种行为的主要的方法如下： * EnableDragColSize(enable=True)：控制用户能否通过拖动边框来改变标 签的宽度 446 / 565
- 447. * EnableDragRowSize(enable=True)：控制用户能否通过拖动边框来改变标 签的高度 * EnableDragGridSize(enable=True)：控制用户能否通过拖动边框一次性改 变标签的宽度和高度 下面的方法是上面方法的相应的使拖动无效的简便的方法： * DisableDragColSize() * DisableDragRowSize() * DisableDragGridSize() 下面的一套方法用以判断能否拖动： * CanDragColSize() * CanDragRowSize() * CanDragGridSize() 14.2.4 如何管理哪些单元格处于选择或可见状态？ 在网格控件中，用户可以选择一个或多个单元格。在wxPython中，有几个 方法让你能够处理多选的情况。 在下面的几个情况中，网格控件中的被选择的项可以是0个或多个： * 单个的处于选择状态的单元格 * 被选择的行 * 被选择的行 * 被选择的由单元格组成的块 用户可以通过命令或在单元格、行或列标签上的敲击，或拖动鼠标来选择 多组单元格。要确定网格中是否有被选择的单元格，可能使用方法 IsSelection()，如果有则该方法返回True。你可以通过使用IsInSelection(row, col) 方法来查询任意一个特定的单元格当前是否处于选择状态中，如果是则返回 True。 表14.2显示了几个方法，它们得到当前被选择的内容并返回给你。 447 / 565
- 448. 表14.2 返回当前被选择的单元格的集的方法 GetSelectedCells()：返回包含一些单个的处于选择状态的单元格的一个Python列 表。在这个列表中的每个项目都是一个(row, col)元组。 GetSelectedCols()：返回由通过敲击列的标签而被选择的列的索引组成的一个 Python列表。 GetSelectedRows()：返回由通过敲击行的标签而被选择的列的索引组成的一个 Python列表。 GetSelectionBlockTopLeft()：返回包含一些被选择的由单元格组成的块的一个 Python列表。其中的每个元素都时一个(row, col)元组，(row, col)元组是每块的左上 角。 GetSelectionBlockBottomRight()：返回包含一些被选择的由单元格组成的块的一个 Python列表。其中的每个元素都时一个(row, col)元组，(row, col)元组是每块的右下 角。 这儿也有几个用于设置或修改选择状态的方法。第一个是 ClearSelection()，它清除当有的被选状态。在该方法被调用以后，IsSelection() 返回False。你也可以做一个相反的动作，就是使用SelectAll()选择所有的单元 格。你也可以使用方法SelectCol(col, addToSelected=False)和 SelectRow(row, addToSelected=False)来选择整列或整行。在这两个方法中，第 一个参数是要选择的行或列的索引。如果参数addToSelected为True，所有另外 被选择的单元格仍然处于被选状态，并且该行或列也被增加到已有的选择中。 如果参数addToSelected为False，那么所有另外被选择的单元格解除被选状态， 而新的行或列代替它们作为被选择对象。同样地，你也可以使用方法 SelectBlock(topRow, leftCol, bottomRow, rightCol, addToSelected=False)来增加 一个对一块范围的选择，前面四个参数是所选的范围的对角，addToSelected参 数的作用同前一样。 你也可以使用IsVisible(row, col, wholeCellVisible=True)方法来得到一个特定 的单元格在当前的显示中是否是可见的。如果该单元格当前显示在屏幕上了 （相对于处在一个可滚动的容器的不可见部分而言），那么该方法返回True。 如果参数wholeCellVisible为True，那么单元格要整个都是可见的，方法才返回 True，如果参数wholeCellVisible为False，则单元格部分可见，方法就会返回 True。方法MakeCellVisible(row, col)通过滚动确保了指定位置的单元格是可见 的。 448 / 565
- 449. 除了被选的单元格外，网格控件也有一个光标单元格，它代表获得当前用 户焦点的单元格。你可以使用GetGridCursorCol()和GetGridCursorRow()方法来 确定光标的当前位置，这两个方法返回整数的索引值。你可以使用 SetGridCursor(row, col)方法来显式地放置一个光标。该方法除了移到光标外， 它还隐式地对新的光标位置调用了MakeCellVisible。 表14.3说明了在网格坐标和显示器坐标之间作转换的网格控件的方法。 表14.3 坐标转换方法 BlockToDeviceRect(topLeft, bottomRight)：参数topLeft, bottomRight是单元格的坐 标（(row, col)元组的形式）。返回值是一个wx.Rect，wx.Rect使用给定的网格坐标 所包围的矩形的设备像素坐标。 CellToRect(row, col)：返回一个wx.Rect，wx.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.5是个示例图片。例14.6显示了产生图14.5的代码。注意其 中的针对特定单元格的网格方法和wx.grid.GridCellAttr对象的创建方法的用 法。 449 / 565
- 451. grid.SetAttr(5, 1, attr) grid.SetRowAttr(8, attr) app = wx.PySimpleApp() frame = TestFrame() frame.Show() app.MainLoop() 我们将通过讨论用于设置整个网格默认值的方法作为开始。你可以使用 SetDefaultCellAlignment(horiz, vert)方法来为网格中所有的单元格设置默认的对 齐方式，其中horiz的取值有wx.LEFT、wx.CENTRE、wx.RIGHT，vert的取值有 wx.TOP, wx.CENTRE, 和wx.BOTTOM。你可以使用GetDefaultCellAlignment() 来得到这个默认的单元格对齐方式，该方法返回一个(horiz, vert)元组。 背景和文本的颜色可以使用SetDefaultCellTextColour(colour)和 SetDefaultCellBackgroundColour(colour)方法来设置。同样，colour参数可以是一 个wx.Colour实例或颜色名。相应的get*方法是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
- 452. 你也可以使用SetMargins(extraWidth, extraHeight)方法来设置网格控件与它 的容器的边距。 在内部，类wx.grid.Grid使用一个名为wx.grid.GridCellAttr类来管理每个单 元格的属性。wx.grid.GridCellAttr类对于本节所讨论到的属性，也有get*和set* 方法。你可以通过使用GetOrCreateCellAttr(row, col)方法来得到关于一个特定的 单元格的attr对象，它是单元格的属性对象。一个单元格的属性对象仅在该单元 格已定义了非默认的属性时才被创建。一旦你有了该单元格的属性对象，你就 可以用它来定义该单元格的显示属性。 要创建你自己的单元格属性对象，这个构造函数是wx.grid.GridCellAttr()。 你可以设置某些参数，然后将该对象传递给方法SetColAttr(attr)或 SetRowAttr(attr)，这两个方法将将这些显示属性应用到该行或列中的每个单元 格，如例14.6所示。 如果你在使用一个网格表，你可以覆盖方法GetAttr(row, col)来返回特定单 元格的一个wx.grid.GridCellAttr实例。 你也可以改变网格线的颜色和显示。网格线的显示是由方法 EnableGridLines(enable)来控制的。参数enable是一个布乐值。如果为True，网 格线被显示，如果为False，则不显示。你可以使用方法 SetGridLineColor(colour)来改变网格线的颜色。 14.3 自定义描绘器和编辑器 是什么使得网格控件是如此的灵活和有用呢？它就是显示或编辑一个单元 格的内容的机制可以被改变这一特性。在后面的几节中，我们将给你展示如何 去使用预定义的描绘器和编辑器，以及如何写你自己的描绘器和编辑器。 14.3.1 如何使用一个自定义的单元格描绘器？ 默认情况下，网格将它的数据以简单字符串的形式显示，然而，你也可以 以不同的格式显示你的数据。你可以想将布尔值数据显示为一个复选框，或以 图片格式显示一个数字值，或将一个数据的列表以线条的方式显示。 在wxPython中，每个单元格都可以有它自己的描绘器，这使得它能够以不 同的方式显示它的数据。下面的部分讨论几个wxPython中预定义的描绘器，以 及如何定义你自己的描绘器。 452 / 565
- 453. 预定义的描绘器(renderer) 一个网格描绘器是类wx.grid.GridCellRenderer的一个实 例，wx.grid.GridCellRenderer是一个抽象的父类。一般，你会使用它的子类。 表14.4说明了几个你可以用在你的单元格中的预定义的描绘器。它们都有一个 构造函数和get*,set*方法。 表14.4 预定义的网格单元格描绘器 wx.grid.GridCellAutoWrapStringRenderer：显示文本化的数据，在单元格边界按词 按行。 wx.grid.GridCellBoolRenderer：使用一个复选框来描绘布尔数据——选中表示 True，未选中表示False。 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参数是用于指定单元格的新的描绘器。这些方法都简单地设置或得到 存储在相关单元格属性对象中的描绘器，所以如果你愿意的话，你可以直接处 理GridCellAttr。你可以通过使GetDefaultRenderer 和 SetDefaultRenderer(renderer)来得到和设置用于整个网格的默认的描绘器。 你也可以为一行设置描绘器，这个的典型应用是电子表格中的某列总是显 示特定类型的数据。实现的方法是 SetColFormatBool(col), SetColFormatNumber(col)，以及 SetColFormatFloat(col, width, precision)。 453 / 565
- 454. 创建一个自定义的描绘器 要创建你自定义的单元格描绘器，需要创建wx.grid.PyGridCellRenderer的 一个子类。创建自定义的单元格描绘器，使你能够以特定的格式显示相关的数 据。 图14.6显示了一个自定义描绘器的示例，它随机地绘制单元格的背景色。 图14.6 例14.7是产生图14.6的代码，其中显示了相关的类和所覆盖的方法 例14.7 #-*- 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
- 456. app = wx.PySimpleApp() frame = TestFrame() frame.Show() app.MainLoop() 你的描绘器类必须覆盖基类的下面三个方法。 Draw() GetBestSize() Clone() 这三个方法中最重要的是Draw(grid, attr, dc, rect, row, col, isSelected)。其中 参数grid是包含相应单元格的网格实例。参数attr是网格的属性实例。如果你需 要使用基本的绘制方法的话，参数dc是用于绘制的设备上下文。参数rect是单 元格的矩形区域。参数row,col是单元格的坐标，如果单元格当前处于被选状态 的话，参数isSelected为True。在你的绘制方法中，你可以自由地做任何你想做 的事情。 方法GetBestSize(grid, attr, dc, row, col)返回一个wx.Size实例，该实例代表单 元格的首先尺寸。方法Clone()返回一个wx.grid.GridCellRenderer实例。一旦描 绘器被定义了，你就可以像使用预定义的描绘器一样使用它。 14.3.2 如何编辑一个单元格？ wxPython的网格控件允许你编辑单元格中的值。敲击一个单元格，或开始 键入一个新的数据值都将打开一个默认的字符串编辑器，让你可以输入不同的 字符串。在这一节，我们将讨论多种修改此默认行为的方法。 你可以使用方法EnableEditing(enable)来开关整个网格的可编辑性——参数 enable是一个布尔值。如果它是False，那么所有的单元格都不可编辑。如果关 闭了网格的可编辑性，那么你就不能再设置单个单元格的编辑状态了。如果打 开了网格的可编辑性的话，单个的单元格可以被指定为只读。你可以使用方法 IsEditable()来确定网格是否可编辑。 你可以使用方法SetReadOnly(row, col, isReadOnly=True)来设置一个特定单 元格的编辑状态。isReadOnly=True代表该单元格为只读，为False代表单元格可 编辑。SetReadOnly()是类wx.grid.GridCellAttr中的同名方法的一个简捷方式。 换句话说，你可以使用GetCellAttr(row, col).SetReadOnly(isReadOnly)之类的来 将一个单元格设置为只读。使用单元格属性机制的好处就是你可以将 456 / 565
- 457. SetReadOnly与SetRowAttr()和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.GridCellEditor。你可以使用方法GetDefaultEditor()和 SetDefaultEditor(editor)来为整个网格管理默认的编辑器。正如描绘器一样，编 辑器对象作为与单元格、行或列相关的wx.grid.GridCellAttr的一部分被存储。 14.3.3 如何使用一个自定义的单元格编辑器？ 正如描绘器一样，wxPython提供了几个不同类型的标准编辑器，也让你可 以创建你自己的编辑器。 预定义的编辑器 所有的wxPython编辑器都是类wx.grid.GridCellEditor的子类。表14.5说明了 这些标准的编辑器。 在接下来的部分，我们将给你展示如何创建自定义的单元格编辑器。 457 / 565
- 458. 表14.5 wxPyhton中的单元格编辑器 wx.grid.GridCellAutoWrapStringEditor：使用多行文本控件来编辑数据值。 wx.grid.GridCellBooleanEditor：用于单元格布尔值的编辑器，由一个复选框构成 必，双击显示该复选框。你不必将布尔值描绘器用于一个布尔值编辑器——你可以用 1或0，或者on/off此类的东西来替代布尔值描绘器来显示被选或未选状态。 wx.grid.GridCellChoiceEditor：复合框编辑器。这个构造函数要求两个参数： (choices,allowOthers=False)，其中参数choices是字符串的选项列表。如果 allowOthers为True，那么除了下拉列表中的选项外，用户可以自己键入一个字符 串。 wx.grid.GridCellEnumEditor：继承自wx.grid.GridCellChoiceEditor，将数字换成等 同的字符串呈现给用户。 wx.grid.GridCellFloatEditor ：用于输入指定精度的浮点数。这个构造函数要求的参 数是(width=-1，precision=-1)，参数的意义与相应描绘器中的意思一样。使用这个编 辑器输入的数被转换到相应的位数和精度。 wx.grid.GridCellNumberEditor：整数编辑器。该构造函数要求的参数是 (min=-1, max=-1)。如果min和max设置了，那么这个编辑器将进行范围检查，并否 决试图输入范围之外的数。单元格的右边会有一个spinner控件，使用户可以通过鼠 标来改变单元格中的值。 wx.grid.GridCellTextEditor：默认的文本编辑器。 创建自定义的编辑器 你可以想创建一个自定义的编辑器自行处理输入的数据。要创建你自己的 编辑器，你要创建wx.grid.PyGridCellEditor的一个子类。这比描绘器复杂些。表 14.6显示了几个你需要覆盖的方法。 表14.7显示了父类的更多的方法，你可以覆盖它们以改进你的自定义编辑 器的外观。 表14.6 你必须覆盖的PyGridCellEditor的方法 BeginEdit(row, col, grid)：参数row,col是单元格的坐标，grid是包含的单元格。该方 法在编辑请求之初被调用。在该方法中，编辑器用于得到数据去编辑，并为编辑做准 工作。 Clone()：返回该编辑器的一个拷贝。 458 / 565
- 462. 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
- 463. 表14.8 wx.grid.GridEvent的方法 AltDown()：当事件被触发时，如果alt键被按下了，则返回True。 ControlDown()：当事件被触发时，如果control键被按下了，则返回True。 GetCol()：返回发生事件的单元格所在的列的索引。 GetPosition()：返回返回一个wx.Point。它代表事件发生点的逻辑坐标（以像素为单 位）。 GetRow()：返回发生事件的单元格所在的行的索引。 MetaDown()：当事件被触发时，如果met键被按下了，则返回True。 Selecting()：如果事件是一个被选事件，则返回True，如果事件是取消选择事件，则 返回False。 ShiftDown()：当事件被触发时，如果shift键被按下了，则返回True。 与wx.grid.GridEvent相关的有几个不同的事件类型。如表14.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
- 464. 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：当行的大小被改变时触发。网格的尺寸 事件有5个与wx.GridEvent! AltDown(), ControlDown(), GetPosition(), MetaDow(), 和ShiftDown相同的方 法。wx.grid.GridSizeEvent的最后的一个方法是GetRowOrCol()，该方法返回发 生改变的列或行的索引，当然这依赖于具体的事件类型。 事件类型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
- 465. 14.4.2 如何捕获用户的键盘动作？ 除了使用鼠标外，用户还可以使用键盘来在网格中移动。你可以通过代码 的方法来使用表14.10中的移动方法改变光标。其中的许多方法都要求一个 expandSelection参数。每个方法中的expandSelection的作用都相同。如果这个参 数为True，那么当前的选项将被扩展以容纳这个新的光标位置。如果这个参数 为False，那么当前的选项被新的光标所取代。 表14.10 网格光标移动方法 MoveCursorDown(expandSelection)：向下移动光标。如果expandSelection为 False，等同于按下"下箭头键"，如果为True，则等同于按下"shift-下箭头键"。 MoveCursorDownBlock(expandSelection)：向下移动光标。如果expandSelection为 False，则等同于"ctrl-下箭头键"，如果为True，则等同于"shift-ctrl-下箭头键"。 MoveCursorLeft(expandSelection)：向左移动光标。如果expandSelection为False， 等同于按下"左箭头键"，如果为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)：向上移动光标。如果expandSelection为False， 等同于按下"上箭头键"，如果为True，则等同于按下"shift-上箭头键"。 MoveCursorUpBlock(expandSelection)：向上移动光标。如果expandSelection为 False，则等同于"ctrl-上箭头键"，如果为True，则等同于"shift-ctrl-上箭头键"。 MovePageDown()：显示下一页的单元格。 MovePageUp()：显示上一页的单元格。 我们已经涵盖了所有你需要了解的有关单元格的知识。在下一章中，我们 将讨论树形控件。 465 / 565
- 466. 14.5 本章小结 1、网格控件使你能够创建像电子表格一样的网格表，并具有很大的可控 性和灵活性。网格控件是类wx.grid.Grid的一个实例。通常，如果使用网格控件 处理复杂的问题的话，你应该通过__init__方法来定义它的子类，这是值得的， 而非仅仅创建基类的一个实例并在程序的其它地方调用它的方法。 2、有两种方法用来将数据放入一个网格控件中。网格控件可以使用 CreateGrid(numRows, numCols)方法被显式创建，然后使用 SetCellValue(row, col, s)方法来设置单个的单元格。另一种是，你可以创建一个 网格表的实例，该网格表作为网格的一个模型，它使你可以很容易地使用另一 数据源的数据并显示在网格中。网格表是wx.grid.PyGridTableBase的子 类，wx.grid.PyGridTableBase的方法中，GetValue(row, col)可以被覆盖以在显示 一个单元格时驱动网格的行为。网格表被连接到网格控件使用方法 SetTable(table)。当使用网格表的方法创建了网格后，可以通过网格表的方法来 改变网格的行和列数。 3、网格也有行和列标签，标签有默认的值，类似于电子表格。标签所显 示的文本和标签的其它显示属性可以使用网格的方法来改变。每个项的行和列 的尺寸可以被显式了设置，或者网格可以根据所显示的自动调整尺寸。用户也 可通过拖动网格线来改变网格的尺寸。如果需要的话，你可以为每行或每列设 置一个最小的尺寸，以防止单元格变得太小而不能显示相应的数据。另外，特 定的单元格了能使用SetCellSize(row, col, numrows, numcols)方法来达到跨行或 列的目的。 4、用户可以选择网格中的一个或多个矩形范围的网格，这也可以通过使 用很多不同的select*方法以程序化的方式实现相同的效果。一个没有在显示区 域中的网格单元，可能使用MakeCellVisible(row, col)方法来将它移到显示区域 上。 5、网格控件的强大性和灵活性来源于可以为每个单元格创建自定义的描 绘器和编辑器这一能力。描绘器用于控件单元格中的信息显示。默认的描绘器 只是一个简单的字符串，但是还有用于布尔值、整数和浮点数的预先定义好 （预定义）的描绘器。你可以通过子类化wx.Grid.PyGridCellRenderer创建你自 己的描绘器并覆盖它的绘制方法。 6、默认情况下，网格允许就地编辑数据。你可以改变这个属性（针对单 元格，或行或列，或整个网格）。当编辑时，编辑器对象控制显示给用户的东 西。默认的编辑器是一个用以修改字符串的普通的文本编辑器控件。其它还有 466 / 565
- 468. 15 树形控件(tree control) 本章内容 * 创建树形控件并添加项目 * 使用样式来设计树形控件 * 在程序中访问树形控件 * 处理树形控件中的选择 * 控制项目的可见性 树形控件是用于显示复杂数据的控件。这里，树形控件被设计用来通过分 级层来显示数据，你可以看到每 块数据都有父子方面的东西。一个标准的例子就是文件树，其中的目录中 有子目录或文件，从而形成了文 件的一个嵌套的层次。另一个例子是HTML或XML文档的文档对象模型 (DOM)树。和列表与网格控件一样，树 形控件也提供了在项目显示方面的灵活性，并允许你就地编辑树形控件中 的项目。在这一章中，我们将给 你展示如何编辑树形控件中的项目及如何响应用户事件。 15.1 创建树形控件并添加项目 树形控件是类wx.TreeCtrl的实例。图15.1显示了一个树形控件的样例。 468 / 565
- 469. 图15.1 例15.1是产生图15.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
- 471. 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.TreeCtrl的构造函数是一个典型的wxPython窗口部件构造函数： 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
- 481. ”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) 你只能添加一个根元素。如果你在已经存在一个根元素后，再添加第二根 元素的话，那么wxPython将引发一个异常。其中的参数text包含用于根元素的 显示字符串。参数image是图像列表中的一个索引，代表要显示在参数text旁边 的图像。这个图像列表将在15.5节中作更详细的讨论，但是现在只要知道它的 行为类似于用于列表控件的图像列表。参数data是一个与项目相关的数据对 象，主要的目的是分类。 481 / 565
- 482. AddRoot()方法返回一个关于根项目的ID。树形控件使用它自己的类 wx.TreeItemId来管理项目。在大多数时候，你不需要关心ID的具体值，你只需 要知道每个项目都有一个唯一的wx.TreeItemId就够了，并且这个值可以使用等 号测试。wx.TreeItemId不映射到任何简单的类型——它的值没有任何的关联 性，因为你只是把它用于相等测试。 15.1.2 如何将更多的项目添加到树中？ 一旦你有了根元素，你就可以开始向树中添加元素了。用的最多的方法是 AppendItem(parent, text, image=-1, selImage=-1, data=None)。参数parent是已有 的树项目的wx.TreeItemId，它作为新项目的父亲。参数text是显示新项目的文 本字符串。参数image和selImage的意义与方法AddRoot()中的相同。该方法将新 的项目放置到其父项目的孩子列表的末尾。这个方法返回新创建的项目的 wx.TreeItemId。如果你想给新的项目添加子项目的话，你需要拥有这个ID。一 个示例如下： 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)。其中参数 previous其父项目中的子列表中的项目的wx.TreeItemId。插入的项目将放置在该 项目的后面。第二个方法是 InsertItemBefore(parent, before, text, image=-1, selImage=-1, data=None)。该方法 将新的项目放置在before所代表的项目之前。然而参数before不是一个项目的 ID。它是项目在孩子列表中的整数索引。第二个方法返回新项目的一个 wx.TreeItemId。 15.1.3 如何管理项目？ 要去掉树中的一个项目，可以使用Delete(item)方法，其中参数item是该项 目的wx.TreeItemId。调用这个方法将导致一个EVT_TREE_Delete_ITEM类型的 482 / 565
- 483. 树的事件被触发。后面的章节我们将讨论树的事件类型。要删除一个项目的所 有子项目，而留下该项目自身，可以使用方法DeleteChildren(item)，其中参数 item也是一个wx.TreeItemId。该方法不产生一个删除事件。要清除整个树，使 用方法DeleteAllItems()。该方法为每个项目生成一个删除事件，但是，这在某 些老版的Windows系统上不工作。 一旦你将一个项目添加到树中，你就可以使用方法GetItemText(item)来得 到该项目在显示在树中的文本，其中参数item是一个wx.TreeItemId。如果你想 改变一个项目的显示文本，可以使用方法SetItemText(item, text)，其中参数item 是一个wx.TreeItemId，参数text是一个新的显示文本。 最后，你可以使用方法GetCount()来得到树中项目的总数。如果你想得到 特定项目下的子项目的数量，可以使用方法 GetChildrenCount(item, recursively=True)。其中参数item是一个wx.TreeItemId， 参数recursively如果为False，那么该方法只返回直接的子项目的数量，如果为 True，则返回所有的子项目而不关嵌套有多深。 15.2 树控件的显示样式 树控件的显示样式分为四类。第一类定义了树中显示在父项目的文本旁的 按钮（用以展开或折叠子项目）。它们显示在表15.1中。 表15.1 树控件中的按钮 wx.TR_HAS_BUTTONS：有按钮。在Windows上，+用于标明项目可以被展开，-表 示可以折叠。 wx.TR_NO_BUTTONS：没有按钮。 接下来的一类显示在表15.2中，它们决定树控件将连接线绘制在何处。 表15.2 树控件中的连接线 wx.TR_LINES_AT_ROOT：如果设置了这个样式，那么树控件将在多个root项目之 间绘制连线。注意，如果wx.TR_HIDE_ROOT被设置了，那么你就有多个root项目。 wx.TR_NO_LINES：如果设置了这个样式，那么树控件将不在兄弟项目间绘制连接 线。这个样式将代替wx.TR_LINES_AT_ROOT。 wx.TR_ROW_LINES ：树控件在行之间将绘制边距。 483 / 565
- 484. 第三类样式显示在表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_ROOT：如果设置了这个样式，则通过AddRoot()确定的root元素将不 被显示。此时该结节的所有子项就如同它们是root一样显示。这个样式用于让一个树 具有多个root元素的外观。 最后，wx.TR_DEFAULT_STYLE让你的树显示出最接近当前操作系统本地 控件的样式。在程序中，你可以使用SetWindowStyle(styles)来改变样式，其中 参数styles是你想要的新样式。 树形控件有几个方法可以用以改变它的显示特性。在这些方法中，参数 item是你想要改变的项的wx.TreeItemId。你可以使用方法 SetItemBackgroundColor(item, col)来设置项目的背景色，其中参数col是一个 wx.Colour或其它能够转换为颜色的东西。你可以使用 SetItemTextColour(item,col)来改变文本的颜色。你可以使用 SetItemFont(item, font)来设置项目的显示字体，其中参数font是一个wx.Font实 例。如果你只想显示文本为粗体，你可以使用方法 SetItemBold(item, bold=True)，其中参数bold是一个布尔值，它决定是否显示为 粗体。上面的四个set*方法都有对应的get*方法，如下所示： GetItemBackgroundColor(item), GetItemTextColour(item), GetItemFont(item), 和IsBold(item)。其中的item参数是一个wx.TreeItemId。 484 / 565
- 485. 15.3 对树形控件的元素排序 对树形控件的元素排序的基本机制是方法SortChildren(item)。其中参数 item是wx.TreeItemId的一个实例。该方法对此项目的子项目按显示字符串的字 母的顺序进行排序。 对于树的排序，每个树项目都需要有已分派的数据，不管你是否使用默认 排序。在默认情况中，所指派的数据是None，但是对于排序任务，在树控件中 你还是需要显式地设置。 在15.1节，我们提及到了让你能够创建一个树项目及将该项目与一个任意 数据对象相关联的方法。我们也告诉你不要使用这个机制。数据项目是一个 wx.TreeItemData。在wxPython中在一预定义的快捷的方法，使你能够用以将一 个Python对象与一个树项目关联起来。 快捷的set*方法是SetItemPyData(item, obj)。其中参数item是一个 wx.TreeItemId，参数obj是一个任意的Python对象，wxPython在后台管理这个关 联。当你想得到这个数据项时，你可以调用GetItemPyData(item)，它返回相关 的Python对象。 注意：对于wx.TreeItemData有一个特别的构造函数： wx.TreeItemData(obj)，其中参数obj是一个Python对象。因此你可以使用 GetItemData(item)和SetItemData(item, obj)方法来处理这个Python数据。这是 SetItemPyData()方法的后台机制。这一信息在某些时候可能对你是有用 的，但是大部分时候，你还是应该使用SetItemPyData(item, obj)和 GetItemPyData(item)方法。 要使用关联的数据来排序你的树，你的树必须是一个wx.TreeCtrl的自定义 的子类，并且你必须覆盖OnCompareItems(item1, item2)方法。其中参数 item1, item2是要比较的两个项的wx.TreeItemId实例。如果item1应该排在item2 的前面，则方法返回-1，如果item1应该排在item2的后面，则返回1，相等则返 回0。该方法是在当树控件为了排序而比较计算每个项时自动被调用的。你可 以在OnCompareItems()方法中做你想做的事情。尤其是，你可以如下调用 GetItemPyData()方法： def OnCompareItems(self, item1, item2); data1 = self.GetItemPyData(item1) data2 = self.GetItemPyData(item2) return cmp(data1, data2) 485 / 565
- 486. 15.4 控制与每项相关的图像 用于树形控件的图像是由一个图像列表来维护的，这非常类似于列表控件 中的图像维护。有关创建图像列表的细节，参见13章。一旦你创建了图像列 表，你就可以使用SetImageList(imageList)或AssignImageList(imageList)方法把 它分配给树控件。前者使得图像列表可以被其它控件共享，后者的图像列表所 有权属于树控件。之后，你可能使用方法GetImageList()来得到该图像列表。图 15.2显示了一个带有一些图像的树。 图15.2 例15.2是产生图15.2的代码。它使用了ArtProvider对象来提供图像。 例15.2 一个带有图标的树控件 #-*- encoding:UTF-8 -*- import wx import data class TestFrame(wx.Frame): def __init__(self): 486 / 565
- 488. 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.TreeItemId。参数which控制你将得到了是哪个图像，默认值 wx.TreeItemIcon_Normal，将得到该项目的未选状态的图像的索引。which的另 一个值wx.TreeItemIcon_Selected的使用，将返回选中状态的图 像，wx.TreeItemIcon_Expanded和wxTreeItemIcon_SelectedExpanded返回当该树 项目被展开时所使用的图像。注意，后者的两个图像不能使用添加方法来被设 置——如果你想设置的话，你必须使用方法 SetItemImage(item, image, which=wx.TreeItemIcon_Normal)来实现。其中参数 item是wx.TreeItemId的实例，参数image是新图像的整数索引，参数which同get* 方法。 15.5 使用编程的方式访问树。 在15.1节中，我们谈到没有直接得到一个给定项目的子项目的Python列表 的方法，至于一个特定子项目的索引就更不用说了。要实现这个，我们需要使 用本节所说的遍历方法来访问树的结点。 488 / 565
- 489. 要开始遍历树，我们首先要使用GetRootItem()来得到根元素。该方法返回 树的根元素的wx.TreeItemId。之后，你就可以使用诸如GetItemText()或 GetItemPyData()之类的方法来获取关于根元素的更多的信息。 一旦你得到了一个项目，你就可以通过迭代器来遍历子项目的列表。你可 以使用方法GetFirstChild(item)来得到子树中的第一个孩子，该方法返回一个二 元元组(child, cookie)。参数item是第一个孩子的wx.TreeItemId。除了告诉你每 一个孩子是什么外，该方法还初始化一个迭代对象，该对象使你能够遍历该 树。cookie值只是一个标志，它使得树控件能够同时保持对多个迭代器的跟 踪，而它们之间不会彼此干扰。 一旦你由GetFirstChild()得到了cookie，你就可以通过反复调用 GetNextChild(item, cookie)来得到其余的孩子。这里的item父项的ID，cookie是 由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
- 490. 没有下一项或前一项，那么这些方法将返回一个无效的项（例如： item.IsOk() == False）。 要确定一个项是否有孩子，使用方法ItemHasChildren(item)，该方法返回布 尔值True或False。你可以使用方法SetItemHasChildren(item, hasChildren=True)来 将一个项设置为有子项，如果这样，即使该项没有实际的子项，它也将显示得 与有子项的一样。也就是说该项旁边会有一个扩展或折叠的按钮，以便展开或 折叠。这通常被用于实现一个虚的树控件。这个技术将在15.7节中演示。 15.6 管理树中的选择 树形控件允许你通过程序的方式管理树中的被选项。基本的方法是 SelectItem(item,select=True) 。在单选树控件中，该方法将选择指定项 item（wx.TreeItemId），同时自动撤消对先前选项的选择。如果参数select的取 值是False，那么该方法将取消对参数item代表的项的选择。在一个可多选的树 控件中，SelectItem()方法只改变item所代表的项的状态，而不改变树中其它项 的选择状态。在可多选的树中，你也可以使用方法ToggleItemSelection(item)， 它只切换参数item所代表项的选择状态。 对于取消选择还有三个快捷的方法。方法Unselect()取消单选模式树中的当 前被选项的选择。在多选模式树中，使用UnselectAll()来取消所有的选择。如 果你只想取消在一个多选树中的一个项的被选状态，可以使用方法 UnselectItem(item)。 你也可以使用方法IsSelected(item)来查询一个项目的选择状态，该方法返 回布尔值True或False。对于单选树，你可能使用方法GetSelection()来得到当前 被选项目的wx.TreeItemId。对于多选树，可以使用方法GetSelections()来得到所 有被选项的wx.TreeItemId的一个Python列表。 当树控件中发生选择变化的时候，有两个事件将被触发并可被捕获。第一 个事件是wx.EVT_TREE_SEL_CHANGING,它在被选项实际改变之前发生。如 果你要处理这个事件，你可以使用事件的Veto()方法来阻止选择的改变。在选 择已经改变之后，事件wx.EVT_TREE_SEL_CHANGED被触发。这两个事件的 类是wx.TreeEvent，这将在15.8节中作更完整的讨论。 15.7 控制项目的可见性 在树控件中有两种机制可以让你用编程的方式控制某项目的可见性。你可 以使用方法Collapse(item)和Expand(item)指定给定的树项目是展开的或折叠 的。这些方法改变树控件的显示，并且如果对一个没有子项的项目调用该方法 490 / 565
- 491. 将不起作用。这儿还有一个方便的函数：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_EXPANDED被触发。这四个事件都是类wx.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
- 494. 这个机制可以被扩展来从外部源读取数据以查看。这个机制除了可以被用 来建造一个文件树外，我们会提及数据库中的数据的可能性，以便对文件的结 构不感趣的你不用全面研究文件结构。 控制可见性 有大量的方法使你能够管理那些项目是可见的。一个对象的不可见，可能 是因为它没处在含有滚动条的框中的可见区域或是因为它处在折叠项中。你可 以使用IsVisible(item)方法来确定项目是否可见，该方法在项目是可见时返回 True，不可见返回False。你可以通过使用方法EnsureVisible(item)迫使指定的项 变成可见的。如果需要的话，该方法将通过展开该项的父项（以及父项的父 项，以此类推）来迫使指定项变成可见的，然后滚动该树，以使指定项处于控 件的可见部分。如果你只需要滚动，可以使用ScrollTo(item)方法来完成。 遍历树中的可见部分，首先要使用的方法是GetFirstVisibleItem()。该方法 返回显示的可见部分中的最顶端的项目的wx.TreeItemId。然后通过使用 GetNextVisible(item)方法来遍历，该方法的item参数来自GetFirstVisibleItem()和 GetNextVisible()的返回值。如果移动的方向向上的话，使用方法 GetPreviousVisible(item)。如果参数item不可见的话，返回值是一个无效的项。 还有几个别的方法可用于项目的显示。树控件有一个属性，该属性用于设 置缩进。可以通过方法GetIndent()和方法SetIndent(indent)来得到和设置该属性 的当前值。其中indent参数是缩进的像素值（整数）。 要得到关于指定点的树项目的信息，使用方法HitTest(point)，其中point是 树控件中的相关位置的一个wx.Point。方法的返回值是一个(item, flags)元组， 其中的item是相关位置的项的wx.TreeItemId或None值。如果指定位置没有项 目，那么一个无效的项目将返回。flags部分是一个位掩码，它给出了相关的信 息。表15.5包含了flags的一个完整列表。 还有两个方法，它们让你可以处理屏幕上项目的实际的边界。方法 GetBoundingRect(item, textOnly=False)返回一个wx.Rect实例，该实例对应于屏 幕上文本项的矩形边界区域。其中参数item是项目的wx.TreeItemId。如果参数 textOnly为True，那么该矩形仅包括项目的显示文本所覆盖的区域。如果为 False，那么该矩形也包括图像区域。在这两种情况中，矩形都包括从树控件的 边缘到内嵌的显示项间的空白区域。如果item代表的项目当前是不可见的，那 么两种方法都返回None。 494 / 565
- 495. 表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)。由于一次只能有一个活动编辑项，所以这里不需要 指定项目的ID。参数cancelEdit是一个布尔值。如果为True，取消编辑，如果为 495 / 565
- 496. False，则不取消。如果因为某种原因，你需要访问当前所用的文本编辑控件， 你可以调用方法GetEditControl()，该方法返回用于当前编辑的wx.TextCtrl实 例，如果当前没有编辑，则返回None。当前该方法只工作于Windows系统下。 当一个编辑会话开始时（通过用户选择或调用EditLabel()方 法），wx.EVT_TREE_BEGIN_LABEL_EDIT类型的wx.TreeEvent事件被触发。 如果使用Veto()方法否决了该事件的话，那么编辑将不会开始。当会话结束时 （通过用户的敲击或调用EndEditLabel()方法），一个 wx.EVT_TREE_END_LABEL_EDIT类型的事件被触发。这个事件也可以被否 决，这样的话，编辑就被取消了，项目不会被改变。 15.9 响应树控件的其它的用户事件 在这一节，我们将讨论wx.TreeEvent类的属性。表15.6列出了这些属性。 表15.6 wx.TreeEvent的属性 GetKeyCode()：返回所按键的整数按键码。只对wx.EVT_TREE_KEY_DOWN事件 类型有效。如果任一修饰键（CTRL,SHIFT,and ALT之类的）也被按下，该属性不会 告知你。 GetItem()：返回与事件相关的项的wx.TreeItemId。 GetKeyEvent()：只对wx.EVT_TREE_KEY_DOWN事件有效。返回wx.KeyEvent。 该事件可以被用来告知你在该事件期间，是否有修饰键被按下。 GetLabel()：返回项目的当前文本标签。只对wx.EVT_TREE_BEGIN_LABEL_EDIT 和wx.EVT_TREE_END_LABEL_EDIT有效。 GetPoint()：返回与该事件相关的鼠标位置的一个wx.Point。只对拖动事件有效。 IsEditCancelled()：只对wx.EVT_TREE_END_LABEL_EDIT有效。如果用户通过取 消来结束当前的编辑则返回True，否则返回False。 SetToolTip(tooltip)：只对wx.EVT_TREE_ITEM_GETTOOLTIP事件有效。这使你能 够得到关于项目的提示。该属性只作在Windows系统上。 表15.7列出了几个不适合在表15.6中列出的wx.TreeEvent的事件类型，它们 有时也是用的。 496 / 565
- 497. 表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.TreeCtrl，wxPython也提供了wx.gizmos.TreeListCtrl，它是树控件 和报告模式的列表控件的组合。除了本章中所讨论的wx.TreeCtrl的特性 外，TreeListCtrl能够显示与每行相关的数据的附加列。图15.3显示了树列表控 件的样子。 497 / 565
- 498. 图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
- 501. 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 本章小结 1、树控件提供给你了一个如文件树或XML文档样的嵌套紧凑的外观。树 控件是类wx.TreeCtrl的实例。有时，人你会想子类化wx.TreeCtrl，尤其是如果 你需要实现自定义的排序的时候。 2、要向树中添加项目，首先要用方法 AddRoot(text, image=-1, selImage=-1, data=None)。该函数的返回值是一个代表 树的root项目的wx.TreeItemId。树控件使用wx.TreeItemId作为它自己的标识符 类型，而非和其它控件一样使用整数的ID。一旦你得到了root项，你就可以使 用方法AppendItem(parent, text, image=-1, selImage=-1, data=None)来添加子项 目，参数parent是父项目的ID。该方法返回新项目的wx.TreeItemId。另外还有 一些用来将新的项目添加在不同位置的方法。方法Delete(item)从树中移除一个 项目，方法DeleteChildren(item)移除指定项的所有子项目。 3、树控件有一些用来改变树的显示外观的样式。一套是用来控制展开或 折叠项目的按钮类型的。另一套是用来控制项目间的连接线的。第三套是用于 控制树是单选还是多选的。你也可以使用样式通过隐藏树的实际的root，来模 拟一个有着多个root项的树。 501 / 565
- 502. 4、默认情况下，树的项目通常是按照显示文本的字母顺序排序的。但是 要使这能够实现，你必须给每项分配数据。实现这个的最容易的方法是使用 SetItemPyData(item, obj)，它给项目分配一个任意的Python对象。如果你想使用 该数据去写一个自定义的排序函数，你必须继承wx.TreeCtrl类并覆盖方法 OnCompareItems(item1, item2)，其中的参数item1和item2是要比较的项的ID。 5、树控件使用一个图像列表来管理图像，类似于列表控件管理图像的方 法。你可以使用SetImageList(imageList)或AssignImageList(imageList)来分配一 个图像列表给树控件。然后，当新的项目被添加到列表时，你可以将它们与图 像列表中的特定的索引联系起来。 6、没有特定的函数可以让你得到一个父项的子项目列表。替而代之的 是，你需要去遍历子项目列表，这通过使用方法GetFirstChild(item)作为开始。 7、你可以使用方法SelectItem(item, select=True)来管理树的项目的选择。 在一个多选树中，你可以使用ToggleItemSelection(item)来改变给定项的状态。 你可以使用IsSelected(item)来查询一个项目的状态。你也可以使用Expand(item) 或Collapse(item)展开或折叠一个项，或使用Toggle(item)来切换它的状态。 8、样式wx.TR_EDIT_LABELS使得树控件可为用户所编辑。一个可编辑的 列表中，用户可以选择一个项，并键入一个新的标签。按下esc来取消编辑而不 对项目作任何改变。你也可以通过 wx.EVT_TREE_END_LABEL_EDIT 事件来 否决编辑。类wx.TreeEvent提供了允许访问当前被处理的项目的显示文本的属 性。 502 / 565
- 503. 16 在你的应用程序中加入HTML 本章内容： * 在wxPython窗口中显示HTML * 处理和打印HTML窗口 * 使用HTML分析器(parser) * 支持新的标记和其它的文件格式 * 在HTML中使用控件 HTML最初是打算被作为超文本系统使用的一个简单的语义标记来使用 的。迄今为止，HTML已经变得更加的复杂和被广泛使用。HTML文档标记已 经被证明在网页浏览器之外也是有用的。目前HTML文档标记通常被用于文本 标记（如在文本控件中），或用于管理一系列的超链接页面（帮助系统中）。 在wxPython中，有许多专用于处理你的HTML需求的特性。你可以在一个窗口 中显示简单的HTML，并用超链接创建你自己的帮助页面，如果你需要的话， 甚至你还可以嵌入一个功能更全的浏览器。 下一节内容提示：如何在wxPython窗口中显示HTML？ 16.1 显示HTML 在wxPython中，你对HTML能做的最重要的事情就是将它显示在一个窗口 中。下面的两节，我们将讨论HTML窗口对象，以及给你展示如何对本地的文 本或远程的URL使用它。 16.1.1 如何在一个wxPython窗口中显示HTML？ 正如我们在第六章中讨论的，对于使用样式文本或简单的网格来快速地描 述文本的布局，wxPython中的HTML是一个有用的机制。wxPython的 wx.html.HtmlWindow类就是用于此目的的。图16.1显示了一个例子。 503 / 565
- 504. 图16.1 例16.1显示了用于产生图16.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 <b>formatted</b> <i><u>text</u></i> ” ”loaded from a <font color=”red”>string</font>.”) app = wx.PySimpleApp() frm = MyHtmlFrame(None, ”Simple HTML”) frm.Show() app.MainLoop() wx.html.HtmlWindow的构造函数基本上是与wx.ScrolledWindow相同的，如下所 示： wx.html.HtmlWindow(parent, id=-1, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.html.HW_SCROLLBAR_AUTO, 504 / 565
- 505. name=”htmlWindow”) 上面的这些参数现在看着应该比熟悉。这最重要的不同点是默认样式 wx.html.HW_SCROLLBAR_AUTO，它将告诉HTML窗口在需要的时候自动增 加滚动条。与之相反的样式是wx.html.HW_SCROLLBAR_NEVER，使用该样 式将不会显示滚动条。还有一个HTML窗口样式是 wx.html.HW_NO_SelectION，它使得用户不能选择窗口中的文本。 当在HTML窗口中写要显示的HTML时，记住所写的HTML要是简单的。 因为wx.html.HtmlWindow控件仅设计用于简单样式文本显示，而非用于全功能 的多媒体超文本系统。它只支持最基本的文本标记，更高级的特性如层叠样式 表(css)和JavaScript不被支持。表16.1包含了官方支持的HTML标记。通常，这 里的标记和它的属性的行为和web浏览器中的一样，但是由于它不是一个完全 成熟的浏览器，所以有时会出现一些奇怪行为的情况。表16.1中列出了后跟有 属性的标记。 表16.1 用于HTML窗口控件的有效的标记 文档结构标记： <a href name target> <body alignment bgcolor link text> <meta content http-equiv> <title> 文本结构标记：<br> <div align> <hr align noshade size width> <p> 文本显示标记： <address> <b> <big> <blockquote> <center> <cite> <code> <em> <font color face size> <h1> <h2> <h3> <h4> <h5> <h6> <i> <kbd> <pre> <samp> <small> <strike> <strin g> <tt> <u> 列表标记：<dd> <dl> <dt> <li> <ol> <ul> 图像和地图标记： <area coords href shape> <img align height src width usemap> <map name> 表格标记：<table align bgcolor border cellpadding cellspacing valign width> <td align bgcolor colspan rowspan valign width nowrap> <th align bgcolor colspan v align width rowspan> <tr align bgcolor valign> HTML窗口使用wx.Image来装载和显示图像，所以它可以支持所有 wx.Image支持的图像文件格式。 505 / 565
- 506. 下节内容提示：如何显示来自一个文件或URL的HTML？ 16.1.2 如何显示来自一个文件或URL的HTML？ 一旦你创建了一个HTML窗口，接下来就是在这个窗口中显示HTML文 本。下面的四个方法用于在窗口中得到HTML文本。 * SetPage(source) * AppendToPage(source) * LoadFile(filename) * LoadPage(location) 其中最直接的方法是SetPage(source)，参数source是一个字符串，它包含你 想显示在窗口中的HTML资源。 你可以使用方法AppendToPage(source)添加HTML到窗口中的文本的后面。 至于SetPage()和AppendToPage()方法，其中的参数source被假设是HTML，这意 味着，如果你传递的是纯文本，那么其中的间距将被忽略，以符合HTML标 准。 如果你想让你的窗口在浏览外部的资源时更像一个浏览器，那么你有两种 方法。方法LoadFile(filename)读取本地文件的内容并将它们显示在窗口中。在 这种情况中，窗口利用MIME文件类型来装载一个图像文件或一个HTML文 件。如果它不能确定文件是何种类型，那么它将以纯文本的方式装载该文件。 如果被装载的文档包含有相关图像或其它文档的链接，那么被用于解析那些链 接的位置是原文件的位置。 当然，一个实际的浏览器不会只局限于本地文件。你可以使用方法 LoadPage(location)来装载一个远程的URL，其中参数location是一个URL，但是 对于本地文件，它是一个路径名。MIME类型的URL被用来决定页面如何被装 载。本章的稍后部分，我们将讨论如何增加对新文件类型的支持。 506 / 565
- 507. 图16.2显示了被装载入HTML窗口中的一个页面。 图16.2 例16.2显示了产生图16.2的代码 例16.2 从一个web页装载HTML窗口的内容 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
- 508. 例16.2中关键的地方是方法LoadPage()。拥有更完整特性的浏览器窗口还 应有显示URL的文本框，并在当用户键入一个新的URL后，可以改变窗口中的 内容。 下节内容提示：管理HTML窗口 16.2 管理HTML窗口 一旦你有了一个HTML窗口，你就可以通过不同的方法来管理它。你可以 根据用户的输入来触发相应的动作，处理窗口的内容，自动显示有关窗口的信 息和打印页面等。在随后的几节中，我们将讨论如何实现这些。 16.2.1 如何响应用户在一个链接上的敲击？ wx.html.HtmlWindow的用处不只限于显示。还可以用于响应用户的输入。 在这种情况下，你不需要定义你自己的处理器，你可以在你的 wx.html.HtmlWindow的子类中覆盖一些处理函数。 表16.2说明了已定义的处理函数。wx.html.HtmlWindow类没有使用事件系 统定义事件，所以你必须使用这些重载的成员函数来处理相关的事件，而非绑 定事件类型。 另外，如果你想让一个HTML窗口响应用户的输入，你必须创建你自己的 子类并覆盖这些方法。 表16.2 wx.html.HtmlWindow的事件处理函数 OnCellClicked(cell, x, y, event)：当用户在HTML文档中敲击时调用。参数cell是一个 wx.html.HtmlCell对象，该对象代表所显示的文档的一部分，诸如文本、单元格或图 像等。wx.html.HtmlCell类被HTML解析器创建，这将在本章后部分讨论。参数x,y是 鼠标敲击的准确位置（像素单位），参数event是相关的鼠标敲击事件。如果cell包含 一个链接，那么这个方法的默认版本将简单地委托给OnLinkClicked()，否则它什么 也不做。 OnCellMouseHover(cell, x, y)：当鼠标经过一个HTML单元时调用。参数同 OnCellClicked()。 OnLinkClicked(link)：当用户在一个超链接上敲击时调用。该方法的默认版对链接的 URL调用LoadPage。覆盖该方法通常用于使用HtmlWindow来为应用程序制作一个 关于框。在那种情况下，你可以改变行为以便用户通过敲击其中的主页来使用 Python的webbrowser模块去运行系统默认的浏览器。 508 / 565
- 509. 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源文件中有<title>标记时调用。通常用于在应用程序中显 示标题。 下节内容提示：如何使用编程的方式改变一个HTML窗口？ 16.2.2 如何使用编程的方式改变一个HTML窗口？ 当你正显示一个HTML页时，你还可以改变你的窗口像浏览器样去显示其 它的内容，如一另一个Web页，或帮助文件或其它类型的数据，以响应用户的 需要。 有两个方法来当HTML窗口在运行时，访问和改变HTML窗口中的信息。 首先，你可以使用GetOpenedPage()方法来得到当前打开的页面的URL。该方法 只在当前页是被LoadPage()方法装载的才工作。如果是这样的，那么方法的返 回值是当前页的URL。否则，或当前没有打开的页面，该方法返回一个空字符 串。另一个相关的方法是GetOpenedAnchor()，它返回当前打开页面中的锚点 （anchor）。如果页面不是被LoadPage()打开的，你将得到一个空的字符串。 要得到当前页的HTML标题，可以使用方法GetOpenedPageTitle()，这将返 回当前页的<title>标记中的值。如果当前页没有一个<title>标记，你将得到一个 空的字符串。 这儿有几个关于改变窗口中文本的选择的方法。方法SelectAll()选择当前 打开的页面中的所有文本。你可以使用SelectLine(pos)或SelectWord(pos)做更有 针对性的选择。其中pos是鼠标的位置wx.Point，这两个方法分别选择一行或一 个词。要取得当前选择中的纯文本内容，可以使用方法SelectionToText()，而方 法ToText()返回整个文档的纯文本内容。 wx.html.HtmlWindow维护着历史页面的一个列表。使用下表16.3中的方 法，可以如通常的浏览器一样浏览这个历史列表。 509 / 565
- 510. 表16.3 HistoryBack()：装载历史列表中的前一项。如果不存在则返回False。 HistoryCanBack()：如果历史列表中存在前一项，则返回True，否则返回False。 HistoryCanForward()：如果历史列表中存在下一项，则返回True，否则返回False。 HistoryClear()：清空历史列表。 HistoryForward()：装载历史列表中的下一项。如果不存在则返回False。 要改变正在使用的字体，可以使用方法 SetFonts(normal_face, fixed_face, sizes=None)。参数normal_face是你想用在窗口 显示中的字体的名字字符串。如果normal_face是一个空字符串，则使用系统默 认字体。参数fixed_face指定固定宽度的文本，类似于<pre>标记的作用。如果 指定了fixed_face参数，那么参数sizes则应是一个代表字体的绝对尺寸的包含7 个整数的列表，它对应于HTML逻辑字体尺寸（如<font>标记所使用的）－2~ +4之间。如果该参数没有指定或是None，则使用默认的。关于默认常量 wx.html.HTML_FONT_SIZE_n，n位于1~7之间。这些默认常量指定了对应于 HTML逻辑字体尺寸所使用的默认字体。准确的值可能因不同的底层系统而不 同。要选择一套基于用户的系统的字体和尺寸，可以调用SetStandardFonts()。 这在GTK2下运行wxPython时是特别有用的，它能够提供一套更好的字体。 如果由于某种原因，你需要改变窗口中文本边缘与窗口边缘之间的间隔的 话，HTML窗口定义了SetBorders(b)方法。参数b是间隔的像素宽度（整数 值）。 下节内容提示：如何在窗口的标题栏中显示页面的标题和如何打印一个 HTML页面？ 16.2.3 如何在窗口的标题栏中显示页面的标题？ 在你的web浏览器中，你可能也注意到了一件事，那就是浏览器中不光只 有显示窗口，还有标题栏和状态栏。通常，标题栏显示打开页面的标题，状态 栏在鼠标位于链接上时显示链接信息。在wxPython中有两个便捷的方法来实现 这些。图16.3对此作了展示。窗口显示的标题是基于web页面的标题的，状态 栏文本也来自Html窗口。 510 / 565
- 512. app = wx.PySimpleApp() frm = MyHtmlFrame(None, ”Simple HTML Browser”) frm.Show() app.MainLoop() 要设置标题栏的关联，使用方法SetRelatedFrame(frame, format)。参数 frame你想显示页面标题的框架。参数format是你想在框架的标题栏中显示的字 符串。通常的格式是这样：“My wxPython Browser: %s”。:%s前面的字符串可 以是你想要的任何字符串，%s将会被HTML页面的标题所取代。在窗口中，一 个页面被载入时，框架的标题自动被新的页面的信息取代。 要设置状态栏，使用方法SetRelatedStatusBar(bar)。该方法必须在 SetRelatedFrame()之后调用。参数bar是状态栏中用于显示状态信息的位置。通 常它是0，但是如果状态栏中存在多个显示区域，那么bar可以有其它的值。如 果bar的取值为－1,那么不显示任何信息。一旦与状态栏的关联被创建，那么当 鼠标移动到显示的页面的链接上时，相关链接的URL将显示在状态栏中。 16.2.4 如何打印一个HTML页面？ 一旦HTML被显示在屏幕上，接下来可能做的事就是打印该HTML。类 wx.html.HtmlEasyPrinting就是用于此目的的。你可以使用下面的构造函数来创 建wx.html.HtmlEasyPrinting的一个实例： wx.html.HtmlEasyPrinting(name=”Printing”, parentWindow=None) 参数name只是一个用于显示在打印对话框中的字符串。参数parentWindow 如果被指定了，那么parentWindow就是这些打印对话框的父窗口。如果 parentWindow为None，那么对话框为顶级对话框。你只应该创建 wx.html.HtmlEasyPrinting的一个实例。尽管wxPython系统没有强制要这样做， 但是该类是被设计为独自存的。 使用wx.html.HtmlEasyPrinting的实例 从该类的名字可以看出，它应该是容易使用的。首先，通过使用 PrinterSetup()和PageSetup()方法，你能够给用户显示用于打印设置的对话框。 调用这些方法将导致相应的对话框显示给用户。实例将存储用户所做的设置， 以备后用。如果你想访问这些设置数据，以用于你自己特定的处理，你可以使 用方法GetPrintData()和GetPageSetupData()。GetPrintData()方法返回一个 512 / 565
- 513. wx.PrintData对象，GetPageSetupData()方法返回一wx.PageSetupDialogData对 象，我们将在第17章中更详细地讨论。 设置字体 你可以使用方法SetFonts(normal_face, fixed_face, sizes)来设置打印所使用的 字体。这个方法的行为同用于HTML窗口的SetFonts()相同（在打印对象中的设 置不会影响到HTML窗口中的设置）。你可以使用方法SetHeader(header, pg)和 SetFooter(footer, pg)来页眉和页脚。参数header和footer是要显示的字符串。字 符串中你可以使用点位符@PAGENUM@，占位符在执行时被打印的页号替 代。你也可以使用@PAGENUM@占位符，它是打印的页面总数。参数pg的取 值可以是这三个：wx.PAGE_ALL、wx.PAGE_EVEN或wx.PAGE_ODD。它控制 页眉和页脚显示在哪个页上。通过对不同的pg参数多次调用该方法，可以为奇 数页和偶数页设置单独的页眉和页脚。 输出预览 如果在打印前，你想预览一下输出的结果，你可以使用 PreviewFile(htmlfile)方法。在这种情况下，参数htmlfile是你本地的包含HTML 的文件的文件名。另一是PreviewText(htmlText, basepath=””)。参数htmlText是你 实际想打印的HTML。basepath文件的路径或URL。如预览成功，这两个方法均 返回True，否则返回False。如果出现了错误，那么全局方法 wx.Printer.GetLastError()将得到更多的错误信息。关于该方法的更详细的信息将 在第17章中讨论。 打印 现在你可能想知道如何简单地打印一个HTML页面。方法就是 PrintFile(htmlfile)和PrintText(htmlText, basepath)。其中的参数同预览方法。所不 同的是，这两个方法使用对话框中的设置直接让打印机打印。打印成功，则返 回True。 下节内容提示：拓展HTML窗口 16.3 拓展HTML窗口 在这一节，我们将给你展示如何处理HTML窗口中的HTML标记，如何创 造你自己的标记，如何在HTML中嵌入wxPython控件，如何处理其它的文件格 式，以及如何在你的应用程序中创建一个真实的HTML浏览器。 513 / 565
- 514. 16.3.1 HTML解析器(parser)是如何工作的？ 在wxPython中，HTML窗口有它自己内在的解析器。实际上，这里有两个 解析器类，但是其中的一个是另一个的改进。通常，使用解析器工作仅在你想 扩展wx.html.HtmlWindow自身的功能时有用。如果你正在使用Python编程，并 基于其它的目的想使用一个HTML解析器，那么我们建议你使用随同Python发 布的htmllib和HTMLParser这两个解析器模块之一，或一个外部的Python工具 如“Beautiful Soup”。 两个解析器类分别是wx.html.HtmlParser，它是一个更通用的解析器，另一 个是wx.html.HtmlWinParser，它是wx.html.HtmlParser的子类，增加了对在 wx.html.HtmlWindow中显示文本的支持。由于我们所关注的基本上是HTML窗 口，所以我们将重点关注wx.html.HtmlWinParser。 要创建一个HTML解析器，可以使用两个构造函数之一。其中基本的一个 是wx.html.HtmlWinParser()，没有参数。wx.html.HtmlWinParser的父类 wx.html.HtmlParser也有一个没有参数的构造函数。你可以使用另一个构造函数 wx.html.HtmlWinParser(wnd)将一个wx.html.HtmlWinParser()与一个已有的 wx.html.HtmlWindow联系在一起，参数wnd是HTML窗口的实例。 要使用解析器，最简单的方法是调用Parse(source)方法。参数source是要被 处理的HTML字符串。返回值是已解析了的数据。对于一个 wx.html.HtmlWinParser，返回值是类wx.html.HtmlCell的一个实例。 HTML解析器将HTML文本转换为一系列的单元，一个单元可以表示一些 文本，一个图像，一个表，一个列表，或其它特定的元素。wx.html.HtmlCell的 最重要的子类是wx.html.HtmlContainerCell，它是一个可以包含其它单元在其中 的一个单元，如一个表或一个带有不同文本样式的段落。对于你解析的几乎任 何文档，返回值都将是一个wx.html.HtmlContainerCell。每个单元都包含一个 Draw(dc, x, y, view_y1, view_y2)方法，这使它可以在HTML窗口中自动绘制它 的信息。 另一个重要的子类单元是wx.html.HtmlWidgetCell，它允许一个任意的 wxPython控件像任何其它单元一样被插入到一个HTML文档中。除了可以包括 用于格式化显示的静态文本，这也包括任何类型的用于管理HTML表单的控 件。wx.html.HtmlWidgetCell的构造函数如下： wx.html.HtmlWidgetCell(wnd, w=0) 514 / 565
- 515. 其中参数wnd是要被绘制的wxPython控件。参数w是一个浮动宽度。如果w 不为0，那么它应该是介于1和100之间的一个整数，wnd控件的宽度则被动态地 调整为相对于其父容器宽度的w%。 另外还有其它许多类型的用于显示HTML文档的部分的单元。更多的信息 请参考wxWidget文档。 下节内容提示：如何增加对新标记的支持？ 16.3.2 如何增加对新标记的支持？ 被解析器返回的单元是被标记处理器内在的创建的，通过HTML标记，一 个可插入的结构与HTML解析器单元的创建和处理相联系起来。你可以创建你 自己的标记处理器，并将它与HTML标记相关联。使用这个机制，你可以扩展 HTML窗口，以包括当前不支持的标准标记，或你自己发明的自定义的标记。 图16.4显示了自定义HTML标记的用法。 图16.4 下例16.4是产生图16.4的代码。 例16.4 定义并使用自定义的标记处理器 import wx import wx.html 515 / 565
- 518. GetParam(param, with_commas=False)：返回参数param的值。如果参 数 with_commas为 True，那么你得到一个首尾都有引号的原始字符串。如果没有指 定该参数，那么返回一个空字符串。方法GetParamAsColour(param)返回的参数值 是一个wx.Color，方法GetParamAsInt(param)返回整数值。 HasEnding()：如果标记有结束标记的话，返回True，否则返回false。 用于扩展HTML窗口的标记处理器都是wx.html.HtmlWinTagHandler的子 类。你的子类需要覆盖两个方法，并且你需要知道进一步的方法。需要覆盖的 第一个方法是GetSupportedTags()。该方法返回由处理器管理的标记的列表。标 记必需是大写的，并且标记之间以逗号分隔，中间不能有空格，如下所示： GetSupportedTags(self): return ”MYTAG,MYTAGPARAM” 第二个你需要覆盖的方法是HandleTag(tag)。在HandleTag(tag)方法中，你 通过增加新的单元元素到解析器来处理标记（或者交替地改变解析器已经打开 的容器单元）。你可以通过调用标记处理器的GetParser()方法来得到解析器。 要写一个HandleTag(tag)方法，你应该像下面这样做： 1、得到解析器。 2、对你的标记的参数做必要的处理，可能要改变或创建一个新的单元。 3、如果被解析的标记包括着内在的文本，那么解析标记之间的文本。 4、执行对于解析器所需要的任何清理工作。 如上所述，你使用GetParser()方法得解析器。要添加或编辑解析器中的单 元，你有三个可选方案。第一个，如果你想添加另一个单元到容器中，你可以 工作于当前的容器。第二个，你可以调用解析器的Container()方法，然后创建 你的wx.html.HTMLCell子类实例，并通过调用容器的InsertCell(cell)方法将它添 加到容器。 有时，你可能想在当前打开的容器中创建一个附属的或内嵌的容器。例如 内嵌于表的一行中的一个单元格。要实现这个，你需要调用解析器的 OpenContainer()方法。这个方法返回你的新的容器单元，你可以使用 InsertCell(cell)方法来插入显示单元到你的新的容器单元中。对于每个在你的标 记处理器中打开的容器，你应该使用CloseContainer()方法来关闭它。如果你没 有成对的使用OpenContainer()和CloseContainer()，那么这将导致解析器解析余 下的HTML文本时出现混乱。 518 / 565
- 519. 第三个方案是创建一个与解析器的当前容器同级的容器，意思是不是嵌入 的。例如一个新的段落——它不是前一段的一部分，也不附属于前一段；它是 该页中的一个新的实体。为了在解析器中实现这个方案，你需要关闭现存的容 器，再打一个新的容器，如下所示： parser = self.GetParser() parser.CloseContainer()#关闭现存的容器 parser.OpenContainer()#打一个新的容器 # 添加或编辑解析器中的单元 parser.CloseContainer() parser.OpenContainer() 下节内容提示：如何支持其他的文件格式？ 16.3.3 如何支持其他的文件格式？ 默认情况下，HTML窗口可以处理带有MIME类型text/html, text/txt, 和 image/*（假设wxPython图像处理器已经被装载）的文件。当碰上一个不是图像 或HTML文件的文件时，该HTML窗口试图以纯文本的方式显示它。这可以不 是你想要的行为。如果有一些文件你想以自定义的方式显示它的话，你可以创 建一个wx.html.HtmlFilter来处理它。比如，你可能想以源代码树的方式显示 XML文件，或使用语法着色来显示Python源代码文件。 要创建一个筛选器（filter），你必须建造wx.html.HtmlFilter的一个子 类。wx.html.HtmlFilter类有两个方法，你必须都覆盖它们。这第一个方法是 CanRead(file)。参数file是wx.FSFile（一个打开的文件的wxPython表示）的一个 实例。类wx.FSFile有两个属性，你可以用来决定你的筛选器是否能够读该文 件。方法GetMimeType()以一个字符串的形式返回该文件的MIME类型。MIME 类型通常由文件的后缀所定义。方法GetLocation()返回带有相关文件位置的绝 对路径或URL的一个字符串。如果筛选器会处理该文件的话，CanRead()方法应 该返回True，否则返回False。处理Python源文件的CanRead()的一个示例如下： CanRead(self, file): return file.GetLocation().endswith(‘.py’) 第二个你需要覆盖的方法是ReadFile(file)。这个方法要求一个同样的file参 数，并返回该文件内容的一个字符串的HTML表达。如果你不想使用 519 / 565
- 520. wxWidgets C++的文件机制来读该文件的话，你可以通过简单地打开位于 file.GetLocation()的文件来使用Python的文件机制。 一旦筛选器被创建了，那么它必须被注册到wx.html.HtmlWindow，使用 wx.html.HtmlWindow窗口的AddFilter(filter)静态方法来实现。参数filter是你的新 的wx.html.HtmlFilter类的一个实例。一旦注册了筛选器，那么该窗口就可以使 用筛选器来管理通过了CanRead()测试的文件对象。 16.3.4 如何得到一个性能更加完整的HTML控件？ 尽管wx.html.HtmlWindow不是一个完整特性的浏览器面板，但是这儿有一 对用于嵌入更加完整特性的HTML表现窗口的选择。如果你是在Windows平台 上，你可以使用类wx.lib.iewin.IEHtmlWindow，它是Internet Explorer ActiveX控 件的封装。这使得你能够直接将ie窗口嵌入到你的应用程序中。 使用IE控件比较简单，类似于使用内部的wxPython的HTML窗口。它的构 造函数如下： wx.lib.iewin.IEHtmlWindow(self, parent, ID=-1, pos=wx.DefaultPosition, size=wx.DefaultSize, style=0, name=’IEHtmlWindow’) 其中参数parent是父窗口，ID是wxPython ID。对于IE窗口，这儿没有可用 的样式标记。要装载HTML到IE组件中，可以使用方法LoadString(html)，其中 参数html是要显示的一个HTML字符串。你可以使用方法LoadStream(stream)装 载自一个打开的文件，或一个Python文件对象；或使用LoadString(URL)方法装 载自一个URL。你能够使用GetText(asHTML)来获取当前显示的文本。参数 asHTML是布尔值。如果为True，则返回HTML形式的文本，否则仅返回一个文 本字符串。 在其它平台上，你可以尝试一下wxMozilla项目(http:// wxmozilla.sourceforge.net)，该项目尝试创建一个Mozilla Gecko表现器的 wxPython封装。目前该项目仍在测试阶段。wxMozilla有用于Windows和Linux 的安装包，对Mac OS X的支持正在开发中。 520 / 565
- 521. 16.4 本章小结 1、HTML不再是只用于Internet了。在wxPython中，你可以使用一个HTML 窗口来显示带有HTML标记的简单子集的文本。该HTML窗口属于 wx.html.HtmlWindow类。除了HTML文本，该HTML窗口还可以管理任一的图 像（图像处理器已装载的情况下）。 2、你可以让HTML窗口显示一个字符串，一个本地文件或一个URL的信 息。你可以像通常的超文本浏览器的方式显示用户的敲击，或使用它自定义的 响应。你也可以将HTML窗口与它的框架相连接起来，以便标题和状态信息自 动地显示在适当的地方。HTML窗口维护着一个历史列表，你可以对它进行访 问和处理。你可以使用类wx.Html.HtmlEasyPrinting来直接打印你的页面。 3、在wxPython中有一个HTML解析器，你可以用来创建用于你自己窗口 的自定义标记。你也可以配置自定义的文件筛选器来在一个HTML窗口中表现 其它的文件格式。 4、最后，如果你对HTML窗口的局限性不太满意的话，那么你可以使用一 个对IE控件的wxPython封闭。如果你不在Windows上的话，这儿也有一个对 Mozilla Gecko HTML表现器的wxPython的封装。 下节内容提示：第17章 wxPython的打印构架 521 / 565
- 522. 第17章 wxPython的打印构架 本章内容 * 用wxPython打印 * 创建和显示打印对话框 * 创建和显示页面设置对话框 * 在你的程序中执行打印 * 执行一个打印预览 在第16章中，我们已经关注了wxPython的一打印方法：使用 wx.HtmlEasyPrinting。如果你用该方法打印HTML（或某些容易转换为HTML的 文件）的话，这个方法将会工作的很好，但是要作为一个完善打印办法还是不 够的。在wxPython中还有一个更为通用的打印构架，你可以用它来打印你想打 印的任何东西。基本上，该构架使你能够使用设备上下文和绘制操作来执行打 印。你也可以创建打印预览。 本章将讨论该构架中最重要的类：wx.Printout，它管理实际的图片部分。 打印输出实例可以由一个代表打印机的wx.Printer对象或用于打印预览的 wx.PrintPreview对象来管理。多们也将讨论几个管理与打印相关的数据的类， 以及用来显示信息给用户的对话框。 17.1 如何用wxPython打印？ 我们将以类wx.Printout作为开始。首先你要创建你自定义的wx.Printout的 子类。接着你要覆盖wx.Printout的方法以定义你自定义的打印行为。wx.Printout 有7个你可以覆盖以自定义打印行为的方法。这些方法在一个打印会话过程期 间被wxPython自动调用。图17.1其中的六个方法，它们被特定的事件触发。在 大多数情况下，你不需要全部覆盖它们。 522 / 565
- 523. 图17.1 17.1.1 理解打印输出的生命周期 你通过创建一个你的打印输出对象的实例和一个类wx.Printer的实例启动一 个打印会话： wx.Printer(data=None) 可选的data参数是wx.PrintDialogData的一个实例。要开始实际的打印，需 要调用wx.Printer的Print(parent, printout, prompt=True)方法。参数parent是父窗口 （它被用作对话框的窗口中）。参数printout是你的wx.Printout实例。如果参数 prompt为True，那么在打印之前，wxPython将显示打印对话框，否则不显示。 在Print()方法开始后，它调用wx.Printout的第一个可被覆盖的方法 OnPreparePrint()。OnPreparePrint()方法在wx.Printout实例做任何其它的事之前 被确保调用，因此该方法是放置收集你的数据或做那些必须在打印开始之前所 要做的计算的一个好的地方。实际的打印使用OnBeginPrinting()方法开始，你 可以对该方法进行覆盖，以自定主你想要的行为——默认情况下，该方法什么 也不做。OnBeginPrinting()在整个打印会话中只会被调用一次。 523 / 565
- 524. 你希望打印的文档的每个单独的拷贝触发对 OnBeginDocument(startPage, endPage)的一个调用，其中参数startPage, endPage 告诉wxPython打印的起始页和最后一页。这两个参数都应该指定。如果你想覆 盖这个方法，那么你必须调用它的基类的方法，因为基类的方法要做一些重要 的工作（如调用wx.DC.StartDoc()）。在wxPython中，你可以使用 base_OnBeginDocument(startPage, endPage)来调用其父类的方法。如果 OnBeginDocument返回False，那么将取消打印工作。 你最有可能去覆盖的方法是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.Printout还有另一个可被覆盖的方法：HasPage(pageNum)。该方法通常 需要被覆盖，它被打印架构用于循环控制。如果参数pageNum存在于文档中， 那么该方法返回True，否则返回False。 17.1.2 实战打印构架 下面我们将通过一个例子来展示打印构架实际上是如何工作的。这个例子 由一个简单的用于打印文本文件的构架组成，并且应用程序让你能够键入简单 的文本。图17.2显示了这个应用程序的结果。 524 / 565
- 525. 图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
- 531. ”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.Printout中有几个get*方法，它们使你能够获取当前打印环境的有关 信息。表17.1列出了这些方法。 表17.1 wx.Printout的信息获取方法 GetDC()：该方法返回关于打印机或打印预览的用于绘制文档的设备上下文。 GetPageInfo()：返回一个含有四个元素的元组 (minPage, maxPage, pageFrom, pageTo)。minPage, maxPage分别是所允许的最 小和最大页码，默认是1和32000。pageFrom, pageTo是必须被打印的范围，默认为 1。你可以在你的子类中覆盖这个方法。 GetPageSizeMM()：返回包含一个页面的宽度和高度的一个(w, h)元组，以毫米为单 位。 531 / 565
- 532. GetPageSizePixels()：返回一个页面的宽度和高度的一个(w, h)元组，以像素为单 位。如果打印输出被用于打印预览，那么像素数将反应当前的缩放比列，意思就是说 像素将会随缩放比列而变。 GetPPIPrinter()：返回当前打印机在垂直和水平方向上每英寸的像素的一个(w, h)元 组。在预览中，这个值也是始终一致的，即使打印预览的缩放比列变化了。 GetPPIScreen()：返回当前屏幕在垂直和水平方向上每英寸的像素的一个(w, h)元 组。在预览中，这个值也是始终一致的，即使打印预览的缩放比列变化了。 GetTitle()：返回打印输出的标题。 在后面的几节中，我们将讨论如何呈现打印对话框给用户。 17.2 如何显示打印对话框？ 诸如要打印那些面面，要打印多少副本这些关于打印工作的数据是由标准 的打印对话框来管理的。打印对话框是与字体和颜色对话框类似的，wxPython 中的打印对话框实例仅仅是对本地控件和一个储存了对话框数据的分离的数据 对象的简单封装。 17.2.1 创建一个打印对话框 图17.3显示了打印设置对话框的样例。 图17.3 532 / 565
- 533. 这里的对话框是类wx.PrintDialog的一个实例，你可以使用下面的构造函数 来得到： wx.PrintDialog(parent, data=None) 其中，参数parent是对话框的父框架，参数data是一个预先存在的 wx.PrintDialogData实例，它用于对话框的初始数据。 使用方法 一旦你有了打印对话框，你就可以使用标准的ShowModal()方法来显示 它，ShowModal()方法将根据用户关闭对话框的方式而返回wx.ID_OK或 wx.ID_CANCEL。 在你关闭了对话框之后，你可以使用GetPrintDialogData()方 法来得到用户输入的数据。你也可以使用GetPrintDC()方法得到与数据相关联 的打印机的设备上下文，如果还没有内容被创建，那么GetPrintDC()方法返回 None。例17.1中的OnPrintSetup()方法显示了实际上对话框是如何被获取的。 使用属性 这个数据对象本身有几个属性，其中的一个是对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
- 535. SetPaperId(paperId) GetPaperId()：返回匹配纸张类型的标识符。通常的值有 wx.PAPER_LETTER, wx.PAPER_LEGAL, 和wx.PAPER_A4。完整的页面（纸 张）ID的列表见wxWidgets文档。 SetPrinterName(printerName) GetPrinterName()：返回被系统引用的当前打印机的名字。如果该值为空字符串，那 么默认打印机被使用。 SetQuality(quality) GetQuality()：返回打印机的当前品质值。set*方法仅接受如下取值： wx.PRINT_QUALITY_DRAFT, wx.PRINT_QUALITY_HIGH, wx.PRINT_QUALITY_ MEDIUM, 或wx.PRINT_QUALITY_LOW。get*方法将返回上面的这些值之一，或一 个代表每英寸点数设置的正整数。 17.3 如何显示页面设置对话框？ 图17.4显示了页面设置对话框是如何让用户来设置与页面尺寸相关的数据 的。 图17.4 17.3.1 创建页面设置对话框 你可以通过实例化一个wx.PageSetupDialog类来创建一个页面设置对话 框。 535 / 565
- 536. wx.PageSetupDialog(parent, data=None) 参数parent是新的对话框的父窗口。参数data是wx.PageSetupDialogData的 一个实例默认为None。一旦页面设置对话框被创建了，那么这个对话框的行为 就和其它任何模式对话框一样，并且你可以使用ShowModal()来显示它。通 常，返回值表明了用户是否是使用wx.ID_OK或wx.ID_CANCEL按钮关闭的对 话框窗口。在对话框关闭后，你可以通过调用GetPageSetupDialogData()来取得 对数据对象的访问， GetPageSetupDialogData()返回类wx.PageSetupDialogData 的一个实例。 17.3.2 使用页面设置属性工作 wx.PageSetupDialogData类有几个必须与页面设置一起使用的属性。表17.4 展示了控制对话框自身显示的属性。除非有其它的指定，否则所有这些属性都 默认为True。 表17.4 wx.PageSetupDialogData的对话框控制属性 GetDefaultMinMargins() SetDefaultMinMargins(flag)：如果这个属性为True，并且你是在微软的Windows系 统上，那么页面设置将使用默认打印机的当前属性作为默认认的最小化页边距。否 则，它将使用系统默认值。 GetDefaultInfo() SetDefaultInfo(flag)：如果这个属性为True，并且你是在微软的Windows系统上，那 么这个页面设置对话框不会被显示。替而代之，当前打印机的所有默认值都将被放入 数据对象。 EnableHelp(flag) GetEnableHelp()：如果为True，那么对话框的帮助部分是有效的。 EnableMargins(flag) GetEnableMargins()：如果为True，那么对话框的用于调整页边距的部分是有效的。 EnableOrientation(flag) GetEnableOrientation()：如果为True，那么对话框的用于改变页面定位的部分是有 效的。 EnablePaper(flag) GetEnablePaper()：如果为True，那么对话框的用于允许用户改变页面（纸张）类 型的部分是效的。 536 / 565
- 538. 17.4 如何打印？ 到目前为止，我们已经见过了打印构架的所有部分，现是我们打印一些东 西的时候了。实际的打印部分是由wx.Printer类的一个实例来控制的。与已经说 明的其它部分相比，打印并不更简单。接下来，我们将对在例17.1中的 OnPrint()中的步骤作介绍。 第一步 按顺序得到你的所有数据 这至少应该包括带有打印机命令的wx.Printout对象，通常也要包括一个 wx.PrintDialogData实例。 第二步 创建一个wx.Printer实例 创建该实例，要使用构造器wx.Printer(data=None)。可选参数data是一个 wx.PrintDialogData实例。该数据控制打印，通常，你会想使用它。 第三步 使用wx.Printer的Print ()方法打印 Print()方法如下： Print(parent, printout, prompt=True) 其中参数parent是当打印时所触发的对话框的父窗口。printout是用于打印 的wx.Printout对象。如果参数prompt为True，那么在打印之前显示打印对话 框，否则将立即；启动打印。 如果打印成功，则Print()方法返回True。你能够调用GetLastError()方法来 得到下列常量之一：wx.PRINTER_CANCELLED（如果失败是由于用户取消了 打印所引起的），wx.PRINTER_ERROR（如果失败在打印期间由打印自身所 引起的），或wx.PRINTER_NO_ERROR（如果Print()返回True且没有错误发 生）。 这儿还有另外两个你可以使用一个wx.Printer实例做的事： * 你可以使用CreateAbortWindow(parent,printout)来显示中止对话框，其中 参数parent和printout同Print()方法中的。如果用户已经中止打印任务，你能够通 过调用Abort()来发现，该方法在这种情况下返回True。 * 你可以使用PrintDialog(parent)来显式地显示打印对话框，并且你可以使 用GetPrintDialogData()来得到活动的打印数据对象。 538 / 565
- 539. 下节内容提示：如何实现一个打印预览？ 17.5 如何实现一个打印预览？ 使用设备上下文的一个好处就是很容易管理打印预览，你可以使用一个屏 幕设备上下文来代替打印机设备上下文。接下来的三个部分将讨论打印预览的 过程。 第一步 创建预览实例 在一个打印预览中的第一步是创建类wx.PrintPreview的一个实 例，wx.PrintPreview类似wx.Printer。构造器如下： wx.PrintPreview(printout, printoutForPrinting, data=None) 其中参数printout是一个wx.Printout对象，用于管理预览。参数 printoutForPrinting是另一个wx.Printout对象。如果它不是None，那么当显示的 时候，该打印预览窗口包含一Print按钮，该按钮启动打印。printoutForPrinting 用于实际的打印。如果参数printoutForPrinting为None，那么Print按钮不显示。 当然，你可以传递同一个实例或你的自定义打印输出类的相同版本的两个实例 给参数printout和printoutForPrinting。参数data可以是一个wx.PrintData对象或一 个wx.PrintDialogData对象。如果参数data指定了的话，那么它被用于控制该打 印预览。在例17.1中，我们显示了一个在OnPrintPreview()方法中使用打印预览 的例子。 第二步 创建预览框架 一旦你有了你的wx.PrintPreview，你就需要一框架以在其中观看你的 wx.PrintPreview。该框架由类wx.PreviewFrame提供，wx.PreviewFrame是 wx.Frame的一个子类，wx.Frame为预览提供基本的用户交互控 件。wx.PreviewFrame的构造器如下： wx.PreviewFrame(preview, parent, title, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE, name=”frame”) 其中真正有意义的参数是preview，它是要被预览的wx.PrintPreview实例。 其它的参数都是标准的wx.Frame中的。wx.PreviewFrame不定义任何自定义的样 式或事件。 539 / 565
- 540. 第三步 初始化框架 在你显示你的wx.PreviewFrame之前，你需要调用Initialize()方法，该方法 创建窗口的内部的部件并做其它的内部的计算。一旦你Show()了该框架，那么 如果你想再改变预览窗口的感观，你可以使用考虑CreateControlBar()和 CreateCanvas()方法，它们分别创建类wx.PreviewControlBar和wx.PreviewCanvas 的对象。覆盖这些方法以创建你自己的画布(canvas)和/或控制栏对象，使得你 能够定制你的打印预览窗口的感观。 17.6 本章小结 1、这是wxPython中的一个通用的打印构架，它不仅可以打印HTML，还 可以打印任何能够被绘制到设备上下文的东西。这个架构中的主要的类是 wx.Printout，但是wx.Printer和wx.PrintPreview也是重要的。 2、wx.Printout类管理图形打印的细节，并且它包含几个可以被覆盖来定制 打印会话期间的行为和使用的数据的方法。打印发生在OnPrintPage()方法期 间。 3、用于打印机设置和页面设置的标准的对话框是可以从wxPython来访问 的。打印机设置对话框是wx.PrintDialog的一个实例，页面设置对话框是 wx.PageSetupDialog的一个实例。这两个对话框都有相关的数据类，数据类使 你的程序可以处理所有显示在对话框中的值。 4、一旦有了数据，那么实际将数据传送给打印机则是wx.Printer类的相对 简单的应用。你可以使用wx.PrintPreview类来管理一个打印预览会话，该类包 括一个打印预览框架，和根据该框架指定通常打印行为的选项。 下节内容提示：第18章 使用wxPython的其它功能 540 / 565
- 541. 18 使用wxPython的其它功能 本章内容： * 放置对象到剪贴板上 * 拖放 * 传送和获取自定义对象 * 使用wx.Timer设置定时的事件 * 编写多线程的wxPython应用程序 18.1 放置对象到剪贴板上 在wxPython中，剪贴板和拖放特性是紧密相关的。期间，内部窗口的通信 是由使用wx.DataObject类或它的子类的一个实例作为中介的。wx.DataObject是 一个特殊的数据对象，它包含描述输出数据格式的元数据。我们将从剪贴板入 手，然后我们将讨论拖放的不同处理。 对于一个剪切和粘贴操作，有三个元素： * source(源) * clipboard(剪贴板) * target(目标) 如果source是在你的应用程序中，那么你的应用程序负责创建 wx.DataObject的一个实例并把它放到剪贴板对象。通常source都是在你的应用 程序的外部。 这里的clipboard是一个全局对象，它容纳数据并在必要时与操作系统的剪 贴板交互。 target对象负责从剪贴板获取wx.DataObject并把它转换为对你的应用程序有 用的那一类数据。 18.1.1 得到剪贴板中的数据 如果你想你的应用程序能够引起一个剪贴事件，也就是说你想能够将数据 剪切或复制到剪贴板，把数据放置到一个wx.DataObject里面。wx.DataObject知 道自己能够被读写何种格式的数据。这点是比较重要的，例如如果你当时正在 写一个词处理程序并希望给用户在粘贴时选择无格式文本的粘贴或丰富文本格 541 / 565
- 542. 式的粘贴的情况。然而大多数时候，在你的剪贴板行为中不需要太强大或太灵 活的性能。对于最常用的情况，wxPython提供了三个预定义的wx.DataObject的 子类：纯文本，位图图像和文件名。 要传递纯文本，可以创建类wx.TextDataObject的一个实例，使用它如下的 构造器： wx.TextDataObject(text=””) 参数text是你想传递到剪贴的文本。你可以使用Text(text)方法来设置该文 本，你也可以使用GetText()方法来得到该文本，你还可以使用GetTextLength() 方法来得到该文本的长度。 一旦你创建了这种数据对象后，接着你必须访问剪贴板。系统的剪贴板在 wxPython中是一个全局性的对象，名为wx.TheClipboard。要使用它，可以使用 它的Open()方法来打开它。如果该剪贴板被打开了则该方法返回True，否则返 回False。如果该剪贴板正在被另一应用程序写入的话，该剪贴板的打开有可能 会失败，因此在使用该剪贴板之前，你应该检查打开方法的返回值。当你使用 完剪贴板之后，你应该调用它的 Close()方法来关闭它。打开剪贴板会阻塞其它的剪贴板用户的使用，因此 剪贴板打开的时间应该尽可能的短。 18.1.2 处理剪贴板中的数据 一旦你有了打开的剪贴板，你就可以处理它所包含的数据对象。你可以使 用SetData(data)来将你的对象放置到剪贴板上，其中参数data是一个 wx.DataObject实例。你可以使用方法Clear()方法来清空剪贴板。如果你希望在 你的应用程序结束后，剪贴板上的数据还存在，那么你必须调用方法Flush()， 该方法命令系统维持你的数据。否则，该wxPython剪贴板对象在你的应用程序 退出时会被清除。 下面是一段添加文本到剪贴板的代码： text_data = wx.TextDataObject(“hi there”) if wx.TheClipboard.Open(): wx.TheClipboard.SetData(text_data) wx.TheClipboard.Close() 下节内容提示：从剪贴板中得到文本数据 542 / 565
- 543. 18.1.3 获得剪贴板中的文本数据 从剪贴板中获得文本数据也是很简单的。一旦你打开了剪贴板，你就可以 调用GetData(data)方法，其中参数data是wx.DataObject的一些特定的子类的一个 实例。如果剪贴板中的数据能够以与方法中的数据对象参数相一致的某种格式 被输出的话，该方法的返回值则为True。这里，由于我们传递进的是一个 wx.TextDataObject，那么返回值True就意味该剪贴板能够被转换到纯文本。下 面是一段样例代码： 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
- 544. 图18.1 例18.1是产生图18.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
- 546. 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.BitmapDataObject，其get*方法和set*方法分别是GetBitmap()和 SetBitmap(bitmap)。经由该数据对象与剪贴板交互的数据对象必须是wx.Bitmap 类型的。 最后一个预定义的数据对象类型是wx.FileDataObject。通常该数据对象被 用于拖放中（将在18.2节中讨论），例如当你将一个文件从你的资源管理器或 查找窗口放置到你的应用程序上时。你可以使用该数据对象从剪贴板接受文件 名数据，并且你可以使用方法GetFilenames()来从该数据对象获取文件名，该方 法返回一个文件名的列表，列表中的每个文件名是已经被添加到剪贴板的文件 名。你可以使用该数据对象的AddFile(file)方法来将数据放置到剪贴板上，该方 法将一个文件名字符串添加到该数据对象。这里没有其它的方法用于直接处理 列表，所以这就要靠你自己了。本章的稍后部份，我们将讨论如何经由剪贴板 传送自定义对象，以及如何拖放对象。 18.2 拖放源 546 / 565
- 547. 拖放是一个类似剪切和粘贴的功能。它是在你的应用程序的不同部分之间 或两个不同的应用程序之间传送数据。由于管理数据和格式几乎是相同的，所 以wxPython同样使用wx.DataObject族来确保对格式作恰当的处理。 拖放和剪切粘贴的最大不同是，剪切粘贴信赖于中介剪贴板的存在。因为 是剪贴板管理数据，所以源程序将数据传送后就不管之后的事情了。这对于拖 放却不然，源应用程序不仅虽要创建一个拖动管理器来服务于剪贴板，而且它 也必须等待目标应用程序的响应。不同于一个剪贴板的操作，在拖放中，是目 标应用来决定操作是一个剪贴或拷贝，所以源应用必须等待以确定传送的数据 所用的目的。 通常，对源的拖动操作是在一个事件处理函数中进行，通常是一个鼠标事 件，因为拖动通常都随鼠标的按下事件发生。创建一个拖动源要求四步： 1、创建数据对象 2、创建wx.DropSource实例 3、执行拖动操作 4、取消或允许释放 步骤1 创建一个数据对象 这第一步是创建你的数据对象。这在早先的剪贴板操作中有很好的说明。 对于简单的数据，使用预定义的wx.DataObject的子类是最简单的。有了数据对 象后，你可以创建一个释放源实例 步骤2 创建释放源实例 接下来的步骤是创建一个wx.DropSource实例，它扮演类似于剪贴板这样的 传送角色。wx.DropSource的构造函数如下： wx.DropSource(win, iconCopy=wx.NullIconOrCursor, iconMove=wx.NullIconOrCursor, iconNone=wx.NullIconOrCursor) 参数win是初始化拖放操作的窗口对象。其余的三个参数用于使用自定义 的图片来代表鼠标的拖动意义（拷贝、移动、取消释放）。如果这三个参数没 有指定，那么使用系统的默认值。在微软的Windows系统上，图片必须是 wx.Cursor对象，对于Unix则应是wx.Icon对象——Mac OS目前忽略你的自定义 图片。 547 / 565
- 548. 一旦你有了你的wx.DropSource实例，那么就可以使用方法SetData(data)来 将你的数据对象关联到wx.DropSource实例。接下来我们将讨论实际的拖动。 步骤3 执行拖动 拖动操作通过调用释放源的方法DoDragDrop(flags=wx.Drag_CopyOnly)来 开始。参数flags表示目标可对数据执行的何种操作。取值有 wx.Drag_AllowMove，它表示批准执行一个移动或拷贝，wx.Drag_DefaultMove 表示不仅允许执行一个移动或拷贝，而且做默认的移动操 作，wx.Drag_CopyOnly表示只执行一个拷贝操作。 步骤4 处理释放 DoDragDrop()方法直到释放被目标取消或接受才会返回。在此期间，虽然 绘制事件会继续被发送，但你的应用程序的线程被阻塞。DoDragDrop()的返回 值基于目标所要求的操作，取值如下： wx.DragCancel（对于取消操作而言） wx.DragCopy （对于拷贝操作而言） wx.DragMove （对于移动操作而言） wx.DragNone （对于错误而言） 对这些返回值的响应由你的应用程序来负责。通常对于响应移动要删除被 拖动的数据外，对于拷贝则是什么也不用做。 18.2.1 实战拖动 例18.2显示了一个完整的拖动源控件，适合于通过拖动上面的箭头图片到 你的系统的任何接受文本的应用上（如Microsoft word）。图18.2图示了这个例 子。 548 / 565
- 551. app = wx.PySimpleApp() frm = MyFrame() frm.Show() app.MainLoop() 接下来，我们将给你展示目标处的拖放。 下节内容提示：拖放的目标 18.3 拖放到的目标 实现拖放到的目标的步骤基本上借鉴了实现拖放源的步骤。其中最大的区 别是，实现拖放源，你可以直接使用类wx.DropSource，而对于目标，你首先必 须写你的自定义的wx.DropTarget的子类。一旦你有了你的目标类，你将需要创 建它的一个实例，并通过使用wx.Window的SetDropTarget(target)方法将该实例 与任一 wx.Window的实例关联起来。设置了目标后，wx.Window的实例（不论它 是一个窗口，一个按钮，一个文本域或其它的控件）就变成了一个有效的释放 目标。为了在你的释放目标上接受数据，你也必须创建一个所需要类型的 wx.DataObject对象，并使用释放目标方法SetDataObject(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,y是释放时鼠标的位置。default参数是DoDragDrop() 的四个取值之一，具体的值基于操作系统，传递给DoDragDrop()标志和当释放 551 / 565
- 552. 发生时修饰键的状态。在且仅在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.DropTarget类中有五个On...方法，你可以在你的子类中覆盖它们以在 目标被调用时提供自定义的行为。我们已经见过了其中的OnData()，另外的如 下： OnDrop(x, y) OnEnter(x, y, default) OnDragOver(x, y, default) OnLeave() 其中的参数x, y, default同OnData()。你不必覆盖这些方法，但是如果你想 在你的应用程序中提供自定义的功能的话，你可以覆盖这些方法。 当鼠标进入释放到的目标区域时，OnEnter()方法首先被调用。你可以使用 该方法来更新一个状态窗口。该方法返回如果释放发生时要执行的操作（通常 是default的值）或wx.DragNone（如果你不接受释放的话）。该方法的返回值 被wxPython用来指定当鼠标移动到窗口上时，哪个图标或光标被用作显示。当 鼠标位于窗口中时，方法OnDragOver()接着被调用，它返回所期望的操作或 552 / 565
- 553. wx.DragNone。当鼠标被释放并且释放(drop)发生时，OnDrop()方法被调用，并 且它默认调用OnData()。最后，当光标退出窗口时OnLeave()被调用。 与数据对象一同，wxPython提供了两个预定义的释放到的目标类来涵盖最 常见的情况。除了在这些情况中预定义的类会为你处理wx.DataObject，你仍然 需要创建一个子类并覆盖一个方法来处理相关的数据。关于文本，类 wx.TextDropTarget提供了可覆盖的方法OnDropText(x, y, data)，你将使用通过覆 盖该方法来替代覆盖OnData()。参数x,y是释放到的坐标，参数data是被释放的 字符串，该字符串你可以立即使用面不用必须对数据对象作更多的查询。如果 你接受新的文本的话，你的覆盖应该返回True，否则应返回False。对于文件的 释放，相关的预定义的类是wx.FileDropTarget，并且可覆盖的方法是 OnDropFiles(x, y, filenames)，参数filenames是被释放的文件的名字的一个列 表。另外，必要的时候你可以处理它们，当完成时可以返回True或False。 下节内容提示：实战释放 18.3.2 实战释放 例18.3中的代码显示了如何创建一个框架（窗口）用以接受文件的释放。 你可以通过从资源管理器或查找窗口拖动一个文件到该框架（窗口）上来测试 例子代码，并观查显示在窗口中的关于文件的信息。图18.3是运行后的结果。 图18.3 例18.3 文件释放到的目标的相关代码 #-*- encoding:UTF-8 -*- import wx 553 / 565
- 555. 到目前为止，我们还是局限于对wxPython的预定义的对象的数据传送的讨 论。接下来，我们将讨论如何将你自己的数据放到剪贴板上。 18.4 传送自定义对象 使用wxPython的预定义的数据对象，你只能工作于纯文本、位图或文件。 而更有创建性的是，你应该让你自定义的对象能够在应用之间被传送。在这一 节，我将给你展示如何给你的wxPython应用程序增加更高级的性能，如传送自 定义的数据对象和以多种格式传送一个对象。 18.4.1 传送自定义的数据对象 尽管文本、位图的数据对象和文件名的列表对于不同的使用已经足够了， 但有时你仍然需要传送自定义的对象，如你自己的图形格式或一个自定义的数 据结构。接下来，在保留对你的对象将接受的数据的类型的控制时，我们将涉 及传送自定义数据对象的机制。该方法的局限是它只能工作在wxPython内，你 不能使用这个方法来让其它的应用程序去读你的自定义的格式。要将RTF（丰 富文本格式）传送给Microsoft Word，该机制将不工作。 要实现自定义的数据传送，我们将使用wxPython的类 wx.CustomDataObject，它被设计来用于处理任意的数据。wx.CustomDataObject 的构造器如下： wx.CustomDataObject(format=wx.FormatInvalid) 参数format技术上应该是类wx.DataFormat的一个实例，但为了我们的目 的，我们可以只给它传递一个字符串，数据类型的责任由wxPython来考虑。我 们只需要这个字符串作为自定义格式的一个标签，以与其它的区分开来。一旦 我们有了我们自定义的数据实例，我们就可以使用方法SetData(data)将数据放 入到自定义的数据实例中。参数data必须是一个字符串。下面是一段样板代 码： data_object = wx.CustomDataObject(“MyNiftyFormat”) data = cPickle.dumps(my_object) data_object.SetData(data) 555 / 565
- 556. 在这段代码片断之后，你可以将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.PyTextDataObject，wx.PyBitmapDataObject, 或 wx.PyFileDataObject的一个子类。这将使你能够覆盖所有必要的方法。 18.4.3 以多种格式传送对象 使用wxPython的数据对象来用于数据传送的最大好处是，数据对象了解数 据格式。一个数据对象甚至能够用多种的格式来管理相同的数据。例如，你可 能希望你自己的应用程序能够接受你的自定义的文本格式对象的数据，但是你 仍然希望其它的应用能够以纯文本的格式接受该数据。 管理该功能的机制是类wx.DataObjectComposite。目前，我们所见过的所有 被继承的数据对象都是wx.DataObjectSimple的子类。wx.DataObjectComposite的 目的是将任意数量的简单数据对象合并为一个数据对象。该合并后的对象能够 将它的数据提供给与构成它的任一简单类型匹配的一个数据对象。 556 / 565
- 557. 要建造一个合成的数据对象，首先要使用一个无参的构造器 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.Timer最灵活和最有效的用法是使它产生EVT_TIMER，并将该事件 如同其它事件一样进行绑定。 创建定时器 要创建一个定时器，首先要使用下面的构造器来创建一个wx.Timer的实 例。 wx.Timer(owner=None, id=-1) 其中参数owner是实现wx.EvtHandler的实例，即任一能够接受事件通知的 wxPython控件或其它的东西。参数id用于区分不同的定时器。如果没有指定 id，则wxPython会为你生成一个id号。如果当你创建定时器时，你不想设置参 数owner和id，那么你可以以后随时使用SetOwner(owner=None, id=-1)方法来设 置，它设置同样的两个参数。 557 / 565
- 558. 绑定定时器 在你创建了定时器之后，你可以如下面一行的代码来在你的事件处理控件 中绑定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是毫秒数。这 将在经过milliseconds时间后，产生一个wx.EVT_TIMER事件。如果 milliseconds=-1，那么将使用早先的毫秒数。如果oneShot为True，那么定时器 只产生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
- 559. 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.TimerEvent几乎与它的父类wx.Event是一样的，除了它不包括 wx.GetInterval()方法来返回定时器的时间间隔外。万一你将来自多个定时器的 事件绑定给了相同的处理函数，并希望根据特定的定时器的事件来做不同的动 作的话，可使用事件方法GetId()来返回定时器的ID，以区别对待。 559 / 565
- 560. 18.5.2 学习定时器的其它用法 另一种使用定时器的方法是子类化wx.Timer。在你的子类中你可以覆盖方 法Notify()。在父类中，该方法每次在定时器经过指定的时间间隔后被自动调 用，它触发定时器事件。然而你的子类没有义务去触发一个定时器事件，你可 以在该Notify()方法中做你想做的事，以响应定时器的时间间隔。 要在未来某时触发一个特定的行为，有一个被称为wx.FutureCall的类可以 使用。它的构造器如下： wx.FutureCall(interval, callable, *args, **kwargs) 一旦它被创建后，wx.FutureCall的实例将等待interval毫秒，然后调用传递 给参数callable的对象，参数*args, **kwargs是callable中的对象所要使用 的。wx.FutureCall只触发一次定时事件。 下节内容提示：创建一个多线程的wxPython应用程序 18.6 创建一个多线程的wxPython应用程序 在大多数的GUI应用程序中，在应用程序的后台中长期执行一个处理过程 而不干涉用户与应用程序的其它部分的交互是有好处的。允许后台处理的机制 通常是产生一个线程并在该线程中长期执行一个处理过程。对于wxPython的多 线程，在这一节我们有两点需要特别说明。 最重要的一点是，GUI的操作必须发生在主线程或应用程序的主循环所处 的地方中。在一个单独的线程中执行GUI操作对于无法预知的程序崩溃和调试 来说是一个好的办法。基于技术方面的原因，如许多Unix的GUI库不是线程安 全性的，以及在微软Windows下UI对象的创建问题，wxPython没有设计它自己 的发生在多线程中的事件，所以我们建议你也不要尝试。 上面的禁令包括与屏幕交互的任何项目，尤其包括wx.Bitmap对象。 对于wxPython应用程序，关于所有UI的更新，后台线程只负责发送消息给 UI线程，而不关心GUI的更新。幸运的是，wxPython没有强制限定你能够有的 后台线程的数量。 560 / 565
- 561. 在这一节，我们将关注几个wxPython中实现多线程的方法。最常用的技术 是使用wx.CallAfter()函数，一会我们会讨论它。然后，我们将看一看如何使用 Python的队列对象来设置一个并行事件队列。最后，我们将讨论如何为多线程 开发一个定制的解决方案。 18.6.1 使用全局函数wx.CallAfter() 例18.5显示了一个使用线程的例子，它使用了wxPython的全局函数 wx.CallAfter()，该函数是传递消息给你的主线程的最容易的方 法。wx.CallAfter()使得主线程在当前的事件处理完成后，可以对一个不同的线 程调用一个函数。传递给wx.CallAfter()的函数对象总是在主线程中被执行。 图18.4显示了多线程窗口的运行结果。 图18.4 例18.5显示了产生图18.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
- 564. 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() 上面这个例子使用了Python的threading模块。上面的代码使用 wx.CallAfter(func,*args)传递方法给主线程。这将发送一个事件给主线程，之 后，事件以标准的方式被处理，并触发对func(*args)的调用。因些，在这种情 况中，线程在它的生命周期期间调用LogMessage()，并在线程结束前调用 ThreadFinished()。 18.6.2 使用队列对象管理线程的通信 尽管使用CallAfter()是管理线程通信的最简单的方法，但是它并不是唯一 的机制。你可以使用Python的线程安全的队列对象去发送命令对象给UI线程。 这个UI线程应该在wx.EVT_IDLE事件的处理函数中写成需要接受来自该队列的 命令。 本质上，你要为线程通信设置一个并行的事件队列。如果使用这一方法， 那么工作线程在当它们增加一个命令对象到队列时，应该调用全局函数 wx.WakeUpIdle()以确保尽可能存在在一个空闲事件。这个技术比wx.CallAfter() 更复杂，但也更灵活。特别是，这个机制可以帮助你在后台线程间通信，虽然 所有的GUI处理仍在主线程上。 18.6.3 开发你自已的解决方案 你也可以让你自己的工作线程创建一个wxPython事件（标准的或自定义 的），并使用全局函数wx.PostEvent(window, event)将它发送给UI线程中的一个 特定的窗口。该事件被添加到特定窗口的未决事件队列中，并且 wx.WakeUpIdle自动被调用。这条道的好处是事件将遍历的wxPython事件设 564 / 565
- 565. 置，这意味你将自由地得到许多事件处理能力，坏处是你不得不自已管理所有 的线程和wx.CallAfter()函数所为你做的事件处理。 下节内容提示：本章小结 18.7 本章小结 1、拖放和剪贴板事件是非常相似的，两者都使用了wx.DataObject来作为 数据格式的媒介。除了可以创建自定义的格式以外，还存在着默认的数据对 象，包括文本，文件和位图。在剪贴板的使用中，全局对象wx.TheClipboard管 理数据的传送并代表底层系统的剪贴板。 2、对于拖放操作，拖动源和拖动到的目标一起工作来管理数据传送。拖 动源事件被阻塞直到拖动到的目标作出该拖动操作是否有效的判断。 3、类wx.Timer使你能够设置定时的事件。 4、线程在wxPython是可以实现的，但时确保所有的GUI活动发生在主线程 中是非常重要的。你可以使用函数wx.CallAfter()来管理内部线程的通信问题。 565 / 565