gtk学习总结:GTK从入门到放弃,三天包教包会

今天花了一些时间复习之前学习过的gtk,感觉东西光学不用忘得好快啊,在这做个之前学过的内容的备份,希望对大家有用,也希望大家不要从入门到放弃。文中有些代码例子可能来自《GTK从入门到精通》吧,我不记得了,或者叫《GTK中文教程》,忘记了,总之,这是一个学习笔记,希望不触及任何人的利益,起到共享学习之用。

目录

编译方法

编译脚本

01.一个简单的按钮

02.两个按钮

03.vbox:一张图片+一个按钮

04.一个简单的提示窗口:下一步+上一步+确定

05.多按钮:一个简单的键盘

06.一个简单的画图draw界面

07.带图片的按钮

08.多选按钮check button

09.单选按钮radio button

10.控制条scrollbar

11.箭头按钮create_arrow_button

12.标签label

12.子窗口:触发事件打开窗口

13.进度条progressbar

14.窗口标尺gtk_hruler_new

15.状态栏(条)gtk_statusbar_new

另一个例子

16.文本输入gtk_entry_new:可见/不可见,可输入/不可输入

规定最大长度的gtk_entry_new_with_max_length

输入文本执行一条命令

17.文件选择:gtk_file_selection_new

18.事件盒子gtk_event_box_new

19.固定容器:gtk_fixed_new

20.一个简单的frame:gtk_frame_new(不同于java的JFrame)

gtk_aspect_frame_new:更多选项的frame

21.滚动窗口:gtk_scrolled_window_new

又一个例子:滚动窗口中放按钮

22.按钮盒子:button box

显示动态图:直接引用GIF,用多张图片显示动图效果

24.画图接口:gdk_draw_arc,gdk_draw_rectangle

25.文本文件编辑gtk_text_view_new

26.菜单/工具栏:gtk_menu_new

27.工具栏/条:gtk_toolbar_new

28.浮动的工具条的菜单

29.一个文本编辑器:包含menu,toolbar,statusbar

30.模拟90坦克游戏:在frame中移动一个图片,键盘控制走向

31.pixmap:

32.固定调节数值的按钮:gtk_spin_button_new_with_range

33.分隔面板:gtk_hpanel_new,gtk_vpanel_new(未编译)

34.会话窗口:gtk_button_new_from_stock

35.字体选择:gtk_font_selection_dialog_new

36.几个画图的骚操作:gtk_drawing_area_new

先给出三个例子的效果:

代码1效果

代码2效果

代码3效果

代码1

代码2

代码3

最后寄语


编译方法

$ gcc main.c `pkg-config --libs --cflags gtk+-3.0`

或者使用gtk-2.0。

编译脚本

#!/bin/bash

if [ $# -lt 1 ]; then
    echo "usage: $0 [main.c]"
    exit
fi

gcc -o a $1 `pkg-config --libs --cflags gtk+-2.0`

01.一个简单的按钮

#include <gtk/gtk.h>
//#include "temp.c"

/* 这是一个回调函数。data 参数在本示例中被忽略。
 * 后面有更多的回调函数示例。*/
void hello( GtkWidget *widget, gpointer   data )
{
    g_print ("Hello World\n");//temp(data );
}

gint delete_event( GtkWidget *widget, GdkEvent  *event, gpointer   data )
{
    /* 如果你的 "delete_event" 信号处理函数返回 FALSE,GTK 会发出 "destroy" 信号。
     * 返回 TRUE,你不希望关闭窗口。
     * 当你想弹出“你确定要退出吗?”对话框时它很有用。*/

    g_print ("delete event occurred\n");

    /* 改 TRUE 为 FALSE 程序会关闭。*/

    return FALSE;
}

/* 另一个回调函数 */
void destroy( GtkWidget *widget, gpointer   data )
{
    gtk_main_quit ();
}

int main( int   argc, char *argv[] )
{
    /* GtkWidget 是构件的存储类型 */
    GtkWidget *window;
    GtkWidget *button;
    
    /* 这个函数在所有的 GTK 程序都要调用。参数由命令行中解析出来并且送到该程序中*/
    gtk_init (&argc, &argv);
    
    /* 创建一个新窗口 */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    
    /* 当窗口收到 "delete_event" 信号 (这个信号由窗口管理器发出,通常是“关闭”
     * 选项或是标题栏上的关闭按钮发出的),我们让它调用在前面定义的 delete_event() 函数。
     * 传给回调函数的 data 参数值是 NULL,它会被回调函数忽略。*/
    g_signal_connect (G_OBJECT (window), "delete_event",
        G_CALLBACK (delete_event), NULL);
    
    /* 在这里我们连接 "destroy" 事件到一个信号处理函数。  
     * 对这个窗口调用 gtk_widget_destroy() 函数或在 "delete_event" 回调函数中返回 FALSE 值
     * 都会触发这个事件。*/
    g_signal_connect (G_OBJECT (window), "destroy",
        G_CALLBACK (destroy), NULL);
    
    /* 设置窗口边框的宽度。*/
    gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
    /* 创建一个标签为 "Hello World" 的新按钮。*/
    button = gtk_button_new_with_label ("Hello World");
    
    /* 当按钮收到 "clicked" 信号时会调用 hello() 函数,并将NULL传给
     * 它作为参数。hello() 函数在前面定义了。*/
    g_signal_connect (G_OBJECT (button), "clicked",
        G_CALLBACK (hello), "1");
    
    /* 当点击按钮时,会通过调用 gtk_widget_destroy(window) 来关闭窗口。
     * "destroy" 信号会从这里或从窗口管理器发出。*/
   // g_signal_connect_swapped (G_OBJECT (button), "clicked",
   //      G_CALLBACK (gtk_widget_destroy),window);
    
    /* 把按钮放入窗口 (一个 gtk 容器) 中。*/
    gtk_container_add (GTK_CONTAINER (window), button);
    
    /* 最后一步是显示新创建的按钮和窗口 */
    gtk_widget_show (button);
    gtk_widget_show (window);
    
    /* 所有的 GTK 程序必须有一个 gtk_main() 函数。程序运行停在这里
     * 等待事件 (如键盘事件或鼠标事件) 的发生。*/
    gtk_main ();
    
    return 0;
}

02.两个按钮

#include <gtk/gtk.h>
/* 我们新改进的回调函数。传递到该函数的数据将打印到标准输出(stdout)。*/
void callback( GtkWidget *widget, gpointer data )
{
       g_print ("%s ", (gchar *) data);
}
/* 另一个回调函数 */
gint delete_event( GtkWidget *widget, GdkEvent *event, gpointer data )
{
     gtk_main_quit ();
     return FALSE;
}

int main( int argc, char *argv[] )
{
/* GtkWidget 是构件的存储类型 */
      GtkWidget *window;
      GtkWidget *button;
      GtkWidget *box1;

      gtk_init (&argc, &argv);
/* 创建一个新窗口 */
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* 这是一个新的调用,设置窗口标题为"Hello Buttons!" */
      gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!");
/* 在这里我们为 delete_event 设置了一个处理函数来立即退出 GTK。*/
      g_signal_connect (G_OBJECT (window), "delete_event",
                        G_CALLBACK (delete_event), NULL);
/* 设置窗口边框的宽度。 */
      gtk_container_set_border_width (GTK_CONTAINER (window), 20);
/* 我们创建了一个组装盒。详情参见“组装”章节。我们看不见组装盒,它仅被作为排列构件的工具。*/
      box1 = gtk_hbox_new (FALSE, 1);
/* 把组装盒放入主窗口中。*/
      gtk_container_add (GTK_CONTAINER (window), box1);
/* 创建一个标签为 "Button 1" 的新按钮。*/
      button = gtk_button_new_with_label ("Hello");
/* 当按钮被按下时,我们调用 "callback" 函数,并将一个指向 "button 1" 的指针作为它的参数。*/
      g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), "hello");
/* 代替 gtk_container_add,我们把按钮放入不可见的组装盒,该组合盒已经组装进窗口中了。*/
      gtk_box_pack_start (GTK_BOX(box1), button, TRUE, TRUE, 0);
/* 总是记住这一步,它告诉 GTK 我们为这个按钮做的准备工作已经完成了,现在可以显示它了。*/
      gtk_widget_show (button);
/* 同样创建第二个按钮。*/
      button = gtk_button_new_with_label ("World");
      g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), "World");
      gtk_box_pack_start(GTK_BOX (box1), button, TRUE, TRUE, 0);
      gtk_widget_show (button);
/* 同样创建第3个按钮。*/
      button = gtk_button_new_with_label ("!");
      g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), "!");
      gtk_box_pack_start(GTK_BOX (box1), button, TRUE, TRUE, 0);
      gtk_widget_show (button);

      gtk_widget_show (box1);
      gtk_widget_show (window);
/* 停在这里等待事件发生。*/
      gtk_main ();
      return 0;
}

03.vbox:一张图片+一个按钮

/* 创建SPLASH窗口 splash.c */
#include <gtk/gtk.h>
//主函数
int main (int argc,char* argv[])
{
   GtkWidget* window ;
   GtkWidget* vbox ;
   GtkWidget* image ;
   GtkWidget* button ;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_POPUP);//no boundary
   gtk_window_set_title(GTK_WINDOW(window),"Splash窗口");
   g_signal_connect(G_OBJECT(window),"destroy",
      G_CALLBACK(gtk_main_quit),NULL);
   //gtk_container_set_border_width(GTK_CONTAINER(window),20);
   //gtk_window_set_default_size(GTK_WINDOW(window),500,400);
   //gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);

   vbox = gtk_vbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(window),vbox);
   image = gtk_image_new_from_file("b.png");
   gtk_box_pack_start(GTK_BOX(vbox),image,FALSE,FALSE,0);
   button = gtk_button_new_with_label("Splash窗口");
   g_signal_connect(G_OBJECT(button),"clicked",
      G_CALLBACK(gtk_main_quit),NULL);
   gtk_box_pack_start(GTK_BOX(vbox),button,FALSE,FALSE,0);
   gtk_widget_show_all(window);
   gtk_main();
   return FALSE;
}

04.一个简单的提示窗口:下一步+上一步+确定

/* 每日提示 tips.c */
#include <gtk/gtk.h>
//XPM格式的图像数据,以C语言源代码形式存于文件中
static char * book_open_xpm[] = {
   "16 16 4 1",
   " c None s None",
   ". c black",
   "X c #808080",
   "o c white",
   " ",
   " .. ",
   " .Xo. ... ",
   " .Xoo. ..oo. ",
   " .Xooo.Xooo... ",
   " .Xooo.oooo.X. ",
   " .Xooo.Xooo.X. ",
   " .Xooo.oooo.X. ",
   " .Xooo.Xooo.X. ",
   " .Xooo.oooo.X. ",
   " .Xoo.Xoo..X. ",
   " .Xo.o..ooX. ",
   " .X..XXXXX. ",
   " ..X....... ",
   " .. ",
   " "};
//自定义提示信息
static gchar *info[5] = {
   "此软件用于测试每日提示功能的实现,如果你发现问题请及时回复。",
   "我们的目的是把GTK+2.0的大多数功能奉献给每一位自由软件爱好者和开发者。",
   "每一位Linux的支持者都会让我们增加一分信心,Linux最终仍是台式计算机操作系统。",
   "计算机软件技术是一种科学技术,它和人类历史上其他的科学技术一样,是允许每一人自由使用的。",
   "当前你测试完此程序后,请设法把它附加到你创作的软件当中去,这是你成功的第一步。"
};
static GtkWidget *window; //主窗口
static GtkWidget *frame; //框架
static GtkWidget *pre_button; //上一提示按钮
static GtkWidget *next_button; //下一提示按钮
static GtkWidget *label; //提示信息内容标签
static GtkWidget *title; //框架的标题
gint current_info = 0 ;//当前提示信息计数
GtkWidget* create_title (GtkWidget *data)
{ //创建框架控件的标题
   GtkWindow *title;
   GtkWidget *hbox;
   GtkWidget *image;
   GtkWidget *label;
   GdkPixmap *pixmap;
   GdkBitmap *mask;
   pixmap = gdk_pixmap_create_from_xpm_d(
                  data->window,&mask,
                  &GTK_WIDGET(data)->style->white,
                  book_open_xpm);
   image = gtk_image_new_from_pixmap(pixmap,NULL);
   label = gtk_label_new("新的标题");
   hbox = gtk_hbox_new(FALSE,0);
   gtk_box_pack_start(GTK_BOX(hbox),image,FALSE,FALSE,2);
   gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,2);
   return hbox ;
}
GtkWidget* create_button (gchar* stockid,gchar* title)
{ //创建带图像的按钮
   GtkWidget *button;
   GtkWidget *image;
   GtkWidget *label;
   GtkWidget *hbox;
   image = gtk_image_new_from_stock(stockid,GTK_ICON_SIZE_MENU);
   label = gtk_label_new(title);
   hbox = gtk_hbox_new(FALSE,0);
   gtk_box_pack_start(GTK_BOX(hbox),image,FALSE,FALSE,3);
   gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,3);
   button = gtk_button_new();
   gtk_container_add(GTK_CONTAINER(button),hbox);
   return button;
}
void pre_info (GtkButton *button,gpointer data)
{ //上一提示
   gint i ;
   i = current_info - 1 ;
   if(i == -1) return ;
   if(i == 0 ) gtk_widget_set_sensitive(pre_button,FALSE);
   current_info = i ;
   gtk_widget_set_sensitive(next_button,TRUE);
   gtk_label_set_text(GTK_LABEL(label),info[current_info]);
}
void next_info (GtkButton *button,gpointer data)
{ //下一提示
   gint i ;
   i = current_info + 1 ;
   if(i == 5) return ;
   if(i == 4) gtk_widget_set_sensitive(next_button,FALSE);
   current_info = i ;
   gtk_widget_set_sensitive(pre_button,TRUE);
   gtk_label_set_text(GTK_LABEL(label),info[current_info]);
}
int main ( int argc , char* argv[])
{
   GtkWidget *hbox ;
   GtkWidget *vbox;
   GtkWidget *bbox;
   GtkWidget *button;
   GtkWidget *image;
   GtkWidget *title;
   gtk_init(&argc,&argv);
   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   g_signal_connect(G_OBJECT(window),"delete_event",
         G_CALLBACK(gtk_main_quit),NULL);
   gtk_window_set_title(GTK_WINDOW(window),"每日提示");
   gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
   gtk_container_set_border_width(GTK_CONTAINER(window),10);
   gtk_widget_realize(window);
   vbox = gtk_vbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(window),vbox);
   hbox = gtk_hbox_new(FALSE,0);
   gtk_box_pack_start(GTK_BOX(vbox),hbox,TRUE,TRUE,5);
   image = gtk_image_new_from_file("l.bmp");
   gtk_box_pack_start(GTK_BOX(hbox),image,FALSE,FALSE,5);
   frame = gtk_frame_new(NULL);
   title = create_title(window);
   gtk_frame_set_label_widget(GTK_FRAME(frame),title);
   gtk_box_pack_start(GTK_BOX(hbox),frame,TRUE,TRUE,5);
   label = gtk_label_new(NULL);
   gtk_label_set_text(GTK_LABEL(label),info[0]);
   gtk_label_set_line_wrap(GTK_LABEL(label),TRUE);
   gtk_container_add(GTK_CONTAINER(frame),label);
   bbox = gtk_hbutton_box_new();
   gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox),GTK_BUTTONBOX_END);
   gtk_box_set_spacing(GTK_BOX(bbox),5);
   gtk_box_pack_start(GTK_BOX(vbox),bbox,FALSE,FALSE,5);
   button = gtk_check_button_new_with_label("每次启动时显示");
   gtk_box_pack_start(GTK_BOX(bbox),button,FALSE,FALSE,5);
   pre_button = create_button(GTK_STOCK_GO_BACK,"上一提示");
   gtk_widget_set_sensitive(pre_button,FALSE);
   g_signal_connect(G_OBJECT(pre_button),"clicked",
         G_CALLBACK(pre_info),NULL);
   gtk_box_pack_start(GTK_BOX(bbox),pre_button,FALSE,FALSE,5);
   next_button = create_button(GTK_STOCK_GO_FORWARD,"下一提示");
   g_signal_connect(G_OBJECT(next_button),"clicked",
         G_CALLBACK(next_info),NULL);
   gtk_box_pack_start(GTK_BOX(bbox),next_button,FALSE,FALSE,5);
   button = gtk_button_new_from_stock(GTK_STOCK_OK);
   g_signal_connect(G_OBJECT(button),"clicked",
         G_CALLBACK(gtk_main_quit),NULL);
   gtk_box_pack_start(GTK_BOX(bbox),button,FALSE,FALSE,5);
   gtk_widget_show_all(window);
   gtk_main();
   return FALSE;
}

效果:

05.多按钮:一个简单的键盘

#include <gtk/gtk.h>
/* 我们的回调。
* 传到这个函数的数据被打印到标准输出 */
void callback( GtkWidget *widget, gpointer data )
{
    g_print ("%s", (char *) data);
}
/* 这个回调退出程序 */
gint delete_event( GtkWidget *widget, GdkEvent *event, gpointer data )
{
    gtk_main_quit ();
    return FALSE;
}
int main( int argc, char *argv[] )
{
    GtkWidget *window;
    GtkWidget *button;
    GtkWidget *table;
    gtk_init (&argc, &argv);
/* 创建一个新窗口 */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* 设置窗口标题 */
    gtk_window_set_title (GTK_WINDOW (window), "Rong Tao's Keyboard");
/* 为 delete_event 设置一个立即退出 GTK 的处理函数。 */
    g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), NULL);
/* 设置窗口的边框宽度。 */
    gtk_container_set_border_width (GTK_CONTAINER (window), 20);
/* 创建一个 2x2 的表 */
    table = gtk_table_new (4, 20, TRUE);
/* 将表放进主窗口 */
    gtk_container_add (GTK_CONTAINER (window), table);
/* 创建第一个按钮 */
    button = gtk_button_new_with_label ("Q");
/* 当这个按钮被点击时,我们调用 "callback" 函数,并将一个指向"button 1"的指针作为它的参数 */
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "q");
/* 将 button 1 插入表的左上象限(quadrant) */
    gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 2, 0, 1);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("W");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "w");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 4, 0, 1);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("E");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "e");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 4, 6, 0, 1);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("R");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "r");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 6, 8, 0, 1);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("T");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "t");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 8, 10, 0, 1);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("Y");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "y");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 10, 12, 0, 1);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("U");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "u");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 12, 14, 0, 1);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("I");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "i");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 14, 16, 0, 1);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("O");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "o");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 16, 18, 0, 1);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("P");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "p");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 18, 20, 0, 1);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("A");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "a");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 1, 3, 1, 2);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("S");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "s");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 3, 5, 1, 2);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("D");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "d");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 5, 7, 1, 2);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("F");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "f");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 7, 9, 1, 2);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("G");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "g");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 9, 11, 1, 2);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("H");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "h");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 11, 13, 1, 2);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("J");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "j");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 13, 15, 1, 2);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("K");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "k");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 15, 17, 1, 2);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("L");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "l");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 17, 19, 1, 2);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("'");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "'");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 0, 2, 2, 3);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("Z");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "z");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 4, 2, 3);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("X");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "x");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 4, 6, 2, 3);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("C");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "c");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 6, 8, 2, 3);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("V");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "v");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 8, 10, 2, 3);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("B");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "b");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 10, 12, 2, 3);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("N");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "n");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 12, 14, 2, 3);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("M");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "m");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 14, 16, 2, 3);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label (",");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) ",");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 16, 18, 2, 3);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label (".");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) ".");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 18, 20, 2, 3);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label ("Enter");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) "\n");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 6, 3, 4);
    gtk_widget_show (button);
