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

在 GTK+ 编程教程的这一部分中，我们讨论事件系统。

GTK+ 是事件驱动的系统。 所有 GUI 应用都是事件驱动的。 应用启动一个主循环，该循环不断检查新生成的事件。 如果没有事件，则应用将等待并且不执行任何操作。 在 GTK+ 中，事件是来自 X 服务器的消息。 当事件到达窗口小部件时，它可以通过发出信号对此事件做出反应。 GTK+ 程序员可以将特定的回调连接到信号。 回调是对信号做出反应的处理函数。

点击按钮

触发按钮时，它会发送clicked信号。 可以通过鼠标指针或使用空格键触发按钮（只要按钮具有焦点）。

buttonclick.c

  1. #include <gtk/gtk.h>
  3. void button_clicked(GtkWidget *widget, gpointer data) {
  5.   g_print("clicked\n");
  6. }
  8. int main(int argc, char *argv[]) {
  10.   GtkWidget *window;
  11.   GtkWidget *halign;
  12.   GtkWidget *btn;
  14.   gtk_init(&argc, &argv);
  16.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  17.   gtk_window_set_title(GTK_WINDOW(window), "GtkButton");
  18.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  19.   gtk_container_set_border_width(GTK_CONTAINER(window), 15);
  20.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  22.   halign = gtk_alignment_new(0, 0, 0, 0);
  23.   btn = gtk_button_new_with_label("Click");
  24.   gtk_widget_set_size_request(btn, 70, 30);
  26.   gtk_container_add(GTK_CONTAINER(halign), btn);
  27.   gtk_container_add(GTK_CONTAINER(window), halign);
  29.   g_signal_connect(G_OBJECT(btn), "clicked", 
  30.       G_CALLBACK(button_clicked), NULL);
  32.   g_signal_connect(G_OBJECT(window), "destroy", 
  33.       G_CALLBACK(gtk_main_quit), NULL);
  35.   gtk_widget_show_all(window);
  37.   gtk_main();
  39.   return 0;
  40. }

在应用中，我们有两个信号：clicked信号和destroy信号。

  1. g_signal_connect(G_OBJECT(btn), "clicked", 
  2.     G_CALLBACK(button_clicked), NULL);

我们使用g_signal_connect()函数将clicked信号连接到button_clicked()回调。

  1. void button_clicked(GtkWidget *widget, gpointer data) {
  3.   g_print("clicked\n");
  4. }

回调将"clicked"字符串打印到控制台。 回调函数的第一个参数是发出信号的对象。 在我们的例子中是单击按钮。 第二个参数是可选的。 我们可能会向回调发送一些数据。 在我们的案例中，我们没有发送任何数据； 我们为g_signal_connect()函数的第四个参数提供了NULL值。

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

如果按标题栏右上角的 x 按钮，或按 Atl + F4 ，则会发出destroy信号。 调用gtk_main_quit()函数，该函数将终止应用。

移动窗口

下一个示例显示了我们如何应对窗口移动事件。

moveevent.c

  1. #include <gtk/gtk.h>
  3. void configure_callback(GtkWindow *window, 
  4.       GdkEvent *event, gpointer data) {
  6.    int x, y;
  7.    GString *buf;
  9.    x = event->configure.x;
  10.    y = event->configure.y;
  12.    buf = g_string_new(NULL);   
  13.    g_string_printf(buf, "%d, %d", x, y);
  15.    gtk_window_set_title(window, buf->str);
  17.    g_string_free(buf, TRUE);
  18. }
  20. int main(int argc, char *argv[]) {
  22.   GtkWidget *window;
  24.   gtk_init(&argc, &argv);
  26.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  27.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  28.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  29.   gtk_widget_add_events(GTK_WIDGET(window), GDK_CONFIGURE);
  31.   g_signal_connect(G_OBJECT(window), "destroy",
  32.         G_CALLBACK(gtk_main_quit), G_OBJECT(window));
  34.   g_signal_connect(G_OBJECT(window), "configure-event",
  35.         G_CALLBACK(configure_callback), NULL);
  37.   gtk_widget_show(window);
  38.   gtk_main();
  40.   return 0;
  41. }

在示例中，我们在标题栏中显示了窗口左上角的当前位置。

  1. gtk_widget_add_events(GTK_WIDGET(window), GDK_CONFIGURE);

