GTK+中控件使用说明

angelblack

这是本人送网上搜刮来的控件的使用说明，虽然不全，但是基本的都有了，希望对英文不好的初学者有所帮助，英文好的还是看官方文档比较好……

GTK+中笔记本控件（NoteBook）使用说明

笔记本构件(The NoteBook Widget)是互相重叠的页面集合，每一页都包含不同的信息，且一次只有一个页面是可见的。该构件在GUI(图形用户接口)编程中很常用。要显示大量的相似信息，同时把它们分别显示时，使用这种构件是一个很好的方法。

第一个你要知道的函数调用，你可能已经猜到了，是用来创建一个新的笔记本构件。

GtkWidget *gtk_notebook_new( void );

一旦创建了笔记本构件，就可以使用一系列的函数操作该构件。下面将对它们进行分别讨论。

先看一下怎样定位页面指示器—或称页标签，可以有四种位置：上、下、左或右。

void gtk_notebook_set_tab_pos( GtkNotebook     *notebook,
                               GtkPositionType pos );

GtkPositionType参数可以取以下几个值，从字面上很容易理解它们的含义：

GTK_POS_LEFT
GTK_POS_RIGHT
GTK_POS_TOP
GTK_POS_BOTTOM

GTK_POS_TOP是缺省值。

下面看一下怎样向笔记本中添加页面。有三种方法向笔记本中添加页面。前两种方法是非常相似的。

void gtk_notebook_append_page( GtkNotebook *notebook,
                               GtkWidget   *child,
                               GtkWidget   *tab_label );

void gtk_notebook_prepend_page( GtkNotebook *notebook,
                                GtkWidget   *child,
                                GtkWidget   *tab_label );

这些函数通过向插入页面到笔记本的后端（append）或前端（prepend）来添加页面。child是放在笔记本页面里的子构件，tab_label是要添加的页面的标签。child构件必须另外创建，一般是一个包含一套选项设置的容器构件，比如一个表格。

最后一个添加页面的函数与前两个函数类似，不过允许指定页面插入的位置。

void gtk_notebook_insert_page( GtkNotebook *notebook,
                               GtkWidget   *child,
                               GtkWidget   *tab_label,
                               gint         position );

其中的参数与_append_和_prepend_函数一样，还包含一个额外参数，position。该参数指定页面应该插入到哪一页。注意，第一页位置为0。

前面介绍了怎样添加一个页面，下面介绍怎样从笔记本中删除一个页面。

void gtk_notebook_remove_page( GtkNotebook *notebook, gint     page_num );

这个函数从notebook指定的笔记本中删除由page_num参数指定的页面。

用这个函数找出笔记本的当前页面：

gint gtk_notebook_get_current_page( GtkNotebook *notebook );

下面两个函数将笔记本的页面向前或向后移动。对要操作的笔记本构件使用以下函数就可以了。注意：当笔记本正在最后一页时，调用 gtk_notebook_next_page() 函数，笔记本会跳到第一页。同样，如果笔记本在第一页，调用了函数 gtk_notebook_prev_page()，笔记本构件会跳到最后一页。

void gtk_notebook_next_page( GtkNoteBook *notebook );

void gtk_notebook_prev_page( GtkNoteBook *notebook );

下面这个函数设置“活动”页面。比如你想笔记本的第5页被打开，你将使用这个函数。不使用这个函数时笔记本默认显示第一页。

void gtk_notebook_set_current_page( GtkNotebook *notebook, gint     page_num );

下面两个函数分别显示或隐藏笔记本的页标签以及它的边框。

void gtk_notebook_set_show_tabs( GtkNotebook *notebook, gboolean     show_tabs );

void gtk_notebook_set_show_border( GtkNotebook *notebook, gboolean show_border );

如果页面较多，标签页在页面上排列不下时，可以用下面这个函数。它允许用两个箭头按钮来滚动标签页。

void gtk_notebook_set_scrollable( GtkNotebook *notebook, gboolean     scrollable );