/*********************/
    button = gtk_button_new_with_label (" ");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback), (gpointer) " ");
    gtk_table_attach_defaults (GTK_TABLE (table), button, 6, 16, 3, 4);
    gtk_widget_show (button);
/* 创建"Quit"按钮 */
    button = gtk_button_new_with_label ("Quit");
/* 当这个按钮被点击时,我们调用 "delete_event" 函数接着程序就退出了 */
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (delete_event), NULL);
/* 将退出按钮插入表的下面两个象限 */
    gtk_table_attach_defaults (GTK_TABLE (table), button, 16, 19, 3, 4);
    gtk_widget_show (button);

    gtk_widget_show (table);
    gtk_widget_show (window);
    gtk_main ();
    return 0;
}

06.一个简单的画图draw界面

/* 绘图软件 brush.c */
#include <gtk/gtk.h>
static GtkWidget *window = NULL;
static GdkPixmap *pixmap = NULL;
static gboolean
scribble_configure_event (GtkWidget *widget,GdkEventConfigure *event,gpointer data)
{
   if (pixmap)
   g_object_unref (G_OBJECT (pixmap));
   pixmap = gdk_pixmap_new (widget->window,
   widget->allocation.width,
   widget->allocation.height,-1);
   gdk_draw_rectangle (pixmap,widget->style->white_gc,
                        TRUE,0,0,widget->allocation.width,
                        widget->allocation.height);
   return TRUE;
}
static gboolean scribble_expose_event (GtkWidget *widget,GdkEventExpose *event,gpointer data)
{
   gdk_draw_drawable (widget->window,
                        widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
                        pixmap,
                        event->area.x, event->area.y,
                        event->area.x, event->area.y,
                        event->area.width, event->area.height);
   return FALSE;
}
static void draw_brush (GtkWidget *widget, gdouble x, gdouble y)
{
   GdkRectangle update_rect;
   update_rect.x = x - 3;
   update_rect.y = y - 3;
   update_rect.width = 6;
   update_rect.height = 6;
   gdk_draw_rectangle (pixmap,
                        widget->style->black_gc,
                        TRUE,
                        update_rect.x, update_rect.y,
                        update_rect.width, update_rect.height);
                        gdk_window_invalidate_rect (widget->window,
                        &update_rect,
                        FALSE);
}
static gboolean scribble_button_press_event (GtkWidget *widget,GdkEventButton *event,gpointer data)
{
   if (pixmap == NULL)
      return FALSE;
   if (event->button == 1)
      draw_brush (widget, event->x, event->y);
   return TRUE;
}
static gboolean scribble_motion_notify_event (GtkWidget *widget,GdkEventMotion *event,gpointer data)
{
   int x, y;
   GdkModifierType state;
   if (pixmap == NULL)
      return FALSE;
   gdk_window_get_pointer (event->window, &x, &y, &state);
   if (state & GDK_BUTTON1_MASK)
      draw_brush (widget, x, y);
   return TRUE;
}
static gboolean checkerboard_expose (GtkWidget *da, GdkEventExpose *event,gpointer data)
{
   gint i, j, xcount, ycount;
   GdkGC *gc1, *gc2;
   GdkColor color;
#define CHECK_SIZE 10
#define SPACING 2
   gc1 = gdk_gc_new (da->window);
   color.red = 30000;
   color.green = 0;
   color.blue = 30000;
   gdk_gc_set_rgb_fg_color (gc1, &color);
   gc2 = gdk_gc_new (da->window);
   color.red = 65535;
   color.green = 65535;
   color.blue = 65535;
   gdk_gc_set_rgb_fg_color (gc2, &color);
   xcount = 0;
   i = SPACING;
   while (i < da->allocation.width)
   {
      j = SPACING;
      ycount = xcount % 2;
      while (j < da->allocation.height)
      {
         GdkGC *gc;
         if (ycount % 2)
            gc = gc1;
         else
            gc = gc2;
         gdk_draw_rectangle (da->window, gc, TRUE,
                              i, j, CHECK_SIZE, CHECK_SIZE);
         j += CHECK_SIZE + SPACING;
         ++ycount;
      }
      i += CHECK_SIZE + SPACING;
      ++xcount;
   }
   g_object_unref (G_OBJECT (gc1));
   g_object_unref (G_OBJECT (gc2));
   return TRUE;
}
int main (int argc,char* argv[])
{
   GtkWidget *frame;
   GtkWidget *vbox;
   GtkWidget *da;
   GtkWidget *label;

   gtk_init(&argc,&argv);

   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title (GTK_WINDOW (window), "绘图软件");
   g_signal_connect (G_OBJECT(window), "delete_event",
         G_CALLBACK (gtk_main_quit), NULL);
   gtk_container_set_border_width (GTK_CONTAINER (window), 10);

   vbox = gtk_vbox_new (FALSE, 8);
   gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
   gtk_container_add (GTK_CONTAINER (window), vbox);

   label = gtk_label_new (NULL);
   gtk_label_set_markup (GTK_LABEL (label),"<u>绘图区域</u>");
   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);

   frame = gtk_frame_new (NULL);
   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
   gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);

   da = gtk_drawing_area_new ();
   gtk_widget_set_size_request (da, 100, 100);
   gtk_container_add (GTK_CONTAINER (frame), da);

   g_signal_connect (da, "expose_event",
         G_CALLBACK (scribble_expose_event), NULL);
   g_signal_connect (da, "configure_event",
         G_CALLBACK (scribble_configure_event), NULL);
   g_signal_connect (da, "motion_notify_event",
         G_CALLBACK (scribble_motion_notify_event), NULL);
   g_signal_connect (da, "button_press_event",
         G_CALLBACK (scribble_button_press_event), NULL);

   gtk_widget_set_events (da, gtk_widget_get_events (da)
                        | GDK_LEAVE_NOTIFY_MASK
                        | GDK_BUTTON_PRESS_MASK
                        | GDK_POINTER_MOTION_MASK
                        | GDK_POINTER_MOTION_HINT_MASK);


   gtk_widget_show_all (window);
   gtk_main();
   return FALSE;
}

07.带图片的按钮

/* 带图像的按钮 button.c */
#include <gtk/gtk.h>
void on_button_clicked (GtkWidget* button,gpointer data)
{
   //g_print("按钮 %s ",(gchar*)data);
   g_print("Button %s is pressed.\n",(gchar*)data);
   //g_print("被按了一下. \n");
}
//创建自己按钮的函数
GtkWidget* create_button1 (void)
{
   GtkWidget* box;
   GtkWidget* image;
   GtkWidget* label;
   GtkWidget* button;
   char* title = "文件家";
   image = gtk_image_new_from_file("dir2.jpg");
   label = gtk_label_new(title);
   box = gtk_vbox_new(FALSE,2);
   gtk_container_set_border_width(GTK_CONTAINER(box),5);
   gtk_box_pack_start(GTK_BOX(box),image,FALSE,FALSE,3);
   gtk_box_pack_start(GTK_BOX(box),label,FALSE,FALSE,3);
   gtk_widget_show(image);
   gtk_widget_show(label);
   button = gtk_button_new();
   gtk_container_add(GTK_CONTAINER(button),box);
   gtk_widget_show(box);
   return button ;
}
GtkWidget* create_button2 (void)
{
   GtkWidget* box;
   GtkWidget* image;
   GtkWidget* label;
   GtkWidget* button;
   char* title = "蝙蝠侠";
   image = gtk_image_new_from_file("batman.jpg");
   label = gtk_label_new(title);
   box = gtk_hbox_new(FALSE,2);
   gtk_container_set_border_width(GTK_CONTAINER(box),5);
   gtk_box_pack_start(GTK_BOX(box),image,FALSE,FALSE,3);
   gtk_box_pack_start(GTK_BOX(box),label,FALSE,FALSE,3);
   gtk_widget_show(image);
   gtk_widget_show(label);
   button = gtk_button_new();
   gtk_container_add(GTK_CONTAINER(button),box);
   gtk_widget_show(box);
   return button ;
}
//主函数
int main (int argc, char *argv[])
{
   GtkWidget* window;
   GtkWidget* box;
   GtkWidget* button1;
   GtkWidget* button2;
   GtkWidget* button3;
   GtkWidget* button4;

   gchar* title = "带图像和快捷键的按钮";
   gchar* b1 = "Red apple";//"红苹果"
   gchar* b2 = "Small mushroom";//"小蘑菇"
   gchar* b3 = "Short key";//"快捷键"
   gchar* b4 = "OK";//"确认"
   gtk_init(&argc,&argv);
   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(window),title);
   gtk_container_set_border_width(GTK_CONTAINER(window),20);
   g_signal_connect(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL);
   box = gtk_hbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(window),box);
   button1 = create_button1();
   g_signal_connect(G_OBJECT(button1),"clicked",
   G_CALLBACK(on_button_clicked),(gpointer)b1);
   gtk_box_pack_start(GTK_BOX(box),button1,FALSE,FALSE,5);
   button2 = create_button2();
   g_signal_connect(G_OBJECT(button2),"clicked",
   G_CALLBACK(on_button_clicked),(gpointer)b2);
   gtk_box_pack_start(GTK_BOX(box),button2,FALSE,FALSE,5);
   button3 = gtk_button_new_with_mnemonic("快捷键(_H)");
   g_signal_connect(G_OBJECT(button3),"clicked",
   G_CALLBACK(on_button_clicked),(gpointer)b3);
   gtk_box_pack_start(GTK_BOX(box),button3,FALSE,FALSE,5);
   button4 = gtk_button_new_from_stock(GTK_STOCK_OK);
   g_signal_connect(G_OBJECT(button4),"clicked",
   G_CALLBACK(on_button_clicked),(gpointer)b4);
   gtk_box_pack_start(GTK_BOX(box),button4,FALSE,FALSE,5);
   gtk_widget_show_all(window);
   gtk_main();
   return FALSE ;
}

08.多选按钮check button

/* 多项选择窗口 checkbutton.c */
#include <gtk/gtk.h>
gboolean isbold = FALSE ;
gboolean isitli = FALSE ;
gboolean isuline = FALSE ;
gboolean iscolor = FALSE ;
void on_check_clicked (GtkWidget* check,gint data)
{
   switch((int)data)
   {
      case 1:
         isbold = !isbold;
         break;
      case 2:
         isitli = !isitli;
         break;
      case 3:
         isuline = !isuline;
         break;
      case 4:
         iscolor = !iscolor;
         break;
   }
}
void on_button_clicked (GtkWidget *button,gpointer data)
{
   g_print("字体配置为:");
   if(isbold)
      g_print("粗体 ");
   if(isitli)
      g_print("斜体 ");
   if(isuline)
      g_print("下划线 ");
   if(iscolor)
      g_print("彩色 ");
   if( !isbold && !iscolor && !isuline && !isitli )
      g_print("正常,无任何选项");
   g_print("\n");
}
//主函数
int main (int argc, char *argv[])
{
   GtkWidget* window;
   GtkWidget* frame;
   GtkWidget* box;
   GtkWidget* button;
   GtkWidget* box1;
   GtkWidget* check1;
   GtkWidget* check2;
   GtkWidget* check3;
   GtkWidget* check4;
   char* title = "多项选择窗口";
   gtk_init(&argc,&argv);
   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(window),title);
   gtk_container_set_border_width(GTK_CONTAINER(window),20);
   g_signal_connect(G_OBJECT(window),"destroy",
         G_CALLBACK(gtk_main_quit),NULL);
   box = gtk_vbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(window),box);
   frame = gtk_frame_new("字体选项:");
   gtk_box_pack_start(GTK_BOX(box),frame,FALSE,FALSE,5);
   box1 = gtk_vbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(frame),box1);
   gtk_container_set_border_width(GTK_CONTAINER(box1),10);
   gtk_widget_show(box);
   check1 = gtk_check_button_new_with_label(" 粗体 ");
   g_signal_connect(G_OBJECT(check1),"released",
         G_CALLBACK(on_check_clicked),(gpointer)1);
   gtk_box_pack_start(GTK_BOX(box1),check1,FALSE,FALSE,3);
   check2 = gtk_check_button_new_with_label(" 斜体 ");
   g_signal_connect(G_OBJECT(check2),"released",
         G_CALLBACK(on_check_clicked),(gpointer)2);
   gtk_box_pack_start(GTK_BOX(box1),check2,FALSE,FALSE,3);
   check3 = gtk_check_button_new_with_label(" 下划线 ");
   g_signal_connect(G_OBJECT(check3),"released",
         G_CALLBACK(on_check_clicked),(gpointer)3);
   gtk_box_pack_start(GTK_BOX(box1),check3,FALSE,FALSE,3);
   check4 = gtk_check_button_new_with_label(" 彩色 ");
   g_signal_connect(G_OBJECT(check4),"released",
         G_CALLBACK(on_check_clicked),(gpointer)4);
   gtk_box_pack_start(GTK_BOX(box1),check4,FALSE,FALSE,3);
   button = gtk_button_new_from_stock(GTK_STOCK_OK);
   g_signal_connect(G_OBJECT(button),"clicked",
         G_CALLBACK(on_button_clicked),NULL);
   g_signal_connect_swapped(G_OBJECT(button),"clicked",
         G_CALLBACK(gtk_widget_destroy),window);
   gtk_box_pack_start(GTK_BOX(box),button,FALSE,FALSE,5);
   gtk_widget_show_all(window);
   gtk_main();
   return FALSE ;
}

09.单选按钮radio button

这里给出两个例子

#include <glib.h>
#include <gtk/gtk.h>
gint close_application( GtkWidget *widget, GdkEvent *event, gpointer data )
{
   gtk_main_quit ();
   return FALSE;
}
int main( int argc, char *argv[] )
{
   GtkWidget *window = NULL;
   GtkWidget *box1;
   GtkWidget *box2;
   GtkWidget *button;
   GtkWidget *separator;
   GSList *group;

   gtk_init (&argc, &argv);

   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   g_signal_connect (G_OBJECT (window), "delete_event",
                     G_CALLBACK (close_application), NULL);
   gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
   gtk_container_set_border_width (GTK_CONTAINER (window), 0);
  
   box1 = gtk_vbox_new (FALSE, 0);
   gtk_container_add (GTK_CONTAINER (window), box1);
   gtk_widget_show (box1);

   box2 = gtk_hbox_new (FALSE, 10);
   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
   gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
   gtk_widget_show (box2);

   button = gtk_radio_button_new_with_label (NULL, "Leonvel");
   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
   gtk_widget_show (button);

   group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));

   button = gtk_radio_button_new_with_label (group, "Rong");
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
   gtk_widget_show (button);

   button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (button),
                                                         "Tao");
   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
   gtk_widget_show (button);

   separator = gtk_hseparator_new ();
   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
   gtk_widget_show (separator);

   box2 = gtk_vbox_new (FALSE, 10);
   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
   gtk_widget_show (box2);

   button = gtk_button_new_with_label ("close");
   g_signal_connect_swapped (G_OBJECT (button), "clicked",
                             G_CALLBACK (close_application), window);
   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
                       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);

   gtk_widget_grab_default (button);
   gtk_widget_show (button);
   gtk_widget_show (window);
   gtk_main ();
   return 0;
}

第二个例子

/* 单项选择窗口 radiobutton.c */
#include <gtk/gtk.h>
static gchar* red = " 红色 " ;
static gchar* green = " 绿色 " ;
static gchar* yellow = " 黄色 " ;
static gchar* blue = " 蓝色 " ;
void on_radio_clicked (GtkWidget* radio,gint data)
{
   g_print("你选择的颜色是:");
   switch((int)data)
   {
      case 1:
         g_print("%s",red); break;
      case 2:
         g_print("%s",green); break;
      case 3:
         g_print("%s",yellow); break;
      case 4:
         g_print("%s",blue); break;
   }
   g_print("\n");
}
//主函数
int main (int argc, char *argv[])
{
   GtkWidget* window;
   GtkWidget* frame;
   GtkWidget* box;
   GtkWidget* box1;
   GtkWidget* button1;
   GtkWidget* radio1;
   GtkWidget* radio2;
   GtkWidget* radio3;
   GtkWidget* radio4;
   GSList* group;
   gchar* title = "单项选择窗口" ;
   gtk_init(&argc,&argv);
   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(window),title);
   gtk_container_set_border_width(GTK_CONTAINER(window),10);
   g_signal_connect(G_OBJECT(window),"destroy",
   G_CALLBACK(gtk_main_quit),NULL);
   box = gtk_vbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(window),box);
   frame = gtk_frame_new("请选择一种颜色:");
   gtk_frame_set_shadow_type(GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
   gtk_box_pack_start(GTK_BOX(box),frame,FALSE,FALSE,5);
   box1 = gtk_hbox_new(FALSE,10);
   gtk_container_set_border_width(GTK_CONTAINER(box1),10);
   gtk_container_add(GTK_CONTAINER(frame),box1);
   radio1 = gtk_radio_button_new_with_label(NULL,red);//红色
   g_signal_connect(G_OBJECT(radio1),"released",
         G_CALLBACK(on_radio_clicked),(gpointer)1);
   gtk_box_pack_start(GTK_BOX(box1),radio1,FALSE,FALSE,5);
//创建多选按钮组
   group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio1));
   radio2 = gtk_radio_button_new_with_label(group,green);//绿色
   g_signal_connect(G_OBJECT(radio2),"released",
         G_CALLBACK(on_radio_clicked),(gpointer)2);
   gtk_box_pack_start(GTK_BOX(box1),radio2,FALSE,FALSE,5);
   group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio2));
   radio3 = gtk_radio_button_new_with_label(group,yellow);//黄色
   g_signal_connect(G_OBJECT(radio3),"released",
         G_CALLBACK(on_radio_clicked),(gpointer)3);
   gtk_box_pack_start(GTK_BOX(box1),radio3,FALSE,FALSE,5);
   group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio3));
   radio4 = gtk_radio_button_new_with_label(group,blue);//蓝色
   g_signal_connect(G_OBJECT(radio4),"released",
         G_CALLBACK(on_radio_clicked),(gpointer)4);
   gtk_box_pack_start(GTK_BOX(box1),radio4,FALSE,FALSE,5);
   button1 = gtk_button_new_from_stock(GTK_STOCK_OK);
   g_signal_connect(G_OBJECT(button1),"clicked",
         G_CALLBACK(gtk_main_quit),NULL);
   gtk_box_pack_start(GTK_BOX(box),button1,FALSE,FALSE,5);
   gtk_widget_show_all(window);
   gtk_main();
   return FALSE ;
}

10.控制条scrollbar