小部件的事件掩码确定特定小部件将接收的事件类型。 一些事件是预先配置的，其他事件必须添加到事件掩码中。 gtk_widget_add_events()将GDK_CONFIGURE事件类型添加到掩码。 GDK_CONFIGURE事件类型说明了窗口的所有大小，位置和堆叠顺序。

  1. g_signal_connect(G_OBJECT(window), "configure-event",
  2.     G_CALLBACK(configure_callback), NULL);

当窗口小部件的窗口的大小，位置或栈发生更改时，将发出configure-event。

  1. void configure_callback(GtkWindow *window, 
  2.       GdkEvent *event, gpointer data) {
  4.    int x, y;
  5.    GString *buf;
  7.    x = event->configure.x;
  8.    y = event->configure.y;
  10.    buf = g_string_new(NULL);   
  11.    g_string_printf(buf, "%d, %d", x, y);
  13.    gtk_window_set_title(window, buf->str);
  15.    g_string_free(buf, TRUE);
  16. }

回调函数具有三个参数：发出信号的对象，GdkEvent和可选数据。 我们确定 x，y 坐标，构建一个字符串，并将其设置为窗口标题。

GTK 事件和信号 - 图1

图：移动事件

输入信号

以下示例显示了我们如何对enter信号做出反应。 当我们使用鼠标指针进入小部件的区域时，将发出enter信号。

entersignal.c

  1. #include <gtk/gtk.h>
  3. void enter_button(GtkWidget *widget, gpointer data) {
  5.   GdkColor col = {0, 27000, 30000, 35000};   
  7.   gtk_widget_modify_bg(widget, GTK_STATE_PRELIGHT, &col);
  8. }
  10. int main(int argc, char *argv[]) {
  12.   GtkWidget *window;
  13.   GtkWidget *halign;
  14.   GtkWidget *btn;
  16.   gtk_init(&argc, &argv);
  18.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  19.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  20.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  21.   gtk_container_set_border_width(GTK_CONTAINER(window), 15);
  22.   gtk_window_set_title(GTK_WINDOW(window), "Enter signal");
  24.   halign = gtk_alignment_new(0, 0, 0, 0);
  26.   btn = gtk_button_new_with_label("Button");
  27.   gtk_widget_set_size_request(btn, 70, 30);
  29.   gtk_container_add(GTK_CONTAINER(halign), btn);
  30.   gtk_container_add(GTK_CONTAINER(window), halign);
  32.   g_signal_connect(G_OBJECT(btn), "enter", 
  33.       G_CALLBACK(enter_button), NULL);
  35.   g_signal_connect(G_OBJECT(window), "destroy",
  36.       G_CALLBACK(gtk_main_quit), NULL);
  38.   gtk_widget_show_all(window);
  40.   gtk_main();
  42.   return 0;
  43. }

在该示例中，当我们将鼠标指针悬停在其上方时，按钮小部件的背景颜色会更改。

  1. g_signal_connect(G_OBJECT(btn), "enter", 
  2.     G_CALLBACK(enter_button), NULL);

当enter信号出现时，我们调用enter_button()用户功能。

  1. void enter_button(GtkWidget *widget, gpointer data) {
  3.   GdkColor col = {0, 27000, 30000, 35000};   
  5.   gtk_widget_modify_bg(widget, GTK_STATE_PRELIGHT, &col);
  6. }

在回调内部，我们通过调用gtk_widget_modify_bg()函数来更改按钮的背景。

断开回调

我们可以从信号断开回调。 下一个代码示例演示了这种情况。