show_tabs, show_border和scrollable参数可以为 TRUE 或 FALSE。

下面看一个示例，它由 GTK 发布版附带的testgtk.c扩展而来。这个小程序创建了一个含一个笔记本构件和6个按钮的窗口。笔记本包含11页，由三种方式添加进来：追加、插入、前插。点击按钮可以改变页标签的位置，显示/隐藏页标签和边框，删除一页，向前或向后移动标签页，以及退出程序。

#include <stdio.h>
#include <gtk/gtk.h>

/* 这个函数旋转页标签的位置 */
void rotate_book( GtkButton   *button,
                  GtkNotebook *notebook )
{
    gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos + 1) % 4);
}

/* 显示/隐藏页标签和边框 */
void tabsborder_book( GtkButton   *button, GtkNotebook *notebook )
{
    gint tval = FALSE;
    gint bval = FALSE;
    if (notebook->show_tabs == 0)
           tval = TRUE;
    if (notebook->show_border == 0)
           bval = TRUE;
   
    gtk_notebook_set_show_tabs (notebook, tval);
    gtk_notebook_set_show_border (notebook, bval);
}

/* 从笔记本上删除一个页面 */
void remove_book( GtkButton   *button, GtkNotebook *notebook )
{
    gint page;
   
    page = gtk_notebook_get_current_page (notebook);
    gtk_notebook_remove_page (notebook, page);
    /* 需要刷新构件 --
     这会迫使构件重绘自身。 */
    gtk_widget_queue_draw (GTK_WIDGET (notebook));
}

gint delete( GtkWidget *widget, GtkWidget *event, gpointer   data )
{
    gtk_main_quit ();
    return FALSE;
}

