Pygtk 简明教程

PyGTK - Quick Guide

PyGTK - Introduction

PyGTK 是用 Python 和 C 编写的 GTK+ GUI 库的一组包装器。它是 GNOME 项目的一部分。它提供在 Python 中构建桌面应用程序的综合工具。还提供了其他流行 GUI 库的 Python 绑定。

PyQt 是 QT 库的 Python 端口。我们的 PyQt 教程可在 here 中找到。类似地，wxPython 工具包是 wxWidgets 的 Python 绑定，它是另一个流行的跨平台 GUI 库。我们的 wxPython 教程可用于 here 。

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 - Environment

PyGTK for Microsoft Windows

PyGTK for Microsoft Windows 的安装包括以下步骤：

Step 1 - 安装一个 32 位 Python 解释器（最新 Python 2.7 发行版）
Step 2 - 下载并安装 GTK+ 运行时。
Step 3 - 下载并安装 GTK+ 运行时 - https://ftp.gnome.org
Step 4 - 建议您从以下 URL 下载 PyCairo 和 PyGobject 模块： https://ftp.gnome.org https://ftp.gnome.org/pub
Step 5 - 为方便起见，还提供了处理所有 PyGTK 依赖项的一体化安装程序。从以下 URL 下载并安装 Windows 的最新一体化安装程序： https://ftp.gnome.org/pub/GNOME

PyGTK for Linux

大多数 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 - Important Classes

PyGTK 模块包含各种小组件。gtk.Object 类充当大多数小组件和某些非小组件类的基类。使用 PyGTK 的桌面应用程序的最顶层窗口由 gtk.Window 类提供。下表列出了重要的小组件及其功能：

S.NO	Classes and Description
1	gtk.Widget 这是所有 PyGTK 小组件的 gtk.base 类。gtk.Widget 为小组件提供一组通用方法和信号。
2	gtk.Window 这是一个包含一个子小组件的最顶层窗口。gtk.Window 是一个带有标题栏的显示区域，以及允许用户关闭、调整大小和移动窗口的项目。
3	gtk.Button 这是一个单击时发出信号的按钮小组件。gtk.Button 通常显示为带有文本标签的按钮，通常用于附加回调函数。
4	gtk.Entry 这是一个单行文本输入小组件。
5	gtk.Label 此小组件显示有限数量的只读文本。
6	gtk.ButtonBox 这是一个包含多个按钮的小组件的基类。
7	gtk.HBox 这是一个将子小组件组织成单个水平行的容器。
8	gtk.VBox 这是一个将子小组件组织成单个列的容器。
9	gtk.Fixed 这是一个可以将子小组件放置在固定位置并带有固定大小（以像素为单位）的容器。
10	gtk.Layout 这提供了一个无限可滚动区域，其中包含子小组件和自定义绘图。
11	gtk.MenuItem 此小组件实现了菜单项的外观和行为。gtk.MenuItem 的派生小组件子类是菜单的唯一有效子级。在用户选择时，它们可以显示弹出菜单或调用关联函数或方法。
12	gtk.Menu 这是一个下拉菜单，其中包含一个 MenuItem 对象列表，用户可以通过该列表进行导航和激活以执行应用程序函数。
13	gtk.MenuBar 这将在应用程序窗口或对话框中水平显示菜单项。
14	gtk.ComboBox 此小工具用于从项目列表中选择。
15	gtk.Scale 这是一个水平或垂直滑动控制器，用于选择数值。
16	gtk.Scrollbar 这会显示一个水平或垂直滚动条。
17	gtk.ProgressBar 这用于显示正在运行的长时间操作的进度。
18	gtk.Dialog 这会显示一个弹出窗口，供用户获取信息和执行操作。
19	gtk.Notebook 此小工具是一个容器，其中的子项是可通过使用标签页标签在之间切换的重叠页。
20	gtk.Paned 对于有两个窗格的小工具，这是基础类，无论它们是水平排列还是垂直排列。子小工具会添加到小工具的窗格中。这两个子项之间的划分是由用户调整的。
21	gtk.TextView 此小工具显示 TextBuffer 对象的内容。
22	gtk.Toolbar 此容器将按钮和窗口小工具放在水平或垂直栏内，并对其进行管理。
23	gtk.TreeView 此小工具显示标准 TreeModel 的内容（ListStore、TreeStore、TreeModelSort）
24	gtk.DrawingArea 此小工具帮助创建自定义用户界面元素。gtk.DrawingArea 本质上是空白小工具，其中包含可以绘图的窗口。
25	gtk.Calendar 此小工具显示日历，并允许用户选择日期。
26	gtk.Viewport 此小工具显示更大窗口小工具的一部分。

PyGTK - Window Class

gtk.Window 类的对象提供了一个在用户眼中常见为“窗口”的小部件。此小部件是一个容器，因此可以放置一个子小部件。它提供了一个带有标题栏和调整大小控件的显示区域。

gtk.Window 类具有以下构造方法 −

gtk.Window(type)

Type 参数取以下值之一 −

gtk.WINDOW_TOPLEVEL (default)

此窗口没有父元素。顶级窗口是主应用程序窗口和对话框。

gtk.WINDOW_POPUP

此窗口没有框架或修饰。弹出窗口用于菜单和工具提示。

Gtk.Window 类中的一些重要方法如下列出 -

S.NO	Methods and Description
1	set_title(string) 这将 Gtk.window 的 "标题" 属性设置为 title 指定的值。窗口的标题将显示在它的标题栏中。
2	get_title() 如果已设置，则这将返回窗口的标题。
3	set_position() 这将设置窗口的位置。预定义的位置常量为 - gtk.WIN_POS_NONE gtk.WIN_POS_CENTER gtk.WIN_POS_MOUSE gtk.WIN_POS_CENTER_ALWAYS gtk.WIN_POS_CENTER_ON_PARENT
3	set_focus() 这将设置指定的构件为窗口的焦点构件。
4	set_resizable() 这在默认情况下为真。set_resizable() 帮助用户设置窗口的大小。
5	set_decorated() 这在默认情况下为真。如果为假，窗口的标题栏和调整大小控件将被禁用。
6	set_modal() 如果为真，窗口将变为模式，并且阻止与其他窗口的交互。这用于对话框构件。
7	set_default_size() 这将窗口的默认大小设置为像素中指定了的宽度和高度。

Gtk.Window 构件会发出以下信号 -

activate-default

当通常是由用户按下回车或输入键激活窗口的默认子构件时，将发出此信号。

activate-focus

当通常是由用户按下空格键激活具有焦点的子构件时，将发出此信号。

move-focus

