原文： http://zetcode.com/gui/gtk2/menusandtoolbars/

在 GTK+ 编程教程的这一部分中，我们使用菜单和工具栏。菜单栏是 GUI 应用的常见部分。 它是位于各个菜单中的一组命令。

GtkMenuBar是创建菜单栏的窗口小部件。 它包含一对多GtkMenuItems。 菜单项是用户可以选择的对象。 GtkMenu实现了一个由GtkMenuItem对象列表组成的下拉菜单，用户可以对其进行导航和激活以执行应用功能。 GtkMenu附加到菜单栏的菜单项或另一个菜单的菜单项。

GTK 中的菜单和工具栏 - 图1

图：菜单

该图显示了菜单栏及其菜单的结构。

简单菜单示例

在第一个示例中，我们创建带有一个“文件”菜单的菜单栏。

simplemenu.c

  1. #include <gtk/gtk.h>
  3. int main(int argc, char *argv[]) {
  5.   GtkWidget *window;
  6.   GtkWidget *vbox;
  8.   GtkWidget *menubar;
  9.   GtkWidget *fileMenu;
  10.   GtkWidget *fileMi;
  11.   GtkWidget *quitMi;
  13.   gtk_init(&argc, &argv);
  15.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  16.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  17.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  18.   gtk_window_set_title(GTK_WINDOW(window), "Simple menu");
  20.   vbox = gtk_vbox_new(FALSE, 0);
  21.   gtk_container_add(GTK_CONTAINER(window), vbox);
  23.   menubar = gtk_menu_bar_new();
  24.   fileMenu = gtk_menu_new();
  26.   fileMi = gtk_menu_item_new_with_label("File");
  27.   quitMi = gtk_menu_item_new_with_label("Quit");
  29.   gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileMi), fileMenu);
  30.   gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), quitMi);
  31.   gtk_menu_shell_append(GTK_MENU_SHELL(menubar), fileMi);
  32.   gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
  34.   g_signal_connect(G_OBJECT(window), "destroy",
  35.         G_CALLBACK(gtk_main_quit), NULL);
  37.   g_signal_connect(G_OBJECT(quitMi), "activate",
  38.         G_CALLBACK(gtk_main_quit), NULL);
  40.   gtk_widget_show_all(window);
  42.   gtk_main();
  44.   return 0;
  45. }

示例中的菜单具有一个菜单项。 通过选择项目，应用退出。

  1. menubar = gtk_menu_bar_new();

gtk_menu_bar_new()创建一个新的GtkMenuBar。

  1. filemenu = gtk_menu_new();

gtk_menu_new()函数创建一个新的GtkMenu。

  1. gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileMi), fileMenu);

通过gtk_menu_item_set_submenu()函数将fileMenu设置为文件菜单项。 菜单是容纳菜单项的容器。 它们本身已插入特定的菜单项。

  1. gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), quitMi);

通过gtk_menu_shell_append()函数将quitMi添加到文件菜单。

  1. gtk_menu_shell_append(GTK_MENU_SHELL(menubar), fileMi);

使用gtk_menu_shell_append()函数将文件菜单项添加到菜单栏。 GtkMenu和GtkMenuBar均来自GtkMenuShell。

  1. g_signal_connect(G_OBJECT(quitMi), "activate",
  2.     G_CALLBACK(gtk_main_quit), NULL);

通过选择退出菜单项，我们终止了该应用。

GTK 中的菜单和工具栏 - 图2

图：简单菜单

子菜单

下一个示例演示如何创建子菜单。 子菜单是另一个菜单中的菜单。