int main( int argc, char *argv[] )
{
    GtkWidget *window;
    GtkWidget *button;
    GtkWidget *table;
    GtkWidget *notebook;
    GtkWidget *frame;
    GtkWidget *label;
    GtkWidget *checkbutton;
    int i;
    char bufferf[32];
    char bufferl[32];
   
    gtk_init (&argc, &argv);
   
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   
    g_signal_connect (G_OBJECT (window), "delete_event",
                     G_CALLBACK (delete), NULL);
   
    gtk_container_set_border_width (GTK_CONTAINER (window), 10);

    table = gtk_table_new (3, 6, FALSE);
    gtk_container_add (GTK_CONTAINER (window), table);
   
    /* 创建一个新的笔记本，将标签页放在顶部 */
    notebook = gtk_notebook_new ();
    gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
    gtk_table_attach_defaults (GTK_TABLE (table), notebook, 0, 6, 0, 1);
    gtk_widget_show (notebook);
   
    /* 在笔记本后面追加几个页面 */
    for (i = 0; i < 5; i++) {
       sprintf(bufferf, "Append Frame %d", i + 1);
       sprintf(bufferl, "age %d", i + 1);
      
       frame = gtk_frame_new (bufferf);
       gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
       gtk_widget_set_size_request (frame, 100, 75);
       gtk_widget_show (frame);
      
       label = gtk_label_new (bufferf);
       gtk_container_add (GTK_CONTAINER (frame), label);
       gtk_widget_show (label);
      
       label = gtk_label_new (bufferl);
       gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
    }
      
    /* 在指定位置添加页面 */
    checkbutton = gtk_check_button_new_with_label ("Check me please!");
    gtk_widget_set_size_request (checkbutton, 100, 75);
    gtk_widget_show (checkbutton);
   
    label = gtk_label_new ("Add page");
    gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), checkbutton, label, 2);
   
    /* 最后向笔记本前插页面 */
    for (i = 0; i < 5; i++) {
       sprintf (bufferf, "repend Frame %d", i + 1);
       sprintf (bufferl, "Page %d", i + 1);
      
       frame = gtk_frame_new (bufferf);
       gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
       gtk_widget_set_size_request (frame, 100, 75);
       gtk_widget_show (frame);
      
       label = gtk_label_new (bufferf);
       gtk_container_add (GTK_CONTAINER (frame), label);
       gtk_widget_show (label);
      
       label = gtk_label_new (bufferl);
       gtk_notebook_prepend_page (GTK_NOTEBOOK (notebook), frame, label);
    }
   
    /* 设置起始页(第4页) */
    gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 3);

    /* 创建一排按钮 */
    button = gtk_button_new_with_label ("close");
    g_signal_connect_swapped (G_OBJECT (button), "clicked",
                           G_CALLBACK (delete), NULL);
    gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 1, 1, 2);
    gtk_widget_show (button);
   
    button = gtk_button_new_with_label ("next page");
    g_signal_connect_swapped (G_OBJECT (button), "clicked",
                           G_CALLBACK (gtk_notebook_next_page),
                           notebook);
    gtk_table_attach_defaults (GTK_TABLE (table), button, 1, 2, 1, 2);
    gtk_widget_show (button);
   
    button = gtk_button_new_with_label ("prev page");
    g_signal_connect_swapped (G_OBJECT (button), "clicked",
                           G_CALLBACK (gtk_notebook_prev_page),
                           notebook);
    gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 3, 1, 2);
    gtk_widget_show (button);
   
    button = gtk_button_new_with_label ("tab position");
    g_signal_connect (G_OBJECT (button), "clicked",
                      G_CALLBACK (rotate_book),
                     notebook);
    gtk_table_attach_defaults (GTK_TABLE (table), button, 3, 4, 1, 2);
    gtk_widget_show (button);
   
    button = gtk_button_new_with_label ("tabs/border on/off");
    g_signal_connect (G_OBJECT (button), "clicked",
                      G_CALLBACK (tabsborder_book),
                      notebook);
    gtk_table_attach_defaults (GTK_TABLE (table), button, 4, 5, 1, 2);
    gtk_widget_show (button);
   
    button = gtk_button_new_with_label ("remove page");
    g_signal_connect (G_OBJECT (button), "clicked",
                      G_CALLBACK (remove_book),
                      notebook);
    gtk_table_attach_defaults (GTK_TABLE (table), button, 5, 6, 1, 2);
    gtk_widget_show (button);
   
    gtk_widget_show (table);
    gtk_widget_show (window);
   
    gtk_main ();
   
    return 0;
}

angelblack

工具栏(Toolbars)常用来将一些构件分组，这样能够简化定制它们的外观和布局。典型情况下工具栏由带图标和标签以及工具提示的按钮组成，不过，其它构件也可以放在工具栏里面。最后，各工具栏组件可以水平或垂直排列，还可以显示图标或标签，或者两者都显示。

用下面的函数创建一个工具栏（可能有些人已经猜到了）：

GtkWidget *gtk_toolbar_new( void );

创建工具栏以后，可以向其中追加、前插和插入工具栏项（这里意指简单文本字符串）或元素（这里意指任何构件类型）。要想描述一个工具栏上的对象，需要一个标签文本、一个工具提示文本、一个私有工具提示文本、一个图标和一个回调函数。例如，要前插或追加一个按钮，应该使用下面的函数：

GtkWidget *gtk_toolbar_append_item( GtkToolbar    *toolbar,
                                    const char    *text,
                                    const char    *tooltip_text,
                                    const char    *tooltip_private_text,
                                    GtkWidget     *icon,
                                    GtkSignalFunc callback,
                                    gpointer       user_data );

GtkWidget *gtk_toolbar_prepend_item( GtkToolbar    *toolbar,
                                     const char    *text,
                                     const char    *tooltip_text,
                                     const char    *tooltip_private_text,
                                     GtkWidget     *icon,
                                     GtkSignalFunc callback,
                                     gpointer       user_data );

如果要使用 gtk_toolbar_insert_item()，除上面函数中要指定的参数以外，还要指定插入对象的位置，形式如下：

