完成课设，偶然碰到GTK，索性学习一遍

转载自ikoDotA の BLOG

（一）、一步一步学GTK+之开篇

一、什么是GTK+

  1. GTK+ 是一种函数库是用来帮助制作图形交互界面的。整个函数库都是由C 语言来编写的。 GTK+函数库通常也叫做 GIMP 工具包。因为，一开始GTK+是用来编写“GIMP”–这个图形处理软件的。从那以后， GTK+就逐渐成为了Linux and BSDUnix 下最受欢迎的用于图形交互界面（GUI）设计的工具包之一。时至今日,大多数的Linux 下的GUI 软件（有图形交互界面）都是由GTK+或者QT 来编写的。GTK+是一种面向对象式的API(applicationprogramming interface)。Glib 是GTK+的基础，而这种“面向对象系统”正是由“Glib”来提供的。GObject 也就是这种面向对象的机制可以为 GTK+绑定很多种开发语言。目前存在的语言有：C++, Python, Perl, Java, C#，PHP,等其他高级语言。

GTK+ 和以下“函数库”存在着依赖关系

• Glib

• Pango

• ATK

• GDK

• GdkPixbuf

• Cairo

Glib 是一种通用的函数库。她提供了各种各样的语言特性，譬如说：各种数据类型，字符串函数，错误通知，消息队列和线程。Pango 是一种函数库，用来实现国际化和本地化的功能。ATK是一种平易近人的工具函数包，她提供了快捷键服务为肢体有缺陷的人使用电脑提供了便利。GDK 是一种函数库，她为整个GTK+图形库系统提供了一些底层的“图形实现”和“窗口实现”的方法。在Linux 中GDK 是位于X 服务器和GTK+函数库之间的。在最近的GTK+发行版本中，越来越多的功能性函数，都交给了Cairo 函数库来处理。GdkPixbuf 函数库是一种函数库工具包用于加载图像和维护图像“缓存”的（pixel buffer）。Cairo 是一种函数库用于制作二维图像。从GTK+2.8 版本以后，Cairo 就正式成为GTK+系统中的一员了。Gnome and XFce 桌面环境系统都是用GTK+来编程实现的. SWT and wxWidgets 是种很著名的编程框架,也是用GTK+来编程实现的。最杰出的GTK+软件的代表是Firefox （火狐浏览器）和 Inkscape。

二、GTK安装

此部分未自主创作内容，非转载,主要面向linux系统，笔者系统Ubuntu 17.10

1、安装codeblocks

自主上网下载或者Ubuntu软件商店中下载

2、安装GTK+

（1）安装gcc/g++/gdb/make 等基本编程工具

$sudo apt-get install build-essential

（2）安装 libgtk2.0-dev libglib2.0-dev 等开发相关的库文件

$sudo apt-get install gnome-core-devel

（3）用于在编译GTK程序时自动找出头文件及库文件位置　　

$sudo apt-get install pkg-config

（4）安装 devhelp GTK文档查看程序

$sudo apt-get install devhelp

（5）安装 gtk/glib 的API参考手册及其它帮助文档

$sudo apt-get install libglib2.0-doc libgtk2.0-doc

（6）安装基于GTK的界面GTK是开发Gnome窗口的c/c++语言图形库

sudoapt−getinstallgladelibglade2−dev或者sudo apt-get install glade-gnome glade-common glade-doc

（7）安装gtk2.0 或者 将gtk+2.0所需的所有文件统通下载安装完毕

sudoapt−getinstalllibgtk2.0−dev或者sudo apt-get install libgtk2.0*

查看GTK库版本

（1）查看 2.x 版本

$pkg-config –modversion gtk+-2.0

（2）查看pkg-config的版本

$pkg-config –version

（3）查看是否安装了gtk

$pkg-config –list-all grep gtk

注意：在测试是否装成功的时候，注意Codeblocks不能有中文路径名称

3.配置code::blocks中的GTK+编译器

现在安装了gtk后，可以用pkg-config –list-all 查看，其中应该包含一个gtk+-2.0.

在code::blocks中 默认的编译器是GNU GCC Compiler，我们为 GTK单独设置一个编译器：