#include <gtk/gtk.h>
GtkWidget *hscale, *vscale;
void cb_pos_menu_select( GtkWidget *item, GtkPositionType pos )
{
/* 设置两个比例构件的比例值的显示位置 */
   gtk_scale_set_value_pos (GTK_SCALE (hscale), pos);
   gtk_scale_set_value_pos (GTK_SCALE (vscale), pos);
}
void cb_update_menu_select( GtkWidget *item, GtkUpdateType policy )
{
/* 设置两个比例构件的更新方式 */
   gtk_range_set_update_policy (GTK_RANGE (hscale), policy);
   gtk_range_set_update_policy (GTK_RANGE (vscale), policy);
}
void cb_digits_scale( GtkAdjustment *adj )
{
/* 设置 adj->value 圆整的小数位数 */
   gtk_scale_set_digits (GTK_SCALE (hscale), (gint) adj->value);
   gtk_scale_set_digits (GTK_SCALE (vscale), (gint) adj->value);
}
void cb_page_size( GtkAdjustment *get, GtkAdjustment *set )
{
/* 将示例调整对象的 page size 和 page increment size 设置
* 为"Page Size"比例构件指定的值 */
   set->page_size = get->value;
   set->page_increment = get->value;
/* 设置调整对象的值并使它引发一个 "changed" 信号,以重新配置所有
* 已经连接到这个调整对象的构件。 */
   gtk_adjustment_set_value (set, CLAMP (set->value,
             set->lower, (set->upper - set->page_size)));
}
void cb_draw_value( GtkToggleButton *button )
{
/* 根据复选按钮的状态设置在比例构件上是否显示比例值 */
   gtk_scale_set_draw_value (GTK_SCALE (hscale), button->active);
   gtk_scale_set_draw_value (GTK_SCALE (vscale), button->active);
}
/* 方便的函数 */
GtkWidget *make_menu_item (gchar *name, GCallback callback, gpointer data)
{
   GtkWidget *item;
   item = gtk_menu_item_new_with_label (name);
   g_signal_connect (G_OBJECT (item), "activate", callback, data);
   gtk_widget_show (item);
   return item;
}
void scale_set_default_values( GtkScale *scale )
{
   gtk_range_set_update_policy (GTK_RANGE (scale),
   GTK_UPDATE_CONTINUOUS);
   gtk_scale_set_digits (scale, 1);
   gtk_scale_set_value_pos (scale, GTK_POS_TOP);
   gtk_scale_set_draw_value (scale, TRUE);
}
/* 创建示例窗口 */
void create_range_controls( void )
{
   GtkWidget *window;
   GtkWidget *box1, *box2, *box3;
   GtkWidget *button;
   GtkWidget *scrollbar;
   GtkWidget *separator;
   GtkWidget *opt, *menu, *item;
   GtkWidget *label;
   GtkWidget *scale;
   GtkObject *adj1, *adj2;
/* 标准的创建窗口代码 */
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
   gtk_window_set_title (GTK_WINDOW (window), "RT's range controls");
   box1 = gtk_vbox_new (FALSE, 0);
   gtk_container_add (GTK_CONTAINER (window), box1);
   gtk_widget_show (box1);
   box2 = gtk_hbox_new (FALSE, 10);
   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
   gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
   gtk_widget_show (box2);
/* value, lower, upper, step_increment, page_increment, page_size */
/* 注意,page_size 值只对滚动条构件有区别,并且,你实际上能取得的最高值
* 是(upper - page_size)。 */
   adj1 = gtk_adjustment_new (0.0, 0.0, 101.0, 0.1, 1.0, 1.0);
   vscale = gtk_vscale_new (GTK_ADJUSTMENT (adj1));
   scale_set_default_values (GTK_SCALE (vscale));
   gtk_box_pack_start (GTK_BOX (box2), vscale, TRUE, TRUE, 0);
   gtk_widget_show (vscale);
   box3 = gtk_vbox_new (FALSE, 10);
   gtk_box_pack_start (GTK_BOX (box2), box3, TRUE, TRUE, 0);
   gtk_widget_show (box3);
/* 重新使用同一个调整对象 */
   hscale = gtk_hscale_new (GTK_ADJUSTMENT (adj1));
   gtk_widget_set_size_request (GTK_WIDGET (hscale), 200, -1);
   scale_set_default_values (GTK_SCALE (hscale));
   gtk_box_pack_start (GTK_BOX (box3), hscale, TRUE, TRUE, 0);
   gtk_widget_show (hscale);
/* 再次重用同一个调整对象 */
   scrollbar = gtk_hscrollbar_new (GTK_ADJUSTMENT (adj1));
/* 注意,这导致当滚动条移动时,比例构件总是连续更新 */
   gtk_range_set_update_policy (GTK_RANGE (scrollbar),
   GTK_UPDATE_CONTINUOUS);
   gtk_box_pack_start (GTK_BOX (box3), scrollbar, TRUE, TRUE, 0);
   gtk_widget_show (scrollbar);
   box2 = gtk_hbox_new (FALSE, 10);
   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
   gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
   gtk_widget_show (box2);
/* 用一个复选按钮控制是否显示比例构件的值 */
   button = gtk_check_button_new_with_label("Display value on scale widgets");
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
   g_signal_connect (G_OBJECT (button), "toggled",
                     G_CALLBACK (cb_draw_value), NULL);
   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
   gtk_widget_show (button);
   box2 = gtk_hbox_new (FALSE, 10);
   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* 用一个选项菜单以改变显示值的位置 */
   label = gtk_label_new ("Scale Value Position:");
   gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
   gtk_widget_show (label);
   opt = gtk_option_menu_new ();
   menu = gtk_menu_new ();
   item = make_menu_item ("Top", G_CALLBACK (cb_pos_menu_select),
                          GINT_TO_POINTER (GTK_POS_TOP));
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
   item = make_menu_item ("Bottom", G_CALLBACK (cb_pos_menu_select),
                          GINT_TO_POINTER (GTK_POS_BOTTOM));
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
   item = make_menu_item ("Left", G_CALLBACK (cb_pos_menu_select),
                           GINT_TO_POINTER (GTK_POS_LEFT));
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
   item = make_menu_item ("Right", G_CALLBACK (cb_pos_menu_select),
                           GINT_TO_POINTER (GTK_POS_RIGHT));
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
   gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
   gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
   gtk_widget_show (opt);
   gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
   gtk_widget_show (box2);
   box2 = gtk_hbox_new (FALSE, 10);
   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* 另一个选项菜单,这里是用于设置比例构件的更新方式 */
   label = gtk_label_new ("Scale Update Policy:");
   gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
   gtk_widget_show (label);
   opt = gtk_option_menu_new ();
   menu = gtk_menu_new ();
   item = make_menu_item ("Continuous", G_CALLBACK (cb_update_menu_select),
                           GINT_TO_POINTER (GTK_UPDATE_CONTINUOUS));
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
   item = make_menu_item ("Discontinuous", G_CALLBACK (cb_update_menu_select),
                          GINT_TO_POINTER (GTK_UPDATE_DISCONTINUOUS));
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
   item = make_menu_item ("Delayed", G_CALLBACK (cb_update_menu_select),
                          GINT_TO_POINTER (GTK_UPDATE_DELAYED));
   gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
   gtk_option_menu_set_menu (GTK_OPTION_MENU (opt), menu);
   gtk_box_pack_start (GTK_BOX (box2), opt, TRUE, TRUE, 0);
   gtk_widget_show (opt);
   gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
   gtk_widget_show (box2);
   box2 = gtk_hbox_new (FALSE, 10);
   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* 一个水平比例构件,用于调整示例比例构件的显示小数位数。 */
   label = gtk_label_new ("Scale Digits:");
   gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
   gtk_widget_show (label);
   adj2 = gtk_adjustment_new (1.0, 0.0, 5.0, 1.0, 1.0, 0.0);
   g_signal_connect (G_OBJECT (adj2), "value_changed", 
                     G_CALLBACK (cb_digits_scale), NULL);
   scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
   gtk_scale_set_digits (GTK_SCALE (scale), 0);
   gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
   gtk_widget_show (scale);
   gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
   gtk_widget_show (box2);
   box2 = gtk_hbox_new (FALSE, 10);
   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
/* 以及,最后一个水平比例构件用于调整滚动条的 page size。 */
   label = gtk_label_new ("Scrollbar Page Size:");
   gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
   gtk_widget_show (label);
   adj2 = gtk_adjustment_new (1.0, 1.0, 101.0, 1.0, 1.0, 0.0);
   g_signal_connect (G_OBJECT (adj2), "value_changed",
                     G_CALLBACK (cb_page_size), adj1);
   scale = gtk_hscale_new (GTK_ADJUSTMENT (adj2));
   gtk_scale_set_digits (GTK_SCALE (scale), 0);
   gtk_box_pack_start (GTK_BOX (box2), scale, TRUE, TRUE, 0);
   gtk_widget_show (scale);
   gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
   gtk_widget_show (box2);
   separator = gtk_hseparator_new ();
   gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
   gtk_widget_show (separator);
   box2 = gtk_vbox_new (FALSE, 10);
   gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
   gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
   gtk_widget_show (box2);
   button = gtk_button_new_with_label ("Quit");
   g_signal_connect_swapped (G_OBJECT (button), "clicked",
                             G_CALLBACK (gtk_main_quit), NULL);
   gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
                        GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
   gtk_widget_grab_default (button);
   gtk_widget_show (button);
   gtk_widget_show (window);
}
int main( int argc, char *argv[] )
{
   gtk_init (&argc, &argv);
   create_range_controls ();
   gtk_main ();
   return 0;
}

11.箭头按钮create_arrow_button

#include <gtk/gtk.h>
/* 用指定的参数创建一个箭头构件并将它组装到按钮中 */
GtkWidget *create_arrow_button( GtkArrowType arrow_type, GtkShadowType shadow_type )
{
   GtkWidget *button;
   GtkWidget *arrow;
   button = gtk_button_new ();
   arrow = gtk_arrow_new (arrow_type, shadow_type);
   gtk_container_add (GTK_CONTAINER (button), arrow);
   gtk_widget_show (button);
   gtk_widget_show (arrow);
   return button;
}
int main( int argc, char *argv[] )
{
/* GtkWidget 是构件的存储类型 */
   GtkWidget *window;
   GtkWidget *button;
   GtkWidget *box;
/* 初始化 */
   gtk_init (&argc, &argv);
/* 创建一个新窗口 */
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title (GTK_WINDOW (window), "Arrow Buttons");
/* 对所有的窗口都这样做是一个好主意 */
   g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
/* 设置窗口的边框的宽度 */
   gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* 建一个组装盒以容纳箭头/按钮 */
   box = gtk_hbox_new (FALSE, 0);
   gtk_container_set_border_width (GTK_CONTAINER (box), 2);
   gtk_container_add (GTK_CONTAINER (window), box);
/* 组装、显示所有的构件 */
   gtk_widget_show (box);
   button = create_arrow_button (GTK_ARROW_UP, GTK_SHADOW_IN);
   gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 3);
   button = create_arrow_button (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
   gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 3);
   button = create_arrow_button (GTK_ARROW_LEFT, GTK_SHADOW_ETCHED_IN);
   gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 3);
   button = create_arrow_button (GTK_ARROW_RIGHT, GTK_SHADOW_ETCHED_OUT);
   gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 3);
   gtk_widget_show (window);
/* 进入主循环,等待用户的动作 */
   gtk_main ();
   return 0;
}

12.标签label

#include <gtk/gtk.h>
int main( int argc, char *argv[] )
{
   static GtkWidget *window = NULL;
   GtkWidget *hbox;
   GtkWidget *vbox;
   GtkWidget *frame;
   GtkWidget *label;
/* 初始化 */
   gtk_init (&argc, &argv);

   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
   gtk_window_set_title (GTK_WINDOW (window), "Label");

   vbox = gtk_vbox_new (FALSE, 5);
   hbox = gtk_hbox_new (FALSE, 5);

   gtk_container_add (GTK_CONTAINER (window), hbox);
   gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);

   gtk_container_set_border_width (GTK_CONTAINER (window), 5);

   frame = gtk_frame_new ("Normal Label");
   label = gtk_label_new ("This is a Normal label");
   gtk_container_add (GTK_CONTAINER (frame), label);
   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);

   frame = gtk_frame_new ("Multi-line Label");
   label = gtk_label_new ("This is a Multi-line label.\nSecond line\n" \
                          "Third line");
   gtk_container_add (GTK_CONTAINER (frame), label);
   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);

   frame = gtk_frame_new ("Left Justified Label");
   label = gtk_label_new ("This is a Left-Justified\n" \
                          "Multi-line label.\nThird line");
   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
   gtk_container_add (GTK_CONTAINER (frame), label);
   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);

   frame = gtk_frame_new ("Right Justified Label");
   label = gtk_label_new ("This is a Right-Justified\nMulti-line label.\n" \
                          "Fourth line, (j/k)");
   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
   gtk_container_add (GTK_CONTAINER (frame), label);
   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);

   vbox = gtk_vbox_new (FALSE, 5);
   gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
   frame = gtk_frame_new ("Line wrapped label");
   label = gtk_label_new ("This is an example of a line-wrapped label. It " \
                           /* 用一段较长的空白字符来测试空白的自动排列 */
                          "should not be taking up the entire" \
                          "width allocated to it, but automatically " \
                          "wraps the words to fit. " \
                          "The time has come, for all good men, to come to " \
                          "the aid of their party. " \
                          "The sixth sheik's six sheep's sick.\n" \
                          "It supports multiple paragraphs correctly, " \
                          "and correctly adds "\
                          "many extra spaces. ");
   gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
   gtk_container_add (GTK_CONTAINER (frame), label);
   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);

   frame = gtk_frame_new ("Filled, wrapped label");
   label = gtk_label_new ("This is an example of a line-wrapped, filled label. " \
                          "It should be taking "\
                          "up the entire width allocated to it. " \
                          "Here is a sentence to prove "\
                          "my point. Here is another sentence. "\
                          "Here comes the sun, do de do de do.\n"\
                          " This is a new paragraph.\n"\
                          " This is another newer, longer, better " \
                          "paragraph. It is coming to an end, "\
                          "unfortunately.");
   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
   gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
   gtk_container_add (GTK_CONTAINER (frame), label);
   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);

   frame = gtk_frame_new ("Underlined label");
   label = gtk_label_new ("This label is underlined!\n"
                          "This one is underlined in quite a funky fashion");
   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
   gtk_label_set_pattern (GTK_LABEL (label),
                          "_________________________ _ _________ _ ________ _______ ___");
   gtk_container_add (GTK_CONTAINER (frame), label);
   gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);

   gtk_widget_show_all (window);

   gtk_main ();
   return 0;
}

12.子窗口:触发事件打开窗口

#include <gtk/gtk.h>

gint delete_event( GtkWidget *widget, GdkEvent  *event, gpointer   data )
{
    g_print ("delete event occurred\n");
    /* 改 TRUE 为 FALSE 程序会关闭。*/
    return FALSE;
}

/* 另一个回调函数 */
void destroy( GtkWidget *widget, gpointer   data )
{
    gtk_main_quit ();
}
void hello( GtkWidget *widget, gpointer   data )
{
    g_print ("Hello World\n");
}
void New_window( GtkWidget *widget, gpointer   data )
{
    GtkWidget *window;
    GtkWidget *button;

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), NULL);
    g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL);
    gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
    button = gtk_button_new_with_label ("Hello world !");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (hello), "1");
    gtk_container_add (GTK_CONTAINER (window), button);

    gtk_widget_show (button);
    gtk_widget_show (window);

    g_print ("Hello World\n");//temp(data );
}
int main( int   argc, char *argv[] )
{
    GtkWidget *window;
    GtkWidget *button;
    
    gtk_init (&argc, &argv);
    
    /* 创建一个新窗口 */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), NULL);
    g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL);
    gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
    button = gtk_button_new_with_label ("Open hello world");
    g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (New_window), "1");
    gtk_container_add (GTK_CONTAINER (window), button);

    gtk_widget_show (button);
    gtk_widget_show (window);

    gtk_main ();
    
    return 0;
}

13.进度条progressbar

#include <gtk/gtk.h>

typedef struct _ProgressData {
   GtkWidget *window;
   GtkWidget *pbar;
   int timer;
   gboolean activity_mode;
} ProgressData;

/* 更新进度条,这样就能够看到进度条的移动 */
gint progress_timeout( gpointer data )
{
   ProgressData *pdata = (ProgressData *)data;
   gdouble new_val;
   if (pdata->activity_mode)
   {
       gtk_progress_bar_pulse (GTK_PROGRESS_BAR (pdata->pbar));
   } else {
/* 使用在调整对象中设置的取值范围计算进度条的值 */
       new_val = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (pdata->pbar)) + 0.01;
       if (new_val > 1.0)
          new_val = 0.0;
/* 设置进度条的新值 */
       gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pdata->pbar), new_val);
   }
/* 这是一个 timeout 函数,返回 TRUE,这样它就能够继续被调用 */
   return TRUE;
}
/* 回调函数,切换在进度条你的滑槽上的文本显示 */
void toggle_show_text( GtkWidget *widget, ProgressData *pdata )
{
   const gchar *text;
   text = gtk_progress_bar_get_text (GTK_PROGRESS_BAR (pdata->pbar));
   if (text && *text)
      gtk_progress_bar_set_text (GTK_PROGRESS_BAR (pdata->pbar), "");
   else
      gtk_progress_bar_set_text (GTK_PROGRESS_BAR (pdata->pbar), "some text");
}
/* 回调函数,切换进度条的活动模式 */
void toggle_activity_mode( GtkWidget *widget, ProgressData *pdata )
{
   pdata->activity_mode = !pdata->activity_mode;
   if (pdata->activity_mode)
       gtk_progress_bar_pulse (GTK_PROGRESS_BAR (pdata->pbar));
   else
       gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (pdata->pbar), 0.0);
}
/* 回调函数,切换进度条的移动方向 */
void toggle_orientation( GtkWidget *widget, ProgressData *pdata )
{
 switch (gtk_progress_bar_get_orientation (GTK_PROGRESS_BAR (pdata->pbar))) {
   case GTK_PROGRESS_LEFT_TO_RIGHT:
      gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
                                     GTK_PROGRESS_RIGHT_TO_LEFT);
      break;
   case GTK_PROGRESS_RIGHT_TO_LEFT:
      gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (pdata->pbar),
                                     GTK_PROGRESS_LEFT_TO_RIGHT);
      break;
   default:; // 什么也不做
 }
}
/* 清除分配的内存,删除定时器(timer) */
void destroy_progress( GtkWidget *widget, ProgressData *pdata)
{
   gtk_timeout_remove (pdata->timer);
   pdata->timer = 0;
   pdata->window = NULL;
   g_free (pdata);
   gtk_main_quit ();
}
int main( int argc, char *argv[])
{
   ProgressData *pdata;
   GtkWidget *align;
   GtkWidget *separator;
   GtkWidget *table;
   GtkWidget *button;
   GtkWidget *check;
   GtkWidget *vbox;

   gtk_init (&argc, &argv);
/* 为传递到回调函数中的数据分配内存 */
   pdata = g_malloc (sizeof (ProgressData));
   pdata->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_resizable (GTK_WINDOW (pdata->window), TRUE);
   g_signal_connect (G_OBJECT (pdata->window), "destroy",
                     G_CALLBACK (destroy_progress), pdata);
   gtk_window_set_title (GTK_WINDOW (pdata->window), "GtkProgressBar");
   gtk_container_set_border_width (GTK_CONTAINER (pdata->window), 10);

   vbox = gtk_vbox_new (FALSE, 5);
   gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
   gtk_container_add (GTK_CONTAINER (pdata->window), vbox);
   gtk_widget_show (vbox);
/* 创建一个居中对齐的对象 */
   align = gtk_alignment_new (0.5, 0.5, 0, 0);
   gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 5);
   gtk_widget_show (align);
/* 创建进度条 */
   pdata->pbar = gtk_progress_bar_new ();
   gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
   gtk_widget_show (pdata->pbar);

/* 加一个定时器(timer),以更新进度条的值 */
   pdata->timer = gtk_timeout_add (200, progress_timeout, pdata);

   separator = gtk_hseparator_new ();
   gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);
   gtk_widget_show (separator);
/* 行数、列数、同质性(homogeneous) */
   table = gtk_table_new (3, 2, FALSE);
   gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, TRUE, 0);
   gtk_widget_show (table);