disconnect.c

  1. #include <gtk/gtk.h>
  3. gint handler_id;
  5. void button_clicked(GtkWidget *widget, gpointer data) {
  7.   g_print("clicked\n");
  8. }
  10. void toogle_signal(GtkWidget *widget, gpointer window) {
  12.   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
  13.      handler_id = g_signal_connect(G_OBJECT(window), "clicked", 
  14.            G_CALLBACK(button_clicked), NULL);
  15.   } else {
  16.      g_signal_handler_disconnect(window, handler_id);
  17.   }
  18. }
  20. int main(int argc, char *argv[]) {
  22.   GtkWidget *window;
  23.   GtkWidget *hbox;
  24.   GtkWidget *vbox;
  25.   GtkWidget *btn;
  26.   GtkWidget *cb;
  28.   gtk_init(&argc, &argv);
  30.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  31.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  32.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  33.   gtk_container_set_border_width(GTK_CONTAINER(window), 15);
  34.   gtk_window_set_title(GTK_WINDOW(window), "Disconnect");
  36.   hbox = gtk_hbox_new(FALSE, 15);
  38.   btn = gtk_button_new_with_label("Click");
  39.   gtk_widget_set_size_request(btn, 70, 30);
  40.   gtk_box_pack_start(GTK_BOX(hbox), btn, FALSE, FALSE, 0);
  42.   cb = gtk_check_button_new_with_label("Connect");
  43.   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cb), TRUE);
  44.   gtk_box_pack_start(GTK_BOX(hbox), cb, FALSE, FALSE, 0);
  46.   vbox = gtk_vbox_new(FALSE, 5);
  47.   gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
  48.   gtk_container_add(GTK_CONTAINER(window), vbox);  
  50.   handler_id = g_signal_connect(G_OBJECT(btn), "clicked", 
  51.       G_CALLBACK(button_clicked), NULL);
  53.   g_signal_connect(G_OBJECT(cb), "clicked",
  54.       G_CALLBACK(toogle_signal), (gpointer) btn);
  56.   g_signal_connect(G_OBJECT(window), "destroy",
  57.       G_CALLBACK(gtk_main_quit), NULL);
  59.   gtk_widget_show_all(window);
  61.   gtk_main();
  63.   return 0;
  64. }

在代码示例中，我们有一个按钮和一个复选框。 复选框用于从按钮的clicked信号连接或断开回调。

  1. handler_id = g_signal_connect(G_OBJECT(btn), "clicked", 
  2.     G_CALLBACK(button_clicked), NULL);

g_signal_connect()返回唯一标识回调的处理器 ID。

  1. if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) {
  2.    handler_id = g_signal_connect(G_OBJECT(window), "clicked", 
  3.          G_CALLBACK(button_clicked), NULL);
  4. } else {
  5.    g_signal_handler_disconnect(window, handler_id);
  6. }

此代码确定复选框的状态。 根据状态，它通过g_signal_connect()函数连接回调或通过g_signal_handler_disconnect()函数断开连接。

GTK 事件和信号 - 图2

图：断开连接

拖放示例

在下一个示例中，我们显示无边界窗口，并学习如何拖动和移动这样的窗口。

dragdrop.c

  1. #include <gtk/gtk.h>
  3. gboolean on_button_press(GtkWidget* widget,
  4.   GdkEventButton *event, GdkWindowEdge edge) {
  6.   if (event->type == GDK_BUTTON_PRESS) {
  8.     if (event->button == 1) {
  9.       gtk_window_begin_move_drag(GTK_WINDOW(gtk_widget_get_toplevel(widget)),
  10.           event->button,
  11.           event->x_root,
  12.           event->y_root,
  13.           event->time);
  14.     }
  15.   }
  17.   return TRUE;
  18. }
  20. int main(int argc, char *argv[]) {
  22.   GtkWidget *window;
  24.   gtk_init(&argc, &argv);
  26.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  27.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  28.   gtk_window_set_default_size(GTK_WINDOW(window), 250, 200);
  29.   gtk_window_set_title(GTK_WINDOW(window), "Drag & drop");
  30.   gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
  31.   gtk_widget_add_events(window, GDK_BUTTON_PRESS_MASK);
  33.   g_signal_connect(G_OBJECT(window), "button-press-event",
  34.       G_CALLBACK(on_button_press), NULL);
  36.   g_signal_connect(G_OBJECT(window), "destroy",
  37.         G_CALLBACK(gtk_main_quit), G_OBJECT(window));
  39.   gtk_widget_show(window);
  41.   gtk_main();
  43.   return 0;
  44. }

该示例演示了无边界窗口的拖放操作。

  1. gtk_window_set_decorated(GTK_WINDOW(window), FALSE);

我们使用gtk_window_set_decorated()函数删除窗口装饰。 这意味着该窗口将没有边框和标题栏。

  1. g_signal_connect(G_OBJECT(window), "button-press-event",
  2.     G_CALLBACK(on_button_press), NULL);

