[譯] 開始使用 wxPython [Getting started with wxPython]

 原文：http://wiki.wxpython.org/Getting%20Started

 

1. 第一個應用程序：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()

[批注：

　　1. 在期望運行該程序前，需要安裝 Python 和 wxPython，否則，我想它不能正常運行

　　2. 如果需要在代碼的添加中文，需要在代碼前面添加編碼格式，否則，我想它也不能正常運行。

         范例代碼如下：

　　

#coding=utf-8
#!/usr/bin/env python
import wx

# 這是一個簡單的 "Hello World" 應用程序
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)

　　# 該 app 是 wx.App 的一個實例，對於大多數簡單的應用程序就是一個 wx.App 對象，

　　# 在需要創建復雜的應用程序時需要使用繼承 wx.App 類，參數 “False”表示不將標准輸出和標准錯誤重定向到窗口。

+-------------------------------------------------------------------------------------------------------------------

 frame = wx.Frame(None, wx.ID_ANY, "Hello World")

　　# 一個 wx.Frame 是一個最頂層的窗口，語法是：wx.Frame(Parent, Id, Title)。

　　# 大多數的使用傳遞的參數是（一個父對象，一個ID號）。

　　# 在該例子中，“None” 代表沒有父對象，“wx.ID_ANY” 表示由 wxWidgets 自動為我們選擇一個 ID 號。

+-------------------------------------------------------------------------------------------------------------------

 frame.Show(True)

　　# 使用 Show 方法，使窗口生效並顯示(True)或隱藏(False)

+-------------------------------------------------------------------------------------------------------------------

 app.MainLoop()

　　# 最后，我們啟動應用程序的主循環來處理事件

+-------------------------------------------------------------------------------------------------------------------

注意：你大多數時候都希望使用 wx.ID_ANY 或者其他的標准 ID 值(參見:標准ID值)。你可以自己定義 ID 值，但是沒有必要。

執行程序，然后你將看到類似下面的一個窗口：

 

1.1. “是胡不是霍，是霍躲不過” [Windows 還是 Frames] ？

　　當大家討論界面 GUI 時，經常會說：窗口windows、菜單memus、圖標icons。自然而然，就會認為 wx.Window 表示

屏幕上的窗口。不幸的是，卻不是這么回事。一個 wx.Window 是一個基本的類對象，用戶衍生出可見的原始對象（如：按鈕、

菜單），而且一個程序的窗口是一個 wx.Frame 實例。對新手來說，這寫不一致可能導致一些困惑。

 

2. 創建一個簡單的文本編輯器

　　我們將在這部分教程中學習創建一個簡單的編輯器。在這個過程中，我們將研究幾個配件（widgets，如：按鈕，編輯框）

的使用，並且會學到它們的一些特性，比如：事件以及事件的回調處理(events and callbacks)。

 

 2.1 第一步

　　第一步，我們創建一個帶有編輯框的窗口。編輯框通過 wx.TextCtrl 創建。默認情況，創建的編輯框只能單行輸入，可以

使用 wx.TE_MULTLINE 來允許輸入多行。

#!/usr/bin/env python
import wx

class MyFrame(wx.Frame):
    """ We simply derive a new callss of Frame. """
    def __init__(self, parent, title):
        wx.Frame.__init__(self, parent, title = title)
        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()。

 

2.2 添加菜單欄

每一個應用程序都應該有一個菜單欄和狀態欄。來，我們一起來添加這些功能：

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()

[批注：

　　1. 想使用中文？Of course！

          兩個地方需要修改：

　　　　1. 代碼開始地方添加代碼的編碼格式注釋

　　　　2. 非注釋的中文表明傳遞的是 utf-8 編碼

　　　　示例代碼如下：

#coding=utf-8
#!/usr/bin/env python

import wx

class MainWindow(wx.Frame):
    def __init__(self, parent, title):
        wx.Frame.__init__(self, parent, title = title, size = (300, 400))
        self.control = wx.TextCtrl(self, style = wx.TE_MULTILINE)
        self.CreateStatusBar() # A Statusbar in the botton 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", u"關於簡易編輯器")
        filemenu.AppendSeparator()
        filemenu.Append(wx.ID_EXIT, "E&xist", u"退出應用程序")

        # 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()

　　2. 參數 "&About"，"E&xist"，符號 "&" 代表可以使用快捷鍵 "Alt + A" 和 "Alt + X" 的意思。

         同理 "&File" 代表可以使用快捷鍵 "Alt + F" 來激活 "File" 菜單欄

]

小建議：注意 wx.ID_ABOUT 和 wx.ID_EXIT 這個兩個 ID 值沒！？它們是 wxWidgets 提供的標准 ID 值。使用標准 ID 值

是一個好習慣。對於這些標准 ID 值， wxWidgets 能夠根據不同的平台展示出更好的效果。

 

2.3 添加事件處理

　　在 wxPython 編程中，對事件作出反應叫做事件處理。一個事件代表某種操作（如：點擊按鈕、輸入文本、移動鼠標）

發生在了你的應用程序上面。大多數界面程序都會有事件處理機制。你可以使用 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" 為真，我們就 do_something()，

否則，我們就不用處理該事件，而讓較外層的事件處理機制捕獲事件並處理。

