GTK+ 2.0教程：从入门到高级实践

需积分: 0 67 浏览量更新于2024-07-29 收藏 1.15MB PDF 举报

本篇教程是关于使用GTK+（GIMP Toolkit）的C接口进行开发的全面指南，由Tony Gale、Ian Main和GTK团队共同编撰。GTK+ 2.0是一个广泛应用于图形用户界面（GUI）开发的强大工具，尤其适合Linux平台。本文档提供了丰富的实例，包括GDK（图形设备接口）和GLib（系统级库）的相关内容。 1. **教程可用性**：教程首先介绍了其获取方式，确保读者可以通过官方文档或网络资源找到相应的源代码和编译指南。 2. **入门介绍**：这部分着重于对GTK+的简介，强调它是如何与C语言集成，以及它在跨平台应用程序开发中的角色。通过一个简单的“Hello World”示例，读者可以学习基本的编译和运行流程。 3. **基础步骤**：从“Hello World in GTK”开始，逐步引导开发者了解信号和回调理论，这是GUI编程的核心概念。通过实践操作，让读者理解事件驱动编程模型，以及如何响应和处理用户交互。 4. **进阶内容**：随后的章节深入到数据类型和信号处理器的使用，展示了如何升级初始的“Hello World”程序以实现更复杂的逻辑。这部分内容有助于构建更加动态和功能丰富的用户界面。 5. **布局管理**：接着讲解了如何利用GTK+的布局系统，如Box包装器，来组织和调整UI组件的位置。通过实例演示，开发者可以学习如何使用表格布局来精确控制组件的排列。 6. **控件概述**：这部分介绍了如何在C代码中正确识别和使用不同类型的控件，如按钮、切换按钮、复选框和单选按钮，以及它们各自的特性和用法。 7. **调整与滑动控件**：专门讨论了调整和滑动控件，如ScrolledWindow和Scale，涵盖了创建、使用和内部机制的讲解。 8. **范围控件**：包括滚动条和滑块，以及如何根据需求定制其行为，例如设置更新策略和读取值。 9. **总结与拓展**：最后部分可能会包含对函数和信号的深入分析，以及一些常见任务的通用方法。读者可以在这里找到如何将所学知识应用到实际项目中的实用技巧。此篇GTK+教程为C开发者提供了一个循序渐进的学习路径，涵盖了从基础到高级的主题，旨在帮助他们熟练掌握这个强大的GUI库。无论是初次接触GTK+还是希望提升技能的开发者，都能从中受益匪浅。

Chapter 3. Getting Started

use the g_signal_connect_swapped() for these, whereas for your functions, you

may need to have additional data supplied to the callbacks.

Events

In addition to the signal mechanism described above, there is a set of events that

reﬂect the X event mechanism. Callbacks may also be attached to these events.

These events are:

• event

• button_press_event

• button_release_event

• scroll_event

• motion_notify_event

• delete_event

• destroy_event

• expose_event

• key_press_event

• key_release_event

• enter_notify_event

• leave_notify_event

• conﬁgure_event

• focus_in_event

• focus_out_event

• map_event

• unmap_event

• property_notify_event

• selection_clear_event

• selection_request_event

• selection_notify_event

• proximity_in_event

• proximity_out_event

• visibility_notify_event

• client_event

• no_expose_event

• window_state_event

In order to connect a callback function to one of these events you use the function

g_signal_connect(), as described above, using one of the above event names as

the name parameter. The callback function for events has a slightly different form

than that for signals:

gint callback_func( GtkWidget *widget,

GdkEvent *event,

gpointer callback_data );

GdkEvent is a C union structure whose type will depend upon which of the

above events has occurred. In order for us to tell which event has been issued

each of the possible alternatives has a type member that reﬂects the event being

issued. The other components of the event structure will depend upon the type

of the event. Possible values for the type are:

GDK_NOTHING

GDK_DELETE

GDK_DESTROY

GDK_EXPOSE

GDK_MOTION_NOTIFY

GDK_BUTTON_PRESS

GDK_2BUTTON_PRESS

GDK_3BUTTON_PRESS

GDK_BUTTON_RELEASE

GDK_KEY_PRESS

GDK_KEY_RELEASE

GDK_ENTER_NOTIFY

GDK_LEAVE_NOTIFY

Chapter 3. Getting Started

Stepping Through Hello World

Now that we know the theory behind this, let’s clarify by walking through the

example helloworld program.

Here is the callback function that will be called when the button is "clicked". We

ignore both the widget and the data in this example, but it is not hard to do things

with them. The next example will use the data argument to tell us which button

was pressed.

void hello( GtkWidget *widget,

gpointer data )

{

g_print ("Hello World\n");

}

The next callback is a bit special. The "delete_event" occurs when the window

manager sends this event to the application. We have a choice here as to what

to do about these events. We can ignore them, make some sort of response, or

simply quit the application.

The value you return in this callback lets GTK know what action to take. By re-

