wxPython官方文档翻译第一期初稿

wxPyWiki的目的是为了提供软件文档、示例、使用方法等。是为了帮助人们学习、理解和使用wxPython。


注解:想了解更多关于wxPython的内容,可以点击这里。


这里有多种类型的可用信息。当前的有:
学习wxPython:
o 安装——如何安装wxPython。(不要忘记去安装文档和示例!)
o 如何学习wxPython——知识概要和学习策略
o 入门指南——编写Hello World和基本概念
o Sizer教程——使用不同Sizer的相关教程
o 使用Sizer——使用Sizer的常见误区和陷阱








如何安装wxPython


安装Python
稳定版的wxPython要求安装Python 2.7版本。Python下载可以点击这里


Windows
在Windows环境下进行安装是特别简单的:运行从wxPython得到的安装程序,根据提示进行即可。


Mac OS X
从wxPython可以获取可用的安装包,同时适用于PPC和Intel的Mac电脑
如果你想自定义安装,可以参照这里的指令
如果你得到了“damaged and can't be opened”,你需要更改安全配置设置,将Allow application downloaded from更改为Anywhere


GNU/Linux - Redhat
你可以找到适用于Redhat的RPM(通过Mandrake可以正常的工作),下载地址是wxPython


GNU/Linux - Debian
可以使用apt-get去安装wxPython,调用apt-get install python-wxgtk2.8 或 apt-get install python-wxgtk2.6,这取决于你想得到的版本。
你可能需要使用管理员权限去调用它。wxPython示例都在wx-examples包中。
我们建议去分别安装这些demo,具体描述在Using wxPython Demo Code。
尝试调用:
apt-get install python-wxgtk2.8
请注意,你可能使用本方法已经安装了wx较老的版本,参照InstallingOnUbuntuOrDebian去学习如何使用apt-get得到最新的版本。


GNU/Linux - Gentoo
通过portage去调用emerge wxPython可以安装wxPython(注意大写的P)。在04年11月28日前,正常的使用是emerge wxpython(不是大写的P)。


GNU/Linux - Building from the source
你可能也想利用源码去构建wxPython。那么你需要做以下三个步骤:
Installing wxGTK from source
wxGTK是GTK版的wxWidgets。GTK(Gimp ToolKit)是Gnome所使用的图形类库,所以它可能已经被安装在你的Linux机器中。
你需要去做的就是,从the wxGTK ftp server或wxWidgets website中去下载wxGTK。
通过命令去解压wxGTK:
tar -xvzf wxGTK-2.2.5.tar.gz
进入解压后的文件目录:
cd wxGTK-2.2.5
运行配置脚本:
./configure --with-gtk
如果GTK或GTK的依赖文件没有安装,会提示出错(在Mandrake版中,你应该安装的rpm是gtk+-devel-1.2.8-6mdk.i586.rpm)
运行命令:
make
如果没有安装yacc或lex会提示出错(在Mandrake版中,应该安装 byacc-1.9-7mdk.i586.rpm和flex-2.5.4a-13mdk.i586.rpm)
你现在应该有了编译好的wxGTK。我们现在去安装它,并把它链接到系统中。
进入超级管理员模式:
su
在这里,你需要提供权限密码。
安装wxGTK:
make install
链接库:
ldconfig
退出超级管理员模式:
exit
正常来说,wxGTK已经安装好了,但是可能wxPython可能还会有问题:
当wxPython去寻找库的时候,库并没有安装。(在Mandrake7.2版中,你想将库安装在/usr/lib,但是它会被自动安装在/usr/local/lib中)。
解决方法是,创建一个这个库的符号链接。
进入你想安装的目录中:
cd /usr/lib
创建一个符号链接这个库:
ln -s /usr/local/lib/libwx_gtk.so


利用源码安装wxPython
下载最新发布版的wxPython源码:
wxPython website
解压缩:
cd wxPython-2.2.5
进入目录:
cd wxPython-2.2.5
编辑setup.py,选择你想要安装的部分。建议不要安装OGL和GL_CANVAS。选择如下:
BUILD_GLCANVAS = 0 # If true, build the contrib/glcanvas extension module
BUILD_OGL = 0      # If true, build the contrib/ogl extension module
BUILD_STC = 1      # If true, build the contrib/stc extension module
CORE_ONLY = 0      # if true, don't build any of the above
GL_ONLY = 0        # Only used when making the -gl RPM.  See the "b" script
   # for the ugly details
USE_SWIG = 0       # Should we actually execute SWIG, or just use the
   # files already in the distribution?
IN_CVS_TREE = 0    # Set to true if building in a full wxWidgets CVS
   # tree, otherwise will assume all needed files are
   # available in the wxPython source distribution