/* 添加一个复选按钮,以选择是否显示在滑槽里的文本 */
   check = gtk_check_button_new_with_label ("Show text");
   gtk_table_attach (GTK_TABLE (table), check, 0, 1, 0, 1,
                     GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5);
   g_signal_connect (G_OBJECT (check), "clicked", G_CALLBACK (toggle_show_text), pdata);
   gtk_widget_show (check);
/* 添加一个复选按钮,切换活动状态 */
   check = gtk_check_button_new_with_label ("Activity mode");
   gtk_table_attach (GTK_TABLE (table), check, 0, 1, 1, 2,
                     GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5);
   g_signal_connect (G_OBJECT (check), "clicked", G_CALLBACK (toggle_activity_mode), pdata);
   gtk_widget_show (check);
/* 添加一个复选按钮,切换移动方向 */
   check = gtk_check_button_new_with_label ("Right to Left");
   gtk_table_attach (GTK_TABLE (table), check, 0, 1, 2, 3, 
                     GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 5);
   g_signal_connect (G_OBJECT (check), "clicked",
                     G_CALLBACK (toggle_orientation), pdata);
   gtk_widget_show (check);
/* 添加一个按钮,用来退出应用程序 */
   button = gtk_button_new_with_label ("close");
   g_signal_connect_swapped (G_OBJECT (button), "clicked",
                             G_CALLBACK (gtk_widget_destroy), pdata->window);
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
/* 将按钮设置为能缺省的构件 */
    GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
/* 将缺省焦点设置到这个按钮上,使之成为缺省按钮,只要按回车键
* 就相当于点击了这个按钮 */
//译者注: 能缺省的构件在获取焦点后成为缺省构件,用户按方向键等可以切换焦点。
   gtk_widget_grab_default (button);
   gtk_widget_show (button);
   gtk_widget_show (pdata->window);
   gtk_main ();
   return 0;
}

14.窗口标尺gtk_hruler_new

#include <gtk/gtk.h>
#define EVENT_METHOD(i, x) GTK_WIDGET_GET_CLASS(i)->x
#define XSIZE 600
#define YSIZE 400
/* 当点击"close"按钮时,退出应用程序 */
gint close_application( GtkWidget *widget, GdkEvent *event, gpointer data )
{
   gtk_main_quit ();
   return FALSE;
}
/* 主函数 */
int main( int argc, char *argv[] ) 
{
   GtkWidget *window, *table, *area, *hrule, *vrule;
/* 初始化,创建主窗口 */
   gtk_init (&argc, &argv);
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (close_application), NULL);
   gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* 创建一个组装表,绘图区和标尺放在里面 */
   table = gtk_table_new (3, 2, FALSE);
   gtk_container_add (GTK_CONTAINER (window), table);
   area = gtk_drawing_area_new ();
   gtk_widget_set_size_request (GTK_WIDGET (area), XSIZE, YSIZE);
   gtk_table_attach (GTK_TABLE (table), area, 1, 2, 1, 2,
                     GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
   gtk_widget_set_events (area, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
/* 水平标尺放在顶部。鼠标移动穿过绘图区时,一个
* motion_notify_event 被传递给标尺的相应的事件处理函数 */
   hrule = gtk_hruler_new ();
   gtk_ruler_set_metric (GTK_RULER (hrule), GTK_PIXELS);
   gtk_ruler_set_range (GTK_RULER (hrule), 0, 50, 0, 20);
   g_signal_connect_swapped (G_OBJECT (area), "motion_notify_event",
                          G_CALLBACK (EVENT_METHOD (hrule, motion_notify_event)), hrule);
   gtk_table_attach (GTK_TABLE (table), hrule, 1, 2, 0, 1,
                     GTK_EXPAND|GTK_SHRINK|GTK_FILL, GTK_FILL, 0, 0);
/* 垂直标尺放在左边。当鼠标移动穿过绘图区时,一个
* motion_notify_event 被传递到标尺相应的事件处理函数中 */
   vrule = gtk_vruler_new ();
   gtk_ruler_set_metric (GTK_RULER (vrule), GTK_PIXELS);
   gtk_ruler_set_range (GTK_RULER (vrule), 0, YSIZE, 10, YSIZE );
   g_signal_connect_swapped (G_OBJECT (area), "motion_notify_event",
                     G_CALLBACK (EVENT_METHOD (vrule, motion_notify_event)), vrule);
   gtk_table_attach (GTK_TABLE (table), vrule, 0, 1, 1, 2,
                     GTK_FILL, GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0);
/* 现在显示所有的构件 */
   gtk_widget_show (area);
   gtk_widget_show (hrule);
   gtk_widget_show (vrule);
   gtk_widget_show (table);
   gtk_widget_show (window);
   gtk_main ();
   return 0;
}

15.状态栏(条)gtk_statusbar_new

#include <stdlib.h>
#include <gtk/gtk.h>
#include <glib.h>
GtkWidget *status_bar;
void push_item( GtkWidget *widget, gpointer data )
{
   static int count = 1;
   char buff[20];
   g_snprintf (buff, 20, "Item %d", count++);
   gtk_statusbar_push (GTK_STATUSBAR (status_bar), GPOINTER_TO_INT (data), buff);
   return;
}
void pop_item( GtkWidget *widget, gpointer data )
{
   gtk_statusbar_pop (GTK_STATUSBAR (status_bar), GPOINTER_TO_INT (data));
   return;
}
int main( int argc, char *argv[] )
{
   GtkWidget *window;
   GtkWidget *vbox;
   GtkWidget *button;
   gint context_id;

   gtk_init (&argc, &argv);
/* 创建新窗口 */
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_widget_set_size_request (GTK_WIDGET (window), 200, 100);
   gtk_window_set_title (GTK_WINDOW (window), "GTK Statusbar Example");
   g_signal_connect (G_OBJECT (window), "delete_event",
                     G_CALLBACK (exit), NULL);

   vbox = gtk_vbox_new (FALSE, 1);
   gtk_container_add (GTK_CONTAINER (window), vbox);
   gtk_widget_show (vbox);

   status_bar = gtk_statusbar_new ();
   gtk_box_pack_start (GTK_BOX (vbox), status_bar, TRUE, TRUE, 0);
   gtk_widget_show (status_bar);

   context_id = gtk_statusbar_get_context_id( GTK_STATUSBAR (status_bar), "Statusbar example");

   button = gtk_button_new_with_label ("push item");
   g_signal_connect (G_OBJECT (button), "clicked",
                     G_CALLBACK (push_item), GINT_TO_POINTER (context_id));
   gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 2);
   gtk_widget_show (button);

   button = gtk_button_new_with_label ("pop last item");
   g_signal_connect (G_OBJECT (button), "clicked",
                     G_CALLBACK (pop_item), GINT_TO_POINTER (context_id));
   gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 2);
   gtk_widget_show (button);

/* 将窗口最后显示,让整个窗口一次性出现在屏幕上. */
   gtk_widget_show (window);
   gtk_main ();
   return 0;
}

另一个例子

/* 状态栏 status.c */
#include <gtk/gtk.h>
static GtkWidget *statusbar;
gint i = 0 ;
void on_push_clicked (GtkButton* button,gpointer data)
{
   char message[1024];
   i++ ;
   sprintf(message,"这是输入的第 %d 条消息.",i);
   gtk_statusbar_push(GTK_STATUSBAR(statusbar),i,message);
}
void on_pop_clicked (GtkButton* button,gpointer data)
{
   if (i<0) return ;
   gtk_statusbar_pop(GTK_STATUSBAR(statusbar),i);
   i--;
}
void on_popped (GtkStatusbar* statusbar,guint id,const gchar*
text)
{
   if(!statusbar->messages)
   i = 0;
}
int main ( int argc , char* argv[])
{
   GtkWidget *window;
   GtkWidget *vbox,*hbox;
   GtkWidget *button;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   g_signal_connect(G_OBJECT(window),"delete_event",
      G_CALLBACK(gtk_main_quit),NULL);
   gtk_window_set_title(GTK_WINDOW(window),"状态栏");
  // gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
   gtk_container_set_border_width(GTK_CONTAINER(window),20);

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

   statusbar = gtk_statusbar_new();
   g_signal_connect(G_OBJECT(statusbar),"text-popped",
      G_CALLBACK(on_popped),NULL);

   gtk_box_pack_start(GTK_BOX(vbox),statusbar,FALSE,FALSE,5);

   hbox = gtk_hbox_new(FALSE,0);
   gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,5);

   button = gtk_button_new_with_label("推入");
   g_signal_connect(G_OBJECT(button),"clicked",
      G_CALLBACK(on_push_clicked),NULL);

   gtk_box_pack_start(GTK_BOX(hbox),button,TRUE,TRUE,5);
   button = gtk_button_new_with_label("弹出");
   g_signal_connect(G_OBJECT(button),"clicked",
      G_CALLBACK(on_pop_clicked),NULL);

   gtk_box_pack_start(GTK_BOX(hbox),button,TRUE,TRUE,5);
   gtk_widget_show_all(window);
   gtk_main();
   return FALSE;
}

16.文本输入gtk_entry_new:可见/不可见,可输入/不可输入

#include <stdio.h>
#include <stdlib.h>
#include <gtk/gtk.h>
void enter_callback( GtkWidget *widget, GtkWidget *entry )
{
   const gchar *entry_text;
   entry_text = gtk_entry_get_text (GTK_ENTRY (entry));
   printf("Entry contents: %s\n", entry_text);
}
void entry_toggle_editable( GtkWidget *checkbutton, GtkWidget *entry )
{
   gtk_editable_set_editable (GTK_EDITABLE (entry),
                              GTK_TOGGLE_BUTTON (checkbutton)->active);
}
void entry_toggle_visibility( GtkWidget *checkbutton, GtkWidget *entry )
{
   gtk_entry_set_visibility (GTK_ENTRY (entry),
                             GTK_TOGGLE_BUTTON (checkbutton)->active);
}
int main( int argc, char *argv[] )
{
   GtkWidget *window;
   GtkWidget *vbox, *hbox;
   GtkWidget *entry;
   GtkWidget *button;
   GtkWidget *check;
   gint tmp_pos;

   gtk_init (&argc, &argv);
/* 创建一个新窗口 */
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_widget_set_size_request (GTK_WIDGET (window), 200, 100);
   gtk_window_set_title (GTK_WINDOW (window), "GTK Entry");
   //g_signal_connect (G_OBJECT (window), "destroy",
   //                  G_CALLBACK (gtk_main_quit), NULL);
   g_signal_connect (G_OBJECT (window), "delete_event",
                     G_CALLBACK (exit), NULL);
   g_signal_connect_swapped (G_OBJECT (window), "delete_event",
                             G_CALLBACK (gtk_widget_destroy), window);

   vbox = gtk_vbox_new (FALSE, 0);
   gtk_container_add (GTK_CONTAINER (window), vbox);
   gtk_widget_show (vbox);

   entry = gtk_entry_new ();
   gtk_entry_set_max_length (GTK_ENTRY (entry), 50);
   g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (enter_callback), entry);

   gtk_entry_set_text (GTK_ENTRY (entry), "hello");

   tmp_pos = GTK_ENTRY (entry)->text_length;
   gtk_editable_insert_text (GTK_EDITABLE (entry), " world", -1, &tmp_pos);
   gtk_editable_select_region (GTK_EDITABLE (entry), 0, GTK_ENTRY (entry)->text_length);
   gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
   gtk_widget_show (entry);

   hbox = gtk_hbox_new (FALSE, 0);
   gtk_container_add (GTK_CONTAINER (vbox), hbox);
   gtk_widget_show (hbox);

   check = gtk_check_button_new_with_label ("Editable");
   gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
   g_signal_connect (G_OBJECT (check), "toggled",
                     G_CALLBACK (entry_toggle_editable), entry);
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
   gtk_widget_show (check);

   check = gtk_check_button_new_with_label ("Visible");
   gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
   g_signal_connect (G_OBJECT (check), "toggled",
                     G_CALLBACK (entry_toggle_visibility), entry);
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
   gtk_widget_show (check);

   button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
   g_signal_connect_swapped (G_OBJECT (button), "clicked",
                             G_CALLBACK (gtk_widget_destroy), window);
   gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
                       GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
   gtk_widget_grab_default (button);
   gtk_widget_show (button);

   gtk_widget_show (window);
   gtk_main();
   return 0;
}

规定最大长度的gtk_entry_new_with_max_length

#include<gtk/gtk.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
GtkWidget *_nx, *_nz, *_dx, *_dz, *_npd, *_mm;
GtkWidget *_vel, *_epsilu, *_deta, *_shot, *_snap;
GtkWidget *_favg, *_fs, *_ds, *_ns, *_zs;

gint nx, nz, npd, mm, fs, ds, ns, zs;
gfloat dx, dz, favg;

void debug(GtkWidget *window,gpointer data)
{  
    gtk_main_quit();
}
 
void write_txt(GtkWidget *widget,gpointer data)
{

    const char*str_nx=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_nx));
    const char*str_nz=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_nz));
    const char*str_dx=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_dx));
    const char*str_dz=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_dz));
    const char*str_npd=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_npd));
    const char*str_mm=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_mm));
    const char*str_vel=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_vel));
    const char*str_epsilu=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_epsilu));
    const char*str_deta=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_deta));
    const char*str_favg=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_favg));
    const char*str_fs=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_fs));
    const char*str_ns=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_ns));
    const char*str_ds=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_ds));
    const char*str_zs=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_zs));
    const char*str_shot=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_shot));
    const char*str_snap=gtk_entry_get_text(GTK_ENTRY((GtkWidget *)_snap));


    nx=strtod(str_nx,NULL);
    nz=strtod(str_nz,NULL);
    dx=strtod(str_dx,NULL);
    dz=strtod(str_dz,NULL);
    npd=strtod(str_npd,NULL);
    mm=strtod(str_mm,NULL);
    favg=strtod(str_favg,NULL);
    fs=strtod(str_fs,NULL);
    ns=strtod(str_ns,NULL);
    ds=strtod(str_ds,NULL);
    zs=strtod(str_zs,NULL);
}
int main(int argc,char* argv[]){
 
    GtkWidget *window;
    GtkWidget *button;

    GtkWidget *label;
    GtkWidget *table;
   
    gtk_init(&argc,&argv);
       
    window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window),"RT's VTI model");
    gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
    //gtk_window_set_default_size(GTK_WINDOW(window),400,400);
    g_signal_connect(GTK_OBJECT(window),"delete_event",GTK_SIGNAL_FUNC(debug),NULL);
     
    table=gtk_table_new(13,6,FALSE);
    gtk_container_add(GTK_CONTAINER(window),table);
    label=gtk_label_new("Model parameter:");
    gtk_table_attach_defaults(GTK_TABLE(table),label,1,2,0,1);

/***   nx  ***/
    label=gtk_label_new("nx=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,1,2);
    _nx=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_nx), "100");
    gtk_table_attach_defaults(GTK_TABLE(table),_nx,1,2,1,2);
/***   dx  ***/
    label=gtk_label_new("dx=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,2,3,1,2);
    _dx=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_dx), "5");
    gtk_table_attach_defaults(GTK_TABLE(table),_dx,3,4,1,2);
/***   npd  ***/
    label=gtk_label_new("npd=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,4,5,1,2);
    _npd=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_npd), "20");
    gtk_table_attach_defaults(GTK_TABLE(table),_npd,5,6,1,2);
/***   nz  ***/
    label=gtk_label_new("nz=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,2,3);
    _nz=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_nz), "100");
    gtk_table_attach_defaults(GTK_TABLE(table),_nz,1,2,2,3);
/***   dz  ***/
    label=gtk_label_new("dz=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,2,3,2,3);
    _dz=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_dz), "5");
    gtk_table_attach_defaults(GTK_TABLE(table),_dz,3,4,2,3);
/***   mm  ***/
    label=gtk_label_new("mm=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,4,5,2,3);
    _mm=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_mm), "4");
    gtk_table_attach_defaults(GTK_TABLE(table),_mm,5,6,2,3);

    label=gtk_label_new("Input Filename:");
    gtk_table_attach_defaults(GTK_TABLE(table),label,1,2,3,4);
/***   vel  ***/
    label=gtk_label_new("vel:");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,4,5);
    _vel=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_vel), "vel.dat");
    gtk_table_attach_defaults(GTK_TABLE(table),_vel,1,4,4,5);
/***   epsilu  ***/
    label=gtk_label_new("epsilu:");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,5,6);
    _epsilu=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_epsilu), "epsilu.dat");
    gtk_table_attach_defaults(GTK_TABLE(table),_epsilu,1,4,5,6);
/***   deta  ***/
    label=gtk_label_new("deta:");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,6,7);
    _deta=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_deta), "deta.dat");
    gtk_table_attach_defaults(GTK_TABLE(table),_deta,1,4,6,7);

    label=gtk_label_new("ShotParas:");
    gtk_table_attach_defaults(GTK_TABLE(table),label,1,2,7,8);
/***   ns  ***/
    label=gtk_label_new("ns=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,8,9);
    _ns=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_ns), "1");
    gtk_table_attach_defaults(GTK_TABLE(table),_ns,1,2,8,9);
/***   favg  ***/
    label=gtk_label_new("favg=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,2,3,8,9);
    _favg=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_favg), "20");
    gtk_table_attach_defaults(GTK_TABLE(table),_favg,3,4,8,9);
/***   fs  ***/
    label=gtk_label_new("fs=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,9,10);
    _fs=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_fs), "1");
    gtk_table_attach_defaults(GTK_TABLE(table),_fs,1,2,9,10);
/***   ds  ***/
    label=gtk_label_new("ds=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,2,3,9,10);
    _ds=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_ds), "0");
    gtk_table_attach_defaults(GTK_TABLE(table),_ds,3,4,9,10);
/***   zs  ***/
    label=gtk_label_new("zs=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,4,5,9,10);
    _zs=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_zs), "1");
    gtk_table_attach_defaults(GTK_TABLE(table),_zs,5,6,9,10);


    label=gtk_label_new("Output Filename:");
    gtk_table_attach_defaults(GTK_TABLE(table),label,1,2,10,11);
/***   shot  ***/
    label=gtk_label_new("shot=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,11,12);
    _shot=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_shot), "shot.dat");
    gtk_table_attach_defaults(GTK_TABLE(table),_shot,1,4,11,12);
/***   snap  ***/
    label=gtk_label_new("snap=");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,12,13);
    _snap=gtk_entry_new_with_max_length(10);
    gtk_entry_set_text (GTK_ENTRY (_snap), "snap.dat");
    gtk_table_attach_defaults(GTK_TABLE(table),_snap,1,4,12,13);

    label=gtk_label_new("Please ensure all parameters input accuratlly !");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,10,13,14);
/***   run button  ***/
    button=gtk_button_new_with_label("RUN");
    g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(write_txt),NULL);
    gtk_table_attach_defaults(GTK_TABLE(table),button,5,6,12,13);
 
    gtk_widget_show_all(window);
    gtk_main();
    return 0;
}

输入文本执行一条命令

/* 命令工具 command.c */
#include <gtk/gtk.h>
static GtkWidget *entry;
void on_button_clicked (GtkButton* button,gpointer data)
{
   const gchar* command;
   command = gtk_entry_get_text(GTK_ENTRY(entry));
   system(command);
}
int main ( int argc , char* argv[])
{
   GtkWidget *window;
   GtkWidget *hbox;
   GtkWidget *label;
   GtkWidget *button;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   g_signal_connect(G_OBJECT(window),"delete_event",
         G_CALLBACK(gtk_main_quit),NULL);
   gtk_window_set_title(GTK_WINDOW(window),"命令窗口");
   //gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);

   hbox = gtk_hbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(window),hbox);

   label = gtk_label_new("输入命令:");
   gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,5);

   entry = gtk_entry_new();
   gtk_box_pack_start(GTK_BOX(hbox),entry,TRUE,TRUE,5);

   button = gtk_button_new_with_label("执行");
   g_signal_connect(G_OBJECT(button),"clicked",
         G_CALLBACK(on_button_clicked),NULL);
   gtk_box_pack_start(GTK_BOX(hbox),button,FALSE,FALSE,5);

   gtk_widget_show_all(window);
   gtk_main();
   return FALSE;
}