submenu.c

  1. #include <gtk/gtk.h>
  3. int main(int argc, char *argv[]) {
  5.   GtkWidget *window;
  6.   GtkWidget *vbox;
  8.   GtkWidget *menubar;
  9.   GtkWidget *fileMenu;
  10.   GtkWidget *imprMenu;
  11.   GtkWidget *sep;
  12.   GtkWidget *fileMi;
  13.   GtkWidget *imprMi;
  14.   GtkWidget *feedMi;
  15.   GtkWidget *bookMi;
  16.   GtkWidget *mailMi;
  17.   GtkWidget *quitMi;
  19.   gtk_init(&argc, &argv);
  21.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  22.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  23.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  24.   gtk_window_set_title(GTK_WINDOW(window), "Submenu");
  26.   vbox = gtk_vbox_new(FALSE, 0);
  27.   gtk_container_add(GTK_CONTAINER(window), vbox);
  29.   menubar = gtk_menu_bar_new();
  31.   fileMenu = gtk_menu_new();
  32.   fileMi = gtk_menu_item_new_with_label("File");
  34.   imprMenu = gtk_menu_new();
  35.   imprMi = gtk_menu_item_new_with_label("Import");
  36.   feedMi = gtk_menu_item_new_with_label("Import news feed...");
  37.   bookMi = gtk_menu_item_new_with_label("Import bookmarks...");
  38.   mailMi = gtk_menu_item_new_with_label("Import mail...");
  40.   gtk_menu_item_set_submenu(GTK_MENU_ITEM(imprMi), imprMenu);
  41.   gtk_menu_shell_append(GTK_MENU_SHELL(imprMenu), feedMi);
  42.   gtk_menu_shell_append(GTK_MENU_SHELL(imprMenu), bookMi);
  43.   gtk_menu_shell_append(GTK_MENU_SHELL(imprMenu), mailMi);
  44.   sep = gtk_separator_menu_item_new();  
  45.   quitMi = gtk_menu_item_new_with_label("Quit");
  47.   gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileMi), fileMenu);
  48.   gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), imprMi);
  49.   gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), sep);
  50.   gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), quitMi);
  51.   gtk_menu_shell_append(GTK_MENU_SHELL(menubar), fileMi);
  52.   gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
  54.   g_signal_connect(G_OBJECT(window), "destroy",
  55.         G_CALLBACK(gtk_main_quit), NULL);
  57.   g_signal_connect(G_OBJECT(quitMi), "activate",
  58.         G_CALLBACK(gtk_main_quit), NULL);
  60.   gtk_widget_show_all(window);
  62.   gtk_main();
  64.   return 0;
  65. }

该示例在另一个菜单内创建一个菜单。 子菜单具有三个菜单项。 我们还添加了一个水平分隔符。

  1. imprMenu = gtk_menu_new();
  2. imprMi = gtk_menu_item_new_with_label("Import");
  3. feedMi = gtk_menu_item_new_with_label("Import news feed...");
  4. bookMi = gtk_menu_item_new_with_label("Import bookmarks...");
  5. mailMi = gtk_menu_item_new_with_label("Import mail...");

这是带有菜单项的子菜单。

  1. gtk_menu_item_set_submenu(GTK_MENU_ITEM(imprMi), imprMenu);

imprMenu子菜单被添加到其自己的菜单项中。

  1. gtk_menu_shell_append(GTK_MENU_SHELL(imprMenu), feedMi);
  2. gtk_menu_shell_append(GTK_MENU_SHELL(imprMenu), bookMi);
  3. gtk_menu_shell_append(GTK_MENU_SHELL(imprMenu), mailMi);

使用gtk_menu_shell_append()函数将三个菜单项添加到子菜单。

  1. sep = gtk_separator_menu_item_new();

使用gtk_separator_menu_item_new()函数创建水平菜单分隔符。

  1. gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), imprMi);
  2. gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), sep);

imprMi和分隔符通过gtk_menu_shell_append()函数添加到文件菜单。

GTK 中的菜单和工具栏 - 图3

图：子菜单

图像菜单，助记符和加速器

GtkImageMenuItem是一个菜单项，在文本标签旁边带有一个图标。 由于用户可以禁用菜单图标的显示，因此我们仍然需要填写文本标签。加速器是用于激活菜单项的键盘快捷键。助记符是 GUI 元素的键盘快捷键。 它们以带下划线的字符表示。 请注意，在某些环境中，我们首先需要按无鼠标修饰符（通常为Alt）以显示带下划线的字符。

我们可能还配置了不显示菜单图像的环境。 要打开菜单图像，我们启动gconf-editor并转到/desktop/gnome/interface/menus_have_icons并检查选项。