[批注：

　　1. 此處描述的 "較外層的事件處理機制捕獲事件並處理" 類似 C++/Java 的異常處理機制一樣。

　　　例如：某一件事情發生了，需要你第一時間處理，而你使用了 wx.Skip()，就相當於你告知了你所知道的上一級的

部門你不處理該事情，然后該部門會處理這個事件，因為該部門使用了 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()

注意：對於代碼

        dlg = wx.MessageDialog( self, "A small text editor", "About Sample Editor", wx.OK)

　　我們可以省略最后的一個參數。那樣的話， wxWidget 會自動產生一個 ID 值。和使用參數 wx.ID_ANY 一樣的。

1 　　　　 dlg = wx.MessageDialog( self, "A small editor in wxPython", "About Sample Editor")

 

2.4. 對話框

　　當然，一個不能保存或打開文檔的編輯器是沒有太多用處的。所以引入通用對話框。這些對話框是由底層平台提供，

所以它們看起來會自然。讓我們來看看 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()

說明：

　　1. 我們使用文件對話框的構造函數來創建對話框

　　2. 我們調用 ShowModal，將會創建一個對話框，Modal 表示這個對話框不會做任何事情，直到“OK”或“Cancel”

　　    被點擊。

　　3. ShowModal 的返回值是被點擊的按鈕的 ID 值。如果用戶點擊了 "OK" ，我們就讀取文件。

　　現在你可以添加對應的菜單欄，並且和 OnOpen 方法綁定起來。如果你有什么問題，可以參考最后的程序的所有

代碼。

[批注：

　　1. 有的中文文檔打不開？有可能是文檔的編碼格式不是 python 默認采用的解碼格式。

　　　　可參考如下代碼：

#encoding=utf-8
#!/usr/bin/env python

import os
import wx

class MainWindow(wx.Frame):
    def __init__(self, parent, title):
        wx.Frame.__init__(self, parent, title = title, size = (400, 300))
        self.control = wx.TextCtrl(self, style = wx.TE_MULTILINE)
        self.CreateStatusBar()

        filemenu = wx.Menu()

        menuAbout = filemenu.Append(wx.ID_ABOUT, "&About", "Information about this programe.")
        menuExit = filemenu.Append(wx.ID_EXIT, "E&xit", "Terminate the programe.")
        menuOpenfile = filemenu.Append(wx.ID_OPEN, "&Open", "Open a file")

        menuBar = wx.MenuBar()
        menuBar.Append(filemenu, "&File")
        self.SetMenuBar(menuBar)

        self.Bind(wx.EVT_MENU, self.OnAbout, menuAbout)
        self.Bind(wx.EVT_MENU, self.OnExit, menuExit)
        self.Bind(wx.EVT_MENU, self.OnOpen, menuOpenfile)

        self.Show(True)

    def OnAbout(self, e):
        dlg = wx.MessageDialog(self, "A small text editor", "About Sample Editor", wx.OK)
        dlg.ShowModal()
        dlg.Destroy()

    def OnExit(self, e):
        self.Close()

    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().decode("utf-8"))     # 將讀到的數據轉碼
            f.close()
        dlg.Destroy()

app = wx.App(False)
frame = MainWindow(None, "Sample Editor")
app.MainLoop()

]

2.5. 擴展

　　當然，這個程序和正式的編輯器相比，還差太多。但是，添加其他的功能不會比我們剛學習的困難。也許你

可以從下面這些 wxPyton 的演示程序受到啟發：

　　* Drag and Drop ( 拖放 )

　　* MDI ( 多文檔界面 )

　　* Tab view/multiple files

　　* Find/Replase dialog

　　* Print dialog ( Printing )

　　* Macro-commands in python ( using the eval function )

[批注：

　　1. 更多演示程序可以從 wxPython 的官網下載 www.wxpython.org 

]

　　

3. 使用窗口

　　Topics：

　　　　* Frame

　　　　* Windows

　　　　* Controls/Widgets

　　　　* Sizers

　　　　* Validators

　　這個部分，我們將展示如何使用 wxPython 的窗口和內容，包括構建輸入表單和多種小工具。我們將創造

一個小的計算報價的應用程序。如果你有界面開發方面的經驗，這將會非常簡單，而且你可能想要使用界面構造

器 - Boa-Constructor 的高級功能。

 

3.1. 概述

　　3.1.1. 制作課件的元素

　　在窗口里，你將使用一系列的 wxWindow 的子類來布局窗口。下面是一些你可能用得上的小工具：

　　* wx.MenuBar: 它將在窗口的頂部創建一個菜單欄

　　* wx.StatusBar: 它將在窗口的低部顯示一些提示信息

　　* wx.ToolBar: 它將窗口上創建一個工具欄

　　* wx.Control 系列: 它是一系列用於接口工具（比如：顯示數據、處理輸入），經常使用的 wx.Control

　　   系列有：wx.Button、wx.StaticText、wx.TextCtrl、wx.ComboBox。

　　* wx.Panel: 它是一個用於包含多個 wx.Control 的容器，將 wx.Control 放入 wx.Panel 可以用來

　　　形成 TAB 頁。

　　所有的圖形化工具對象（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 的子類

這篇文字將會使用 wxSizer 這種方式，因為這是我最熟悉的一種結構。

 

 3.1.2 Sizer

　　Sizer 是 wx.Sizer 的一個子類，可以用來處理窗口里的各個工具，Sizer 可以：

　　* 對每個工具類計算一個合適的大小

　　* 每一個元素的放置都遵循統一的規則

　　* 當窗口大小變化時，自動調整工具的大小和位置

　　一些經常使用的布局工具(sizer)：

　　* wx.BoxSizer：水平或垂直布局

　　* wx.GridSizer：以網格的方式布局

　　* wx.FlexGridSizer：和 wx.GridSizer 類似，但更靈活

　　一個 sizer 是對一系列給定的 wx.Window 對象進行設置規格。可以調用 sizer.Add，或者sizer.AddMany。

Sizer 必須要有給定的對象。Sizers 可以嵌套。

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 有三個參數。第一個參數  control 將被添加到 sizer。第二個參數表示占用的比例因子。比如：

你希望使其成為 3:2:1 的比例關系，第二個參數你需要填寫該比例。0 表示不會隨着增長而變化。第三個參數通常

為 wx.GROW（等同於 wx.EXPAND），表示如果需要，將被重新設置大小，如果使用 wx.SHAPED，小工具的大

小將保持不變，第二個參數將表示各個小工具的間隔。

　　如果第二個參數為 0，control 對象不會被重置大小，對於第三個參數，wx.ALIGN_CENTER_HORIZONTAL，

wx.ALIGN_CENTER_VERTICAL，wx.ALIGN_CENTER (both) 分別表示水平居中，垂直居中，水平垂直居中。

可以使用這些值來替代 wx.GROW，wx.SHAPED。

　　你還可以選擇使用 wx.ALIGN_LEFT，wx.ALIGN_TOP，wx.ALIGN_RIGHT，wx.ALIGN_BOTTOM。默認

使用 wx.ALIGN_LEFT | wx.ALIGN_TOP。

　　你將這些控件添加到 sizer 里后，下一步就是告訴 frame 或 window 使能 sizer，使用如下方式使能：

window.SetSizer(sizer)
window.SetAutoLayout(True)
sizer.Fit(window)

　　SetSizer() 調用將告知 window(frame) 使用哪個 sizer，SetAutoLayout() 告知窗口如何放置控件和設置

控件大小，sizer.Fit() 告知 sizer 計算所有控件的位置和大小。如果你使用 sizer 這種方式設置控件位置和大小，

這是一種通用的處理過程。

 

3.1.3 菜單

　　我想你會能搞一個菜單出來的，如果你看了前面關於菜單欄的實現。

3.1.4 Validators 校驗器

　　當你創建一個對話框或者其他的輸入表格，你可以使用 wx.Validator 來進行簡單處理加載數據到你的表格