我们将窗口连接到button-press-event信号。

  1. gboolean on_button_press(GtkWidget* widget,
  2.   GdkEventButton *event, GdkWindowEdge edge) {
  4.   if (event->type == GDK_BUTTON_PRESS) {
  6.     if (event->button == 1) {
  7.       gtk_window_begin_move_drag(GTK_WINDOW(gtk_widget_get_toplevel(widget)),
  8.           event->button,
  9.           event->x_root,
  10.           event->y_root,
  11.           event->time);
  12.     }
  13.   }
  15.   return TRUE;
  16. }

在on_button_press()函数内，我们执行拖放操作。 我们检查是否按下了鼠标左键。 然后我们调用gtk_window_begin_move_drag()函数，该函数开始移动窗口。

计时器示例

下面的示例演示一个计时器示例。 当我们有一些重复的任务时使用计时器。 可能是时钟，倒数，视觉效果或动画。

timer.c

  1. #include <cairo.h>
  2. #include <gtk/gtk.h>
  4. gchar buf[256];
  6. gboolean on_expose_event(GtkWidget *widget,
  7.     GdkEventExpose *event,
  8.     gpointer data) {
  10.   cairo_t *cr;
  12.   cr = gdk_cairo_create(widget->window);
  14.   cairo_move_to(cr, 30, 30);
  15.   cairo_set_font_size(cr, 15);
  16.   cairo_show_text(cr, buf);
  18.   cairo_destroy(cr);
  20.   return FALSE;
  21. }
  23. gboolean time_handler(GtkWidget *widget) {
  25.   if (widget->window == NULL) return FALSE;
  27.   GDateTime *now = g_date_time_new_now_local(); 
  28.   gchar *my_time = g_date_time_format(now, "%H:%M:%S");
  30.   g_sprintf(buf, "%s", my_time);
  32.   g_free(my_time);
  33.   g_date_time_unref(now);
  35.   gtk_widget_queue_draw(widget);
  37.   return TRUE;
  38. }
  40. int main(int argc, char *argv[]) {
  42.   GtkWidget *window;
  43.   GtkWidget *darea;
  45.   gtk_init(&argc, &argv);
  47.   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  49.   darea = gtk_drawing_area_new();
  50.   gtk_container_add(GTK_CONTAINER(window), darea);
  52.   g_signal_connect(darea, "expose-event",
  53.       G_CALLBACK(on_expose_event), NULL);
  54.   g_signal_connect(window, "destroy",
  55.       G_CALLBACK(gtk_main_quit), NULL);
  57.   gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  58.   gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
  60.   gtk_window_set_title(GTK_WINDOW(window), "Timer");
  61.   g_timeout_add(1000, (GSourceFunc) time_handler, (gpointer) window);
  62.   gtk_widget_show_all(window);
  63.   time_handler(window);
  65.   gtk_main();
  67.   return 0;
  68. }

该示例在窗口上显示当前本地时间。 也使用 Cairo 2D 库。

  1. g_signal_connect(darea, "expose-event",
  2.     G_CALLBACK(on_expose_event), NULL);

我们在on_expose_event()回调中绘制时间。 回调连接到expose-event信号，该信号在要重绘窗口时发出。

  1. g_timeout_add(1000, (GSourceFunc) time_handler, (gpointer) window);

此功能注册计时器。 time_handler()函数会定期重复调用。 就我们而言，每一秒钟。 将调用计时器函数，直到返回FALSE。

  1. time_handler(window);

这将立即调用计时器函数。 否则，将延迟一秒钟。

  1. cairo_t *cr;
  3. cr = gdk_cairo_create(widget->window);
  5. cairo_move_to(cr, 30, 30);
  6. cairo_set_font_size(cr, 15);
  7. cairo_show_text(cr, buf);
  9. cairo_destroy(cr);

此代码在窗口上绘制当前时间。 有关 Cairo 2D 库的更多信息，请参见 ZetCode 的 Cairo 图形教程。

  1. if (widget->window == NULL) return FALSE;

当窗口被破坏时，可能会调用计时器函数。 这行代码可以防止处理已经销毁的窗口小部件。

  1. GDateTime *now = g_date_time_new_now_local(); 
  2. gchar *my_time = g_date_time_format(now, "%H:%M:%S");
  4. g_sprintf(buf, "%s", my_time);

这些行确定当前的本地时间。 时间存储在全局buf变量中。

  1. gtk_widget_queue_draw(widget);

gtk_widget_queue_draw()函数使窗口区域无效，然后发出expose-event信号。

本章是关于 GTK+ 中的事件的。