imagemenu.c

  1. #include <gtk/gtk.h>
  2. #include <gdk/gdkkeysyms.h>
  4. int main(int argc, char *argv[]) {
  6.   GtkWidget *window;
  7.   GtkWidget *vbox;
  9.   GtkWidget *menubar;
  10.   GtkWidget *fileMenu;
  11.   GtkWidget *fileMi;
  12.   GtkWidget *newMi;
  13.   GtkWidget *openMi;
  14.   GtkWidget *quitMi;
  16.   GtkWidget *sep;
  18.   GtkAccelGroup *accel_group = NULL;
  20.   gtk_init(&argc, &argv);
  22.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  23.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  24.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  25.   gtk_window_set_title(GTK_WINDOW(window), "Images");
  27.   vbox = gtk_vbox_new(FALSE, 0);
  28.   gtk_container_add(GTK_CONTAINER(window), vbox);
  30.   menubar = gtk_menu_bar_new();
  31.   fileMenu = gtk_menu_new();
  33.   accel_group = gtk_accel_group_new();
  34.   gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
  36.   fileMi = gtk_menu_item_new_with_mnemonic("_File");
  37.   newMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);
  38.   openMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
  39.   sep = gtk_separator_menu_item_new();
  40.   quitMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group);
  42.   gtk_widget_add_accelerator(quitMi, "activate", accel_group, 
  43.       GDK_q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); 
  45.   gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileMi), fileMenu);
  46.   gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), newMi);
  47.   gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), openMi);
  48.   gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), sep);
  49.   gtk_menu_shell_append(GTK_MENU_SHELL(fileMenu), quitMi);
  50.   gtk_menu_shell_append(GTK_MENU_SHELL(menubar), fileMi);
  51.   gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
  53.   g_signal_connect(G_OBJECT(window), "destroy",
  54.       G_CALLBACK(gtk_main_quit), NULL);
  56.   g_signal_connect(G_OBJECT(quitMi), "activate",
  57.       G_CALLBACK(gtk_main_quit), NULL);
  59.   gtk_widget_show_all(window);
  61.   gtk_main();
  63.   return 0;
  64. }

该示例包含三个带有图标的菜单项。 菜单项可以用助记符选择。 退出菜单项具有键盘加速器。

  1. accel_group = gtk_accel_group_new();
  2. gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
  3. ...
  4. quitMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group);
  6. gtk_widget_add_accelerator(quitMi, "activate", accel_group, 
  7.     GDK_q, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

加速器组是一组键盘加速器，通常附加到顶层窗口。 在这里，我们创建 Ctrl + Q 键盘加速器。

  1. fileMi = gtk_menu_item_new_with_mnemonic("_File");

gtk_menu_item_new_with_mnemonic()创建一个可以带有助记符的菜单项。 标签中的下划线表示菜单项的助记符。 该字符与无鼠标修饰符（通常为Alt）结合在一起。 在我们的情况下，我们创建了 Alt + F 助记符。

  1. newMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW, NULL);
  2. openMi = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);

gtk_image_menu_item_new_from_stock()创建一个GtkImageMenuItem，其中包含来自库存项目的图像和文本。

GTK 中的菜单和工具栏 - 图4

图：带图标的菜单项

CheckMenuItem

GtkCheckMenuItem是带有复选框的菜单项。

checkmenuitem.c

  1. #include <gtk/gtk.h>
  3. void toggle_statusbar(GtkWidget *widget, gpointer statusbar) {
  5.   if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
  7.     gtk_widget_show(statusbar);
  8.   } else {
  10.     gtk_widget_hide(statusbar);
  11.   }
  12. }
  14. int main(int argc, char *argv[]) {
  16.   GtkWidget *window;
  17.   GtkWidget *vbox;
  19.   GtkWidget *menubar;
  20.   GtkWidget *viewmenu;
  21.   GtkWidget *view;
  22.   GtkWidget *tog_stat;
  23.   GtkWidget *statusbar;
  25.   gtk_init(&argc, &argv);
  27.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  28.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  29.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  30.   gtk_window_set_title(GTK_WINDOW(window), "GtkCheckMenuItem");
  32.   vbox = gtk_vbox_new(FALSE, 0);
  33.   gtk_container_add(GTK_CONTAINER(window), vbox);
  35.   menubar = gtk_menu_bar_new();
  36.   viewmenu = gtk_menu_new();
  38.   view = gtk_menu_item_new_with_label("View");
  39.   tog_stat = gtk_check_menu_item_new_with_label("View statusbar");
  40.   gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tog_stat), TRUE);
  42.   gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), viewmenu);
  43.   gtk_menu_shell_append(GTK_MENU_SHELL(viewmenu), tog_stat);
  44.   gtk_menu_shell_append(GTK_MENU_SHELL(menubar), view);
  45.   gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
  47.   statusbar = gtk_statusbar_new();
  48.   gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 0);
  50.   g_signal_connect(G_OBJECT(window), "destroy",
  51.         G_CALLBACK(gtk_main_quit), NULL);
  53.   g_signal_connect(G_OBJECT(tog_stat), "activate", 
  54.         G_CALLBACK(toggle_statusbar), statusbar);
  56.   gtk_widget_show_all(window);
  58.   gtk_main();
  60.   return 0;
  61. }