17.文件选择:gtk_file_selection_new

#include <gtk/gtk.h>
/* 获得文件名,并将它打印到控制台(console)上 */
void file_ok_sel( GtkWidget *w, GtkFileSelection *fs )
{
   g_print ("Filename:%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
}
int main( int argc, char *argv[] )
{
   GtkWidget *filew;
   gtk_init (&argc, &argv);
/* 创建一个新的文件选择构件 */
   filew = gtk_file_selection_new ("File selection");
   g_signal_connect (G_OBJECT (filew), "destroy", G_CALLBACK (gtk_main_quit), NULL);
/* 为 ok_button 按钮设置回调函数,连接到 file_ok_sel function 函数 */
   g_signal_connect (G_OBJECT (GTK_FILE_SELECTION (filew)->ok_button), "clicked",
                     G_CALLBACK (file_ok_sel), filew);
/* 为 cancel_button 设置回调函数,销毁构件 */
   g_signal_connect_swapped (G_OBJECT (GTK_FILE_SELECTION (filew)->cancel_button), "clicked",
                             G_CALLBACK (gtk_widget_destroy), filew);
/* 设置文件名,比如这个一个文件保存对话框,我们给了一个缺省文件名 */
   gtk_file_selection_set_filename (GTK_FILE_SELECTION(filew), "penguin.png");
   gtk_widget_show (filew);
   gtk_main ();
   return 0;
}

给另一个例子,选择一个VTI介质模型参数

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

GtkWidget *file,*_vel,*_deta,*_epsilu;


void file_OK( GtkWidget *w, gpointer *data )
{
    gtk_entry_set_text (GTK_ENTRY (data),
                   gtk_file_selection_get_filename (GTK_FILE_SELECTION (file)));
    gtk_widget_destroy (file);
}
void select_file(GtkWidget *w,gpointer *data)
{
    file= gtk_file_selection_new ("File selection");

    g_signal_connect (G_OBJECT (GTK_FILE_SELECTION (file)->ok_button), "clicked",
                     G_CALLBACK (file_OK), data);
    g_signal_connect_swapped (G_OBJECT (GTK_FILE_SELECTION (file)->cancel_button), "clicked",
                             G_CALLBACK (gtk_widget_destroy), NULL);
    gtk_widget_show (file);
}
/* 创建一个新的横向盒,它包含一个图像和一个标签,并返回这个盒。*/
GtkWidget *xpm_label_box( gchar *xpm_filename, gchar *label_text )
{
   GtkWidget *box;
   GtkWidget *label;
   GtkWidget *image;
/* 为图像和标签创建盒 */
   box = gtk_hbox_new (FALSE, 0);
   gtk_container_set_border_width (GTK_CONTAINER (box), 10);
/* 创建一个图像 */
   image = gtk_image_new_from_file (xpm_filename);
/* 为按钮创建一个标签 */
   label = gtk_label_new (label_text);
/* 把图像和标签组装到盒子里 */
   gtk_box_pack_start (GTK_BOX (box), image, TRUE, TRUE, 3);
   gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 3);
   gtk_widget_show (image);
   gtk_widget_show (label);
   return box;
}
int main( int argc, char *argv[] )
{
    GtkWidget *window;
    GtkWidget *button;

    GtkWidget *label;
    GtkWidget *table;

    GtkWidget *box;

    gtk_init (&argc, &argv);

    window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window),"RT's VTI model");
    gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
    g_signal_connect(GTK_OBJECT(window),"delete_event",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
     
    table=gtk_table_new(3,8,TRUE);
    gtk_container_add(GTK_CONTAINER(window),table);

    label=gtk_label_new("Input Filename:");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,2,0,1);

/*******************  vel *******************/
    label=gtk_label_new("vel:");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,1,2);
    _vel=gtk_entry_new_with_max_length(100);
    gtk_entry_set_text (GTK_ENTRY (_vel), "vel.dat");
    gtk_table_attach_defaults(GTK_TABLE(table),_vel,1,7,1,2);
    button=gtk_button_new();
    box = xpm_label_box ("pic/dir2.jpg", NULL);
    gtk_container_add (GTK_CONTAINER (button), box);
    g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(select_file),_vel);
    gtk_table_attach_defaults(GTK_TABLE(table),button,7,8,1,2);

/*******************  epsilu *******************/
    label=gtk_label_new("epsilu:");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,2,3);
    _epsilu=gtk_entry_new_with_max_length(100);
    gtk_entry_set_text (GTK_ENTRY (_epsilu), "epsilu.dat");
    gtk_table_attach_defaults(GTK_TABLE(table),_epsilu,1,7,2,3);
    //button=gtk_button_new_with_label("...");
    button=gtk_button_new();
    box = xpm_label_box ("pic/dir2.jpg", NULL);
    gtk_container_add (GTK_CONTAINER (button), box);
    g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(select_file),_epsilu);
    gtk_table_attach_defaults(GTK_TABLE(table),button,7,8,2,3);

/*******************  deta *******************/
    label=gtk_label_new("deta:");
    gtk_table_attach_defaults(GTK_TABLE(table),label,0,1,3,4);
    _deta=gtk_entry_new_with_max_length(100);
    gtk_entry_set_text (GTK_ENTRY (_deta), "deta.dat");
    gtk_table_attach_defaults(GTK_TABLE(table),_deta,1,7,3,4);
    //button=gtk_button_new_with_label("...");
    button=gtk_button_new();
    box = xpm_label_box ("pic/dir2.jpg", NULL);
    gtk_container_add (GTK_CONTAINER (button), box);
    g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(select_file),_deta);
    gtk_table_attach_defaults(GTK_TABLE(table),button,7,8,3,4);



    gtk_widget_show_all(window);
    gtk_main ();
    return 0;
}

18.事件盒子gtk_event_box_new

#include <stdlib.h>
#include <gtk/gtk.h>
int main( int argc, char *argv[] )
{
   GtkWidget *window;
   GtkWidget *event_box;
   GtkWidget *label;
   gtk_init (&argc, &argv);
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title (GTK_WINDOW (window), "Event Box");
   g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (exit), NULL);
   gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* 创建一个事件盒,然后将它加到顶级窗口上 */
   event_box = gtk_event_box_new ();
   gtk_container_add (GTK_CONTAINER (window), event_box);
   gtk_widget_show (event_box);
/* 创建一个长标签 */
   label = gtk_label_new ("Click here to quit, quit, quit, quit, quit");
   gtk_container_add (GTK_CONTAINER (event_box), label);
   gtk_widget_show (label);
/* 将标签剪裁短。 */
   gtk_widget_set_size_request (label, 110, 20);
/* 为它绑定一个动作 */
   gtk_widget_set_events (event_box, GDK_BUTTON_PRESS_MASK);
   g_signal_connect (G_OBJECT (event_box), "button_press_event", G_CALLBACK (exit), NULL);
/* 又是一个要有 X 窗口的东西... */
//译者注: 要设置鼠标式样也要有 X 窗口。gtk_widget_realize 使构件在没有 show 之前就形成 X 窗口。
   gtk_widget_realize (event_box);
   gdk_window_set_cursor (event_box->window, gdk_cursor_new (GDK_HAND1));
   gtk_widget_show (window);
   gtk_main ();
   return 0;
}

19.固定容器:gtk_fixed_new

#include <gtk/gtk.h>
/* 我准备偷点懒,用一些全局变量储存固定容器里构件的位置。 */
gint x = 50;
gint y = 50;
/* 这个回调函数将按钮移动到固定容器的新位置。 */
void move_button( GtkWidget *widget, GtkWidget *fixed )
{
   x = (x + 30) % 300;
   y = (y + 50) % 300;
   gtk_fixed_move (GTK_FIXED (fixed), widget, x, y);
}
int main( int argc, char *argv[] )
{
/* GtkWidget 是构件的存储类型 */
   GtkWidget *window;
   GtkWidget *fixed;
   GtkWidget *button;
   gint i;
/* 初始化 */
   gtk_init (&argc, &argv);
/* 创建一个新窗口 */
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title (GTK_WINDOW (window), "Fixed Container");
/* 为窗口的 "destroy" 事件设置一个信号处理函数 */
   g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
/* 设置窗口的边框宽度 */
   gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* 创建一个固定容器 */
   fixed = gtk_fixed_new ();
   gtk_container_add (GTK_CONTAINER (window), fixed);
   gtk_widget_show (fixed);
   for (i = 1 ; i <= 3 ; i++) {
/* 创建一个标签为"Press me"的新按钮 */
   button = gtk_button_new_with_label ("Press me");
/* 当按钮接收到 "clicked" 信号时,调用 move_button() 函数,并把这个固定
* 容器作为参数传给它 */
   g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (move_button), fixed);
/* 将按钮组装到一个固定容器的窗口中 */
   gtk_fixed_put (GTK_FIXED (fixed), button, i*10, i*10);
/* 最后一步是显示新建的构件 */
   gtk_widget_show (button);
   }
/* 显示窗口 */
   gtk_widget_show (window);
/* 进入事件循环 */
   gtk_main ();
   return 0;
}

点击按钮后,按钮位置发生变化,挺好玩的

20.一个简单的frame:gtk_frame_new(不同于java的JFrame)

#include <gtk/gtk.h>
int main( int argc, char *argv[] )
{
/* GtkWidget 是构件的存储类型 */
   GtkWidget *window;
   GtkWidget *frame;
/* 初始化 */
   gtk_init (&argc, &argv);
/* 创建一个新窗口 */
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title (GTK_WINDOW (window), "Frame Example");
/* 在这里我们将 "destroy" 事件连接到一个回调函数 */
   g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
   gtk_widget_set_size_request (window, 300, 300);
/* 设置窗口的边框宽度 */
   gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* 创建一个框架 */
   frame = gtk_frame_new (NULL);
   gtk_container_add (GTK_CONTAINER (window), frame);
/* 设置框架的标签 */
   gtk_frame_set_label (GTK_FRAME (frame), "GTK Frame Widget");
/* 将标签定位在框架的右边 */
   gtk_frame_set_label_align (GTK_FRAME (frame), 1.0, 1.0);
/* 设置框架的风格 */
   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_OUT);
   gtk_widget_show (frame);
/* 显示窗口 */
   gtk_widget_show (window);
/* 进入事件循环 */
   gtk_main ();
   return 0;
}

gtk_aspect_frame_new:更多选项的frame

#include <gtk/gtk.h>
int main( int argc, char *argv[] )
{
   GtkWidget *window;
   GtkWidget *aspect_frame;
   GtkWidget *drawing_area;

   gtk_init (&argc, &argv);

   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title (GTK_WINDOW (window), "Aspect Frame");
   g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
   gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* 创建一个比例框架,将它添加到顶级窗口中 */
   aspect_frame = gtk_aspect_frame_new ("2x1", /* label */
                                          0.5, /* center x */
                                          0.5, /* center y */
                                            2, /* xsize/ysize = 2 */
                                         FALSE /* ignore child's aspect */);
   gtk_container_add (GTK_CONTAINER (window), aspect_frame);
   gtk_widget_show (aspect_frame);
/* 添加一个子构件到比例框架中 */
   drawing_area = gtk_drawing_area_new ();
/* 要求一个 200×200 的窗口,但是比例框架会给出一个 200×100
* 的窗口,因为我们已经指定了 2×1 的比例值 */
   gtk_widget_set_size_request (drawing_area, 200, 200);
   gtk_container_add (GTK_CONTAINER (aspect_frame), drawing_area);
   gtk_widget_show (drawing_area);
   gtk_widget_show (window);
   gtk_main ();
   return 0;
}

21.滚动窗口:gtk_scrolled_window_new

#include <stdio.h>
#include <gtk/gtk.h>
/* 创建一个"信息"列表 */
GtkWidget *create_list( void )
{
   GtkWidget *scrolled_window;
   GtkWidget *tree_view;
   GtkListStore *model;
   GtkTreeIter iter;
   GtkCellRenderer *cell;
   GtkTreeViewColumn *column;

   int i;
/* 创建一个新的滚动窗口(scrolled window),只有需要时,滚动条才出现 */
   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
                                   GTK_POLICY_AUTOMATIC,  GTK_POLICY_AUTOMATIC);
   model = gtk_list_store_new (1, G_TYPE_STRING);
   tree_view = gtk_tree_view_new ();
   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), tree_view);
   gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (model));
   gtk_widget_show (tree_view);
/* 在窗口中添加一些消息 */
   for (i = 0; i < 10; i++) {
      gchar *msg = g_strdup_printf ("Message #%d", i);
      gtk_list_store_append (GTK_LIST_STORE (model), &iter);
      gtk_list_store_set (GTK_LIST_STORE (model),
                          &iter,
                          0, msg,
                          -1);
      g_free (msg);
   }
   cell = gtk_cell_renderer_text_new ();
   column = gtk_tree_view_column_new_with_attributes ("Messages", cell, "text", 0, NULL);
   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
                                GTK_TREE_VIEW_COLUMN (column));
   return scrolled_window;
}
/* 向文本构件中添加一些文本 - 这是当窗口被实例化(realized)时调用的回调函数。
* 我们也可以用 gtk_widget_realize 强行将窗口实例化,但这必须在它的层次关系
* 确定后(be part of a hierarchy)才行。 */
// 译者注: 构件的层次关系就是其 parent 被确定。将一个子构件加到一个容器中
// 时,其 parent 就是这个容器。层次关系被确定要求,其 parent 的 parent...也
// 确定了。顶级窗口可以不要 parent。只是我的经验理解。
void insert_text (GtkTextBuffer *buffer)
{
   GtkTextIter iter;
   gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
   gtk_text_buffer_insert (buffer, &iter,
                          "From: pathfinder@nasa.gov\n"
                          "To: mom@nasa.gov\n"
                          "Subject: Made it!\n"
                          "\n"
                          "We just got in this morning. The weather has been\n"
                          "great - clear but cold, and there are lots of fun sights.\n"
                          "Sojourner says hi. See you soon.\n"
                          " -Path\n", -1);
}
/* 创建一个滚动文本区域,用于显示一个"信息" */
GtkWidget *create_text( void )
{
   GtkWidget *scrolled_window;
   GtkWidget *view;
   GtkTextBuffer *buffer;
   view = gtk_text_view_new ();
   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
   gtk_container_add (GTK_CONTAINER (scrolled_window), view);
   insert_text (buffer);
   gtk_widget_show_all (scrolled_window);
   return scrolled_window;
}
int main( int argc, char *argv[] )
{
   GtkWidget *window;
   GtkWidget *vpaned;
   GtkWidget *list;
   GtkWidget *text;

   gtk_init (&argc, &argv);

   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title (GTK_WINDOW (window), "Paned Windows");
   g_signal_connect (G_OBJECT (window), "destroy",
   G_CALLBACK (gtk_main_quit), NULL);
   gtk_container_set_border_width (GTK_CONTAINER (window), 10);
   gtk_widget_set_size_request (GTK_WIDGET (window), 450, 400);
/* 在顶级窗口上添加一个垂直分栏窗口构件 */
   vpaned = gtk_hpaned_new ();
   gtk_container_add (GTK_CONTAINER (window), vpaned);
   gtk_widget_show (vpaned);
/* 在分栏窗口的两部分各添加一些构件 */
   list = create_list ();
   gtk_paned_add1 (GTK_PANED (vpaned), list);
   gtk_widget_show (list);
   text = create_text ();
   gtk_paned_add2 (GTK_PANED (vpaned), text);
   gtk_widget_show (text);
   gtk_widget_show (window);
   gtk_main ();
   return 0;
}

又一个例子:滚动窗口中放按钮

#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;
}

22.按钮盒子:button box

#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;
}

23.在aspect_frame中显示一个图片

#include <gtk/gtk.h>

#define pixmap GdkPixmap
#define pixbuf GdkPixmap

void hello( GtkWidget *widget, gpointer   data )
{
    g_print ("Hello World\n");//temp(data );
}
gint delete_event( GtkWidget *widget, GdkEvent  *event, gpointer   data )
{
    g_print ("delete event occurred\n");
    return FALSE;
}
void destroy( GtkWidget *widget, gpointer   data )
{
    gtk_main_quit ();
}

int main( int   argc, char *argv[] )
{

    GtkWidget *window;
    GtkWidget *draw;
    GtkWidget *frame;
    
    gtk_init (&argc, &argv);
    

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), NULL);
    g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL);
    gtk_container_set_border_width (GTK_CONTAINER (window), 10);
    
    frame = gtk_aspect_frame_new ("image:",0.5, 0.1,1, FALSE);
    gtk_container_add (GTK_CONTAINER (window), frame);

    draw = gtk_drawing_area_new();
    gtk_widget_set_size_request (draw, 800, 600);
    draw = gtk_image_new_from_file("batman.jpg");

   // g_signal_connect (G_OBJECT (draw), "clicked", G_CALLBACK (expose_event), NULL);
    
    gtk_container_add (GTK_CONTAINER (frame), draw);
    
    gtk_widget_show_all (window);
    gtk_main ();
    
    return 0;
}

显示动态图:直接引用GIF,用多张图片显示动图效果

/* 简单的动画 gif.c */
#include <gtk/gtk.h>
static GtkWidget *ourgif ;
static gchar *bmpfile[4] = {"l.bmp","r.bmp","u.bmp","d.bmp" };
gint i = 0 ;
void change_bmp ()
{ //依次更改图像实现动态效果
   gtk_image_set_from_file(GTK_IMAGE(ourgif),bmpfile[i]);
   i++ ;
   if ( i == 4 ) i = 0 ;
}
int main ( int argc , char* argv[])
{
   GtkWidget *window;
   GtkWidget *vbox;
   GtkWidget *hbox;
   GtkWidget *label;
   GtkWidget *image;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   g_signal_connect(G_OBJECT(window),"delete_event",
         G_CALLBACK(gtk_main_quit),NULL);
   gtk_window_set_title(GTK_WINDOW(window),"简单的动画");
   //gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
   gtk_container_set_border_width(GTK_CONTAINER(window),10);

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

   label = gtk_label_new("直接引用GIF动画");
   gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,5);
   image = gtk_image_new_from_file("a.gif");
   gtk_box_pack_start(GTK_BOX(vbox),image,FALSE,FALSE,5);

   label = gtk_label_new("四幅静态的图像");
   gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,5);

   hbox = gtk_hbox_new(FALSE,0);
   gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,5);

   image = gtk_image_new_from_file("l.bmp");
   gtk_box_pack_start(GTK_BOX(hbox),image,FALSE,FALSE,5);
   image = gtk_image_new_from_file("r.bmp");
   gtk_box_pack_start(GTK_BOX(hbox),image,FALSE,FALSE,5);
   image = gtk_image_new_from_file("u.bmp");
   gtk_box_pack_start(GTK_BOX(hbox),image,FALSE,FALSE,5);
   image = gtk_image_new_from_file("d.bmp");
   gtk_box_pack_start(GTK_BOX(hbox),image,FALSE,FALSE,5);

   label = gtk_label_new("通过时钟控制的动画");
   gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,5);

   ourgif = gtk_image_new_from_file("p1.bmp");
   gtk_box_pack_start(GTK_BOX(vbox),ourgif,FALSE,FALSE,5);

   gtk_timeout_add(150,(GtkFunction)change_bmp,NULL);


   gtk_widget_show_all(window);
   gtk_main();
   return FALSE;
}