中，校驗輸入的數據，從表單中導出數據。wx.Validator 也可以用來處理按鍵事件和其他一些輸入框的事件。

要使用校驗器，你必須自己創建 wx.Validator 的子類（wxPython 沒有實現類似如 wx.TextValidator、

wx.GenericValidator 的類），子類通過輸入框對象 myInputField.SetValidator(myValidator) 的方式將事

件和輸入框關聯起來。

　　注意：你的 wx.Validator 子類必須實現 wxValidator.Clone() 方法

 

3.2 一個例子

3.2.1 嘗試在面板 panel 中使用標簽 label

　　　來，我們以一個例子開始。我們的程序將會有一個 Frame 窗口，Frame 里面有一個 Panel 面板， Panel 里面

再包含一個 Label 標簽。

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()

　　這個設計應該是非常的清晰，如果你看了 “簡易編輯器” 的實現，你應該不會有任何問題。注意，使用 sizer 比使用

pos 更合適，對於控件來說。

        self.quote = wx.StaticText(panel, label="Your quote: ", pos = (20, 30))

　　使用 Panel 作為我們的 wx.StaticText(parent, ...) 的 parent 參數。這樣，我們的 StaticText 將顯示在我們創建

的 Panel 面板上。wx.Point 用來作為 pos 參數，wx.Size 也是一個可選的參數值，但用在這里有些不合適。

　　

3.2.2 添加更多的控件

　　在 wxPython 的演示程序和幫助文檔里，你會發現一些列的控件，我們將展示經常使用的控件：

　　· wxButton 可點擊的按鈕

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)

　　例如：點擊清除按鈕時，將文本清空，將觸發 EVT_TEXT。

　　· wxComboBox 下拉列表框，事件 EVT_COMBOBOX

　　· wxCheckBox 　校驗框，有 True/False 連個選擇

　　· wxRadioBox　  單選框

　　來，讓我們來看看我們現在的程序是怎樣的了：

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 = (500, 20), size= (250, 350), style = wx.TE_MULTILINE | wx.TE_READONLY)

        # A button
        self.button = wx.Button(self, label = "Save", pos = (200, 350))
        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 = (200, 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', 'adverising', '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 = (200, 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.GetInt())

    def EvtText(self, event):
        self.logger.AppendText('EvtText: %s\n' % event.GetString())

    def EvtChar(self, event):
        self.logger.AppendText('EvtChar: %d\n' % event.GetKeyCode())

    def EvtCheckBox(self, event):
        self.logger.AppendText('EvtCheckBox: %d\n' % event.Checked())

app = wx.App(False)
frame = wx.Frame(None, size = (800, 600))
panel = ExamplePanel(frame)
frame.Show()
app.MainLoop()

將看到類似這樣的窗口：

 　　我們的類變得越來越充實了，里面有很多的控件和控件事件的處理。我們添加了一個 wxTextCtrl 編輯框控件用來顯示

控件接收到的事件。

 

3.2.3 標簽頁 notebook

　　wxNoteBook ，TAB 頁

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()

 [批注：該程序添加到上一個程序中的]

 

3.2.4. 改善布局 - 使用 sizers

　　使用絕對的位置值經常不能達到滿意的效果：如果窗口不是合適的大小，那就非常的丑陋。wxPython 有很豐富的

資料可以用來進行布局。

　　· wx.BoxSizer  是最常用，也是最簡單易用的布局神器，但是它會出現很多種布局組織的可能性。它的主要功能是

大致的將控件組成列或行的方式，也會自動重組（比如窗口大小改變的時候）。

　　· wx.GridSizer  wx.FlexGridSizer 也是兩個重要的布局神器，采用表格式的布局。

　　來看看例子：

import wx

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
        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
        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 link ?", 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)


    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.GetInt())

    def EvtText(self, event):
        self.logger.AppendText('EvtText: %s\n' % event.GetString())

    def EvtChar(self, event):
        self.logger.AppendText('EvtChar: %d\n' % event.GetKeyCode())

    def EvtCheckBox(self, event):
        self.logger.AppendText('EvtCheckBox: %d\n' % event.Checked())


app = wx.App(False)
frame = wx.Frame(None, title = "Layout EX")
panel = ExamplePanel(frame)
frame.Show()
app.MainLoop()

　　這個例子使用一個 GridBagSizer 來放置控件。參數 'pos' 控制如何布局控件，(x, y) 表示位置。例如：(0, 0)表示

左上角位置，(3, 5) 表示第三行，第五列。參數 'span' 運行控件跨越多行

 

 4. 響應用戶動作

　　我想你現在已經知道如何搞定用戶動作的事件響應，如果你看了前面的事件處理章節的內容。

　　參考： Events, Pop-up Menus

 

5. 畫圖

　　· Device Contexts

　　· Fonts

　　· Colours

　　· onPaint() methos

5.1 概述

　　在這部分，我們將介紹在窗口里面畫畫。我們也將會展示如何創建右鍵彈出式菜單(pop-up menus)。

5.2 例子

　　[官方暫未寫該部分的內容]

6. 使用 wxPython 

6.1 調試技術

　　當一個 python 程序遇到一個未處理的異常（ BUG），它會異常退出，並且會有 traceback 調用關系用來定位問

題出現的地方。wxPython 也有這樣的機制，但是有一點讓人苦惱。taceback 信息被定向標准 IO，好的 GUI 應用程

序都會是獨立的。下面有幾種方法，設置標准 IO：

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 來調試大多數的布局事件。

6.2 PyCrust 交互式終端

　　wxPython 發布了一個 PyCrust 交互式終端。你可以使用它來進行交互式測試你的布局程序。

7. 下一步

7.1 Events

　　事件處理機制是 wxPython 的一個重要特性。所有的 GUI 系統都是依賴於事件處理機制的。有兩種處理機制：

　　· 定義一個方法來處理事件，將一個控件的事件和方法綁定起來，當事件觸發是，回調方法，實現事件的處理

　　· 使用一個預先設定的方法來處理事件。這樣的話，如果你想修改某一個控件的事件處理，需要重寫該方法

　　所以， 'self.Bind(wx.EVT_SOMETHING, ACallable)' 表示：

　　當 SOMETHING 事件告知了窗口 Window(self)，該事件可能來自窗口的任意一個子窗口或自己，然后調用 

ACallable， self 必須是一個 wxPython 窗口的的類對象（Button、Dialog、Frame）。

　　另一個 'self.Bind(wx.EVT_SOMETHING, ACallable, srcWin)' 表示：