构建python模块:
python setup.py build
进入超级管理员模式:
su
在这里,你需要提供权限密码。
安装模块:
python setup.py install
退出超级管理员模式:
exit
检查模式是否可以工作:
[lucas@b007 wxPython-2.2.5]$ python
Python 1.5.2 (#1, Sep 30 2000, 18:08:36)  [GCC 2.95.3 19991030 (prerelease)] on linux-i386
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> import wx
>>>
wxPython已经安装好了!

使用PIP安装wxPython-Phoenix
确保你已经最低安装有pip-6.0.8和setuptools-12.0.5
按照README.rst的要求进行安装:
https://github.com/wxWidgets/Phoenix/blob/master/README.rst
快速浏览snapshots的README.txt:
https://wxpython.org/Phoenix/snapshot-builds/README.txt
安装wxPython-Phoenix(Linux):
sudo pip install --upgrade --pre -f https://wxpython.org/Phoenix/snapshot-builds/ wxPython_Phoenix 
安装wxPython-Phoenix(Windows,在需要安装的目录下使用命令):
C:\python27\scripts\pip.exe install --upgrade --pre -f https://wxpython.org/Phoenix/snapshot-builds/ wxPython_Phoenix 
确认安装:
python2
   >>> import wx
   >>> wx.VERSION_STRING
   '3.0.3.dev1784+18750f4'
   >>> wx.version()
   '3.0.3.dev1784+18750f4 msw (phoenix)'
   
   
   
如何去学习wxPython


学习Python
如何你没有使用过Python,或者你从来没有进行过编程,那么首先去学习Python是最有意义的,不使用任何的GUI。
这个过程可能让人沮丧,但是很有必要。Python是一种非常强大的编程语言,不管是使用或不使用GUI。
最基本的,你应该理解函数、模块和类。没有这些,学习Python是非常困难的事情。在Python官网对于初学者有非常棒的指导,让你一步步的去学习它。http://www.python.org/about/gettingstarted/


选择一个好的编译器
拥有自动编译、代码提示和一个可交互的窗口,能够让编程更加的方便,避免出错。
点击http://wiki.python.org/moin/PythonEditors查看编译器列表。


安装wxPython
如果你还没有安装wxPython,请看如何安装wxPython。


阅读wxPython教程
Wiki教程:最重要是就是入门指南。然后你可以学习Obstacle Course和Fully Functional Demo。
其他教程:最棒的资源就是Zetcode wxPython tutorial。它拥有了大量的内容,包括:入门指南、菜单/工具栏、sizers、事件、drawing API、widgets、创建自定义的widgets和示例应用”skeleton“
视频教程:ShowMeDo.com中的wxPython tutorial videos特别适合初学者。YouTube中也有大量的视频。


阅读wxPython风格指南
它会告诉你,如何让你的wxPython代码更漂亮,更具有现在化的风格。由于多年来API的变化,和大量的经验,使得wxPython多年来变得更加Python化。
不幸的是,你会发现有很多示例并没有被更新成这种风格。当你刚开始的时候就学习wxPython Style Guide,能够让你使用好看,现代化的风格,这会是一种好的习惯。


阅读示例文件
wxPython自带有很全面的大量示例。进入the download page并找到wxPython-demo-x.x.x文件。示例会展示wxPython基本所有的工作。你可以查看不同功能是如何工作的,并学习源码。
注意:如果示例不能工作,请确保你已经安装了最新版的wxPython。有时候示例中使用的功能并不适用于老的版本。
检查你的wxPython版本,可以运行:
import wx
print wx.version()
wxPython中一种很普遍的工作方式,就是找到一个类似于你想要的功能的示例,然后复制它,并修改添加出你需要的功能。
另一个示例的源码是wxPython Cookbook.


阅读wxWidgets文档
一个非常重要的资源就是wxWidgets文档.
它主要是用C++编写的,但是它有很多针对于wxPython的注释,大多数时候,你可以从c++语法转换为wxPython语法。你并不需要知道C++对于它的作用在哪里。
很多wxPython程序员根本不懂c++,但是他们还是认为wxWidgets文档是很有帮助的。
如果你要阅读这个wxWidgets文档,C++ Guide for Pythoneers对你会有很大的帮助。或者你也可以在mailing list上寻求帮助。


使用wxPython引用(试验)
你可以去尝试automatically generated API reference。它是一个试验性的功能。它不像wxWidgets文档那样完善,但是它是用wxPython语法编写的。


学习其他人的代码
查尔斯·西蒙尼,微软的传奇性程序员,生于匈牙利,只有很少的书本能够让他去学习计算机科学。他就像音乐家使用乐谱学习一样,通过源码的编译和打印输出去学习编程。
在用wxPython编写的代码中,有很多经典之外,这是示例代码所没有的。例如,FrogEdit和它的底层wx.lib.editor模块。
我猜测一个editor会是一个wx.TextCtrl。我非常惊讶的发现,这个text使用DC(device control)绘制到屏幕上,我学习到了一些不错的技巧。
我也”读“了Transana和Task Coach这两个使用Python和wxPython编写的复杂的应用,去学习大型的应用是如何组成的。
在这个wiki中的小例子,和真实项目中的代码有非常大的不同,所以分析大型应用的过程就是学习wxPython的一部分。


提出问题!
wxPython用户邮件列表中的成员,都是友好的,乐于助人的。你可以在这里订阅它:https://wxpython.org/maillist.php






wxPyhon入门指南


第一个应用:”Hello World“
作为一种传统,我们首先编写一个”Hello World“的小应用。代码如下:
#!/usr/bin/env python
import wx


app = wx.App(False)  # Create a new app, don't redirect stdout/stderr to a window.
frame = wx.Frame(None, wx.ID_ANY, "Hello World") # A Frame is a top-level window.
frame.Show(True)     # Show the frame.
app.MainLoop()
说明:
app = wx.App(False) 每一个wxPython App都是wx.App的一个实例。对于大多数简单的应用你都可以直接使用wx.App。当你要开发更为复杂的应用时,你就应该去继承wx.App类了。”False“参数代表”不要将标准输出和标准错误重定向到一个窗口“
wx.Frame(None,wx.ID_ANY,"Hello") 一个wx.Frame是一个最高等级的窗口。它的语法是x.Frame(Parent, Id, Title).大多数的时候,它的构造函数是这样的(a parent object, followed by an Id)。在这个例子中,我们使用None表示了”没有parent“,wx.ID_ANY表示让wxWidgets为我们选择一个ID
frame.Show(True)  我们修改一个frame的可见性,并展示出来。
app.MainLoop() 最后,我们开始一个应用的MainLoop,它是用来处理事件的
注意:你可能总是使用wx.ID_ANY或由wxWidgets提供的standard ID (v2.8)。你也可以去使用你自己的ID,但是这里没有必要去这样做。
运行程序,你可以看到如下的一个窗口:


窗口还是框架?
当人们在讨论GUI的时候,他们通常都是在说窗口,菜单和图标。自然地,你会认为wx.Window应该表示一个在屏幕上的窗口。
事实并非如此。一个wx.Window是一个所有可视化元素推导出来的基类(如按钮,菜单等),我们正常来说的作为一个程序窗口的其实是一个wx.Frame。
这是最让初学者感到困惑的地方。


构建一个简单的文本编辑器
在这个教程中,我们将要去构建一个简单的文本编辑器。在这个过程中,我们将要探索几个部件,并且学习相关的功能,如事件和回调。


第一步
第一步是创建一个带有可编辑文本框的框架。一个文本框可以用wx.TextCtrl部件来创建。默认情况下,一个文本框是单行的,wx.TE_MULTILINE参数可以允许我们输入多行的文本。
#!/usr/bin/env python
import wx
class MyFrame(wx.Frame):
    """ We simply derive a new class of Frame. """
    def __init__(self, parent, title):
        wx.Frame.__init__(self, parent, title=title, size=(200,100))
        self.control = wx.TextCtrl(self, style=wx.TE_MULTILINE)
        self.Show(True)


app = wx.App(False)
frame = MyFrame(None, 'Small editor')
app.MainLoop()
在这个例子中,我们取得wx.Frame,并重写了它的__init__函数。这里我们声明了一个新的wx.TextCtrl,是一个简单的文本编辑控件。注意,因为我们在MyFrame的__init__函数中运行了self.Show(),所以我们不需要再去调用frame.Show()了。


添加一个菜单栏
每一个应用都应该有一个菜单栏和一个状态栏。让我们把它们添加到我们应用中:
import wx


class MainWindow(wx.Frame):
    def __init__(self, parent, title):
        wx.Frame.__init__(self, parent, title=title, size=(200,100))
        self.control = wx.TextCtrl(self, style=wx.TE_MULTILINE)
        self.CreateStatusBar() # A Statusbar in the bottom of the window


        # Setting up the menu.
        filemenu= wx.Menu()


        # wx.ID_ABOUT and wx.ID_EXIT are standard IDs provided by wxWidgets.
        filemenu.Append(wx.ID_ABOUT, "&About"," Information about this program")
        filemenu.AppendSeparator()
        filemenu.Append(wx.ID_EXIT,"E&xit"," Terminate the program")


        # Creating the menubar.
        menuBar = wx.MenuBar()
        menuBar.Append(filemenu,"&File") # Adding the "filemenu" to the MenuBar
        self.SetMenuBar(menuBar)  # Adding the MenuBar to the Frame content.
        self.Show(True)


app = wx.App(False)
frame = MainWindow(None, "Sample editor")
app.MainLoop()
提示:注意wx.ID_ABOUT和wx.ID_EXIT这两个ID。它们是由wxWidgets提供的标准ID(点击这里查看完整的列表)。使用标准ID是一个非常良好的习惯。标准ID能够让wxWidgets知道如何在每个平台中去显示这个部件,能够让部件看起来更加的自然。


事件处理
在wxPython中,对于事件的反馈叫事件处理。一个事件表示在你的应用中发生了某些事情(如点击按钮、文本输入、鼠标点击等)。GUI程序很大一部分都是由事件处理组成的。使用bind()方法将事件绑定到对应的对象上:
class MainWindow(wx.Frame):
    def __init__(self, parent, title):
        wx.Frame.__init__(self,parent, title=title, size=(200,100))
        ...
        menuItem = filemenu.Append(wx.ID_ABOUT, "&About"," Information about this program")
        self.Bind(wx.EVT_MENU, self.OnAbout, menuItem)
这样意味着,从现在开始,当用户选择”About“菜单项时,self.OnAbout这个函数会被调用。wx.EVT_MENU是“选择菜单项”事件。wxWidgets能够理解更多的其他事件(点击查看完整列表)。这个self.OnAbout函数拥有如下声明:
def OnAbout(self, event):
        ...
这里event是wx.Event子类的一个实例。例如,一个按钮点击事件——wx.EVT_BUTTON——是wx.Event的一个子类。
当事件发生时,这个函数会被调用。默认情况下,这个函数会处理这个事件,在回调完成后这个事件会终止。但是,你也可以使用event.Skip()去“跳过”一个事件。这会使得这个事件直接通过这个事件处理。例如:
def OnButtonClick(self, event):
    if (some_condition):
        do_something()
    else:
        event.Skip()


def OnEvent(self, event):
    ...
当一个按钮点击事件发生时,OnButtonClick函数被调用。如果some_condition是true,我们会调用do_something(),否则我们会让这个事件直接通过事件处理。现在让我们来看看我们的应用:
import os
import wx




class MainWindow(wx.Frame):
    def __init__(self, parent, title):
        wx.Frame.__init__(self, parent, title=title, size=(200,100))
        self.control = wx.TextCtrl(self, style=wx.TE_MULTILINE)
        self.CreateStatusBar() # A StatusBar in the bottom of the window


        # Setting up the menu.
        filemenu= wx.Menu()


        # wx.ID_ABOUT and wx.ID_EXIT are standard ids provided by wxWidgets.
        menuAbout = filemenu.Append(wx.ID_ABOUT, "&About"," Information about this program")
        menuExit = filemenu.Append(wx.ID_EXIT,"E&xit"," Terminate the program")


        # Creating the menubar.
        menuBar = wx.MenuBar()
        menuBar.Append(filemenu,"&File") # Adding the "filemenu" to the MenuBar
        self.SetMenuBar(menuBar)  # Adding the MenuBar to the Frame content.


        # Set events.
        self.Bind(wx.EVT_MENU, self.OnAbout, menuAbout)
        self.Bind(wx.EVT_MENU, self.OnExit, menuExit)


        self.Show(True)


    def OnAbout(self,e):
        # A message dialog box with an OK button. wx.OK is a standard ID in wxWidgets.
        dlg = wx.MessageDialog( self, "A small text editor", "About Sample Editor", wx.OK)
        dlg.ShowModal() # Show it
        dlg.Destroy() # finally destroy it when finished.


    def OnExit(self,e):
        self.Close(True)  # Close the frame.


app = wx.App(False)
frame = MainWindow(None, "Sample editor")
app.MainLoop()
注意:可代替的
wx.MessageDialog( self, "A small editor in wxPython", "About Sample Editor", wx.OK)
我们可以省略掉这个id。在这种情况下,wxWidget会自动生成一个ID(就像你指定了wx.ID_ANY一样):
wx.MessageDialog( self, "A small editor in wxPython", "About Sample Editor")


对话框
当然,如果不能够去保存或打开一个文档,一个编辑器是没有用处的。这个时候普通的对话框就起作用了。普通对话框是由平台底层去提供的,这让你的应用看起来更像是原生应用一样。这里在MainWindow中实现了OnOpen函数:
 def OnOpen(self,e):
        """ Open a file"""
        self.dirname = ''
        dlg = wx.FileDialog(self, "Choose a file", self.dirname, "", "*.*", wx.OPEN)
        if dlg.ShowModal() == wx.ID_OK:
            self.filename = dlg.GetFilename()
            self.dirname = dlg.GetDirectory()
            f = open(os.path.join(self.dirname, self.filename), 'r')
            self.control.SetValue(f.read())
            f.close()
        dlg.Destroy()、
说明:
首先,我们通过调用适当的构造函数创建了这个对话框
然后,我们调用了ShowModal。打开这个对话框——“Modal”意味着用户不能进行任何操作,除非他点击了确定或取消。
ShowModal的返回值是被点击按钮的ID。如果用户点击了确定,我们就可以读取这个文件。
你现在应该可以添加相应的入口到菜单中,并把它连接到OnOpen函数中。如果你有任何问题,向下滚动到附件中的完整源码。

可能的扩展
当然,这个程序远不能成为一个像样的编辑器。但是添加一些其他的功能部件并不比之前的那些困难。你可能会从wxPython附带包中的那些示例中获得灵感:
Drag and Drop.
MDI
Tab view/multiple files
Find/Replace dialog
Print dialog (Printing)
Macro-commands in python ( using the eval function)
etc ...




在Windows环境下工作
主题:
Frames(框架)
Windows(窗口)
Controls/Widgets(控件/部件)
Sizers(筛分器)
Validators(验证器)
在这一部分,我们将要展示如何使用wxPython去处理窗口和窗口里的内容,包括创建输入表单,使用大量的部件/控件。我们将要去创建一个计算价格的小应用。
如果你是一个有经验的GUI开发者,这对你来说是非常简单的,你可以直接去看高级部分的Boa-Constructor部分。


入门指南
制定视觉元素
在一个框架里,你应该会使用若干的wxWindow子类去充实这个框架的内容。这里有一些普通的元素,可能你会想要放进你的框架中:
wx.MenuBar,在你的框架顶部放置一个菜单栏。
wx.StatusBar,放在你的框架底部区域,用来显示一些状态信息等。
wx.ToolsBar,在你的框架中放置一个工具栏。
wx.Control的子类,这些是呈现用户界面部件的对象(显示数据或处理用户输入的视觉元素)。普通的wx.Control例子包括wx.Button, wx.StaticText, wx.TextCtrl和wx.ComboBox.
wx.Panel,是一个可以持有你不同wx.Control对象的容器。把你的wx.Control放入到wx.Panel中,用户可以从一个UI小部件切换到下一个。
所有的视觉元素(wxWindow对象和他们的子类)都可以持有子元素。例如,wx.Frame可以持有若干个wx.Panel对象,而wx.Panel对象又持有若干个wx.Button, wx.StaticText和wx.TextCtrl对象,这样使得你的元素更具有层次感。
注意:这只不过是描述了某些视觉元素之间是有联系的,并不是在说他们是如何摆放在框架上的。去解决如何在框架里摆放元素,你有以下几个方法:
1.你可以通过手动指定每个元素在他们父窗口中精确的像素位置。因为在不同平台中字体大小等的不同,这个方法并不推荐。
2.你可以使用wx.LayoutConstraints,可是用起来是相当的复杂的。
3.你可以使用Delphi-like的LayoutAnchors,它用起来比wx.LayoutConstraints简单一些
4.你可以使用wxSizer子类中的一个。
这篇文档会集中介绍使用wxSizers,因为这个是我最熟悉的。




Sizers
一个sizer(它是wxSizer子类中的一个)可以被用来去解决在一个窗口或框架中视觉元素的排列。Sizers能够做:
计算出每个视觉元素合适的大小
根据确定准则去定位所有的元素
当框架调整大小后,动态的重新调整或重新定位每个元素
经常使用的一些sizers包括:
wx.BoxSizer,按照水平或垂直的线性方式去排列视觉元素。
wx.GridSizer,将所有视觉元素安排在格状布局中。
wx.FlexGridSizer,类似于wx.GridSizer,但它能够更灵活的去排列视觉元素。
通过调用sizer.Add(window, options...)或sizer.AddMany(...),sizer将若干wx.Window对象进行排列。sizer只能对那些被赋予的元素进行工作。
Sizers可以进行嵌套。你可以将一个sizer添加到另一个sizer中,例如现在有两行按钮(每行都使用一个行排列的wx.BoxSizer)包含在另一个wx.BoxSizer中,然后让一行按钮在另一行上面。就像这样:
注意:上面的例子中,并不是排列了两行按钮,每行有三个。要这样做,需要使用wx.GridSizer.
在下面的例子中,我们使用了两个嵌套的sizer,其中一个垂直排列的sizer嵌套了一个水平排列的sizer:
import wx
import os


class MainWindow(wx.Frame):
    def __init__(self, parent, title):
        self.dirname=''


        # A "-1" in the size parameter instructs wxWidgets to use the default size.
        # In this case, we select 200px width and the default height.
        wx.Frame.__init__(self, parent, title=title, size=(200,-1))
        self.control = wx.TextCtrl(self, style=wx.TE_MULTILINE)
        self.CreateStatusBar() # A Statusbar in the bottom of the window


        # Setting up the menu.
        filemenu= wx.Menu()
        menuOpen = filemenu.Append(wx.ID_OPEN, "&Open"," Open a file to edit")
        menuAbout= filemenu.Append(wx.ID_ABOUT, "&About"," Information about this program")
        menuExit = filemenu.Append(wx.ID_EXIT,"E&xit"," Terminate the program")


        # Creating the menubar.
        menuBar = wx.MenuBar()
        menuBar.Append(filemenu,"&File") # Adding the "filemenu" to the MenuBar
        self.SetMenuBar(menuBar)  # Adding the MenuBar to the Frame content.


        # Events.
        self.Bind(wx.EVT_MENU, self.OnOpen, menuOpen)
        self.Bind(wx.EVT_MENU, self.OnExit, menuExit)
        self.Bind(wx.EVT_MENU, self.OnAbout, menuAbout)


        self.sizer2 = wx.BoxSizer(wx.HORIZONTAL)
        self.buttons = []
        for i in range(0, 6):
            self.buttons.append(wx.Button(self, -1, "Button &"+str(i)))
            self.sizer2.Add(self.buttons[i], 1, wx.EXPAND)


        # Use some sizers to see layout options
        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer.Add(self.control, 1, wx.EXPAND)
        self.sizer.Add(self.sizer2, 0, wx.EXPAND)


        #Layout sizers
        self.SetSizer(self.sizer)
        self.SetAutoLayout(1)
        self.sizer.Fit(self)
        self.Show()


    def OnAbout(self,e):
        # Create a message dialog box
        dlg = wx.MessageDialog(self, " A sample editor \n in wxPython", "About Sample Editor", wx.OK)
        dlg.ShowModal() # Shows it
        dlg.Destroy() # finally destroy it when finished.


    def OnExit(self,e):
        self.Close(True)  # Close the frame.


    def OnOpen(self,e):
        """ Open a file"""
        dlg = wx.FileDialog(self, "Choose a file", self.dirname, "", "*.*", wx.OPEN)
        if dlg.ShowModal() == wx.ID_OK:
            self.filename = dlg.GetFilename()
            self.dirname = dlg.GetDirectory()
            f = open(os.path.join(self.dirname, self.filename), 'r')
            self.control.SetValue(f.read())
            f.close()
        dlg.Destroy()


app = wx.App(False)
frame = MainWindow(None, "Sample editor")
app.MainLoop()
sizer.Add函数有三个参数。第一个指定要被包含在这个sizer中控件。第二个是权重因数,表明这个控件在被调整大小时所占的比例。
例如,你有三个可编辑的控件,你想它们的比例为3:2:1,当添加控件时,你需要指定他们的因数作为参数。0表示这个控件或sizer并不会改变。
第三个参数是正常的wx.GROW(就像wx.EXPAND),表示当需要的时候,这个控件会被调整大小。如果使用了wx.SHAPED,会保持这个控件的纵横比。
如果第二个参数是0,也就是说,这个控件并不会被调整大小。如果这个控件需要水平或垂直居中,则需要使用wx.ALIGN_CENTER_HORIZONTAL, wx.ALIGN_CENTER_VERTICAL或wx.ALIGN_CENTER(可以都写上),而不是使用wx.GROW或wx.SHAPED作为第三个参数。
您还可以指定组合wx.ALIGN_LEFT, wx.ALIGN_TOP, wx.ALIGN_RIGHT和wx.ALIGN_BOTTOM.默认的情况下是wx.ALIGN_LEFT | wx.ALIGN_TOP.
wx.Sizer和它的子类有一个令人困惑的地方,一个sizer和一个parent window之间是有区别的。当你要创建一个对象添加到sizer中时,你不能让sizer作为对象的父窗口。sizer是排列窗口的一种方式,但是sizer并不等于window.
在上面的例子中,所有六个按钮都被创建,父窗口是包围按钮的框架或窗口——而不是sizer。如果你尝试创建一个视觉元素,而它的父窗口是sizer的话,那么你的程序就会崩溃。
一旦你创建了你的视觉元素,并把它们添加到一个sizer中(或者是一组嵌套的sizer),下一步就是告诉你的窗口或框架去使用这个sizer。你可以这样去做:
window.SetSizer(sizer)
window.SetAutoLayout(True)
sizer.Fit(window)
SetSizer()会告诉你的窗口(或框架)哪个sizer会被使用。SetAutoLayout()告诉你的窗口使用这个sizer去定位并调整你的组件。最后,调用sizer.Fit()告诉这个sizer计算所有元素的初始位置和大小。
如果你使用了sizer,这是您在第一次显示窗口或框架内容之前所要经历的正常过程。


菜单
验证器
当你创建了一个对话框或其他的输入表单时,你可以使用wx.Validator简化将数据加载到表单中的过程,验证输入的数据,并再次从表单中提取数据。wx.Validator也可以用来在输入时,拦截键盘或其他事件。
为了使用验证器,你需要去创建一个你自己的wx.Validator的子类(而不是wxPython中的wx.TextValidator或wx.GenericValidator)。然后调用myInputField.SetValidator(myValidator)把它和输入控件关联。
注意:你的wx.Validator子类必需实现wxValidator.Clone()函数。


一个实际的例子
我们第一个在面板中的标签
让我们开始一个例子。我们的程序会拥有单个的框架,包括一个面板和一个标签:
import wx
class ExampleFrame(wx.Frame):
    def __init__(self, parent):
        wx.Frame.__init__(self, parent)
        panel = wx.Panel(self)
        self.quote = wx.StaticText(panel, label="Your quote: ", pos=(20, 30))
        self.Show()


app = wx.App(False)
ExampleFrame(None)
app.MainLoop()
如果你阅读了Small Editor部分,这个设计应该是清楚的,你不应该有任何问题。注意:这里应该使用sizer,而不是指定每个部件的位置。注意这一行:
 self.quote = wx.StaticText(panel, label="Your quote: ", pos=(20, 30))
面板被用来作为我们wxStaticText的父参数。我们的静态文本将会出现在我们之前创建的面板上。wxPoint被用来作为位置参数。也有一个可选参数wxSize,但是在这里是不合理的。
[7]根据wxPython的文档:
“面板是放置控件的窗口。它通常被放置在框架中。它包含了最小的额外功能,超过了它的父类wxWindow;它主要就是类似于对话框的外观和功能,但是拥有任何父窗口的灵活性。”
事实上,它是一个简单的窗口被用来作为其他可处理数据的对象的(灰色)背景。它通常被当作控件或部件。
[8]标签被用来显示文本,不能用来与用户进行交互。


再添加一些控件
在示例和帮助中,你可以发现一系列完整的存在于wxPython中的大量控件,这里我们去展示那些更经常使用到的:
wxButton是最基础的控件:一个按钮展示了一段可以点击的文本。例如,这里有一个“Clear“按钮(去清除一段文件):
clearButton = wx.Button(self, wx.ID_CLEAR, "Clear")
self.Bind(wx.EVT_BUTTON, self.OnClear, clearButton)
wxTextCtrl这个控件可以让用户去输入文本。它自带有两个事件。在文本被改变时会调用EVT_TEXT,无论哪一个按键被点击时都会调用EVT_CHAR。
textField = wx.TextCtrl(self)
self.Bind(wx.EVT_TEXT, self.OnChange, textField)
self.Bind(wx.EVT_CHAR, self.OnKeyPress, textField)
例如:如果用户点击了”Clear“按钮,然后清除了文本区域,会发生EVT_TEXT事件,而不会发生EVT_CHAR事件。
wxComboBox一个非常类似于wxTextCtrl的下拉框,但是除了wxTextCtrl带有的事件外,wxComboBox还有EVT_COMBOBOX事件。
wxCheckBox复选框控件让用户用来选择true/false。
wxRadioBox让用户可以从一系列选项中选择的单选框
让我们仔细看看Form1的例子:
import wx
class ExamplePanel(wx.Panel):
    def __init__(self, parent):
        wx.Panel.__init__(self, parent)
        self.quote = wx.StaticText(self, label="Your quote :", pos=(20, 30))


        # A multiline TextCtrl - This is here to show how the events work in this program, don't pay too much attention to it
        self.logger = wx.TextCtrl(self, pos=(300,20), size=(200,300), style=wx.TE_MULTILINE | wx.TE_READONLY)


        # A button
        self.button =wx.Button(self, label="Save", pos=(200, 325))
        self.Bind(wx.EVT_BUTTON, self.OnClick,self.button)


        # the edit control - one line version.
        self.lblname = wx.StaticText(self, label="Your name :", pos=(20,60))
        self.editname = wx.TextCtrl(self, value="Enter here your name", pos=(150, 60), size=(140,-1))
        self.Bind(wx.EVT_TEXT, self.EvtText, self.editname)
        self.Bind(wx.EVT_CHAR, self.EvtChar, self.editname)


        # the combobox Control
        self.sampleList = ['friends', 'advertising', 'web search', 'Yellow Pages']
        self.lblhear = wx.StaticText(self, label="How did you hear from us ?", pos=(20, 90))
        self.edithear = wx.ComboBox(self, pos=(150, 90), size=(95, -1), choices=self.sampleList, style=wx.CB_DROPDOWN)
        self.Bind(wx.EVT_COMBOBOX, self.EvtComboBox, self.edithear)
        self.Bind(wx.EVT_TEXT, self.EvtText,self.edithear)


        # Checkbox
        self.insure = wx.CheckBox(self, label="Do you want Insured Shipment ?", pos=(20,180))
        self.Bind(wx.EVT_CHECKBOX, self.EvtCheckBox, self.insure)


        # Radio Boxes
        radioList = ['blue', 'red', 'yellow', 'orange', 'green', 'purple', 'navy blue', 'black', 'gray']
        rb = wx.RadioBox(self, label="What color would you like ?", pos=(20, 210), choices=radioList,  majorDimension=3,
                         style=wx.RA_SPECIFY_COLS)
        self.Bind(wx.EVT_RADIOBOX, self.EvtRadioBox, rb)


    def EvtRadioBox(self, event):
        self.logger.AppendText('EvtRadioBox: %d\n' % event.GetInt())
    def EvtComboBox(self, event):
        self.logger.AppendText('EvtComboBox: %s\n' % event.GetString())
    def OnClick(self,event):
        self.logger.AppendText(" Click on object with Id %d\n" %event.GetId())
    def EvtText(self, event):
        self.logger.AppendText('EvtText: %s\n' % event.GetString())
    def EvtChar(self, event):
        self.logger.AppendText('EvtChar: %d\n' % event.GetKeyCode())
        event.Skip()
    def EvtCheckBox(self, event):
        self.logger.AppendText('EvtCheckBox: %d\n' % event.Checked())




app = wx.App(False)
frame = wx.Frame(None)
panel = ExamplePanel(frame)
frame.Show()
app.MainLoop()
我们的类变得更大了;它现在有很多控件和控件反馈。我们添加了一个指定的wxTextCtrl,用来显示各个控件所发生的事件信息。


记事本
有时候,单个页面填充了一个数据量非常大的表单。wxNoteBook适用于这种情况:它允许用户通过点击相应的选项卡,可以快速的在少量的页面之间就是切换导航。
我们通过放置wxNoteBook代替我们的表单到主框架中,然后使用AddPage去添加我们的Form1到notebook中去实现这个功能。
注意ExamplePanel的parent是NoteBook。这是非常重要的
app = wx.App(False)
frame = wx.Frame(None, title="Demo with Notebook")
nb = wx.Notebook(frame)
nb.AddPage(ExamplePanel(nb), "Absolute Positioning")
nb.AddPage(ExamplePanel(nb), "Page Two")
nb.AddPage(ExamplePanel(nb), "Page Three")
frame.Show()
app.MainLoop()


改善布局——使用Sizer
经常使用绝对位置并让人非常满意:如果窗口不是正常的大小时(或其他理由)导致布局会很难看。wxPython有丰富的对象去排列控件。
wx.BoxSizer是最常用最简单的布局对象,它允许有大量的可能性。它的规则是非常简单的,就是按照一行或一列去排列控件,并在需要的时候去重新排列(当全局大小改变时)。
wx.GridSizer和wx.FlexGridSizer是两个非常重要的布局工具。它们将控件安装在一个表格布局中。
下面是重写了上面的例子,加入了sizer:
class ExamplePanel(wx.Panel):
    def __init__(self, parent):
        wx.Panel.__init__(self, parent)


        # create some sizers
        mainSizer = wx.BoxSizer(wx.VERTICAL)
        grid = wx.GridBagSizer(hgap=5, vgap=5)
        hSizer = wx.BoxSizer(wx.HORIZONTAL)


        self.quote = wx.StaticText(self, label="Your quote: ")
        grid.Add(self.quote, pos=(0,0))


        # A multiline TextCtrl - This is here to show how the events work in this program, don't pay too much attention to it
        self.logger = wx.TextCtrl(self, size=(200,300), style=wx.TE_MULTILINE | wx.TE_READONLY)


        # A button
        self.button =wx.Button(self, label="Save")
        self.Bind(wx.EVT_BUTTON, self.OnClick,self.button)


        # the edit control - one line version.
        self.lblname = wx.StaticText(self, label="Your name :")
        grid.Add(self.lblname, pos=(1,0))
        self.editname = wx.TextCtrl(self, value="Enter here your name", size=(140,-1))
        grid.Add(self.editname, pos=(1,1))
        self.Bind(wx.EVT_TEXT, self.EvtText, self.editname)
        self.Bind(wx.EVT_CHAR, self.EvtChar, self.editname)


        # the combobox Control
        self.sampleList = ['friends', 'advertising', 'web search', 'Yellow Pages']
        self.lblhear = wx.StaticText(self, label="How did you hear from us ?")
        grid.Add(self.lblhear, pos=(3,0))
        self.edithear = wx.ComboBox(self, size=(95, -1), choices=self.sampleList, style=wx.CB_DROPDOWN)
        grid.Add(self.edithear, pos=(3,1))
        self.Bind(wx.EVT_COMBOBOX, self.EvtComboBox, self.edithear)
        self.Bind(wx.EVT_TEXT, self.EvtText,self.edithear)


        # add a spacer to the sizer
        grid.Add((10, 40), pos=(2,0))


        # Checkbox
        self.insure = wx.CheckBox(self, label="Do you want Insured Shipment ?")
        grid.Add(self.insure, pos=(4,0), span=(1,2), flag=wx.BOTTOM, border=5)
        self.Bind(wx.EVT_CHECKBOX, self.EvtCheckBox, self.insure)


        # Radio Boxes
        radioList = ['blue', 'red', 'yellow', 'orange', 'green', 'purple', 'navy blue', 'black', 'gray']
        rb = wx.RadioBox(self, label="What color would you like ?", pos=(20, 210), choices=radioList,  majorDimension=3,
                         style=wx.RA_SPECIFY_COLS)
        grid.Add(rb, pos=(5,0), span=(1,2))
        self.Bind(wx.EVT_RADIOBOX, self.EvtRadioBox, rb)


        hSizer.Add(grid, 0, wx.ALL, 5)
        hSizer.Add(self.logger)
        mainSizer.Add(hSizer, 0, wx.ALL, 5)
        mainSizer.Add(self.button, 0, wx.CENTER)
        self.SetSizerAndFit(mainSizer)
这个例子使用了一个GridBagSizer去摆放它的控件。”pos“参数按照(x,y)的位置,控制了控件在表格中处于什么位置。例如,(0,0)是左上角的位置,(3,5)是在第三行第五列上。span参数允许一个控件去跨越多行或多列。


响应用户操作
主题:
事件
弹出式菜单
入门指南
概念请看这里
一个实际的例子
TODO:示例看这里。


绘制
主题:
设备上下文
字体
颜色
onPaint()函数
入门指南
在这个部分中,我们会介绍如何在一个窗口中进行绘制。我们也会展示如何去创建一个弹出式菜单,当在主窗口右击时。
一个实际的例子


使用wxPython
调试技术
当你的python程序碰到一个不可解决的错误(Bug!)时,程序会带着一个回溯中止运行,它用来帮助你去定位程序错误的位置。wxPython程序也可以做到这样,但会有一些不太一样。
回溯被导向了标准输入输出,在一个独立于程序的GUI框架中被捕获。如果一个错误发生在了一个事件处理中,回溯会显示出来,但你的程序会继续运行下去。但是,当初始化你的程序时出错,回溯会显示出来,然后程序就会中止,带着标准输入输出窗口(和回溯)。
当你继承了wxApp时,你可以通过wxPython提供的可选参数去获取标准输入输出。下面的例子可以很好的说明这个:
class MyApp (wx.App):
#...
#...
#...
myapp = MyApp() # functions normally. Stdio is redirected to its own window
myapp = MyApp(0) #does not redirect stdout. Tracebacks will show up at the console.
myapp = MyApp(1, 'filespec') #redirects stdout to the file 'filespec'
# NOTE: These are named parameters, so you can do this for improved readability:
myapp = MyApp(redirect = 1, filename = 'filespec') # will redirect stdout to 'filespec'
myapp = MyApp(redirect = 0) #stdio will stay at the console...
你也可以使用Widget Inspection Tool去帮助调试布局问题。


PyCrust可交互的shell
wxPython自带有PyCrust shell。使用它,你可以交互式的去测试你的布局。这里有一个简单的例子。
部署你的wxPython应用


下一步
事件
事件处理是wxPython关键功能之一。我们都知道所有的GUI系统,在大量的应用之间都依赖于事件去分发信息。当接受到一个详细的事件的时候,决定如何去做是每一个GUI应用的工作,被称为事件处理。
在以前的面对过程的程序中,处理事件意味着你要有一个”switch“操作,然后决定某个特定类型的事件应该如何去做。对于面向对象程序来说,这不是很简单的吗:有两种方法去处理事件:
一种方法(例如JAVA)依赖去调用事件处理。事件处理和特定的对象联系在一起,必定有一个回调函数。当对象接受到特定类型的事件时,事件处理触发回调函数。
另一种方法是提供预定名字的函数去处理特定的事件。这种方法,如果你要去修改一个特定类对于一个特定事件的响应,你应该派生你的类并重写相关的函数。
wxPython结合了以上两种方法。你可以通过派生类和实现新的行为去定义事件处理。
所以self.Bind(wx.EVT_SOMETHING, ACallable)意味着:
当一个SOMETHING事件传递到这个窗口(self)时,这个事件可以来自任何子窗口或它自己,然后调用ACallable,并且self必须是派生自wxPython窗口的一个类(如,一个按钮,一个对话框,一个框架),"ACallable”可以是任何函数,然后对于程序员来说通常的选择是使它成为上述类中的一个函数。


Scintilla
在wxPython中,Scintilla是wxStyledTextCtrl使用的基础组件,它提供了语法着色。
Boa-Constructor
Boa-Constructor是wxPython的一个RAD IDE

有用的资源
http://wxPython.org/
首先,一个很普通的网站,但是你可以去看看在wxPython页面上的Demo。这些是非常有用的示例,更接近于所有你想要的项目。如何去运行这些Demo:
在Windows环境下,点击开始菜单中的wxPython子菜单,选择这个程序然后运行。
在Linux环境下,找到Demo所在的目录路径,并运行“python demo.py”
http://wxPython.org/
你也可以尝试去wxWidgets网站发现信息。wxPython的文档包括了所有的wxWidget。如果你已经有了wxPython文档,去这个网站就没有意义了。
http://wxpython.org/maillist.php
这是wxPython的邮件列表。这是一个发现特定信息的好地方。在询问任何问题之前,请先寻找相关的文档。
Boa-Constructor是wxPython的一个RAD GUI buiding IDE。
这是一篇为新手准备的优秀文章。
最后但同样重要的,由Mark Hammond和Andy Robinson编写的书“Python Programming on Win32"有一个非常优秀的wxPython章节。
Scintilla是wxPython提供绑定的完整编辑组件(一个控件名为wxStyledTextCtrl2)
http://www.python.org/
这是python社区的相关网站
http://starship.python.net/crew/theller/py2exe/
使用这个工具,你可以将Python(也包括wxPython脚本...)脚本转换为独立的windows程序。这使得你的分发工作变得更加简单。


总之——跟随我们一起去GUI-apps的未来
你现在也学习了wxPython程序的方方面面,应该也可以去编写wxPython程序了。不要再犹豫了,快来订阅wxPython社区,来交流你所遇到的问题。


鸣谢
wxPython社区
Lucas Bruand
Rob CakeBread
Charlie Derr
Robin Dunn
Michael Roberts
Erik Westra
我们也想要去感谢:
Andrew Kuchling的帮助和支持,他并没有对于我无止境的问题和请求感到厌烦。
Robin North, J-P Syed, Armel Guenneugues, Pilar Rodriguez, Matteo Caligaris的大力支持,不开开玩笑的叫我Geek。


附录
Small editor - 完整代码
WxHowtoSmallEditor


Building Forms - 完整代码
WxHowtoBuildingForms


Drawing with wxPython - 完整代码
WxHowtoDrawing


A rudimentary project organizer - 完整代码
WxProject 它也展示了wxPyhton的用法.


常见问答
请看: FAQ


评论
评论示例
在这里可以随意添加任何评论或评论。欢迎和修改内容建议。
Lucas Bruand


OS独立路径连接
下面是代码:
import os
f=open(os.path.join(self.dirname,self.filename),'r')
Windows在这种情况下还是会出现问题,你使用普通的对话框去导航到本机的根目录时。这种情况,普通的对话框函数会返回self.dirname="c:"(你会期望是”c:“,除非你和MS交易了许多年)。不幸的是,当字符串中包括”:“时,os.path.join并不能工作,当打开”c:file.py“时会出现错误,因为这样会依赖于cwd设置(假设”file.py“在”C:\“中但不在cwd中)。
如何解决?我这样做:
f=open(self.dirname+'/'+self.filename,'r')
没有任何问题。我猜windows低级函数如”open“可能会调用os.path.normpath()修复它。这种优势在于,我还可以使用”/“用在目录和URL中,而且这段代码在Windows和Linux中都通用。我知道有一会也会出现错误。一个更好的方法就是:
f=open(os.path.normpath(os.path.join(self.dirname+os.sep,self.filename)),'r')
我认为适合于所有的场景,除非当你开始时self.dirname是'c:\'(在第一个join参数里normpath不会分离多于的分隔符)。或许一个更好的方法是使用os.path.isabs()
Kevin Vap


一步使用Sizer
我总是让设置sizer的三行代码变得更短(最少wxWidgets/wxPython 2.4以上),以前的使用是:
window.SetSizer(sizer)
window.SetAutoLayout(true)
sizer.Fit(window)
可以缩短为:
window.SetSizerAndFit(sizer)
Lukasz Pankowski


如何让标签工作
这对于我来说真的特别困难,在没有对话框的窗口中让标签工作:在整个文档中的唯一的提示就是在wxWindow风格wxTAB_TRAVERSAL的描述,但是它还是描述不太清楚。最后我这样去做:
1.想要所有的标签工作,你放置控件的窗口或独立面板,让它的风格如下:wxTAB_TRAVERSAL ie:
class ContactsPanel(wx.Panel):
    def __init__(self, parent,id):
        wx.Panel.__init__(self, parent, id, wx.DefaultPosition,wx.DefaultSize,
                         wx.RAISED_BORDER|wx.TAB_TRAVERSAL)
2.标签的顺序就是你把控件添加到面板或框架中的顺序。(信息来自于Massimiliano Sartor)
3.标签的顺序也可以看作为被创建控件的顺序。我猜这是因为控件ID数字的原因。sizer/panel的顺序貌似对于我没有用。-- Keith Veleba
4.一旦你的控件建立,这里有一些设置标签顺序的小技术:
order = (control1, control2, control3, ...)
for i in xrange(len(order) - 1):
    order[i+1].MoveAfterInTabOrder(order[i])
(这个列表包括了真实的控件对象。)这使得更改顺序和添加控件等变得简单。-- Don Dwiggins






Sizer教程
这一系列的教程会描述如何去使用一部分wxPython sizer,包括如何去管理控件的位置和大小。
BoxSizerTutorial——一个只使用BoxSizer的一般教程
GridSizerTutorial——一个使用GridSizer的一般教程
BoxSizerFromTheGroundUp——有实际示例的详细教程
GridBagSizerTutorial——使用GridBagSizer的一般教程
其他的一些关于sizer的好文档:
wxSizer in python
UsingSizers
wxDesigner Sizer Tutorial


BoxSizerTutorial:
在这个教程中,我们会创建一个只使用wx.BoxSizers的示例
例如:简单的数据收集表单,图标和文本沿着右边的冒号垂直对齐。
icon - title
separator
icon - text: - single line input control
icon - text: - single line input control
icon - text: - single line input control
icon - text: - multi-line text/list control that stretches vertically
separator
ok - cancel
首先,我们会倾巢出动一个wx.Frame去包含所有的控件,然后我们会创建一个wx.Panel作为框架的皮肤,让它在所有平台上看起来都很正常。
import wx
class MyForm(wx.Frame):


    def __init__(self):
        wx.Frame.__init__(self, None, wx.ID_ANY, title='My Form')


        # Add a panel so it looks correct on all platforms
        self.panel = wx.Panel(self, wx.ID_ANY)


if __name__ == '__main__':
    app = wx.PySimpleApp()
    frame = MyForm().Show()
    app.MainLoop()
下一步是去指出如何去创建一个图标。我会使用适用于的wx.ArtProvider,因为它一般的跨平台的位图/图标,我会把这个位置放在wx.StaticBitmap控件上。得出的代码如下:
bmp = wx.ArtProvider.GetBitmap(wx.ART_INFORMATION, wx.ART_OTHER, (16, 16))
titleIco = wx.StaticBitmap(self.panel, wx.ID_ANY, bmp)
让我们去看看这段代码到底如何工作的。GetBitmap的第一个参数是一个艺术ID,第二个参数是一个载体(比如wx.ART_TOOLBAR或wx.ART_MENU),第三个参数是图标的大小。
StaticBitmap的参数都可以看懂的。在wxPython示例中也可以看到这两个操作。
接下来我们把所有的代码整合到一起,然后把它们放到sizer中。在这个示例中我只使用BoxSizer。
import wx


class MyForm(wx.Frame):


    def __init__(self):
        wx.Frame.__init__(self, None, wx.ID_ANY, title='My Form')


        # Add a panel so it looks correct on all platforms
        self.panel = wx.Panel(self, wx.ID_ANY)


        bmp = wx.ArtProvider.GetBitmap(wx.ART_INFORMATION, wx.ART_OTHER, (16, 16))
        titleIco = wx.StaticBitmap(self.panel, wx.ID_ANY, bmp)
        title = wx.StaticText(self.panel, wx.ID_ANY, 'My Title')


        bmp = wx.ArtProvider.GetBitmap(wx.ART_TIP, wx.ART_OTHER, (16, 16))
        inputOneIco = wx.StaticBitmap(self.panel, wx.ID_ANY, bmp)
        labelOne = wx.StaticText(self.panel, wx.ID_ANY, 'Input 1')
        inputTxtOne = wx.TextCtrl(self.panel, wx.ID_ANY, '')


        inputTwoIco = wx.StaticBitmap(self.panel, wx.ID_ANY, bmp)
        labelTwo = wx.StaticText(self.panel, wx.ID_ANY, 'Input 2')
        inputTxtTwo = wx.TextCtrl(self.panel, wx.ID_ANY,'')


        inputThreeIco = wx.StaticBitmap(self.panel, wx.ID_ANY, bmp)
        labelThree = wx.StaticText(self.panel, wx.ID_ANY, 'Input 3')
        inputTxtThree = wx.TextCtrl(self.panel, wx.ID_ANY, '')


        inputFourIco = wx.StaticBitmap(self.panel, wx.ID_ANY, bmp)
        labelFour = wx.StaticText(self.panel, wx.ID_ANY, 'Input 4')
        inputTxtFour = wx.TextCtrl(self.panel, wx.ID_ANY, '')


        okBtn = wx.Button(self.panel, wx.ID_ANY, 'OK')
        cancelBtn = wx.Button(self.panel, wx.ID_ANY, 'Cancel')
        self.Bind(wx.EVT_BUTTON, self.onOK, okBtn)
        self.Bind(wx.EVT_BUTTON, self.onCancel, cancelBtn)


        topSizer        = wx.BoxSizer(wx.VERTICAL)
        titleSizer      = wx.BoxSizer(wx.HORIZONTAL)
        inputOneSizer   = wx.BoxSizer(wx.HORIZONTAL)
        inputTwoSizer   = wx.BoxSizer(wx.HORIZONTAL)
        inputThreeSizer = wx.BoxSizer(wx.HORIZONTAL)
        inputFourSizer  = wx.BoxSizer(wx.HORIZONTAL)
        btnSizer        = wx.BoxSizer(wx.HORIZONTAL)


        titleSizer.Add(titleIco, 0, wx.ALL, 5)
        titleSizer.Add(title, 0, wx.ALL, 5)


        inputOneSizer.Add(inputOneIco, 0, wx.ALL, 5)
        inputOneSizer.Add(labelOne, 0, wx.ALL, 5)


        inputOneSizer.Add(inputTxtOne, 1, wx.ALL|wx.EXPAND, 5)


        inputTwoSizer.Add(inputTwoIco, 0, wx.ALL, 5)
        inputTwoSizer.Add(labelTwo, 0, wx.ALL, 5)
        inputTwoSizer.Add(inputTxtTwo, 1, wx.ALL|wx.EXPAND, 5)


        inputThreeSizer.Add(inputThreeIco, 0, wx.ALL, 5)
        inputThreeSizer.Add(labelThree, 0, wx.ALL, 5)
        inputThreeSizer.Add(inputTxtThree, 1, wx.ALL|wx.EXPAND, 5)


        inputFourSizer.Add(inputFourIco, 0, wx.ALL, 5)
        inputFourSizer.Add(labelFour, 0, wx.ALL, 5)
        inputFourSizer.Add(inputTxtFour, 1, wx.ALL|wx.EXPAND, 5)


        btnSizer.Add(okBtn, 0, wx.ALL, 5)
        btnSizer.Add(cancelBtn, 0, wx.ALL, 5)


        topSizer.Add(titleSizer, 0, wx.CENTER)
        topSizer.Add(wx.StaticLine(self.panel,), 0, wx.ALL|wx.EXPAND, 5)
        topSizer.Add(inputOneSizer, 0, wx.ALL|wx.EXPAND, 5)
        topSizer.Add(inputTwoSizer, 0, wx.ALL|wx.EXPAND, 5)
        topSizer.Add(inputThreeSizer, 0, wx.ALL|wx.EXPAND, 5)
        topSizer.Add(inputFourSizer, 0, wx.ALL|wx.EXPAND, 5)
        topSizer.Add(wx.StaticLine(self.panel), 0, wx.ALL|wx.EXPAND, 5)
        topSizer.Add(btnSizer, 0, wx.ALL|wx.CENTER, 5)


        self.panel.SetSizer(topSizer)
        topSizer.Fit(self)




    def onOK(self, event):
        # Do something
        print 'onOK handler'


    def onCancel(self, event):
        self.closeProgram()


    def closeProgram(self):
        self.Close()




# Run the program
if __name__ == '__main__':
    app = wx.PySimpleApp()
    frame = MyForm().Show()
    app.MainLoop()
运行之后,效果如下:


所以,sizer是如何进行工作的呢?让我们来看一看。这是一个最基础的风格:
mySizer.Add(window, proportion, flag(s), border, userData)
第一个参数可以是窗口,控件,sizer或size。第二个参数是一个比例,可以让开发者指定当父窗口调整大小时,一个控件应该被拉伸成多少。
第三个参数是一个标志或一系列的标志,用来控制对齐方式,边界和重定大小。第四个参数是一个边界,表示添加的控件四周的空白区域的像素值。
最后一个是用户数据,从来没有使用过。然而,根据”wxPython in Action“这本书,它用于将额外的数据传递给sizer算法。


第三个参数中的标志,我使用的是wx.ALL, wx.EXPAND和wx.CENTER:wx.ALL用于在控件的所有方向放置x个像素。wx.EXPAND告诉sizer,允许控件在parent绅缩时进行绅缩。wx.CENTER会使控件外于parent的正中间。
如你所见,我为两个或更多的需要水平对齐的控件创建了一个单独的BoxSizer。然后我创建了一个主的垂直方向的BoxSizer,使得它可以把其他的sizer都放在里面。我也创建了两个wx.StaticLine在适当的地方作为分隔符。


最后,我使用SetSizer()把panel和最上层的Sizer关联到了一起。我也调用了sizer的Fit()函数,告诉sizer去计算基于窗口的大小。你也可以使用SetMinSize()函数,使得内部的所有控件处于最小状态。


现在你已经学习了如何使用BoxSizer去建立一个表单。进一步可以阅读:
wx.ArtProvider Docs
Learn Sizers
UsingSizers


GridSizerTutorial:
在我的BoxSizerTutorial中,我在wxPython中创建了一个普通的表单,只使用了wx.BoxSizer去自动调整我的控件大小。这一次,我在我的上一个示例中添加了wx.GridSizer去完成以下功能:
如何右对齐图标和标签
如何水平对齐标签和文件控件
如何保持文本控件和标签对齐,无论标签的长度如何
众所周知,实现上面功能的方法不只一种,只有更好更简单的。任何愚蠢的代码都是我的问题。
现在,是实现功能的时候了!需要注意的第一项就是使用wx.GridSizer。看看下面的代码:
gridSizer = wx.GridSizer(rows=4, cols=2, hgap=5, vgap=5)
这段代码我们,我创建了一个有4行2列,并且水平垂直方向都有5像素空白的控件。它会按照从左往右的方式去添加控件,当你已经添加了等同于列数的控件时,它会自动的切换到下一行。
换句话说,如果我添加了两个控件,然后一行就满了,如果我再添加一个控件,那么它就会自动添加到第二行(依次类推)。
在我们添加任何东西到wx.GridSizer之前,我们需要先看一下我如何改变了我的wx.BoxSizer.在每一个wx.BoxSizer之前都添加了一个间隔,并且设置proportion为1.
这意味着这些间隔使得每个sizer左边都有一些空白。我也在每个BoxSizer中添加了图标和标签,然后把这个wx.BoxSizer作为第一项添加到了wx.GridSizer中。回来说一下这个间隔:
inputOneSizer.Add((20,20), proportion=1)
这个间隔在这种情况下是一个元组。实际上你可以使用任何的大小。元组中的第一个元素是宽度,第二个是高度。如果我没有设置proportion为1,我可以用宽度的大小来调整我的图标和标签。
如果你想用默认的高度,可以设置-1.这样会告诉wxPython应该去使用默认值。
你应该注意到了,当我在wx.BoxSizer中添加标签时,我添加了wx.ALIGN_CENTER_VERTICAL标志。它会强制标签处于垂直方向的中央,这样看起来相对于文件控件它是处于中央的。
在一些真正的项目中,我会让字体变大以达到相似的效果。
现在我们把wx.BoxSizer添加到我的wx>GridSizer中:
gridSizer.Add(inputOneSizer, 0, wx.ALIGN_RIGHT)
这里我设置了wx.ALIGN_RIGHT,使得所有的控件都对准了一道无形的靠近文本控件的墙。当我添加文本控件时,我设置了wx.EXPAND标志,为了使它在窗口变化的时候也跟着变化。
最后,我把wx.GridSizer添加到了我最高层的Sizer中,是一个垂直向的wx.BoxSizer:
topSizer.Add(gridSizer, 0, wx.ALL|wx.EXPAND, 5)
你应该也注意到了,在这里我也设置了wx.EXPAND标志。如果我不这样做,最高层的Sizer会一直保持着它所包含的大小。你可以自己设置那些标志尝试一下。
以下是完整的代码:
import wx
 
class MyForm(wx.Frame):
 
    def __init__(self):
        wx.Frame.__init__(self, None, wx.ID_ANY, title=‘My Form’)
 
        # Add a panel so it looks correct on all platforms
        self.panel = wx.Panel(self, wx.ID_ANY)
 
        bmp = wx.ArtProvider.GetBitmap(wx.ART_INFORMATION, wx.ART_OTHER, (16, 16))
        titleIco = wx.StaticBitmap(self.panel, wx.ID_ANY, bmp)
        title = wx.StaticText(self.panel, wx.ID_ANY, ‘My Title’)
 
        lblSize = (50, -1)
 
        bmp = wx.ArtProvider.GetBitmap(wx.ART_TIP, wx.ART_OTHER, (16, 16))
        inputOneIco = wx.StaticBitmap(self.panel, wx.ID_ANY, bmp)
        labelOne = wx.StaticText(self.panel, wx.ID_ANY, ‘Name’)
        inputTxtOne = wx.TextCtrl(self.panel, wx.ID_ANY,”)
 
        inputTwoIco = wx.StaticBitmap(self.panel, wx.ID_ANY, bmp)
        labelTwo = wx.StaticText(self.panel, wx.ID_ANY, ‘Address’)
        inputTxtTwo = wx.TextCtrl(self.panel, wx.ID_ANY,”)
 
        inputThreeIco = wx.StaticBitmap(self.panel, wx.ID_ANY, bmp)
        labelThree = wx.StaticText(self.panel, wx.ID_ANY, ‘Email’)
        inputTxtThree = wx.TextCtrl(self.panel, wx.ID_ANY, ”)
 
        inputFourIco = wx.StaticBitmap(self.panel, wx.ID_ANY, bmp)
        labelFour = wx.StaticText(self.panel, wx.ID_ANY, ‘Phone’)
        inputTxtFour = wx.TextCtrl(self.panel, wx.ID_ANY, ”)
 
        okBtn = wx.Button(self.panel, wx.ID_ANY, ‘OK’)
        cancelBtn = wx.Button(self.panel, wx.ID_ANY, ‘Cancel’)
        self.Bind(wx.EVT_BUTTON, self.onOK, okBtn)
        self.Bind(wx.EVT_BUTTON, self.onCancel, cancelBtn)
 
        topSizer        = wx.BoxSizer(wx.VERTICAL)
        titleSizer      = wx.BoxSizer(wx.HORIZONTAL)
        gridSizer       = wx.GridSizer(rows=4, cols=2, hgap=5, vgap=5)
        inputOneSizer   = wx.BoxSizer(wx.HORIZONTAL)
        inputTwoSizer   = wx.BoxSizer(wx.HORIZONTAL)
        inputThreeSizer = wx.BoxSizer(wx.HORIZONTAL)
        inputFourSizer  = wx.BoxSizer(wx.HORIZONTAL)
        btnSizer        = wx.BoxSizer(wx.HORIZONTAL)
 
        titleSizer.Add(titleIco, 0, wx.ALL, 5)
        titleSizer.Add(title, 0, wx.ALL, 5)
 
        # each input sizer will contain 3 items
        # A spacer (proportion=1),
        # A bitmap (proportion=0),
        # and a label (proportion=0)
        inputOneSizer.Add((20,-1), proportion=1)  # this is a spacer
        inputOneSizer.Add(inputOneIco, 0, wx.ALL, 5)
        inputOneSizer.Add(labelOne, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
 
        inputTwoSizer.Add((20,20), 1, wx.EXPAND) # this is a spacer
        inputTwoSizer.Add(inputTwoIco, 0, wx.ALL, 5)
        inputTwoSizer.Add(labelTwo, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
 
        inputThreeSizer.Add((20,20), 1, wx.EXPAND) # this is a spacer
        inputThreeSizer.Add(inputThreeIco, 0, wx.ALL, 5)
        inputThreeSizer.Add(labelThree, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
 
        inputFourSizer.Add((20,20), 1, wx.EXPAND) # this is a spacer
        inputFourSizer.Add(inputFourIco, 0, wx.ALL, 5)
        inputFourSizer.Add(labelFour, 0, wx.ALL|wx.ALIGN_CENTER_VERTICAL, 5)
 
        # Add the 3-item sizer to the gridsizer and
        # Right align the labels and icons
        gridSizer.Add(inputOneSizer, 0, wx.ALIGN_RIGHT)
        # Set the TextCtrl to expand on resize
        gridSizer.Add(inputTxtOne, 0, wx.EXPAND)
        gridSizer.Add(inputTwoSizer, 0, wx.ALIGN_RIGHT)
        gridSizer.Add(inputTxtTwo, 0, wx.EXPAND)
        gridSizer.Add(inputThreeSizer, 0, wx.ALIGN_RIGHT)
        gridSizer.Add(inputTxtThree, 0, wx.EXPAND)
        gridSizer.Add(inputFourSizer, 0, wx.ALIGN_RIGHT)
        gridSizer.Add(inputTxtFour, 0, wx.EXPAND)
 
        btnSizer.Add(okBtn, 0, wx.ALL, 5)
        btnSizer.Add(cancelBtn, 0, wx.ALL, 5)
 
        topSizer.Add(titleSizer, 0, wx.CENTER)
        topSizer.Add(wx.StaticLine(self.panel), 0, wx.ALL|wx.EXPAND, 5)
        topSizer.Add(gridSizer, 0, wx.ALL|wx.EXPAND, 5)
        topSizer.Add(wx.StaticLine(self.panel), 0, wx.ALL|wx.EXPAND, 5)
        topSizer.Add(btnSizer, 0, wx.ALL|wx.CENTER, 5)
 
        # SetSizeHints(minW, minH, maxW, maxH)
        self.SetSizeHints(250,300,500,400)
 
        self.panel.SetSizer(topSizer)
        topSizer.Fit(self)
 
 
    def onOK(self, event):
        # Do something
        print ‘onOK handler’
 
    def onCancel(self, event):
        self.closeProgram()
 
    def closeProgram(self):
        self.Close()
 
 
# Run the program
if __name__ == ‘__main__’:
    app = wx.PySimpleApp()
    frame = MyForm().Show()
    app.MainLoop()





BoxSizerFromTheGroundUp:
所有的关联wiki都在这里:
BoxSizerFromTheGroundUp
BoxSizerFromTheGroundUp/ControlsPadding
BoxSizerFromTheGroundUp/ControlsResizing
BoxSizerFromTheGroundUp/NestedBoxSizers
BoxSizerFromTheGroundUp/NestedControlGroups
BoxSizerFromTheGroundUp/DivideAndConquer


本页的内容包括:
1.术语
2.wx.BoxSizer
a.为什么是另一个Sizer教程
b.什么是Sizers?什么是BoxSizer?
c.flag=参数
d.短轴定位标志


术语
术语”control“等同于”widget“,也可以称为”wxWidgets“。Control/Widgets是可显示的二维wxPython图形对象。只有很少的wxPython对象是不可见的:wx.DC位图操作工具和wx.Sizer工具。在这里,一般的术语“窗口”从来没有使用过,以避免与wx.Window控件概念混淆。


wx.BoxSizer
为什么是另一个Sizer教程
有太多太多的BoxSizer教程和示例应用,但是没有一个拥有完整的文档,完整的可以详述所有参数,还有其他方面。sizer的使用在API设计方面是让人痛苦的,它要求逻辑上有不同的flag=常量,但这看起来并没有什么效果。BoxSizer似乎总是正确地执行,并且没有任何已知的错误。
什么是Sizers?什么是BoxSizer?
Sizers是wx控制自动定位算法的。它们是工具,不是控件/部件。它们的学术术语”几何管理“工具,可以根据规则去自动去调整控件的大小和位置。
BoxSizer是最基础的Sizer,大概也是被使用最多的。第一次使用并不是特别的困难,所有flag常量的意思都是很容易理解的。使用这个sizer可能是复杂的,然而它更容易让我们去掌握更高级的sizer的原理。
理解这个BoxSizer会是一个比较长的如何去学习其他sizer的学习之路。
BoxSizer可以被命名的更好一点,比如”StackSizer“。BoxSizer按照顺序去排列控件,选择水平或垂直方向,从上往下或从左向右的进行排列。
使用BoxSizer的时候,第一个需要决定的就是方向,是wx.VERTICAL还是wx.HORIZONTAL。只能去指定一个方向去进行控件的排列。实际一个BoxSizer如下:
bxSzrName = wx.BoxSizer( wx.VERTICAL )        # There are no other arguments. Sizers can't have parents because they are NOT controls.
方括号[]在下面的伪代码片段中代表着可选参数。大括号{}代表着和参数有关的值。虽然最后的三个参数是可选的,很有可能最少有一个或多少是需要的,为了去产生一个可见的外观。不管任何类型的控件都可以使用sizer去定位。Add()函数为了让它们的位置被自动控制。基本的Add()语法是:
bxSzrName.Add( { control, sizer spacer or another sizer },
                          [ proportion=] { positive integer },
                          [ flag=] { a logical "OR" phrase of border padding and minor axis positioning flags },
                          [ border=] { a positive integer specifying border width in pixels } )
第一步:Designing the Parent Container Widget Before Any Coding Begins
一个控件容器可是以不同类型的控件,如wx.Frame,wx.Window,wx.Panel,wx.Dialog,记事本等,它们可以持有(包含和显示)其他的控件。有不同类型的sizer可以去定位管理它们的子控件。事实上,如果在一个控件容器中使用了一个sizer,那么在这个容器中所有的子控件都应该被这个sizer所管理。所有的子控件没有通过sizer或绝对定位进行定位,可能最后会被堆放在其父窗口的左上角区域。
第一个实验就是去摆放一个框架,它由一个StaticText和一个TextCtrl组成。对于这个应用来说,最重要的就是位置要求,我的观点是:
StaticText用作标题,放在TextCtrl上方的正中间
两个控件都相对于父容器进行水平居中
两个控件都有相同值的四边空白
那么代码应该去做:
1.创建两个控件(意味着去实例化可见的wxPython对象)
2.然后创建一个BoxSizer
3.使用sizer对控件的位置进行管理
然后代码如下:
# The caption wx.StaticText is placed directly above a wx.TextCtrl.
        # Note that no "pos=" positioning parameter is needed because the BoxSizer
        # will determine its positioning.
        # If a position were to be specified it would be ignored and overridden by the sizer.
        #
        caption_stTxt = wx.StaticText( self, -1, 'My TextCtrl Caption' )
        self.listing_txtCtrl = wx.TextCtrl( self, -1, style=wx.TE_MULTILINE, size=(200, 150) )


        allCtrls_vertSizer = wx.BoxSizer( wx.VERTICAL )


        allCtrls_vertSizer.Add( caption_stTxt,       proportion=0 )
        allCtrls_vertSizer.Add( self.listing_txtCtrl, proportion=0 )


        self.SetSizer( allCtrls_vertSizer )   # "self" must be a control with a client area
        self.Layout()                                      # Tell this control to tell its associated sizer to arrange all the visible controls.
p.s.因为sizer不是一个控件,它必须与一个控件绑定在一起,这个控件的类型必须能够在它的内容区域内可以持有显示其他控件,如框架,面板,窗口,SplitterWindow等。在上面的代码段中使用的是这种情况:
self.SetSizer( allCtrls_vertSizer )
self是诸如框架,面板,窗口,SplitterWindow等中的一个
例子中sizer已经正确的在父容器中按照垂直方向从上往下,贴着左边摆放控件。下一步最重要的就是将两个控件安排在父工作区的水平居中。这样去做的话,flag=参数会被用到。
wx.Frame是控件中少有的拥有decorations的。decorations代表性地拥有标题和位于控件顶部的按钮。控件的边界由独立的控件组成,可以提供用户的调整大小事件处理。标题栏下面边界内的区域被称为工作区。这里可以摆放子控件。在大多数的基础控件中,工作区是由控件的区域组成。
在父控件中摆放子控件,使用(0,0)为开始进行摆放。框架(和对话框)使用绝对的屏幕坐标进行摆放。相对坐标的起点是控件工作区的左上角。所以总共两个坐标系统:屏幕坐标和工作区坐标。


flag= 参数
这个参数提供了对于BoxSizer来说,相对于另一个控件和工作区如何摆放一个控件的额外说明。预先定义的常量被用来作为值,三组中的每一个都会影响控件的位置和大小。
p.s.事实上,三组几乎独立的flag=常量必须使用逻辑“或”在一起,这对于新手来说是一个很大的障碍。公认的Python化方法是,使用独立的参数进行函数调用或类实际化,以便于去描述他们各自的目的。
但是,flag参数可以分配三种大小和定位常量组中所有的值。因此,flag参数不提供任何关于它被使用的特定目的的信息。


短轴定位标志
如果一个BoxSizer声明了wx.VERTICAL,例如,使用wx.ALIGN_LEFT或wx.ALIGN_RIGHT中的一个,然后沿着sizer短轴的边界的方向定位控件。wx.ALIGN_CENTER会将控件沿着短轴居中,不管短轴的方向如何。长轴会被默认忽略掉。
wx.ALIGN_LEFT # 为了起作用,sizer必须声明wx.VERTICAL
wx.ALIGN_RIGHT # 只适用于声明了wx.VERTICAL的sizer
wx.ALIGN_TOP # 只适用于声明了wx.HORIZONTAL的sizer
wx.ALIGN_BOTTOM # 只适用于声明了wx.HORIZONTAL的sizer
wx.ALIGN_CENTER = wx.ALIGN_CENTRE # 不论短轴进行居中处理
wx.CENTER_VERTICAL # 只适用于声明了wx.HORIZONTAL的sizer. 它比使用wx.ALIGN_CENTER/RE或wx.CENTER/RE还简单.
wx.CENTER_HORIZONTAL # 只适用于声明了wx.VERTICAL的sizer. 它比使用wx.ALIGN_CENTER/RE或wx.CENTER/RE来简单.
wx.EXPAND # 使用proportion= 参数会在下面的教程中介绍
下面的两条.Add()语句,可以很简单的去沿着短轴居中控件:
allCtrls_vertSizer.Add( cap_stTxt,flag=wx.ALIGN_CENTER )    # May substitute '''wx.ALIGN_CENTRE'''
    allCtrls_vertSizer.Add( self.myListing_txtCtrl, flag=wx.ALIGN_CENTER )
完整版本的示例程序:SIMPLE_SINGLE_SIZER_2_A.PY
剩下要做的事,就是在控件和工作区顶部之间插入一些空间。有两种方法可以紧挨着控件放空间,为了可以将它和任何紧邻的控件分开:
A)在.Add()语句中使用flag=一个常量值,例如wx.Top,也可以提供一个相关联的border=参数,使用一个整型的像素空间值。
在StaticText的.Add()之前或之后直接使用BoxSizer三种中的一种
Style B 更方便使用和阅读。Style A会在之后讲到。
Style B 有三个不同的类型:
1)sizerName.AddSpacer(int)
会添加一个大小为(int,int)的矩形空间
2)sizerName.Add((w,h))
会添加一个大小为(w,h)的矩形空间。当其中一个值为0时,sizer会添加一个沿着轴线的空间,因此为创建一个一维空间。
3)sizerName.AddStretchSpacer(prop=int)
会添加一个一维自适应的可伸缩的空间。这个空间有一个可伸缩的属性去限制工作区的大小,并不是由固定大小的控件和空间声明的。如果多种AddStretchSpacer是parent,sizer会根据prop=参数的值去分割可使用区域。注意.Add()有一个参数叫proportion,不是prop。