该示例在“查看”菜单中包含一个GtkCheckMenuItem。 如果该复选框已激活，则显示状态栏小部件。

  1. tog_stat = gtk_check_menu_item_new_with_label("View statusbar");

gtk_check_menu_item_new_with_label()函数创建一个新的CheckMenuItem。

  1. statusbar = gtk_statusbar_new();

gtk_statusbar_new()函数创建一个新的GtkStatusbar小部件。 它用于向用户报告次要消息。

  1. if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
  3.   gtk_widget_show(statusbar);
  4. } else {
  6.   gtk_widget_hide(statusbar);
  7. }

如果菜单项中的复选框被激活，我们将显示状态栏小部件。 否则状态栏将被隐藏。

GTK 中的菜单和工具栏 - 图5

图：GtkCheckMenuItem

弹出菜单

在下一个示例中，我们创建一个弹出菜单。 弹出菜单也称为上下文菜单。 当我们右键单击 GUI 对象时，通常会显示这种类型的菜单。

popupmenu.c

  1. #include <gtk/gtk.h>
  3. int show_popup(GtkWidget *widget, GdkEvent *event) {
  5.   const gint RIGHT_CLICK = 3;
  7.   if (event->type == GDK_BUTTON_PRESS) {
  9.       GdkEventButton *bevent = (GdkEventButton *) event;
  11.       if (bevent->button == RIGHT_CLICK) {      
  13.           gtk_menu_popup(GTK_MENU(widget), NULL, NULL, NULL, NULL,
  14.               bevent->button, bevent->time);
  15.           }
  17.       return TRUE;
  18.   }
  20.   return FALSE;
  21. }
  23. int main(int argc, char *argv[]) {
  25.   GtkWidget *window;
  26.   GtkWidget *ebox;
  27.   GtkWidget *pmenu;
  28.   GtkWidget *hideMi;
  29.   GtkWidget *quitMi;
  31.   gtk_init(&argc, &argv);
  33.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  34.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  35.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  36.   gtk_window_set_title(GTK_WINDOW(window), "Popup menu");
  38.   ebox = gtk_event_box_new();
  39.   gtk_container_add(GTK_CONTAINER(window), ebox);
  41.   pmenu = gtk_menu_new();
  43.   hideMi = gtk_menu_item_new_with_label("Minimize");
  44.   gtk_widget_show(hideMi);
  45.   gtk_menu_shell_append(GTK_MENU_SHELL(pmenu), hideMi);
  47.   quitMi = gtk_menu_item_new_with_label("Quit");
  48.   gtk_widget_show(quitMi);
  49.   gtk_menu_shell_append(GTK_MENU_SHELL(pmenu), quitMi);
  51.   g_signal_connect_swapped(G_OBJECT(hideMi), "activate", 
  52.       G_CALLBACK(gtk_window_iconify), GTK_WINDOW(window));    
  54.   g_signal_connect(G_OBJECT(quitMi), "activate", 
  55.       G_CALLBACK(gtk_main_quit), NULL);  
  57.   g_signal_connect(G_OBJECT(window), "destroy",
  58.       G_CALLBACK(gtk_main_quit), NULL);
  60.   g_signal_connect_swapped(G_OBJECT(ebox), "button-press-event", 
  61.       G_CALLBACK(show_popup), pmenu);  
  63.   gtk_widget_show_all(window);
  65.   gtk_main();
  67.   return 0;
  68. }

在代码示例中，我们创建带有两个菜单项的弹出菜单。 第一个最小化窗口，第二个终止应用。

  1. ebox = gtk_event_box_new();
  2. gtk_container_add(GTK_CONTAINER(window), ebox);

为了处理按钮按下事件，我们创建了一个GtkEventBox。

  1. pmenu = gtk_menu_new();

弹出菜单是GtkMenu。

  1. hideMi = gtk_menu_item_new_with_label("Minimize");
  2. gtk_widget_show(hideMi);
  3. gtk_menu_shell_append(GTK_MENU_SHELL(pmenu), hideMi);