24.画图接口:gdk_draw_arc,gdk_draw_rectangle

#include <gtk/gtk.h>

static void destroy( GtkWidget *widget, gpointer data )
{
    gtk_main_quit ();
}
static gboolean my_expose( GtkWidget      *da,
                           GdkEventExpose *event,
                           gpointer        data )
{
    GdkGC *gc1, *gc2, *gc;  /*gc1为矩形,gc2为文字*/

    GdkColor color;

    gc1 = gdk_gc_new( da->window );

    color.red = 10000;
    color.green = 20000;
    color.blue = 30000;
    gdk_gc_set_rgb_fg_color(gc1, &color );

    gc2 = gdk_gc_new( da->window );

    color.red = 1;
    color.green = 2;
    color.blue = 3;
    gdk_gc_set_rgb_fg_color( gc2, &color );

    gc = gc1;
    gdk_draw_rectangle( da->window, gc, TRUE,//fill or not
                           50, 50, 100, 100 );  /*(fx、fz、dx、dz)*/
    gc = gc2;
    gdk_draw_arc( da->window, gc, TRUE, //fill or not
                      50, 50, 100, 100, 0, 270 * 64 );  /*(fx、fz、dx、dz、0、arc)*/
 
    PangoLayout *layout = gtk_widget_create_pango_layout( da, "This is a cube \nand a circle." );

    PangoFontDescription *fontdesc = pango_font_description_from_string( "Luxi Mono 8" );

    pango_layout_set_font_description( layout, fontdesc ); 

    gdk_draw_layout( da->window, gc1, 50, 155, layout );

    pango_font_description_free( fontdesc );

    g_object_unref( layout );
 
    g_object_unref( G_OBJECT(gc1) );
    g_object_unref( G_OBJECT(gc2) );
   
    return TRUE;
}
int main( int  argc, char *argv[] )
{
    GtkWidget *window;
    GtkWidget *da; //drawing area
    gtk_init (&argc, &argv);
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect( G_OBJECT (window), "destroy",
                G_CALLBACK (destroy), NULL );
    
    da = gtk_drawing_area_new ();
    /* set a minimum size */
    gtk_widget_set_size_request( da, 200, 200 );
    gtk_container_add( GTK_CONTAINER(window), da );
    g_signal_connect( da, "expose_event", G_CALLBACK(my_expose), NULL );
    gtk_widget_show_all( window ); //simply show all widgets
    gtk_main();
    
    return 0;
}

25.文本文件编辑gtk_text_view_new

#include <gtk/gtk.h> 
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<string.h>
GtkWidget *text_view; 
GtkTextBuffer *buffer; 
GtkTextIter *Iter; 

void button_event(GtkWidget *widget,gpointer *data) 
{
    const gchar *text={"How are you!\n"};
    GtkTextIter start,end; 
    gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(buffer),&start,&end);
    gtk_text_buffer_insert(GTK_TEXT_BUFFER(buffer),&end,text,strlen(text));
}
 int main(int argc,char *argv[ ]) 
{ 
    GtkWidget *window;
    GtkWidget *button; 
    GtkWidget *box; 

    gtk_init(&argc,&argv); 
    window=gtk_window_new(GTK_WINDOW_TOPLEVEL); 
    gtk_widget_set_size_request(window,400,300); 
    g_signal_connect(GTK_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL); 

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

    text_view=gtk_text_view_new();
    gtk_widget_set_size_request(text_view,400,250); 
    gtk_box_pack_start(GTK_BOX(box),text_view,FALSE,FALSE,0); 

    buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));

    button=gtk_button_new_with_label("sure");
    gtk_box_pack_start(GTK_BOX(box),button,FALSE,FALSE,5);
 
    gtk_signal_connect(GTK_OBJECT(button),"clicked",GTK_SIGNAL_FUNC(button_event),NULL); 
    gtk_widget_show_all(window); 
    gtk_main();
} 

26.菜单/工具栏:gtk_menu_new

/* 添加菜单 menu.c */
#include <gtk/gtk.h>
void on_menu_activate (GtkMenuItem* item,gpointer data)
{
   //g_print("菜单项 %s 被激活\n",(gchar*)data);
   g_print("Menuitem %s is pressed.\n",(gchar*)data);
}
int main (int argc, char* argv[])
{
   GtkWidget* window;
   GtkWidget* box;
   GtkWidget* menubar;
   GtkWidget* menu;
   GtkWidget* editmenu;
   GtkWidget* helpmenu;
   GtkWidget* rootmenu;
   GtkWidget* menuitem;
   GtkAccelGroup* accel_group ;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_widget_set_size_request(window,400,300); 
   gtk_window_set_title(GTK_WINDOW(window),"菜单测试程序");
   g_signal_connect(G_OBJECT(window),"destroy",
      G_CALLBACK(gtk_main_quit),NULL);
   accel_group = gtk_accel_group_new();

   gtk_window_add_accel_group(GTK_WINDOW(window),accel_group);// AccelGroup

   box = gtk_vbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(window),box);
   menu = gtk_menu_new();//文件菜单
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_NEW,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_menu_activate),//(gpointer)("新建"));
      (gpointer)("New"));
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_OPEN,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_menu_activate),//(gpointer)("打开"));
      (gpointer)("Open"));
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_SAVE,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_menu_activate),//(gpointer)("保存"));
      (gpointer)("Save"));
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_SAVE_AS,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_menu_activate),//(gpointer)("另存为"));
      (gpointer)("Save As"));
   menuitem = gtk_separator_menu_item_new();
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_QUIT,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_menu_activate),//(gpointer)("退出"));
      (gpointer)("Exit"));
   rootmenu = gtk_menu_item_new_with_label(" 文件 ");
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu),menu);
   menubar = gtk_menu_bar_new();
   gtk_menu_shell_append(GTK_MENU_SHELL(menubar),rootmenu);
   rootmenu = gtk_menu_item_new_with_label(" 编辑 ");
   editmenu = gtk_menu_new();//编辑菜单
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_CUT,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(editmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_menu_activate),//(gpointer)("剪切"));
      (gpointer)("Cut"));
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_COPY,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(editmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_menu_activate),//(gpointer)("复制"));
      (gpointer)("Copy"));
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_PASTE,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(editmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_menu_activate),//(gpointer)("粘贴"));
      (gpointer)("Paste"));
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_FIND,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(editmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_menu_activate),//(gpointer)("查找"));
      (gpointer)("Search"));
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu),editmenu);
   gtk_menu_shell_append(GTK_MENU_SHELL(menubar),rootmenu);
   rootmenu = gtk_menu_item_new_with_label(" 帮助 ");
   helpmenu = gtk_menu_new();
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_HELP,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_menu_activate),//(gpointer)("帮助"));
      (gpointer)("Help"));
   menuitem = gtk_menu_item_new_with_label(" 关于... ");
   gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_menu_activate),//(gpointer)("关于"));
   (gpointer)("About"));
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu),helpmenu);
   gtk_menu_shell_append(GTK_MENU_SHELL(menubar),rootmenu);
   gtk_box_pack_start(GTK_BOX(box),menubar,FALSE,FALSE,0);
   gtk_widget_show_all(window);
   gtk_main();
   return FALSE;
}

27.工具栏/条:gtk_toolbar_new

/* 添加工具条 toolbar.c*/
#include <gtk/gtk.h>
void on_button_clicked (GtkButton* button,gpointer data)
{
   g_print("你点击的按钮是 %s \n",(gchar*)data);
}
int main (int argc, char* argv[])
{
   GtkWidget* window;
   GtkWidget* box ;
   GtkWidget* toolbar ;
   GtkWidget* entry ;
   GtkWidget* label ;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_widget_set_size_request(window,700,100); 
   gtk_window_set_title(GTK_WINDOW(window),"添加工具条");
   g_signal_connect(G_OBJECT(window),"destroy",
      G_CALLBACK(gtk_main_quit),NULL);

   box = gtk_vbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(window),box);
   toolbar = gtk_toolbar_new();
   gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar),GTK_STOCK_NEW,
      "新建一个文件","新建",
      GTK_SIGNAL_FUNC(on_button_clicked),
      (gpointer)("新建"),-1);

   gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar),GTK_STOCK_OPEN,
      "打开一个文件","打开",
      GTK_SIGNAL_FUNC(on_button_clicked),
      (gpointer)("打开"),-1);

   gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar),GTK_STOCK_SAVE,
      "保存当前文件","保存",
      GTK_SIGNAL_FUNC(on_button_clicked),
      (gpointer)("保存"),-1);

   gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
   label = gtk_label_new(" 文件名:");
   gtk_toolbar_append_widget(GTK_TOOLBAR(toolbar),label,
      "这是一个标签","标签");
   entry = gtk_entry_new();
   gtk_toolbar_append_widget(GTK_TOOLBAR(toolbar),entry,
      "这是一个录入条","录入");
   gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
   gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar),GTK_STOCK_CUT,
      "剪切","剪切",
      GTK_SIGNAL_FUNC(on_button_clicked),
      (gpointer)("剪切"),-1);
   gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar),GTK_STOCK_COPY,
      "复制","复制",
      GTK_SIGNAL_FUNC(on_button_clicked),
      (gpointer)("复制"),-1);
   gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar),GTK_STOCK_PASTE,
      "粘贴","粘贴",
      GTK_SIGNAL_FUNC(on_button_clicked),
      (gpointer)("粘贴"),-1);
   gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
   gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar),GTK_STOCK_QUIT,
      "退出","退出",
      GTK_SIGNAL_FUNC(on_button_clicked),
      (gpointer)("退出"),-1);
   gtk_toolbar_set_style(GTK_TOOLBAR(toolbar),GTK_TOOLBAR_ICONS);
   gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar),
      GTK_ICON_SIZE_SMALL_TOOLBAR);
   gtk_box_pack_start(GTK_BOX(box),toolbar,FALSE,FALSE,0);
   gtk_widget_show_all(window);
   gtk_main();
   return FALSE;
}

28.浮动的工具条的菜单

/* 浮动的工具条和菜单 handle.c */
#include <gtk/gtk.h>
//创建自己按钮的函数
GtkWidget* create_button (char *filename)
{
   GtkWidget* image;
   GtkWidget* button;
   image = gtk_image_new_from_file(filename) ;
   gtk_widget_show(image);
   button = gtk_button_new();
   gtk_container_add(GTK_CONTAINER(button),image) ;
   return button ;
}
//主函数
int main (int argc, char *argv[])
{
   GtkWidget* window;
   GtkWidget* vbox;
   GtkWidget* hbox;
   GtkWidget* box;
   GtkWidget* box1;
   GtkWidget* handle;
   GtkWidget* handle1;
   GtkWidget* menubar;
   GtkWidget* button1;
   GtkWidget* button2;
   GtkWidget* button3;
   GtkWidget* button4;
   GtkWidget* menu;
   GtkWidget* menuitem;
   GtkWidget* rootmenu;
   GtkTooltips* button_tips;

   char* title = "浮动的工具条和菜单";

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(window),title);
   gtk_container_set_border_width(GTK_CONTAINER(window),5);
   g_signal_connect(G_OBJECT(window),"destroy",
      G_CALLBACK(gtk_main_quit),NULL);

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

   hbox = gtk_hbox_new(FALSE,0);
   gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,5);

   handle = gtk_handle_box_new();
   gtk_box_pack_start(GTK_BOX(hbox),handle,FALSE,FALSE,5);

   box = gtk_hbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(handle),box);

   button1 = create_button("win7.jpg") ;
   gtk_box_pack_start(GTK_BOX(box),button1,FALSE,FALSE,3);

   button2 = create_button("dir.jpg");
   gtk_box_pack_start(GTK_BOX(box),button2,FALSE,FALSE,3);

   button3 = create_button("save.gif");
   gtk_box_pack_start(GTK_BOX(box),button3,FALSE,FALSE,3);

   button4 = create_button("quit.gif");
   gtk_box_pack_start(GTK_BOX(box),button4,FALSE,FALSE,3);

   button_tips = gtk_tooltips_new();
   gtk_tooltips_set_tip(GTK_TOOLTIPS(button_tips),button1,
      "创建一个新文件","New");
   gtk_tooltips_set_tip(GTK_TOOLTIPS(button_tips),button2,
      "打开文件","Open");
   gtk_tooltips_set_tip(GTK_TOOLTIPS(button_tips),button3,
      "保存当前编辑的文件","Save");
   gtk_tooltips_set_tip(GTK_TOOLTIPS(button_tips),button4,
      "退出此程序","Quit");
   handle1 = gtk_handle_box_new();
   gtk_box_pack_start(GTK_BOX(hbox),handle1,FALSE,FALSE,5);
   box1 = gtk_hbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(handle1),box1);
   menubar = gtk_menu_bar_new();
   gtk_box_pack_start(GTK_BOX(box1),menubar,FALSE,FALSE,5);
   menu = gtk_menu_new();
   menuitem = gtk_menu_item_new_with_label("菜单项一");
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   menuitem = gtk_menu_item_new_with_label("菜单项二");
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   rootmenu = gtk_menu_item_new_with_label(" 文件 ");
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu),menu);
   gtk_menu_shell_append(GTK_MENU_SHELL(menubar),rootmenu);
   gtk_widget_show_all(window);
   gtk_main();
   return FALSE ;
}

29.一个文本编辑器:包含menu,toolbar,statusbar

// A app //
///a
///a
///a
///a
/*a 回调函数文件 callbacks.c */
#include <gtk/gtk.h>
gboolean on_window_delete_event (GtkWidget* widget,
GdkEvent *event,
gpointer data)
{
   gtk_main_quit();
   return FALSE;
}
void on_file_new_activate (GtkMenuItem* menuitem, gpointer data)
{
   g_print("the file_new is clicked .\n");
}
void on_file_open_activate (GtkMenuItem* menuitem, gpointer data)
{
}
void on_file_save_activate (GtkMenuItem* menuitem, gpointer data)
{
}
void on_file_saveas_activate (GtkMenuItem* menuitem, gpointer data)
{
}
void on_file_exit_activate (GtkMenuItem* menuitem,gpointer data)
{
}
void on_edit_cut_activate (GtkMenuItem* menuitem,gpointer data)
{
}
void on_edit_copy_activate (GtkMenuItem* menuitem,gpointer data)
{
}
void on_edit_paste_activate (GtkMenuItem* menuitem,gpointer data)
{
}
void on_edit_selectall_activate (GtkMenuItem* menuitem,gpointer data)
{
}
void on_edit_find_activate (GtkMenuItem* menuitem,gpointer data)
{
}
void on_help_help_activate (GtkMenuItem* menuitem,gpointer data)
{
}
void on_help_about_activate (GtkMenuItem* menuitem,gpointer data)
{
}

///a
///a
///a
///a
/* 界面代码文件 interface.c */
//#include <gtk/gtk.h>
//#include "callbacks.h"
GtkWidget* create_menu (GtkAccelGroup* accel_group,GtkWidget *window);
GtkWidget* create_toolbar (GtkWidget* window);
GtkWidget* create_window (void)
{
   GtkWidget* window;
   GtkWidget* text;
   GtkWidget* scrolledwin;
   GtkWidget* box;
   GtkWidget* statusbar;
   GtkWidget* menubar ;
   GtkWidget* toolbar ;
   GtkAccelGroup* accel_group ;
   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(window),"完整的应用程序窗口");
   gtk_window_set_default_size(GTK_WINDOW(window),400,300);
   accel_group = gtk_accel_group_new();
   gtk_window_add_accel_group(GTK_WINDOW(window),accel_group);
   box = gtk_vbox_new(FALSE,0);
   gtk_container_add (GTK_CONTAINER (window), box);
   menubar = create_menu(accel_group,window);
   gtk_box_pack_start(GTK_BOX(box),menubar,0,0,0);
   toolbar = create_toolbar(window);
   gtk_box_pack_start(GTK_BOX(box),toolbar,0,1,0);
   scrolledwin = gtk_scrolled_window_new(NULL,NULL);
   text = gtk_text_view_new();
   gtk_box_pack_start(GTK_BOX(box),scrolledwin,TRUE,TRUE,0);
   gtk_container_add(GTK_CONTAINER(scrolledwin),text);
   gtk_text_view_set_editable(GTK_TEXT_VIEW(text),TRUE);
   statusbar = gtk_statusbar_new();
   gtk_box_pack_start(GTK_BOX(box),statusbar,FALSE,FALSE,0);
   gtk_widget_show_all(window);
   return window;
}
GtkWidget* create_menu (GtkAccelGroup* accel_group,GtkWidget *window)
{
   GtkWidget* menubar;
   GtkWidget* menu;
   GtkWidget* editmenu;
   GtkWidget* helpmenu;
   GtkWidget* rootmenu;
   GtkWidget* menuitem;
   menu = gtk_menu_new();//文件菜单
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_NEW,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_file_new_activate),NULL);
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_OPEN,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_file_new_activate),NULL);
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_SAVE,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_SAVE_AS,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   menuitem = gtk_separator_menu_item_new();
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_QUIT,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_window_delete_event),NULL);
   rootmenu = gtk_menu_item_new_with_label(" 文件 ");
   gtk_widget_show(rootmenu);
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu),menu);
   menubar = gtk_menu_bar_new();
   gtk_menu_shell_append(GTK_MENU_SHELL(menubar),rootmenu);
   rootmenu = gtk_menu_item_new_with_label(" 编辑 ");
   editmenu = gtk_menu_new();//编辑菜单
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_CUT,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(editmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_edit_cut_activate),NULL);
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_COPY,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(editmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_edit_copy_activate),NULL);
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_PASTE,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(editmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_edit_paste_activate),NULL);
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_FIND,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(editmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_edit_find_activate),NULL);
   gtk_widget_show(rootmenu);
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu),editmenu);
   gtk_menu_shell_append(GTK_MENU_SHELL(menubar),rootmenu);
   rootmenu = gtk_menu_item_new_with_label(" 帮助 ");
   helpmenu = gtk_menu_new();
   menuitem = gtk_image_menu_item_new_from_stock
      (GTK_STOCK_HELP,accel_group);
   gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_help_help_activate),NULL);
   menuitem = gtk_menu_item_new_with_label(" 关于 ");
   gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu),menuitem);
   g_signal_connect(G_OBJECT(menuitem),"activate",
      G_CALLBACK(on_help_about_activate),NULL);
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(rootmenu),helpmenu);
   gtk_menu_shell_append(GTK_MENU_SHELL(menubar),rootmenu);
   return menubar ;
}
GtkWidget* create_toolbar (GtkWidget* window)
{
   GtkWidget* toolbar ;
   toolbar = gtk_toolbar_new();
   gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar),
      GTK_STOCK_NEW,
      "创建一个新文件","新建",
      GTK_SIGNAL_FUNC(on_file_new_activate),
      window,-1);
   gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar),
      GTK_STOCK_OPEN,
      "打开一个文件","打开",
      GTK_SIGNAL_FUNC(on_file_open_activate),
      toolbar,-1);
   gtk_toolbar_insert_stock(GTK_TOOLBAR(toolbar),
      GTK_STOCK_SAVE,
      "保存当前文件","保存",
      GTK_SIGNAL_FUNC(on_file_save_activate),
      toolbar,-1);
   return toolbar;
}
///a
///a
///a
///a
/* 主函数文件 main.c*/
//#include <gtk/gtk.h>
//#include "callbacks.h"
//#include "interface.h"
int main (int argc , gchar* argv[])
{
   GtkWidget * window ;
   gtk_init(&argc,&argv);
   window = create_window();
   g_signal_connect(G_OBJECT(window),"delete_event",
      G_CALLBACK(on_window_delete_event),NULL);
   gtk_widget_show(window);
   gtk_main();
   return FALSE;
}