AddStretchSpacer示例:
假设创建了一个垂直方向的BoxSizer,并且垂直方向的工作区(Y轴长度)大小为100像素。这里有一个控件,在之前和之后都使用了.AddStretchSpacer()的独立控件。
self.SetClientSize( (123, 100) )
        ...
        self.listing_txtCtrl = wx.TextCtrl( self, size=(83, 70), style=wx.TE_MULTILINE )  # The X axis dimension, 83, is not important.
        allCtrls_vertSizer = wx.BoxSizer( wx.VERTICAL )
        allCtrls_vertSizer.AddStretchSpacer( prop=3 )
        allCtrls_vertSizer.Add( self.listing_txtCtrl, flag=wx.CENTRE )
        allCtrls_vertSizer.AddStretchSpacer( prop=7 )
        self.SetSizer( allCtrls_vertSizer )   # Indicate that the container control is to use this sizer.
        self.Layout()  # Invoke the sizer on every wx.EVT_SIZE event. This event first happens on a Frame's .Show()
这个TextCtrl的高度为70像素。还有在垂直方向上剩余的30像素被sizer分配给了两个StretchSpacer。因为prop=参数值分别是3和7,这30像素会按照3:7的比例分别分配给第一个和第二个StretchSpacer。
顶部的StretchSpacer大小=(3/(3+7))*30像素=9像素
底部的StretchSpacer大小=(7/(3+7))*30像素=21像素
proportion参数在这个例子中,只是用来解释一个BoxSizer是如何计算每个StretchSpacer的大小。StretchSpacer经常被用来使得一个控件或一组控件的两端有相同的间隔,所以容器的边界和控件的两端的间隔是相等的(把两个StretchSpacer都设置prop=1)。这是这个App需要去做的,满足在本节开头列出的三个定位要求。
allCtrls_vertSizer = wx.BoxSizer( wx.VERTICAL )
        allCtrls_vertSizer.AddStretchSpacer( prop=1 )  # for major axis (vertical) centering
        allCtrls_vertSizer.Add( caption_stTxt,       flag=wx.ALIGN_CENTRE )  # for minor axis (horizontally for allCtrls_vertSizer) centering
        allCtrls_vertSizer.Add( self.listing_txtCtrl, flag=wx.ALIGN_CENTER )
        allCtrls_vertSizer.AddStretchSpacer( prop=1 )  # for major axis (vertical) centering of the 2 controls
        self.SetSizer( allCtrls_vertSizer )
        self.Layout()   # Invoke the sizer on every wx.EVT_SIZE event. This event happens on .Show()