第一个菜单项已添加到弹出菜单。

  1. g_signal_connect_swapped(G_OBJECT(hideMi), "activate", 
  2.     G_CALLBACK(gtk_window_iconify), GTK_WINDOW(window));

选择第一个菜单项将使窗口最小化。 我们将“隐藏”菜单项的activate信号连接到gtk_window_iconify()函数。 术语“图标化”是“最小化”的同义词。

  1. g_signal_connect_swapped(G_OBJECT(ebox), "button_press_event", 
  2.     G_CALLBACK(show_popup), pmenu);

当按下鼠标按钮时，会发出button-press-event信号。 我们将信号连接到show_popup()函数，然后将其传递给弹出菜单。

  1. if (event->type == GDK_BUTTON_PRESS) {

在事件处理器内部，我们检查按钮按下事件的类型。

  1. if (bevent->button == RIGHT_CLICK) {      
  3.     gtk_menu_popup(GTK_MENU(widget), NULL, NULL, NULL, NULL,
  4.         bevent->button, bevent->time);
  5. }

当触发信号的按钮是鼠标右键时，我们将显示带有gtk_menu_popup()函数的弹出菜单。

GTK 中的菜单和工具栏 - 图6

图：弹出菜单

工具栏

菜单将我们可以在应用中使用的命令分组。 使用工具栏可以快速访问最常用的命令。 GtkToolbar是 GTK+ 中的工具栏小部件。 工具栏可以包含GtkToolItem子类的实例，例如 GtkToolButton或GtkSeparatorToolItem。

toolbar.c

  1. #include <gtk/gtk.h>
  3. int main(int argc, char *argv[]) {
  5.   GtkWidget *window;
  6.   GtkWidget *vbox;
  8.   GtkWidget *toolbar;
  9.   GtkToolItem *newTb;
  10.   GtkToolItem *openTb;
  11.   GtkToolItem *saveTb;
  12.   GtkToolItem *sep;
  13.   GtkToolItem *exitTb;
  15.   gtk_init(&argc, &argv);
  17.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  18.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  19.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  20.   gtk_window_set_title(GTK_WINDOW(window), "toolbar");
  22.   vbox = gtk_vbox_new(FALSE, 0);
  23.   gtk_container_add(GTK_CONTAINER(window), vbox);
  25.   toolbar = gtk_toolbar_new();
  26.   gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
  28.   newTb = gtk_tool_button_new_from_stock(GTK_STOCK_NEW);
  29.   gtk_toolbar_insert(GTK_TOOLBAR(toolbar), newTb, -1);
  31.   openTb = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
  32.   gtk_toolbar_insert(GTK_TOOLBAR(toolbar), openTb, -1);
  34.   saveTb = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE);
  35.   gtk_toolbar_insert(GTK_TOOLBAR(toolbar), saveTb, -1);
  37.   sep = gtk_separator_tool_item_new();
  38.   gtk_toolbar_insert(GTK_TOOLBAR(toolbar), sep, -1); 
  40.   exitTb = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
  41.   gtk_toolbar_insert(GTK_TOOLBAR(toolbar), exitTb, -1);
  43.   gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 5);
  45.   g_signal_connect(G_OBJECT(exitTb), "clicked", 
  46.         G_CALLBACK(gtk_main_quit), NULL);
  48.   g_signal_connect(G_OBJECT(window), "destroy",
  49.         G_CALLBACK(gtk_main_quit), NULL);
  51.   gtk_widget_show_all(window);
  53.   gtk_main();
  55.   return 0;
  56. }

该代码示例创建了简单的工具栏示例。

  1. toolbar = gtk_toolbar_new();

gtk_toolbar_new()函数创建一个新的GtkToolBar小部件。

  1. gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS)

gtk_toolbar_set_style()函数将工具栏的视图更改为仅显示图标，仅显示文本或同时显示两者。 传递GTK_TOOLBAR_ICONS常量可使工具栏仅显示图标。

  1. newTb = gtk_tool_button_new_from_stock(GTK_STOCK_NEW);

gtk_tool_button_new_from_stock()函数创建一个新的GtkToolButton，其中包含来自库存项目的图像和文本。

  1. gtk_toolbar_insert(GTK_TOOLBAR(toolbar), new, -1);

gtk_toolbar_insert()函数将GtkToolItem插入工具栏的指定位置。 如果位置为负，则该项目将附加到工具栏的末尾。

  1. sep = gtk_separator_tool_item_new();
  2. gtk_toolbar_insert(GTK_TOOLBAR(toolbar), sep, -1);