　　當 SOMETHING 事件由 'srcWin' 產生時，通過窗口的層級關系遞送到了本窗口 Window(self)，然后調用

ACallable。

　　但是有些事件不會被本窗口捕獲（代表着第二種方式將不起作用），所以最好使用第一種方式。這是一種基本的方式

除了菜單欄，因為他們沒有 Bind 方法。

 

7.2 Scintilla

　　Scintilla 是一個基本的組件被 wxStyledTextCtrl， 提供給我們語法高亮的功能。

　　參見： StyledTextCtrl。

7.3 Boa-constructor

　　Boa-constructor 是 wxPython 的一個 RAD IDE。

7.4 多線程

　　[官方很懶啊，什么也沒留下]

7.5 管理、非管理窗口

　　[官方很懶啊，什么也沒留下]

8 非常有用的鏈接[可供參考的資料]

　　· http://wxPython.org/

　　　　wxPython 官方網站了，官方提供的資源都在這了。

　　· http://wxwidgets.org/

　　　　wxWidgets 網站，要使用 wxPython 的控件，這里也有。這個的描述文檔在 wxPython 里也有。

　　· http://wxpython.org/maillist.php

　　　　這個可厲害了，和大神們交流啊，去吧！不過，如果是請教問題的話，最好先整理好問題。

　　· http://www.python.org/

　　　　python 社區

　　· http://starship.python.net/crew/theller/py2exe/

　　　　python 腳本(包括wxPython)  轉換成 Windows 系統的 exe 程序。

9. 這個...

　　你已經了解了 wxPython 的主要功能特性，而且能夠寫出 wxPython 的應用程序了。不要猶豫，加入 wxPython

社區吧，訂閱郵件列表，來一起討論。

10. 感覺貢獻者

　　· wxPhthon 社區

　　· and 很多人 ...

11. 附錄

11.1 小小編輯器

　　參見：WxHowtoSmallEditor

import wx
import os.path


class MainWindow(wx.Frame):
    def __init__(self, filename='noname.txt'):
        super(MainWindow, self).__init__(None, size=(400,200))
        self.filename = filename
        self.dirname = '.'
        self.CreateInteriorWindowComponents()
        self.CreateExteriorWindowComponents()

    def CreateInteriorWindowComponents(self):
        ''' Create "interior" window components. In this case it is just a
            simple multiline text control. '''
        self.control = wx.TextCtrl(self, style=wx.TE_MULTILINE)

    def CreateExteriorWindowComponents(self):
        ''' Create "exterior" window components, such as menu and status
            bar. '''
        self.CreateMenu()
        self.CreateStatusBar()
        self.SetTitle()

    def CreateMenu(self):
        fileMenu = wx.Menu()
        for id, label, helpText, handler in \
            [(wx.ID_ABOUT, '&About', 'Information about this program',
                self.OnAbout),
             (wx.ID_OPEN, '&Open', 'Open a new file', self.OnOpen),
             (wx.ID_SAVE, '&Save', 'Save the current file', self.OnSave),
             (wx.ID_SAVEAS, 'Save &As', 'Save the file under a different name',
                self.OnSaveAs),
             (None, None, None, None),
             (wx.ID_EXIT, 'E&xit', 'Terminate the program', self.OnExit)]:
            if id == None:
                fileMenu.AppendSeparator()
            else:
                item = fileMenu.Append(id, label, helpText)
                self.Bind(wx.EVT_MENU, handler, item)

        menuBar = wx.MenuBar()
        menuBar.Append(fileMenu, '&File') # Add the fileMenu to the MenuBar
        self.SetMenuBar(menuBar)  # Add the menuBar to the Frame

    def SetTitle(self):
        # MainWindow.SetTitle overrides wx.Frame.SetTitle, so we have to
        # call it using super:
        super(MainWindow, self).SetTitle('Editor %s'%self.filename)


    # Helper methods:

    def defaultFileDialogOptions(self):
        ''' Return a dictionary with file dialog options that can be
            used in both the save file dialog as well as in the open
            file dialog. '''
        return dict(message='Choose a file', defaultDir=self.dirname,
                    wildcard='*.*')

    def askUserForFilename(self, **dialogOptions):
        dialog = wx.FileDialog(self, **dialogOptions)
        if dialog.ShowModal() == wx.ID_OK:
            userProvidedFilename = True
            self.filename = dialog.GetFilename()
            self.dirname = dialog.GetDirectory()
            self.SetTitle() # Update the window title with the new filename
        else:
            userProvidedFilename = False
        dialog.Destroy()
        return userProvidedFilename

    # Event handlers:

    def OnAbout(self, event):
        dialog = wx.MessageDialog(self, 'A sample editor\n'
            'in wxPython', 'About Sample Editor', wx.OK)
        dialog.ShowModal()
        dialog.Destroy()

    def OnExit(self, event):
        self.Close()  # Close the main window.

    def OnSave(self, event):
        textfile = open(os.path.join(self.dirname, self.filename), 'w')
        textfile.write(self.control.GetValue())
        textfile.close()

    def OnOpen(self, event):
        if self.askUserForFilename(style=wx.OPEN,
                                   **self.defaultFileDialogOptions()):
            textfile = open(os.path.join(self.dirname, self.filename), 'r')
            self.control.SetValue(textfile.read())
            textfile.close()

    def OnSaveAs(self, event):
        if self.askUserForFilename(defaultFile=self.filename, style=wx.SAVE,
                                   **self.defaultFileDialogOptions()):
            self.OnSave(event)


app = wx.App()
frame = MainWindow()
frame.Show()
app.MainLoop()

 

11.2 表單、TAB 頁、Sizer

　　參考：WxHowtoBuildingForms

import wx


