<<TableOfContents>>

= 欢迎使用wxPython =

下面是一个例子，它创建了一个有一个文本框的窗口用来显示鼠标的位置。
{{{#!python
#!/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()
}}}


图示如下：

{{attachment:w1.1.gif}}


漂亮的界面是一个`GUI`程序必不可少的一部分，{{{wxPython}}}可以做到这一点，加之{{{Python}}}强大的功能和简洁的语法，使用得它在{{{Python}}}的{{{gui}}}中成为一种主流。


== 开始wxPython ==


首先我们创建一个显示一个图像的文件。这将分三步：

 1. 首先创建一个空的最小的可以工作的{{{wxPthon}}}程序
 1. 组织和细化
 1. 显示{{{wxPython}}}的{{{logo}}}
图示如下：

{{attachment:w1.2.gif}}

== 创建最小的空的wxPython程序 ==

我们创建一个名为{{{bare.py}}}的程序并键入以下代码：
{{{#!python
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
}}}

上面的代码运行的结果如下：

{{attachment:w1.5.gif}}


上面的代码的任何一行都不能少，否则将不能工作。这个基本的{{{wxPython}}}程序说明了开发任一{{{wxPython}}}程序所必须的五个基本步骤：
 1. 导入必须的{{{wxPython}}}包
 1. 子类化{{{wxPython}}}应用程序类
 1. 定义一个应用程序的初始化方法
 1. 创建一个应用程序类的实例
 1. 进入这个应用程序的主事件循环

下面让我们看看这个最小的空的程序是如何一步一步实现的。


=== 导入wxPython ===

你需要做的第一件事就是导入这个主要的{{{wxPython}}}包，这个包名为{{{wx:}}}

{{{#!python
import wx
}}}

一旦这个包被导入，你就可以引用{{{wxPython}}}的类、函数和常量（它们以{{{wx}}}为前缀），如下所示：

{{{#!python
class App(wx.App):
}}}

注意：老的引入方式仍然被支持，你可能会遇到用这种老的引入方式的代码。因此我们将会简短地说明这种老的方式及为什么要改变它。老的包的名字是{{{wxPython}}}，它包含了一个内在的名为{{{wx}}}模块。那时，通常有两种导入必要的代码的方法，一种就是从{{{wxPython}}}包中导入{{{wx}}}模块：{{{from}}} {{{wxPython}}} {{{import}}} {{{wx}}}；另一种就是直接从{{{wx}}}模块中导入所有的东西：{{{from}}} {{{wxPython.wx}}} {{{import}}} *。这两种方法都有严重的缺点。这第二种方法{{{Python}}}中是不建议使用的，这因为可能导致名字空间冲突，而老的{{{wx}}}模块通过在其属性前加一个{{{wx}}}前缀避免了这个问题。尽管使用这个安全防范，但是{{{import}}}*仍然有可能导致问题，但是许多{{{wxPython}}}程序员喜欢这种类型，并且你将在老的代码中经常看到这种用法。这种风格的坏处是类名以小写字母开头，而大多数{{{wxPython}}}方法以大写字母开头，这和通常的{{{Python}}}编写程序的习惯相反。

然而如果你试图避免由于使用{{{import}}}*导致的名字空间膨胀，而使用{{{from}}} {{{wxPython}}} {{{import}}} {{{wx}}}。那么你就不得不为每个类、函数、常数名键入两次{{{wx}}}，一次是作为包的前缀，另一次是作为通常的前缀，例如{{{wx.wxWindow}}}。

对于导入顺序需要注意的是：你从{{{wxPython}}}导入其它东西之前必须先导入{{{wx}}}。通常情况下，{{{Python}}}中的模块导入顺序无关。但是{{{wxPython}}}中的不同，它是一个复杂的模块。当你第一次导入{{{wx}}}模块时，{{{wxPython}}}要对别的{{{wxPython}}}模块执行一些初始化工作。例如{{{wxPython}}}中的一些子包，如{{{xrc}}}模块，它在{{{wx}}}模块导入之前不能够正确的工作，我们必须按下面顺序导入：

{{{#!python
import wx
from wx import xrc
}}}

以上的导入顺序只针对{{{wxPython}}}的模块，{{{Python}}}的模块导入顺序没关系。例如：

{{{#!python
import sys
import wx
import os
from wx import xrc
import urllib
}}}


=== 使用应用程序和框架工作 ===


一旦你导入了{{{wx}}}模块，你就能够创建你的应用程序（{{{application}}}）对象和框架（{{{frame}}}）对象。每个{{{wxPython}}}程序必须有一个{{{application}}}对象和至少一个{{{frame}}}对象。{{{application}}}对象必须是{{{wx.App}}}的一个实例或你在{{{OnInit()}}}方法中定义的一个子类的一个实例。当你的应用程序启动的时候，{{{OnInit()}}}方法将被{{{wx.App}}}父类调用。


'''子类化{{{wxPython}}}'''
'''{{{application}}}类'''

下面的代码演示了如何定义我们的{{{wx.App}}}的子类：
{{{#!python
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()__}}}方法，示例如下：
{{{#!python
class App(wx.App):
    def __init__(self):

        wx.App.__init__(self)
}}}


如果你忘了这样做，{{{wxPython}}}将不被初始化并且你的{{{OnInit()}}}方法也将得不到调用。

'''创建一个应用程序实例并进入它的主事件循环'''

这步是创建{{{wx.App}}}子类的实例，并调用它的{{{MainLoop()}}}方法：

{{{#!python
app = App()
app.MainLoop()
}}}


一旦进入主事件循环，控制权将转交给{{{wxPython}}}。{{{wxPython}}} {{{GUI}}}程序主要响应用户的鼠标和键盘事件。当一个应用程序的所有框架被关闭后，这个{{{app.MainLoop()}}}方法将返回且程序退出。


== 扩展这个最小的空的wxPython程序 ==


现在我们将给空的最小程序增加适当数量的功能，它包含了通常{{{Python}}}编程的标准并能够作为你自己的程

序的一个基准。下面我们创建一个名为{{{spare.py}}}程序：
{{{#!python
#!/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}}}命令），我们可以在命令行下仅仅键入该程序的名字来运行这个程序：

{{{
% spare.py
}}}

这行在其它的操作系统上将被忽略。但是包含它可以实现代码的跨平台。


'''#2''' 这是文档字符串，当模块中的第一句是字符串的时候，这个字符串就成了该模块的文档字符串并存储

在该模块的{{{__doc__}}}属性中。你能够在你的代码中、某些开发平台、甚至交互模式下运行的{{{Python}}}解释器

中访问文档字符串：
{{{#!python
    import spare
    print spare.__doc__
}}}

{{{Spare.py}}} 简单 {{{wxPython}}} 程序的起点。

'''#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__}}}属性来实现：

{{{#!python
if __name__ == '__main__':
   app = App()
   app.MainLoop()
}}}


== 创建最终的hello.py程序 ==


代码如下：
{{{#!python
#!/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()

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}}}的事件循环。