gtk_separator_tool_item_new()函数创建一个新的GtkSeparatorToolItem。 它通过gtk_toolbar_insert()函数插入到工具栏中。

GTK 中的菜单和工具栏 - 图7

图：工具栏

撤销重做

下面的示例演示如何禁用工具栏上的工具栏按钮。 这是 GUI 编程中的常见做法。 例如，保存按钮； 如果我们将文档的所有更改都保存到磁盘上，则在大多数文本编辑器中，“保存”按钮均处于禁用状态。 这样，应用会向用户指示所有更改都已保存。

undoredo.c

  1. #include <gtk/gtk.h>
  3. void undo_redo(GtkWidget *widget,  gpointer item) {
  5.   static gint count = 2;
  6.   const gchar *name = gtk_widget_get_name(widget);
  8.   if (g_strcmp0(name, "undo") ) {
  9.     count++;
  10.   } else {
  11.     count--;
  12.   }
  14.   if (count < 0) {
  15.      gtk_widget_set_sensitive(widget, FALSE);
  16.      gtk_widget_set_sensitive(item, TRUE);
  17.   } 
  19.   if (count > 5) {
  20.      gtk_widget_set_sensitive(widget, FALSE);
  21.      gtk_widget_set_sensitive(item, TRUE);
  22.   }
  23. }
  25. int main(int argc, char *argv[]) {
  27.   GtkWidget *window;
  28.   GtkWidget *vbox;
  30.   GtkWidget *toolbar;
  31.   GtkToolItem *undo;
  32.   GtkToolItem *redo;
  33.   GtkToolItem *sep;
  34.   GtkToolItem *exit;
  36.   gtk_init(&argc, &argv);
  38.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  39.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  40.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  41.   gtk_window_set_title(GTK_WINDOW(window), "Undo redo");
  43.   vbox = gtk_vbox_new(FALSE, 0);
  44.   gtk_container_add(GTK_CONTAINER(window), vbox);
  46.   toolbar = gtk_toolbar_new();
  47.   gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
  49.   gtk_container_set_border_width(GTK_CONTAINER(toolbar), 2);
  51.   undo = gtk_tool_button_new_from_stock(GTK_STOCK_UNDO);
  52.   gtk_widget_set_name(GTK_WIDGET(undo), "undo");
  53.   gtk_toolbar_insert(GTK_TOOLBAR(toolbar), undo, -1);
  55.   redo = gtk_tool_button_new_from_stock(GTK_STOCK_REDO);
  56.   gtk_toolbar_insert(GTK_TOOLBAR(toolbar), redo, -1);
  58.   sep = gtk_separator_tool_item_new();
  59.   gtk_toolbar_insert(GTK_TOOLBAR(toolbar), sep, -1); 
  61.   exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
  62.   gtk_toolbar_insert(GTK_TOOLBAR(toolbar), exit, -1);
  64.   gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
  66.   g_signal_connect(G_OBJECT(undo), "clicked", 
  67.         G_CALLBACK(undo_redo), redo);
  69.   g_signal_connect(G_OBJECT(redo), "clicked", 
  70.         G_CALLBACK(undo_redo), undo);
  72.   g_signal_connect(G_OBJECT(exit), "clicked", 
  73.         G_CALLBACK(gtk_main_quit), NULL);
  75.   g_signal_connect(G_OBJECT(window), "destroy",
  76.         G_CALLBACK(gtk_main_quit), NULL);
  78.   gtk_widget_show_all(window);
  80.   gtk_main();
  82.   return 0;
  83. }

我们的示例从 GTK+ 库存资源创建撤消和重做按钮。 单击几下后，每个按钮均被禁用。 按钮显示为灰色。

  1. if (count < 0) {
  2.    gtk_widget_set_sensitive(widget, FALSE);
  3.    gtk_widget_set_sensitive(item, TRUE);
  4. } 
  6. if (count > 5) {
  7.    gtk_widget_set_sensitive(widget, FALSE);
  8.    gtk_widget_set_sensitive(item, TRUE);
  9. }

gtk_widget_set_sensitive()函数用于激活或禁用工具栏按钮。

GTK 中的菜单和工具栏 - 图8

图：撤销和重做

在本章中，我们介绍了 GTK+ 中的菜单和工具栏。