这是一个更聪明的功能,当用户或程序将容器调整大小时,所有的内部控件都可以自动调整大小。在下面显示的框架中,我作为用户手动的调整了框架的大小。通过两个StretchSpacer将控件进行了垂直(sizer主轴)居中。通过两个flag=参数进行了水平(sizer副轴)居中。
我们讲解了BoxSizer对齐flag参数和三种spacer中的两个。在下一个部分中,我们会探索实现单个控件四周的边界间隔,而不是在一对控件中插入spacer。






用于填充控件边框间隔的flag
我们已经看过对齐flag,现在我们看看边框间隔flag。这些flag总是和对齐flag没有任何关系,但是它们总是用逻辑“或”使得flag=参数总是和对齐flag在一起。这些flag总是被用来指定控件的边,间距值大小为border=参数的值的边。这些flag中的任何组合都被会使用在flag=参数中,但是他们总是和border=的间距值联系在一起。
边框间距Flag包括:
wx.TOP
wx.BOTTOM
wx.LEFT
wx.RIGHT
wx.ALL
wx.ALL flag是一个很便利的定义,指定控件的四边都有边框。
这里是示例程序的当前状态:
我想要去放一个小的间隔,在StaticText和TextCtrl之间。我们已经看过了如何去使用.AddSpacer()函数放置一个正方形空间,使用.Add()函数放置一个矩形空间。这里我们使用另一种方法,使用flag=和border=参数。我们可以选择放在TextCtrl的顶部或StaticText的底部,甚至可以两者都放。我希望你现在可以看到,为什么在控件之间添加一个空间是更简单的。至现在为止,TextCtrl的顶部会被填充。那样需要去做的就是,去修改TextCtrl的.Add()语句,写入7像素的边框填充。
之前:
allCtrls_vertSizer.Add( self.myListing_txtCtrl, flag=wx.ALIGN_CENTER )
之后:
allCtrls_vertSizer.Add( self.myListing_txtCtrl, flag=wx.ALIGN_CENTER | wx.TOP, border=7 )
注意,wx.ALIGN_CENTER的效果与wx.TOP的效果完全没有关系,除了它们都适用于相同的控制。我们现在可以看到的是:
现在的外观有点好看,而且很容易去做。但是,它更直接简单的就是去插入这一行:
allCtrls_vertSizer.Add( (0, 7) )            # A one-dimensional vertical spacer. The best option, overall.
或者:
allCtrls_vertSizer.AddSpacer( 7 )       # A square spacer. It's minor axis dimension wont't interfere in this case.
当提到spacer时,“达到目的的方法不止一种”。然而,别人试图去指出你的代码使用了wx.TOP参数已经努力实现了,wx.ALIGN_CENTER参数和wx.TOP参数没有任何关系,即使它们会被写入到同一个flag=参数中。
边框填充flag使得使用和修改变得困难,特别是当相信的两个控件都使用了它。使用分开的语句去插入一个spacer能够使得编写和理解你的代码变得更简单。做这种完全独立的空间效果并正确的适用它,它必须不能有任何的无意义边去影响任何的相邻控件。据此考虑,使用.Add((w,0))或.Add((0,h))spacer插入语句更好,而不是.AddSpacer(n)语句。一个正方形spacer副轴的尺寸无意中干扰了其他的相邻控件或sizer。使用一维spacer中的一个保证这种情况不会发生。但是,尺寸值必须放置在给定(x,y)坐标的适当位置。
使用这个简单的方法,可以完全不用去考虑BoxSizer的主轴和副轴:
def AddLinearSpacer( boxsizer, pixelSpacing ) :
    """ A one-dimensional spacer along only the major axis for any BoxSizer """


    orientation = boxsizer.GetOrientation()
    if   (orientation == wx.HORIZONTAL) :
        boxsizer.Add( (pixelSpacing, 0) )


    elif (orientation == wx.VERTICAL) :
        boxsizer.Add( (0, pixelSpacing) )
    #end if