当用户按下 Tab、Shift+Tab 或向上、向下、向左或向右箭头键时，在窗口的子构件中改变焦点时，将发出此信号。

set-focus

当 widget 中的焦点变为 window 时，将发出此信号。

PyGTK - Button Class

gtk.Button 小工具通常显示为带有文本标签的按钮。它通常用于附加回调函数或方法，并且在单击按钮时会调用该方法。

gtk.Button 类具有以下构造函数 −

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

其中，

Label − 按钮标签显示的文本
Stock − 用于识别按钮中使用的库存图像和文本的库存 ID。默认值为无。
Underline − 如果为真，文本中的下划线表示下一个字符应该加下划线，并用作助记键加速器。

一些用于股票参数的预定义常量为 -

STOCK_OK
STOCK_STOP
STOCK_YES
STOCK_NO
STOCK_QUIT
STOCK_CANCEL
STOCK_CLOSE

Button 类具有以下重要方法 -

S.NO	Methods and Description
1	set_label() 这将按钮标签的文本设置为 label。如果 "use_stock" 属性为 True，也将使用该字符串选择股票项目。
2	get_label() 这从按钮的标签中检索文本
3	set_focus_on_click() 如果为 True，则单击按钮时，按钮将获得焦点。
4	set_alignment() 这是子小工具的水平和垂直对齐方式。值范围为 0.0 至 1.0。
5	set_image() 这将图像属性设置为 image 的值。应该将 "gtkbutton-images" 属性设置为 True。

按钮小工具会发出以下信号 -

activate

当调用 gtk.Widget 的 activate() 方法时，会发出该方法。对于按钮，会导致发出 "clicked" 信号。

clicked

当鼠标按钮按下并在指针位于按钮上方时或当用键盘触发按钮时，会发出该方法。

PyGTK - Label Class

一个标签窗口小部件仅用于展示不可编辑文本。标签通常用于很多其他窗口小部件。例如，按钮有一个标签来在面部显示文本。同样地，MenuItem 对象也有一个标签。标签是一个无窗口对象，因此它不能直接接收到事件。

标签类有一个简单的构造 −

gtk.Label(str = None)

下列有用的方法可以与标签对象一起使用 −

S.NO	Methods and Description
1	set_text() 设置标签的新文本
2	get_text() 从标签返回文本
3	set_use_underline() 如果为真，文本中的下划线表示下一个字符应该被用于助记符加速键。
4	set_justify 这设置文本中的各行相对于彼此的对齐方式。可能的值为 – gtk.JUSTIFY_LEFT、gtk.JUSTIFY_RIGHT、gtk.JUSTIFY_CENTER 和 gtk.JUSTIFY_FILL。
5	Set_line_wrap() 如果为真，将对行进行换行
6	set_selectable() 如果为真，标签中的文本可以选择复制粘贴
7	set_width_chars() 这设置标签的宽度

标签小工具发出了以下信号 −

activate-current-link

当用户激活标签中的链接时会发出此信号。

activate-link

当激活一个 URI 时会发出此信号。

copy-clipboard

当从标签向剪贴板复制文本时会发出此信号。

PyGTK - Entry Class

Entry 小工具是一个单行文本条目小工具。如果输入的文本长于小工具的分配，小工具将滚动，以便光标位置可见。

可以使用该类的 set_visibility() 方法在密码模式下转换 Entry 字段。输入的文本将被 invisible_char() 方法选择的字符替换，默认为 '*”。

Entry 类具有以下构造函数 -

gtk.Entry(max = 0)

此处，max 表示条目字段的最大长度，以字符为单位。参数采用数字值 (0-65536)。

下表显示了 Entry 类的重要方法-

S.NO	Methods and Description
1	set_visibility(visible) 如果为 false，则通过使用默认的不可见字符 — '*' 替换字符来隐藏内容
2	set_invisible_char(char) 条目字段中的默认 '*' 字符将替换为 char
3	set_max_length(x) 这将 "max-length" 属性设置为 x 的值。(0-65536)
4	set_text(str) 这将 "text" 属性设置为 str 的值。 str 中的字符串替换条目当前的内容。
5	get_text() 它返回“text”属性的值，该属性是一个包含条目内容的字符串。
6	set_alignment() 它将“xalign”属性设置为 xalign 的值。set_alignment() 控制条目字段中内容的水平定位。

入口小工具会发出以下信号：

activate

当用户操作或通过 gtk.Widget.activate() 方法以编程方式激活入口时，该信号会被发出。

backspace

当从键盘输入 Backspace 键时，该信号会被发出。

copy-clipboard

当入口中的选择文本被复制到剪贴板时，该信号会被发出。

cut-clipboard

当入口中的选择被剪切并放入剪贴板时，该信号会被发出。

paste-clipboard

当剪贴板的内容被粘贴到入口中时，该信号会被发出。

PyGTK - Signal Handling

与按顺序执行的控制台模式应用程序不同，基于 GUI 的应用程序是事件驱动的。 gtk.main() 函数会启动一个无限循环。GUI 上发生的事件会被传输到相应的回调函数中。

每个 PyGTK 小工具均源自 GObject 类，它被设计为在针对一个或多个事件做出响应时发出 ‘signal’ 。信号自身并不执行任何操作。相反，它会“连接”到一个回调函数。

某些信号会被小工具继承，而另一些信号是小工具特有的。例如，toggleButton 小工具会发出“toggled”信号。

通过调用 gtk.widget 类中的 connect() 方法可以设置信号处理程序。

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

第一个参数 name 是一个字符串，它包含要捕获的信号的名称。
第二个参数 func 是在捕获到信号时要调用的回调函数。
第三个参数 func_data 是要传递给此函数的数据。
handler id，它用于唯一标识回调方法。

例如，要当按钮被单击时调用 onClicked() 函数，请使用以下语法：

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

onClicked() 函数定义为：

def onClicked(widget, data=None):

如果回调方法是一个对象方法，则它会额外接收 self 作为参数：

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

Example

在以下示例中，一个 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 - Event Handling

除了信号机制，窗口系统事件还可以连接到回调函数。窗口调整大小、按键、滚动事件等是一些常见的窗口系统事件。这些事件会报告到应用程序的主循环。从那里，它们通过信号传递给回调函数。

下面列出了一些系统事件 -

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 是在事件发生时要调用的 callback 函数的名称。data 是要传递给回调函数的参数。

因此，以下代码连接了一个 Button 窗口小部件并捕获 button_press 事件 -

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

hello() 函数的原型如下 -

def hello(self,widget,event):

Example

以下是对按钮事件处理程序的代码 -

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 - Containers

