GTK+2.0教程：C接口入门指南

需积分: 10 166 浏览量更新于2024-07-19 收藏 851KB PDF 举报

"GTK+2.0教程，由Tony Gale、Ian Main和GTK团队撰写，旨在通过C接口介绍如何使用GTK（GIMP工具包）" GTK+是一个用于创建图形用户界面的开源工具包，广泛应用于Linux和其他Unix-like操作系统。GTK+ 2.0是其第二个主要版本，提供了一套丰富的控件和功能，支持多种主题和国际化。 **2. Introduction** 在介绍部分，作者可能讲述了GTK+的基本概念，包括它的设计哲学、主要特点以及为何选择GTK+作为开发GUI应用的平台。GTK+强调可移植性、灵活性和可扩展性，使得开发者能够创建出跨平台的应用程序。 **3. Getting Started** 这部分是入门指南，以“Hello World”程序为例，演示了如何在GTK+中创建一个简单的窗口。首先，介绍了如何编写基本的GTK+代码，然后解释了如何编译这个程序。接着，讨论了信号和回调的概念，这是GTK+中处理用户交互的关键机制。事件处理也在此部分提及，包括如何响应用户的键盘和鼠标操作。 **4. Moving On** 本章节深入探讨了数据类型和信号处理的更多细节。作者可能阐述了自定义信号处理器的实现方法，并展示了如何升级“Hello World”程序以添加更复杂的功能。此外，可能还涉及了类型转换和类型安全性的相关话题。 **5. Packing Widgets** 这一节讲解了如何在窗口或容器中组织和布局控件，这是构建用户界面的重要部分。理论部分涵盖了包装盒子的原理，包括水平和垂直盒子。然后，通过具体的示例程序展示了如何使用盒子进行控件的包装。同时，还介绍了使用表格进行布局的方法。 **6. Widget Overview** 在这里，作者可能对GTK+中的各种控件进行了概述，包括如何进行类型转换，以及控件之间的继承关系。还提到了没有窗口的控件，这些通常用作其他控件的辅助元素。 **7. The Button Widget** 按钮是GUI中最基础的元素之一。这部分详细介绍了普通按钮、复选框、单选按钮和切换按钮的使用方法，以及它们各自的行为和交互方式。 **8. Adjustments** 调整器（Adjustment）是控制滑块和滚动条等范围控件的核心对象。这里讲述了如何创建调整器，以及如何简单地与控件关联。此外，还可能深入到调整器的内部工作原理。 **9. Range Widgets** 范围控件包括滚动条和比例尺，用于调节数值。这一章介绍了如何创建和配置滚动条和比例尺，以及它们的常用函数和信号。特别是设置更新策略，这决定了控件在何时更新其显示状态。通过这个教程，读者将掌握GTK+ 2.0的基础知识，能够构建基本的GUI应用程序，并了解如何处理用户交互和控件布局。不过，由于提供的内容有限，完整的学习还需要阅读整个PDF文档，以获取全部细节和实例。

Chapter 5. Packing Widgets

Packing Using Tables

Let’s take a look at another way of packing - Tables. These can be extremely useful

in certain situations.

Using tables, we create a grid that we can place widgets in. The widgets may take

up as many spaces as we specify.

The ﬁrst thing to look at, of course, is the gtk_table_new() function:

GtkWidget *gtk_table_new( guint rows,

guint columns,

gboolean homogeneous );

The ﬁrst argument is the number of rows to make in the table, while the second,

obviously, is the number of columns.

The homogeneous argument has to do with how the table’s boxes are sized. If

homogeneous is TRUE, the table boxes are resized to the size of the largest widget

in the table. If homogeneous is FALSE, the size of a table boxes is dictated by the

tallest widget in its same row, and the widest widget in its column.

The rows and columns are laid out from 0 to n, where n was the number speciﬁed

in the call to gtk_table_new. So, if you specify rows = 2 and columns = 2, the

layout would look something like this:

0 1 2

0+----------+----------+

| | |

1+----------+----------+

| | |

2+----------+----------+

Note that the coordinate system starts in the upper left hand corner. To place a

widget into a box, use the following function:

void gtk_table_attach( GtkTable *table,

GtkWidget *child,

guint left_attach,

guint right_attach,

guint top_attach,

guint bottom_attach,

GtkAttachOptions xoptions,

GtkAttachOptions yoptions,

guint xpadding,

guint ypadding );

The ﬁrst argument ("table") is the table you’ve created and the second ("child")

the widget you wish to place in the table.

The left and right attach arguments specify where to place the widget, and how