30.模拟90坦克游戏:在frame中移动一个图片,键盘控制走向

/* 坦克游戏 tank.c */
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
enum _FORWARD { LEFT, UP, RIGHT, DOWN } ;
typedef enum _FORWARD Forward; //定义方向类型
void move (Forward fw);
void key_press (GtkWidget* widget,GdkEventKey *event,gpointer data);
static gchar* tank_file[4] = {"u.bmp","r.bmp","d.bmp","l.bmp"};
static GtkWidget *fixed;
static GtkWidget *tank_image;
gint i = 75 ;
gint j = 75 ;
Forward forward = UP ;//定义方向
void move (Forward fw)
{
   switch(fw)
   {
      case UP :
         j = j - 5 ;
         if ( j < 0 ) j = 400 ;
         gtk_image_set_from_file(GTK_IMAGE(tank_image),tank_file[0]);
         gtk_fixed_move(GTK_FIXED(fixed),tank_image,i,j);
         break;
      case DOWN :
         j = j + 5;
         if ( j > 400 ) j = 0 ;
         gtk_image_set_from_file(GTK_IMAGE(tank_image),tank_file[2]);
         gtk_fixed_move(GTK_FIXED(fixed),tank_image,i,j);
         break;
      case LEFT :
         i = i - 5;
         if ( i < 0 ) i = 400 ;
         gtk_image_set_from_file(GTK_IMAGE(tank_image),tank_file[3]);
         gtk_fixed_move(GTK_FIXED(fixed),tank_image,i,j);
         break;
      case RIGHT :
         i = i + 5;
         if ( i > 400 ) i = 0 ;
         gtk_image_set_from_file(GTK_IMAGE(tank_image),tank_file[1]);
         gtk_fixed_move(GTK_FIXED(fixed),tank_image,i,j);
         break;
   }
}
void key_press (GtkWidget* widget,GdkEventKey *event,gpointer data)
{
   switch(event->keyval)
   {
      case GDK_Up :
         forward = UP;
         move(forward);
         break;
      case GDK_Down :
         forward = DOWN;
         move(forward);
         break;
      case GDK_Left :
         forward = LEFT;
         move(forward);
         break;
      case GDK_Right :
         forward = RIGHT;
         move(forward);
         break;
   }
}
//主函数
int main (int argc, char *argv[])
{
   GtkWidget* window;
   GtkWidget* vbox;
   GtkWidget* bbox;
   GtkWidget* sep;
   GtkWidget* frame;
   GtkWidget* button;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(window),"坦克游戏");
   gtk_container_set_border_width(GTK_CONTAINER(window),10);
   g_signal_connect(G_OBJECT(window),"destroy",
      G_CALLBACK(gtk_main_quit),NULL);

   g_signal_connect(G_OBJECT(window),"key_press_event",
      G_CALLBACK(key_press),NULL);keyboard input

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

   frame = gtk_frame_new(NULL);
   gtk_frame_set_shadow_type(GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);

   fixed = gtk_fixed_new();
   gtk_fixed_set_has_window(GTK_FIXED(fixed),TRUE);
   gtk_widget_set_size_request(fixed,400,400);

   gtk_container_add(GTK_CONTAINER(frame),fixed);
   gtk_box_pack_start(GTK_BOX(vbox),frame,TRUE,TRUE,5);

   sep = gtk_hseparator_new();
   gtk_box_pack_start(GTK_BOX(vbox),sep,FALSE,FALSE,5);

   bbox = gtk_hbutton_box_new();
   gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox),GTK_BUTTONBOX_END);
   gtk_box_pack_start(GTK_BOX(vbox),bbox,FALSE,FALSE,5);

   button = gtk_button_new_from_stock(GTK_STOCK_QUIT);
   g_signal_connect(G_OBJECT(button),"clicked",
      G_CALLBACK(gtk_main_quit),NULL);
   gtk_box_pack_end(GTK_BOX(bbox),button,FALSE,FALSE,5);

   tank_image = gtk_image_new_from_file(tank_file[0]);
   gtk_fixed_put(GTK_FIXED(fixed),tank_image,i,j);
   gtk_widget_show_all(window);
   gtk_main();
   return FALSE ;
}

31.pixmap:

网址:https://developer.gimp.org/api/2.0/gdk-pixbuf/gdk-pixbuf-creating.html

我暂时没找到一个pixmap的图像,等找到以后在更新

/* 图像的直接引用 pixmap.c */
#include <gtk/gtk.h>
#include "a.h" //这里买年包含了一个pixmap图像
int main ( int argc , char* argv[])
{
   GtkWidget *window;
   GtkWidget *vbox;
   GtkWidget *frame;
   GtkWidget *image;
   GdkPixbuf *pixbuf;
   GdkPixbuf *pix1,*pix2,*pix3;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   g_signal_connect(G_OBJECT(window),"delete_event",
      G_CALLBACK(gtk_main_quit),NULL);
   gtk_window_set_title(GTK_WINDOW(window),"图像的直接引用");
   gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
   gtk_container_set_border_width(GTK_CONTAINER(window),10);

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

   pixbuf = gdk_pixbuf_new_from_file("b.png",NULL);
   frame = gtk_frame_new("这是一幅完整的图像");
   image = gtk_image_new_from_pixbuf(pixbuf);
   gtk_box_pack_start(GTK_BOX(vbox),frame,FALSE,FALSE,5);
   gtk_container_add(GTK_CONTAINER(frame),image);

   pix1 = gdk_pixbuf_new_subpixbuf(pixbuf,280,40,40,40);
   frame = gtk_frame_new("从上图中分割出来的一幅图像");
   image = gtk_image_new_from_pixbuf(pix1);
   gtk_container_add(GTK_CONTAINER(frame),image);
   gtk_box_pack_start(GTK_BOX(vbox),frame,FALSE,FALSE,5);

   pix2 =gdk_pixbuf_new_from_inline(22400+24,pieces_inline,TRUE,NULL);
   frame = gtk_frame_new("内建的一幅图像");
   image = gtk_image_new_from_pixbuf(pix2);
   gtk_container_add(GTK_CONTAINER(frame),image);
   gtk_box_pack_start(GTK_BOX(vbox),frame,FALSE,FALSE,5);
   pix3 = gdk_pixbuf_new_subpixbuf(pix2,120,20,20,20);
   frame = gtk_frame_new("从内建图像中分割出来的一幅图像");
   image = gtk_image_new_from_pixbuf(pix3);
   gtk_container_add(GTK_CONTAINER(frame),image);
   gtk_box_pack_start(GTK_BOX(vbox),frame,FALSE,FALSE,5);
   gtk_widget_show_all(window);
   gtk_main();
   return FALSE;
}

32.固定调节数值的按钮:gtk_spin_button_new_with_range

/* 滚动按钮 spin.c */
#include <gtk/gtk.h>
int main (int argc, char* argv[])
{
   GtkWidget* window;
   GtkWidget* vbox;
   GtkWidget* frame;
   GtkWidget* spin;
   GtkWidget* label;
   GtkWidget* vvbox;
   GtkWidget *hbox,*vbox1,*vbox2,*vbox3;
   GtkAdjustment* adj1;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(window),"滚动按钮");
   g_signal_connect(G_OBJECT(window),"destroy",
            G_CALLBACK(gtk_main_quit),NULL);
   gtk_container_set_border_width(GTK_CONTAINER(window),10);

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

   frame = gtk_frame_new("日历");
   gtk_box_pack_start(GTK_BOX(vbox),frame,FALSE,FALSE,5);

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

   vbox1 = gtk_vbox_new(TRUE,0);
   gtk_box_pack_start(GTK_BOX(hbox),vbox1,TRUE,TRUE,5);
   label = gtk_label_new("年:");
   gtk_box_pack_start(GTK_BOX(vbox1),label,FALSE,FALSE,2);
   spin = gtk_spin_button_new_with_range(2019,2100,1);
   gtk_box_pack_start(GTK_BOX(vbox1),spin,FALSE,FALSE,2);

   vbox2 = gtk_vbox_new(TRUE,0);
   gtk_box_pack_start(GTK_BOX(hbox),vbox2,TRUE,TRUE,5);
   label = gtk_label_new("月:");
   gtk_box_pack_start(GTK_BOX(vbox2),label,FALSE,FALSE,2);
   spin = gtk_spin_button_new_with_range(1,12,1);
   gtk_box_pack_start(GTK_BOX(vbox2),spin,FALSE,FALSE,2);

   vbox3 = gtk_vbox_new(TRUE,0);
   gtk_box_pack_start(GTK_BOX(hbox),vbox3,TRUE,TRUE,5);
   label = gtk_label_new("日:");
   gtk_box_pack_start(GTK_BOX(vbox3),label,FALSE,FALSE,2);
   spin = gtk_spin_button_new_with_range(1,31,1);
   gtk_box_pack_start(GTK_BOX(vbox3),spin,FALSE,FALSE,2);

   frame = gtk_frame_new(NULL);
   gtk_box_pack_start(GTK_BOX(vbox),frame,FALSE,FALSE,5);

   vvbox = gtk_vbox_new(FALSE,0);
   gtk_container_add(GTK_CONTAINER(frame),vvbox);
   gtk_container_set_border_width(GTK_CONTAINER(vvbox),10);

   label = gtk_label_new("第一个滚动按钮,\n显示整数,范围: 0 - 100");

   adj1 = (GtkAdjustment *) gtk_adjustment_new (50.0, 0.0, 100.0, 1.0,  5.0, 5.0);

   spin = gtk_spin_button_new(adj1,5,1);
   gtk_box_pack_start(GTK_BOX(vvbox),label,FALSE,FALSE,3);
   gtk_box_pack_start(GTK_BOX(vvbox),spin,FALSE,FALSE,3);

   label = gtk_label_new("第二个滚动按钮,\n显示浮点数,范围: 0.1 - 1.50");

   spin = gtk_spin_button_new_with_range(0,9.9,0.1);
   gtk_box_pack_start(GTK_BOX(vvbox),label,FALSE,FALSE,3);
   gtk_box_pack_start(GTK_BOX(vvbox),spin,FALSE,FALSE,3);


   gtk_widget_show_all(window);
   gtk_main();
   return FALSE;
}

33.分隔面板:gtk_hpanel_new,gtk_vpanel_new(未编译)

/* 分隔面板 panel.c */
#include <gtk/gtk.h>
int main (int argc, char* argv[])
{
   GtkWidget *window;
   GtkWidget *panel;
   GtkWidget *panel1;
   GtkWidget *button1;
   GtkWidget *button2;
   GtkWidget *button3;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(window),"分隔面板测试程序");
   g_signal_connect(G_OBJECT(window),"destroy",
         G_CALLBACK(gtk_main_quit),NULL);

   panel = gtk_hpanel_new();
   gtk_container_add(GTK_CONTAINER(window),panel);
   gtk_widget_show(panel);

   button1 = gtk_button_new_with_label("按钮一");
   gtk_panel_add1(GTK_PANEL(panel),button1);
   gtk_widget_show(button1);

   panel1 = gtk_vpanel_new();
   gtk_panel_add2(GTK_PANEL(panel),panel1);
   gtk_widget_show(panel1);

   button2 = gtk_button_new_with_label("按钮二");
   gtk_panel_add1(GTK_PANEL(panel1),button2);
   gtk_widget_show(button2);

   button3 = gtk_button_new_with_label("按钮三");
   gtk_panel_add2(GTK_PANEL(panel1),button3);
   gtk_widget_show(button3);


   gtk_widget_show(window);
   gtk_main();
   return FALSE;
}

34.会话窗口:gtk_button_new_from_stock

共四种:

GTK_STOCK_DIALOG_INFO, 

GTK_STOCK_DIALOG_ERROR,

GTK_STOCK_DIALOG_QUESTION,

GTK_STOCK_DIALOG_WARNING

/* 消息对话框测试程序 message.c*/
#include <gtk/gtk.h>
static void on_button_clicked (GtkWidget* button,gint data)
{
   GtkWidget* dialog ;
   GtkMessageType type ;
   gchar *message;
   switch((int)data)
   {
      case 1 :
         message = "这是一个信息提示对话框.";
         type = GTK_MESSAGE_INFO ; break;
      case 2 :
         message = "这是一个错误提示对话框.";
         type = GTK_MESSAGE_ERROR ; break;
      case 3 :
         message = "这是一个问题提示对话框.";
         type = GTK_MESSAGE_QUESTION ; break;
      case 4 :
         message = "这是一个警告提示对话框.";
         type = GTK_MESSAGE_WARNING ; break;
   }
//
   dialog = gtk_message_dialog_new(NULL,
         GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
         type ,
         GTK_BUTTONS_OK,
         message);
   gtk_dialog_run(GTK_DIALOG(dialog));
   gtk_widget_destroy(dialog);
}
int main (int argc, char* argv[])
{
   GtkWidget* window;
   GtkWidget* frame;
   GtkWidget* box;
   GtkWidget* button1;
   GtkWidget* button2;
   GtkWidget* button3;
   GtkWidget* button4;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(window),"创建消息框");
   g_signal_connect(G_OBJECT(window),"destroy",
         G_CALLBACK(gtk_main_quit),NULL);
   gtk_container_set_border_width(GTK_CONTAINER(window),20);

   frame = gtk_frame_new("四种消息对话框:");
   gtk_container_add(GTK_CONTAINER(window),frame);

   box = gtk_hbox_new(TRUE,0);
   gtk_container_add(GTK_CONTAINER(frame),box);
   gtk_container_set_border_width(GTK_CONTAINER(box),20);

   button1= gtk_button_new_from_stock(GTK_STOCK_DIALOG_INFO);
   gtk_box_pack_start(GTK_BOX(box),button1,FALSE,FALSE,5);
   g_signal_connect(G_OBJECT(button1),"clicked",
         G_CALLBACK(on_button_clicked),(gpointer)1);

   button2 = gtk_button_new_from_stock(GTK_STOCK_DIALOG_ERROR);
   gtk_box_pack_start(GTK_BOX(box),button2,FALSE,FALSE,5);
   g_signal_connect(G_OBJECT(button2),"clicked",
         G_CALLBACK(on_button_clicked),(gpointer)2);

   button3 = gtk_button_new_from_stock(GTK_STOCK_DIALOG_QUESTION);
   gtk_box_pack_start(GTK_BOX(box),button3,FALSE,FALSE,5);
   g_signal_connect(G_OBJECT(button3),"clicked",
         G_CALLBACK(on_button_clicked),(gpointer)3);

   button4 = gtk_button_new_from_stock(GTK_STOCK_DIALOG_WARNING);
   gtk_box_pack_start(GTK_BOX(box),button4,FALSE,FALSE,5);
   g_signal_connect(G_OBJECT(button4),"clicked",
         G_CALLBACK(on_button_clicked),(gpointer)4);


   gtk_widget_show_all(window);
   gtk_main();
   return FALSE;
}

35.字体选择:gtk_font_selection_dialog_new

/* 选择字体 fontsel.c */
#include <gtk/gtk.h>
void on_font_select_ok (GtkWidget *button,GtkFontSelectionDialog *fs)
{
   GtkWidget *dialog;
   gchar message[1024];
   gchar *s = gtk_font_selection_dialog_get_font_name(fs);
   sprintf(message,"你选择的字体是:%s \n",s);
   dialog = gtk_message_dialog_new(NULL,
            GTK_DIALOG_DESTROY_WITH_PARENT,
            GTK_MESSAGE_INFO,
            GTK_BUTTONS_OK,
            message,
            NULL);
   g_free(s);
   gtk_widget_destroy(GTK_WIDGET(fs));
   gtk_dialog_run(GTK_DIALOG(dialog));
   gtk_widget_destroy(dialog);
}
void on_button_clicked (GtkWidget *button,gpointer userdata)
{
   GtkWidget* dialog ;

   dialog = gtk_font_selection_dialog_new("请选择一种字体:");
   gtk_window_set_position(GTK_WINDOW(dialog),GTK_WIN_POS_CENTER);
   gtk_signal_connect(GTK_OBJECT(dialog),"destroy",
         GTK_SIGNAL_FUNC(gtk_widget_destroy),&dialog);
   gtk_signal_connect(GTK_OBJECT(GTK_FONT_SELECTION_DIALOG(dialog)->ok_button),
         "clicked",GTK_SIGNAL_FUNC(on_font_select_ok),
         GTK_FONT_SELECTION_DIALOG(dialog));

   gtk_signal_connect_object(GTK_OBJECT(GTK_FONT_SELECTION_DIALOG(dialog)->cancel_button),
         "clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),
         GTK_OBJECT(dialog));

   gtk_widget_show(dialog);
}
int main ( int argc , char* argv[])
{
   GtkWidget *window;
   GtkWidget *button;

   gtk_init(&argc,&argv);

   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   g_signal_connect(G_OBJECT(window),"delete_event",
         G_CALLBACK(gtk_main_quit),NULL);
   gtk_window_set_title(GTK_WINDOW(window),"字体选择功能实现");
   gtk_window_set_default_size(GTK_WINDOW(window),500,100);
   //gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
   gtk_container_set_border_width(GTK_CONTAINER(window),40);

   button = gtk_button_new_with_label("按下此按钮来选择字体");
   g_signal_connect(G_OBJECT(button),"clicked",
         G_CALLBACK(on_button_clicked),NULL);
   gtk_container_add(GTK_CONTAINER(window),button);
   gtk_widget_show(button);


   gtk_widget_show(window);
   gtk_main();
   return FALSE;
}

 

36.几个画图的骚操作:gtk_drawing_area_new

先给出三个例子的效果:

代码1效果

代码2效果

代码3效果

代码1

/* 绘图软件 brush.c */
#include <gtk/gtk.h>
#include <stdlib.h>
#include <stdio.h>
static GtkWidget *window = NULL;
static GdkPixmap *pixmap = NULL;

char FN[250]={"layer.txt"};
int nx=300;
int nz=300;