PyGTK 库提供不同的容器类来控制窗口内小组件的位置。最简单的方法是使用一个 fixed container class ，然后指定其以像素为单位的绝对坐标，以此将其内部放置一个小组件。

让我们现在按照以下步骤操作 -

Step 1 - 声明一个 fixed class 的对象

fixed = gtk.Fixed()

Step 2 - 创建一个按钮小组件，并使用需要 x 和 y 坐标的 put() 方法将其添加到固定容器中。此处，按钮将被放置在 (100,100) 位置。

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

Step 3 - 可以在固定容器中放置多个控件。然后将其添加到顶级窗口，并调用 show_all() 方法

self.add(fixed)
self.show_all()

但是，此绝对布局由于以下原因而不合适 -

即使调整了窗口的大小，小组件的位置也不会改变。
在具有不同分辨率的不同显示设备上，外观可能不统一。
布局的修改很困难，因为它可能需要重新设计整个表单。

以下是 original window -

以下是 resized window -

按钮的位置在这里保持不变。

PyGTK API 针对容器内部小组件的位置提供容器类，以增强管理。布局管理器相对于绝对位置配置的优点包括：

窗口中的小组件自动调整大小。
确保在不同分辨率的显示设备上一致的外观。
添加或删除小组件的动态性无需重新设计。

gtk.Container 作为以下类的基类：

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

PyGTK - Box Class

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() 方法将小部件从结束放置到开始。或者，您可以使用与 pack_start() 类似的 add() 方法。

对于 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 − 如果要给子在盒子中提供额外的空间，则将其设置为 True。额外空间在所有子 widgets 之间分配。
fill − 如果为 True，将额外空间分配给子。否则，此参数用作填充。
padding − 这是盒子中各个小部件之间的像素空间。

gtk_box_pack_end ()

这将子添加到盒子中，并根据盒子的结尾进行打包。

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

以下为参数 −

child − 这是要添加的小部件对象
expand − 如果要给子在盒子中提供额外的空间，则将其设置为 True。此额外的空间在所有子小部件之间分配。
fill − 如果为 True，将额外空间分配给子，否则用作填充。
padding − 这是盒子中各个小部件之间的像素空间。

set_spacing (spacing) 是一个函数，用于设置在盒子的各个子之间放置的像素数。

方法 add (widget) 从 gtk.Container 类派生。它向容器中添加部件。可以使用此方法替代 pack_start() 方法。

Example

在下面给出的示例中，顶级窗口包含一个垂直盒子（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 - ButtonBox Class

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.

Example

在下面的示例中，toplevel 窗口内的 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 - Alignment Class

该组件在控制其子组件的对齐方式和尺寸方面非常有用。它有四个名为 xalign、yalign、xscale 和 yscale 的属性。scale 属性指定子组件将使用多少空闲空间。对齐属性用于在可用区域中放置子组件。

这四个属性都取 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 - 是子组件吸收的垂直空闲空间的比例。

Example

以下代码演示了 gtk.alignment 小组件的使用。主窗口中的一个 VBox 在其中放置了一个上部的 VBox 和下部的 HBox。在上的垂直框中，标签和小组件 Entry 被放置，以至于在左侧 50% 的空间被保持空闲并且超过 25% 被占据，方法是向 yalign 属性分配 0.5 xalign 和 0.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 - EventBox Class

PyGTK 工具包中的一些窗口小部件没有自己的窗口。这样的无窗口窗口小部件不能接收事件信号。这样的窗口小部件（例如标签），如果放入事件框中，就可以接收信号。

事件框是一个不可见的容器，它为无窗口小部件提供窗口。它有一个没有参数的简单构造函数：

gtk.EventBox()

Example

在以下示例中，将 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 时，将打印“单击标签 1”消息。类似地，在单击标签 2 时，将打印“单击标签 2”消息。

PyGTK - Layout Class

Gtk.Layout 是类似于 Gtk.Fixed 的容器构件。通过指定绝对坐标，可以在布局构件中放置构件。然而，布局构件在以下方式上与固定构件不同 -

布局构件可以具有无限的宽度和高度。宽度和高度的最大值会受到无符号整数大小的限制。
Gtk.DrawingArea 构件可以封装在布局容器内。DrawingArea 是一个可以绘制 2D 元素（如线、矩形等）的画布。
为了将 Layout 容器放在尺寸较小的顶层窗口中，可以将其与滚动条关联，也可以将其放在 ScrolledWindow 中。

Gtk.Layout 类具有以下构造函数 -

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

hadjustment 和 vadjustment 属性表示一个具有可调界定值的对象。

下表列出了该布局中经常使用的方法：

put(widget, x, y)

将子窗口小部件置于指定坐标处

set_size(w, h)

将布局容器的大小设置为指定的宽度和高度

当与其关联的调整被更改时，布局对象将发出 set_scroll_adjustment 信号。

Example

在下面的示例中，一个标签放置在布局容器的中心，而这个容器又放置在较小尺寸的顶层窗口中。因此，它首先被添加到 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 Class

组合框是任何 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 类具有以下方法 -

S.NO	Methods and Description
1	set_wrap_width() 设置在弹出表布局中显示的列数
2	get_active() 返回“active”属性的值，这是当前活动项模型中的索引
3	set_active() 将组合框的活动项设置为具有指定模型索引的项
4	set_model() 设置组合框所用的模型
5	append_text() 将 text 指定的字符串追加到组合框列表存储中存储的字符串列表
6	Insert_text() 在 index 指定位置插入 text 指定的字符串到组合框 gtk.ListStore
7	prepend_text() 将 text 指定的字符串前置到列表存储中存储的字符串列表
8	remove_text() 删除相关列表存储中 position 指定索引处的字符串
9	get_active_text() 返回当前活动字符串

组合框小部件发出以下信号 −

changed

在选择组合框中新的项目时发出

move_active

这是键盘绑定信号，用来移动活动选择

Popdown

这是一个键盘绑定信号，用来弹出组合框列表。此信号的默认绑定是 Alt+上箭头和 Esc

Popup

这是一个键盘绑定信号，用来弹出组合框列表。此信号的默认绑定是 Alt+下箭头

下面给出两个 ComboBox 演示示例代码。

Example 1

在这个示例中，使用流行的 Python GUI 工具包名称填充 ListStore，并将其与 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()

执行后，程序会显示以下输出 −

Example 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 Class

ToggleButton 小部件是带有两个状态的 gtk.Button — pressed or active （或打开）状态和 normal or inactive (or off) 状态。每次按下按钮时，状态都会交替改变。还可以通过 set_active() 方法以编程方式改变 ToggleButton 的状态。若要切换按钮状态，也可以使用 toggled() 方法。