#end def
这个算法是非常简单的,但让我困惑的是,为什么使用一个还没有创建的wx.BoxSizer作为一个参数。我猜这只是BoxSizer的“Design By Committee”的另一个示例。使用这个方法会更简单:
AddLinearSpacer( allCtrls_vertSizer, 7 )        # This method determines the sizer's orientation by itself.
上面就是我们要讲的控件间距。现在我们去看看BoxSizer怎样自动调整一个控件大小,当parent调整大小时。




调整控件大小
BoxSizer可以用来去扩展一个控件,“将这一项分配的空间填满”。看http://www.wxpython.org/docs/api/wx.Sizer-class.html。它很可能像人类一样的能说会道。正确的来说,分配给项的空间到底会有多少?
在WxWidget的文档中,并没有去写关于任何控件扩展后占满了工作区的所有区域,不包括固定大小控件和固定大小spacer的空间。如果有多个控件或spacer设置成了wx.EXPAND,那么没有被声明分配的空间会分配给他们。
wx.EXPAND和wx.GROW是同义词。
为了能够证明一个控件可以扩充满一个框架,那么就创建两个相邻的wx.Panel。为了区别,将两个Panel设置成为了不同的颜色。这两个Panel会被.Add()到一个水平方向的BoxSizer中。 
#!/usr/bin/python