many boxes to use. If you want a button in the lower right table entry of our 2x2

table, and want it to ﬁll that entry only, left_attach would be = 1, right_attach = 2,

top_attach = 1, bottom_attach = 2.

Now, if you wanted a widget to take up the whole top row of our 2x2 table, you’d

use left_attach = 0, right_attach = 2, top_attach = 0, bottom_attach = 1.

The xoptions and yoptions are used to specify packing options and may be bit-

wise OR’ed together to allow multiple options.

These options are:

GTK_FILL

If the table box is larger than the widget, and GTK_FILL is speciﬁed, the wid-

get will expand to use all the room available.

Chapter 5. Packing Widgets

GTK_SHRINK

If the table widget was allocated less space then was requested (usually by

the user resizing the window), then the widgets would normally just be

pushed off the bottom of the window and disappear. If

GTK_SHRINK is spec-

iﬁed, the widgets will shrink with the table.

GTK_EXPAND

This will cause the table to expand to use up any remaining space in the

window.

Padding is just like in boxes, creating a clear area around the widget speciﬁed in

pixels.

gtk_table_attach() has a lot of options. So, there’s a shortcut:

void gtk_table_attach_defaults( GtkTable *table,

GtkWidget *widget,

guint left_attach,

guint right_attach,

guint top_attach,

guint bottom_attach );

The X and Y options default to GTK_FILL | GTK_EXPAND, and X and Y padding

are set to 0. The rest of the arguments are identical to the previous function.

We also have gtk_table_set_row_spacing() and gtk_table_set_col_spacing().

These places spacing between the rows at the speciﬁed row or column.

void gtk_table_set_row_spacing( GtkTable *table,

guint row,

guint spacing );

and

void gtk_table_set_col_spacing ( GtkTable *table,

guint column,

guint spacing );

Note that for columns, the space goes to the right of the column, and for rows,

the space goes below the row.

You can also set a consistent spacing of all rows and/or columns with:

void gtk_table_set_row_spacings( GtkTable *table,

guint spacing );

And,

void gtk_table_set_col_spacings( GtkTable *table,

guint spacing );

Note that with these calls, the last row and last column do not get any spacing.

Table Packing Example

Here we make a window with three buttons in a 2x2 table. The ﬁrst two buttons

will be placed in the upper row. A third, quit button, is placed in the lower row,

spanning both columns. Which means it should look something like this:

Chapter 5. Packing Widgets

Here’s the source code:

#include



gtk/gtk.h



/* Our callback.

* The data passed to this function is printed to stdout */

void callback( GtkWidget *widget,

gpointer data )

{

g_print ("Hello again - %s was pressed\n", (char *) data);

}

/* This callback quits the program */

gint delete_event( GtkWidget *widget,

GdkEvent *event,

gpointer data )

{

gtk_main_quit ();

return FALSE;

}

int main( int argc,

char *argv[] )

{

GtkWidget *window;

GtkWidget *button;

GtkWidget *table;

gtk_init (&argc, &argv);

/* Create a new window */

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

/* Set the window title */

gtk_window_set_title (GTK_WINDOW (window), "Table");

/* Set a handler for delete_event that immediately

* exits GTK. */

g_signal_connect (G_OBJECT (window), "delete_event",

G_CALLBACK (delete_event), NULL);

/* Sets the border width of the window. */

gtk_container_set_border_width (GTK_CONTAINER (window), 20);

/* Create a 2x2 table */

table = gtk_table_new (2, 2, TRUE);

/* Put the table in the main window */

gtk_container_add (GTK_CONTAINER (window), table);

/* Create first button */

button = gtk_button_new_with_label ("button 1");

/* When the button is clicked, we call the "callback" function

* with a pointer to "button 1" as its argument */

g_signal_connect (G_OBJECT (button), "clicked",

G_CALLBACK (callback), (gpointer) "button 1");

Chapter 5. Packing Widgets

/* Insert button 1 into the upper left quadrant of the table */

gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 1, 0, 1);

gtk_widget_show (button);

/* Create second button */

button = gtk_button_new_with_label ("button 2");

/* When the button is clicked, we call the "callback" function

* with a pointer to "button 2" as its argument */

g_signal_connect (G_OBJECT (button), "clicked",

G_CALLBACK (callback), (gpointer) "button 2");

/* Insert button 2 into the upper right quadrant of the table */

gtk_table_attach_defaults (GTK_TABLE (table), button, 1, 2, 0, 1);

gtk_widget_show (button);

/* Create "Quit" button */

button = gtk_button_new_with_label ("Quit");