gtk.ToggleButton 类有以下构造函数 −

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

此处，label 是要显示在按钮上的文本。use_underline 属性为 True 时，文本中的下划线表示下一个字符必须加上下划线并用作快捷键加速器。

gtk.ToggleButton 类的部分重要方法如下表所示 -

set_active()

这将 active 属性设置为 True (活动或按下或打开，或 False (非活动或正常或关闭)

get_active()

这将检索按钮状态

toggled()

这将在切换按钮上发出 "toggled" 信号。

ToggleButton 小部件发出下列信号 -

Toggled

当切换按钮状态通过编程方式或用户操作而更改时，会发出此信号。

下面给出的代码演示了 ToggleButton 小部件的使用。

两个 ToggleButtons 和 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 上显示按钮的瞬时状态。

Example

观察以下代码 -

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 Class

CheckButton 小部件只不过是一个设计成复选框和标签的 ToggleButton。它继承 ToggleButton 类中所有的属性和方法。与标题在按钮表面上的 ToggleButton 不同，CheckButton 显示一个可勾选的小方块，其右侧有一个标签。

与 gtk.CheckButton 相关联的构造器、方法和信号与 gtk.ToggleButton 完全相同。

Example

以下示例演示了 CheckButton 小部件的使用。两个 CheckButton 和一个 Label 被置于一个 VBox 中。第一个 CheckButton 的 toggled 信号连接到 on_checked() 方法，该方法将第二个按钮的状态设置为 True（前提是第一个按钮的状态为 fasle，反之亦然）。

观察代码 −

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 Class

一个单一的 RadioButton 小部件提供与 CheckButton 类似的功能。但是，当在同一容器中出现多个单选按钮时，用户可以从可用选项中进行互斥选择。如果容器中的每个单选按钮都属于同一组，则选定一个时，其他按钮将自动取消选择。

以下是 gtk.RadioButton 类的构造函数 -

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

为了创建一个按钮组，请为第一个单选按钮提供 group=None ，为后续选项提供第一个按钮的对象作为组。

与 ToggleButton 和 CheckButton 一样，RadioButton 也发出 the toggled signal 。在下面给出的示例中，gtk.RadioButton 小部件的三个对象被置于一个 VBox 中。它们全部连接到一个回调函数 on_selected() 中，以处理 toggled 信号。

回调函数识别源 RadioButton 小部件的标签，并将其显示在 VBox 中的标签上。

Example

观察以下代码 -

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 and 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")

这些 MenuItems 将被添加到菜单窗口小部件中，然后将菜单对象添加到菜单栏中。

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

PyGTK 工具包提供了许多类型的 MenuItem 窗口小部件。ImageMenuItem 是与之关联图像的菜单项。您可以通过使用库存 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)

Example

以下示例演示了上面讨论的功能 -

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 Class

Toolbar 类从 gtk.Container 类继承。它保存和管理一组按钮和其他窗口小部件。通常在顶层窗口的菜单栏正下方看到一个或多条水平按钮条。工具栏也可以放在称为 HandleBox 的可拆卸窗口中。默认情况下，gtk.Toolbar 窗口小部件中的按钮水平排列。可以通过将方向属性设置为 gtk.ORIENTATION_VERTICAL 来设置垂直工具栏。

可以将工具栏配置为显示带图标、文本或两者兼有的按钮。样式枚举器为 -

gtk.TOOLBAR_ICONS

这些按钮仅在工具栏中显示图标。

gtk.TOOLBAR_TEXT

这些按钮在工具栏中只显示文本标签。

gtk.TOOLBAR_BOTH

这些按钮在工具栏中显示文本和图标。

gtk.TOOLBAR_BOTH_HORIZ

这些按钮将图标和文本并排显示，而不是垂直堆叠。

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。例如， New 工具提示被分配给新的 ToolButton。

newbtn.set_tooltip_text("New")

Example

以下代码显示了一个顶级窗口，其中包含一个工具栏，用于包含常规工具项目、单选按钮和分隔项目。

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 - Adjustment Class

PyGTK 工具包中的一些小部件是这样，用户可以通过使用鼠标或键盘在指定范围内调整它们的属性。Viewport 这样的部件用于显示大量数据中的某个可调整部分，例如 TextView 控件中的多行文本。

PyGTK 使用 gtk.Adjustment 对象与这些小部件一起使用，以便将用户调整传递给某个回调函数进行处理。调整对象包含可调整值的上下限及其增量步长参数。当调整对象的 parameters 更改时，它会发出 changed 或 value_changed 信号。

以下是 gtk.Adjustment 类的构造函数：

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

构造函数中每个属性的含义如下：

value

The initial value

lower

The minimum value

upper

The maximum value

step_incr

The step increment

page_incr

The page increment

page_size

The page sizes

调整对象发出的信号如下：

Changed

当一个（或多个）调整属性（除了值属性）发生更改时发出。

Value-changed

当调整值属性发生更改时发出。

如上所述，调整对象不是物理小部件。相反，它与可以更改其属性的其他小部件一起使用。范围小部件与调整对象一起使用。

PyGTK - Range Class

此类充当允许用户在上下界之间调整数字参数值的小部件的基本类。Scale 小部件 (gtk.Hscale 和 gtk.Vscale) 和滚动条小部件 (gtk.HScrollbar 和 gtk.VScrollbar) 派生自 Range 类的功能。这些 Range 小部件与 Adjustment 对象结合使用。

Scale 和 Scrollbar 小部件实现的 gtk.Range 类的以下重要功能 -

set_update_policy() - 这会将 "update-policy" 属性设置为该值。该策略具有以下值 -

gtk.UPDATE_CONTINUOUS

每当移动范围滑块时，范围值将更改，并将发出 "value_changed" 信号。

gtk.UPDATE_DELAYED

值将在出现一段时间的空闲滑动时的等待超时后更新，因此值更改会稍有延迟，而不是连续更新。

gtk.UPDATE_DISCONTINUOUS

仅当用户松开按钮并结束滑块拖动操作时才更新值。

set_adjustment() - 这会设置 "adjustment" 属性。Adjustment 对象用作 Range 对象的模型。
set_increments() - 这会设置范围的步骤和页面大小。
set_range() - 这会设置 Range 小部件允许的最小值和最大值
set_value() - 这会将范围的当前值设置为指定的值。

scale 控件类 -(HScale 和 VScale) 继承自 gtk.Range 类。

PyGTK - Scale Class

此类充当 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)

adjustment 对象包含许多提供访问值和边界的属性。

PyGTK - Scrollbar Class