GtkWidget *gtk_toolbar_insert_item( GtkToolbar    *toolbar,
                                    const char    *text,
                                    const char    *tooltip_text,
                                    const char    *tooltip_private_text,
                                    GtkWidget     *icon,
                                    GtkSignalFunc callback,
                                    gpointer       user_data,
                                    gint           position );

要简单地在工具栏项之间添加空白区域，可以使用下面的函数：

void gtk_toolbar_append_space( GtkToolbar *toolbar );

void gtk_toolbar_prepend_space( GtkToolbar *toolbar );

void gtk_toolbar_insert_space( GtkToolbar *toolbar, gint        position );

如果需要，工具栏的放置方向和它的式样可以在运行时用下面的函数设置：

void gtk_toolbar_set_orientation( GtkToolbar     *toolbar, GtkOrientation orientation );

void gtk_toolbar_set_style( GtkToolbar      *toolbar, GtkToolbarStyle style );

void gtk_toolbar_set_tooltips( GtkToolbar *toolbar, gint        enable );

上面的orientation参数取GTK_ORIENTATION_HORIZONTAL或GTK_ORIENTATION_VERTICAL。style参数用于设置工具栏项的外观，可以取GTK_TOOLBAR_ICONS，GTK_TOOLBAR_TEXT或GTK_TOOLBAR_BOTH。

要想了解工具栏还能做什么，看一看下面的程序(在代码之间我们插入了一些解释)：

#include <gtk/gtk.h>

/* 这个函数连接到Close按钮或者从窗口管理器关闭窗口的事件上 */
gint delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
{
gtk_main_quit ();
return FALSE;
}

上面的代码和其它的 GTK 应用程序差别不大，有一点不同的是：我们包含了一个漂亮的 XPM 图片，用作所有按钮的图标。

GtkWidget* close_button; /* 这个按钮将引发一个信号以
                          * 关闭应用程序 */
GtkWidget* tooltips_button; /* 启用/禁用工具提示 */
GtkWidget* text_button,
         * icon_button,
         * both_button; /* 切换工具栏风格的单选按钮 */
GtkWidget* entry; /* 一个文本输入构件，用于演示任何构件都可以组装到
                   * 工具栏里 */

事实上，不是上面所有的构件都是必须的，我把它们放在一起，是为了让事情更清晰。

/* 很简单...当按钮进行状态切换时，我们检查哪一个按钮是活动的，依此设置工具栏的式样
* 注意，工具栏是作为用户数据传递到回调函数的！ */
void radio_event (GtkWidget *widget, gpointer data)
{
if (GTK_TOGGLE_BUTTON (text_button)->active)
    gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_TEXT);
else if (GTK_TOGGLE_BUTTON (icon_button)->active)
    gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_ICONS);
else if (GTK_TOGGLE_BUTTON (both_button)->active)
    gtk_toolbar_set_style (GTK_TOOLBAR (data), GTK_TOOLBAR_BOTH);
}

/* 更简单，检查给定开关按钮的状态，依此启用或禁用工具提示 */
void toggle_event (GtkWidget *widget, gpointer data)
{
gtk_toolbar_set_tooltips (GTK_TOOLBAR (data),
                            GTK_TOGGLE_BUTTON (widget)->active );
}

上面只是当工具栏上的一个按钮被按下时要调用的两个回调函数。你应该已经熟悉了这些东西，如果你已经使用过开关按钮（以及单选按钮）。

int main (int argc, char *argv[])
{
/* 下面是主窗口（一个对话框）和一个把柄盒(handlebox) */
GtkWidget* dialog;
GtkWidget* handlebox;

/* 好了,我们需要一个工具栏,一个带掩码(mask)的图标（所有的按钮共用一个掩码）以及
   * 一个放图标的图标构件（但我们会为每个按钮创建一个分割构件） */
GtkWidget * toolbar;
GtkWidget * iconw;

/* 这个在所有的 GTK 程序中都被调用。 */
gtk_init (&argc, &argv);

/* 用给定的标题和尺寸创建一个新窗口 */
dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog), "GTKToolbar Tutorial");
gtk_widget_set_size_request (GTK_WIDGET (dialog), 600, 300);
GTK_WINDOW (dialog)->allow_shrink = TRUE;