Settings -> Compiler settings ,选择GNU GCC Compiler 然后点击 copy ,输入一个gtk编译器的名称：GUN GCC Compiler GTK2.0,并设置为默认编译器,点击 set as default .然后在 Compiler settings -> Other options -> 添加pkg-config --cflags gtk+-2.0(目的是添加include),在linker settings -> Other linker options 中也添加 pkg-config –libs gtk+-2.0`（目的是添加lib），如果在windows下运行时候可能会报错，如果缺少zlib1.dll ，放在 工程/bin/Debug下即可。

4.测试一下环境是否正确

在codeblocks中新建一个工程，选择上面新添加的编译器（GUN GCC Compiler GTK2.0），然后在main.c中添加代码：

  1. #include <gtk/gtk.h>
  2. int main( int argc, char *argv[])
  3. {
  4.     GtkWidget *window;
  5.     gtk_init(&argc, &argv);
  6.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  7.     gtk_widget_show(window);
  8.     gtk_main();
  9.     return 0;
  10. }

编译并执行出现一个空白窗体（linux下在命令行下执行），即代表gtk+的开发环境配置成功了。

顺便说下可以直接用gcc命令行生成：

  1. gcc -o hello-world main.c  `pkg-config --cflags --libs gtk+-2.0`

（二）、一步一步学GTK+之窗口

本系列不准备对GTK+的各个组件分别介绍，这会让人觉得很无趣，采用开发一个小软件作为演示，该软件的功能就是演示GTK+的控件应用，以达到学习目的。在上一篇的最后我给出了一段代码来测试环境——显示了一个空白的窗口，代码如下：

  1. #include <gtk/gtk.h>
  2. int main( int argc, char *argv[])
  3. {
  4.     GtkWidget *window;
  5.     /*初始化整个GTK+程序，是每一个GTK+程序必不可少的部分*/
  6.     gtk_init(&argc, &argv);
  7.     /*这里生成了一个窗口构件——GtkWindow，GTK_WINDOW_TOPLEVEL包含窗口的标题栏和边框，同意用窗口管理器来进行管理*/
  8.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  10.     /*开始显示窗口*/
  11.     gtk_widget_show(window);
  12.     gtk_main();
  13.     return 0;
  14. }

现在我们来给窗口做一些改进工作：

一、添加一个标题、设置默认大小以及显示位置。

  1. #include <gtk/gtk.h>
  2. int main( int argc, char *argv[])
  3. {
  4.     GtkWidget *window;
  5.     /*初始化整个GTK+程序，是每一个GTK+程序必不可少的部分*/
  6.     gtk_init(&argc, &argv);
  7.     /*这里生成了一个窗口构件——GtkWindow，GTK_WINDOW_TOPLEVEL包含窗口的标题栏和边框，同意用窗口管理器来进行管理*/
  8.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  9.     /*设置窗口标题*/
  10.     gtk_window_set_title(GTK_WINDOW(window), "一步一步学GTK+ DEMO");
  11.     /*设置窗口默认大小*/
  12.     gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
  13.     /*
  14.      * 设置窗口在显示器中的位置为居中。
  15.      *   GTK_WIN_POS_NONE            ：不固定
  16.      *   GTK_WIN_POS_CENTER          : 居中
  17.      *   GTK_WIN_POS_MOUSE           : 出现在鼠标位置
  18.      *   GTK_WIN_POS_CENTER_ALWAYS   : 窗口改变大小的时候仍然居中
  19.     */
  20.     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  22.     /*开始显示窗口*/
  23.     gtk_widget_show(window);
  24.     gtk_main();
  25.     return 0;
  26. }

二、设置应用程序的图标

  1. #include <gtk/gtk.h>
  3. /*
  4.   @Description: 从一个图片中获取信息得到pixbuf
  5.   @param:       gchar filename
  6. */
  7. GdkPixbuf *create_pixbuf(const gchar * filename)
  8. {
  9.     GdkPixbuf *pixbuf;
  10.     GError *error = NULL;
  11.     /*
  12.      * 函数gdk_pixbuf_new_from_file() 从一个图片文件中加载图象数据，从而生成一个新的 pixbuf，
  13.      * 至于文件中包含图象的格式，是由系统自动检测的。如果该函数返回值是NULL 的话，程序就会出现错误。
  14.     */
  15.     pixbuf = gdk_pixbuf_new_from_file(filename, &error);
  16.     if(!pixbuf) {
  17.         fprintf(stderr, "%s\n", error->message);
  18.         g_error_free(error);
  19.     }
  20.     return pixbuf;
  21. }
  23. int main( int argc, char *argv[])
  24. {
  25.     GtkWidget *window;
  26.     /*初始化整个GTK+程序，是每一个GTK+程序必不可少的部分*/
  27.     gtk_init(&argc, &argv);
  28.     /*这里生成了一个窗口构件——GtkWindow，GTK_WINDOW_TOPLEVEL包含窗口的标题栏和边框，同意用窗口管理器来进行管理*/
  29.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  30.     /*设置窗口标题*/
  31.     gtk_window_set_title(GTK_WINDOW(window), "一步一步学GTK+ DEMO");
  32.     /*设置窗口默认大小*/
  33.     gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
  34.     /*
  35.      * 设置窗口在显示器中的位置为居中。
  36.      *   GTK_WIN_POS_NONE            ：不固定
  37.      *   GTK_WIN_POS_CENTER          : 居中
  38.      *   GTK_WIN_POS_MOUSE           : 出现在鼠标位置
  39.      *   GTK_WIN_POS_CENTER_ALWAYS   : 窗口改变大小的时候仍然居中
  40.     */
  41.     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  43.     /*函数gtk_window_set_icon() 是为窗口设置图标用的，函数create_pixbuf是我们自定义的，目的是从一个图片中获取信息得到pixbuf。*/
  44.     gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("./images/bear.png"));
  46.     /*开始显示窗口*/
  47.     gtk_widget_show(window);
  48.     gtk_main();
  49.     return 0;
  50. }

三、当点击关闭窗口(X)时，应该结束程序

在命令行下运行这个demo,点击右上角的X时候，窗口虽然关闭了，但是程序还在运行，需要按ctrl+C（linux下 ctrl+D）来结束程序运行。我们希望点击X的时候就结束程序的运行。我们必须要明确为这个例子程序连接一个关闭的信号（destroy signal），然后调用回调函数gtk_main_quit() 实现结束程序。这里涉及到事件和信号会在日后讲到。

  1. #include <gtk/gtk.h>
  3. /*
  4.   @Description: 从一个图片中获取信息得到pixbuf
  5.   @param:       gchar filename
  6. */
  7. GdkPixbuf *create_pixbuf(const gchar * filename)
  8. {
  9.     GdkPixbuf *pixbuf;
  10.     GError *error = NULL;
  11.     /*
  12.      * 函数gdk_pixbuf_new_from_file() 从一个图片文件中加载图象数据，从而生成一个新的 pixbuf，
  13.      * 至于文件中包含图象的格式，是由系统自动检测的。如果该函数返回值是NULL 的话，程序就会出现错误。
  14.     */
  15.     pixbuf = gdk_pixbuf_new_from_file(filename, &error);
  16.     if(!pixbuf) {
  17.         fprintf(stderr, "%s\n", error->message);
  18.         g_error_free(error);
  19.     }
  20.     return pixbuf;
  21. }
  23. int main( int argc, char *argv[])
  24. {
  25.     GtkWidget *window;
  26.     /*初始化整个GTK+程序，是每一个GTK+程序必不可少的部分*/
  27.     gtk_init(&argc, &argv);
  28.     /*这里生成了一个窗口构件——GtkWindow，GTK_WINDOW_TOPLEVEL包含窗口的标题栏和边框，同意用窗口管理器来进行管理*/
  29.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  30.     /*设置窗口标题*/
  31.     gtk_window_set_title(GTK_WINDOW(window), "一步一步学GTK+ DEMO");
  32.     /*设置窗口默认大小*/
  33.     gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
  34.     /*
  35.      * 设置窗口在显示器中的位置为居中。
  36.      *   GTK_WIN_POS_NONE            ：不固定
  37.      *   GTK_WIN_POS_CENTER          : 居中
  38.      *   GTK_WIN_POS_MOUSE           : 出现在鼠标位置
  39.      *   GTK_WIN_POS_CENTER_ALWAYS   : 窗口改变大小的时候仍然居中
  40.     */
  41.     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  43.     /*函数gtk_window_set_icon() 是为窗口设置图标用的，函数create_pixbuf是我们自定义的，目的是从一个图片中获取信息得到pixbuf。*/
  44.     gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("./images/bear.png"));
  46.     /***********************************以下是信号处理部分************************************/
  48.     /*关闭窗口时退出主循环*/
  49.     g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit), NULL);
  51.     /***********************************以下是显示控件部分************************************/
  52.     /*开始显示窗口*/
  53.     gtk_widget_show(window);
  55.     gtk_main();
  56.     return 0;
  57. }

（三）、一步一步学GTK+之布局

本来想接上篇把关于窗口方面的写的更详尽一点，但因为我做软件的习惯来说还暂时用不不到、我们先跳过，然后先说说窗口中的布局。跟大多数软件界面一样，一般包含标题栏、菜单栏、工具栏、状态栏和工作区等。

首先，我必须要有一个初步的规划，因为是自己设计一些软件，我只需要问我自己几个问题（why/how），而不需要跟设计部进行沟通。

1.Q：为什么要设计这个demo？

A：初步认识GTK+的构件并应用到实际开发中，实现掌握GTK+的能力并能分享给大家。

2.Q:如何分享？demo有什么功能？

A:我通过逐步添加代码的方式，高亮显示能看到代码进化的过程，让本系列读者达到学习的目的；要全面接触到所有的GTK+的构建，那么只有把demo做成GTK+构件演示软件才能满足了。

3.Q:demo的界面大致是怎么样的？

A:基本的软件界面，通过菜单、工具栏等方式逐步演示界面上显示不到的功能。

4.Q:怎么样去划分demo的功能？

A:根据Glade 3中的划分，GTK+构建分为Toplevels、Containers、Controls and Display、Composite Widgets等类型。所以在菜单设计中可以按这个分类去设计。

好了，现在应该基本知道未来的demo大概是个什么样的了吧。

一、添加简单菜单栏，以后在逐步完善

  1.  在添加菜单栏之前、还需要用一个容器来将窗体划分为多个区域，以供放工具栏、状态栏等.我们从上到下分4栏，最上面是菜单栏，紧接着是工具栏，然后是工作区，最下面是状态栏。我们先添加一个容器vbox来划分区域，并加入toggle菜单。这个菜单的功能是让用户可以操作划分区域的显示和隐藏。
  1. #include <gtk/gtk.h>
  3. /*
  4.   @Description: 从一个图片中获取信息得到pixbuf
  5.   @param:       gchar filename
  6. */
  7. GdkPixbuf *create_pixbuf(const gchar * filename)
  8. {
  9.     GdkPixbuf *pixbuf;
  10.     GError *error = NULL;
  11.     /*
  12.      * 函数gdk_pixbuf_new_from_file() 从一个图片文件中加载图象数据，从而生成一个新的 pixbuf，
  13.      * 至于文件中包含图象的格式，是由系统自动检测的。如果该函数返回值是NULL 的话，程序就会出现错误。
  14.     */
  15.     pixbuf = gdk_pixbuf_new_from_file(filename, &error);
  16.     if(!pixbuf) {
  17.         fprintf(stderr, "%s\n", error->message);
  18.         g_error_free(error);
  19.     }
  20.     return pixbuf;
  21. }
  23. int main( int argc, char *argv[])
  24. {
  25.     GtkWidget *window;
  26.     GtkWidget *vbox;            //盒装容器
  27.     GtkWidget *menubar;         //菜单栏
  28.     GtkWidget *menutoggle, *menu_tog_toggle,*menu_tog_toolbar, *menu_tog_statusbar;  //界面开关菜单
  29.     //GtkWidget *menu_about, *menu_about_us;  //帮助菜单
  31.     /*初始化整个GTK+程序，是每一个GTK+程序必不可少的部分*/
  32.     gtk_init(&argc, &argv);
  33.     /*这里生成了一个窗口构件——GtkWindow，GTK_WINDOW_TOPLEVEL包含窗口的标题栏和边框，同意用窗口管理器来进行管理*/
  34.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  35.     /*设置窗口标题*/
  36.     gtk_window_set_title(GTK_WINDOW(window), "一步一步学GTK+ DEMO");
  37.     /*设置窗口默认大小*/
  38.     gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
  39.     /*
  40.      * 设置窗口在显示器中的位置为居中。
  41.      *   GTK_WIN_POS_NONE            ：不固定
  42.      *   GTK_WIN_POS_CENTER          : 居中
  43.      *   GTK_WIN_POS_MOUSE           : 出现在鼠标位置
  44.      *   GTK_WIN_POS_CENTER_ALWAYS   : 窗口改变大小的时候仍然居中
  45.     */
  46.     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  48.     /*函数gtk_window_set_icon() 是为窗口设置图标用的，函数create_pixbuf是我们自定义的，目的是从一个图片中获取信息得到pixbuf。*/
  49.     gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("./images/bear.png"));
  51.     /*创建一个盒装容器并添加到窗口中*/
  52.     vbox = gtk_vbox_new(FALSE, 0);
  53.     gtk_container_add(GTK_CONTAINER(window), vbox);
  55.     /*创建菜单*/
  56.     menubar = gtk_menu_bar_new();   //代表整个菜单,是一个menu shell
  58.     menutoggle = gtk_menu_new();   //这里代表第一列菜单toggle ,也是一个menu shell
  59.     menu_tog_toggle = gtk_menu_item_new_with_label("widget toggle");
  60.     menu_tog_toolbar = gtk_menu_item_new_with_label("show Toolbar"); //toggle 菜单中子项
  61.     menu_tog_statusbar = gtk_menu_item_new_with_label("show Statusbar");
  63.     gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_tog_toggle), menutoggle);  //widget toggle菜单加入 menutoggle menu shell
  64.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_toolbar);
  65.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_statusbar);
  67.     gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menu_tog_toggle);
  69.     /*把菜单加入盒子容器*/
  70.     gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);
  71.     /***********************************以下是信号处理部分************************************/
  73.     /*关闭窗口时退出主循环*/
  74.     g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit), NULL);
  76.     /***********************************以下是显示控件部分************************************/
  77.     /*开始显示窗口*/
  78.     //gtk_widget_show(window);
  79.     gtk_widget_show_all(window);
  81.     gtk_main();
  82.     return 0;
  83. }

二、添加状态栏，并点击任意菜单的时候在状态来显示内容

  1. #include <gtk/gtk.h>
  3. /*
  4.   @Description: 从一个图片中获取信息得到pixbuf
  5.   @param:       gchar filename
  6. */
  7. GdkPixbuf *create_pixbuf(const gchar * filename)
  8. {
  9.     GdkPixbuf *pixbuf;
  10.     GError *error = NULL;
  11.     /*
  12.      * 函数gdk_pixbuf_new_from_file() 从一个图片文件中加载图象数据，从而生成一个新的 pixbuf，
  13.      * 至于文件中包含图象的格式，是由系统自动检测的。如果该函数返回值是NULL 的话，程序就会出现错误。
  14.     */
  15.     pixbuf = gdk_pixbuf_new_from_file(filename, &error);
  16.     if(!pixbuf) {
  17.         fprintf(stderr, "%s\n", error->message);
  18.         g_error_free(error);
  19.     }
  20.     return pixbuf;
  21. }
  23. /*点击菜单时，状态栏显示*/
  24. void menu_pressed(GtkWidget *widget, gpointer window)
  25. {
  26.     gchar *str;
  27.     str = g_strdup_printf("you clicked one menu item");
  28.     gtk_statusbar_push(GTK_STATUSBAR(window),gtk_statusbar_get_context_id(GTK_STATUSBAR(window), str), str);
  29.     g_free(str);
  30. }
  32. int main( int argc, char *argv[])
  33. {
  34.     GtkWidget *window;
  35.     GtkWidget *vbox;            //盒装容器
  36.     GtkWidget *menubar;         //菜单栏
  37.     GtkWidget *menutoggle, *menu_tog_toggle,*menu_tog_toolbar, *menu_tog_statusbar;  //界面开关菜单
  38.     //GtkWidget *menu_about, *menu_about_us;  //帮助菜单
  39.     GtkWidget *statusbar;       //状态栏
  41.     /*初始化整个GTK+程序，是每一个GTK+程序必不可少的部分*/
  42.     gtk_init(&argc, &argv);
  43.     /*这里生成了一个窗口构件——GtkWindow，GTK_WINDOW_TOPLEVEL包含窗口的标题栏和边框，同意用窗口管理器来进行管理*/
  44.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  45.     /*设置窗口标题*/
  46.     gtk_window_set_title(GTK_WINDOW(window), "一步一步学GTK+ DEMO");
  47.     /*设置窗口默认大小*/
  48.     gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
  49.     /*
  50.      * 设置窗口在显示器中的位置为居中。
  51.      *   GTK_WIN_POS_NONE            ：不固定
  52.      *   GTK_WIN_POS_CENTER          : 居中
  53.      *   GTK_WIN_POS_MOUSE           : 出现在鼠标位置
  54.      *   GTK_WIN_POS_CENTER_ALWAYS   : 窗口改变大小的时候仍然居中
  55.     */
  56.     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  58.     /*函数gtk_window_set_icon() 是为窗口设置图标用的，函数create_pixbuf是我们自定义的，目的是从一个图片中获取信息得到pixbuf。*/
  59.     gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("./images/bear.png"));
  61.     /*创建一个盒装容器并添加到窗口中*/
  62.     vbox = gtk_vbox_new(FALSE, 0);
  63.     gtk_container_add(GTK_CONTAINER(window), vbox);
  65.     /*创建菜单*/
  66.     menubar = gtk_menu_bar_new();   //代表整个菜单,是一个menu shell
  68.     menutoggle = gtk_menu_new();   //这里代表第一列菜单toggle ,也是一个menu shell
  69.     menu_tog_toggle = gtk_menu_item_new_with_label("widget toggle");
  70.     menu_tog_toolbar = gtk_menu_item_new_with_label("show Toolbar"); //toggle 菜单中子项
  71.     menu_tog_statusbar = gtk_menu_item_new_with_label("show Statusbar");
  73.     gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_tog_toggle), menutoggle);  //widget toggle菜单加入 menutoggle menu shell
  74.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_toolbar);
  75.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_statusbar);
  77.     gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menu_tog_toggle);
  79.     /*把菜单加入盒子容器*/
  80.     gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 4);
  82.     statusbar = gtk_statusbar_new();
  83.     gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
  84.     /***********************************以下是信号处理部分************************************/
  86.     /*关闭窗口时退出主循环*/
  87.     g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit), NULL);
  88.     g_signal_connect(G_OBJECT(menu_tog_toolbar),"activate",G_CALLBACK(menu_pressed), G_OBJECT(statusbar));
  89.     g_signal_connect(G_OBJECT(menu_tog_statusbar),"activate",G_CALLBACK(menu_pressed), G_OBJECT(statusbar));
  91.     /***********************************以下是显示控件部分************************************/
  92.     /*开始显示窗口*/
  93.     //gtk_widget_show(window);
  94.     gtk_widget_show_all(window);
  96.     gtk_main();
  97.     return 0;
  98. }

状态栏的相关函数：

函数
guint gtk_statusbar_push (GtkStatusbar *statusbar, guint context_id, const gchar*text);
void gtk_statusbar_pop (GtkStatusbar *statusbar, guint context_id);
void gtk_statusbar_remove (GtkStatusbar *statusbar, guint context_id, guint message_id);
void gtk_statusbar_remove_all (GtkStatusbar *statusbar, guint context_id);

三、添加工具栏，并给“退出”按钮加入信号

  1. #include <gtk/gtk.h>
  3. /*
  4.   @Description: 从一个图片中获取信息得到pixbuf
  5.   @param:       gchar filename
  6. */
  7. GdkPixbuf *create_pixbuf(const gchar * filename)
  8. {
  9.     GdkPixbuf *pixbuf;
  10.     GError *error = NULL;
  11.     /*
  12.      * 函数gdk_pixbuf_new_from_file() 从一个图片文件中加载图象数据，从而生成一个新的 pixbuf，
  13.      * 至于文件中包含图象的格式，是由系统自动检测的。如果该函数返回值是NULL 的话，程序就会出现错误。
  14.     */
  15.     pixbuf = gdk_pixbuf_new_from_file(filename, &error);
  16.     if(!pixbuf) {
  17.         fprintf(stderr, "%s\n", error->message);
  18.         g_error_free(error);
  19.     }
  20.     return pixbuf;
  21. }
  23. /*点击菜单时，状态栏显示*/
  24. void menu_pressed(GtkWidget *widget, gpointer window)
  25. {
  26.     gchar *str;
  27.     str = g_strdup_printf("you click one menu item");
  28.     gtk_statusbar_push(GTK_STATUSBAR(window),gtk_statusbar_get_context_id(GTK_STATUSBAR(window), str), str);
  29.     g_free(str);
  30. }
  32. int main( int argc, char *argv[])
  33. {
  34.     GtkWidget *window;
  35.     GtkWidget *vbox;            //盒装容器
  36.     GtkWidget *menubar;         //菜单栏
  37.     GtkWidget *menutoggle, *menu_tog_toggle,*menu_tog_toolbar, *menu_tog_statusbar;  //界面开关菜单
  38.     //GtkWidget *menu_about, *menu_about_us;  //帮助菜单
  39.     GtkWidget *toolbar;         //工具栏
  40.     GtkToolItem *tool_exit, *tool_sep,*tool_about;
  41.     GtkWidget *statusbar;       //状态栏
  43.     /*初始化整个GTK+程序，是每一个GTK+程序必不可少的部分*/
  44.     gtk_init(&argc, &argv);
  45.     /*这里生成了一个窗口构件——GtkWindow，GTK_WINDOW_TOPLEVEL包含窗口的标题栏和边框，同意用窗口管理器来进行管理*/
  46.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  47.     /*设置窗口标题*/
  48.     gtk_window_set_title(GTK_WINDOW(window), "一步一步学GTK+ DEMO");
  49.     /*设置窗口默认大小*/
  50.     gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
  51.     /*
  52.      * 设置窗口在显示器中的位置为居中。
  53.      *   GTK_WIN_POS_NONE            ：不固定
  54.      *   GTK_WIN_POS_CENTER          : 居中
  55.      *   GTK_WIN_POS_MOUSE           : 出现在鼠标位置
  56.      *   GTK_WIN_POS_CENTER_ALWAYS   : 窗口改变大小的时候仍然居中
  57.     */
  58.     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  60.     /*函数gtk_window_set_icon() 是为窗口设置图标用的，函数create_pixbuf是我们自定义的，目的是从一个图片中获取信息得到pixbuf。*/
  61.     gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("./images/bear.png"));
  63.     /*创建一个盒装容器并添加到窗口中*/
  64.     vbox = gtk_vbox_new(FALSE, 0);
  65.     gtk_container_add(GTK_CONTAINER(window), vbox);
  67.     /*创建菜单*/
  68.     menubar = gtk_menu_bar_new();   //代表整个菜单,是一个menu shell
  70.     menutoggle = gtk_menu_new();   //这里代表第一列菜单toggle ,也是一个menu shell
  71.     menu_tog_toggle = gtk_menu_item_new_with_label("View");
  72.     menu_tog_toolbar = gtk_menu_item_new_with_label("show Toolbar"); //toggle 菜单中子项
  73.     menu_tog_statusbar = gtk_menu_item_new_with_label("show Statusbar");
  75.     gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_tog_toggle), menutoggle);  //widget toggle菜单加入 menutoggle menu shell
  76.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_toolbar);
  77.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_statusbar);
  79.     gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menu_tog_toggle);
  81.     //创建工具栏
  82.     toolbar = gtk_toolbar_new();
  83.     gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); //设置工具栏样式为图标
  84.     gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);      //工具栏边框大小
  86.     tool_exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);     //工具栏中的 “退出” 按钮
  87.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_exit, -1);
  89.     tool_sep = gtk_separator_tool_item_new();                       //工具栏中按钮之间的分割线
  90.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_sep, -1);
  92.     tool_about = gtk_tool_button_new_from_stock(GTK_STOCK_HELP);    //工具栏中的“关于” 按钮
  93.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_about, -1);
  95.     statusbar = gtk_statusbar_new();
  96.     /*把菜单加入盒子容器*/
  97.     gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 1);
  98.     /*把工具栏加入盒子容器*/
  99.     gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
  100.     /*把状态栏加入盒子最下面*/
  101.     gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
  103.     /***********************************以下是信号处理部分************************************/
  104.     /*关闭窗口时退出主循环*/
  105.     g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit), NULL);
  106.     g_signal_connect(G_OBJECT(tool_exit), "clicked",G_CALLBACK(gtk_main_quit), NULL);
  108.     g_signal_connect(G_OBJECT(menu_tog_toolbar),"activate",G_CALLBACK(menu_pressed), G_OBJECT(statusbar));
  109.     g_signal_connect(G_OBJECT(menu_tog_statusbar),"activate",G_CALLBACK(menu_pressed), G_OBJECT(statusbar));
  111.     /***********************************以下是显示控件部分************************************/
  112.     /*开始显示窗口*/
  113.     //gtk_widget_show(window);
  114.     gtk_widget_show_all(window);
  116.     gtk_main();
  117.     return 0;
  118. }

四、选择（Check）菜单选项（menu item）

移除刚才菜单点时候状态栏显示的功能，新增功能——控制工具栏和状态栏的显示/隐藏。

  1. #include <gtk/gtk.h>
  3. /*
  4.   @Description: 从一个图片中获取信息得到pixbuf
  5.   @param:       gchar filename
  6. */
  7. GdkPixbuf *create_pixbuf(const gchar * filename)
  8. {
  9.     GdkPixbuf *pixbuf;
  10.     GError *error = NULL;
  11.     /*
  12.      * 函数gdk_pixbuf_new_from_file() 从一个图片文件中加载图象数据，从而生成一个新的 pixbuf，
  13.      * 至于文件中包含图象的格式，是由系统自动检测的。如果该函数返回值是NULL 的话，程序就会出现错误。
  14.     */
  15.     pixbuf = gdk_pixbuf_new_from_file(filename, &error);
  16.     if(!pixbuf) {
  17.         fprintf(stderr, "%s\n", error->message);
  18.         g_error_free(error);
  19.     }
  20.     return pixbuf;
  21. }
  23. /*点击菜单时，状态栏显示*/
  24. /*
  25. void menu_pressed(GtkWidget *widget, gpointer window)
  26. {
  27.     gchar *str;
  28.     str = g_strdup_printf("you click one menu item");
  29.     gtk_statusbar_push(GTK_STATUSBAR(window),gtk_statusbar_get_context_id(GTK_STATUSBAR(window), str), str);
  30.     g_free(str);
  31. }
  32. */
  33. //根据菜单栏的选择(check)控制一些构件的显示和隐藏
  34. void toggle_display(GtkWidget *widget, gpointer oneofwidget)
  35. {
  36.     if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
  37.         gtk_widget_show(oneofwidget);
  38.     } else {
  39.         gtk_widget_hide(oneofwidget);
  40.     }
  41. }
  43. int main( int argc, char *argv[])
  44. {
  45.     GtkWidget *window;
  46.     GtkWidget *vbox;            //盒装容器
  47.     GtkWidget *menubar;         //菜单栏
  48.     GtkWidget *menutoggle, *menu_tog_toggle,*menu_tog_toolbar, *menu_tog_statusbar;  //界面开关菜单
  49.     //GtkWidget *menu_about, *menu_about_us;  //帮助菜单
  50.     GtkWidget *toolbar;         //工具栏
  51.     GtkToolItem *tool_exit, *tool_sep,*tool_about;
  52.     GtkWidget *statusbar;       //状态栏
  54.     /*初始化整个GTK+程序，是每一个GTK+程序必不可少的部分*/
  55.     gtk_init(&argc, &argv);
  56.     /*这里生成了一个窗口构件——GtkWindow，GTK_WINDOW_TOPLEVEL包含窗口的标题栏和边框，同意用窗口管理器来进行管理*/
  57.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  58.     /*设置窗口标题*/
  59.     gtk_window_set_title(GTK_WINDOW(window), "一步一步学GTK+ DEMO");
  60.     /*设置窗口默认大小*/
  61.     gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
  62.     /*
  63.      * 设置窗口在显示器中的位置为居中。
  64.      *   GTK_WIN_POS_NONE            ：不固定
  65.      *   GTK_WIN_POS_CENTER          : 居中
  66.      *   GTK_WIN_POS_MOUSE           : 出现在鼠标位置
  67.      *   GTK_WIN_POS_CENTER_ALWAYS   : 窗口改变大小的时候仍然居中
  68.     */
  69.     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  71.     /*函数gtk_window_set_icon() 是为窗口设置图标用的，函数create_pixbuf是我们自定义的，目的是从一个图片中获取信息得到pixbuf。*/
  72.     gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("./images/bear.png"));
  74.     /*创建一个盒装容器并添加到窗口中*/
  75.     vbox = gtk_vbox_new(FALSE, 0);
  76.     gtk_container_add(GTK_CONTAINER(window), vbox);
  78.     /*创建菜单*/
  79.     menubar = gtk_menu_bar_new();   //代表整个菜单,是一个menu shell
  81.     menutoggle = gtk_menu_new();   //这里代表第一列菜单toggle ,也是一个menu shell
  82.     menu_tog_toggle = gtk_menu_item_new_with_label("View");
  83.     //menu_tog_toolbar = gtk_menu_item_new_with_label("show Toolbar"); //toggle 菜单中子项
  84.     //menu_tog_statusbar = gtk_menu_item_new_with_label("show Statusbar");
  85.     menu_tog_toolbar = gtk_check_menu_item_new_with_label("show Toolbar");
  86.     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_tog_toolbar),TRUE);
  87.     menu_tog_statusbar = gtk_check_menu_item_new_with_label("show Statusbar");
  88.     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_tog_statusbar),TRUE);
  90.     gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_tog_toggle), menutoggle);  //widget toggle菜单加入 menutoggle menu shell
  91.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_toolbar);
  92.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_statusbar);
  94.     gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menu_tog_toggle);
  96.     //创建工具栏
  97.     toolbar = gtk_toolbar_new();
  98.     gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); //设置工具栏样式为图标
  99.     gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);      //工具栏边框大小
  101.     tool_exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);     //工具栏中的 “退出” 按钮
  102.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_exit, -1);
  104.     tool_sep = gtk_separator_tool_item_new();                       //工具栏中按钮之间的分割线
  105.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_sep, -1);
  107.     tool_about = gtk_tool_button_new_from_stock(GTK_STOCK_HELP);    //工具栏中的“关于” 按钮
  108.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_about, -1);
  110.     statusbar = gtk_statusbar_new();
  111.     /*把菜单加入盒子容器*/
  112.     gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 1);
  113.     /*把工具栏加入盒子容器*/
  114.     gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
  115.     /*把状态栏加入盒子最下面*/
  116.     gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
  118.     /***********************************以下是信号处理部分************************************/
  119.     /*关闭窗口时退出主循环*/
  120.     g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit), NULL);
  121.     g_signal_connect(G_OBJECT(tool_exit), "clicked",G_CALLBACK(gtk_main_quit), NULL);
  123.     //g_signal_connect(G_OBJECT(menu_tog_toolbar),"activate",G_CALLBACK(menu_pressed), G_OBJECT(statusbar));
  124.     //g_signal_connect(G_OBJECT(menu_tog_statusbar),"activate",G_CALLBACK(menu_pressed), G_OBJECT(statusbar));
  125.     g_signal_connect(G_OBJECT(menu_tog_toolbar), "activate",G_CALLBACK(toggle_display), toolbar);
  126.     g_signal_connect(G_OBJECT(menu_tog_statusbar), "activate",G_CALLBACK(toggle_display), statusbar);
  128.     /***********************************以下是显示控件部分************************************/
  129.     /*开始显示窗口*/
  130.     //gtk_widget_show(window);
  131.     gtk_widget_show_all(window);
  133.     gtk_main();
  134.     return 0;
  135. }

（四）、一步一步学GTK+之多窗口

一、按照一定的逻辑去切割代码并实现多窗口

上一篇中完成了一个简单的软件界面，考虑到这个软件主要的目的是在软件中容纳很多控件，一个窗口中不可能全部包含进去的。所以这篇内容是我们一起来学下多窗口。既然我们要实现多窗口，那么就不能把所有代码放到一个文件中，这样会很混乱的，一个文件来放一个窗口，然后用main.c的入口文件来调度它们。使用我先把文件的结构分为：

main.c——入口文件

window_main.c——主窗口文件

window_test.c——测试用的子窗口文件

common_func.c——各个窗口调用的公共函数文件

既然涉及到公共函数会被其他窗口调用，我们还需要建立一些头文件，在其中加入一些宏来防止重复包含文件。

common_func.h

  1. #ifndef __COMMON_FUNC_H__
  2. #define __COMMON_FUNC_H__
  4. #include <gtk/gtk.h>
  5. GdkPixbuf *create_pixbuf(const gchar * filename);
  6. void toggle_display(GtkWidget *widget, gpointer oneofwidget);
  8. #endif // __COMMON_FUNC_H__

common.c


  2. #include "common_func.h"
  3. /*
  4.   @Description: 从一个图片中获取信息得到pixbuf
  5.   @param:       gchar filename
  6. */
  7. GdkPixbuf *create_pixbuf(const gchar * filename)
  8. {
  9.     GdkPixbuf *pixbuf;
  10.     GError *error = NULL;
  11.     /*
  12.      * 函数gdk_pixbuf_new_from_file() 从一个图片文件中加载图象数据，从而生成一个新的 pixbuf，
  13.      * 至于文件中包含图象的格式，是由系统自动检测的。如果该函数返回值是NULL 的话，程序就会出现错误。
  14.     */
  15.     pixbuf = gdk_pixbuf_new_from_file(filename, &error);
  16.     if(!pixbuf) {
  17.         fprintf(stderr, "%s\n", error->message);
  18.         g_error_free(error);
  19.     }
  20.     return pixbuf;
  21. }
  23. //根据菜单栏的选择(check)控制一些构件的显示和隐藏
  24. void toggle_display(GtkWidget *widget, gpointer oneofwidget)
  25. {
  26.     if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
  27.         gtk_widget_show(oneofwidget);
  28.     } else {
  29.         gtk_widget_hide(oneofwidget);
  30.     }
  31. }

以上只是把原来的两个函数提取出来，并添加了头文件。

window_main.h

  1. #ifndef __WINDOW_MAIN_H__
  2. #define __WINDOW_MAIN_H__
  4. #include <gtk/gtk.h>
  5. #include "common_func.h"
  6. GtkWidget *create_main_window();
  8. #endif // __WINDOW_MAIN_H__

window_main.c

  1. #include "common_func.h"
  2. #include "window_main.h"
  4. GtkWidget *create_main_window()
  5. {//创建主窗口
  6.     GtkWidget *window;
  7.     GtkWidget *vbox;            //盒装容器
  8.     GtkWidget *menubar;         //菜单栏
  9.     GtkWidget *menutoggle, *menu_tog_toggle,*menu_tog_toolbar, *menu_tog_statusbar;  //界面开关菜单
  10.     //GtkWidget *menu_about, *menu_about_us;  //帮助菜单
  11.     GtkWidget *toolbar;         //工具栏
  12.     GtkToolItem *tool_exit, *tool_sep,*tool_about;
  13.     GtkWidget *statusbar;       //状态栏
  15.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  16.     gtk_window_set_title(GTK_WINDOW(window), "一步一步学GTK+ DEMO");
  17.     gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
  18.     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  20.     /*函数gtk_window_set_icon() 是为窗口设置图标用的，函数create_pixbuf是我们自定义的，目的是从一个图片中获取信息得到pixbuf。*/
  21.     gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("./images/bear.png"));
  23.     /*创建一个盒装容器并添加到窗口中*/
  24.     vbox = gtk_vbox_new(FALSE, 0);
  25.     gtk_container_add(GTK_CONTAINER(window), vbox);
  27.     /*创建菜单*/
  28.     menubar = gtk_menu_bar_new();   //代表整个菜单,是一个menu shell
  30.     menutoggle = gtk_menu_new();   //这里代表第一列菜单toggle ,也是一个menu shell
  31.     menu_tog_toggle = gtk_menu_item_new_with_label("View");
  33.     menu_tog_toolbar = gtk_check_menu_item_new_with_label("show Toolbar");
  34.     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_tog_toolbar),TRUE);
  35.     menu_tog_statusbar = gtk_check_menu_item_new_with_label("show Statusbar");
  36.     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_tog_statusbar),TRUE);
  38.     gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_tog_toggle), menutoggle);  //widget toggle菜单加入 menutoggle menu shell
  39.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_toolbar);
  40.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_statusbar);
  42.     gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menu_tog_toggle);
  44.     //创建工具栏
  45.     toolbar = gtk_toolbar_new();
  46.     gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); //设置工具栏样式为图标
  47.     gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);      //工具栏边框大小
  49.     tool_exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);     //工具栏中的 “退出” 按钮
  50.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_exit, -1);
  52.     tool_sep = gtk_separator_tool_item_new();                       //工具栏中按钮之间的分割线
  53.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_sep, -1);
  55.     tool_about = gtk_tool_button_new_from_stock(GTK_STOCK_HELP);    //工具栏中的“关于” 按钮
  56.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_about, -1);
  58.     statusbar = gtk_statusbar_new();
  59.     /*把菜单加入盒子容器*/
  60.     gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 1);
  61.     /*把工具栏加入盒子容器*/
  62.     gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
  63.     /*把状态栏加入盒子最下面*/
  64.     gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
  66.      /***********************************以下是信号处理部分************************************/
  67.     /*关闭窗口时退出主循环*/
  68.     g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit), NULL);
  69.     g_signal_connect(G_OBJECT(tool_exit), "clicked",G_CALLBACK(gtk_main_quit), NULL);
  71.     g_signal_connect(G_OBJECT(menu_tog_toolbar), "activate",G_CALLBACK(toggle_display), toolbar);
  72.     g_signal_connect(G_OBJECT(menu_tog_statusbar), "activate",G_CALLBACK(toggle_display), statusbar);
  74.     /***********************************以下是显示控件部分************************************/
  75.     /*开始显示窗口*/
  76.     //gtk_widget_show_all(window);
  78.     //gtk_main();
  79.     //return 0;
  80.     return window;
  82. }

这段也只是原来的代码中，把显示窗口的部分放在了一个函数中（create_main_window()）,并把显示窗口语句gtk_widget_show_all(window); 注释掉，放在入口文件中调用，并注释掉gtk_main()主循环，主循环我们应该放在入口文件中，让这个函数返回创建的窗口， return window;

window_test.h

  1. #ifndef __WINDOW_TEST_H__
  2. #define __WINDOW_TEST_H__
  4. #include <gtk/gtk.h>
  5. #include "common_func.h"
  6. GtkWidget *create_test_window();
  8. #endif // __WINDOW_TEST_H__

window_test.c

  1. #include "window_test.h"
  3.  GtkWidget *create_test_window()
  4.  { //创建一个测试窗口
  6.     GtkWidget *window_test;
  8.     window_test = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  9.     gtk_widget_show(window_test);
  10.     //gtk_main();
  11.     //return 0;
  12.     return window_test;
  13.  }

这里只用了个函数创建了一个空白的测试窗口，并返回窗口。

main.c

  1. #include <gtk/gtk.h>
  2. #include "common_func.h"
  3. #include "window_main.h"
  4. #include "window_test.h"
  6. int main( int argc, char *argv[])
  7. {
  8.     GtkWidget *main_window ,*test_window;
  9.     gtk_init(&argc, &argv);
  11.     main_window=create_test_window(); //创建主窗口
  12.     test_window=create_main_window(); //创建测试窗口
  14.     gtk_widget_show_all(main_window); //显示主窗口
  15.     gtk_widget_show_all(test_window); //显示测试窗口
  16.     gtk_main();
  17.     return 0;
  19. }

在入口文件中，我们开始执行创建窗口并显示它们,这样看起来就很简洁，如果还有其他窗口我们用同样的方法去增加就好了。在main.c中同一控制其他窗口的调度是很方便的。这样分开后，代码结构清晰，审查代码也很方便了。

以上的代码仅仅是显示了2个窗口，但点击任意窗口右上角的X就会全部关闭.下面我们来实现2个窗口的交互。

二、主窗口与子窗口的交互

在主窗口中的2个按钮分别控制子窗口的显示和隐藏（没有使用摧毁和重新创建的方法），并在点击子窗口的按钮，改变主窗口的label控件中的文字。顺便也简单介绍下 按钮（GtkButton）和标签控件(GtkLabel).以及非盒装容器GtkFixed。

注意：由于本人能力有限，且暂时不想引入在结构体中包含函数指针的方法，姑且采用几个全局变量，这样其他文件中可通过extern修饰符进行引用。

修改main.c

  1. #include <gtk/gtk.h>
  2. #include "common_func.h"
  3. #include "window_main.h"
  4. #include "window_test.h"
  6. //Global
  7. GtkWidget *window_test = NULL;  //子窗口本身
  8. GtkWidget *label = NULL;        //主窗口中的label
  10. int main( int argc, char *argv[])
  11. {
  12.     GtkWidget *window_main;     //主窗口不会在子窗口中使用，故不用声明为全局变量
  14.     gtk_init(&argc, &argv);
  16.     window_main=create_main_window(); //创建主窗口
  17.     window_test=create_test_window(); //创建测试窗口
  19.     gtk_widget_show_all(window_main); //显示主窗口
  20.     //gtk_widget_show_all(window_test); //显示测试窗口
  22.     gtk_main();
  23.     return 0;
  25. }

window_main.c

  1. #include "common_func.h"
  2. #include "window_main.h"
  4. extern GtkWidget *window_test;
  5. extern GtkWidget *label;
  7. //显示子窗口
  8. void show_test_window(GtkWidget *widget)
  9. {
  11.     gchar *msg="子窗口打开了";
  12.     gtk_label_set_text(GTK_LABEL(label),msg);
  13.     gtk_widget_show_all(window_test);
  14. }
  16. //隐藏子窗口
  17. void hide_test_window(GtkWidget *widget)
  18. {
  19.     gchar *msg="子窗口关闭了";
  20.     gtk_label_set_text(GTK_LABEL(label),msg);
  21.     gtk_widget_hide_all(window_test);
  22. }
  24. GtkWidget *create_main_window()
  25. {//创建主窗口
  26.     GtkWidget *window;
  27.     GtkWidget *vbox;            //盒装容器
  28.     GtkWidget *menubar;         //菜单栏
  29.     GtkWidget *menutoggle, *menu_tog_toggle,*menu_tog_toolbar, *menu_tog_statusbar;  //界面开关菜单
  30.     //GtkWidget *menu_about, *menu_about_us;  //帮助菜单
  31.     GtkWidget *toolbar;         //工具栏
  32.     GtkToolItem *tool_exit, *tool_sep,*tool_about;
  33.     GtkWidget *statusbar;       //状态栏
  34.     GtkWidget *fixed;
  36.     GtkWidget *test_button;
  37.     GtkWidget *test2_button;
  39.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  40.     gtk_window_set_title(GTK_WINDOW(window), "一步一步学GTK+ DEMO");
  41.     gtk_window_set_default_size(GTK_WINDOW(window), 500, 400);
  42.     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  44.     /*函数gtk_window_set_icon() 是为窗口设置图标用的，函数create_pixbuf是我们自定义的，目的是从一个图片中获取信息得到pixbuf。*/
  45.     gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("./images/bear.png"));
  47.     /*创建一个盒装容器并添加到窗口中*/
  48.     vbox = gtk_vbox_new(FALSE, 0);
  49.     gtk_container_add(GTK_CONTAINER(window), vbox);
  51.     /*创建菜单*/
  52.     menubar = gtk_menu_bar_new();   //代表整个菜单,是一个menu shell
  54.     menutoggle = gtk_menu_new();   //这里代表第一列菜单toggle ,也是一个menu shell
  55.     menu_tog_toggle = gtk_menu_item_new_with_label("View");
  57.     menu_tog_toolbar = gtk_check_menu_item_new_with_label("show Toolbar");
  58.     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_tog_toolbar),TRUE);
  59.     menu_tog_statusbar = gtk_check_menu_item_new_with_label("show Statusbar");
  60.     gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_tog_statusbar),TRUE);
  62.     gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_tog_toggle), menutoggle);  //widget toggle菜单加入 menutoggle menu shell
  63.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_toolbar);
  64.     gtk_menu_shell_append(GTK_MENU_SHELL(menutoggle), menu_tog_statusbar);
  66.     gtk_menu_shell_append(GTK_MENU_SHELL(menubar), menu_tog_toggle);
  68.     //创建工具栏
  69.     toolbar = gtk_toolbar_new();
  70.     gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); //设置工具栏样式为图标
  71.     gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);      //工具栏边框大小
  73.     tool_exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);     //工具栏中的 “退出” 按钮
  74.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_exit, -1);
  76.     tool_sep = gtk_separator_tool_item_new();                       //工具栏中按钮之间的分割线
  77.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_sep, -1);
  79.     tool_about = gtk_tool_button_new_from_stock(GTK_STOCK_HELP);    //工具栏中的“关于” 按钮
  80.     gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_about, -1);
  82.     statusbar = gtk_statusbar_new();
  83.     fixed = gtk_fixed_new();
  84.     /*把菜单加入盒子容器*/
  85.     gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 1);
  86.     /*把工具栏加入盒子容器*/
  87.     gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
  88.     /*把fixed加入主工作区*/
  89.     gtk_box_pack_start(GTK_BOX(vbox), fixed, FALSE, FALSE, 0);
  90.     /*在fixed中放入一些按钮和label*/
  91.     test_button=gtk_button_new_with_label("打开测试窗口");
  92.     gtk_fixed_put(GTK_FIXED(fixed), test_button, 150, 50);
  93.     gtk_widget_set_size_request(test_button, 150, 35);
  95.     test2_button=gtk_button_new_with_label("关闭测试窗口");
  96.     gtk_fixed_put(GTK_FIXED(fixed), test2_button, 300, 50);
  97.     gtk_widget_set_size_request(test2_button, 80, 35);
  99.     label = gtk_label_new("这里的文字会通过子窗口的操作来改变。");
  100.     gtk_fixed_put(GTK_FIXED(fixed), label, 100, 100);
  101.     gtk_widget_set_size_request(label, 300, 100);
  103.     /*把状态栏加入盒子最下面*/
  104.     gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
  106.      /***********************************以下是信号处理部分************************************/
  107.     /*关闭窗口时退出主循环*/
  108.     g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit), NULL);
  109.     g_signal_connect(G_OBJECT(tool_exit), "clicked",G_CALLBACK(gtk_main_quit), NULL);
  111.     g_signal_connect(G_OBJECT(menu_tog_toolbar), "activate",G_CALLBACK(toggle_display), toolbar);
  112.     g_signal_connect(G_OBJECT(menu_tog_statusbar), "activate",G_CALLBACK(toggle_display), statusbar);
  114.     g_signal_connect(G_OBJECT(test_button), "clicked",G_CALLBACK(show_test_window), NULL);
  115.     g_signal_connect(G_OBJECT(test2_button), "clicked",G_CALLBACK(hide_test_window), NULL);
  117.     return window;
  119. }

window_test.c

  1. #include "window_test.h"
  2. //
  3. extern GtkWidget *window_test;
  4. extern GtkWidget *label;
  6. static gint delete_event()
  7. {
  8.     /* 如果你的 "delete_event" 信号处理函数返回 FALSE，GTK 会发出 "destroy" 信号。
  9.     * 返回 TRUE，你不希望关闭窗口。
  10.     * 当你想弹出“你确定要退出吗?”对话框时它很有用。*/
  11.     gtk_widget_hide_all(window_test);
  13.     return TRUE; //注意必须为TRUE，否则子窗口点击关闭按钮后，就摧毁了，而不是隐藏了。
  14. }
  16. static void change_label_text()
  17. {
  18.     char *text="我是子窗口的动作改变的";
  19.     gtk_label_set_text(GTK_LABEL(label),text);
  20. }
  22.  GtkWidget *create_test_window()
  23.  { //创建一个测试窗口
  25.     GtkWidget *window_test;
  26.     GtkWidget *fixed;
  27.     GtkWidget *button;
  29.     window_test = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  30.     gtk_window_set_default_size(GTK_WINDOW(window_test), 300, 200);
  31.     fixed = gtk_fixed_new();
  33.     button=gtk_button_new_with_label("改变主窗口label文字");
  34.     gtk_fixed_put(GTK_FIXED(fixed), button, 50, 50);
  35.     gtk_widget_set_size_request(button, 80, 65);
  37.     gtk_container_add(GTK_CONTAINER(window_test), fixed);
  39.     //gtk_widget_show(window);
  40.     g_signal_connect(G_OBJECT(window_test),"delete_event",G_CALLBACK(delete_event), NULL); //注意这里不是“destroy” 事件
  41.     g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(change_label_text), NULL);
  43.     //gtk_main();
  44.     //return 0;
  45.     return window_test;
  46.  }

运行如下：

点击“打开测试窗口”——子窗口打开了，点击关闭测试窗口——子窗口关闭了（隐藏了），并主窗口中有对应的文字显示（label）

点击子窗口中的按钮，主窗口中的label标签文字改变了

说明：本方法只是测试多窗口的交互而已，是很拙劣的方法。在我看来如果能实现下面这种就更好了，可我不会。

1.入口文件中，通过其他2个文件创建并返回了2个窗口。

2.那么如果能在入口文件中操作其他所有窗口以及窗口中的控件和信号就好了。

一步一步学习GTK的更多相关文章

  1. 12.Linux软件安装 (一步一步学习大数据系列之 Linux)

    1.如何上传安装包到服务器 有三种方式: 1.1使用图形化工具,如: filezilla 如何使用FileZilla上传和下载文件 1.2使用 sftp 工具: 在 windows下使用CRT 软件 ...

  2. (转) 一步一步学习ASP.NET 5 (四）- ASP.NET MVC 6四大特性

    转发:微软MVP 卢建晖 的文章,希望对大家有帮助.原文:http://blog.csdn.net/kinfey/article/details/44459625 编者语 : 昨晚写好的文章居然csd ...

  3. (转) 一步一步学习ASP.NET 5 (二）- 通过命令行和sublime创建项目

    转发:微软MVP 卢建晖 的文章,希望对大家有帮助. 注:昨天转发之后很多朋友指出了vNext的命名问题,原文作者已经做出了修改,后面的标题都适用 asp.net 5这个名称. 编者语 : 昨天发了第 ...

  4. 一步一步学习SignalR进行实时通信_1_简单介绍

    一步一步学习SignalR进行实时通信\_1_简单介绍 SignalR 一步一步学习SignalR进行实时通信_1_简单介绍 前言 SignalR介绍 支持的平台 相关说明 OWIN 结束语 参考文献 ...

  5. 一步一步学习SignalR进行实时通信_8_案例2

    原文:一步一步学习SignalR进行实时通信_8_案例2 一步一步学习SignalR进行实时通信\_8_案例2 SignalR 一步一步学习SignalR进行实时通信_8_案例2 前言 配置Hub 建 ...

  6. 一步一步学习SignalR进行实时通信_9_托管在非Web应用程序

    原文:一步一步学习SignalR进行实时通信_9_托管在非Web应用程序 一步一步学习SignalR进行实时通信\_9_托管在非Web应用程序 一步一步学习SignalR进行实时通信_9_托管在非We ...

  7. 一步一步学习SignalR进行实时通信_7_非代理

    原文:一步一步学习SignalR进行实时通信_7_非代理 一步一步学习SignalR进行实时通信\_7_非代理 SignalR 一步一步学习SignalR进行实时通信_7_非代理 前言 代理与非代理 ...

  8. 一步一步学习SignalR进行实时通信_5_Hub

    原文:一步一步学习SignalR进行实时通信_5_Hub 一步一步学习SignalR进行实时通信\_5_Hub SignalR 一步一步学习SignalR进行实时通信_5_Hub 前言 Hub命名规则 ...

  9. 一步一步学习SignalR进行实时通信_6_案例

    原文:一步一步学习SignalR进行实时通信_6_案例 一步一步学习SignalR进行实时通信\_6_案例1 一步一步学习SignalR进行实时通信_6_案例1 前言 类的定义 各块功能 后台 上线 ...

随机推荐

  1. 表皮囊肿？wtf

    https://baike.baidu.com/item/%E8%A1%A8%E7%9A%AE%E5%9B%8A%E8%82%BF/7852024?fr=aladdin

  2. 选带傅里叶变换(zoom-fft)

    选带傅里叶变换的原理大家能够看书.大致的步骤为 移频 (将选带的中心频率移动到零频) 数字低通滤波器  (防止频率混叠) 又一次採样  (将採样的数据再次间隔採样,间隔的数据取决于分析的带宽,就是放大 ...

  3. SQL 撤销索引、撤销表以及撤销数据库

    SQL 撤销索引.撤销表以及撤销数据库 通过使用 DROP 语句,可以轻松地删除索引.表和数据库. DROP INDEX 语句 DROP INDEX 语句用于删除表中的索引. 用于 MS Access ...

  4. JAVA 并发编程-返回运行结果（Callable和Future）（九）

    启动一个线程不论使用Thread或者Runnable的时候.都是没有返回结果的. 也就是说Thread和Runnable的run()方法必须没有返回值. public void run(){} 解决方 ...

  5. Axure安装fontawesome字体

    http://www.fontawesome.com.cn/ 下载后,双击安装字体提示  不是有效的字体,百度 ..解决方法: 任务管理器--服务-- MpsSvc-Windows Firewall ...

  6. iOS开发——高级篇——Runloop相关一

    一.什么是runLoop 1.说白了,runloop就是运行循环 2.runloop,他是多线程的法宝 通常来讲,一个线程一次只能执行一个任务,执行完之后就退出线程.但是,对于主线程是不能退出的,因此 ...

  7. File to byte[] in Java

    File to byte[] in Java - Stack Overflow https://stackoverflow.com/questions/858980/file-to-byte-in-j ...

  8. 检查 统计 异常 通信 time_wait

    [root@hadoop1 conf]# netstat -n | grep -v 127.0.0.1 | grep -v :3306  | grep TIME_WAIT | sort -k 5n | ...

  9. Spring简单实现数据源的动态切换

    Spring简单实现数据源的动态切换: 1. 创建一个数据源切换类: 2. 继承AbstractRoutingDataSource,创建多数据源路由类,并注入到spring的配置文件中: 3. AOP ...

  10. RabbitMQ（三）RabbitMQ消息过期时间（TTL）

    在RabbitMQ(二)AMQP协议mandatory和immediate标志位区别中我们提到,在RabbitMQ3.0以后的版本里,去掉了immediate参数支持,要实现类似的确认功能要使用TTL ...