此类是 gtk.Hscrollbar 和 gtk.Vscrollbar 小部件的抽象基类。两者均与 Adjustment 对象相关联。滚动条拇指的位置由滚动调整控制。调整对象中的属性使用如下 −

lower

滚动区域的最小值

upper

滚动域的最大值

value

描述滚动条的位置，必须介于“lower”和“upper”之间

page_size

描述可见可滚动区域的大小

step_increment

当单击小型步进器箭头时滚动距离

page_increment

当按键 Page Up 或 Page Down 时滚动距离

以下程序显示放置在 VBox 中的 HScale 和 HScrollbar 小部件，这些小部件被添加到顶级窗口中。它们中的每一个都与一个调整对象相关联。

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)

为了显示滚动条的瞬时值，将 the adjustment object — 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)))

Example

观察以下代码 -

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 Class

Dialog 窗口小部件通常用作父窗口上方的弹出窗口。Dialog 的目的是从用户那里收集一些数据并将其发送到父窗口。Dialog 可以是模态的（它会阻止父帧）或无模态的（可以绕过 Dialog 帧）。

PyGTK 库的 Dialog 窗口小部件是一个垂直分割的窗口。在它的顶部部分，有一个 gtk.VBox，其中填充了 Label 或 Entry Widget。底部部分被称为 action_area，其中放置了一个或多个按钮。两个区域由 gtk.HSeparator 分隔。

gtk.Dialog 类具有以下构造函数 −

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

其中，

Title − 这是出现在 Dialog 窗口小部件标题栏中的文本。
Parent − 这是弹出 dialog 的顶级窗口的引用。
Flag − 定义控制 Dialog 操作的常量。已定义的常量为 −

gtk.DIALOG_MODAL

如果设置，dialog 将截获所有键盘事件

gtk.DIALOG_DESTROY_WITH_PARENT

如果设置，则当其父元素被摧毁时，dialog 也会被摧毁。

gtk.DIALOG_NO_SEPARATOR

如果设置，则按钮上方没有分隔栏。

What is a Button?

按钮是包含 gtk.Button 及其 stock 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 指定文本的按钮（或 stock 按钮，如果 button_text 为 stock ID）。
response() − 发射具有在 response_id 中指定的值的“response”信号
run() − 显示对话然后在发送 delete_event 时返回 response_id。
set_default_response() − 设置对话 action 区域中的最后 widget，使用指定的 response_id 作为对话的默认 widget。

gtk.Dialog widget 发射以下信号 -

当对话关闭时发射。

Response

当 action_area widget 激活时发射（按钮“点击”），对话收到 delete_event 或应用程序调用 response() 方法。

Dialog widget 的 action_area 中的两个按钮使用 Sock ID gtk.STOCK.CANCEL 和 gtk.STOCK_OK。它们分别与响应 ID gtk. RESPONSE_REJECT 和 gtk. RESPONSE_ACCEPT 关联。当按任何按钮时关闭 Dialog。run() 方法返回相应的响应 ID，可以用于进一步处理。

以下代码显示了其中包含按钮的顶级 gtk.Window。当点击按钮时，出现一个包含标签和两个按钮的 Dialog。

Example

观察以下代码 -

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

上述代码生成以下输出 -

Preconfigured Dialog Widgets

PyGTK API 具有多个预配置的 Dialog widget -

MessageDialog
AboutDialog
ColorSelectionDialog
FontSelectionDialog
FileChooserDialog

为了演示 PyGTK 中上述标准对话的功能，在以下程序中将一个菜单（每个菜单项在点击时分别调用一个对话）放置在 gtk.Window 中。列出了响应以激活每个菜单项的信号的回调函数。您还可以理解为每种类型的对话 widget 提供的说明。

Example

观察以下代码 -

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 Class

MessageDialog 部件是一个 Dialog 窗口，配置为显示一个表示消息类型的图像，即错误、问题或一些信息文本。使用以下构造函数声明 MessageDialog 对象 −

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

以下预定义的消息类型用于配置消息对话框 −

gtk.MESSAGE_INFO

这是一个信息消息

gtk.MESSAGE_WARNING

这是一个非致命警告消息

gtk.MESSAGE_QUESTION

这个问题需要做出选择

gtk.MESSAGE_ERROR

这条是致命错误信息

还提供了一组预定义的按钮集供使用。

gtk.BUTTONS_NONE

No buttons at all

gtk.BUTTONS_OK

这是确定按钮

gtk.BUTTONS_CLOSE

这是关闭按钮

gtk.BUTTONS_CANCEL

这是取消按钮

gtk.BUTTONS_YES_NO

这是是与否按钮

gtk.BUTTONS_OK_CANCEL

这是确定与取消按钮

当 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 - AboutDialog Class

gtk.AboutDialog 小部件提供了一种简单的方法来显示有关程序的信息，如其徽标、名称、版权、网站和许可证。当用户从 Help 菜单中选择 About 选项时，通常会打开一个关于对话框。对话框的所有部件都是可选的。

About Dialog 可以包含 URL 和电子邮件地址。当用户单击 URL 和电子邮件 ID 时，gtk.AboutDialog 提供全局挂钩

以下是 gtk.AboutDialog 类的构造函数 −

dlg = gtk.AboutDialog()

以下方法用来配置 About Dialog

set_program_name() − 这可将名称设置为在 About Dialog 中显示的内容。默认为 application_name()。
set_version() − 这可将属性设置为“版本”。
set_copyright() − 这可设置“版权”。如果 None, ，则会隐藏版权声明。
set_license() − 这可将属性设置为“许可证”。如果 None, ，则会隐藏许可证按钮。
set_website() − 这可将属性“网站”设置为应为有效 URL 的字符串。
set_author() − 这可将属性“作者”设置为在辅助署名对话框中“作者”选项卡中显示的作者姓名列表。
set_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("http://www.tutorialspoint.com")

   about.run()
   about.destroy()

上述函数生成以下输出 −

PyGTK - Font Selection Dialog

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("http://www.tutorialspoint.com")
   about.run()
   about.destroy()

所选字体应用于放置在顶级窗口上的标签的文本。

以下是输出 −

PyGTK - Color Selection Dialog

这是一个 PyGTK API 中的预配置 Dialog，允许用户选择并应用颜色。它在内部嵌入了一个 gtk.ColorSelection widget。

gtk.ColorScelection widget 呈现一个色轮，用于颜色参数（如 HSV 和 RGB）的输入框。可以通过操作色轮或输入颜色参数来选择新颜色。它的 get_current_color 对于进一步处理很有用。

以下是 gtk.ColorSelectionDialog 类构造函数的原型 -