class Form(wx.Panel):
    ''' The Form class is a wx.Panel that creates a bunch of controls
        and handlers for callbacks. Doing the layout of the controls is
        the responsibility of subclasses (by means of the doLayout()
        method). '''

    def __init__(self, *args, **kwargs):
        super(Form, self).__init__(*args, **kwargs)
        self.referrers = ['friends', 'advertising', 'websearch', 'yellowpages']
        self.colors = ['blue', 'red', 'yellow', 'orange', 'green', 'purple',
                       'navy blue', 'black', 'gray']
        self.createControls()
        self.bindEvents()
        self.doLayout()

    def createControls(self):
        self.logger = wx.TextCtrl(self, style=wx.TE_MULTILINE|wx.TE_READONLY)
        self.saveButton = wx.Button(self, label="Save")
        self.nameLabel = wx.StaticText(self, label="Your name:")
        self.nameTextCtrl = wx.TextCtrl(self, value="Enter here your name")
        self.referrerLabel = wx.StaticText(self,
            label="How did you hear from us?")
        self.referrerComboBox = wx.ComboBox(self, choices=self.referrers,
            style=wx.CB_DROPDOWN)
        self.insuranceCheckBox = wx.CheckBox(self,
            label="Do you want Insured Shipment?")
        self.colorRadioBox = wx.RadioBox(self,
            label="What color would you like?",
            choices=self.colors, majorDimension=3, style=wx.RA_SPECIFY_COLS)

    def bindEvents(self):
        for control, event, handler in \
            [(self.saveButton, wx.EVT_BUTTON, self.onSave),
             (self.nameTextCtrl, wx.EVT_TEXT, self.onNameEntered),
             (self.nameTextCtrl, wx.EVT_CHAR, self.onNameChanged),
             (self.referrerComboBox, wx.EVT_COMBOBOX, self.onReferrerEntered),
             (self.referrerComboBox, wx.EVT_TEXT, self.onReferrerEntered),
             (self.insuranceCheckBox, wx.EVT_CHECKBOX, self.onInsuranceChanged),
             (self.colorRadioBox, wx.EVT_RADIOBOX, self.onColorchanged)]:
            control.Bind(event, handler)

    def doLayout(self):
        ''' Layout the controls that were created by createControls().
            Form.doLayout() will raise a NotImplementedError because it
            is the responsibility of subclasses to layout the controls. '''
        raise NotImplementedError

    # Callback methods:

    def onColorchanged(self, event):
        self.__log('User wants color: %s'%self.colors[event.GetInt()])

    def onReferrerEntered(self, event):
        self.__log('User entered referrer: %s'%event.GetString())

    def onSave(self,event):
        self.__log('User clicked on button with id %d'%event.GetId())

    def onNameEntered(self, event):
        self.__log('User entered name: %s'%event.GetString())

    def onNameChanged(self, event):
        self.__log('User typed character: %d'%event.GetKeyCode())
        event.Skip()

    def onInsuranceChanged(self, event):
        self.__log('User wants insurance: %s'%bool(event.Checked()))

    # Helper method(s):

    def __log(self, message):
        ''' Private method to append a string to the logger text
            control. '''
        self.logger.AppendText('%s\n'%message)


class FormWithAbsolutePositioning(Form):
    def doLayout(self):
        ''' Layout the controls by means of absolute positioning. '''
        for control, x, y, width, height in \
                [(self.logger, 300, 20, 200, 300),
                 (self.nameLabel, 20, 60, -1, -1),
                 (self.nameTextCtrl, 150, 60, 150, -1),
                 (self.referrerLabel, 20, 90, -1, -1),
                 (self.referrerComboBox, 150, 90, 95, -1),
                 (self.insuranceCheckBox, 20, 180, -1, -1),
                 (self.colorRadioBox, 20, 210, -1, -1),
                 (self.saveButton, 200, 300, -1, -1)]:
            control.SetDimensions(x=x, y=y, width=width, height=height)


class FormWithSizer(Form):
    def doLayout(self):
        ''' Layout the controls by means of sizers. '''

        # A horizontal BoxSizer will contain the GridSizer (on the left)
        # and the logger text control (on the right):
        boxSizer = wx.BoxSizer(orient=wx.HORIZONTAL)
        # A GridSizer will contain the other controls:
        gridSizer = wx.FlexGridSizer(rows=5, cols=2, vgap=10, hgap=10)

        # Prepare some reusable arguments for calling sizer.Add():
        expandOption = dict(flag=wx.EXPAND)
        noOptions = dict()
        emptySpace = ((0, 0), noOptions)

        # Add the controls to the sizers:
        for control, options in \
                [(self.nameLabel, noOptions),
                 (self.nameTextCtrl, expandOption),
                 (self.referrerLabel, noOptions),
                 (self.referrerComboBox, expandOption),
                  emptySpace,
                 (self.insuranceCheckBox, noOptions),
                  emptySpace,
                 (self.colorRadioBox, noOptions),
                  emptySpace,
                 (self.saveButton, dict(flag=wx.ALIGN_CENTER))]:
            gridSizer.Add(control, **options)

        for control, options in \
                [(gridSizer, dict(border=5, flag=wx.ALL)),
                 (self.logger, dict(border=5, flag=wx.ALL|wx.EXPAND,
                    proportion=1))]:
            boxSizer.Add(control, **options)

        self.SetSizerAndFit(boxSizer)


class FrameWithForms(wx.Frame):
    def __init__(self, *args, **kwargs):
        super(FrameWithForms, self).__init__(*args, **kwargs)
        notebook = wx.Notebook(self)
        form1 = FormWithAbsolutePositioning(notebook)
        form2 = FormWithSizer(notebook)
        notebook.AddPage(form1, 'Absolute Positioning')
        notebook.AddPage(form2, 'Sizers')
        # We just set the frame to the right size manually. This is feasible
        # for the frame since the frame contains just one component. If the
        # frame had contained more than one component, we would use sizers
        # of course, as demonstrated in the FormWithSizer class above.
        self.SetClientSize(notebook.GetBestSize())


if __name__ == '__main__':
    app = wx.App(0)
    frame = FrameWithForms(None, title='Demo with Notebook')
    frame.Show()
    app.MainLoop()

 

11.3 畫圖

　　參考：WxHowtoDrawing

# doodle.py

'''
This module contains the DoodleWindow class which is a window that you
can do simple drawings upon.
'''

import wx


