PyGTK - 快速指南
PyGTK - Introduction
PyGTK是一组用Python和C编写的包装器，用于GTK + GUI库。 它是GNOME项目的一部分。 它提供了用Python构建桌面应用程序的全面工具。 其他流行的GUI库的Python绑定也可用。
PyQt是QT库的Python端口。 我们的PyQt教程可以在here找到。 类似地，wxPython工具包是另一个流行的跨平台GUI库wxWidgets的Python绑定。 我们的wxPython教程可here 。
GTK+或GIMP Toolkit是一个用于创建图形用户界面的多平台工具包。 GTK +提供了一整套小部件，适用于从小型一次性工具到完整应用程序套件的项目。
GTK +的设计初衷是为了支持多种语言。 PyGTK是GTK +的Python包装器。
GTK +围绕以下四个库构建 -
Glib - 构成GTK +基础的低级核心库。 它为C提供数据结构处理。
Pango - 用于文本布局和渲染的库，重点是国际化。
Cairo - 支持多种输出设备（包括X Window System，Win32）的2D图形库
ATK - 用于提供辅助工具（如屏幕阅读器，放大镜和替代输入设备）的一组接口的库。
PyGTK简化了该过程，并使用Python编程语言帮助您使用图形用户界面创建程序。 底层的GTK +库提供各种可视元素和实用程序，以便为GNOME桌面开发全功能的应用程序。 PyGTK是一个跨平台的库。 它是根据LGPL许可证分发的免费软件。
PyGTK是围绕GTK + 2.x构建的。 为了构建GTK +3的应用程序，PyGObject绑定也可用。
PyGTK - Environment
适用于Microsoft Windows的PyGTK
为Microsoft Windows安装PyGTK涉及以下步骤 -
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
PyGTK包含在大多数Linux发行版中（包括Debian，Fedora，Ubuntu，RedHat等）; 源代码也可以从以下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 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 | 类和描述 |
|---|---|
| 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类的一个对象提供了一个用户通常认为是Wwindow的小部件。 这个小部件是一个容器，因此它可以容纳一个子小部件。 它提供了一个可显示区域，装饰有标题栏和调整大小控件。
gtk.Window类有以下构造函数 -
gtk.Window(type)
类型参数采用以下值之一 -
| gtk.WINDOW_TOPLEVEL (default) | 此窗口没有父级。 Toplevel窗口是主要的应用程序窗口和对话框。 |
| gtk.WINDOW_POPUP | 这个窗口没有框架或装饰。 弹出窗口用于菜单和工具提示。 |
下面列出了gtk.Window类的一些重要方法 -
| S.NO | 方法和描述 |
|---|---|
| 1 | set_title(string) 这将gtk.window的“title”属性设置为标题指定的值。 窗口的标题将显示在其标题栏中。 |
| 2 | get_title() 如果设置，则返回窗口的标题。 |
| 3 | set_position() 这设置了窗口的位置。 预定义的位置常数是 -
|
| 3 | set_focus() 这会将指定的窗口小部件设置为窗口的焦点窗口小部件。 |
| 4 | set_resizable() 默认情况下这是真的。 set_resizable（）帮助用户设置窗口的大小。 |
| 5 | set_decorated() 默认情况下这是真的。 如果为false，则将禁用标题栏和窗口的调整大小控件。 |
| 6 | set_modal() 如果为true，则窗口变为模态，并且防止与其他窗口的交互。 这用于Dialog小部件。 |
| 7 | set_default_size() 这会将窗口的默认大小设置为指定的宽度和高度（以像素为单位）。 |
gtk.Window小部件发出以下信号 -
| activate-default | 当窗口的默认子窗口小部件通常由用户按Return或Enter键激活时，会发出此信息。 |
| activate-focus | 当具有焦点的子窗口小部件通常由用户按下Space键激活时，会发出此信息。 |
| move-focus | 当用户按下Tab键，Shift + Tab键或向上，向下，向左或向右箭头键时，在窗口的子窗口小部件中更改焦点时会发出此信息。 |
| set-focus | 当焦点更改为widget中的window widget时会发出此信息。 |
PyGTK - Button Class
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类有以下重要方法 -
| S.NO | 方法和描述 |
|---|---|
| 1 | set_label() 这会将按钮标签的文本设置为标签。 如果“use_stock”属性为True，则此字符串还用于选择库存项目。 |
| 2 | get_label() 这将从按钮的标签中检索文本 |
| 3 | set_focus_on_click() 如果为True，则在使用鼠标单击时按钮会抓取焦点。 |
| 4 | set_alignment() 这是子窗口小部件的水平和垂直对齐方式。 该值的范围为0.0到1.0。 |
| 5 | set_image() 这会将image属性设置为image的值。 “gtkbutton-images”属性应设置为True。 |
Button小部件发出以下信号 -
| activate | 调用gtk.Widget的activate()方法时会发出这种情况。 对于按钮，它会导致发出“点击”信号。 |
| clicked | 当指针在按钮上方或用键盘触发按钮时按下并释放鼠标按钮时会发出此信号。 |
PyGTK - Label Class
Label小部件可用于显示不可编辑的文本。 内部的许多其他小部件都使用Label。 例如，Button有一个标签，用于在脸上显示文字。 同样，MenuItem对象也有一个标签。 标签是无窗口对象，因此无法直接接收事件。
Label类有一个简单的构造函数 -
gtk.Label(str = None)
Label对象可以使用以下有用的方法 -
| S.NO | 方法和描述 |
|---|---|
| 1 | set_text() 这会将新文本设置为标签 |
| 2 | get_text() 这将从label返回文本 |
| 3 | set_use_underline() 如果为true，则文本中的下划线表示下一个字符应该用于助记键加速键。 |
| 4 | set_justify 这将设置标签文本中的行相对于彼此的对齐方式。 可能的值有 - gtk.JUSTIFY_LEFT，gtk.JUSTIFY_RIGHT，gtk.JUSTIFY_CENTER和gtk.JUSTIFY_FILL。 |
| 5 | Set_line_wrap() 如果为true，则换行 |
| 6 | set_selectable() 如果为true，则可以选择标签中的文本进行复制粘贴 |
| 7 | set_width_chars() 这将设置标签的宽度 |
标签小部件发出以下信号 -
| activate-current-link | 当用户激活标签中的链接时，会发出此消息。 |
| activate-link | 这会被发出以激活URI。 |
| copy-clipboard | 将文本从标签复制到剪贴板时会发出此消息。 |
PyGTK - Entry Class
Entry小部件是单行文本输入小部件。 如果输入的文本比窗口小部件的分配长，则窗口小部件将滚动，以便光标位置可见。
可以使用此类的set_visibility（）方法在密码模式下转换输入字段。 输入的文本由invisible_char（）方法选择的字符替换，默认为'*'。
Entry类具有以下构造函数 -
gtk.Entry(max = 0)
这里，max代表字符中输入字段的最大长度。 该参数采用数值（0-65536）。
下表显示了Entry类的重要方法 -
| S.NO | 方法和描述 |
|---|---|
| 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中的str替换条目的当前内容。 |
| 5 | get_text() 这将返回“text”属性的值，该属性是包含条目内容的字符串。 |
| 6 | set_alignment() 这会将“xalign”属性设置为xalign的值。 set_alignment（）控制Entry字段中内容的水平位置。 |
条目小部件发出以下信号 -
| activate | 当通过用户操作或使用gtk.Widget.activate()方法以编程方式激活条目时，将发出此gtk.Widget.activate() 。 |
| backspace | 从键盘输入Backspace键时会发出此信息。 |
| copy-clipboard | 将条目中的选择文本复制到剪贴板时会发出此消息。 |
| cut-clipboard | 当条目中的选择被剪切并放入剪贴板时，会发出此信息。 |
| paste-clipboard | 将剪贴板的内容粘贴到条目中时会发出此信息。 |
PyGTK - Signal Handling
与以顺序方式执行的控制台模式应用程序不同，基于GUI的应用程序是事件驱动的。 gtk.main()函数启动一个无限循环。 GUI上发生的事件被转移到适当的回调函数。
每个PyGTK小部件都是从GObject类派生的，旨在发出'signal'以响应一个或多个事件。 信号本身不会执行任何操作。 相反，它与回调函数“连接”。
一些信号由小部件继承，而一些信号是小部件特定的。 例如，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):
例子 (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 IoWiki
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函数的名称。 数据是要传递给回调函数的参数。
因此，以下代码连接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 IoWiki
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对象框）。 它又有一个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类，它本身是gtk.Box类的子类。
按钮框用于在整个应用程序中提供一致的按钮布局。 它提供了一个默认布局和一个默认间距值，它们在所有小部件中都是持久的。
gtk.Box类的set_spacing()方法可用于更改按钮框中按钮之间的默认间距。
可以通过set_default()方法更改按钮的默认布局。 按钮布局的可能值是 -
gtk.BUTTONBOX_SPREAD
gtk.BUTTONBOX_EDGE
gtk.BUTTONBOX_START
gtk.BUTTONBOX_END.
例子 (Example)
在下面的示例中，顶层窗口内的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。 缩放属性指定子窗口小部件将使用多少可用空间。 对齐属性用于将子窗口小部件放置在可用区域内。
所有四个属性都占用0到1.0之间的浮点值。 如果xscale和yscale属性设置为0，则表示widget不吸收任何可用空间，如果设置为1，则widget分别在水平或垂直方向吸收最大可用空间。
如果设置为0，则xalign和yalign属性表示左侧或上方小部件没有可用空间。 如果设置为1，则窗口小部件左侧或上方将有最大可用空间。
gtk.alignment类具有以下构造函数 -
gtk.alignment(xalign = 0.0, yalign = 0.0, xscale = 0.0, yscale = 0.0)
Where,
xalign - 是子窗口小部件左侧的水平可用空间的分数。
yalign - 是子窗口小部件上方的垂直自由空间的分数。
xscale - 是子窗口小部件吸收的水平可用空间的分数。
yscale - 是子窗口小部件吸收的垂直自由空间的分数。
例子 (Example)
以下代码演示了gtk.alignment小部件的用法。 顶层窗口中的Vbox有一个上部Vbox和下部Hbox。 在上部垂直框中，放置一个标签和一个Entry小部件，使得向左，50％的空间保持空闲，并且通过将0.5 xalign和0.25分配给yalign属性来占用超过25％的空间。
在较低的HBox中，所有可用空间都在左侧。 这是通过将1分配给xalign属性来实现的。 因此，水平框中的两个按钮显示为右对齐。
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工具包中的一些小部件没有自己的窗口。 这种无窗口小部件无法接收事件信号。 这些小部件，例如标签，如果放在事件框内，则可以接收信号。
EventBox是一个不可见的容器，为无窗口小部件提供窗口。 它有一个简单的构造函数，没有任何参数 -
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元素。
为了将布局容器放在较小尺寸的顶层窗口中，它可以与滚动条相关联，也可以放在ScrolledWindow中。
gtk.Layout类具有以下构造函数 -
gtk.Layout(hadjustment = None, vadjustment = None)
hadjustment和vadjustment属性表示具有可调整的有界值的对象。
下表列出了常用的布局方法 -
| put(widget, x, y) | 将子窗口小部件放在指定的坐标处 |
| set_size(w, h) | 将Layout容器的大小设置为指定的宽度和高度 |
当与之关联的调整发生更改时，Layout对象会发出set_scroll_adjustment信号。
例子 (Example)
在下面的示例中，Label位于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 Class
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类有以下方法 -
| S.NO | 方法和描述 |
|---|---|
| 1 | set_wrap_width() 设置要在弹出表布局中显示的列数 |
| 2 | get_active() 返回“active”属性的值，该属性是当前活动项的模型中的索引 |
| 3 | set_active() 将combo_box的活动项设置为指定了模型索引的项 |
| 4 | set_model() 设置组合框使用的模型 |
| 5 | append_text() 将text指定的字符串追加到组合框列表存储中存储的字符串列表中 |
| 6 | Insert_text() 在由position指定的索引处的组合框gtk.ListStore中插入由text指定的字符串 |
| 7 | prepend_text() 将文本指定的字符串添加到列表存储中存储的字符串列表中 |
| 8 | remove_text() 删除关联列表库中由position指定的索引处的字符串 |
| 9 | get_active_text() 返回当前活动的字符串 |
ComboBox小部件发出以下信号 -
| changed | 选择组合框中的新项时会发出此项 |
| move_active | 这是一个键绑定信号，它被发射以移动有效选择。 |
| Popdown | 这是一个键绑定信号，它会弹出组合框列表。 此信号的默认绑定是Alt + Up和Escape |
| Popup | 这是一个键绑定信号，它会弹出组合框列表。 此信号的默认绑定是Alt + Down。 |
下面给出了用于演示ComboBox的两个示例代码。
例子1 (Example 1)
在此示例中，ListStore使用流行的Python GUI工具包的名称进行填充，并与ComboBox小部件相关联。 当用户做出选择时，发出改变的信号。 它连接到回调函数以显示用户的选择。
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 (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)状态。 每次按下按钮，状态交替显示。 ToggleButton的状态也可以通过set_active（）方法以编程方式更改。 要切换按钮的状态，也可以使用toggled（）方法。
gtk.ToggleButton类具有以下构造函数 -
gtk.ToggleButton(label = None, use_underline = True)
这里，label是要在按钮上显示的测试。 use_underline属性（如果为True），文本中的下划线表示下一个字符应加下划线并用于助记符加速器。
gtk.ToggleButton类的一些重要方法在下表中给出 -
| set_active() | 这会将active属性设置为True （活动或按下或打开）或False （非活动或正常或关闭） |
| get_active() | 这将检索按钮的状态 |
| toggled() | 这会在togglebutton上发出“切换”信号。 |
ToggleButton小部件发出以下信号 -
| Toggled | 当togglebutton状态以编程方式或用户操作更改时，会发出此消息。 |
下面给出的代码演示了ToggleButton小部件的使用。
两个ToggleButtons和Label小部件放在VBox容器中。 Button1发出的切换信号连接到回调函数on_toggled（）。 在此函数中，如果Button1的状态为False，则Button2的状态设置为True，反之亦然。
if self.btn1.get_active() == True:
self.btn2.set_active(False)
else:
self.btn2.set_active(True)
它显示标签上按钮的瞬时状态。
例子 (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小部件的用法。 两个CheckButtons和一个标签放在VBox中。 第一个CheckButton的切换信号连接到on_checked（）方法，该方法将第二个按钮的状态设置为True，如果第一个按钮的状态为false，反之亦然。
观察代码 -
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（），以处理切换信号。
回调函数标识源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")
这些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)
例子 (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
工具栏类继承自gtk.Container类。 它保存并管理一组按钮和其他小部件。 通常在顶层窗口的菜单栏下方看到一个或多个水平条形按钮。 工具栏也可以放在名为HandleBox的可拆卸窗口中。 默认情况下，gtk.Toolbar小部件中的按钮是水平放置的。 可以通过将orientation属性设置为gtk.ORIENTATION_VERTICAL来设置垂直工具栏。
工具栏可以配置为显示带有图标，文本或两者的按钮。 风格调查员是 -
| gtk.TOOLBAR_ICONS | 这些按钮仅显示工具栏中的图标。 |
| gtk.TOOLBAR_TEXT | 这些按钮仅显示工具栏中的文本标签。 |
| gtk.TOOLBAR_BOTH | 这些按钮在工具栏中显示文本和图标。 |
| gtk.TOOLBAR_BOTH_HORIZ | 这些按钮彼此并排显示图标和文本，而不是垂直堆叠。 |
使用以下构造函数设置工具栏小部件 -
bar = gtk.Toolbar()
工具栏的组成部分是gtk.ToolItem的实例。 这些项可以是ToolButton，RadioToolButton，ToggleToolButton或SeparatorToolItem。 为了将图标分配给ToolItem对象，可以使用具有预定义stock_ID的图像，或者可以通过set_image（）方法分配自定义图像。
以下示例显示如何构造不同的ToolItems -
ToolButton (ToolButton)
newbtn = gtk.ToolButton(gtk.STOCK_NEW)
RadioToolButton (RadioToolButton)
rb1 = gtk.RadioToolButton(None,gtk.STOCK_JUSTIFY_LEFT)
rb2 = gtk.RadioToolButton(rb1,gtk.STOCK_JUSTIFY_RIGHT)
请注意，多个单选按钮放在同一组中。
SeparatorToolItem (SeparatorToolItem)
sep = gtk.SeparatorToolItem()
通过调用其insert方法将这些项放在工具栏中。
gtk.Toolbar.insert(item, index)
例如，
bar.insert(new,0)
您还可以使用set_tooltip_text（）nethod为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对象与这些小部件相关联，以便将用户调整传递给某些回调函数进行处理。 调整对象包含可调整值的下限和上限以及增量步骤参数。 当调整对象的参数发生变化时，它会发出change或value_changed信号。
以下是gtk.Adjustment类的构造函数 -
gtk.Adjustment(value = 0, lower = 0, upper = 0, step_incr = 0,
page_incr = 0, page_size = 0)
构造函数中每个属性的含义如下 -
| value | 初始值 |
| lower | 最小值 |
| upper | 最大值 |
| step_incr | The step increment |
| page_incr | 页面增量 |
| page_size | 页面大小 |
调整对象发出以下信号 -
| Changed | 当一个（或多个）调整属性（值属性除外）发生更改时，会发出此消息。 |
| Value-changed | 调整值属性更改时会发出此信息。 |
如上所述，Adjustment对象不是物理小部件。 相反，它与其他小部件相关联地使用，其中的属性被改变。 范围小部件与Adjustment对象一起使用。
PyGTK - Range Class
此类充当窗口小部件的基类，允许用户调整下限和上限之间的数值参数的值。 缩放窗口小部件（gtk.Hscale和gtk.Vscale）和滚动条窗口小部件（gtk.HScrollbar和gtk.VScrollbar）从Range类派生功能。 这些Range小部件与Adjustment对象一起使用。
gtk.Range类的以下重要功能由Scale和Scrollbar小部件实现 -
set_update_policy() - 这set_update_policy() “update-policy”属性设置为该值。 该政策具有以下价值 -
| gtk.UPDATE_CONTINUOUS | 无论何时移动范围滑块，范围值都将改变，并且将发出“value_changed”信号。 |
| gtk.UPDATE_DELAYED | 在没有滑块运动的短暂超时后，该值将更新，因此值更改会略微延迟而不是持续更新。 |
| gtk.UPDATE_DISCONTINUOUS | 只有在用户释放按钮并结束滑块拖动操作时才会更新该值。 |
set_adjustment() - 设置“调整”属性。 Adjustment对象用作Range对象的模型。
set_increments() - 设置范围的步长和页面大小。
set_range() - 设置Range小部件的最小和最大允许值
set_value() - 这将范围的当前值设置为指定的值。
缩放窗口小部件类 - （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)
调整对象包含许多提供对值和边界的访问的属性。
PyGTK - Scrollbar Class
此类是gtk.Hscrollbar和gtk.Vscrollbar小部件的抽象基类。 两者都与Adjustment对象相关联。 滚动条的拇指位置由滚动调整控制。 调整对象的属性使用如下 -
| lower | 滚动区域的最小值 |
| upper | 滚动区域的最大值 |
| value | 表示滚动条的位置，该位置必须介于下限和上限之间 |
| 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 “值改变”信号the adjustment object — adj2连接到回调函数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的目标是从用户收集一些数据并将其发送到父窗口。 对话框可以是模态的（它阻止父帧）或无模式（可以绕过对话框）。
PyGTK库的Dialog小部件是一个垂直分割的窗口。 在其顶部，有一个gtk.VBox，其中包含Label或Entry Widgets。 底部称为action_area，其中放置了一个或多个按钮。 两个区域由gtk.HSeparator分隔。
gtk.Dialog类有以下构造函数 -
dlg = gtk.Dialog (Title = None, parent = None, flags = 0, buttons = None)
Where,
Title - 文本是否出现在Dialog小部件的标题栏中。
Parent - 是从弹出对话框的顶层窗口的引用。
Flag - 定义控制Dialog操作的常量。 定义的常数是 -
| gtk.DIALOG_MODAL | 如果设置，则对话框将抓取所有键盘事件 |
| gtk.DIALOG_DESTROY_WITH_PARENT | 如果设置，则对话框的父对象将被销毁。 |
| gtk.DIALOG_NO_SEPARATOR | 如果设置，则按钮上方没有分隔条。 |
什么是按钮？
Button是一个元组对象，包含一对带有股票ID（或文本）的gtk.Button及其响应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() - 在add_button()添加一个按钮，该按钮包含button_text指定的文本（或者一个股票按钮，如果button_text是股票ID）。
response() - 使用response_id中指定的值发出“response”信号
run() - 显示对话框并在发出delete_event时返回response_id。
set_default_response() - 使用指定的response_id作为对话框的默认小部件，设置对话框操作区域中的最后一个小部件。
gtk.Dialog小部件发出以下信号 -
| Close | 关闭对话框时会发出此信息。 |
| Response | 当激活action_area小部件（按钮“单击”）时，会发出此消息，对话框接收delete_event或应用程序调用response（）方法。 |
Dialog小部件的action_area中的两个按钮使用Stock ID gtk.STOCK.CANCEL和gtk.STOCK_OK。 它们与响应ID gtk相关联。 RESPONSE_REJECT和gtk。 分别为RESPONSE_ACCEPT。 按下任何按钮时，对话框将关闭。 run（）方法返回相应的响应ID，可用于进一步处理。
以下代码显示顶级gtk.Window，其中包含一个Button。 单击按钮时，会出现一个带有标签和两个按钮的对话框。
例子 (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()
上面的代码产生以下输出 -
预配置的Dialog Widgets
PyGTK API有许多预配置的Dialog小部件 -
- MessageDialog
- AboutDialog
- ColorSelectionDialog
- FontSelectionDialog
- FileChooserDialog
为了演示PyGTK中上述标准对话框的功能，在单击时调用对话框的菜单项的菜单放在以下程序的gtk.Window中。 将列出响应以激活每个菜单项的信号的回调函数。 您还可以了解为每种类型的对话框小部件提供的说明。
例子 (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("IoWiki")
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
Messagingialog小部件是一个对话窗口，配置为显示表示消息类型的图像，即错误，问题或某些信息文本。 使用以下构造函数声明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 | 这是一个OK按钮 |
| gtk.BUTTONS_CLOSE | 这是一个关闭按钮 |
| gtk.BUTTONS_CANCEL | 这是一个取消按钮 |
| gtk.BUTTONS_YES_NO | 这些是Yes和No按钮 |
| gtk.BUTTONS_OK_CANCEL | 这些是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() - 设置“version”属性
set_copyright() - 设置“版权”。 如果为None,则隐藏版权声明。
set_license() - 设置“许可证”。 如果为None,则隐藏许可证按钮。
set_website() - 这将“website”属性设置为字符串，其中应该是有效的URL。
set_author() - 这将“authors”属性设置为secondary credits对话框的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) IoWiki")
about.set_comments("About Dialog example")
about.set_website("http://www.iowiki.com")
about.run()
about.destroy()
上面的函数生成以下输出 -
PyGTK - Font Selection Dialog
gtk.FontSelection小部件允许用户选择和应用特定名称，大小和样式的字体。 该对话框有一个预览框，其中包含一些将以选定的字体描述显示的文本，以及两个按钮CANCEL和OK。
PyGTK API包含一个Pango模块，它定义了呈现高质量国际化文本所需的类和功能。 Pango支持gtk中的字体和文本处理。 pango.Font对象以与系统无关的方式表示字体。 pango.FontDescription对象包含字体的特征。
gtk.FontSelectionDialog返回一个pango.Font对象。 为了应用所选字体，通过从中获取pango.FontDescription对象来获取fontmetrics。
以下是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) IoWiki")
about.set_comments("About Dialog example")
about.set_website("http://www.iowiki.com")
about.run()
about.destroy()
选定的字体将应用于放置在顶层窗口上的标签文本。
以下是输出 -
PyGTK - Color Selection Dialog
这是PyGTK API中的预配置对话框，允许用户选择和应用颜色。 它内部嵌入了一个gtk.ColorSelection小部件。
gtk.ColorScelection小部件提供了一个colow轮，以及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 - File Chooser Dialog
此对话框可让用户选择需要打开或保存的文件的位置和名称。 它嵌入了FileChooserWidget并在action_area中提供了OK和CANCEL按钮。
以下是gtk.FileChooserDialog类的构造函数 -
Dlg=gtk.FileChooserDialog (title = None, parent = None,
action = gtk.FILE_CHOOSER_ACTION_OPEN, buttons = None, backend = None)
参数是 -
| title | 这是对话框的标题 |
| parent | 对话框的临时父级或无 |
| action | 对话框的打开或保存模式 |
| buttons | 这是一个包含按钮标签 - 响应ID对或无的元组 |
| 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) - 这将页面插入到位置指定的位置的笔记本中。
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小部件发出以下信号 -
| change-current-page | 发出页面转发或页面后退请求时会发出此信息 |
| focus-tab | 通过Tab键更改焦点时会发出此信号。 |
| page-added | 将页面添加到笔记本时会发出此信息。 |
| page-removed | 从笔记本中删除页面后会发出此消息。 |
| select-page | 选择新的子页面时会发出此信息。 |
| switch-page | 更改笔记本页面时会发出此信息。 |
例子 (Example)
在以下示例中，将具有三个页面的gtk.Notebook放置在顶层gtk.Window中。 第一页包含一个VBox，其中包含标签和Entry字段。 标有“资格”的第二页有一个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()
执行时，上面的代码显示一个三页的笔记本 -
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以外的小部件设置为frame的标签。
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)
为了在框周围绘制边框，将其放置在框架窗口小部件中，并将其添加到顶层窗口。
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类是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属性确定子项左侧的水平free空间的分数。 0.0表示左侧没有free空间，1.0表示左侧的所有free空间。
yalign属性确定子项上方的垂直free空间的分数。 0.0表示上面没有free空间，1.0表示上面的所有free空间。
如果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)
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等
例如，用于存储字符串项的ListStore对象声明为 -
store = gtk.ListStore(gobject.TYPE_STRING
为了在商店中添加商品，使用了append（）方法 -
store.append (["item 1"])
TreeStore是多列树小部件的模型。 例如，以下语句创建一个存储，其中一列包含字符串项。
Store = gtk.TreeStore(gobject.TYPE_STRING)
要在TreeStore中添加项目，请使用append（）方法。 append（）方法有两个参数，parent和row。 要添加顶级项，父级为“无”。
row1 = store.append(None, ['row1'])
您需要重复此语句以添加多行。
要添加子行，请将toplevel行作为父参数传递给append（）方法 -
childrow = store.append(row1, ['child1'])
您需要重复此语句以添加多个子行。
现在，创建一个TreeView小部件并使用上面的TreeStore对象作为模型。
treeview = gtk.TreeView(store)
我们现在必须创建TreeViewColumn来显示商店数据。 gtk.TreeViewColumn的对象使用gtk.CelRenderer管理标题和单元格。 使用以下构造函数创建TreeViewColumn对象 -
gtk.TreeViewColumn(title, cell_renderer,…)
除了title和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标题按钮时，将发出“单击”信号。
配置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指定的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对象添加到固定容器，将其放置在顶层窗口上。
例子1 (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函数时，用户选择的项目显示在窗口中的标签上。
例子2 (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） - 这会将child指定的窗口小部件添加到底部或右窗格。
Paned.pack1（子节点，调整大小，缩小） - 这会将子节点指定的小部件添加到顶部或左侧窗格中，并带有参数。 如果resize为True ，则应在调整paned窗口小部件时调整子项的大小。 如果shrink为True ，则可以使child小于其最小大小请求。
Paned.pack2（child，resize，shrink） - 设置两个窗格之间分隔符的位置。
两种类型的Paned小部件都会发出以下信号 -
| accept-position | 当paned具有焦点导致具有焦点的子窗口小部件被激活时，将发出此信息。 |
| cancel-position | 当paned具有焦点时按下Esc键时会发出此信号。 |
| 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 | 将消息添加到状态栏消息堆栈时会发出此消息。 |
以下示例演示了Statusbar的功能。 Toplevel窗口包含两行的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()方法来刷新通知区域中的消息。
例子 (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 。 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
例子 (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小部件没有任何调整。 因此它需要一个视口。 一些小部件具有本机滚动支持。 但是Label或gtk.Table小部件没有内置的滚动支持。 因此他们必须使用Viewport。
ViewPort类具有以下构造函数 -
gtk.Viewport(hadj, vadj)
这里， vadj和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-adjustment信号。
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添加到gtk.Viewport ，然后将视口添加到滚动窗口。
以下代码在gtk.Table对象周围添加了一个滚动窗口，其中包含10×10维。 由于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)
例子 (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)
在以下示例中，将四个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 - 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标识的库存项目中的图像数据。
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库进行此类绘图操作。 开罗是一个流行的2D矢量图形库。 它是用C语言编写的，但它在大多数语言中都有绑定，如C ++，Java，Python，PHP等。开罗库可用于在各种操作系统中绘制标准输出设备。 它还可用于创建PDF，SVG和后脚本文件。
为了执行不同的绘图操作，我们必须在目标输出对象的文本上获取设备。 在这种情况下，由于图形出现在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对象的不同方法。 这些方法在Cairo设备上下文中绘制相应的对象。
以下是可用的绘图方法 -
dc.rectangle（x，y，w，h） - 在指定的左上角坐标处绘制一个矩形，并具有givwn宽度和高度。
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值
例子 (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对象，可以使用该对象限制微调器中数值的范围和步长。
SpinButton小部件使用以下构造函数创建 -
sp = gtk.SpinButton(adj, climb_rate, digits)
这里，adj表示gtk.Adjustment object controlling range ， climb_rate是加速因子和由数字指定的小数位数。
gtk.SpinButton类有以下方法 -
SpinButton.set_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） - 这会在指定方向上递增或递减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 | 移动到最大值 |
| gtk.SPIN_USER_DEFINED | 为该值添加增量 |
SpinButton.set_wrap（） - 如果wrap为True，当范围的上限或下限超过时，旋转按钮值将回绕到相反的限制。
gtk.SpinButton小部件发出以下信号 -
| change-value | 当通过键盘操作更改旋钮按钮值时会发出此信号 |
| input | 值在更改时发出。 |
| output | 当旋钮显示值改变时发出。 如果处理程序成功设置文本并且不需要进一步处理，则返回True 。 |
| value-changed | 当更改旋转按钮显示的任何设置发生更改时，会发出此信号。 |
| wrapped | 这是在旋钮从最大值到最小值换行后立即发出的，反之亦然。 |
例子 (Example)
以下示例使用三个SpinButton小部件构造一个简单的Date Selector 。 日期选择器应用调整对象以限制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工具箱中的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） - 当它的值介于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
Clipboard对象保存同一应用程序的两个进程或两个小部件之间的共享数据。 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回调（剪贴板，文本，数据） - 文本将包含从剪贴板检索的text 。
作为剪贴板的演示，以下代码在顶层gtk.Window上使用两个TextView和两个按钮。 “Set”按钮调用on_set()函数，该函数将第一个on_set()的文本放在剪贴板上。
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()
当按下第二个按钮（'retrieve'）时，来自剪贴板的数据由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)
例子 (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, …)
第二个参数是你希望在每毫秒之后调用的回调函数，它是第一个参数的值 - interval。 其他参数可以作为函数数据传递给回调。
该函数的返回值是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)
以下是Timeout示例的完整代码 -
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 Window的小部件能够拖放。 在程序中，必须首先指定作为拖放源和/或目标的窗口小部件。 定义为源的窗口小部件可以发送拖动的数据。 当拖放数据被删除时，目标小部件接受它。
设置启用拖放的应用程序涉及以下步骤 -
Step 1 - 设置源小部件。
Step 2 - drag_source_set（）方法指定拖动操作的目标类型 -
widget.drag_source_set(start_button_mask, targets, info)
Step 3 - start_button_mask参数指定用于启动拖动操作的按钮的位掩码。
Step 4 - 目标参数是此结构的元组列表 -
(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）: |
设置目标小组件
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传递给drag_finish() 。 |
| gtk.DEST_DEFAULT_ALL | 如果设置，则指定应采取所有默认操作。 |
目标是包含目标信息的元组列表。 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_dest_find_target()方法请求拖动数据。 数据将在“drag-data-received”处理程序中提供。