turning TRUE, we let it know that we don’t want to have the "destroy" signal

emitted, keeping our application running. By returning FALSE, we ask that "de-

stroy" be emitted, which in turn will call our "destroy" signal handler.

gint delete_event( GtkWidget *widget,

GdkEvent *event,

gpointer data )

{

g_print ("delete event occurred\n");

return TRUE;

}

Here is another callback function which causes the program to quit by calling

gtk_main_quit(). This function tells GTK that it is to exit from gtk_main when

control is returned to it.

void destroy( GtkWidget *widget,

gpointer data )

{

gtk_main_quit ();

}

I assume you know about the main() function... yes, as with other applications,

all GTK applications will also have one of these.

int main( int argc,

char *argv[] )

{

This next part declares pointers to a structure of type GtkWidget. These are used

below to create a window and a button.

GtkWidget *window;

GtkWidget *button;

Here is our gtk_init() again. As before, this initializes the toolkit, and parses the

arguments found on the command line. Any argument it recognizes from the

command line, it removes from the list, and modiﬁes argc and argv to make it

look like they never existed, allowing your application to parse the remaining

arguments.

gtk_init (&argc, &argv);

Create a new window. This is fairly straightforward. Memory is allocated for the

GtkWidget *window structure so it now points to a valid structure. It sets up

Chapter 3. Getting Started

a new window, but it is not displayed until we call gtk_widget_show(window)

near the end of our program.

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

Here are two examples of connecting a signal handler to an object, in this case,

the window. Here, the "delete_event" and "destroy" signals are caught. The ﬁrst

is emitted when we use the window manager to kill the window, or when we

use the gtk_widget_destroy() call passing in the window widget as the object to

destroy. The second is emitted when, in the "delete_event" handler, we return

FALSE. The G_OBJECT and G_CALLBACK are macros that perform type casting and

checking for us, as well as aid the readability of the code.

g_signal_connect (G_OBJECT (window), "delete_event",

G_CALLBACK (delete_event), NULL);

g_signal_connect (G_OBJECT (window), "destroy",

G_CALLBACK (destroy), NULL);

This next function is used to set an attribute of a container object. This just sets

the window so it has a blank area along the inside of it 10 pixels wide where no

widgets will go. There are other similar functions which we will look at in the

section on Setting Widget Attributes

And again, GTK_CONTAINER is a macro to perform type casting.

gtk_container_set_border_width (GTK_CONTAINER (window), 10);

This call creates a new button. It allocates space for a new GtkWidget structure

in memory, initializes it, and makes the button pointer point to it. It will have the

label "Hello World" on it when displayed.

button = gtk_button_new_with_label ("Hello World");

Here, we take this button, and make it do something useful. We attach a signal

handler to it so when it emits the "clicked" signal, our hello() function is called.

The data is ignored, so we simply pass in NULL to the hello() callback func-

tion. Obviously, the "clicked" signal is emitted when we click the button with our

mouse pointer.

g_signal_connect (G_OBJECT (button), "clicked",

G_CALLBACK (hello), NULL);

We are also going to use this button to exit our program. This will illustrate how

the "destroy" signal may come from either the window manager, or our program.

When the button is "clicked", same as above, it calls the ﬁrst hello() callback func-

tion, and then this one in the order they are set up. You may have as many call-

back functions as you need, and all will be executed in the order you connected

them. Because the gtk_widget_destroy() function accepts only a GtkWidget *wid-

get as an argument, we use the g_signal_connect_swapped() function here in-

stead of straight g_signal_connect().

g_signal_connect_swapped (G_OBJECT (button), "clicked",

G_CALLBACK (gtk_widget_destroy),

G_OBJECT (window));

This is a packing call, which will be explained in depth later on in Packing Wid-

gets. But it is fairly easy to understand. It simply tells GTK that the button is to be

placed in the window where it will be displayed. Note that a GTK container can

only contain one widget. There are other widgets, that are described later, which

are designed to layout multiple widgets in various ways.

gtk_container_add (GTK_CONTAINER (window), button);

Now we have everything set up the way we want it to be. With all the signal

handlers in place, and the button placed in the window where it should be, we

ask GTK to "show" the widgets on the screen. The window widget is shown last

so the whole window will pop up at once rather than seeing the window pop

剩余243页未读，继续阅读

kukykooky

粉丝: 0
资源: 1

GTK+ 2.0教程：从入门到高级实践

gtk+2.0 tutorial

004-GTK-TUTORIAL.rar_gtk_tool

python gtk3 tutorial

GTK 2.0 Tutorial

GTK.rar_GIMP_gtk 2.0 tutorial chm_gtk pdf_gtk 图形_gtk2

GTK+ 1.2 Tutorial

GTK + 2.0教程GTK+ 2.0 Tutorial

Gtk4-tutorial:gtk4初学者教程

Python GTK+ 3 Tutorial

gtk3-tutorial:GTK + 3 C编程语言教程

最新资源