static gboolean scribble_configure_event (GtkWidget *widget,GdkEventConfigure *event,gpointer data)
{
   if (pixmap)
   g_object_unref (G_OBJECT (pixmap));
   pixmap = gdk_pixmap_new (widget->window,
   widget->allocation.width,
   widget->allocation.height,-1);
   gdk_draw_rectangle (pixmap,widget->style->white_gc,
                        TRUE,0,0,widget->allocation.width,
                        widget->allocation.height);
   return TRUE;
}
static gboolean scribble_expose_event (GtkWidget *widget,GdkEventExpose *event,gpointer data)
{
   gdk_draw_drawable (widget->window,
                        widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
                        pixmap,
                        event->area.x, event->area.y,
                        event->area.x, event->area.y,
                        event->area.width, event->area.height);
   return FALSE;
}
static void draw_brush (GtkWidget *widget, gdouble x, gdouble y)
{
   GdkRectangle update_rect;
   update_rect.x = x - 3;
   update_rect.y = y - 3;
   update_rect.width = 6;
   update_rect.height = 6;
   gdk_draw_rectangle (pixmap,
                        widget->style->black_gc,
                        TRUE,
                        update_rect.x, update_rect.y,
                        update_rect.width, update_rect.height);
                        gdk_window_invalidate_rect (widget->window,
                        &update_rect,
                        FALSE);
}
static gboolean scribble_button_press_event (GtkWidget *widget,GdkEventButton *event,gpointer data)
{
   if (pixmap == NULL)
      return FALSE;
   if (event->button == 1)
   {
      draw_brush (widget, event->x, event->y);
      printf("x=%.2f, z=%.2f\n", event->x, event->y*5.0);
   }
   return TRUE;
}
static gboolean scribble_motion_notify_event (GtkWidget *widget,GdkEventMotion *event,gpointer data)
{
   int x, y;
   GdkModifierType state;
   if (pixmap == NULL)
      return FALSE;
   gdk_window_get_pointer (event->window, &x, &y, &state);
   if (state & GDK_BUTTON1_MASK)
      draw_brush (widget, x, y);
   return TRUE;
}
static gboolean checkerboard_expose (GtkWidget *da, GdkEventExpose *event,gpointer data)
{
   gint i, j, xcount, ycount;
   GdkGC *gc1, *gc2;
   GdkColor color;
#define CHECK_SIZE 10
#define SPACING 2
   gc1 = gdk_gc_new (da->window);
   color.red = 30000;
   color.green = 0;
   color.blue = 30000;
   gdk_gc_set_rgb_fg_color (gc1, &color);
   gc2 = gdk_gc_new (da->window);
   color.red = 65535;
   color.green = 65535;
   color.blue = 65535;
   gdk_gc_set_rgb_fg_color (gc2, &color);
   xcount = 0;
   i = SPACING;
   while (i < da->allocation.width)
   {
      j = SPACING;
      ycount = xcount % 2;
      while (j < da->allocation.height)
      {
         GdkGC *gc;
         if (ycount % 2)
            gc = gc1;
         else
            gc = gc2;
         gdk_draw_rectangle (da->window, gc, TRUE,
                              i, j, CHECK_SIZE, CHECK_SIZE);
         j += CHECK_SIZE + SPACING;
         ++ycount;
      }
      i += CHECK_SIZE + SPACING;
      ++xcount;
   }
   g_object_unref (G_OBJECT (gc1));
   g_object_unref (G_OBJECT (gc2));
   return TRUE;
}
void writeTXT( GtkWidget *widget, gpointer data )
{
       FILE *fp=fopen(FN,"w");
       fprintf(fp,"rongtao\n");
       fclose(fp);
       g_print ("Write txt done.\n ");
       gtk_main_quit ();
}
int main (int argc,char* argv[])
{
   GtkWidget *frame;
   GtkWidget *vbox;
   GtkWidget *da;
   GtkWidget *label;

   GtkWidget *button;

   gtk_init(&argc,&argv);

   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title (GTK_WINDOW (window), "绘图软件");
   g_signal_connect (G_OBJECT(window), "delete_event",
         G_CALLBACK (gtk_main_quit), NULL);
   gtk_container_set_border_width (GTK_CONTAINER (window), 10);

   vbox = gtk_vbox_new (FALSE, 8);
   gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
   gtk_container_add (GTK_CONTAINER (window), vbox);

   label = gtk_label_new (NULL);
   gtk_label_set_markup (GTK_LABEL (label),"<u>绘图区域</u>");
   gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);

   frame = gtk_frame_new (NULL);
   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
   gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);

   da = gtk_drawing_area_new ();
   gtk_widget_set_size_request (da, nx, nz);
   gtk_container_add (GTK_CONTAINER (frame), da);

   g_signal_connect (da, "expose_event",
         G_CALLBACK (scribble_expose_event), NULL);
   g_signal_connect (da, "configure_event",
         G_CALLBACK (scribble_configure_event), NULL);
   g_signal_connect (da, "motion_notify_event",
         G_CALLBACK (scribble_motion_notify_event), NULL);
   g_signal_connect (da, "button_press_event",
         G_CALLBACK (scribble_button_press_event), NULL);

   gtk_widget_set_events (da, gtk_widget_get_events (da)
                           | GDK_LEAVE_NOTIFY_MASK
                           | GDK_BUTTON_PRESS_MASK
                           | GDK_POINTER_MOTION_MASK
                           | GDK_POINTER_MOTION_HINT_MASK);

      button = gtk_button_new_with_label ("Hello");
      g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (writeTXT), NULL);
      gtk_box_pack_start (GTK_BOX(vbox), button, TRUE, TRUE, 0);


   gtk_widget_show_all (window);
   gtk_main();
   return FALSE;
}

代码2

#include <gtk/gtk.h>

static GdkPixmap *pixmap = NULL;
GdkGC *my_gc_red;
GdkColor color;

int my_configure_event(GtkWidget *widget , GdkEventConfigure *event)
{
      if(pixmap)
          g_object_unref(pixmap);
      pixmap = gdk_pixmap_new(widget->window , 
                  widget->allocation.width , 
                  widget->allocation.height , 
                  -1);
      gdk_draw_rectangle(pixmap , widget->style->white_gc , 
                  TRUE , 0 , 0 , 
                  widget->allocation.width , 
                  widget->allocation.height);

      my_gc_red = gdk_gc_new(widget->window);
      color.red = 30000;
      color.green = 0;
      color.blue = 30000;
      gdk_gc_set_rgb_fg_color(my_gc_red , &color);    

      return 0;
}

int my_expose_event(GtkWidget *widget , GdkEventExpose *event , gpointer data)
{
      gdk_draw_drawable(widget->window , 
              widget->style->fg_gc[GTK_WIDGET_STATE(widget)] ,
              pixmap , 0 , 0 , 0 , 0 , 
              widget->allocation.width , 
              widget->allocation.height);    

      return 0;
}

int my_draw(GtkWidget *widget , double x , double y , int type)
{
      switch(type){
          case 1:
              gdk_draw_rectangle(pixmap , 
                      widget->style->black_gc , 
                      FALSE ,     
                      x , y , 10 , 10);
              gtk_widget_queue_draw_area(widget , 
                          x , y , 10 , 10);
              break;
          case 2:
              gdk_draw_rectangle(pixmap , 
                      my_gc_red , 
                      TRUE ,     
                      x , y , 15 , 15);
              gtk_widget_queue_draw_area(widget , 
                          x , y , 15 , 15);
              break;
          case 3:
              gdk_draw_line(pixmap , my_gc_red , 
                      x , y , x + 15 , y - 15);
              gtk_widget_queue_draw_area(widget , 
                      x , y - 15 , 15 , 15);
              break;
          default:
              printf("....\n");
              break;
      }
    
      return 0;
}
int my_button_press_event(GtkWidget *widget , GdkEventButton *event)
{
      my_draw(widget , event->x , event->y , event->button);    
      printf("x=%lf y=%lf\n" , event->x , event->y);

      return 0;    
}
int my_clear(GtkWidget *widget , GtkWidget *area)
{
      gdk_draw_rectangle(pixmap , 
              area->style->white_gc , 
              TRUE , 0 , 0 , 
              area->allocation.width , 
              area->allocation.height);
      gtk_widget_queue_draw(area);

      return 0;
}
int my_quit(GtkWidget *widget , gpointer data)
{
      gtk_main_quit();
    
      return 0;
}

int main(int argc , char *argv[])
{
      GtkWidget *window;
      GtkWidget *drawing_area;
      GtkWidget *vbox;
      GtkWidget *bt_clear;
      GtkWidget *bt_quit;

      gtk_init(&argc , &argv);
    
      window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
      gtk_widget_set_name(window , "Test drawing_area");
      gtk_widget_set_size_request(window , 300 , 200);
      gtk_container_set_border_width(GTK_CONTAINER(window) , 2);
      gtk_window_set_resizable(GTK_WINDOW(window) , FALSE);

      vbox = gtk_vbox_new(FALSE , 0);
      gtk_container_add(GTK_CONTAINER(window) , vbox);
      gtk_widget_show(vbox);
    
      g_signal_connect(G_OBJECT(window) , "destroy" , 
              G_CALLBACK(my_quit) , NULL);

      drawing_area = gtk_drawing_area_new();
      gtk_box_pack_start(GTK_BOX(vbox) , drawing_area , TRUE , TRUE , 0);
      gtk_widget_show(drawing_area);
      g_signal_connect(G_OBJECT(drawing_area) , "configure_event" , 
              G_CALLBACK(my_configure_event) , NULL);
      g_signal_connect(G_OBJECT(drawing_area) , "expose_event" , 
              G_CALLBACK(my_expose_event) , NULL);
      g_signal_connect(G_OBJECT(drawing_area) , "button_press_event" , 
              G_CALLBACK(my_button_press_event) , NULL);
      gtk_widget_set_events(drawing_area , GDK_BUTTON_PRESS_MASK);
    
      bt_clear = gtk_button_new_with_label("clear");
      gtk_box_pack_start(GTK_BOX(vbox) , bt_clear , FALSE , FALSE , 0);
      g_signal_connect(G_OBJECT(bt_clear) , "clicked" , 
              G_CALLBACK(my_clear) , drawing_area);
      gtk_widget_show(bt_clear);
    
      bt_quit = gtk_button_new_with_label("quit");
      gtk_box_pack_start(GTK_BOX(vbox) , bt_quit , FALSE , FALSE , 0);
      g_signal_connect(G_OBJECT(bt_quit) , "clicked" , 
              G_CALLBACK(my_quit) , window);
      gtk_widget_show(bt_quit);

      gtk_widget_show(window);

      gtk_main();

      return 0;
}

代码3

/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
* Modified by the GTK+ Team and others 1997-2000.   See the AUTHORS
* file for a list of people on the GTK+ Team.   See the ChangeLog
* files for a list of changes.   These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
*/
//#include <config.h>
#include <stdio.h>
#include "gtk/gtk.h"
/* Backing pixmap for drawing area */
static GdkPixmap *pixmap = NULL;
/* Information about cursor */
static gint cursor_proximity = TRUE;
static gdouble cursor_x;
static gdouble cursor_y;
/* Unique ID of current device */
static GdkDevice *current_device;
/* Erase the old cursor, and/or draw a new one, if necessary */
static void
update_cursor (GtkWidget *widget,   gdouble x, gdouble y)
{
   static gint cursor_present = 0;
   gint state = !current_device->has_cursor && cursor_proximity;
   if (pixmap != NULL)
     {
       if (cursor_present && (cursor_present != state ||
         x != cursor_x || y != cursor_y))
{
    gdk_draw_drawable (widget->window,
         widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
         pixmap,
         cursor_x - 5, cursor_y - 5,
         cursor_x - 5, cursor_y - 5,
         10, 10);
}
       cursor_present = state;
       cursor_x = x;
       cursor_y = y;
       if (cursor_present)
{
    gdk_draw_rectangle (widget->window,
          widget->style->black_gc,
          TRUE,
          cursor_x - 5, cursor_y -5,
          10, 10);
}
     }
}
/* Create a new backing pixmap of the appropriate size */
static gint
configure_event (GtkWidget *widget, GdkEventConfigure *event)
{
   if (pixmap)
     g_object_unref (pixmap);
   pixmap = gdk_pixmap_new(widget->window,
      widget->allocation.width,
      widget->allocation.height,
      -1);
   gdk_draw_rectangle (pixmap,
         widget->style->white_gc,
         TRUE,
         0, 0,
         widget->allocation.width,
         widget->allocation.height);
   return TRUE;
}
/* Refill the screen from the backing pixmap */
static gint
expose_event (GtkWidget *widget, GdkEventExpose *event)
{
   gdk_draw_drawable (widget->window,
        widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
        pixmap,
        event->area.x, event->area.y,
        event->area.x, event->area.y,
        event->area.width, event->area.height);
   return FALSE;
}
/* Draw a rectangle on the screen, size depending on pressure,
    and color on the type of device */
static void
draw_brush (GtkWidget *widget, GdkInputSource source,
      gdouble x, gdouble y, gdouble pressure)
{
   GdkGC *gc;
   GdkRectangle update_rect;
   switch (source)
     {
     case GDK_SOURCE_MOUSE:
       gc = widget->style->dark_gc[GTK_WIDGET_STATE (widget)];
       break;
     case GDK_SOURCE_PEN:
       gc = widget->style->black_gc;
       break;
     case GDK_SOURCE_ERASER:
       gc = widget->style->white_gc;
       break;
     default:
       gc = widget->style->light_gc[GTK_WIDGET_STATE (widget)];
     }
   update_rect.x = x - 10 * pressure;
   update_rect.y = y - 10 * pressure;
   update_rect.width = 20 * pressure;
   update_rect.height = 20 * pressure;
   gdk_draw_rectangle (pixmap, gc, TRUE,
         update_rect.x, update_rect.y,
         update_rect.width, update_rect.height);
   gtk_widget_queue_draw_area (widget,
          update_rect.x, update_rect.y,
          update_rect.width, update_rect.height);
   gdk_window_process_updates (widget->window, TRUE);
}
static guint32 motion_time;
static void
print_axes (GdkDevice *device, gdouble *axes)
{
   int i;
  
   if (axes)
     {
       g_print ("%s ", device->name);
      
       for (i=0; i<device->num_axes; i++)
             g_print ("%g ", axes[i]);
       g_print ("\n");
     }
}
static gint
button_press_event (GtkWidget *widget, GdkEventButton *event)
{
   current_device = event->device;
   cursor_proximity = TRUE;
   if (event->button == 1 && pixmap != NULL)
     {
       gdouble pressure = 0.5;
       print_axes (event->device, event->axes);
       gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_PRESSURE, &pressure);
       draw_brush (widget, event->device->source, event->x, event->y, pressure);
      
       motion_time = event->time;
     }
   update_cursor (widget, event->x, event->y);
   return TRUE;
}
static gint
key_press_event (GtkWidget *widget, GdkEventKey *event)
{
   if ((event->keyval >= 0x20) && (event->keyval <= 0xFF))
     printf("I got a %c\n", event->keyval);
   else
     printf("I got some other key\n");
   return TRUE;
}
static gint
motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
{
   GdkTimeCoord **events;
   int n_events;
   int i;
   current_device = event->device;
   cursor_proximity = TRUE;
   if (event->state & GDK_BUTTON1_MASK && pixmap != NULL)
     {
       if (gdk_device_get_history (event->device, event->window, 
       motion_time, event->time,
       &events, &n_events))
{
    for (i=0; i<n_events; i++)
      {
        double x = 0, y = 0, pressure = 0.5;
        gdk_device_get_axis (event->device, events[i]->axes, GDK_AXIS_X, &x);
        gdk_device_get_axis (event->device, events[i]->axes, GDK_AXIS_Y, &y);
        gdk_device_get_axis (event->device, events[i]->axes, GDK_AXIS_PRESSURE, &pressure);
        draw_brush (widget,   event->device->source, x, y, pressure);
        print_axes (event->device, events[i]->axes);
      }
    gdk_device_free_history (events, n_events);
}
       else
{
    double pressure = 0.5;
    gdk_event_get_axis ((GdkEvent *)event, GDK_AXIS_PRESSURE, &pressure);
    draw_brush (widget,   event->device->source, event->x, event->y, pressure);
}
       motion_time = event->time;
     }
   if (event->is_hint)
     gdk_device_get_state (event->device, event->window, NULL, NULL);
   print_axes (event->device, event->axes);
   update_cursor (widget, event->x, event->y);
   return TRUE;
}
/* We track the next two events to know when we need to draw a
    cursor */
static gint
proximity_out_event (GtkWidget *widget, GdkEventProximity *event)
{
   cursor_proximity = FALSE;
   update_cursor (widget, cursor_x, cursor_y);
   return TRUE;
}
static gint
leave_notify_event (GtkWidget *widget, GdkEventCrossing *event)
{
   cursor_proximity = FALSE;
   update_cursor (widget, cursor_x, cursor_y);
   return TRUE;
}
void
input_dialog_destroy (GtkWidget *w, gpointer data)
{
   *((GtkWidget **)data) = NULL;
}
void
create_input_dialog (void)
{
   static GtkWidget *inputd = NULL;
   if (!inputd)
     {
       inputd = gtk_input_dialog_new ();
       g_signal_connect (inputd, "destroy",
            G_CALLBACK (input_dialog_destroy), &inputd);
       g_signal_connect_swapped (GTK_INPUT_DIALOG (inputd)->close_button,
            "clicked",
            G_CALLBACK (gtk_widget_hide),
            inputd);
       gtk_widget_hide (GTK_INPUT_DIALOG (inputd)->save_button);
       gtk_widget_show (inputd);
     }
   else
     {
       if (!GTK_WIDGET_MAPPED(inputd))
            gtk_widget_show(inputd);
       else
            gdk_window_raise(inputd->window);
     }
}
void
quit (void)
{
   gtk_main_quit ();
}
int
main (int argc, char *argv[])
{
   GtkWidget *window;
   GtkWidget *drawing_area;
   GtkWidget *vbox;
   GtkWidget *button;
   gtk_init (&argc, &argv);
   current_device = gdk_device_get_core_pointer ();
   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_widget_set_name (window, "Test Input");

      gtk_widget_set_size_request(window , 300 , 320);
      gtk_container_set_border_width(GTK_CONTAINER(window) , 2);
      gtk_window_set_resizable(GTK_WINDOW(window) , FALSE);

   vbox = gtk_vbox_new (FALSE, 0);
   gtk_container_add (GTK_CONTAINER (window), vbox);
   gtk_widget_show (vbox);
   g_signal_connect (window, "destroy",
       G_CALLBACK (quit), NULL);
   /* Create the drawing area */
   drawing_area = gtk_drawing_area_new ();
   gtk_widget_set_size_request (drawing_area, 200, 200);
   gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
   gtk_widget_show (drawing_area);
   /* Signals used to handle backing pixmap */
   g_signal_connect (drawing_area, "expose_event",
       G_CALLBACK (expose_event), NULL);
   g_signal_connect (drawing_area, "configure_event",
       G_CALLBACK (configure_event), NULL);
   /* Event signals */
   g_signal_connect (drawing_area, "motion_notify_event",
       G_CALLBACK (motion_notify_event), NULL);
   g_signal_connect (drawing_area, "button_press_event",
       G_CALLBACK (button_press_event), NULL);
   g_signal_connect (drawing_area, "key_press_event",
       G_CALLBACK (key_press_event), NULL);
   g_signal_connect (drawing_area, "leave_notify_event",
       G_CALLBACK (leave_notify_event), NULL);
   g_signal_connect (drawing_area, "proximity_out_event",
       G_CALLBACK (proximity_out_event), NULL);
   gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
     | GDK_LEAVE_NOTIFY_MASK
     | GDK_BUTTON_PRESS_MASK
     | GDK_KEY_PRESS_MASK
     | GDK_POINTER_MOTION_MASK
     | GDK_POINTER_MOTION_HINT_MASK
     | GDK_PROXIMITY_OUT_MASK);
   /* The following call enables tracking and processing of extension
      events for the drawing area */
   gtk_widget_set_extension_events (drawing_area, GDK_EXTENSION_EVENTS_ALL);
   GTK_WIDGET_SET_FLAGS (drawing_area, GTK_CAN_FOCUS);
   gtk_widget_grab_focus (drawing_area);
   /* .. And create some buttons */
   button = gtk_button_new_with_label ("Input Dialog");
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   g_signal_connect (button, "clicked",
       G_CALLBACK (create_input_dialog), NULL);
   gtk_widget_show (button);
   button = gtk_button_new_with_label ("Quit");
   gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
   g_signal_connect_swapped (button, "clicked",
        G_CALLBACK (gtk_widget_destroy),
        window);
   gtk_widget_show (button);
   gtk_widget_show (window);
   gtk_main ();
   return 0;
}

最后寄语

希望在座各位在学习的道路上越走越远,完成从入门到放弃的质的转变。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

©️2020 CSDN 皮肤主题: 酷酷鲨 设计师:CSDN官方博客 返回首页