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.com")
   
   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.com")
   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" 处理程序中可用。