# wxEXPAND_DEMO_A_1.PY


import wx


#------------------------------------------------------------------------------


class AppFrame( wx.Frame ) :


    def __init__( self ) :


        #-----  Configure the Frame.


        wx.Frame.__init__( self, parent=None, title='wxEXPAND_DEMO_A_1' )
        self.Position = (200, 0)
        self.ClientSize = (300, 200)
        self.BackgoundColour = 'white'


        # A panel is needed for tab-traversal and platform background color consistency.
        # The first control instantiated in a Frame automatically expands
        #   to the size Frame.ClientSize.  This is unique to Frames.
        frm_pnl = wx.Panel( self )
        frm_pnl.BackgroundColour = (255, 255, 230)  # Contrast with panels below.


        #-----  Create the panel's controls


        left_pnl  = wx.Panel( frm_pnl )
        left_pnl.BackgroundColour  = (200, 240, 200)      # light green


        right_pnl = wx.Panel( frm_pnl )
        right_pnl.BackgroundColour = (200, 230, 250)      # light blue


        #-----  Create the sizer and add the controls to it.


        frmPnl_horzSizer = wx.BoxSizer( wx.HORIZONTAL )
        frmPnl_horzSizer.Add( left_pnl  )
        frmPnl_horzSizer.Add( right_pnl )


        frm_pnl.SetSizer( frmPnl_horzSizer )
        frm_pnl.Layout()


    #end __init__ def