class DoodleWindow(wx.Window):
    colours = ['Black', 'Yellow', 'Red', 'Green', 'Blue', 'Purple',
        'Brown', 'Aquamarine', 'Forest Green', 'Light Blue', 'Goldenrod',
        'Cyan', 'Orange', 'Navy', 'Dark Grey', 'Light Grey']

    thicknesses = [1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128]

    def __init__(self, parent):
        super(DoodleWindow, self).__init__(parent,
            style=wx.NO_FULL_REPAINT_ON_RESIZE)
        self.initDrawing()
        self.makeMenu()
        self.bindEvents()
        self.initBuffer()

    def initDrawing(self):
        self.SetBackgroundColour('WHITE')
        self.currentThickness = self.thicknesses[0]
        self.currentColour = self.colours[0]
        self.lines = []
        self.previousPosition = (0, 0)

    def bindEvents(self):
        for event, handler in [ \
                (wx.EVT_LEFT_DOWN, self.onLeftDown), # Start drawing
                (wx.EVT_LEFT_UP, self.onLeftUp),     # Stop drawing
                (wx.EVT_MOTION, self.onMotion),      # Draw
                (wx.EVT_RIGHT_UP, self.onRightUp),   # Popup menu
                (wx.EVT_SIZE, self.onSize),          # Prepare for redraw
                (wx.EVT_IDLE, self.onIdle),          # Redraw
                (wx.EVT_PAINT, self.onPaint),        # Refresh
                (wx.EVT_WINDOW_DESTROY, self.cleanup)]:
            self.Bind(event, handler)

    def initBuffer(self):
        ''' Initialize the bitmap used for buffering the display. '''
        size = self.GetClientSize()
        self.buffer = wx.EmptyBitmap(size.width, size.height)
        dc = wx.BufferedDC(None, self.buffer)
        dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
        dc.Clear()
        self.drawLines(dc, *self.lines)
        self.reInitBuffer = False

    def makeMenu(self):
        ''' Make a menu that can be popped up later. '''
        self.menu = wx.Menu()
        self.idToColourMap = self.addCheckableMenuItems(self.menu,
            self.colours)
        self.bindMenuEvents(menuHandler=self.onMenuSetColour,
            updateUIHandler=self.onCheckMenuColours,
            ids=self.idToColourMap.keys())
        self.menu.Break() # Next menu items go in a new column of the menu
        self.idToThicknessMap = self.addCheckableMenuItems(self.menu,
            self.thicknesses)
        self.bindMenuEvents(menuHandler=self.onMenuSetThickness,
            updateUIHandler=self.onCheckMenuThickness,
            ids=self.idToThicknessMap.keys())

    @staticmethod
    def addCheckableMenuItems(menu, items):
        ''' Add a checkable menu entry to menu for each item in items. This
            method returns a dictionary that maps the menuIds to the
            items. '''
        idToItemMapping = {}
        for item in items:
            menuId = wx.NewId()
            idToItemMapping[menuId] = item
            menu.Append(menuId, str(item), kind=wx.ITEM_CHECK)
        return idToItemMapping

    def bindMenuEvents(self, menuHandler, updateUIHandler, ids):
        ''' Bind the menu id's in the list ids to menuHandler and
            updateUIHandler. '''
        sortedIds = sorted(ids)
        firstId, lastId = sortedIds[0], sortedIds[-1]
        for event, handler in \
                [(wx.EVT_MENU_RANGE, menuHandler),
                 (wx.EVT_UPDATE_UI_RANGE, updateUIHandler)]:
            self.Bind(event, handler, id=firstId, id2=lastId)

    # Event handlers:

    def onLeftDown(self, event):
        ''' Called when the left mouse button is pressed. '''
        self.currentLine = []
        self.previousPosition = event.GetPositionTuple()
        self.CaptureMouse()

    def onLeftUp(self, event):
        ''' Called when the left mouse button is released. '''
        if self.HasCapture():
            self.lines.append((self.currentColour, self.currentThickness,
                self.currentLine))
            self.currentLine = []
            self.ReleaseMouse()

    def onRightUp(self, event):
        ''' Called when the right mouse button is released, will popup
            the menu. '''
        self.PopupMenu(self.menu)

    def onMotion(self, event):
        ''' Called when the mouse is in motion. If the left button is
            dragging then draw a line from the last event position to the
            current one. Save the coordinants for redraws. '''
        if event.Dragging() and event.LeftIsDown():
            dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
            currentPosition = event.GetPositionTuple()
            lineSegment = self.previousPosition + currentPosition
            self.drawLines(dc, (self.currentColour, self.currentThickness,
                [lineSegment]))
            self.currentLine.append(lineSegment)
            self.previousPosition = currentPosition

    def onSize(self, event):
        ''' Called when the window is resized. We set a flag so the idle
            handler will resize the buffer. '''
        self.reInitBuffer = True

    def onIdle(self, event):
        ''' If the size was changed then resize the bitmap used for double
            buffering to match the window size.  We do it in Idle time so
            there is only one refresh after resizing is done, not lots while
            it is happening. '''
        if self.reInitBuffer:
            self.initBuffer()
            self.Refresh(False)

    def onPaint(self, event):
        ''' Called when the window is exposed. '''
        # Create a buffered paint DC.  It will create the real
        # wx.PaintDC and then blit the bitmap to it when dc is
        # deleted.  Since we don't need to draw anything else
        # here that's all there is to it.
        dc = wx.BufferedPaintDC(self, self.buffer)

    def cleanup(self, event):
        if hasattr(self, "menu"):
            self.menu.Destroy()
            del self.menu

    # These two event handlers are called before the menu is displayed
    # to determine which items should be checked.
    def onCheckMenuColours(self, event):
        colour = self.idToColourMap[event.GetId()]
        event.Check(colour == self.currentColour)

    def onCheckMenuThickness(self, event):
        thickness = self.idToThicknessMap[event.GetId()]
        event.Check(thickness == self.currentThickness)

    # Event handlers for the popup menu, uses the event ID to determine
    # the colour or the thickness to set.
    def onMenuSetColour(self, event):
        self.currentColour = self.idToColourMap[event.GetId()]

    def onMenuSetThickness(self, event):
        self.currentThickness = self.idToThicknessMap[event.GetId()]

    # Other methods
    @staticmethod
    def drawLines(dc, *lines):
        ''' drawLines takes a device context (dc) and a list of lines
        as arguments. Each line is a three-tuple: (colour, thickness,
        linesegments). linesegments is a list of coordinates: (x1, y1,
        x2, y2). '''
        dc.BeginDrawing()
        for colour, thickness, lineSegments in lines:
            pen = wx.Pen(wx.NamedColour(colour), thickness, wx.SOLID)
            dc.SetPen(pen)
            for lineSegment in lineSegments:
                dc.DrawLine(*lineSegment)
        dc.EndDrawing()


class DoodleFrame(wx.Frame):
    def __init__(self, parent=None):
        super(DoodleFrame, self).__init__(parent, title="Doodle Frame",
            size=(800,600),
            style=wx.DEFAULT_FRAME_STYLE|wx.NO_FULL_REPAINT_ON_RESIZE)
        doodle = DoodleWindow(self)


if __name__ == '__main__':
    app = wx.App()
    frame = DoodleFrame()
    frame.Show()
    app.MainLoop()

 

11.4 工程管理

　　參見：WxProject

　　該部分展示了如何使用 wxPython Style Guide。

　　[批注：在 77 行的地方，筆者的測試環境提示未定義 wx.NO_3D， 故下面的代碼筆記將  'wx.NO_3D|' 去除了 ]