dlg = gtk.ColorSelectionDialog(title)

从 colorsel 属性获得当前所选颜色。使用 modify_fg() 或 modify_bg() 方法将选定的颜色应用于 widget。

当 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 - File Chooser Dialog

该对话框对于用户选择需要打开或保存的文件的位置和名称很有用。它嵌入 FileChooserWidget，并在 action_area 中提供确定和取消按钮。

以下是 gtk.FileChooserDialog 类的构造函数 -

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

参数是 -

title

这是对话框的标题

parent

对话框的瞬态父级，或无

action

对话框的打开或保存模式

buttons

这是一个包含按钮标签-响应 ID 对或 None 的元组。

backend

要使用的特定文件系统后端名称。

以下是操作模式：

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 Class

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_LEFTgtk.POS_RIGHTgtk.POS_TOPgtk.POS_BOTTOM
set_tab_label_text(child, text) - 它创建一个新的标签，并使用指定标签文本，然后将该文本作为包含 child 的页面的选项卡标签进行设置。

gtk.Notebook 控件发送以下信号 -

change-current-page

当发出向后翻页或向前翻页请求时，将发出此信号

focus-tab

当通过制表键改变焦点时，将发出此信号。

page-added

当将页面添加到记事本时，将发出此信号。

page-removed

当从记事本中删除页面后，将发出此信号。

select-page

当选择新的子页面时，将发出此信号。

switch-page

这在笔记本页面变更时发出。

Example

在以下示例中，一个带三个页面的 gtk.Notebook 被置于一个顶级 gtk.Window 中。第一页包含一个 VBox，其中打包了一个标签和一个输入域。标记为“资质”的第二页包含一个 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 Class

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)

Example

观察以下代码 -

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 - AspectFrame Class

gtk.AspectFrame 类是框架类的子类。此框架中的子小工具始终保持其宽高比，即使主窗口更改了大小。

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 类的代码，唯一区别在于 ButtonBox 被放置在 AspectFrame 小工具中。

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

Note − obey_child 属性被设置为 False，因为需要在调整窗口大小时保持宽高比。

Example

观察以下代码 -

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

上述代码将生成以下的原始和调整大小的窗口 −

Original Window

Resized Window

PyGTK - TreeView Class

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 etc.

例如，声明一个用于存储字符串项目的 ListStore 对象的方法如下：

store = gtk.ListStore(gobject.TYPE_STRING

为了在存储器中添加项目，使用 append() 方法：

store.append (["item 1"])

TreeStore 是一个多列树小部件模型。例如，以下语句创建了一个其一列含有字符串项的存储。

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 类的 USING 方法设置这些参数。

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, treeview 列可见
TreeViewColumn.set_title() - 此方法将 "title" 属性设置为指定的值。
TreeViewColumn.set_lickable() - 如果设置为 True，标题可以接受键盘焦点，并且可以被单击。
TreeViewColumn.set_alignment(xalign) - 此方法将 "alignment" 属性设置为 xalign 的值。

当用户单击 treeviewcolumn 标题按钮时，会发出 "clicked" 信号。

在配置了 TreeViewColumn 对象之后，它将使用 append_column() 方法添加到 TreeView 小部件中。

以下为 TreeView 类的重要方法 -

TreevVew.set_model() - 它为 treeview 设置“model”属性。如果 treeview 已有一个设置的模型，此方法会在设置新模型之前将其移除。如果 model 是 None ，它将取消设置旧模型。
TreeView.set_header_clickable() - 如果设置为 True，则可以单击列标题按钮。
TreeView.append_column() - 它将指定的 TreeViewColumn 追加到列列表。
TreeView.remove_column() - 它从 treeview 移除指定的列。
TreeView.insert_column() - 它将指定的 column 插入treeview 中 position 指定的位置。

TreeView 组件发出以下信号 -

cursor-changed

它在光标移动或设置时发出。

expand-collapse-cursor-row

当光标所在的行需要展开或折叠时发出。

row-activated

当用户双击 treeview 行时发出。

row-collapsed

当用户或编程操作折叠一行时发出。

row-expanded

当通过用户或编程操作展开一行时发出。

下面给出 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)

TreeView Object通过将它添加到 Fixed 容器而被放置到最顶层的窗口中。

Example 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 callback 函数，用户选择的对象显示在窗口中的标签上。

Example 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 Class

Paned 类是控件的基本类，这些控件可以水平（gtk.Hpaned）或垂直（gtk.Vpaned）显示两个可调整的面板。通过使用 pack1() 和 pack2() 方法向控件中添加子控件。

Paned 控件在两个面板之间绘制分隔符滑块，并提供一个调整它们相对宽度/高度的句柄。如果控件内部子控件的 resize 属性设置为 True，那么它将根据控件的大小进行调整。

对于 HPaned 以及 VPaned 类，可使用以下方法 −

Paned.add1(child) − 这会将 child 指定的控件添加到顶部或左侧面板
Paned.add2(子控件) − 这会将 child 指定的小部件添加到底部或右侧窗格。
Paned.pack1(子控件, 调整大小, 收缩) − 这会将 child 指定的小部件添加到带有参数的顶部或左侧窗格。如果 resize 是 True ，那么调整窗格小部件的大小时 child 应调整大小。如果 shrink 是 True ，则 child 可以缩小到小于其最小尺寸请求。
Paned.pack2(子控件, 调整大小, 收缩) − 这会设置两个窗格之间的分隔符的位置。

Paned 小部件的两种类型都会发出以下信号 −

accept-position

当 paned 具有焦点且导致聚焦的子控件被激活时，这会被发出。

cancel-position

当按下 Esc 键且 paned 具有焦点时，这会被发出。

move-handle

当 paned 具有焦点且分隔符被移动时，这会被发出。

Example

下面的示例使用 gtk.Hpaned 小部件。在左侧窗格中，添加了一个 TreeView 小部件，在右侧窗格中，有一个 TextView 小部件。当选定 TreeView 中的任何行时，它会发出 row_activated 信号，该信号连接到回调函数。 on_activated()function 检索行的文本并显示在文本视图面板中。

观察代码 −

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 - Statusbar Class

一个通知区域，通常位于窗口底部，称为状态栏。可以在状态栏上显示任何类型的状态变更消息。它还有握柄，可以使用它来调整大小。

gtk.Statusbar 组件维护一个消息堆栈。因此，新消息显示在当前消息的顶部。如果它被弹出，则以前的邮件将再次可见。必须通过 context_id 识别消息的来源才能唯一标识它。

以下是 gtk.Statusbar 组件的构造函数 −

