PyGTK 快速指南

---

---

PyGTK - 簡介

PyGTK 是一套用 Python 和 C 編寫的 GTK+ GUI 庫的包裝器。它是 GNOME 專案的一部分。它提供了構建 Python 桌面應用程式的全面工具。其他流行的 GUI 庫的 Python 繫結也可用。

PyQt 是 QT 庫的 Python 移植版本。我們的 PyQt 教程可以在這裡找到 此處。類似地，wxPython 工具包是 wxWidgets 的 Python 繫結，wxWidgets 是另一個流行的跨平臺 GUI 庫。我們的 wxPython 教程可在 此處。

GTK+，或 GIMP 工具包，是一個用於建立圖形使用者介面的多平臺工具包。GTK+ 提供了一套完整的部件，適用於從小型一次性工具到完整應用程式套件的各種專案。

GTK+ 從一開始就被設計為支援各種語言。PyGTK 是 GTK+ 的 Python 包裝器。

GTK+ 基於以下四個庫構建 −

• Glib − 一個低階核心庫，構成 GTK+ 的基礎。它為 C 提供資料結構處理。

• Pango − 一個用於文字佈局和渲染的庫，重點關注國際化。

• Cairo − 一個用於 2D 圖形的庫，支援多種輸出裝置（包括 X 視窗系統、Win32）

• ATK − 一個用於一組介面的庫，提供輔助功能工具，例如螢幕閱讀器、放大鏡和替代輸入裝置。

PyGTK 簡化了流程，並幫助您使用 Python 程式語言建立具有圖形使用者介面的程式。底層的 GTK+ 庫為此提供了各種視覺元素和實用程式，以便為 GNOME 桌面開發功能齊全的應用程式。PyGTK 是一個跨平臺庫。它是一個在 LGPL 許可下分發的自由軟體。

PyGTK 基於 GTK+ 2.x 構建。為了構建 GTK+3 的應用程式，PyGObject 繫結也可用。

PyGTK - 環境

適用於 Microsoft Windows 的 PyGTK

在 Microsoft Windows 上安裝 PyGTK 包括以下步驟 −

• 步驟 1 − 安裝 32 位 Python 直譯器（最新的 Python 2.7 發行版）

• 步驟 2 − 下載並安裝 GTK+ 執行時。

• 步驟 3 − 下載並安裝 GTK+ 執行時 −https://ftp.gnome.org

• 步驟 4 − 還建議您從以下 URL 下載 PyCairo 和 PyGobject 模組 − https://ftp.gnome.org https://ftp.gnome.org/pub

• 步驟 5 − 為方便起見，也提供了處理所有 PyGTK 依賴項的多合一安裝程式。從以下 URL 下載並安裝適用於 Windows 的最新多合一安裝程式 − https://ftp.gnome.org/pub/GNOME

適用於 Linux 的 PyGTK

大多數 Linux 發行版（包括 Debian、Fedora、Ubuntu、RedHat 等）都包含 PyGTK；原始碼也可以從以下 URL 下載並編譯

https://ftp.gnome.org/pub/GNOME/sources/pygtk/2.24/

PyGTK - Hello World

使用 PyGTK 建立視窗非常簡單。要繼續，我們首先需要在程式碼中匯入 gtk 模組。

import gtk

gtk 模組包含 gtk.Window 類。它的物件構造一個頂級視窗。我們從 gtk.Window 派生一個類。

class PyApp(gtk.Window):

定義建構函式並呼叫 gtk.window 類的 show_all() 方法。

def __init__(self):
   super(PyApp, self).__init__()
   self.show_all()

現在我們必須宣告此類的物件並透過呼叫其 main() 方法啟動事件迴圈。

PyApp()
gtk.main()

建議我們在父視窗中新增一個標籤 “Hello World”。

label = gtk.Label("Hello World")
self.add(label)

以下是顯示 “Hello World” 的完整程式碼 −

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_default_size(300,200)
      self.set_title("Hello World in PyGTK")
      label = gtk.Label("Hello World")
      self.add(label)
      self.show_all()
PyApp()
gtk.main()

上述程式碼的實現將產生以下輸出 −

PyGTK - 重要類

PyGTK 模組包含各種部件。gtk.Object 類充當大多數部件以及一些非部件類的基類。使用 PyGTK 的桌面應用程式的頂級視窗由 gtk.Window 類提供。下表列出了重要的部件及其功能 −

PyGTK - 視窗類

gtk.Window 類的物件提供了一個使用者通常認為是視窗的部件。此部件是一個容器，因此它可以容納一個子部件。它提供了一個可顯示的區域，裝飾有標題欄和調整大小控制元件。

gtk.Window 類具有以下建構函式 −

gtk.Window(type)

Type 引數採用以下值之一 −

gtk.Window 類的一些重要方法如下所示 −

gtk.Window 部件發出以下訊號 −

PyGTK - 按鈕類

gtk.Button 部件通常顯示為帶有文字標籤的按鈕。它通常用於附加一個回撥函式或方法，當按鈕被點選時呼叫該函式或方法。

gtk.Button 類具有以下建構函式：

gtk.Button(label = None, stock = None, use_underline = True)

其中，

• Label - 按鈕標籤要顯示的文字

• Stock - 標識按鈕中要使用的庫存影像和文字的庫存 ID。預設為 None。

• Underline - 如果為 True，文字中的下劃線表示下一個字元應帶下劃線並用作記憶體加速鍵。

stock 引數的一些預定義常量為：

• STOCK_OK
• STOCK_STOP
• STOCK_YES
• STOCK_NO
• STOCK_QUIT
• STOCK_CANCEL
• STOCK_CLOSE

Button 類具有以下重要方法：

Button 部件發出以下訊號：

PyGTK - Label 類

Label 部件用於顯示不可編輯的文字。Label 在內部被許多其他部件使用。例如，Button 有一個 Label 來顯示其表面的文字。類似地，MenuItem 物件也有一個 Label。Label 是一個無視窗物件，因此它無法直接接收事件。

Label 類具有一個簡單的建構函式：

gtk.Label(str = None)

以下有用的方法可用於 Label 物件：

Label 部件發出以下訊號：

PyGTK - 輸入框類

Entry 部件是一個單行文字輸入部件。如果輸入的文字長於部件的分配，部件將滾動，以便游標位置可見。

可以使用此類的 set_visibility() 方法將 Entry 欄位轉換為密碼模式。輸入的文字將被 invisible_char() 方法選擇的字元替換，預設為 '*'。

Entry 類具有以下建構函式：

gtk.Entry(max = 0)

這裡，max 代表 Entry 欄位以字元為單位的最大長度。該引數採用數值（0-65536）。

下表顯示了 Entry 類的重要方法：

Entry 部件發出以下訊號：

PyGTK - 訊號處理

與以順序方式執行的控制檯模式應用程式不同，基於 GUI 的應用程式是事件驅動的。gtk.main()函式啟動一個無限迴圈。GUI 上發生的事件被傳遞到相應的回撥函式。

每個從 GObject 類派生的 PyGTK 部件都設計為響應一個或多個事件發出“訊號”。訊號本身不執行任何操作。相反，它“連線”到一個回撥函式。

一些訊號是由部件繼承的，而一些訊號是部件特定的。例如，“toggled”訊號由 toggleButton 部件發出。

透過呼叫 gtk.widget 類的connect()方法來設定訊號處理程式。

handler_id = object.connect(name, func, func_data)

• 第一個引數name是一個字串，包含要捕獲的訊號的名稱。

• 第二個引數func是要在捕獲訊號時呼叫的回撥函式。

• 第三個引數func_data是要傳遞給此函式的資料。

• 處理程式 ID，用於唯一標識回撥方法。

例如，要在單擊按鈕時呼叫 onClicked() 函式，請使用以下語法：

btn.connect("clicked",onClicked,None)

onClicked() 函式定義如下：

def onClicked(widget, data=None):

如果回撥方法是一個物件方法，它會接收 self 作為附加引數：

def onClicked(self, widget, data=None):

示例

在以下示例中，一個 Button 被新增到 gtk.Window。當按鈕被點選時，將列印“Hello World”訊息。

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Hello World in PyGTK")
      self.set_default_size(400,300)
      self.set_position(gtk.WIN_POS_CENTER)
		
      self.label = gtk.Label("Enter name")
      self.entry = gtk.Entry()
		
      self.btn = gtk.Button("Say Hello")
      self.btn.connect("clicked",self.hello)
		
      fixed = gtk.Fixed()
      fixed.put(self.label, 100,100)
      fixed.put(self.entry, 100,125)
      fixed.put(self.btn,100,150)
		
      self.add(fixed)
      self.show_all()
		
   def hello(self,widget):
      print "hello",self.entry.get_text()
PyApp()
gtk.main()

從 Python 提示符執行上述程式碼。將顯示以下輸出：

當按下按鈕時，控制檯將顯示以下輸出：

Hello TutorialsPoint

PyGTK - 事件處理

除了訊號機制之外，視窗系統事件也可以連線到回撥函式。視窗調整大小、按鍵、滾動事件等是一些常見的視窗系統事件。這些事件被報告給應用程式的主迴圈。從那裡，它們透過訊號傳遞給回撥函式。

一些系統事件如下所示：

• button_press_event
• button_release_event
• scroll_event
• motion_notify_event
• delete_event
• destroy_event
• expose_event
• key_press_event
• key_release_event

connect() 方法用於將事件與回撥函式關聯，語法如下：

Object.connect(name, function, data)

這裡，name 代表要捕獲的事件名稱對應的字串。而function是要在事件發生時呼叫的回撥函式的名稱。Data 是要傳遞給回撥函式的引數。

因此，以下程式碼連線了一個 Button 部件並捕獲 button_press 事件：

self.btn.connect("button_press_event", self.hello)

hello() 函式的原型如下：

def hello(self,widget,event):

示例

以下是按鈕事件處理程式的程式碼：

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Hello World in PyGTK")
      self.set_default_size(400,300)
      self.set_position(gtk.WIN_POS_CENTER)
		
      self.label = gtk.Label("Enter name")
      self.entry = gtk.Entry()
      self.btn = gtk.Button("Say Hello")
      self.btn.connect("button_press_event", self.hello)
		
      fixed = gtk.Fixed()
      fixed.put(self.label, 100,100)
      fixed.put(self.entry, 100,125)
      fixed.put(self.btn,100,150)
		
      self.add(fixed)
      self.show_all()
		
   def hello(self,widget,event):
      print "hello",self.entry.get_text()

PyApp()
gtk.main()

執行上述程式碼時，控制檯將顯示以下輸出：

Hello TutorialsPoint

PyGTK - 容器

PyGTK 庫提供了不同的容器類來控制部件在視窗內的放置。最簡單的方法是使用固定容器類，並透過指定其以畫素為單位的絕對座標將部件放置在其中。

現在讓我們按照以下步驟操作：

步驟 1 - 宣告fixed 類的物件

fixed = gtk.Fixed()

步驟 2 - 建立一個按鈕部件，並使用put()方法將其新增到固定容器中，該方法需要 x 和 y 座標。這裡，按鈕將放置在 (100,100) 位置。

btn = gtk.Button("Hello")
fixed.put(btn, 100,100)

步驟 3 - 您可以將多個控制元件放置在固定容器中。並將其新增到頂級視窗並呼叫show_all()方法

self.add(fixed)
self.show_all()

然而，這種絕對佈局並不合適，原因如下：

• 即使視窗大小發生變化，部件的位置也不會改變。
• 在具有不同解析度的不同顯示裝置上，外觀可能不統一。
• 佈局的修改很困難，因為它可能需要重新設計整個表單。

以下是原始視窗：

以下是調整大小後的視窗：

此處按鈕的位置未發生變化。

PyGTK API 提供了容器類，用於增強對容器內部件位置的管理。佈局管理器相對於絕對定位的優勢在於：

• 視窗內的部件會自動調整大小。
• 確保在具有不同解析度的顯示裝置上外觀統一。
• 可以動態新增或刪除部件，而無需重新設計。

gtk.Container 充當以下類的基類：

• gtk.ButtonBox
• gtk.Box
• gtk.Alignment
• gtk.EventBox
• gtk.Table

PyGTK - 盒狀容器類

gtk.Box 類是一個抽象類，定義了容器的功能，在該容器中，部件放置在矩形區域中。gtk.HBox 和 gtk.VBox 部件從中派生。

gtk.Hbox 中的子部件水平排列在同一行中。另一方面，gtk.VBox 的子部件垂直排列在同一列中。

gtk.Box 類使用以下建構函式：

gtk.Box(homogenous = True, spacing = 0)

預設情況下，homogenous 屬性設定為 True。因此，所有子部件都獲得相同的分配。

gtk.Box 使用打包機制將其中的子部件放置在特定位置，或者相對於開頭或結尾。pack_start() 方法從開頭到結尾放置部件。相反，pack_end() 方法從結尾到開頭放置部件。或者，您可以使用 add() 方法，它類似於 pack_start()。

以下方法可用於 gtk.HBox 和 gtk.VBox：

• gtk_box_pack_start ()

• gtk_box_pack_end ()

gtk_box_pack_start ()

此方法將child新增到盒中，並相對於盒的開頭進行打包。

pack_start(child, expand = True, fill = True, padding = 0)

以下是引數：

• child − 要新增到盒中的部件物件

• expand − 如果要為child在盒中分配額外的空間，則將其設定為True。額外的空間將在所有child部件之間分配。

• fill − 如果為True，則會為child分配額外的空間。否則，此引數用作填充。

• padding − 盒中部件之間的畫素間距。

gtk_box_pack_end ()

這將child新增到盒中，並相對於盒的末尾進行打包。

pack_end (child, expand = True, fill = True, padding = 0)

以下是引數：

• child − 要新增的部件物件

• expand − 如果要為child在盒中分配額外的空間，則將其設定為True。此額外空間將在所有child部件之間分配。

• fill − 如果為True，則會為child分配額外的空間；否則用作填充。

• padding − 盒中部件之間的畫素間距。