/* When the button is clicked, we call the "delete_event" function

* and the program exits */

g_signal_connect (G_OBJECT (button), "clicked",

G_CALLBACK (delete_event), NULL);

/* Insert the quit button into the both

* lower quadrants of the table */

gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 2, 1, 2);

gtk_widget_show (button);

gtk_widget_show (table);

gtk_widget_show (window);

gtk_main ();

return 0;

}

Chapter 6. Widget Overview

The general steps to creating a widget in GTK are:

1. gtk_*_new() - one of various functions to create a new widget. These are all

detailed in this section.

2. Connect all signals and events we wish to use to the appropriate handlers.

3. Set the attributes of the widget.

4. Pack the widget into a container using the appropriate call such as

gtk_container_add() or gtk_box_pack_start().

5. gtk_widget_show() the widget.

gtk_widget_show() lets GTK know that we are done setting the attributes of the

widget, and it is ready to be displayed. You may also use gtk_widget_hide to

make it disappear again. The order in which you show the widgets is not impor-

tant, but I suggest showing the window last so the whole window pops up at

once rather than seeing the individual widgets come up on the screen as they’re

formed. The children of a widget (a window is a widget too) will not be displayed

until the window itself is shown using the gtk_widget_show() function.

Casting

You’ll notice as you go on that GTK uses a type casting system. This is always

done using macros that both test the ability to cast the given item, and perform

the cast. Some common ones you will see are:

G_OBJECT (object)

GTK_WIDGET (widget)

GTK_OBJECT (object)

GTK_SIGNAL_FUNC (function)

GTK_CONTAINER (container)

GTK_WINDOW (window)

GTK_BOX (box)

These are all used to cast arguments in functions. You’ll see them in the exam-

ples, and can usually tell when to use them simply by looking at the function’s

declaration.

As you can see below in the class hierarchy, all GtkWidgets are derived from the

GObject base class. This means you can use a widget in any place the function

asks for an object - simply use the

G_OBJECT() macro.

For example:

g_signal_connect( G_OBJECT (button), "clicked",

G_CALLBACK (callback_function), callback_data);

This casts the button into an object, and provides a cast for the function pointer

to the callback.

Many widgets are also containers. If you look in the class hierarchy below, you’ll

notice that many widgets derive from the Container class. Any one of these wid-

gets may be used with the

GTK_CONTAINER macro to pass them to functions that

ask for containers.

Unfortunately, these macros are not extensively covered in the tutorial, but I rec-

ommend taking a look through the GTK header ﬁles or the GTK API reference

manual. It can be very educational. In fact, it’s not difﬁcult to learn how a widget

works just by looking at the function declarations.

Widget Hierarchy

For your reference, here is the class hierarchy tree used to implement widgets.

(Deprecated widgets and auxiliary classes have been omitted.)

Chapter 6. Widget Overview

GObject

GtkObject

+GtkWidget

| +GtkMisc

| | +GtkLabel

| | | ‘GtkAccelLabel

| | +GtkArrow

| | ‘GtkImage

| +GtkContainer

| | +GtkBin

| | | +GtkAlignment

| | | +GtkFrame

| | | | ‘GtkAspectFrame

| | | +GtkButton

| | | | +GtkToggleButton

| | | | ‘GtkOptionMenu

| | | +GtkItem

| | | | +GtkMenuItem

| | | | +GtkCheckMenuItem

| | | | +GtkImageMenuItem

| | | | +GtkSeparatorMenuItem

| | | | ‘GtkTearoffMenuItem

| | | +GtkWindow

| | | | +GtkDialog

| | | | ‘GtkPlug

| | | +GtkEventBox

| | | +GtkHandleBox

| | | +GtkScrolledWindow

| | | ‘GtkViewport

| | +GtkBox

| | | +GtkButtonBox

| | | | +GtkHButtonBox

| | | | ‘GtkVButtonBox

| | | +GtkVBox

| | | | +GtkColorSelection

| | | | +GtkFontSelection

| | | | ‘GtkGammaCurve

| | | ‘GtkHBox

| | | +GtkCombo

| | | ‘GtkStatusbar

| | +GtkFixed

| | +GtkPaned

| | | +GtkHPaned

| | | ‘GtkVPaned

| | +GtkLayout

| | +GtkMenuShell

| | | +GtkMenuBar

| | | ‘GtkMenu

| | +GtkNotebook

| | +GtkSocket

| | +GtkTable

| | +GtkTextView

| | +GtkToolbar

| | ‘GtkTreeView

| +GtkCalendar