#end AppFrame class


#==============================================================================


myApp = wx.App( redirect=False )
AppFrame().Show()
myApp.MainLoop()
没有大小或位置参数,是因为这是sizer的工作。flag=wx.EXPAND参数被故意忽略掉后效果如下:
这绝对不是我们想要的。但是,两个Panel仅仅是可见的,而且右边的蓝色不是在左边绿色的上面,可能会出现一个或两个Panel没有被添加到sizer中。大多数的控件并没有最小的大小。很少部分的控件,例如wx.Button和wx.StaticText会有合适的自身大小,可以说。。。在MS Windows平台,一个控件例如wx.Panel没有明确定义大小时,会变成一个20像素的正方形。这对于调试目的来说,比变成0像素大小的不可见的正方形好多了。
现在可以在.Add()语句中设置wx.EXPAND(wx.GROW)参数了。注意wx.EXPAND只能影响到副轴方向,sizer是wx.HORIZONTAL。
我们成功了!好。。。但并不完美。Panel只是wx.EXPAND了sizer的副轴。但是,如何才能使得主轴也可以产生效果呢?proportion=参数之前我们已经见过了。因为Panel假设都是相同的大小,proportion=参数就需要设置成相同大小的正数值。但是应该选择多大的值呢?任何>=1的值都可以。
然而,为了促进总体编码清晰,应该使用值1,以便任何人,包括你自己,都能够在以后看代码的时候,可以快速的理解这个参数的值。
这样好多了!尝试去调整框架的水平大小,看看sizer是如何不断的维护着Panel的宽度比例为1:1的。
现在是把我们所学到的所有东西应用到上面的single-sizer/two-panel的时候了。边框和spacer会用来完成下面的外观:
你可以将下面的屏幕快照中添加的注释与实际的示例代码相匹配。
为了精确的显示BoxSizer如何分配水平空间的比例,上面的例子已经被修改去计算由工作区宽度和三个固定的spacer提供的两个Panel的宽度。这些计算结果遵循公式:
已经分配的空间=2*左边和右边的spacer-中间的spacer
可分配的空间=工作区宽度-已经分配的空间
左边控件的宽度=可分配的空间* (winLeft_horzProp / (winLeft_horzProp + winRight_horzProp))
右边控件的宽度=可分配的空间* (winRight_horzProp / (winLeft_horzProp + winRight_horzProp))
这里有一些使用示例的sizer和控件的测试计算输出。sizer的真实宽度设置了panel永远在测试程序计算宽度的1个像素内。这证明了sizer做了适当地分配比例大小。
更多复杂的布局
很多页面的布局会比这个更加的复杂。当需要有一个复杂的显示时,它们会变得非常非常的复杂。这会要求使用更多的sizer.