#!/usr/bin/env python

"""
This sample comes from an IBM developerWorks article at
http://www-106.ibm.com/developerworks/library/l-wxpy/index.html

This small program was adapted to demonstrate the current guide lines
on http://wiki.wxpython.org/index.cgi/wxPython_20Style_20Guide.
Changes are noted in readme.txt.
"""

import sys, os
import wx


# Process the command line.  Not much to do;
# just get the name of the project file if it's given. Simple.
projfile = 'Unnamed'
if len(sys.argv) > 1:
    projfile = sys.argv[1]


def MsgDlg(window, string, caption='wxProject', style=wx.YES_NO|wx.CANCEL):
    """Common MessageDialog."""
    dlg = wx.MessageDialog(window, string, caption, style)
    result = dlg.ShowModal()
    dlg.Destroy()
    return result


class main_window(wx.Frame):
    """wxProject MainFrame."""
    def __init__(self, parent, title):
        """Create the wxProject MainFrame."""
        wx.Frame.__init__(self, parent, title=title, size=(500, 500),
                          style=wx.DEFAULT_FRAME_STYLE|wx.NO_FULL_REPAINT_ON_RESIZE)


        # Set up menu bar for the program.
        self.mainmenu = wx.MenuBar()                  # Create menu bar.

        # Make the 'Project' menu.
        menu = wx.Menu()

        item = menu.Append(wx.ID_OPEN, '&Open', 'Open project')  # Append a new menu
        self.Bind(wx.EVT_MENU, self.OnProjectOpen, item)  # Create and assign a menu event.

        item = menu.Append(wx.ID_NEW, '&New', 'New project')
        self.Bind(wx.EVT_MENU, self.OnProjectNew, item)

        item = menu.Append(wx.ID_EXIT, 'E&xit', 'Exit program')
        self.Bind(wx.EVT_MENU, self.OnProjectExit, item)

        self.mainmenu.Append(menu, '&Project')  # Add the project menu to the menu bar.

        # Make the 'File' menu.
        menu = wx.Menu()

        item = menu.Append(wx.ID_ANY, '&Add', 'Add file to project')
        self.Bind(wx.EVT_MENU, self.OnFileAdd, item)

        item = menu.Append(wx.ID_ANY, '&Remove', 'Remove file from project')
        self.Bind(wx.EVT_MENU, self.OnFileRemove, item)

        item = menu.Append(wx.ID_ANY, '&Open', 'Open file for editing')
        self.Bind(wx.EVT_MENU, self.OnFileOpen, item)

        item = menu.Append(wx.ID_ANY, '&Save', 'Save file')
        self.Bind(wx.EVT_MENU, self.OnFileSave, item)

        self.mainmenu.Append(menu, '&File') # Add the file menu to the menu bar.

        # Attach the menu bar to the window.
        self.SetMenuBar(self.mainmenu)

        # Create the splitter window.
        splitter = wx.SplitterWindow(self, style=wx.SP_3D)  ### Atenttion, I remove  'wx.NO_3D |'
        splitter.SetMinimumPaneSize(1)

        # Create the tree on the left.
        self.tree = wx.TreeCtrl(splitter, style=wx.TR_DEFAULT_STYLE)
        self.tree.Bind(wx.EVT_TREE_BEGIN_LABEL_EDIT, self.OnTreeLabelEdit)
        self.tree.Bind(wx.EVT_TREE_END_LABEL_EDIT, self.OnTreeLabelEditEnd)
        self.tree.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnTreeItemActivated)

        # Create the editor on the right.
        self.editor = wx.TextCtrl(splitter, style=wx.TE_MULTILINE)
        self.editor.Enable(0)

        # Install the tree and the editor.
        splitter.SplitVertically(self.tree, self.editor)
        splitter.SetSashPosition(180, True)

        # Some global state variables.
        self.projectdirty = False
        self.root = None
        self.close = False

        self.Bind(wx.EVT_CLOSE, self.OnProjectExit)

        self.Show(True)

    # ----------------------------------------------------------------------------------------
    # Some nice little handlers.
    # ----------------------------------------------------------------------------------------

    def project_open(self, project_file):
        """Open and process a wxProject file."""
        try:
            input = open(project_file, 'r')
            self.tree.DeleteAllItems()

            self.project_file = project_file
            name = input.readline().replace ('\n', '')
            self.SetTitle(name)

            # create the file elements in the tree control.
            self.root = self.tree.AddRoot(name)
            self.activeitem = self.root
            for line in input:
                self.tree.AppendItem(self.root, line.replace ('\n', ''))
            input.close()
            self.tree.Expand(self.root)

            self.editor.Clear()
            self.editor.Enable(False)

            self.projectdirty = False
        except IOError:
            pass

    def project_save(self):
        """Save a wxProject file."""
        try:
            output = open(self.project_file, 'w+')
            output.write(self.tree.GetItemText(self.root) + '\n')
            count = self.tree.GetChildrenCount(self.root)  # collect all file (tree) items.
            iter = 0
            child = ''
            for i in range(count):
               if i == 0:
                  child, cookie = self.tree.GetFirstChild(self.root)
               else:
                  child, cookie = self.tree.GetNextChild(self.root, cookie)
               output.write(self.tree.GetItemText(child) + '\n')
            output.close()
            self.projectdirty = False
        except IOError:
            MsgDlg(self, 'There was an error saving the new project file.', 'Error!', wx.OK)

    def CheckProjectDirty(self):
        """Were the current project changed? If so, save it before."""
        open_it = True
        if self.projectdirty:
            # save the current project file first.
            result = MsgDlg(self, 'The project has been changed.  Save?')
            if result == wx.ID_YES:
                self.project_save()
            if result == wx.ID_CANCEL:
                open_it = False
        return open_it

    def CheckTreeRootItem(self):
        """Is there any root item?"""
        if not self.root:
            MsgDlg(self, 'Please create or open a project before.', 'Error!', wx.OK)
            return False
        return True

    # ----------------------------------------------------------------------------------------
    # Event handlers from here on out.
    # ----------------------------------------------------------------------------------------

    def OnProjectOpen(self, event):
        """Open a wxProject file."""
        open_it = self.CheckProjectDirty()
        if open_it:
            dlg = wx.FileDialog(self, 'Choose a project to open', '.', '', '*.wxp', wx.OPEN)
            if dlg.ShowModal() == wx.ID_OK:
                self.project_open(dlg.GetPath())
            dlg.Destroy()

    def OnProjectNew(self, event):
        """Create a new wxProject."""
        open_it = self.CheckProjectDirty()
        if open_it:
            dlg = wx.TextEntryDialog(self, 'Name for new project:', 'New Project',
                                     'New project', wx.OK|wx.CANCEL)
            if dlg.ShowModal() == wx.ID_OK:
                newproj = dlg.GetValue()
                dlg.Destroy()
                dlg = wx.FileDialog(self, 'Place to store new project.', '.', '', '*.wxp', wx.SAVE)
                if dlg.ShowModal() == wx.ID_OK:
                    try:
                        # save the project file.
                        proj = open(dlg.GetPath(), 'w')
                        proj.write(newproj + '\n')
                        proj.close()
                        self.project_open(dlg.GetPath())
                    except IOError:
                        MsgDlg(self, 'There was an error saving the new project file.', 'Error!', wx.OK)
            dlg.Destroy()

    def SaveCurrentFile(self):
        """Check and save current file."""
        go_ahead = True
        if self.root:
            if self.activeitem != self.root:
                if self.editor.IsModified():  # Save modified file before
                    result = MsgDlg(self, 'The edited file has changed.  Save it?')
                    if result == wx.ID_YES:
                        self.editor.SaveFile(self.tree.GetItemText(self.activeitem))
                    if result == wx.ID_CANCEL:
                        go_ahead = False
                if go_ahead:
                    self.tree.SetItemBold(self.activeitem, 0)
        return go_ahead

    def OnProjectExit(self, event):
        """Quit the program."""
        if not self.close:
            self.close = True
            if not self.SaveCurrentFile():
                self.close = False
            if self.projectdirty and self.close:
                result = MsgDlg(self, 'The project has been changed.  Save?')
                if result == wx.ID_YES:
                    self.project_save()
                if result == wx.ID_CANCEL:
                    self.close = False
            if self.close:
                self.Close()
        else:
            event.Skip()

    def OnFileAdd(self, event):
        """Adds a file to the current project."""
        if not self.CheckTreeRootItem():
            return

        dlg = wx.FileDialog(self, 'Choose a file to add.', '.', '', '*.*', wx.OPEN)
        if dlg.ShowModal() == wx.ID_OK:
            path = os.path.split(dlg.GetPath())
            self.tree.AppendItem(self.root, path[1])
            self.tree.Expand(self.root)
            self.project_save()

    def OnFileRemove(self, event):
        """Removes a file to the current project."""
        if not self.CheckTreeRootItem():
            return
        item = self.tree.GetSelection()
        if item != self.root:
            self.tree.Delete(item)
            self.project_save()

    def OnFileOpen(self, event):
        """Opens current selected file."""
        if self.root:
            item = self.tree.GetSelection()
            if item != self.root:
                self.OnTreeItemActivated(None, item)
                return
        MsgDlg(self, 'There is no file to load.', 'Error!', wx.OK)

    def OnFileSave(self, event):
        """Saves current selected file."""
        if self.root:
            if self.activeitem != self.root:
                self.editor.SaveFile(self.tree.GetItemText(self.activeitem))
                return
        MsgDlg(self, 'There is no file to save.', 'Error!', wx.OK)


    def OnTreeLabelEdit(self, event):
        """Edit tree label (only root label can be edited)."""
        item = event.GetItem()
        if item != self.root:
            event.Veto()

    def OnTreeLabelEditEnd(self, event):
        """End editing the tree label."""
        self.projectdirty = True


    def OnTreeItemActivated(self, event, item=None):
        """Tree item was activated: try to open this file."""
        go_ahead = self.SaveCurrentFile()

        if go_ahead:
            if event:
                item = event.GetItem()
            self.activeitem = item
            if item != self.root:
                # load the current selected file
                self.tree.SetItemBold(item, 1)
                self.editor.Enable(1)
                self.editor.LoadFile(self.tree.GetItemText(item))
                self.editor.SetInsertionPoint(0)
                self.editor.SetFocus()
            else:
                self.editor.Clear()
                self.editor.Enable(0)