bar = gtk.Statusbar()

以下是 gtk.Statusbar 类的函数 −

Statusbar.push(context_id, text) − 这将一个新消息推送到状态栏的堆栈上。
Statusbar.pop(context_id) − 这从状态栏的堆栈中使用指定的 context_id 移除顶部消息。

状态栏小组件会发出以下信号：

text-popped

当消息从状态栏消息堆栈中移除时发出。

text-pushed

当消息添加到状态栏消息堆栈时发出。

以下示例演示了状态栏的功能。顶层窗口包含一个带有两行的 VBox。上排有一行 Fixed 小组件，其中包含一个标签、一个 Entry 小组件和一个按钮。在底行中添加了一个 gtk.Statusbar 小组件。

为了向状态栏发送消息，需要获取其 context_id。

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

Button 对象的“单击”信号通过一个回调函数连接，通过该回调函数在状态栏中推送消息。而且当在 Entry 小组件中按下 Enter 键时会发出“激活”信号。此小组件连接到另一个回调。

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

两个回调都使用 push() 方法在通知区域中闪烁消息。

Example

观察以下代码 -

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 以在状态栏中看到“已输入文本”消息。

PyGTK - ProgressBar Class

进度条用于向用户提供长时间运行进程的视觉指示。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() 是回调函数。它以 1% 的幅度增加 set_fraction() 方法的参数，并更新进度条中的文本以显示完成百分比。

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

Example

观察以下代码 -

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 Class

如果窗口小部件的区域大于顶级窗口的区域，它与 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 Class

滚动窗口用于访问大于父窗口的区域中的其他小组件。TreeView 和 TextView 等某些小组件本地支持滚动。对于其他小组件，例如 Label 或 Table，应该提供视口。

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 ，然后将视口添加到滚动窗口中。

以下代码为具有 10 x 10 尺寸的 gtk.Table 对象添加了滚动窗口。由于 Table 对象不支持自动调整，因此它被添加到视口中。

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)

Example

观察以下代码 -

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 - Arrow Class

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 常量在以下表中列出：

gtk.SHADOW_NONE

No outline.

gtk.SHADOW_IN

轮廓向内倒角。

gtk.SHADOW_OUT

轮廓像按钮一样向外倒角。

gtk.SHADOW_ETCHED_IN

轮廓本身是向内倒角，但框架向外倒角。

gtk.SHADOW_ETCHED_OUT

轮廓是向外倒角，框架向内倒角。

Example

在以下示例中，四个按钮小组件添加到 Hbox 中。在每个按钮的顶部，分别放置了指向向上、向下、向左和向右的 gtk.Arrow 对象。HBOX 容器在 Alignment 容器的帮助下被放置在顶层窗口的底部。

观察代码 −

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 - Image Class

此类也从 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 识别的 stock item 设置图像数据。
Image.clear() - 移除当前图像。
Image.set_from_image() - 从当前显示器的像素格式中设置一个客户端图像缓冲区的图像数据。如果图像为 None ，则将移除当前图像数据。

Example

在以下程序中，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 Class

DrawingArea 小部件显示一个空白画布，画布上包含一个 gtk.gdk.Window，可以在其上绘制线条、矩形、弧线等对象。

PyGTK 使用 Cairo 库进行此类绘图操作。Cairo 是一个流行的二次矢量图形库。它用 C 语言编写，但在大多数语言中都有绑定，如 C++、Java、Python、PHP 等。Cairo 库可用于在各种操作系统中绘制标准输出设备。它还可以用于创建 PDF、SVG 和 PostScript 文件。

为了执行不同的绘图操作，我们必须提取目标输出对象的文本设备。在本例中，由于绘图出现在 gtk.DrawingArea 小部件上，因此会获取其内部包含的 gdk.Window 的设备上下文。此类具有一个 cairo-create() 方法，该方法返回设备上下文。

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

DrawingArea 小部件可以基于它发出的以下信号连接到回调：

Realize

当小部件在特定显示器上实例化时执行任何必要操作。

configure_event

当小部件大小改变时执行任何必要操作。

expose_event

当绘图区域第一次出现在屏幕上或当它被另一个窗口覆盖然后取消覆盖（公开）时，处理重新绘制小部件的内容。

鼠标和键盘事件也可以通过 gtk.Widget class 的 add_events() method 调用回调。

特别感兴趣的是当 DrawingArea 画布第一次出现时发出的 expose-event 信号。定义在 Cairo 库中的用于绘制 2D 对象的不同方法从此回调中调用，该回调连接到 expose-event 信号。这些方法在 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() − draws outline
dc.fill() - 使用当前颜色填充形状
dc.set_color_rgb(r,g,b) - 使用介于 0.0 到 1.0 之间的 r、g 和 b 值设置轮廓和填充颜色

Example

以下脚本使用 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 Class

SpinnButton 小组件通常称为 Spinner，它是一个 gtk.Entry 小组件，在右侧带有向上和向下箭头。用户可以直接在其中输入数值，也可以使用向上和向下箭头进行递增或递减。gtk.SpinButton 类继承自 gtk.Entry 类。它使用一个 gtk.Adjustment 对象，可使用该对象限制 spinner 中数值的范围和步长。

使用以下构造函数创建 SpinButton 小组件：

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

其中，adj 代表 gtk.Adjustment object controlling range ， climb_rate 是一个加速度因子，digits 指定的小数位数。

gtk.SpinButton 类具有以下方法：

SpinButton.set_adjustment() - 设置“adjustment”属性。
SpinButton.set_digits() - 将“digits”属性设置为确定 spinbutton 显示的小数位数的值。
SpinButton.set_increments(step, page) - 设置每次按下鼠标左键应用的增量和每次按下鼠标中键应用的增量。
SpinButton.set_range() - 设置 spinbutton 的最小和最大允许值。
SpinButton.set_value() - 以编程方式将 Spin Button 设置为新值。
SpinButton.update_policy() - 有效值为 gtk.UPDATE_ALWAYS 和 gtk.UPDATE_VALID
SpinButton.spin(方向, 增量=1) - 此操作会以指定方向对 Spinner 的值递增或递减。

以下是预定义的方向常量 -

gtk.SPIN_STEP_FORWARD

forward by step_increment

gtk.SPIN_STEP_BACKWARD

backward by step_increment

gtk.SPIN_PAGE_FORWARD

forward by step_increment

gtk.SPIN_PAGE_BACKWARD

backward by step_increment

gtk.SPIN_HOME

move to minimum value

gtk.SPIN_END

move to maximum value

gtk.SPIN_USER_DEFINED

将增量添加到值