多样的BoxSizer:嵌套
在下面的布局中,让一个单独的BoxSizer包含四个控件是不可能的,因为它们形成了一个二维模式。BoxSizer只能使用一个轴。这个平面模板是常客,当一个StaticText和一个TextCtrl可被复写的时候。这是很容易去做的,通过实例化一个容器控件,例如一个wx.Panel,在一个TextCtrl上面定位一个StaticText。
在你头脑中在做思考的过程时,注释上面的示意图是非常有帮助的,确定所有必要的控件组和spacer。
你自己的手绘图并不需要像这个一样完美,但是我想要让你理解我想要怎么做。这个画可以分解成两个sizer。你能够去通过看图纸就可以理解如何去写出这个sizer代码。填充的矩形是一种或另一种的spacer,并且空余的空矩形代表BoxSizer——蓝色是wx.VERTIACL(认为“蓝色皮肤”:从上往下),绿色代表wx.HORIZONTAL(认为“绿色”:从左往右)
现在我们很明白的去详细编写控件嵌套和复写。第一个任务就是去创建一个StaticText凌驾于一个TextCtrl之上的Panel类。注意我们想要去重写这个Panel,它会设计成没有硬编码的文本。意思就是,StaticText的字符值会使用一个参数代替。
class TxtCtrlPanel( wx.Panel ) :


    def __init__( self, parent, caption_txt ) :


        wx.Panel.__init__( self, parent=parent, id=-1 )


        #-----


        self.caption_stTxt = wx.StaticText( self, -1, caption_txt )
        self.caption_stTxt.BackgroundColour = ( 'wHIte' )


        self.list_txtCtrl = wx.TextCtrl( self, -1, style=wx.TE_MULTILINE, size=(200, 150) )


        #-----


        panel_vertSizer = wx.BoxSizer( wx.VERTICAL )


        panel_vertSizer.Add( self.caption_stTxt, proportion=0, flag=wx.CENTER )


        als.AddLinearSpacer( panel_vertSizer, 2 )


        panel_vertSizer.Add( self.list_txtCtrl,  proportion=0, flag=wx.ALIGN_CENTER )


        self.SetSizer( panel_vertSizer )    # Invoke the sizer.
        self.Fit()        # Make "self" (the panel) shrink to the minimum size required by the controls.


    #end __init__


    def GetControls( self ) :


        return self.caption_stTxt, self.list_txtCtrl


#end TxtCtrlPanel class
两个控件都用.Add()带上了flag=wx.CENTER参数,确保两个控件都被sizer居中。更宽的控件不需要这个参数,但是两个控件中的哪一个将会更宽,一般不可能提前知道。
当文本插入到TextCtrl中时,在下面代码中Line#16检索了实例化的控件为了之后使用。甚至StaticText的字符都可以修改,如果需要的话。StaticText中的Static意味着这个控件不能被交互式使用,例如TextCtrl,Button或CheckBox。
class MainFrame( wx.Frame ) :
    """ A very basic single BoxSizer demo """


    def __init__( self, parent ) :


        wx.Frame.__init__ ( self, parent, -1, title='Simple Single Sizer Demo',
                                      size=(400, 300), style=wx.DEFAULT_FRAME_STYLE )
        self.Position = (100, 0)


        self.SetBackgroundColour( (215, 150, 250) )         # yellow
        sacrificial_frmCtrl = wx.Panel( self ).Hide()


        #-----


        txtCtl_panel_1 = TxtCtrlPanel( self, 'My TextCtrl Caption #1' )
        stTxt_1, txtCtl_1 = txtCtl_panel_1.GetControls()


        #-----


        allCtrls_vertSizer = wx.BoxSizer( wx.HORIZONTAL )


        self.SetSizer( allCtrls_vertSizer )
        self.Layout()                        # self.Fit()  # always use one or the other


    #end __init__


#end MainFrame class


#==========================================================


if __name__ == '__main__' :


    app = wx.PySimpleApp( redirect=False )
    appFrame = MainFrame( None ).Show()
    app.MainLoop()


#end if
现在这个示例可以去修改添加第二个TextCtrlPanel,这个类到目前为止,证明可以正常工作。去水平对齐两个Panel,需要一个水平方向的sizer添加到框架内并去持有它们。三个spacer也要被添加去相互分离Panel和页面的边界。另外,整体的页面需要通过一个完整的垂直方向的sizer处理。
第二个Panel的标题被更改,在Panel已经被创建带着一个已经初始的标题字符。在框架代码中,它通过重新获取StaticText对象进行的修改。也要注意,当左边标题很窄的同时,右边StaticText的宽度大于它的TextCtrl。这就说明了,为什么参数wx.CENTER或三个它的同义词中的一个需要出现在每一个.Add()语句中,是为了能让每一个控件都能够在sizer中被居中。
class MainFrame( wx.Frame ) :
    """ A 2-control class with a BoxSizer demo """


    def __init__( self ) :


        #-----  Configure the Frame.


        wx.Frame.__init__ ( self, None, title='DUAL_CONTROL_CLASS_2.PY',
                            size=(600, 300), style=wx.DEFAULT_FRAME_STYLE )
        self.Position = (100, 0)


        # A panel is needed for tab-traversal and platform background color capabilities.
        # The first control instantiated in a Frame automatically expands
        #   to the Frame's client size.  This is unique to Frames.
        frm_pnl = wx.Panel( self )
        frm_pnl.BackgroundColour = (250, 250, 150)         # yellow


        #-----  Create the controls


        # Create all the page's controls either individually or using classes.


        ctrlsPanel_1 = TxtCtrlPanel( frm_pnl, 'My TextCtrl Caption #1' )
        stTxt_1, txtCtl_1 = ctrlsPanel_1.GetControls()  # Retrieve the control objects.


        ctrlsPanel_2 = TxtCtrlPanel( frm_pnl, 'My TextCtrl Caption #2' )
        stTxt_2, txtCtl_2 = ctrlsPanel_2.GetControls()


        # Let's change the original caption "after the fact".
        stTxt_2.Label = 'Caption Redefined After Panel Class Instantiation'
        ctrlsPanel_2.LayoutAgain()


        #-----  Create the sizers and add the controls to it.


        panelCtrls_horzSizer = wx.BoxSizer( wx.HORIZONTAL )


        als.AddLinearSpacer( panelCtrls_horzSizer, 35 )
        panelCtrls_horzSizer.Add( ctrlsPanel_1 )
        als.AddLinearSpacer( panelCtrls_horzSizer, 15 )
        panelCtrls_horzSizer.Add( ctrlsPanel_2 )
        als.AddLinearSpacer( panelCtrls_horzSizer, 35 )


        frmPnl_vertSizer = wx.BoxSizer( wx.VERTICAL )


        als.AddLinearSpacer( frmPnl_vertSizer, 35 )
        frmPnl_vertSizer.Add( panelCtrls_horzSizer )


        als.AddLinearSpacer( frmPnl_vertSizer, 35 )


        #-----  Create the sizer and add the controls to it.


        # "There can be only one.", Duncan MacLeod from the clan MacLeod.
        # That is, a page can have exactly 1 or none top level sizer.
        # Sizer nesting can effectively have infinite levels.
        frm_pnl.SetSizer( frmPnl_vertSizer )
        frm_pnl.Fit()


    #end __init__


#end MainFrame class


#==============================================================================


if __name__ == '__main__' :


    app = wx.PySimpleApp( redirect=False )
    appFrame = MainFrame().Show()
    app.MainLoop()


#end if






 #-----


        lightbulb_image = wx.Image( 'LIGHTBULB.64x64.PNG', wx.BITMAP_TYPE_ANY)
        lightbulb_bmap = lightbulb_image.ConvertToBitmap()


        lightbulb_horzSizer = wx.BoxSizer( wx.HORIZONTAL )
        for idx in xrange( 8 ) :
            aLightbulb_stBmap = wx.StaticBitmap( self, -1, lightbulb_bmap )
            lightbulb_horzSizer.Add( aLightbulb_stBmap, flag=wx.CENTER )


        page_vertSizer.Add( lightbulb_horzSizer, flag=wx.ALIGN_CENTRE )   # note synonym


        #-----

为了欢乐,我将放出一些基于文件的图形图像。
创建更复杂的布局
当计划好的时候,在页面sizer中添加控件是非常简单的,特别是当控件类为来更多样的分组控件被应用时。我让为你现在可以明白摆放页面可以很快的变得复杂。下一个话题我们来关注一个技术去解决更复杂的情况。






这里的GUI代码是由包含了很多控件的Panel组成的。每个Panel都设置了唯一的颜色,以便于能够很容易的区分彼此。在每个Panel的四周都有边框间距,以便于能够和相邻的Panel分离开。在大部分真实的GUI中,Panel会有相应的背景色,并且不会用它们自己的类名标记。
每个Panel都会包含一个单个的控件,但不一定要有一个StaticText去用来作为标签,去详细的去说明被关联控件的用途。一些控件如RadioBox已经含有标签。按钮自然也有一个自己的标签,而且不需要去包含在一个Panel中。
当然只有BoxSizer被用来去排列所有事情。






分隔线和Conquer
具有多个控件的嵌套sizer所需的所有基础知识我们已经讲完了。让我们去学习更加复杂的。这里有一个来自于Creative Labs的面向MS Windows的音乐播放器。现在的任务就是使用wxPython去重新创建下面的GUI。忽略渐变,阴影,自定义图像等。
一旦GUI创建好了,传真机就会很简单的被添加进去。
首先,这次的项目看起来让人很气馁。这里有非常基本和有用的工程原理叫Divide and Conquer可以有效的运用。简单的说,它意味着是一个很大的任务,应该分解成更小的,更容易管理的子任务。实现和测试每一个子任务,确保它能够像你想的那样工作。然后把它们这些低等级的结构整合到一起成为更高一级的结构,并测试他们。最后把它们都结合到一起成为一个单独的可工作的解决方法。
听起来很简单,是吧?当你使用Dividing and Conquering时,你也可以以分层的形式很自然的组织项目。不仅仅是让项目更简单的完成,也是为了更加容易理解。
由于这一任务的结果是图形化,所以分析它的最佳工具也是图形化的,这类作品是由真实的铅笔和纸制成的。你可以使用图形软件去代替,例如MS Visio,Adobe Photoshop,HyperSnap-DX或其他相同的项目去创建图纸。下面的是真实控件简化而来的控件简略图:
这个更简单的图纸让控件面板更容易去分析,分解成集群的控件。这个图纸并不是100%的正确,但是它对于分析的目的是足够的了。下面是使用简单的视觉检查编译的所有控件的列表:
2 wx.StaticBitmap (logo图像)
22 wx.BitmapButton (提供了自定义,但是统一的按钮外观)
2 wx.Gauge (播放进度滑块;音量滑块)
1 wx.StaticText (标题)
3 wx.StaticText (正确地显示状态信息)
此外,通过简单的观察所有控件组可以选择由特定的sizer处理:
蓝色方块代表着垂直方向的BoxSizer,绿色的代表水平方向的。
  • 0
    点赞
  • 9
    收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
评论
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值