| +GtkDrawingArea

| | ‘GtkCurve

| +GtkEditable

| | +GtkEntry

| | ‘GtkSpinButton

| +GtkRuler

| | +GtkHRuler

Chapter 7. The Button Widget

Normal Buttons

We’ve almost seen all there is to see of the button widget. It’s pretty simple.

There is however more than one way to create a button. You can use the

gtk_button_new_with_label() or gtk_button_new_with_mnemonic() to create a

button with a label, use gtk_button_new_from_stock() to create a button

containing the image and text from a stock item or use gtk_button_new() to

create a blank button. It’s then up to you to pack a label or pixmap into this new

button. To do this, create a new box, and then pack your objects into this box

using the usual gtk_box_pack_start(), and then use gtk_container_add() to pack

the box into the button.

Here’s an example of using gtk_button_new() to create a button with a image

and a label in it. I’ve broken up the code to create a box from the rest so you can

use it in your programs. There are further examples of using images later in the

tutorial.

#include



stdlib.h



#include



gtk/gtk.h



/* Create a new hbox with an image and a label packed into it

* and return the box. */

GtkWidget *xpm_label_box( gchar *xpm_filename,

gchar *label_text )

{

GtkWidget *box;

GtkWidget *label;

GtkWidget *image;

/* Create box for image and label */

box = gtk_hbox_new (FALSE, 0);

gtk_container_set_border_width (GTK_CONTAINER (box), 2);

/* Now on to the image stuff */

image = gtk_image_new_from_file (xpm_filename);

/* Create a label for the button */

label = gtk_label_new (label_text);

/* Pack the image and label into the box */

gtk_box_pack_start (GTK_BOX (box), image, FALSE, FALSE, 3);

gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 3);

gtk_widget_show (image);

gtk_widget_show (label);

return box;

}

/* Our usual callback function */

void callback( GtkWidget *widget,

gpointer data )

{

g_print ("Hello again - %s was pressed\n", (char *) data);

}

int main( int argc,

Chapter 7. The Button Widget

char *argv[] )

{

/* GtkWidget is the storage type for widgets */

GtkWidget *window;

GtkWidget *button;

GtkWidget *box;

gtk_init (&argc, &argv);

/* Create a new window */

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

gtk_window_set_title (GTK_WINDOW (window), "Pixmap’d Buttons!");

/* It’s a good idea to do this for all windows. */

g_signal_connect (G_OBJECT (window), "destroy",

G_CALLBACK (gtk_main_quit), NULL);

g_signal_connect (G_OBJECT (window), "delete_event",

G_CALLBACK (gtk_main_quit), NULL);

/* Sets the border width of the window. */

gtk_container_set_border_width (GTK_CONTAINER (window), 10);

/* Create a new button */

button = gtk_button_new ();

/* Connect the "clicked" signal of the button to our callback */

g_signal_connect (G_OBJECT (button), "clicked",

G_CALLBACK (callback), (gpointer) "cool button");

/* This calls our box creating function */

box = xpm_label_box ("info.xpm", "cool button");

/* Pack and show all our widgets */

gtk_widget_show (box);

gtk_container_add (GTK_CONTAINER (button), box);

gtk_widget_show (button);

gtk_container_add (GTK_CONTAINER (window), button);

gtk_widget_show (window);

/* Rest in gtk_main and wait for the fun to begin! */

gtk_main ();

return 0;

}

The xpm_label_box() function could be used to pack images and labels into any

widget that can be a container.

The Button widget has the following signals:

• pressed - emitted when pointer button is pressed within Button widget

• released - emitted when pointer button is released within Button widget

• clicked - emitted when pointer button is pressed and then released within

Button widget

• enter - emitted when pointer enters Button widget

• leave - emitted when pointer leaves Button widget

剩余121页未读，继续阅读

乌龟在流浪

粉丝: 1
资源: 2

GTK+2.0教程：C接口入门指南

GTK + 2.0教程GTK+ 2.0 Tutorial

No package 'gtk+-2.0pkg-config' found

GTK+ 2.x symbols detected. Using GTK+ 2.x and GTK+ 3 in the same process is not supported Trace/breakpoint trap (core dumped)

(detect.py:9541): Gtk-ERROR **: 14:26:29.250: GTK+ 2.x symbols detected. Using GTK+ 2.x and GTK+ 3 in the same process is not supported

那如何下载GTK+ 库？

c语言如何安装gtk+图形库c语言如何安装gtk+图形库

还有一个问题，GTK+的优缺点是什么

centos7安装GTK+2

最新资源