/* 在关闭窗口时退出 */
g_signal_connect (G_OBJECT (dialog), "delete_event",
                    G_CALLBACK (delete_event), NULL);

/* 需要实例化窗口,因为我们要在它的内容中为工具栏设置图片 */
gtk_widget_realize (dialog);

/* 我们将工具栏放在一个手柄构件(handle box)上，
   * 这样它可以从主窗口上移开 */
handlebox = gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
                      handlebox, FALSE, FALSE, 5);

上面的代码和任何其它Gtk应用程序都差不多。它们进行 GTK 初始化，创建主窗口等。唯一需要解释的是：一个手柄盒(a handle box)。手柄盒只是一个可以在其中组装构件的盒子。它和普通盒子的区别在于它能从一个父窗口移开(事实上，手柄盒保留在父窗口上，但是它缩小为一个非常小的矩形，同时它的所有内容重新放在一个新的可自由移动的浮动窗口上)。拥有一个可浮动工具栏给人感觉非常好，所以这两种构件经常同时使用。

/* 工具栏设置为水平的，同时带有图标和文本
   * 在每个项之间有5像素的间距，
   * 并且，我们也将它放在手柄盒上 */
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH);
gtk_container_set_border_width (GTK_CONTAINER (toolbar), 5);
gtk_toolbar_set_space_size (GTK_TOOLBAR (toolbar), 5);
gtk_container_add (GTK_CONTAINER (handlebox), toolbar);

上面的代码初始化工具栏构件。

/* 工具栏上第一项是<close>按钮 */
iconw = gtk_image_new_from_file ("gtk.xpm"); /* 图标构件 */
close_button = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), /* 工具栏 */
                             "Close",               /* 按钮标签 */
                             "Closes this app",     /* 按钮的工具提示 */
                             "rivate",             /* 工具提示的私有信息 */
                             iconw,                 /* 图标构件 */
                             GTK_SIGNAL_FUNC (delete_event), /* 一个信号 */
                             NULL);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)); /* 工具栏项后的空白 */

在上面的代码中，可以看到最简单的情况：在工具栏上增加一个按钮。在追加一个新的工具栏项前，必须构造一个图片(image)构件用作该项的图标，这个步骤我们要对每一个工具栏项重复一次。在工具栏项之间还要增加间隔空间，这样后面的工具栏项就不会一个接一个紧挨着。可以看到，gtk_toolbar_append_item()返回一个指向新创建的按钮构件的指针，所以我们可以用正常的方式使用它。

/* 现在，我们创建单选按钮组... */
iconw = gtk_image_new_from_file ("gtk.xpm");
icon_button = gtk_toolbar_append_element (
                    GTK_TOOLBAR (toolbar),
                    GTK_TOOLBAR_CHILD_RADIOBUTTON, /* 元素类型 */
                    NULL,                          /* 指向构件的指针 */
                    "Icon",                        /* 标签 */
                    "Only icons in toolbar",       /* 工具提示 */
                    "rivate",                     /* 工具提示的私有字符串 */
                    iconw,                         /* 图标 */
                    GTK_SIGNAL_FUNC (radio_event), /* 信号 */
                    toolbar);                      /* 信号传递的数据 */
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));

这里我们开始创建一个单选按钮组。用 gtk_toolbar_append_element 就行了。事实上，使用这个函数，我们能够添加简单的工具栏项或空白间隔（类型为GTK_TOOLBAR_CHILD_SPACE或GTK_TOOLBAR_CHILD_BUTTON）。在上面的示例中，我们先创建了一个单选按钮组。要为这个组创建其它单选按钮，需要一个指向前一个按钮的指针，这样按钮的清单可以很容易组织起来（看在本文档前面部分的单选按钮节）。

