• 基础

    基础

    我们用一个最简单的程序来开始对GTK的介绍，下面的程序将创造一个200×200像素的窗体。
    window_default

    新建一个名为 example-0.c 的文件，写入如下内容：

    1. #include <gtk/gtk.h>
    3. int main (int   argc, char *argv[])
    4. {
    5.     GtkWidget *window;
    6.     gtk_init (&argc, &argv);
    7.     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    8.     gtk_window_set_title (GTK_WINDOW (window), "Window");
    9.     g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
    10.     gtk_widget_show (window);
    11.     gtk_main ();
    12.     return 0;
    13. }

    然后在终端输入以下命令用GCC编译程序：

    1. gcc `pkg-config --cflags gtk+-3.0` -o example-0 example-0.c `pkg-config --libs gtk+-3.0`

    注：要查找更多编译GTK程序的信息，请查看手册中编译GTK+应用的部分。

    所有的GTK+程序必须包括gtk/gtk.h，这个头文件声明了GTK+程序需要的函数、类和宏。

    注：即使GTK+安装了多种头文件，只有顶层的gtk/gtk.h 能被第三方代码直接引入。如果引入任意一个其他的头文件，编译器都会报错。

    我们接下来进入main函数，将会声明一个GtkWidget类型的指针变量window。
    下面一行将会调用gtk_init()函数，这个函数是GTK+程序的初始化函数，它将设置GTK+、类系统和与窗口环境的连接。

    注:要查找更多GTK+程序的命令参数，请查看手册中运行GTK+程序的部分。

    调用gtk_window_new()函数将会创造一个新的GtkWindow并将其储存在window变量中。并且，这个窗体的类型是GTK_WINDOW_TOPLEVEL，这也就意味着这个GtkWindow将会被当前的系统管理：这个窗体将会根据不同的系统平台产生一个框架、一个标题栏和窗口控件。

    当GtkWindow被破坏时，我们将“destroy”信号连接到gtk_main_quit()函数以终止这个程序。这个函数将会在之后终止由gtk_main()函数启动的GTK+程序的主循环。“destroy”信号会在一个窗口部件被破坏时触发，也会是在调用gtk_widget_destroy()或者在这个窗口部件失去母体控件时触发。最顶端的GtkWindows会在关闭按钮被点击时被破坏。

    GtkWidgets默认是隐藏的，通过在一个控件上调用gtk_widget_show()，我们将能设置其为可见。所有这些工作都将在主循环开始后被完成。

    最后一行调用了gtk_main()。这个函数就会启动GTK+程序的主循环并且在gtk_main_quit()函数被调用之前都阻止main()的控制流。

    当程序运行时，GTK+一直接收事件。有一些输入事件是由用户与程序互动时产生的，但也有一些事件，比如来自窗口管理器或者其他程序的信息。GTK+处理这些事件和信息，然后触发信号。为这些信号连接handles就是让你的程序为用户输入做出正确响应的方法。

    下面这个例子有点复杂，它将展示GTK+的能力。按照程序设计语言和库的古老传统，这个程序也叫Hello，World。

    hello_worldpng

    Example 1. Hello World in GTK+

    新建一个名为 example-1.c 的文件，写入如下内容：

    1. #include <gtk/gtk.h>
    3. /* This is a callback function. The data arguments are ignored
    4.  * in this example. More on callbacks below.
    5.  */
    6. static void print_hello (GtkWidget *widget,
    7.         gpointer   data)
    8. {
    9.     g_print ("Hello World\n");
    10. }
    12. static gboolean on_delete_event (GtkWidget *widget,
    13.         GdkEvent  *event,
    14.         gpointer   data)
    15. {
    16.     /* If you return FALSE in the "delete_event" signal handler,
    17.      * GTK will emit the "destroy" signal. Returning TRUE means
    18.      * you don't want the window to be destroyed.
    19.      *
    20.      * This is useful for popping up 'are you sure you want to quit?'
    21.      * type dialogs.
    22.      */
    23.     g_print ("delete event occurred\n");
    24.     return TRUE;
    25. }
    27. int main (int  argc, char *argv[])
    28. {
    29.     /* GtkWidget is the storage type for widgets */
    30.     GtkWidget *window;
    31.     GtkWidget *button;
    33.     /* This is called in all GTK applications. Arguments are parsed
    34.      * from the command line and are returned to the application.
    35.      */
    36.     gtk_init (&argc, &argv);
    38.     /* create a new window, and set its title */
    39.     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    40.     gtk_window_set_title (GTK_WINDOW (window), "Hello");
    42.     /* When the window emits the "delete-event" signal (which is emitted
    43.      * by GTK+ in response to an event coming from the window manager,
    44.      * usually as a result of clicking the "close" window control), we
    45.      * ask it to call the on_delete_event() function as defined above.
    46.      *
    47.      * The data passed to the callback function is NULL and is ignored
    48.      * in the callback function.
    49.      */
    50.     g_signal_connect (window, "delete-event", G_CALLBACK (on_delete_event), NULL);
    52.     /* Here we connect the "destroy" event to the gtk_main_quit() function.
    53.      * This signal is emitted when we call gtk_widget_destroy() on the window,
    54.      * or if we return FALSE in the "delete_event" callback.
    55.      */
    56.     g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
    58.     /* Sets the border width of the window. */
    59.     gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    61.     /* Creates a new button with the label "Hello World". */
    62.     button = gtk_button_new_with_label ("Hello World");
    64.     /* When the button receives the "clicked" signal, it will call the
    65.      * function print_hello() passing it NULL as its argument.
    66.      * The print_hello() function is defined above.
    67.      */
    68.     g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
    70.     /* The g_signal_connect_swapped() function will connect the "clicked" signal
    71.      * of the button to the gtk_widget_destroy() function; instead of calling it
    72.      * using the button as its argument, it will swap it with the user data
    73.      * argument. This will cause the window to be destroyed by calling
    74.      * gtk_widget_destroy() on the window.
    75.      */
    76.     g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
    78.     /* This packs the button into the window. A GtkWindow inherits from GtkBin,
    79.      * which is a special container that can only have one child
    80.      */
    81.     gtk_container_add (GTK_CONTAINER (window), button);
    83.     /* The final step is to display this newly created widget... */
    84.     gtk_widget_show (button);
    86.     /* ... and the window */
    87.     gtk_widget_show (window);
    89.     /* All GTK applications must have a gtk_main(). Control ends here
    90.      * and waits for an event to occur (like a key press or a mouse event),
    91.      * until gtk_main_quit() is called.
    92.      */
    93.     gtk_main ();
    94.     return 0;
    95. }

    然后在终端输入以下命令用GCC编译程序：

    1. gcc `pkg-config --cflags gtk+-3.0` -o example-1 example-1.c `pkg-config --libs gtk+-3.0`