set_spacing (spacing)是設定在盒的子部件之間放置的畫素數的函式。

方法add (widget)繼承自gtk.Container類。它將部件新增到容器中。此方法可以代替pack_start()方法使用。

示例

在下面給出的示例中，頂級視窗包含一個垂直盒（gtk.VBox物件box）。它依次包含一個VBox物件vb和一個HBox物件hb。在上盒中，標籤、輸入部件和按鈕垂直放置。在下盒中，另一組標籤、輸入和按鈕垂直放置。

觀察以下程式碼：

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
         self.set_title("Box demo")
		
      box = gtk.VBox()
      vb = gtk.VBox()
      lbl = gtk.Label("Enter name")
		
      vb.pack_start(lbl, expand = True, fill = True, padding = 10)
      text = gtk.Entry()
		
      vb.pack_start(text, expand = True, fill = True, padding = 10)
      btn = gtk.Button(stock = gtk.STOCK_OK)
		
      vb.pack_start(btn, expand = True, fill = True, padding = 10)
      hb = gtk.HBox()
		
      lbl1 = gtk.Label("Enter marks")
      hb.pack_start(lbl1, expand = True, fill = True, padding = 5)
      text1 = gtk.Entry()
		
      hb.pack_start(text1, expand = True, fill = True, padding = 5)
      btn1 = gtk.Button(stock = gtk.STOCK_SAVE)
		
      hb.pack_start(btn1, expand = True, fill = True, padding = 5)
      box.add(vb)
      box.add(hb)
      self.add(box)
      self.show_all()
PyApp()
gtk.main()

以上程式碼將產生以下輸出：

PyGTK - 按鈕盒類

gtk API中的ButtonBox類充當容器的基類，用於水平或垂直容納多個按鈕。兩個子類HButtonBox和VButtonBox派生自ButtonBox類，而ButtonBox類本身是gtk.Box類的子類。

按鈕盒用於在整個應用程式中提供一致的按鈕佈局。它提供了一種預設佈局和一個預設間距值，這些值在所有部件中都是持久存在的。

可以使用gtk.Box類的set_spacing()方法更改按鈕盒中按鈕之間的預設間距。

可以透過set_default()方法更改按鈕的預設佈局。按鈕佈局的可能值為：

• gtk.BUTTONBOX_SPREAD

• gtk.BUTTONBOX_EDGE

• gtk.BUTTONBOX_START

• gtk.BUTTONBOX_END。

示例

在下面的示例中，頂級視窗內的VBox物件內部包含一個VButtonBox物件和一個HButtonBox物件，每個物件都包含兩個按鈕，分別垂直和水平排列。

觀察程式碼：

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Button Box demo")
      self.set_size_request(200,100)
      self.set_position(gtk.WIN_POS_CENTER)
	  vb = gtk.VBox()
      box1 = gtk.VButtonBox()
      btn1 = gtk.Button(stock = gtk.STOCK_OK)
      btn2 = gtk.Button(stock = gtk.STOCK_CANCEL)
		
      box1.pack_start(btn1, True, True, 0)
      box1.pack_start(btn2, True, True, 0)
      box1.set_border_width(5)
		
      vb.add(box1)
      box2 = gtk.HButtonBox()
      btn3 = gtk.Button(stock = gtk.STOCK_OK)
      btn4 = gtk.Button(stock = gtk.STOCK_CANCEL)
		
      ent = gtk.Entry()
      box2.pack_start(btn3, True, True, 0)
      box2.pack_start(btn4, True, True, 0)
      box1.set_border_width(5)
		
      vb.add(box2)
      self.add(vb)
      self.show_all()

PyApp()
gtk.main()

以上程式碼生成以下輸出：

PyGTK - 對齊類

此部件在控制其子部件的對齊和大小方面非常有用。它具有四個屬性，稱為xalign、yalign、xscale和yscale。scale屬性指定子部件將使用多少可用空間。align屬性用於將子部件放置在可用區域內。

所有四個屬性都佔用0到1.0之間的浮點值。如果xscale和yscale屬性設定為0，則表示部件不吸收任何可用空間；如果設定為1，則部件分別水平或垂直吸收最大可用空間。

如果xalign和yalign屬性設定為0，則表示部件左側或上方沒有可用空間。如果設定為1，則部件左側或上方將有最大可用空間。

gtk.alignment類具有以下建構函式：

gtk.alignment(xalign = 0.0, yalign = 0.0, xscale = 0.0, yscale = 0.0)

其中，

• xalign − 是子部件左側水平可用空間的一部分。

• yalign − 是子部件上方的垂直可用空間的一部分。

• xscale − 是子部件吸收的水平可用空間的一部分。

• yscale − 是子部件吸收的垂直可用空間的一部分。

示例

以下程式碼演示了gtk.alignment部件的使用。頂級視窗中的一個Vbox在其內部放置了一個上部Vbox和一個下部Hbox。在上垂直盒中，標籤和輸入部件的放置方式是，左側保留50%的空間，並且透過為0.5 xalign和0.25 yalign屬性賦值，佔用超過25%的空間。