/* 后面的单选按钮引用前面创建的 */
iconw = gtk_image_new_from_file ("gtk.xpm");
text_button = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar),
                                GTK_TOOLBAR_CHILD_RADIOBUTTON,
                                icon_button,
                                "Text",
                                "Only texts in toolbar",
                                "rivate",
                                iconw,
                                GTK_SIGNAL_FUNC (radio_event),
                                toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
                                          
iconw = gtk_image_new_from_file ("gtk.xpm");
both_button = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar),
                                GTK_TOOLBAR_CHILD_RADIOBUTTON,
                                text_button,
                                "Both",
                                "Icons and text in toolbar",
                                "rivate",
                                iconw,
                                GTK_SIGNAL_FUNC (radio_event),
                                toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (both_button), TRUE);

最后，我们必须手工设置其中一个按钮的状态(否则它们全部处于活动状态，并阻止我们在它们之间做出选择)。

/* 下面只是一个简单的开关按钮 */
iconw = gtk_image_new_from_file ("gtk.xpm");
tooltips_button = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar),
                                GTK_TOOLBAR_CHILD_TOGGLEBUTTON,
                                NULL,
                                "Tooltips",
                                "Toolbar with or without tips",
                                "rivate",
                                iconw,
                                GTK_SIGNAL_FUNC (toggle_event),
                                toolbar);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tooltips_button), TRUE);

开关按钮的创建方法就很明显了（如果你已经知道怎么创建单选按钮了）。

/* 要将一个构件组装到工具栏上，只需创建它，然后将它追
   * 加到工具栏上，同时设置合适的工具提示 */
entry = gtk_entry_new ();
gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar),
                             entry,
                             "This is just an entry",
                             "rivate");

/* 因为它不是工具栏自己创建的，所以我们还需要显示它 */
gtk_widget_show (entry);

可以看到，将任何构件添加到工具栏上都是非常简单的。唯一要记住的是，这个构件必须手工显示(与此相反，工具栏自己创建的工具栏项随工具栏一起显示)。

/* 好了，现在可以显示所有的东西了 */
gtk_widget_show (toolbar);
gtk_widget_show (handlebox);
gtk_widget_show (dialog);

/* 进入主循环，等待用户的操作 */
gtk_main ();

return 0;
}

angelblack

按钮盒(Button Boxes)可以很方便地快速布置一组按钮。它有水平和垂直两种样式。你可以用以下函数创建水平或垂直按钮盒：

GtkWidget *gtk_hbutton_box_new( void );

GtkWidget *gtk_vbutton_box_new( void );

将按钮添加到按钮盒中可以用下面这个通常的函数：

gtk_container_add (GTK_CONTAINER (button_box), child_widget);

下面的示例演示了按钮盒的不同布局设置。

#include <gtk/gtk.h>

/* 用指定的参数创建一个按钮盒 */
GtkWidget *create_bbox( gint horizontal,
                        char *title,
                        gint spacing,
                        gint child_w,
                        gint child_h,
                        gint layout )
{
GtkWidget *frame;
GtkWidget *bbox;
GtkWidget *button;

frame = gtk_frame_new (title);

if (horizontal)
    bbox = gtk_hbutton_box_new ();
else
    bbox = gtk_vbutton_box_new ();

gtk_container_set_border_width (GTK_CONTAINER (bbox), 5);
gtk_container_add (GTK_CONTAINER (frame), bbox);

/* 设置按钮盒的外观 */
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), layout);
gtk_box_set_spacing (GTK_BOX (bbox), spacing);
/*gtk_button_box_set_child_size (GTK_BUTTON_BOX (bbox), child_w, child_h);*/

button = gtk_button_new_from_stock (GTK_STOCK_OK);
  gtk_container_add (GTK_CONTAINER (bbox), button);

button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_container_add (GTK_CONTAINER (bbox), button);

button = gtk_button_new_from_stock (GTK_STOCK_HELP);
gtk_container_add (GTK_CONTAINER (bbox), button);

return frame;
}