class App(wx.App):
    """wxProject Application."""
    def OnInit(self):
        """Create the wxProject Application."""
        frame = main_window(None, 'wxProject - ' + projfile)
        if projfile != 'Unnamed':
            frame.project_open(projfile)
        return True


if __name__ == '__main__':
    app = App(0)
    app.MainLoop()

 

11.5 FAQ

　　參見：FAQ

 

12. 備注

12.1 '國際慣例'

　　歡迎評論和發表意見

12.2 不同系統的路徑問題

　　代碼：

import os
f=open(os.path.join(self.dirname,self.filename),'r')

　　在 Windows 系統上可能存在問題，如果你的目錄是在驅動盤的根目錄下。在這種情況下，普通的對話框會返回

self.dirname = 'c:' （但你期望的是 'c:\'，除非你使用 MS many years）。不幸的是，os.path.join 不會自動添

加期望的符號導致打開一個文件為 'c:file.py' 而出錯。一個更好的解決方法是：

f=open(os.path.normpath(os.path.join(self.dirname+os.sep,self.filename)),'r')

　　我想大多數情況下是正常的，除非 self.dirname 是 'c:\'，因為 normpath 不會去除第一個參數的分隔符。或

着一個更優雅的解決方法，使用 os.path.isbas() 。

 

12.3 使用 sizer 的步驟

 　　上面我們使用的是這種方式：

window.SetSizer(sizer)
window.SetAutoLayout(true)
sizer.Fit(window)

　　我們也可以使用下面的方式：

window.SetSizerAndFit(sizer)

 

12.4 怎樣使能 tab 的切換功能

　　對於一個沒有對話框的窗口來講，使能 TAB 按鍵功能真的比較難：僅有的線索是整個窗口使能 style wxTAB_TRAVERSAL，

但是卻不是很清晰。我最后得到的答案是：

　　1）需要使能 TAB 功能的控件或窗口，開啟 style wxTAB_TRAVERSAL，例如：

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）TAB 的順序是根據你添加控件的順序來的（來源於：Massimiliano Sartor）

　　3）TAB 的順序也有可能和創建的順序有關。我猜測是由於控件的 ID 號。使用 sizer、panel 沒有太多幫助

　　　　（來源於：Keith Veleba）

　　4）有一種慣用方法來設置 TAB 的順序：

order = (control1, control2, control3, ...)
for i in xrange(len(order) - 1):
    order[i+1].MoveAfterInTabOrder(order[i])

　　list 列表里是真正的控件的 TAB 順序，對於添加新控件，這樣能夠很容易的改變順序（來源於： Don Dwiggins）