在下Hbox中，所有可用的可用空間都在左側。這是透過將xalign屬性賦值為1來實現的。因此，水平盒中的兩個按鈕右對齊。

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Alignment demo")
      self.set_size_request(400,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      vb = gtk.VBox()
      hbox = gtk.HBox(True, 3)
      valign = gtk.Alignment(0.5,0.25, 0, 0)
		
      lbl = gtk.Label("Name of student")
      vb.pack_start(lbl, True, True, 10)
      text = gtk.Entry()
		
      vb.pack_start(text, True, True, 10)
      valign.add(vb)
      vbox.pack_start(valign)
		
      ok = gtk.Button("OK")
      ok.set_size_request(70, 30)
		
      close = gtk.Button("Close")
      hbox.add(ok)
      hbox.add(close)
		
      halign = gtk.Alignment(1, 0, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, False, 3)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
PyApp()
gtk.main()

以上程式碼產生以下輸出：

PyGTK - 事件盒類

PyGTK工具包中的一些部件沒有自己的視窗。此類無視窗部件無法接收事件訊號。例如，標籤等此類部件，如果放在事件盒內，則可以接收訊號。

EventBox是一個不可見的容器，它為無視窗部件提供視窗。它有一個簡單的建構函式，沒有任何引數：

gtk.EventBox()

示例

在下面的示例中，兩個gtk.EventBox部件放置在頂級視窗中。在每個事件盒內，都添加了一個標籤。現在，事件盒連線到一個回撥函式，以處理其上的button_press_event。由於事件盒本身是不可見的，因此有效地，事件發生在嵌入的標籤上。因此，當我們點選任何標籤時，都會呼叫相應的回撥函式。

觀察程式碼：

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("EventBox demo")
      self.set_size_request(200,100)
      self.set_position(gtk.WIN_POS_CENTER)
      fixed = gtk.Fixed()
      
      event1 = gtk.EventBox()
      label1 = gtk.Label("Label 1")
      event1.add(label1)
      fixed.put(event1, 80,20)
      
      event1.connect("button_press_event",self.hello1)
      event2 = gtk.EventBox()
      label2 = gtk.Label("Label 2")
      event2.add(label2)
      event2.connect("button_press_event",self.hello2)
      fixed.put(event2, 80,70)
      
      self.add(fixed)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def hello1(self, widget, event):
      print "clicked label 1"
		
   def hello2(self, widget, event):
      print "clicked label 2"

PyApp()
gtk.main()

以上程式碼生成以下輸出：

當單擊控制檯上的標籤1時，會列印訊息“clicked label 1”。類似地，當單擊標籤2時，會列印“clicked label 2”訊息。

PyGTK - 佈局類

gtk.Layout是一個類似於gtk.Fixed的容器部件。透過指定絕對座標，將部件放置在Layout部件中。但是，Layout與固定部件的不同之處在於：

• Layout部件可以具有無限的寬度和高度。寬度和高度的最大值受無符號整數的大小限制。

• gtk.DrawingArea部件可以封閉在一個佈局容器中。DrawingArea是一個畫布，可以在其上繪製線條、矩形等二維元素。

• 為了將Layout容器放在尺寸較小的頂級視窗中，可以將其與捲軸關聯，或者可以將其放置在ScrolledWindow中。

gtk.Layout類具有以下建構函式：

gtk.Layout(hadjustment = None, vadjustment = None)

hadjustment和vadjustment屬性表示一個具有可調整邊界值的物體。

下表列出了Layout常用的方法：

當與其關聯的調整發生更改時，Layout物件會發出set_scroll_adjustment訊號。

示例

在下面的示例中，一個標籤放置在Layout容器的中心，而Layout容器又將放置在一個尺寸較小的頂級視窗中。因此，它首先被新增到ScrolledWindow中，然後ScrolledWindow被新增到主視窗中。

觀察程式碼：

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("layout")
      self.set_size_request(300,200)
      self.set_position(gtk.WIN_POS_CENTER)
      sc = gtk.ScrolledWindow()
      lo = gtk.Layout()
      lo.set_size(400,400)
      button = gtk.Button("Press Me")
      lo.put(button, 125,200)
      sc.add(lo)
      self.add(sc)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 組合框類

ComboBox是任何GUI工具包中功能強大且流行的部件。它提供了一個下拉列表，使用者可以從中選擇專案。gtk.ComboBox部件實現了CellLayout介面，並提供了一些方法來管理專案的顯示。

gtk.ComboBox類的物件與ListSore相關聯，ListSore是一個列表模型，可以與顯示專案集合的部件一起使用。使用append()方法將專案新增到ListStore中。此外，建立CellRendererText物件並將其打包到組合框中。

按照以下步驟設定組合框。

combobox = gtk.ComboBox()
store = gtk.ListStore(gobject.TYPE_STRING)
cell = gtk.CellRendererText()
combobox.pack_start(cell)
combobox.add_attribute(cell, 'text', 0)

PyGTK提供了一個便捷方法—gtk.combo_box_new_text()來建立組合框，而不是使用列表儲存。關聯的便捷方法append_text()、prepend_text()、insert_text()和remove_text()用於管理組合框內容。

gtk.ComboBox類具有以下方法：

ComboBox部件發出以下訊號：

下面給出了兩個組合框演示示例程式碼。

示例1

在此示例中，ListStore填充了流行的Python GUI工具包的名稱，並將其與ComboBox部件相關聯。當用戶做出選擇時，會發出changed訊號。它連線到一個回撥函式以顯示使用者的選擇。

import pygtk
pygtk.require('2.0')
import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("ComboBox with ListStore")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      combobox = gtk.ComboBox()
      store = gtk.ListStore(str)
      cell = gtk.CellRendererText()
      combobox.pack_start(cell)
      combobox.add_attribute(cell, 'text', 0)
      fixed = gtk.Fixed()
      lbl = gtk.Label("select a GUI toolkit")
      fixed.put(lbl, 25,75)
      fixed.put(combobox, 125,75)
      lbl2 = gtk.Label("Your choice is:")
      fixed.put(lbl2, 25,125)
      self.label = gtk.Label("")
      fixed.put(self.label, 125,125)
      self.add(fixed)
      
      store.append (["PyQt"])
      store.append (["Tkinter"])
      store.append (["WxPython"])
      store.append (["PyGTK"])
      store.append (["PySide"])
      combobox.set_model(store)
      combobox.connect('changed', self.on_changed)
      combobox.set_active(0)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
      return
   
   def on_changed(self, widget):
      self.label.set_label(widget.get_active_text())
      return
      
if __name__ == '__main__':
PyApp()
gtk.main()

執行後，程式將顯示以下輸出：

示例2

程式的第二個版本使用便捷方法combo_box_new_text()建立組合框，並使用append_text()函式在其中新增字串。在這兩個程式中，get_active_text()方法用於獲取使用者的選擇並在視窗上的標籤上顯示。

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Simple ComboBox")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      cb = gtk.combo_box_new_text()
      cb.connect("changed", self.on_changed)
      cb.append_text('PyQt')
      cb.append_text('Tkinter')
      cb.append_text('WxPython')
      cb.append_text('PyGTK')
      cb.append_text('PySide')
      
      fixed = gtk.Fixed()
      lbl = gtk.Label("select a GUI toolkit")
      fixed.put(lbl, 25,75)
      
      fixed.put(cb, 125,75)
      lbl2 = gtk.Label("Your choice is:")
      fixed.put(lbl2, 25,125)
      
      self.label = gtk.Label("")
      fixed.put(self.label, 125,125)
      self.add(fixed)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_changed(self, widget):
      self.label.set_label(widget.get_active_text())
if __name__ == '__main__':
   PyApp()
   gtk.main()

此程式的輸出與上一個程式的輸出類似。

PyGTK - 切換按鈕類

ToggleButton部件是一個gtk.Button，它具有兩種狀態—按下或活動（或開啟）狀態和正常或非活動（或關閉）狀態。每次按下按鈕時，狀態都會交替。也可以透過set_active()方法以程式設計方式更改ToggleButton的狀態。要切換按鈕的狀態，還可以使用toggled()方法。

gtk.ToggleButton類具有以下建構函式：

gtk.ToggleButton(label = None, use_underline = True)

這裡，label是要在按鈕上顯示的文字。如果use_underline屬性為True，則文字中的下劃線表示下一個字元應帶下劃線，並用於助記符加速鍵。

gtk.ToggleButton類的一些重要方法在下表中給出：

ToggleButton部件發出以下訊號：

下面給出的程式碼演示了ToggleButton部件的使用。

兩個ToggleButton和Label部件放置在一個VBox容器中。Button1發出的toggled訊號連線到on_toggled()的回撥函式中。在此函式中，如果Button1的狀態為False，則將Button2的狀態設定為True，反之亦然。

if self.btn1.get_active() == True:
   self.btn2.set_active(False)
else:
   self.btn2.set_active(True)

它在Label上顯示按鈕的瞬時狀態。

示例

觀察以下程式碼：

import gtk

 PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Toggle Button")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      vbox = gtk.VBox()
      self.btn1 = gtk.ToggleButton("Button 1")
      self.btn1.connect("toggled", self.on_toggled)
      self.btn2 = gtk.ToggleButton("Button 2")
      self.lbl = gtk.Label()
      
      vbox.add(self.btn1)
      vbox.add(self.btn2)
      vbox.add(self.lbl)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_toggled(self, widget, data = None):
      if self.btn1.get_active() == True:
         self.btn2.set_active(False)
      else:
         self.btn2.set_active(True)
         state = "Button1 : "+str(self.btn1.get_active())+" 
         Button2 : "+str(self.btn2.get_active())
         self.lbl.set_text(state)
if __name__ == '__main__':
   PyApp()
   gtk.main()

以上程式碼生成以下輸出：

PyGTK - 複選框類

CheckButton部件只不過是一個樣式為複選框和標籤的ToggleButton。它繼承了ToggleButton類中的所有屬性和方法。與ToggleButton（其標題位於按鈕表面）不同，CheckButton顯示一個小正方形（可選中），並在其右側有一個標籤。

與gtk.CheckButton關聯的建構函式、方法和訊號與gtk.ToggleButton完全相同。

示例

以下示例演示了CheckButton部件的使用。兩個CheckButton和一個Label放置在一個VBox中。第一個CheckButton的toggled訊號連線到on_checked()方法，該方法如果第一個按鈕為假則將第二個按鈕的狀態設定為True，反之亦然。

觀察程式碼：

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Check Button")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)

      vbox = gtk.VBox()
      self.btn1 = gtk.CheckButton("Button 1")
      self.btn1.connect("toggled", self.on_checked)
      self.btn2 = gtk.CheckButton("Button 2")
      self.btn2.connect("toggled", self.on_checked)
      self.lbl = gtk.Label()
		
      vbox.add(self.btn1)
      vbox.add(self.btn2)
      vbox.add(self.lbl)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_checked(self, widget, data = None):
      state = "Button1 : "+str(self.btn1.get_active())+" 
         Button2 : "+str(self.btn2.get_active())
      self.lbl.set_text(state)
if __name__ == '__main__':
   PyApp()
   gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 單選按鈕類

單個RadioButton部件提供了類似於CheckButton的功能。但是，當同一個容器中存在多個單選按鈕時，使用者可以選擇其中一個可用選項，從而實現互斥選擇。如果容器中的每個單選按鈕都屬於同一個組，那麼當選中一個時，其他按鈕會自動取消選中。

以下是gtk.RadioButton類的建構函式：

gtk.RadioButton(group = None, Label = None, unerline = None)

為了建立一個按鈕組，對於第一個單選按鈕，提供group=None，對於後續選項，提供第一個按鈕的物件作為組。

與ToggleButton和CheckButton一樣，RadioButton也會發出toggled訊號。在下面給出的示例中，三個gtk.RadioButton部件的物件放置在一個VBox中。所有這些都連線到一個回撥函式on_selected()，以處理toggled訊號。

回撥函式識別源RadioButton部件的標籤並在VBox中放置的標籤上顯示它。

示例

觀察以下程式碼：

import gtk

class PyApp(gtk.Window):

   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Radio Button")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      vbox = gtk.VBox()
      
      btn1 = gtk.RadioButton(None, "Button 1")
      btn1.connect("toggled", self.on_selected)
      btn2 = gtk.RadioButton(btn1,"Button 2")
      btn2.connect("toggled", self.on_selected)
      btn3 = gtk.RadioButton(btn1,"Button 3")
      btn3.connect("toggled", self.on_selected)
      
      self.lbl = gtk.Label()
      vbox.add(btn1)
      vbox.add(btn2)
      vbox.add(btn3)
      vbox.add(self.lbl)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_selected(self, widget, data=None):
      self.lbl.set_text(widget.get_label()+" is selected")
if __name__ == '__main__':
   PyApp()
   gtk.main()

以上程式碼將生成以下輸出：

PyGTK - MenuBar、Menu和MenuItem

頂級gtk.Window標題欄正下方有一條水平條，用於顯示一系列選單。它是PyGTK API中gtk.MenuBar類的物件。

gtk.Menu類的物件被新增到選單欄中。它也用於建立上下文選單和彈出選單。每個選單可以包含一個或多個gtk.MenuItem部件。其中一些可以是子選單，並具有級聯的MenuItem按鈕。

gtk.MenuBar是gtk.MenuShell類的子類。它有一個簡單的預設建構函式：

gtk.MenuBar()

要將選單新增到MenuBar，使用MenuBar類的append()方法。

為了構建一個選單，建立一個帶有希望在選單欄中顯示的標籤的MenuItem部件，並將其設定為子選單。

例如，以下程式碼用於設定“檔案”選單：

menu1 = gtk.Menu()
file = gtk.MenuItem("_File")
file.set_submenu(menu1)

現在，可以在選單中新增一個或多個MenuItem類的部件。

item1 = gtk.MenuItem("New")
item2 = gtk.MenuItem("Open")

這些MenuItem被新增到Menu部件中，而選單物件依次被新增到選單欄中。

menu1.append(item1)
menu1.append(item2)
mb.append(menu1)

PyGTK工具包提供了許多型別的MenuItem部件。ImageMenuItem是一個與影像關聯的選單項。您可以使用Stock ID引數使用任何庫存影像，或者透過set_image()方法分配任何其他影像。

例如，以以下方式建立帶有影像的“新建”選單項：

new = gtk.ImageMenuItem(gtk.STOCK_NEW)
menu1.append(new)

類似地，也可以使用以下程式碼新增CheckMenuItem：

chk = gtk.CheckMenuItem("Checkable")
menu1.append(chk)

可以使用以下程式碼新增一組單選按鈕：

radio1 = gtk.RadioMenuItem(None,"Radio1")
radio2 = gtk.RadioMenuItem(radio1, "Radio2")
menu1.append(radio1)
menu1.append(radio2)

有時，您可能希望在選單項之間新增分隔線。為此，SeparatorMenuItem也可用。

sep = gtk.SeparatorMenuItem()
menu1.append(sep)

您還可以為選單項分配鍵盤快捷鍵。PyGTK有加速鍵。首先建立一個加速鍵組並將其附加到頂級視窗。

acgroup = gtk.AccelGroup()
self.add_accel_group(acgroup)

要分配快捷鍵，請使用add_accelerator()函式，其原型如下：

Item1.add_accelerator(signal, group, key, modifier, flags)

以下是一些預定義的修飾符：

• SHIFT_MASK
• LOCK_MASK
• CONTROL_MASK
• BUTTON1_MASK
• BUTTON1_MASK

為了將Ctrl+N快捷鍵分配給“新建”選單項，請使用以下語法：

new = gtk.ImageMenuItem(gtk.STOCK_NEW,acgroup)
new.add_accelerator("activate", acgroup, ord('N'), 
   gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)

示例

以下示例演示了上面討論的功能：

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      
      super(PyApp, self).__init__()
      self.set_title("Menu Demo")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      mb = gtk.MenuBar()
      
	  menu1 = gtk.Menu()
      file = gtk.MenuItem("_File")
      file.set_submenu(menu1)
      acgroup = gtk.AccelGroup()
      self.add_accel_group(acgroup)
      new = gtk.ImageMenuItem(gtk.STOCK_NEW,acgroup)
      new.add_accelerator("activate", acgroup, ord('N'), 
         gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
      
      menu1.append(new)
      open = gtk.ImageMenuItem(gtk.STOCK_OPEN)
      
      menu1.append(open)
      chk = gtk.CheckMenuItem("Checkable")
      
      menu1.append(chk)
      radio1 = gtk.RadioMenuItem(None,"Radio1")
      radio2 = gtk.RadioMenuItem(radio1, "Radio2")
      
      menu1.append(radio1)
      menu1.append(radio2)
      sep = gtk.SeparatorMenuItem()
      
      menu1.append(sep)
      exit = gtk.ImageMenuItem(gtk.STOCK_QUIT)
      
      menu1.append(exit)
      menu2 = gtk.Menu()
      edit = gtk.MenuItem("_Edit")
      edit.set_submenu(menu2)
      copy = gtk.ImageMenuItem(gtk.STOCK_COPY)
      
      menu2.append(copy)
      cut = gtk.ImageMenuItem(gtk.STOCK_CUT)
      
      menu2.append(cut)
      paste = gtk.ImageMenuItem(gtk.STOCK_PASTE)
      
      menu2.append(paste)
      mb.append(file)
      mb.append(edit)
      vbox = gtk.VBox(False, 2)
      vbox.pack_start(mb, False, False, 0)
      
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
if __name__ == '__main__':
   PyApp()
   gtk.main()

以上程式碼將產生以下輸出：

PyGTK - 工具欄類

Toolbar類繼承自gtk.Container類。它儲存並管理一組按鈕和其他部件。通常在頂級視窗的選單欄正下方可以看到一個或多個水平按鈕條。Toolbar也可以放在一個名為HandleBox的可分離視窗中。預設情況下，gtk.Toolbar部件中的按鈕水平排列。可以透過將orientation屬性設定為gtk.ORIENTATION_VERTICAL來設定垂直工具欄。

可以將工具欄配置為顯示帶圖示、文字或兩者的按鈕。樣式列舉器為：

使用以下建構函式設定Toolbar部件：

bar = gtk.Toolbar()

Toolbar的組成部分是gtk.ToolItem的例項。這些項可以是ToolButton、RadioToolButton、ToggleToolButton或SeparatorToolItem。為了將圖示分配給ToolItem物件，可以使用具有預定義stock_ID的影像，或者可以透過set_image()方法分配自定義影像。

以下示例顯示瞭如何構建不同的ToolItem：

ToolButton

newbtn = gtk.ToolButton(gtk.STOCK_NEW)

RadioToolButton

rb1 = gtk.RadioToolButton(None,gtk.STOCK_JUSTIFY_LEFT) 
rb2 = gtk.RadioToolButton(rb1,gtk.STOCK_JUSTIFY_RIGHT)

請注意，多個單選按鈕放在同一個組中。

SeparatorToolItem

sep = gtk.SeparatorToolItem()

透過呼叫其insert方法將這些項放入工具欄中。

gtk.Toolbar.insert(item, index)

例如，

bar.insert(new,0)

您還可以使用set_tooltip_text()方法為ToolButton分配工具提示。例如，新建工具提示分配給新建ToolButton。

newbtn.set_tooltip_text("New")

示例

以下程式碼顯示了一個頂級視窗，其中設定了一個工具欄，用於包含普通工具項、單選按鈕項和分隔符項。

import gtk

class PyApp(gtk.Window):

   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Toolbar Demo")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      toolbar = gtk.Toolbar()
      toolbar.set_style(gtk.TOOLBAR_ICONS)
      toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
      
      newbtn = gtk.ToolButton(gtk.STOCK_NEW)
      newbtn.set_tooltip_text("New")
      openbtn = gtk.ToolButton(gtk.STOCK_OPEN)
      savebtn = gtk.ToolButton(gtk.STOCK_SAVE)
      sep = gtk.SeparatorToolItem()
      
      rb1 = gtk.RadioToolButton(None,gtk.STOCK_JUSTIFY_LEFT)
      53
      rb2 = gtk.RadioToolButton(rb1,gtk.STOCK_JUSTIFY_RIGHT)
      
      prv = gtk.ToggleToolButton(gtk.STOCK_PRINT_PREVIEW)
      quitbtn = gtk.ToolButton(gtk.STOCK_QUIT)
      
      toolbar.insert(newbtn, 0)
      toolbar.insert(openbtn, 1)
      toolbar.insert(savebtn, 2)
      toolbar.insert(sep, 3)
      toolbar.insert(rb1,4)
      toolbar.insert(rb2,5)
      toolbar.insert(prv,6)
      toolbar.insert(quitbtn, 7)
      
      quitbtn.connect("clicked", gtk.main_quit)
      vbox = gtk.VBox(False, 2)
      vbox.pack_start(toolbar, False, False, 0)
      
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_checked(self, widget, data = None):
      state = "Button1 : "+str(self.btn1.get_active())+" 
         Button2 : "+str(self.btn2.get_active())
      self.lbl.set_text(state)
if __name__ == '__main__':
   PyApp()
   gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 調整類

PyGTK工具包中的一些部件，其屬性可以透過使用者使用滑鼠或鍵盤在指定範圍內調整。像Viewport這樣的部件用於顯示大型資料的一部分，例如，TextView控制元件中的多行文字。

PyGTK使用gtk.Adjustment物件與這些部件一起使用，以便將使用者調整傳遞給某些回撥函式進行處理。Adjustment物件包含可調整值的上下限及其增量步長引數。當調整物件的引數更改時，它會發出changed或value_changed訊號。

以下是gtk.Adjustment類的建構函式：

gtk.Adjustment(value = 0, lower = 0, upper = 0, step_incr = 0, 
   page_incr = 0, page_size = 0)

建構函式中每個屬性的含義如下：

Adjustment物件發出以下訊號：

如上所述，Adjustment物件不是物理部件。相反，它與其他部件一起使用，透過這些部件，其屬性會發生更改。範圍部件與Adjustment物件一起使用。

PyGTK - 範圍類

此類充當部件的基類，這些部件允許使用者在上下限之間調整數值引數的值。Scale部件（gtk.Hscale和gtk.Vscale）和Scrollbar部件（gtk.HScrollbar和gtk.VScrollbar）從Range類派生功能。這些Range部件與Adjustment物件一起工作。

gtk.Range類的以下重要函式由Scale和Scrollbar部件實現：

• set_update_policy() - 將“update-policy”屬性設定為該值。策略具有以下值：

• set_adjustment() - 設定“adjustment”屬性。Adjustment物件用作Range物件的模型。

• set_increments() - 設定範圍的步長和頁面大小。

• set_range() - 設定Range部件的最小和最大允許值

• set_value() - 將範圍的當前值設定為指定的值。

比例部件類 - （HScale和VScale）派生自gtk.Range類。

PyGTK - 刻度類

此類充當HScale和VScale部件的抽象基類。這些部件用作滑塊控制元件並選擇數值。

此抽象類的以下方法由HScale類和VScale類實現：

• set_digits() - 設定用於顯示部件瞬時值的十進位制位數。

• set_draw_value() - 設定為True，當前值將顯示在滑塊旁邊。

• set_value_pos() - 這是繪製值的位置。這可以是gtk.POS_LEFT、gtk.POS_RIGHT、gtk.POS_TOP或gtk.POS_BOTTOM。

gtk.HScale類的物件提供水平滑塊，而gtk.VScale類的物件提供垂直滑塊。這兩個類具有相同的建構函式：

gtk.HScale(Adjustment = None)
gtk.VScale(Adjustment = None)

調整物件包含許多屬性，這些屬性提供對值和邊界的訪問。

PyGTK - 捲軸類

此類是gtk.Hscrollbar和gtk.Vscrollbar部件的抽象基類。兩者都與Adjustment物件相關聯。捲軸的滑塊位置由滾動調整控制。調整物件的屬性按如下方式使用：

以下程式顯示了一個HScale和一個HScrollbar部件，它們放置在新增到頂級視窗的VBox中。它們每個都與一個調整物件相關聯。

adj1 = gtk.Adjustment(0, 0, 101, 0.1, 1, 1)
self.adj2 = gtk.Adjustment(10,0,101,5,1,1)

gtk.HScale部件是一個與adj1關聯的滑塊控制元件。其更新策略、繪製值的數目和位置設定如下：

scale1 = gtk.HScale(adj1)
scale1.set_update_policy(gtk.UPDATE_CONTINUOUS)
scale1.set_digits(1)
scale1.set_value_pos(gtk.POS_TOP)
scale1.set_draw_value(True)

gtk.HScrollbar提供水平捲軸。它與adj2物件相關聯。其更新策略也設定為CONTINUOUS。

self.bar1 = gtk.HScrollbar(self.adj2)
self.bar1.set_update_policy(gtk.UPDATE_CONTINUOUS)

為了顯示捲軸的瞬時值，調整物件—adj2的“value-changed”訊號連線到回撥函式on_scrolled()。該函式檢索調整物件的value屬性並在捲軸下方的標籤上顯示它。

self.adj2.connect("value_changed", self.on_scrolled)
   def on_scrolled(self, widget, data = None):
   self.lbl2.set_text("HScrollbar value: "+str(int(self.adj2.value)))

示例

觀察以下程式碼：

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Range widgets Demo")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      adj1 = gtk.Adjustment(0.0, 0.0, 101.0, 0.1, 1.0, 1.0)
      self.adj2 = gtk.Adjustment(10,0,101,5,1,1)
      
      scale1 = gtk.HScale(adj1)
      scale1.set_update_policy(gtk.UPDATE_CONTINUOUS)
      scale1.set_digits(1)
      scale1.set_value_pos(gtk.POS_TOP)
      scale1.set_draw_value(True)
      
      vb = gtk.VBox()
      vb.add(scale1)
      lbl1 = gtk.Label("HScale")
      
      vb.add(lbl1)
      self.bar1 = gtk.HScrollbar(self.adj2)
      self.bar1.set_update_policy(gtk.UPDATE_CONTINUOUS)
      vb.add(self.bar1)
      self.lbl2 = gtk.Label("HScrollbar value: ")
      
      vb.add(self.lbl2)
      self.adj2.connect("value_changed", self.on_scrolled)
      self.add(vb)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   
   def on_scrolled(self, widget, data=None):
      self.lbl2.set_text("HScrollbar value: "+str(int(self.adj2.value)))
if __name__ == '__main__':
   PyApp()
   gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 對話方塊類

Dialog部件通常用作父視窗頂部的彈出視窗。Dialog的目標是從使用者那裡收集一些資料並將其傳送到父視窗。Dialog可以是模態的（它會阻止父框架）或非模態的（可以繞過對話方塊框架）。

PyGTK庫的Dialog部件是一個垂直分割的視窗。在其頂部部分，有一個gtk.VBox，其中打包了Label或Entry部件。底部部分稱為action_area，其中放置了一個或多個按鈕。兩個區域由gtk.HSeparator分隔。

gtk.Dialog類具有以下建構函式：

dlg = gtk.Dialog (Title = None, parent = None, flags = 0, buttons = None)

其中，

• Title - 是顯示在Dialog部件標題欄中的文字。

• Parent - 是對Dialog從中彈出的頂級視窗的引用。

• Flag - 定義控制Dialog操作的常量。定義的常量為：

什麼是按鈕？

按鈕是一個元組物件，包含gtk.Button與庫存ID（或文字）及其響應ID的配對。

響應ID可以是任何數字或預定義的響應ID常量之一 -

• gtk.RESPONSE_NONE
• gtk.RESPONSE_REJECT
• gtk.RESPONSE_ACCEPT
• gtk.RESPONSE_DELETE_EVENT
• gtk.RESPONSE_OK
• gtk.RESPONSE_CANCEL
• gtk.RESPONSE_CLOSE
• gtk.RESPONSE_YES
• gtk.RESPONSE_NO
• gtk.RESPONSE_APPLY
• gtk.RESPONSE_HELP

gtk.Dialog類的重要方法如下所示 -

• add_button() - 在action_area中新增一個按鈕，該按鈕的文字由button_text指定（如果button_text是庫存ID，則為庫存按鈕）。

• response() - 發出“response”訊號，其值為response_id中指定的值。

• run() - 顯示對話方塊，並在delete_event發出時返回response_id。

• set_default_response() - 將對話方塊操作區域中的最後一個部件設定為具有指定response_id的對話方塊的預設部件。

gtk.Dialog部件發出以下訊號 -

對話方塊部件的action_area中的兩個按鈕使用庫存ID gtk.STOCK.CANCEL和gtk.STOCK_OK。它們分別與響應ID gtk.RESPONSE_REJECT和gtk.RESPONSE_ACCEPT關聯。當按下任何按鈕時，對話方塊就會關閉。run()方法返回相應的響應ID，該ID可用於進一步處理。

以下程式碼顯示一個頂級gtk.Window，其中包含一個按鈕。當按鈕被點選時，會出現一個帶有標籤和兩個按鈕的對話方塊。

示例

觀察以下程式碼：

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Dialog Demo")
      self.set_default_size(250, 200)
      fixed = gtk.Fixed()
      btn = gtk.Button("Show")
      btn.connect("clicked",self.show_sialog)
      fixed.put(btn,100,100)
      self.add(fixed)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
      
   def show_sialog(self, widget, data=None):
      dialog = gtk.Dialog("My dialog",
         self,
         gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
         (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
         gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
      label = gtk.Label("Simple dialog")
      dialog.vbox.add(label)
      label.show()
      res = dialog.run()
      print res
      dialog.destroy()
if __name__ == '__main__':
   PyApp()
   gtk.main()

以上程式碼產生以下輸出：

預配置對話方塊部件

PyGTK API有一系列預配置的對話方塊部件 -

• MessageDialog
• AboutDialog
• ColorSelectionDialog
• FontSelectionDialog
• FileChooserDialog

為了演示PyGTK中上述標準對話方塊的功能，在以下程式中，一個選單被放置在一個gtk.Window中，每個選單項都包含一個當被點選時會呼叫對話方塊的選單項。列出了響應每個選單項的啟用訊號的回撥函式。您還可以瞭解每個型別對話方塊部件的解釋。

示例

觀察以下程式碼：

import gtk, pango

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Dialog Boxes")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
      mb = gtk.MenuBar()
      menu1 = gtk.Menu()
      file = gtk.MenuItem("_File")
      file.set_submenu(menu1)
      msg = gtk.MenuItem("MessageDialog")
      
      menu1.append(msg)
      abt = gtk.MenuItem("AboutDialog")
      menu1.append(abt)
      colo = gtk.MenuItem("colorDialog")
      menu1.append(colo)
      font = gtk.MenuItem("FontSelectionDialog")
      menu1.append(font)
      fl = gtk.MenuItem("FileChooserDialog")
      menu1.append(fl)
      mb.append(file)
      
      vbox = gtk.VBox(False, 2)
      vbox.pack_start(mb, False, False, 0)
      self.add(vbox)
      self.text = gtk.Label("TutorialsPoint")
      vbox.pack_start(self.text, True, True, 0)
      msg.connect("activate",self.on_msgdlg)
      abt.connect("activate",self.on_abtdlg)
      font.connect("activate",self.on_fntdlg)
      colo.connect("activate",self.on_color)
      
      fl.connect("activate", self.on_file)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
   def on_msgdlg(self, widget):
      #MessageDialog usage code
   def on_abtdlg(self, widget):
      #AboutDialog usage code
   def on_fntdlg(self,widget):
      #FontSelectionDialog usage code
   def on_color(self, widget):
      #ColorChooserDialog usage cde
   Def on_file(self, widget):
      #FileChooserDialog usage code
if __name__ == '__main__':
   PyApp()
   gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 訊息對話方塊類

Messagedialog部件是一個對話方塊視窗，配置為顯示錶示訊息型別的影像，即錯誤、問題或一些資訊文字。MessageDialog物件透過使用以下建構函式宣告 -

gtk.MessageDialog(parent = None, flags = 0, type = gtk.MESSAGE_INFO, 
   buttons = gtk.BUTTONS_NONE, message_format = None)

以下預定義的訊息型別用於配置訊息對話方塊 -

一組預定義的按鈕集也可用於使用。

當MessageBox選單項被啟用時，以下回調函式被呼叫，並且訊息框作為輸出彈出。

def on_msgdlg(self, widget):
   md = gtk.MessageDialog(self,
      gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR,
      gtk.BUTTONS_CLOSE, "Error message")
   md.run()

上述函式將生成以下輸出 -

PyGTK - 關於對話方塊類

gtk.AboutDialog部件提供了一種簡單的方法來顯示有關程式的資訊，例如其徽標、名稱、版權、網站和許可證。當用戶從“幫助”選單中選擇“關於”選項時，通常會開啟關於對話方塊。對話方塊的所有部分都是可選的。

“關於對話方塊”可以包含URL和電子郵件地址。當用戶點選URL和電子郵件ID時，gtk.AboutDialog提供全域性掛鉤。

以下是gtk.AboutDialog類的建構函式 -

dlg = gtk.AboutDialog()

以下方法用於配置“關於對話方塊”。

• set_program_name() - 這將設定在“關於對話方塊”中顯示的名稱。預設為application_name()。

• set_version() - 這將設定“version”屬性。

• set_copyright() - 這將設定“copyright”。如果為None，則版權宣告將隱藏。

• set_license() - 這將設定“license”。如果為None，則許可證按鈕將隱藏。

• set_website() - 這將“website”屬性設定為應為有效URL的字串。

• set_author() - 這將“authors”屬性設定為在輔助信用對話方塊的作者選項卡中顯示的作者名稱列表。

• set_logo() - 這將“logo”屬性設定為Pixbuf物件。如果為None，則將使用預設視窗圖示集。

當AboutDialog選單按鈕被點選時，以下回調函式被呼叫。此函式生成“關於對話方塊” -

def on_abtdlg(self, widget):
   
   about = gtk.AboutDialog()
   about.set_program_name("PyGTK Dialog")
   about.set_version("0.1")
   about.set_authors("M.V.Lathkar")
   about.set_copyright("(c) TutorialsPoint")
   about.set_comments("About Dialog example")
   about.set_website("https://tutorialspoint.tw")
   
   about.run()
   about.destroy()

上述函式生成以下輸出 -

PyGTK - 字型選擇對話方塊

gtk.FontSelection部件允許使用者選擇和應用特定名稱、大小和樣式的字型。對話方塊有一個預覽框，其中包含一些將在所選字型描述中顯示的文字，以及兩個按鈕“取消”和“確定”。

PyGTK API包含一個Pango模組，該模組定義了呈現高質量國際化文字所需的類和功能。gtk中的字型和文字處理由Pango支援。pango.Font物件以系統無關的方式表示字型。pango.FontDescription物件包含字型的特徵。

gtk.FontSelectionDialog返回一個pango.Font物件。為了應用所選字型，透過從該物件獲取pango.FontDescription物件來獲取字型度量。

以下是FontSelectionDialog類的建構函式 -

dlg = gtk.FontSelectionDialog(title)

以下是此類的一些常用方法 -

• get_font_name() - 這返回一個包含當前所選字型名稱的字串，如果未選擇任何字型名稱，則返回None。

• set_font_name() - 這將設定當前字型。

• set_preview_text() - 這將設定預覽區域輸入中的文字。

使用modify_font()方法將所選字型應用於部件中的文字。

當FontSelectionDialog選單項被啟用時，以下回調函式被呼叫 -

def on_abtdlg(self, widget):
   about = gtk.AboutDialog()
   about.set_program_name("PyGTK Dialog")
   about.set_version("0.1")
   about.set_authors("M.V.Lathkar")
   about.set_copyright("(c) TutorialsPoint")
   about.set_comments("About Dialog example")
   about.set_website("https://tutorialspoint.tw")
   about.run()
   about.destroy()

所選字型應用於放置在頂級視窗上的標籤的文字。

以下是輸出 -

PyGTK - 顏色選擇對話方塊

這是PyGTK API中一個預配置的對話方塊，允許使用者選擇和應用顏色。它在內部嵌入了一個gtk.ColorSelection部件。

gtk.ColorScelection部件顯示一個顏色輪，以及顏色引數（如HSV和RGB）的輸入框。可以透過操作顏色輪或輸入顏色引數來選擇新顏色。它的get_current_color對於進一步處理很有用。

以下是gtk.ColorSelectionDialog類建構函式的原型 -

dlg = gtk.ColorSelectionDialog(title)

當前所選顏色從colorsel屬性中獲取。使用modify_fg()或modify_bg()方法將所選顏色應用於部件。

當ColorDialog選單按鈕被啟用時，以下回調函式被執行 -

def on_color(self, widget):
   dlg = gtk.ColorSelectionDialog("Select color")
   col = dlg.run()
   sel = dlg.colorsel.get_current_color()
   self.text.modify_fg(gtk.STATE_NORMAL, sel)

所選顏色應用於視窗上的標籤部件中的文字 -

以下是輸出 -

PyGTK - 檔案選擇對話方塊

此對話方塊用於讓使用者選擇需要開啟或儲存的檔案的位置和名稱。它嵌入FileChooserWidget並在action_area中提供“確定”和“取消”按鈕。

以下是gtk.FileChooserDialog類的建構函式 -

Dlg=gtk.FileChooserDialog (title = None, parent = None, 
   action = gtk.FILE_CHOOSER_ACTION_OPEN,  buttons = None, backend = None)

引數為 -

以下是操作模式 -

• gtk.FILE_CHOOSER_ACTION_OPEN
• gtk.FILE_CHOOSER_ACTION_SAVE
• gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER
• gtk.FILE_CHOOSER_ACTION_CREATE_FOLDER

如果希望限制要顯示的檔案型別，可以透過使用add_filter()方法應用gtk.FileFilter的物件。

如果FileChooserDialog選單按鈕被點選，以下回調函式將執行。

def on_file(self, widget):
   dlg = gtk.FileChooserDialog("Open..", None, gtk.FILE_CHOOSER_ACTION_OPEN,
      (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK))
   response = dlg.run()
   self.text.set_text(dlg.get_filename())
   dlg.destroy()

從對話方塊中選擇檔案 -

所選檔案顯示在頂級gtk.Window上的標籤上 -

PyGTK - 筆記本類

Notebook部件是一個選項卡式容器。此容器中的每個選項卡都包含一個不同的頁面，並且頁面以重疊的方式顯示。透過點選選項卡的標籤，可以使任何所需的頁面可見。標籤可以配置為顯示在頂部、底部或左側或右側。一個包含其他部件的容器部件或單個部件放置在每個頁面的下方。

如果要顯示的資料在一個檢視中太大，則將其分組到不同的頁面中，每個頁面都放置在Notebook部件的一個選項卡下。這種型別的控制元件被廣泛使用。例如，Internet瀏覽器使用此選項卡式顯示在不同的選項卡中呈現不同的頁面。

以下是gtk.Notebook類的建構函式 -

gtk.Notebook()

以下是gtk.Notebook類的常用方法 -

• append_page(child, label) - 這將一個頁面追加到筆記本中，該頁面包含一個由tab_label指定的部件作為選項卡上的標籤。如果tab_label可以為None，則使用預設標籤。

• insert_page(child, label, position) - 這將在position指定的位置將一個頁面插入到筆記本中。

• remove_page(index) - 這將刪除指定索引處的頁面。

• get_current_page() - 這將返回當前頁面的頁面索引。

• set_current_page(index) - 這將切換到索引指定的頁面編號。

• set_show_tabs() - 如果為false，則選項卡將不可見。預設情況下為True。

• set_tab_pos(pos) - 這將設定在筆記本中繪製用於切換頁面的選項卡的邊緣。預定義的常量為 -

  • gtk.POS_LEFT

  • gtk.POS_RIGHT

  • gtk.POS_TOP

  • gtk.POS_BOTTOM

• set_tab_label_text(child, text) - 這將建立一個具有指定文字的新標籤，並將其設定為包含child的頁面的選項卡標籤。

gtk.Notebook部件發出以下訊號 -

示例

在下面的示例中，一個包含三個頁面的 gtk.Notebook 被放置在一個頂級的 gtk.Window 中。第一個頁面包含一個 VBox，其中包含一個標籤和一個 Entry 欄位。第二個頁面標為“qualifications”，它有一個 HButtonBox，其中添加了三個互斥的 RadioButton 控制元件。第三個頁面有一個 TextView 物件。頁面標籤顯示在頂部。

觀察程式碼：

import gtk
class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Notebook Demo")
      self.set_default_size(250, 200)
		
      nb = gtk.Notebook()
      nb.set_tab_pos(gtk.POS_TOP)
      vbox = gtk.VBox(False, 5)
		
      vb = gtk.VBox()
      hbox = gtk.HBox(True, 3)
		
      valign = gtk.Alignment(0.5,0.25, 0, 0)
      lbl = gtk.Label("Name of student")
		
      vb.pack_start(lbl, True, True, 10)
      text = gtk.Entry()
		
      vb.pack_start(text, True, True, 10)
      valign.add(vb)
		
      vbox.pack_start(valign)
      nb.append_page(vbox)
      nb.set_tab_label_text(vbox, "Name")
      hb = gtk.HButtonBox()
		
      btn1 = gtk.RadioButton(None,"Degree")
      hb.add(btn1)
		
      btn2 = gtk.RadioButton(btn1,"P.G.")
      hb.add(btn2)
		
      btn3 = gtk.RadioButton(btn1,"Doctorate")
      hb.add(btn3)
		
      nb.append_page(hb)
      nb.set_tab_label_text(hb, "Qualification")
		
      tv = gtk.TextView()
      nb.append_page(tv)
      nb.set_tab_label_text(tv, "about")
		
      self.add(nb)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
if __name__ == '__main__':
   PyApp()
   gtk.main()

執行上述程式碼後，將顯示一個包含三個頁面的 Notebook -

PyGTK - 框架類

Frame 類是 gtk.Bin 類的子類。它在放置在其內部的子控制元件周圍繪製一個裝飾性邊框。框架可以包含一個標籤，其位置可以自定義。

可以使用以下建構函式構建 gtk.Frame 物件 -

frame = gtk.Frame(label = None)

以下是 gtk.Frame() 類的常用方法 -

• set_label(text) - 此方法設定標籤為 text 指定的文字。如果為 None，則移除當前標籤。

• set_label_widget() - 此方法設定除 gtk.Label 之外的其他控制元件作為框架的標籤。

• set_label_align(x, y) - 此方法設定框架標籤控制元件和裝飾的對其方式（預設值為 0.0 和 0.5）。

• set_shadow_type() - 此方法設定框架的陰影型別。

可能的值為 -

• gtk.SHADOW_NONE
• gtk.SHADOW_IN
• gtk.SHADOW_OUT
• gtk.SHADOW_ETCHED_IN
• tk.SHADOW_ETCHED_OUT

以下程式碼演示了 Frame 控制元件的功能。一組三個 gtk.RadioButton 物件被放置在一個 HButtonBox 中。

btn1 = gtk.RadioButton(None,"Degree")
btn2 = gtk.RadioButton(btn1,"P.G.")
btn3 = gtk.RadioButton(btn1,"Doctorate")
hb = gtk.HButtonBox()
hb.add(btn1)
hb.add(btn2)
hb.add(btn3)

為了在框周圍繪製邊框，將其放置在一個 Frame 控制元件中，並將其新增到頂級視窗。

frm = gtk.Frame()
frm.add(hb)
self.add(frm)

示例

觀察以下程式碼：

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Frame Demo")
      self.set_default_size(250, 200)
      self.set_border_width(5)
      frm = gtk.Frame()
      hb = gtk.HButtonBox()
      btn1 = gtk.RadioButton(None,"Degree")
      hb.add(btn1)
      btn2 = gtk.RadioButton(btn1,"P.G.")
      hb.add(btn2)
      btn3 = gtk.RadioButton(btn1,"Doctorate")
      hb.add(btn3)
      frm.add(hb)
      frm.set_label("Qualifications")
      self.add(frm)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

if __name__ == '__main__':
   PyApp()
   gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 帶縱橫比的框架類

gtk.AspectFrame 類是 Frame 類的子類。即使主視窗大小發生改變，此框架中的子控制元件也會始終保持其縱橫比（寬度和高度）。

gtk.AspectFrame 控制元件的 ratio 屬性確定控制元件的寬度：高度比。縱橫比為 0.5 表示寬度是高度的一半；縱橫比為 2.0 表示寬度是高度的兩倍。屬性“ratio”的預設值為 1.0。

以下語法用於 gtk.AspectFrame 類的建構函式 -

gtk.AspectFrame (label = None, xalign = 0.5, yalign = 0.5, ratio = 1.0, obey_child = True)

xalign 屬性確定子控制元件左側的水平空閒空間的比例。0.0 表示左側沒有空閒空間，1.0 表示左側所有空閒空間。

yalign 屬性確定子控制元件上方的垂直空閒空間的比例。0.0 表示上方沒有空閒空間，1.0 表示上方所有空閒空間。

如果 obey_child 屬性為 False，則保持框架的寬度與高度的比率。

obey_child 屬性確定是否忽略比率。預設值為 True。

以下程式碼與 Frame 類使用的程式碼類似。唯一的區別是 ButonBox 被放置在一個 AspectFrame 控制元件中。

frm = gtk.AspectFrame(label = None, xalign = 0.5, yalign = 0.5, 
   ratio = 5.0, obey_child = False)

注意 - obey_child 屬性設定為 False，因為即使視窗大小發生改變，也希望保持縱橫比。

示例

觀察以下程式碼：

import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Aspect Frame Demo")
      self.set_default_size(250, 200)
      self.set_border_width(5)
      frm = gtk.AspectFrame(label = None, xalign = 0.5, yalign = 0.5, 
         ratio = 5.0, obey_child = False)
      hb = gtk.HButtonBox()
      btn1 = gtk.RadioButton(None,"Degree")
      hb.add(btn1)
      btn2 = gtk.RadioButton(btn1,"P.G.")
      hb.add(btn2)
      btn3 = gtk.RadioButton(btn1,"Doctorate")
      hb.add(btn3)
      frm.add(hb)
      frm.set_label("Qualifications")
      self.add(frm)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
      
if __name__ == '__main__':
   PyApp()
   gtk.main()

上述程式碼將生成以下原始視窗和調整大小後的視窗 -

原始視窗

調整大小後的視窗

PyGTK - 樹形檢視類

Treeview 控制元件顯示實現 gtk.TreeModel 介面的模型的內容。PyGTK 提供以下型別的模型 -

• gtk.ListStore
• gtk.TreeStore
• gtk.TreeModelSort

ListStore 是一個列表模型。當與 gtk.TreeView 控制元件關聯時，它會生成一個列表框，其中包含要從中選擇的專案。gtk.ListStore 物件使用以下語法宣告 -

store = gtk.ListStore(column_type)

列表可以有多個列，預定義的型別常量為 -

• gobject.TYPE_BOOLEAN
• gobject.TYPE_BOXED
• gobject.TYPE_CHAR
• gobject.TYPE_DOUBLE
• gobject.TYPE_ENUM
• gobject.TYPE_FLOAT
• gobject.TYPE_INT
• gobject.TYPE_LONG
• gobject.TYPE_NONE
• gobject.TYPE_OBJECT
• gobject.TYPE_STRING
• gobject.TYPE_UCHAR
• gobject.TYPE_UINT
• gobject.TYPE_ULONG
• gtk.gdk.pixbuf 等。

例如，用於儲存字串專案的 ListStore 物件宣告如下 -

store = gtk.ListStore(gobject.TYPE_STRING

為了在儲存中新增專案，使用 append() 方法 -

store.append (["item 1"])

TreeStore 是多列 Tree 控制元件的模型。例如，以下語句建立了一個儲存，其中一列包含字串專案。

Store = gtk.TreeStore(gobject.TYPE_STRING)

為了在 TreeStore 中新增專案，使用 append() 方法。append() 方法有兩個引數，parent 和 row。要新增頂級專案，parent 為 None。

row1 = store.append(None, ['row1'])

需要重複此語句以新增多行。

為了新增子行，將頂級行作為 parent 引數傳遞給 append() 方法 -

childrow = store.append(row1, ['child1'])

需要重複此語句以新增多個子行。

現在，建立一個 TreeView 控制元件，並使用上述 TreeStore 物件作為模型。

treeview = gtk.TreeView(store)

現在我們必須建立 TreeViewColumn 來顯示儲存資料。gtk.TreeViewColumn 的物件使用 gtk.CelRenderer 管理標題和單元格。TreeViewColumn 物件使用以下建構函式建立 -

gtk.TreeViewColumn(title, cell_renderer,…)

除了標題和渲染器之外，它還接受零個或多個 attribute=column 對，以指定從哪個樹模型列檢索屬性的值。這些引數也可以使用下面給出的 TreeViewColumn 類的常用方法設定。

gtk.CellRenderer 是用於渲染不同型別資料的物件集的基類。派生類有 CellRendererText、CellRendererPixBuf 和 CellRendererToggle。

TreeViewColumn 類的以下常用方法用於配置其物件 -

• TreeViewColumn.pack_start(cell, expand = True) - 此方法將 CellRenderer 物件打包到列的開頭。如果 expand 引數設定為 True，則將列的整個分配空間分配給單元格。

• TreeViewColumn.add_attribute(cell, attribute, column) - 此方法將屬性對映新增到樹列中的列表中。column 是樹模型的列。

• TreeViewColumn.set_attributes() - 此方法使用 attribute = column 對設定renderer 的屬性位置。

• TreeViewColumn.set_visible() - 如果為 True，則樹檢視列可見。

• TreeViewColumn.set_title() - 此方法將“title”屬性設定為指定的值。

• TreeViewColumn.set_lickable() - 如果設定為 True，則標題可以獲取鍵盤焦點，並且可以單擊。

• TreeViewColumn.set_alignment(xalign) - 此方法將“alignment”屬性設定為xalign的值。

當用戶單擊treeviewcolumn標題按鈕時，會發出“clicked”訊號。

配置完 TreeViewColumn 物件後，使用 append_column() 方法將其新增到 TreeView 控制元件。

以下是 TreeView 類的常用方法 -

• TreevVew.set_model() - 此方法設定樹檢視的“model”屬性。如果樹檢視已經設定了模型，則此方法將在設定新模型之前將其移除。如果model為None，則它將取消設定舊模型。

• TreeView.set_header_clickable() - 如果設定為 True，則可以單擊列標題按鈕。

• TreeView.append_column() - 此方法將指定的TreeViewColumn追加到列列表。

• TreeView.remove_column() - 此方法從樹檢視中移除指定的列。

• TreeView.insert_column() - 此方法將指定的column插入到由position指定位置的樹檢視中。

TreeView 控制元件發出以下訊號 -

下面給出了 TreeView 控制元件的兩個示例。第一個示例使用 ListStore 生成一個簡單的 ListView。

這裡建立了一個 ListStore 物件，並將字串專案新增到其中。此 ListStore 物件用作 TreeView 物件的模型 -

store = gtk.ListStore(str)

treeView = gtk.TreeView()
treeView.set_model(store)

然後將 CellRendererText 新增到 TreeViewColumn 物件，並將該物件追加到 TreeView。

rendererText = gtk.CellRendererText()
column = gtk.TreeViewColumn("Name", rendererText, text = 0)
treeView.append_column(column)

透過將其新增到 Fixed 容器中，將 TreeView 物件放置在頂級視窗上。

示例1

觀察以下程式碼：

import pygtk
pygtk.require('2.0')
import gtk

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("TreeView with ListStore")
      self.set_default_size(250, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      store = gtk.ListStore(str)
      store.append (["PyQt"])
      store.append (["Tkinter"])
      store.append (["WxPython"])
      store.append (["PyGTK"])
      store.append (["PySide"])
      
      treeView = gtk.TreeView()
      treeView.set_model(store)
		
      rendererText = gtk.CellRendererText()
      column = gtk.TreeViewColumn("Python GUI Libraries", rendererText, text=0)
      treeView.append_column(column)
      
      fixed = gtk.Fixed()
      lbl = gtk.Label("select a GUI toolkit")
      fixed.put(lbl, 25,75)
      fixed.put(treeView, 125,15)
		
      lbl2 = gtk.Label("Your choice is:")
      fixed.put(lbl2, 25,175)
      self.label = gtk.Label("")
		
      fixed.put(self.label, 125,175)
      self.add(fixed)
      
      treeView.connect("row-activated", self.on_activated)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_activated(self, widget, row, col):
      
	  model = widget.get_model()
      text = model[row][0]
      self.label.set_text(text)
		
def main():
   gtk.main()
   return

if __name__ == "__main__":
   bcb = PyApp()
   main()

使用者選擇的專案顯示在視窗中的標籤上，因為on_activated 回撥函式被呼叫。

示例2

第二個示例從 TreeStore 構建一個分層 TreeView。此程式遵循構建儲存、將其設定為 TreeView 的模型、設計 TreeViewColumn 並將其追加到 TreeView 的相同順序。

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("TreeView with TreeStore")
      self.set_size_request(400,200)
      self.set_position(gtk.WIN_POS_CENTER)
      vbox = gtk.VBox(False, 5)
      
      # create a TreeStore with one string column to use as the model
      store = gtk.TreeStore(str)
      
      # add row
      row1 = store.append(None, ['JAVA'])
      
      #add child rows
      store.append(row1,['AWT'])
      store.append(row1,['Swing'])
      store.append(row1,['JSF'])
      
      # add another row
      row2 = store.append(None, ['Python'])
      store.append(row2,['PyQt'])
      store.append(row2,['WxPython'])
      store.append(row2,['PyGTK'])
      
      # create the TreeView using treestore
      treeview = gtk.TreeView(store)
      tvcolumn = gtk.TreeViewColumn('GUI Toolkits')
      treeview.append_column(tvcolumn)
		
      cell = gtk.CellRendererText()
      tvcolumn.pack_start(cell, True)
      tvcolumn.add_attribute(cell, 'text', 0)
      vbox.add(treeview)
		
      self.add(vbox)
      
	  self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

以下 TreeView 顯示為輸出 -

PyGTK - 分割窗格類

Paned 類是用於可以水平（gtk.Hpaned）或垂直（gtk.Vpaned）顯示兩個可調整窗格的控制元件的基類。使用 pack1() 和 pack2() 方法將子控制元件新增到窗格。

Paned 控制元件在兩個窗格之間繪製一個分隔線滑塊，並提供一個控制代碼來調整它們的相對寬度/高度。如果窗格內子控制元件的 resize 屬性設定為 True，則它將根據窗格的大小調整大小。

以下方法適用於 HPaned 和 VPaned 類 -

• Paned.add1(child) - 此方法將由child指定的控制元件新增到頂部或左側窗格。

• Paned.add2(child) - 此方法將由child指定的控制元件新增到底部或右側窗格。

• Paned.pack1(child, resize, shrink) - 此方法使用引數將由child指定的控制元件新增到頂部或左側窗格。如果resize為True，則當 Paned 控制元件大小發生改變時，child應調整大小。如果shrink為True，則child可以小於其最小尺寸請求。

• Paned.pack2(child, resize, shrink) - 此方法設定兩個窗格之間分隔線的位置。

兩種型別的 Paned 控制元件都發出以下訊號 -

示例

以下示例使用 gtk.Hpaned 控制元件。在左側窗格中，添加了一個 TreeView 控制元件，在右側窗格中，有一個 TextView 控制元件。當 TreeView 中的任何行被選中時，它將發出 row_activated 訊號，該訊號連線到回撥函式。on_activated()函式檢索行的文字並在文字視圖面板中顯示。

觀察程式碼：

import gtk, gobject

class PyApp(gtk.Window):
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("HPaned widget Demo")
      self.set_default_size(250, 200)
      vp = gtk.HPaned()
      sw = gtk.ScrolledWindow()
      sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) 
		
      tree = gtk.TreeView()
      languages = gtk.TreeViewColumn()
      languages.set_title("GUI Toolkits")
      cell = gtk.CellRendererText()
      languages.pack_start(cell, True)
      languages.add_attribute(cell, "text", 0)
      treestore = gtk.TreeStore(str)
      it = treestore.append(None, ["Python"])
		
      treestore.append(it, ["PyQt"])
      treestore.append(it, ["wxPython"])
      treestore.append(it, ["PyGTK"])
      treestore.append(it, ["Pydide"])
		
      it = treestore.append(None, ["Java"])
      treestore.append(it, ["AWT"])
      treestore.append(it, ["Swing"])
      treestore.append(it, ["JSF"])
      treestore.append(it, ["SWT"])
		
      tree.append_column(languages)
      tree.set_model(treestore)
		
      vp.add1(tree)
      self.tv = gtk.TextView()
      vp.add2(self.tv)
      vp.set_position(100)
      self.add(vp)
		
      tree.connect("row-activated", self.on_activated)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_activated(self, widget, row, col):
      model = widget.get_model()
      text = model[row][0]
      print text
		
      buffer = gtk.TextBuffer()
      buffer.set_text(text+" is selected")
      self.tv.set_buffer(buffer)

if __name__ == '__main__':
   PyApp()
   gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 狀態列類

通常位於視窗底部的通知區域稱為狀態列。可以在狀態列上顯示任何型別的狀態更改訊息。它還有一個用於調整其大小的控制柄。

gtk.Statusbar 控制元件維護一個訊息堆疊。因此，新訊息將顯示在當前訊息的頂部。如果彈出訊息，則先前訊息將再次可見。訊息的來源必須由 context_id 唯一標識。

以下是 gtk.Statusbar 控制元件的建構函式 -

bar = gtk.Statusbar()

以下是 gtk.Statusbar 類的常用方法 -

• Statusbar.push(context_id, text) - 此方法將新訊息推送到狀態列的堆疊。

• Statusbar.pop(context_id) - 此方法從狀態列的堆疊中移除具有指定context_id的頂部訊息。

Statusbar 控制元件會發出以下訊號：

以下示例演示了 Statusbar 的功能。頂級視窗包含一個具有兩行的 VBox。上行有一個 Fixed 控制元件，其中放置了一個標籤、一個 Entry 控制元件和一個按鈕。而在底行，添加了一個 gtk.Statusbar 控制元件。

為了向狀態列傳送訊息，需要獲取其 context_id。

id1 = self.bar.get_context_id("Statusbar")

Button 物件的“clicked”訊號透過回撥函式連線，透過該函式將訊息推送到狀態列。當在 Entry 控制元件內按下 Enter 鍵時，會發出“activate”訊號。此控制元件連線到另一個回撥函式。

btn.connect("clicked", self.on_clicked, id1)
txt.connect("activate", self.on_entered, id1)

這兩個回撥函式都使用push()方法在通知區域中顯示訊息。

示例

觀察以下程式碼：

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Statusbar demo")
      self.set_size_request(400,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox()
      fix = gtk.Fixed()
      lbl = gtk.Label("Enter name")
		
      fix.put(lbl, 175, 50)
      txt = gtk.Entry()
      fix.put(txt, 150, 100)
		
      btn = gtk.Button("ok")
      fix.put(btn, 200,150)
		
      vbox.add(fix)
      self.bar = gtk.Statusbar()
      vbox.pack_start(self.bar, True, False, 0)
		
      id1 = self.bar.get_context_id("Statusbar")
      btn.connect("clicked", self.on_clicked, id1)
      txt.connect("activate", self.on_entered, id1)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
      def on_clicked(self, widget, data=None):
         self.bar.push(data, "Button clicked
		
      def on_entered(self, widget, data):
         self.bar.push(data, "text entered")

PyApp()
gtk.main()

執行上述程式碼後，將顯示以下輸出：

嘗試在文字框中輸入內容並按 Enter 鍵，檢視狀態列中的“text entered”訊息。

PyGTK - 進度條類

進度條用於向用戶提供長時間執行程序的視覺指示。gtk.ProgressBar 控制元件可以在兩種模式下使用——百分比模式和活動模式。

如果可以準確地估計還有多少工作需要完成，則進度條可以使用百分比模式，使用者會看到一個遞增的條形，顯示已完成工作的百分比。另一方面，如果無法準確確定要完成的工作量，則進度條將使用活動模式，其中，條形透過顯示一個來回移動的塊來顯示活動。

以下建構函式初始化 gtk.ProgressBar 類的控制元件：

pb = gtk.ProgressBar()

gtk.ProgressBar 使用以下方法來管理功能：

• ProgressBar.pulse() - 輕微推動進度條以指示已取得一些進展，但您不知道取得了多少進展。此方法還會將進度條模式更改為“活動模式”，其中一個塊來回彈跳。

• ProgressBar.set_fraction(fraction) - 這會導致進度條“填充”由fraction指定的條形部分。fraction的值應介於 0.0 和 1.0 之間。

• ProgressBar.set_pulse_setup() - 這將進度條總長度的某個部分（由fraction指定）設定為每次呼叫pulse()方法時移動彈跳塊。

• ProgressBar.set_orientation() - 這設定進度條的方向。可以將其設定為以下常量之一：

  • gtk.PROGRESS_LEFT_TO_RIGHT

  • gtk.PROGRESS_RIGHT_TO_LEFT

  • gtk.PROGRESS_BOTTOM_TO_TOP

  • gtk.PROGRESS_TOP_TO_BOTTOM

在以下程式中，gtk.ProgressBar 控制元件在活動模式下使用。因此，set_fraction()方法將進度的初始位置設定為 0.0。

self.pb = gtk.ProgressBar()
self.pb.set_text("Progress")
self.pb.set_fraction(0.0)

為了在 100 毫秒後將進度增加 1%，聲明瞭一個計時器物件，並設定了一個回撥函式，以便每隔 100 毫秒呼叫一次，從而更新進度條。

self.timer = gobject.timeout_add (100, progress_timeout, self)

這裡，progress_timeout()是回撥函式。它將set_fraction()方法的引數增加 1%，並更新進度條中的文字以顯示完成的百分比。

def progress_timeout(pbobj):
   new_val = pbobj.pb.get_fraction() + 0.01
   pbobj.pb.set_fraction(new_val)
   pbobj.pb.set_text(str(new_val*100)+" % completed")
   return True

示例

觀察以下程式碼：

import gtk, gobject
   
def progress_timeout(pbobj):
   new_val = pbobj.pb.get_fraction() + 0.01
   pbobj.pb.set_fraction(new_val)
   pbobj.pb.set_text(str(new_val*100)+" % completed")
   return True

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Progressbar demo")
      self.set_size_request(300,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      fix = gtk.Fixed()
      self.pb = gtk.ProgressBar()
      self.pb.set_text("Progress")
      self.pb.set_fraction(0.0)
		
      fix.put(self.pb,80,100)
      self.add(fix)
      self.timer = gobject.timeout_add (100, progress_timeout, self)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
PyApp()
gtk.main()

以上程式碼將生成以下輸出：

要在活動模式下使用進度條，請將回調函式更改為以下內容並執行：

def progress_timeout(pbobj):
   pbobj.pb.pulse()
   return True

進度條內塊的來回移動將顯示活動的進度。

PyGTK - 視口類

如果控制元件的面積大於頂級視窗的面積，則它與一個 ViewPort 容器關聯。gtk.Viewport 控制元件提供調整功能，可在 ScrolledWindow 中使用。例如，Label 控制元件沒有任何調整。因此，它需要一個 Viewport。某些控制元件具有本機滾動支援。但是 Label 或 gtk.Table 控制元件沒有內建的滾動支援。因此，它們必須使用 Viewport。

ViewPort 類具有以下建構函式：

gtk.Viewport(hadj, vadj)

這裡，hadj和vadj是與視口關聯的調整物件。

gtk.ViewPort 類使用以下方法：

• Viewport.set_hadjustment() - 這設定“hadjustment”屬性。

• Viewport.set_vadjustment() - 這設定“vadjustment”屬性。

• Viewport.set_shadow_type() - 這將“shadow-type”屬性設定為type的值。type的值必須是以下之一：

  • gtk.SHADOW_NONE

  • gtk.SHADOW_IN

  • gtk.SHADOW_OUT

  • gtk.SHADOW_ETCHED_IN

  • gtk.SHADOW_ETCHED_OUT

當水平或垂直 gtk.Adjustment 物件之一或兩者發生更改時，gtk.Viewport 物件會發出 set-scroll-adjustments 訊號。

PyGTK - ScrolledWindow 類

建立滾動視窗是為了訪問面積大於父視窗的其他控制元件。某些控制元件（如 TreeView 和 TextView）具有本機滾動支援。對於其他控制元件（如 Label 或 Table），應提供 Viewport。

以下語法用於 gtk.ScrolledWindow 類的建構函式：

sw = gtk.ScrolledWindow(hadj, vadj)

以下是 gtk.ScrolledWindow 類的使用方法：

• ScrolledWindow.set_hadjustment() - 這將水平調整設定為 gtk.Adjustment 物件。

• ScrolledWindow.set_vadjustment() - 這將垂直調整設定為 gtk.Adjustment 物件。

• ScrolledWindow.set_Policy (hpolicy, vpolicy) - 這設定“hscrollbar_policy”和“vscrollbar_policy”屬性。使用以下預定義常量之一：

  • gtk.POLICY_ALWAYS - 捲軸始終存在。

  • gtk.POLICY_AUTOMATIC - 僅在需要時顯示捲軸，即內容大於視窗。

  • gtk.POLICY_NEVER - 捲軸從不顯示。

• ScrolledWindow.add_with_viewport(child) - 此方法用於將沒有本機滾動功能的控制元件（由 child 指定）新增到滾動視窗。這是一個便捷函式，等效於將child新增到gtk.Viewport，然後將視口新增到滾動視窗。

以下程式碼在大小為 10x10 的 gtk.Table 物件周圍添加了一個滾動視窗。由於 Table 物件不會自動支援調整，因此將其新增到 Viewport 中。

sw = gtk.ScrolledWindow()
table = gtk.Table(10,10)

使用兩個巢狀迴圈新增 10 行 10 列。在每個單元格中放置一個 gtk.Button 控制元件。

for i in range(1,11):
   for j in range(1,11):
      caption = "Btn"+str(j)+str(i)
      btn = gtk.Button(caption)
      table.attach(btn, i, i+1, j, j+1)

現在，將這個足夠大的表格與視口一起新增到滾動視窗中。

sw.add_with_viewport(table)

示例

觀察以下程式碼：

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("ScrolledWindow and Viewport")
      self.set_size_request(400,300)
      self.set_position(gtk.WIN_POS_CENTER)
      sw = gtk.ScrolledWindow()
      table = gtk.Table(10,10)
      table.set_row_spacings(10)
      table.set_col_spacings(10)
      for i in range(1,11):
         for j in range(1,11):
            caption = "Btn"+str(j)+str(i)
            btn = gtk.Button(caption)
            table.attach(btn, i, i+1, j, j+1)
      sw.add_with_viewport(table)
      self.add(sw)
      
	  self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 箭頭類

gtk.Arrow 物件用於繪製指向四個基點方向的簡單箭頭。此類繼承自gtk.Misc類，並且該物件將佔據分配給它的任何空間，例如 Label 或 Button 控制元件。

通常，使用以下建構函式建立 Arrow 物件：

Arr = gtk.Arrow(arrow_type, shadow_type)

預定義的 arrow_type 常量為：

• gtk.ARROW_UP
• gtk.ARROW_DOWN
• gtk.ARROW_LEFT
• gtk.ARROW_RIGHT

預定義的 shadow_type 常量列在下表中：

示例

在以下示例中，四個 Button 控制元件被新增到 Hbox 中。在每個按鈕的頂部，分別放置了一個指向 UP、DOWN、LEFT 和 RIGHT 的 gtk.Arrow 物件。藉助 Alignment 容器，將 HBOX 容器放置在頂級視窗的底部。

觀察程式碼：

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Arrow Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      hbox = gtk.HBox(True, 3)
      valign = gtk.Alignment(0, 1, 0, 0)
      vbox.pack_start(valign)
		
      arr1 = gtk.Arrow(gtk.ARROW_UP, gtk.SHADOW_NONE)
      arr2 = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_NONE)
      arr3 = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE)
      arr4 = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE)
		
      btn1 = gtk.Button()
      btn1.add(arr1)
      btn2 = gtk.Button()
      btn2.add(arr2)
      btn3 = gtk.Button()
      btn3.add(arr3)
      btn4 = gtk.Button()
      btn4.add(arr4)
		
      hbox.add(btn1)
      hbox.add(btn2)
      hbox.add(btn3)
      hbox.add(btn4)
		
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, True, 10)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 圖片類

此類也繼承自 gtk.Misc 類。gtk.Image 類的物件顯示影像。通常，影像需要從檔案中載入到表示 gtk.gdk.Pixbuf 類的畫素緩衝區中。相反，通常使用便捷函式set_from_file()從檔案中顯示 gk.Image 控制元件中的影像資料。

建立 gtk.Image 物件最簡單的方法是使用以下建構函式：

img = gtk.Image()

以下是 gtk.Image 類的使用方法：

• Image.set_from_file() - 從檔案內容設定影像資料。

• Image.set_from_pixbuf() - 從pixmap設定影像資料，其中載入影像資料以進行離屏操作。

• Image.set_from_pixbuf() - 使用pixbuf設定影像資料，pixbuf是一個物件，包含使用客戶端資源描述影像的資料。

• Image.set_from_stock() - 從由stock_id標識的庫存項設定影像資料。

• Image.clear() - 刪除當前影像。

• Image.set_from_image() - 從當前顯示的畫素格式的客戶端影像緩衝區設定影像資料。如果影像為None，則將刪除當前影像資料。

示例

在以下程式中，從影像檔案獲取 gtk.Image 物件。它進一步新增到頂級視窗中。

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("PyGtk Image demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      
	  image1 = gtk.Image()
      image1.set_from_file("python.png")
      self.add(image1)
      
	  self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 繪圖區域類

DrawingArea 控制元件提供了一個空白畫布，其中包含一個 gtk.gdk.Window，可以在其上繪製線、矩形、弧等物件。

PyGTK 使用 Cairo 庫執行此類繪圖操作。Cairo 是一個流行的 2D 向量圖形庫。它是用 C 編寫的，儘管它在大多數語言（如 C++、Java、Python、PHP 等）中都有繫結。Cairo 庫可用於在各種作業系統的標準輸出裝置上繪圖。它還可以用於建立 PDF、SVG 和 PostScript 檔案。

為了執行不同的繪圖操作，我們必須獲取目標輸出物件的文字上的裝置。在本例中，由於繪圖出現在 gtk.DrawingArea 控制元件上，因此獲取了其中包含的 gdk.Window 的裝置上下文。此類具有cairo-create()方法，該方法返回裝置上下文。

area = gtk.DrawingArea()
dc = area.window.cairo_create()

DrawingArea 控制元件可以連線到基於其發出的以下訊號的回撥函式：

滑鼠和鍵盤事件也可以用於透過gtk.Widget 類的add_events()方法呼叫回撥函式。

特別需要注意的是 expose-event 訊號，當 DrawingArea 畫布首次出現時會發出此訊號。從連線到 expose-event 訊號的此回撥函式中呼叫在 Cairo 庫中定義的不同 2D 物件繪圖方法。這些方法在 Cairo 裝置上下文中繪製相應的物件。

以下是可以使用的繪圖方法：

• dc.rectangle(x,y,w,h) - 在指定的左上角座標處繪製一個矩形，並具有給定的寬度和高度。

• dc.arc(x,y,r,a1,a2) - 使用給定的半徑和兩個角度繪製一個圓弧。

• dc.line(x1, y1, x2, y2) - 在兩對座標之間繪製一條線。

• dc.line_to(x,y) - 從當前位置到 (x,y) 繪製一條線。

• dc.show_text(str) - 在當前游標位置繪製字串。

• dc.stroke() - 繪製輪廓。

• dc.fill() - 使用當前顏色填充形狀。

• dc.set_color_rgb(r,g,b) - 將顏色設定為輪廓並使用介於 0.0 到 1.0 之間的 r、g 和 b 值填充。

示例

以下指令碼使用 Cairo 方法繪製不同的形狀和測試。

import gtk
import math

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Basic shapes using Cairo")
      self.set_size_request(400, 250)
      self.set_position(gtk.WIN_POS_CENTER)
      
	  self.connect("destroy", gtk.main_quit)
		
      darea = gtk.DrawingArea()
      darea.connect("expose-event", self.expose)
		
      self.add(darea)
      self.show_all()
		
      def expose(self, widget, event):
      cr = widget.window.cairo_create()
		
      cr.set_line_width(2)
      cr.set_source_rgb(0,0,1)
      cr.rectangle(10,10,100,100)
      cr.stroke()
		
      cr.set_source_rgb(1,0,0)
      cr.rectangle(10,125,100,100)
      cr.stroke()
		
      cr.set_source_rgb(0,1,0)
      cr.rectangle(125,10,100,100)
      cr.fill()
		
      cr.set_source_rgb(0.5,0.6,0.7)
      cr.rectangle(125,125,100,100)
      cr.fill()
		
      cr.arc(300, 50, 50,0, 2*math.pi)
      cr.set_source_rgb(0.2,0.2,0.2)
      cr.fill()
		
      cr.arc(300, 200, 50, math.pi,0)
      cr.set_source_rgb(0.1,0.1,0.1)
      cr.stroke()
		
      cr.move_to(50,240)
      cr.show_text("Hello PyGTK")
      cr.move_to(150,240)
      cr.line_to(400,240)
      cr.stroke()

PyApp()
gtk.main() 

上述指令碼將生成以下輸出：

PyGTK - 旋轉按鈕類

SpinButton 控制元件，通常稱為 Spinner，是一個 gtk.Entry 控制元件，其右側帶有向上和向下的箭頭。使用者可以直接在其中鍵入數值，或者使用向上和向下的箭頭進行增減。gtk.SpinButton 類繼承自 gtk.Entry 類。它使用一個 gtk.Adjustment 物件，透過該物件可以限制微調器中數值的範圍和步長。

SpinButton 控制元件使用以下建構函式建立：

sp = gtk.SpinButton(adj, climb_rate, digits)

其中，adj 表示**控制範圍的 gtk.Adjustment 物件**，**climb_rate** 是一個加速因子，digits 指定的小數位數。

gtk.SpinButton 類具有以下方法：

• SpinButton.set_adjustment() - 設定“adjustment”屬性。

• SpinButton.set_digits() - 將“digits”屬性設定為一個值，以確定微調器顯示的小數位數。

• SpinButton.set_increments(step, page) - 設定步長值，每次左鍵單擊時應用步長增量；設定頁面值，每次中鍵單擊時應用頁面增量。

• SpinButton.set_range() - 設定微調器的最小和最大允許值。

• SpinButton.set_value() - 以程式設計方式將微調器設定為新值。

• SpinButton.update_policy() - 有效值為 gtk.UPDATE_ALWAYS 和 gtk.UPDATE_VALID

• SpinButton.spin(direction, increment=1) - 在指定的方向上增加或減少微調器的值。

以下是預定義的方向常量：

• SpinButton.set_wrap() — 如果 wrap 為 True，則當範圍的上限或下限超出時，微調器的值將環繞到相對的限制。

gtk.SpinButton 控制元件發出以下訊號：

示例

以下示例使用三個 SpinButton 控制元件構建一個簡單的**日期選擇器**。日期選擇器應用了一個 Adjustment 物件，以將值限制在 1 到 31 之間。第二個選擇器用於月份數 1 到 12。第三個選擇器選擇年份範圍 2000 到 2020。

觀察程式碼：

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("SpinButton Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
      self.set_border_width(20)
		
      vbox = gtk.VBox(False, 5)
      hbox = gtk.HBox(True, 3)
      lbl1 = gtk.Label("Date")
      hbox.add(lbl1)
		
      adj1 = gtk.Adjustment(1.0, 1.0, 31.0, 1.0, 5.0, 0.0)
      spin1 = gtk.SpinButton(adj1, 0, 0)
      spin1.set_wrap(True)
		
      hbox.add(spin1)
      lbl2 = gtk.Label("Month")
      hbox.add(lbl2)
		
      adj2 = gtk.Adjustment(1.0, 1.0, 12.0, 1.0, 5.0, 0.0)
      spin2 = gtk.SpinButton(adj2, 0, 0)
      spin2.set_wrap(True)
		
      hbox.add(spin2)
      lbl3 = gtk.Label("Year")
      hbox.add(lbl3)
		
      adj3 = gtk.Adjustment(1.0, 2000.0, 2020.0, 1.0, 5.0, 0.0)
      spin3 = gtk.SpinButton(adj3, 0, 0)
      spin3.set_wrap(True)
      hbox.add(spin3)
		
      frame = gtk.Frame()
      frame.add(hbox)
      frame.set_label("Date of Birth")
		
      vbox.add(frame)
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
PyApp()
gtk.main()

執行上述程式碼後，將生成以下輸出：

PyGTK - 日曆類

PyGTK 工具包中的 Calendar 控制元件顯示一個簡單的日曆，每次顯示一個月的檢視。預設情況下顯示用於更改月份和年份的導航控制元件。可以適當地配置顯示選項。

month 屬性的值介於 0 到 11 之間，date 屬性的值介於 1 到 31 之間。

有一個簡單的建構函式來建立 gtk.Calendar 物件：

cal = gtk.Calendar()

預設顯示樣式顯示當前月份和年份以及日期名稱。

gtk.Calendar 類具有以下方法：

• Calendar.select_month(mm,yy) — 將日曆顯示更改為指定的**mm** 和**yy**。

• Calendar.select_day(dd) — 當**dd** 的值在 1 到 31 之間時，在日曆上選擇指定的**dd**。如果**dd** 為 0，則刪除當前日期選擇。

• Calendar.display_options() — 將日曆顯示選項設定為**flags** 指定的值。可能的顯示選項是以下選項的組合：

• Calendar.get_date() — 將日曆的當前年份、月份和選定的日期數字作為元組 (year, month, day) 檢索。

gtk.Calendar 控制元件發出以下訊號：

在以下示例中，gtk.Calendar 控制元件和四個按鈕放置在頂級視窗中。

當單擊“標題”按鈕時，日曆的顯示選項將設定為 SHOW_HEADING：

def heading(self, widget):
   self.cal.set_display_options(gtk.CALENDAR_SHOW_HEADING)

當用戶單擊“日期名稱”按鈕時，回撥將顯示選項設定為 SHOW_DAY_NAMES：

def dayname(self, widget):
self.cal.set_display_options(gtk.CALENDAR_SHOW_DAY_NAMES)

當按下“兩者”按鈕時，兩個顯示選項都將啟用。首先，透過將其設定為 0 來刪除顯示選項的所有標誌。

self.cal.set_display_options(0)

“設定”按鈕彈出一個訊息框，顯示當前標記的日期。

tp = self.cal.get_date()
str1 = str(tp[0])
str2 = str(tp[1]+1)
str3 = str(tp[2])
label = gtk.Label("Date selected:"+str3+"-"+str2+"-"+str1)
dialog.vbox.add(label)
label.show()

示例

觀察以下程式碼：

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Calendar Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      self.cal = gtk.Calendar()
      halign1 = gtk.Alignment(0.5, 0.5, 0, 0)
      halign1.add(self.cal)
		
      self.cal.set_display_options(0)
      valign = gtk.Alignment(0, 1, 0, 0)
      vbox.pack_start(halign1)
		
      self.btn1 = gtk.Button("set")
      self.btn2 = gtk.Button("heading")
      self.btn3 = gtk.Button("day name")
      self.btn4 = gtk.Button("Both")
		
      hbox = gtk.HBox(True, 3)
      hbox.add(self.btn1)
      hbox.add(self.btn2)
      hbox.add(self.btn3)
      hbox.add(self.btn4)
		
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, True, 10)
      self.add(vbox)
		
      self.btn1.connect("clicked", self.selectdate)
      self.btn2.connect("clicked", self.heading)
      self.btn3.connect("clicked", self.dayname)
      self.btn4.connect("clicked", self.bothflags)
		
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def heading(self, widget):
      self.cal.set_display_options(gtk.CALENDAR_SHOW_HEADING)
		
   def dayname(self, widget):
      self.cal.set_display_options(gtk.CALENDAR_SHOW_DAY_NAMES)
		
   def bothflags(self, widget):
      self.cal.set_display_options(gtk.CALENDAR_SHOW_HEADING|gtk.CALENDAR_SHOW_DAY_NAMES)
   def selectdate(self, widget):
      tp = self.cal.get_date()
      dialog = gtk.Dialog("My dialog",
      self,
      gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
      (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
		
      str1 = str(tp[0])
      str2 = str(tp[1]+1)
      str3 = str(tp[2])
		
      label = gtk.Label("Date selected:"+str3+"-"+str2+"-"+str1)
      dialog.vbox.add(label)
      label.show()
      res = dialog.run()
      dialog.destroy()

PyApp()
gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 剪貼簿類

剪貼簿物件儲存兩個程序或同一應用程式的兩個控制元件之間共享的資料。gtk.Clipboard 是 gtk.SelectionData 類的更高級別的介面。

以下是 gtk.Clipboard 建構函式的原型：

gtk.Clipboard(display,selction)

此處，display 引數對應於要為其建立或檢索剪貼簿的 gtk.gdk.Display 物件。預設情況下，它是標準輸出裝置。selection 引數預設為 CLIPBOARD，一個表示內部字串的物件。

PyGTK 提供了一個方便的函式來建立具有預設值的剪貼簿物件。

gtk.clipboard.get()

gtk.Clipboard 類具有以下方法：

• Clipboard.store() - 將當前剪貼簿資料儲存在某個位置，以便即使在應用程式退出後也能保留。

• Clipboard.clear() - 刪除剪貼簿的內容。

• Clipboard.set_text(text) - 將剪貼簿的內容設定為字串。

• Clipboard.request_text() - 將剪貼簿的內容請求為文字。稍後收到文字時，將使用**user_data** 指定的資料呼叫**callback**。**callback** 的簽名為

  • def callback(clipboard, text, data) - text 將包含從剪貼簿檢索的**text**。

為了演示剪貼簿，以下程式碼在頂級 gtk.Window 上使用兩個 TextView 和兩個按鈕。“設定”按鈕呼叫**on_set()** 函式，該函式將第一個 textView 中的文字放入剪貼簿。

buf = self.tv1.get_buffer()
text = buf.get_text(buf.get_start_iter(), buf.get_end_iter())
self.clipboard = gtk.clipboard_get()
self.clipboard.set_text(text)
self.clipboard.store()

當按下第二個按鈕（“檢索”）時，將透過 request_text() 方法獲取剪貼簿中的資料：

self.clipboard.request_text(self.readclipboard,        user_data = None)

**user_data** 的內容將傳遞給回撥方法**readclipboard()**，該方法將其顯示在第二個 textview 上。

def readclipboard(self, clipboard, text, data):
   buffer = gtk.TextBuffer()
   buffer.set_text(text)
   self.tv2.set_buffer(buffer)

示例

以下是剪貼簿操作的完整程式碼：

import gtk

class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Clipboard demo")
      self.set_size_request(300,200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      self.tv1 = gtk.TextView()
		
      vbox.add(self.tv1)
      self.tv2 = gtk.TextView()
		
      vbox.add(self.tv2)
      hbox = gtk.HBox(True, 3)
		
      Set = gtk.Button("set")
      Set.set_size_request(70, 30)
		
      retrieve = gtk.Button("retrieve")
      hbox.add(Set)
      hbox.add(retrieve)
      halign = gtk.Alignment(1, 0, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, False, 3)
      self.add(vbox)
      Set.connect("clicked", self.on_set)
      retrieve.connect("clicked", self.on_retrieve)
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_set(self, widget):
      buf = self.tv1.get_buffer()
      text = buf.get_text(buf.get_start_iter(), buf.get_end_iter())
      self.clipboard = gtk.clipboard_get()
      self.clipboard.set_text(text)
      self.clipboard.store()
		
   def on_retrieve(self, widget):
      self.clipboard.request_text(self.readclipboard, user_data=None)
		
   def readclipboard(self, clipboard, text, data):
      buffer = gtk.TextBuffer()
      buffer.set_text(text)
      self.tv2.set_buffer(buffer)

PyApp()
gtk.main()

以上程式碼將生成以下輸出：

PyGTK - 標尺類

這是水平（gtk.Hruler）和垂直（gtk.Vruler）標尺的基類，用於顯示滑鼠指標在視窗中的位置。標尺中的一個小三角形指示指標的位置。

標尺物件使用各自的建構函式建立：

hrule = gtk.Hruler()
vrule = gtk.Vruler()

以下 gtk.Ruler 類方法可用於兩個派生類：

• Ruler.set_metric() - 設定測量單位。預定義的度量常量為：gtk.PIXELS（預設）、gtk.INCHES 和 gtk.CENTIMETERS

• Ruler.set_range() - 設定標尺的下限和上限、位置和最大尺寸。

在下面給出的示例中，水平和垂直標尺分別放置在 gtk.TextView 控制元件的上方和左側。

水平標尺的測量單位為畫素。其最小值和最大值分別為 0 和 400。它放置在 gtk.VBox 的頂行。

hrule = gtk.HRuler()
hrule.set_metric(gtk.PIXELS)
hrule.set_range(0, 4,0,0.5)
vbox.pack_start(hrule)

Vbox 的底行包含一個 HBox。其中打包了一個垂直標尺和一個 TextView 控制元件，使用者可以在其中輸入多行文字。

vrule=gtk.VRuler()
vrule.set_metric(gtk.PIXELS)
vrule.set_range(0, 4, 10, 0.5)
hbox.pack_start(vrule)

示例

觀察以下程式碼：

import gtk
class PyApp(gtk.Window):
   
   def __init__(self):
      super(PyApp, self).__init__()
      
	  self.set_title("Ruler demo")
      self.set_size_request(400,400)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox()
      tv = gtk.TextView()
      tv.set_size_request(350,350)
		
      hrule = gtk.HRuler()
      hrule.set_metric(gtk.PIXELS)
      hrule.set_range(0, 4,0,0.5)
		
      vbox.pack_start(hrule)
      hbox = gtk.HBox()
      vrule = gtk.VRuler()
		
      vrule.set_metric(gtk.PIXELS)
      vrule.set_range(0, 4, 10, 0.5)
		
      hbox.pack_start(vrule)
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(tv)
		
      hbox.pack_start(halign, False, True, 10)
      vbox.add(hbox)
		
      self.add(vbox)
      self.connect("destroy", gtk.main_quit)
      self.show_all()

PyApp()
gtk.main()

上述程式生成的輸出類似於 MS Word 文件：

PyGTK - 超時

PyGTK API 的 gobject 模組有一個有用的函式，用於建立將定期呼叫的超時函式。

source_id = gobject.timeout_add(interval, function, …)

第二個引數是要在第一個引數（間隔）的值（毫秒）後每次呼叫回撥函式。可以將其他引數作為函式資料傳遞給回撥函式。

此函式的返回值為**source_id**。使用它，可以停止回撥函式的呼叫。

gobject.source_remove(source_id)

回撥函式必須返回 True 以保持重複呼叫。因此，可以透過返回 False 來停止它。

在以下程式中，兩個按鈕和兩個標籤放置在頂級視窗上。一個標籤顯示遞增的數字。btn1 呼叫**on_click**，它設定超時函式，間隔為 1000 毫秒（1 秒）。

btn1.connect("clicked", self.on_click)

def on_click(self, widget):
   self.source_id = gobject.timeout_add(1000, counter, self)

超時函式名為**counter()**。它每隔 1 秒在標籤上遞增數字。

def counter(timer):
   c=timer.count+1
   print c
   timer.count=c
   timer.lbl.set_label(str(c))
   return True

第二個按鈕上的回撥刪除超時函式。

btn2.connect("clicked", self.on_stop)
def on_stop(self, widget):
gobject.source_remove(self.source_id)

示例

以下是超時示例的完整程式碼：

import gtk, gobject

def counter(timer):
      c = timer.count+1
      print c
      timer.count = c
      timer.lbl.set_label(str(c))
      return True
      class PyApp(gtk.Window):
		
   def __init__(self):
      super(PyApp, self).__init__()
      self.set_title("Timeout Demo")
      self.set_size_request(300, 200)
      self.set_position(gtk.WIN_POS_CENTER)
		
      vbox = gtk.VBox(False, 5)
      hbox = gtk.HBox(True, 3)
		
      hb = gtk.HBox()
      lbl1 = gtk.Label("Counter: ")
		
      hb.add(lbl1)
      self.lbl = gtk.Label("")
      hb.add(self.lbl)
      valign = gtk.Alignment(0.5, 0.5, 0, 0)
      valign.add(hb)
      vbox.pack_start(valign, True, True, 10)
		
      btn1 = gtk.Button("start")
      btn2 = gtk.Button("stop")
		
      self.count = 0
      self.source_id = 0
		
      hbox.add(btn1)
      hbox.add(btn2)
		
      halign = gtk.Alignment(0.5, 0.5, 0, 0)
      halign.add(hbox)
		
      vbox.pack_start(halign, False, True, 10)
      self.add(vbox)
		
      btn1.connect("clicked", self.on_click)
      btn2.connect("clicked", self.on_stop)
		
      self.connect("destroy", gtk.main_quit)
      self.show_all()
		
   def on_click(self, widget):
      self.source_id = gobject.timeout_add(1000, counter, self)
		
   def on_stop(self, widget):
      gobject.source_remove(self.source_id)

PyApp()
gtk.main()

執行時，視窗底部顯示兩個按鈕。當單擊“開始”按鈕時，標籤上的數字將定期遞增，當單擊“停止”按鈕時，它將停止遞增。

觀察輸出：

PyGTK - 拖放

具有關聯 X 視窗的小部件能夠進行拖放。在程式中，必須首先指定一個作為拖放源和/或目標的小部件。定義為源的小部件可以傳送拖動的資料。當拖動的資料被拖放到目標小部件上時，目標小部件會接受它。

設定啟用拖放的應用程式涉及以下步驟：

**步驟 1** - 設定源小部件。

**步驟 2** - drag_source_set() 方法指定拖動操作的目標型別：

widget.drag_source_set(start_button_mask, targets, info)

**步驟 3** - start_button_mask 引數指定啟動拖動操作的按鈕位掩碼。

**步驟 4** - target 引數是此結構的元組列表：

(target, flags, info)

target 引數是一個字串，表示拖動型別，例如，text/plain 或 image/x-xpixmap。

**步驟 6** - 以下標誌是預定義的：

• gtk.TARGET_SAME_APP
• gtk.TARGET_SAME_WIDGET

**步驟 7** - 由於標誌設定為 0，因此沒有限制。

如果小部件不需要充當源，則可以取消設定：

widget.drag_source_unset()

源訊號發出訊號。下表列出了訊號及其回撥。

設定目標部件

drag_dest_set() 方法指定哪個部件可以接收拖放的資料。

widget.drag_dest_set(flags, targets, action)

flags 引數可以取以下常量之一：

目標是一個包含目標資訊的元組列表。actions 引數是以下值之一或多個的按位或組合：

• gtk.gdk.ACTION_DEFAULT
• gtk.gdk.ACTION_COPY
• gtk.gdk.ACTION_MOVE
• gtk.gdk.ACTION_LINK
• gtk.gdk.ACTION_PRIVATE
• gtk.gdk.ACTION_ASK

"drag-motion" 處理程式必須透過將目標部件的目標與gtk.gdk.DragContext的目標進行匹配，並可選地透過呼叫drag_get_data()方法檢查拖放資料來確定拖放資料是否合適。必須呼叫gtk.gdk.DragContext.drag_status()方法來更新drag_context狀態。

"drag-drop" 處理程式必須使用drag_dest_find_target()方法確定匹配的目標，然後使用drag_get_data()方法請求拖放資料。資料將在"drag-data-received" 處理程式中可用。