int main( int   argc, char *argv[] )
{
static GtkWidget* window = NULL;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *frame_horz;
GtkWidget *frame_vert;

/* 初始化 */
gtk_init (&argc, &argv);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Button Boxes");

g_signal_connect (G_OBJECT (window), "destroy",
                  G_CALLBACK (gtk_main_quit),
                  NULL);

gtk_container_set_border_width (GTK_CONTAINER (window), 10);

main_vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);

frame_horz = gtk_frame_new ("Horizontal Button Boxes");
gtk_box_pack_start (GTK_BOX (main_vbox), frame_horz, TRUE, TRUE, 10);

vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_container_add (GTK_CONTAINER (frame_horz), vbox);

gtk_box_pack_start (GTK_BOX (vbox),
          create_bbox (TRUE, "Spread (spacing 40)", 40, 85, 20, GTK_BUTTONBOX_SPREAD),
                    TRUE, TRUE, 0);

gtk_box_pack_start (GTK_BOX (vbox),
          create_bbox (TRUE, "Edge (spacing 30)", 30, 85, 20, GTK_BUTTONBOX_EDGE),
                    TRUE, TRUE, 5);

gtk_box_pack_start (GTK_BOX (vbox),
           create_bbox (TRUE, "Start (spacing 20)", 20, 85, 20, GTK_BUTTONBOX_START),
                    TRUE, TRUE, 5);

gtk_box_pack_start (GTK_BOX (vbox),
          create_bbox (TRUE, "End (spacing 10)", 10, 85, 20, GTK_BUTTONBOX_END),
                    TRUE, TRUE, 5);

frame_vert = gtk_frame_new ("Vertical Button Boxes");
gtk_box_pack_start (GTK_BOX (main_vbox), frame_vert, TRUE, TRUE, 10);

hbox = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_container_add (GTK_CONTAINER (frame_vert), hbox);

gtk_box_pack_start (GTK_BOX (hbox),
           create_bbox (FALSE, "Spread (spacing 5)", 5, 85, 20, GTK_BUTTONBOX_SPREAD),
                    TRUE, TRUE, 0);

gtk_box_pack_start (GTK_BOX (hbox),
           create_bbox (FALSE, "Edge (spacing 30)", 30, 85, 20, GTK_BUTTONBOX_EDGE),
                    TRUE, TRUE, 5);

gtk_box_pack_start (GTK_BOX (hbox),
           create_bbox (FALSE, "Start (spacing 20)", 20, 85, 20, GTK_BUTTONBOX_START),
                    TRUE, TRUE, 5);

gtk_box_pack_start (GTK_BOX (hbox),
           create_bbox (FALSE, "End (spacing 20)", 20, 85, 20, GTK_BUTTONBOX_END),
                    TRUE, TRUE, 5);

gtk_widget_show_all (window);

/* 进入事件循环 */
gtk_main ();
   
return 0;
}

angelblack

滚动窗口(Scrolled windows)用于创建一个可滚动区域，并将其它构件放入其中。可以在滚动窗口中插入任何其它构件，在其内部的构件不论尺寸大小都可以通过滚动条访问到。

用下面的函数创建新的滚动窗口。

GtkWidget *gtk_scrolled_window_new( GtkAdjustment *hadjustment, GtkAdjustment *vadjustment );

第一个参数是水平方向的调整对象，第二个参数是垂直方向的调整对象。它们一般都设置为NULL。

void gtk_scrolled_window_set_policy( GtkScrolledWindow *scrolled_window,
                                     GtkPolicyType      hscrollbar_policy,
                                     GtkPolicyType      vscrollbar_policy );

这个函数可以设置滚动条出现的方式。第一个参数是要设置的滚动窗口，第二个设置水平滚动条出现的方式，第三个参数设置垂直滚动条出现的方式。

滚动条的方式取值可以为GTK_POLICY_AUTOMATIC或GTK_POLICY_ALWAYS。当要求滚动条根据需要自动出现时， 可设为GTK_POLICY_AUTOMATIC ；若设为GTK_POLICY_ALWAYS，滚动条会一直出现在滚动窗口上。