SpinButton.set_wrap() — 如果 wrap 为 True，则当超出了范围的上限或下限时，旋转按钮的值将反向环绕到相反的限制。

gtk.SpinButton 小组件会发出以下信号 -

change-value

当键盘操作更改 spinbutton 值时发出此信号。

input

当值更改时发出此信号。

output

当更改 spinbutton 显示值时发出此信号。如果处理程序成功设置文本且不需要进一步处理，则返回 True 。

value-changed

当更改任何更改 spinbutton 显示的设置时发出此信号。

wrapped

当 spinbutton 从其最大值环绕到最小值或反之亦然时会立即发出此信号。

Example

以下示例通过使用三个 SpinButton 小组件构造一个简单的 Date Selector 。Day Selector 应用了一个 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 - Calendar Class

PyGTK 工具包中的日历小组件一次显示一个月视图的简单日历。默认情况下显示更改月份和年份的导航控件。可以适当地配置显示选项。

月份属性的值介于 0 到 11 之间，日期属性的值介于 1 到 31 之间。

有一个简单的构造函数来创建 gtk.Calendar 对象 -

cal = gtk.Calendar()

默认显示样式显示当前月份和年份以及日期名称。

gtk.Calendar 类有以下方法 -

Calendar.select_month(mm,yy) — 此操作将更改日历显示为指定的 mm 和 yy 。
Calendar.select_day(dd) — 当日历的值介于 1 到 31 之间时，此操作选择日历上的指定 dd 。如果 dd 为 0，则会删除当前日期选择。
Calendar.display_options() — 这会将日历显示选项设置为 flags 指定的值。可能的显示选项组合包括：

gtk.CALENDAR_SHOW_HEADING

指定显示月份和年份。

gtk.CALENDAR_SHOW_DAY_NAMES

指定显示三字母星期描述。

gtk.CALENDAR_NO_MONTH_CHANGE

防止用户使用日历切换月份。

gtk.CALENDAR_SHOW_WEEK_NUMBERS

在日历左侧向下显示当前年份的各周数。

gtk.CALENDAR_WEEK_START_MONDAY

将日历星期从默认的星期日改为星期一。

Calendar.get_date() — 这会将日历的当前年、月和选定星期数作为一个元组 (年、月、日) 提取出来。

gtk.Calendar 窗口小部件发出以下信号 −

day-selected

当某一天通过用户或程序选择后发出此信号。

month-changed

当用户或程序更换日历月份时，发出此信号。

next-month

当用户单击日历标题中的“下一个月”导航控件时发出此信号。

next-year

当用户单击日历标题中的“下一年”导航控件时发出此信号。

prev-month

当用户单击日历标题中的“上一个月”导航控件时发出此信号。

prev-year

当用户单击日历标题中的“上一年”导航控件时发出此信号。

在以下示例中，一个 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()

Example

观察以下代码 -

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 - Clipboard Class

剪贴板对象在两个进程或同一应用程序的两个微件之间保存共享数据。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() − 这会请求剪贴板的内容并将其作为文本提供。在稍后收到文本时， callback 会使用 user_data 指定的数据进行调用。 callback 的签名为：def callback(clipboard, text, data) − text 将包含从剪贴板中检索到的 text 。

作为剪贴板演示，以下代码在顶级 gtk.Window 中使用了两个 TextView 和两个按钮。'Set' 按钮会调用 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() ，后者在第二个文本视图上显示它。

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

Example

以下是剪贴板操作的全部代码 −

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 - Ruler Class

这是一个用于水平 (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)

Example

观察以下代码 -

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 - Timeout

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

第二个按钮上的 Callback 移除了超时函数。

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

Example

以下是超时示例的完整代码：

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 - Drag and Drop

与 X 窗口关联的小部件支持拖放操作。在程序中，小部件作为拖放操作的源和/或目标时必须首先进行指定。定义为源的小部件可发送被拖拽的数据。目标小部件在拖拽数据被放置到其上的时候接收数据。

在设置启用了拖放操作的应用程序时涉及以下步骤 −

Step 1 − 设置源小部件。

Step 2 − drag_source_set() 方法为拖放操作指定目标类型 −

widget.drag_source_set(start_button_mask, targets, info)

Step 3 − start_button_mask 参数指定启动拖放操作的按钮的位掩码。

Step 4 − target 参数是由此结构组成的元组列表 −

(target, flags, info)

target 参数是表示拖放类型的字符串，例如 text/plain 或 image/x-xpixmap。

Step 6 − 预定义了以下标记 −

gtk.TARGET_SAME_APP
gtk.TARGET_SAME_WIDGET

Step 7 − 由于标记设置为 0，因此没有限制。

如果不需要小部件作为源，则可以取消设置 −

widget.drag_source_unset()

源信号会发出信号。下表列出了信号及其回调。

drag_begin

def drag_begin_cb(widget, drag_context, data):

drag_data_get

def drag_data_get_cb(widget, drag_context, selection_data, info, time, data):

drag_data_delete

def drag_data_delete_cb(widget, drag_context, data):

drag_end

def drag_end_cb(widget, drag_context, data):

Setting up a Destination Widget

drag_dest_set() 方法指定可以接收被拖拽数据的窗口小部件。

widget.drag_dest_set(flags, targets, action)

flags 参数可以采用以下常量之一 −

gtk.DEST_DEFAULT_MOTION

这会检查拖放是否与该窗口小部件可能的目标和动作列表匹配，然后适当地调用 drag_status()。

gtk.DEST_DEFAULT_HIGHLIGHT

只要有拖放操作经过该窗口小部件，就会在该窗口小部件上绘制一个高亮显示。

gtk.DEST_DEFAULT_DROP

当出现放置时，如果拖放与该窗口小部件可能的目标和动作列表匹配，则调用 drag_get_data() 来代表窗口小部件。无论放置成功与否，都要调用 drag_finish() 。如果动作是移动且拖放成功，则会将 TRUE 作为 delete 参数传递给 drag_finish() 。

gtk.DEST_DEFAULT_ALL

如果设置，则表示应执行所有默认动作。

target 是包含目标信息的元组列表。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

“拖拽移动”处理程序必须通过将目标目标与 gtk.gdk.DragContext 目标进行匹配来判断拖拽数据是否适当，还可以通过调用 drag_get_data() 方法来检查拖拽数据。必须调用 gtk.gdk.DragContext . drag_status( ) 方法来更新 drag_context 状态。

“拖拽放置”处理程序必须使用 drag_dest_find_target() 方法确定匹配的目标，然后使用 drag_get_data() 方法请求拖拽数据。数据将在“drag-data-received”处理程序中可用。