可以用下面的函数将构件放到滚动窗口里：

void gtk_scrolled_window_add_with_viewport( GtkScrolledWindow *scrolled_window,
                                            GtkWidget         *child);

下面是一个简单示例：在滚动窗口构件中放置一个表格构件，并在表格中放100个开关按钮。我将只对那些你可能比较陌生的代码作些注释。

#include <stdio.h>
#include <gtk/gtk.h>

void destroy( GtkWidget *widget, gpointer   data )
{
    gtk_main_quit ();
}

int main( int   argc, char *argv[] )
{
    static GtkWidget *window;
    GtkWidget *scrolled_window;
    GtkWidget *table;
    GtkWidget *button;
    char buffer[32];
    int i, j;
   
    gtk_init (&argc, &argv);
   
    /* 创建一个新的对话框窗口，滚动窗口就放在这个窗口上 */
    window = gtk_dialog_new ();
    g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL);
    gtk_window_set_title (GTK_WINDOW (window), "GtkScrolledWindow example");
    gtk_container_set_border_width (GTK_CONTAINER (window), 0);
    gtk_widget_set_size_request (window, 300, 300);
   
    /* 创建一个新的滚动窗口。 */
    scrolled_window = gtk_scrolled_window_new (NULL, NULL);
   
    gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
   
    /* 滚动条的出现方式可以是GTK_POLICY_AUTOMATIC 或GTK_POLICY_ALWAYS。
     * 设为GTK_POLICY_AUTOMATIC将自动决定是否需要出现滚动条
     * 而设为GTK_POLICY_ALWAYS，将一直显示一个滚动条
     * 第一个是设置水平滚动条，第二个是垂直滚动条 */
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
    /* 对话框窗口内部包含一个vbox构件 */                                                        
    gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scrolled_window,
                     TRUE, TRUE, 0);
    gtk_widget_show (scrolled_window);
   
    /* 创建一个包含10×10个格子的表格 */
    table = gtk_table_new (10, 10, FALSE);
   
    /* 设置x和y方向的行间间距为10像素 */
    gtk_table_set_row_spacings (GTK_TABLE (table), 10);
    gtk_table_set_col_spacings (GTK_TABLE (table), 10);
   
    /* 将表格组装到滚动窗口中 */
    gtk_scrolled_window_add_with_viewport (
                   GTK_SCROLLED_WINDOW (scrolled_window), table);
    gtk_widget_show (table);
   
    /* 简单地在表格中添加许多开关按钮以展示滚动窗口 */
    for (i = 0; i < 10; i++)
       for (j = 0; j < 10; j++) {
          sprintf (buffer, "button (%d,%d)\n", i, j);
        button = gtk_toggle_button_new_with_label (buffer);
        gtk_table_attach_defaults (GTK_TABLE (table), button,
                                    i, i+1, j, j+1);
          gtk_widget_show (button);
       }
   
    /* 在对话框的底部添加一个"close"按钮 */
    button = gtk_button_new_with_label ("close");
    g_signal_connect_swapped (G_OBJECT (button), "clicked",
                           G_CALLBACK (gtk_widget_destroy),
                           window);
   
    /* 让按钮能被缺省 */
    GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
    gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0);
   
    /* 将按钮固定为缺省按钮，只要按回车键就相当于点击了这个按钮 */
    gtk_widget_grab_default (button);
    gtk_widget_show (button);
   
    gtk_widget_show (window);
   
    gtk_main();
   
    return 0;
}

尝试改变窗口的大小，可以看到滚动条是如何起作用的。还可以用 gtk_widget_set_size_request() 函数设置窗口或其它构件的缺省尺寸。

angelblack

呼~~剩下的明天再发，论坛的搜索功能不好用，我也不知道是不是有人发过，如果重复或侵犯了某人的版权……请版主删除吧

realtang

引用请注明出处，下不为例。