GTK+ FAQ

转载 2011年01月11日 16:23:00
目录表
1.
总说明
1.1. 注意:本文档主要是关于GTK+1.2
1.2. 致谢
1.3. 作者
1.4. 什么是GTK+
1.5. GTK+中的+是什么意思?
1.6. GTK+, GDK和GLib中的G代表什么?
1.7. 那里可以找到GTK+的文档
1.8. 有没有关于GTK+的邮件列表(或者是邮件列表的压缩包) ?
1.9. GTK+如何获得帮助?
1.10. GTK+中如何报告bug?
1.11. GTK+有没有windows版本?
1.12. 哪些程序是用GTK+编成的 ?
1.13. 我想用GTK+编写一个程序,IRC(在线聊天系统)的客户端如何?
2. GTK+如何得到 配置 安装和查错
2.1. 运行GTK+需要安装什么
2.2. 那里可以得到GTK+
2.3. 如何配置/编译GTK+
2.4. 编译的时候出现错误 如:make: file `Makefile' line 456: Syntax erro
2.5. 我编译和安装了GTK+,但是不能将程序和它连接[GTK 2.x]
2.6. 当我安装GTK+的程序时,configure报告不能找到GTK.[GTK 2.x]
3. GTK+的开发和维护
3.1. 每个人都在 谈论的CVS是什么东西,怎样才能访问它?
3.2. 如何向GTK+投稿?
3.3. 如何知道我写的补丁是否被采用,如果没有,原因是什么?
3.4. 向库中添加新的控件的方针是什么?
3.5. 除了C之外,有人在绑定其他的语言吗?
4. 用GTK+开发:开始
4.1. 如何开始?
4.2. 如何用GTK+编写安全的/SUID/SGID敏感的程序?GTK+安全吗?听说的GTK_MODULES安 全漏洞是什么?
4.3. 我尝试编译一个小型的Hello World 程序,但是失败了,有什么线索? [GTK 2.x]
4.4. 怎样使用make 程序? [GTK 2.x]?
4.5. 我在make文件中使用了后置引用(backquote),但是我的make失败了.
4.6. 我想添加一些配置资料(configure stuff),应如何做?
4.7. 我尝试使用gdb来调试程序,但是当我执行到一些断点时,它挂起了我的X服务器(X server),怎么办?
5. 用GTK+开发:常规问题
5.1. GTK中有那些控件(widget)?
5.2. GTK+的线程安全吗?如何编写多线程GTK+程序?
5.3. 当在GTK+的app文件中使用fork()时,为什么会出现奇怪的 'x io error'错误?
5.4. 为什么当按钮按下时文本(contents)不移动?这里有一个补丁可以使它这样 .
5.5. 如何识别一个控件的最高层窗口(top level window)或者其他的祖先?
5.6. 如何得到一个GtkWindow窗口的ID(Window ID)?
5.7. 如何捕获一个双击(double click)事件(event)(例如在一个列表控件中)?
5.8. 顺便问一下,信号(signals)和事件(events)的区别是什么?
5.9. 传递给delete_event (或者其他事件)处理函数的数据被损坏.
5.10. 我将信号和所有事件都连接起来,但是看起来我并没有捕获它,什么原因?
5.11. 我要向GTK+控件中添加一个新的信号,怎么办?
5.12. 文本能否换行显示?
5.13. 如何设置窗口模式( modal)?/如何激活一个单一的窗口?
5.14. 为什么我的控件(例如 进度条)没有更新?
5.15. 如何向GTK+的对象/控件附加数据
5.16. 如何去掉附加在控件上的数据?
5.17. 如何重定控件的父窗口?
5.18. 如何得到控件的位置?
5.19. 如何设置控件/窗口的大小?如何才能禁止用户重新设置窗口的大小?
5.20. 如何向我的GTK+程序中添加一个弹出式菜单?
5.21. 如何禁止或使能一个控件,例如一个按钮?
5.22. 为什么gtk_clist*函数中的文本参数( text argument)不应被声明为const?
5.23. 如何在屏幕上显示象素(图像数据)?
5.24. 如何在不创建窗口或不显示窗口的情况下创建一个象素映射( pixmap)?
5.25. 如何拖放?
5.26. 为什么GTK+/GLib会泄漏内存?
6. GTK+开发: 控件专题
6.1.
在GtkList控件中如何找出选择项( selection)?
6.2. 在GtkCList控件中,当表内容滚动时,怎样避免标题消失?
6.3. 我不想让我的程序的用户在组合框(GtkCombo)中输入文本,怎么办?
6.4. 如何捕捉组合框( combo box)的改变?
6.5. 如何在菜单中定义分隔线( separation line)?
6.6. 如何向右对齐菜单,比如Help?
6.7. 如何在菜单项中添加带下滑线的加速键?
6.8. 如何从GtkMenuItem中重新找回文本?
6.9. 如何向右(或其他方向)对齐GtkLabel?
6.10. 如何给 GtkLabel控件设置背景颜色?
6.11. 如何使用 Resource 文件来给 GtkLabel设置颜色和字体?
6.12. 如何在 Resource 文件中配置工具提示( Tooltips)?
6.13. 无法在GtkEntry中输入大于2000(大约)个字符,什么原因?
6.14. 如何能在按下回车时使 GtkEntry控件激活?
6.15. 如何确认/限制/筛选GtkEntry中的输入?
6.16. 如何在GtkText控件中使用水平滚动条( horizontal scrollbars)?
6.17. 如何改变GtkText控件的字体?
6.18. 如何在GtkText控件中设定光标位置( cursor position )?
7. 关于 GDK
7.1.
什么是GDK?
7.2. 如何使用颜色分配?
8. 关于 GLib
8.1. 什么是GLib?
8.2. 如何使用双向链表(doubly linked lists)?
8.3. 当我释放分配的链表节点时,内存似乎没有被释放.
8.4. 为什么使用g_print, g_malloc, g_strdup和其他的glib函数?
8.5. 什么是扫描器(GScanner),如何使用?
9. GTK+ FAQ 投稿,维护者和版权(英文版)

第一章 总说明

目录表


1.7. 那里可以找到GTK+的文档?

那里可以找到GTK+的文档?

GTK+发布版本的doc/文件夹下面,你可以找到 GTK 和 GDK的参考资料,本FAQ和GTK指南.

另外,你可以通过下面的网址找到这个文件HTML版本 http://www.gtk.org/ ,打包的gtk指南,SGML, HTML, Postscript, DVI或text 的版本可以在下面找到ftp://ftp.gtk.org/pub/gtk/tutorial

这里还有一些有关GTK+, GDK and GNOME编程的书刊:


1.10. GTK+中如何报告bug?

GTK+中如何报告bug?

bug应该报告给GNOME的bug跟踪系统,(http://bugzilla.gnome.org/ )在你报告一个新的bug之前,你应该输入你的电子邮件地址,并且得到一个密码才能够进入该系统.

当你提交一个bug的时候有一些选项和文本需要你选择和填写.你给出越多的信息,就越容易把这个bug跟踪找到.你应该提交的有用的信息包括:

如何重现这个bug

如果你能够通过包含在gtk/子文件夹的测试程序来重现这个bug,那将是最方便的.否则请包含一个简短的测试程序能展现出它的行为.实在不行的话,你可以指出一个可以下载的软件中的测试点.

(如果在GIMP能够重现的bug在gtk的测试程序中是最容易发现的.如果你使用GIMP的时候发现了一个bug,请加上你使用的GIMP的版本号.)

  • 如果这个bug是一个会导致崩溃(crash),应该准确的记录该崩溃发生时的输出.

  • 更进一步的信息,比如堆栈跟踪(stack traces)可能会有用,但是并不是必须的.如果你送出一个堆栈跟踪(stack traces),并且这个错误是X错误,如果能在运行测试命令加上--sync选项产生,它将会很有用.


1.11. GTK+有没有windows版本?

GTK+有没有windows版本?

现在有一项正在进行的将 GTK+移植到windows平台的项目,取得了很大的进展.参阅

  http://www.iki.fi/tml/gimp/win32 .


1.12. 哪些程序是用GTK+编成的?

哪些程序是用GTK+编成的?

你可以在GTK+ 的网站上找到一个基于 GTK+ 的程序的列表,大约包含了350个程序. http://www.gtk.org/apps/ .

如果上面不行,那就到GNOME项目上领取一个工程,编写一个小游戏.写些有用的东西.http://www.gnome.org/ .

其中包括


1.13. 我想用GTK+编写一个程序,IRC(在线聊天系统)的客户端如何?

我想用GTK+编写一个程序,IRC(在线聊天系统)的客户端如何?

gtk-list找一些建议.现在至少有三个IRC的客户端软件正在开发.(更多信息参阅 http://www.forcix.cx/irc-clients.html ).

  • X-Chat.
  • girc. (Included with GNOME)
  • gsirc. (In the gnome CVS tree)

第二章 GTK+如何得到 配置 安装和查错

2.1. 运行GTK+需要安装什么

运行GTK+需要安装什么

编译GTK+,你只需要一个c编译器(gcc),一个X window系统和相关的库文件.


2.2. 那里可以得到GTK+

那里可以得到GTK+

官方网站 ftp://ftp.gtk.org/pub/gtk .

一般新的GTK+版本发布的时候,这个网站都很拥挤,所以你可以试试下面列表中的镜像网站. ftp://ftp.gtk.org/etc/mirrors

下面有一些镜像网站:


2.4. 编译的时候出现错误:make: file `Makefile' line 456: Syntax error [GTK 2.x]

编译的时候出现错误:make: file `Makefile' line 456: Syntax error [GTK 2.x]

确定你是否使用的是GNU make(用make -v 检查),现在有很多形形色色的make的版本,但是不是所有的都能正确的处理自动产生的make文件( Makefiles).


第三章 GTK+的开发和维护

3.1. 每个人都在谈论的CVS是什么东西,怎样采能访问它?

每个人都在谈论的CVS是什么东西,怎样采能访问它?

CVS叫协作版本系统(Concurrent Version System ),是一种非常流行的软件版本控制手段,它设计用来允许不同的开发者能够同时在相同的源树(source tree )上操作,源树(source tree )是集中维护的,但是每个开发者都有一个可以修改的本地镜像.

GTK+开发者使用CVS库来储存目前正在开发的版本号的拷贝.同样的,如果要捐献GTK+的补丁,你应该根据CVS版本号来生成.一般的用户应该使用打包的发布版本.

RedHat的站点上你能找到RPM格式的CVS工具包,下面的站点可以找到最新的版本.

  http://download.cyclic.com/pub/

任何 人都可以通过匿名登陆下载 最新版本的GTK+的CVS版本号,请使用下面的步骤:

  • 在类bourne的shell(例如 bash)中,输入:

    CVSROOT=':pserver:anonymous@anoncvs.gnome.org:/cvs/gnome'
    export CVSROOT

  • 然后,如果是第一次下载,需要登陆cvs:

    cvs login

  • 系统将要求你输入一个密码( password), cvs.gimp.org是没有密码的,所以只需输入回车即可.

  • 下载树(tree)并将它放在你目前的工作目录中,输入下面的命令: 

    cvs -z3 get gtk+

  • 注意:在GTK+1.1的树(tree)中,glib被放在另外一个单独的CVS组件中,所以如果没有,你需要下面的方法来得到它: 

    cvs -z3 get glib


3.5. 除了C外,有人在绑定其他的语言吗?

除了C外,有人在绑定其他的语言吗?

GTK+的主页上列出了GTK+的语言绑定( http://www.gtk.org/ ) :


第四章 . 用GTK+开发:开始

4.1. 如何开始?

如何开始 ?

你安装了GTK+之后,有一些东西可以让你轻松的使用GTK+来开发.在这里有一份GTK+指南: http://www.gtk.org/tutorial/ , 贯穿整个开发过程,它将会向你介绍如何用C语言来编写程序.

目前,这份指南没有包括GTK+中的所有控件(widget)的信息,所以,使用所有的GTK+控件的基本的功能的实例代码,你应该看GTK+发布中的gtk/testgtk.c文件(以及相关的源文件).看看这些例子可以给你一个良好的基础,了解这些控件都能干什么.


4.4. 怎样使用make程序? [GTK 2.x]

怎样使用make程序? [GTK 2.x]

下面是一个编译基于GTK+的程序的简单的make文件:

# basic GTK+ app makefile
SOURCES = myprg.c foo.c bar.c
OBJS = ${SOURCES:.c=.o}
CFLAGS = `pkg-config gtk+-2.0 --cflags`
LDADD = `pkg-config gtk+-2.0 --libs`
CC = gcc
PACKAGE = myprg

all : ${OBJS}
${CC} -o ${PACKAGE} ${OBJS} ${LDADD}

.c.o:
${CC} ${CFLAGS} -c $<

# end of file

 

了解更多的关于make程序的信息,应该阅读相关的手册页(man page)或者相关的信息文件(info file).


4.6. 我想添加一些配置资料(configure stuff),应如何做?

我想添加一些配置资料(configure stuff),应如何做?

使用 autoconf/automake,你首先应安装相关的包,分别是:

你可以在GUN的ftp主站 ( ftp://ftp.gnu.org/ )或任何一个镜像上找到这些包,

为了使用这个强大的 autoconf/automake工具,你必须先配置,如下:

dnl Process this file with autoconf to produce a configure script.
dnl configure.in for a GTK+ based program

AC_INIT(myprg.c)dnl
AM_INIT_AUTOMAKE(mypkgname,0.0.1)dnl
AM_CONFIG_HEADER(config.h)dnl

dnl Checks for programs.
AC_PROG_CC dnl check for the c compiler
dnl you should add CFLAGS="" here, 'cos it is set to -g by PROG_CC

dnl Checks for libraries.
AM_PATH_GTK(1.2.0,,AC_MSG_ERROR(mypkgname 0.1 needs GTK))dnl

AC_OUTPUT(
Makefile
)dnl

 必须添加一个 Makefile.am :

bin_PROGRAMS    = myprg
myprg_SOURCES = myprg.c foo.c bar.c
INCLUDES = @GTK_CFLAGS@
LDADD = @GTK_LIBS@
CLEANFILES = *~
DISTCLEANFILES = .deps/*.P

如果你的工程中包含不止一个的子文件夹,你应该在每个子文件夹中创建一个Makefile.am 加上一个主Makefile.am ,主Makefile.am 如下:

SUBDIRS         = mydir1 mydir2 mydir3

然后,来使用他们,输入:

aclocal
autoheader
autoconf
automake --add-missing --include-deps --foreign

了解更多的信息,你应该看autoconf和 automake的文档(附带的文档很容易理解,还有很多有关autoconf和automake的网上资源)


第五章 . 用GTK+开发: 常规问题

目录表
5.1. GTK中有那些控件(widget)?
5.2. GTK+的线程安全吗?如何编写多线程GTK+程序?
5.3. 当在GTK+的app文件中使用fork()时,为什么会出现奇怪的 'x io error'错误?
5.4. 为什么当按钮按下时文本(contents)不移动?这里有一个补丁可以使它这样 .
5.5. 如何识别一个控件的最高层窗口(top level window)或者其他的祖先?
5.6. 如何得到一个GtkWindow窗口的ID(Window ID)?
5.7. 如何捕获一个双击(double click)事件(event)(例如在一个列表控件中)?
5.8. 顺便问一下,信号(signals)和事件(events)的区别是什么?
5.9. 传递给delete_event (或者其他事件)处理函数的数据被损坏.
5.10. 我将信号和所有事件都连接起来,但是看起来我并没有捕获它,什么原因?
5.11. 我要向GTK+控件中添加一个新的信号,怎么办?
5.12. 文本能否换行显示?
5.13. 如何设置窗口模式( modal )?/如何激活一个单一的窗口?
5.14. 为什么我的控件(例如 进度条)没有更新?
5.15. 如何向GTK+的对象/控件附加数据
5.16. 如何去掉附加在控件上的数据?
5.17. 如何重定控件的父窗口?
5.18. 如何得到控件的位置?
5.19. 如何设置控件/窗口的大小?如何才能禁止用户重新设置窗口的大小?
5.20. 如何向我的GTK+程序中添加一个弹出式菜单?
5.21. 如何禁止或使能一个控件,例如一个按钮?
5.22. 为什么gtk_clist*函数中的文本参数(text argument)不应被声明为const?
5.23. 如何在屏幕上显示象素(图像数据)?
5.24. 如何在不创建窗口或不显示窗口的情况下创建一个象素映射(pixmap)?
5.25. 如何拖放?
5.26. 为什么GTK+/GLib会泄漏内存?

5.1.GTK中有那些控件(widget)?

GTK中有那些控件(widget)?

GTK+指南中列出了下面的控件:

  GtkObject
+GtkData
| +GtkAdjustment
| `GtkTooltips
`GtkWidget
+GtkContainer
| +GtkBin
| | +GtkAlignment
| | +GtkEventBox
| | +GtkFrame
| | | `GtkAspectFrame
| | +GtkHandleBox
| | +GtkItem
| | | +GtkListItem
| | | +GtkMenuItem
| | | | `GtkCheckMenuItem
| | | | `GtkRadioMenuItem
| | | `GtkTreeItem
| | +GtkViewport
| | `GtkWindow
| | +GtkColorSelectionDialog
| | +GtkDialog
| | | `GtkInputDialog
| | `GtkFileSelection
| +GtkBox
| | +GtkButtonBox
| | | +GtkHButtonBox
| | | `GtkVButtonBox
| | +GtkHBox
| | | +GtkCombo
| | | `GtkStatusbar
| | `GtkVBox
| | +GtkColorSelection
| | `GtkGammaCurve
| +GtkButton
| | +GtkOptionMenu
| | `GtkToggleButton
| | `GtkCheckButton
| | `GtkRadioButton
| +GtkCList
| `GtkCTree
| +GtkFixed
| +GtkList
| +GtkMenuShell
| | +GtkMenuBar
| | `GtkMenu
| +GtkNotebook
| +GtkPaned
| | +GtkHPaned
| | `GtkVPaned
| +GtkScrolledWindow
| +GtkTable
| +GtkToolbar
| `GtkTree
+GtkDrawingArea
| `GtkCurve
+GtkEditable
| +GtkEntry
| | `GtkSpinButton
| `GtkText
+GtkMisc
| +GtkArrow
| +GtkImage
| +GtkLabel
| | `GtkTipsQuery
| `GtkPixmap
+GtkPreview
+GtkProgressBar
+GtkRange
| +GtkScale
| | +GtkHScale
| | `GtkVScale
| `GtkScrollbar
| +GtkHScrollbar
| `GtkVScrollbar
+GtkRuler
| +GtkHRuler
| `GtkVRuler
`GtkSeparator
+GtkHSeparator
`GtkVSeparator

5.2. GTK+的线程安全吗?如何编写多线程GTK+程序?

GTK+的线程安全吗?如何编写多线程GTK+程序?

在执行其他的GLib 调用之前调用g_thread_init()可以使GLib库工作在线程安全模式(thread-safe mode)之下.在这种模式中,GLib将会根据需要自动的锁定所有内部数据结构(internal data structures),这并不是说两个线程可以同时访问.例如:一个单一的hash表(hash table),他们可以同时访问两个不同的hash表,如果两个不同的线程需要访问相同的hash表,程序将会锁定自身.

GLib被初始化为安全线程模式(thread-safe),GTK+能够"线程识别"(thread aware ),在执行任何的GDK调用之前,你必须通过调用gdk_threads_enter()获得一个单一全局锁定(single global lock),而后又调用gdk_threads_leave()释放.

一个最小的GTK+线程程序主函数看起来象下面这样:

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

g_thread_init(NULL);
gtk_init(&argc, &argv);

window = create_window();
gtk_widget_show(window);

gdk_threads_enter();
gtk_main();
gdk_threads_leave();

return(0);
}

回调信号需要引起主意,GTK+中的回调信号(信号(signals))在GTK+锁定(lock )的内部,但是GLib中的回调信号(超时,IO和系统空闲(timeouts, IO callbacks, and idle functions) )在GTK+锁定(lock)之外,所以,在一个信号处理函数(signal handler) 中你不需要调用gdk_threads_enter(),但是在其他类型的调用中,你需要调用gdk_threads_enter().

Erik Mouw 提供了下面的代码实例说明了如何在GTK+中使用线程:

/*-------------------------------------------------------------------------
* Filename: gtk-thread.c
* Version: 0.99.1
* Copyright: Copyright (C) 1999, Erik Mouw
* Author: Erik Mouw <J.A.K.Mouw@its.tudelft.nl>
* Description: GTK threads example.
* Created at: Sun Oct 17 21:27:09 1999
* Modified by: Erik Mouw <J.A.K.Mouw@its.tudelft.nl>
* Modified at: Sun Oct 24 17:21:41 1999
*-----------------------------------------------------------------------*/
/*
* Compile with:
*
* cc -o gtk-thread gtk-thread.c `pkg-config gtk+-2.0 --cflags --libs gthread`
*
* Thanks to Sebastian Wilhelmi and Owen Taylor for pointing out some
* bugs.
*
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <gtk/gtk.h>
#include <glib.h>
#include <pthread.h>

#define YES_IT_IS (1)
#define NO_IT_IS_NOT (0)

typedef struct
{
GtkWidget *label;
int what;
} yes_or_no_args;

G_LOCK_DEFINE_STATIC (yes_or_no);
static volatile int yes_or_no = YES_IT_IS;

void destroy(GtkWidget *widget, gpointer data)
{
gtk_main_quit();
}

void *argument_thread(void *args)
{
yes_or_no_args *data = (yes_or_no_args *)args;
gboolean say_something;

for(;;)
{
/* sleep a while */
sleep(rand() / (RAND_MAX / 3) + 1);

/* lock the yes_or_no_variable */
G_LOCK(yes_or_no);

/* do we have to say something? */
say_something = (yes_or_no != data->what);

if(say_something)
{
/* set the variable */
yes_or_no = data->what;
}

/* Unlock the yes_or_no variable */
G_UNLOCK(yes_or_no);

if(say_something)
{
/* get GTK thread lock */
gdk_threads_enter();

/* set label text */
if(data->what == YES_IT_IS)
gtk_label_set_text(GTK_LABEL(data->label), "O yes, it is!");
else
gtk_label_set_text(GTK_LABEL(data->label), "O no, it isn't!");

/* release GTK thread lock */
gdk_threads_leave();
}
}

return(NULL);
}

int main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *label;
yes_or_no_args yes_args, no_args;
pthread_t no_tid, yes_tid;

/* init threads */
g_thread_init(NULL);

/* init gtk */
gtk_init(&argc, &argv);

/* init random number generator */
srand((unsigned int)time(NULL));

/* create a window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

gtk_signal_connect(GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(destroy), NULL);

gtk_container_set_border_width(GTK_CONTAINER (window), 10);

/* create a label */
label = gtk_label_new("And now for something completely different ...");
gtk_container_add(GTK_CONTAINER(window), label);

/* show everything */
gtk_widget_show(label);
gtk_widget_show (window);

/* create the threads */
yes_args.label = label;
yes_args.what = YES_IT_IS;
pthread_create(&yes_tid, NULL, argument_thread, &yes_args);

no_args.label = label;
no_args.what = NO_IT_IS_NOT;
pthread_create(&no_tid, NULL, argument_thread, &no_args);

/* enter the GTK main loop */
gdk_threads_enter();
gtk_main();
gdk_threads_leave();

return(0);
}

5.3. 当在GTK+的app文件中使用fork()时,为什么会出现奇怪的'x io error'错误?

当在GTK+的app文件中使用fork()时,为什么会出现奇怪的'x io error'错误?

这实际上并不是GTK+的问题,而且也和fork() 没有关系,如果发生了'x io error',你可以使用exit() 函数来从子程序中退出.

当GDK打开了一个X显示,它创建了一个插座文件描述符(socket file descriptor),当你使用exit() 函数时,你默认的关闭了所有的打开文件描述符(open file descriptors).但是底层(underlying)的X库(X library)并不如此.

这里应该使用的函数是exit().

Erik Mouw贡献了这个代码实例来说明如何处理 fork()和exit().

/*-------------------------------------------------------------------------
* Filename: gtk-fork.c
* Version: 0.99.1
* Copyright: Copyright (C) 1999, Erik Mouw
* Author: Erik Mouw <J.A.K.Mouw@its.tudelft.nl>
* Description: GTK+ fork example
* Created at: Thu Sep 23 21:37:55 1999
* Modified by: Erik Mouw <J.A.K.Mouw@its.tudelft.nl>
* Modified at: Thu Sep 23 22:39:39 1999
*-----------------------------------------------------------------------*/
/*
* Compile with:
*
* cc -o gtk-fork gtk-fork.c `pkg-config gtk+-2.0 --cflags --libs`
*
*/

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <gtk/gtk.h>

void sigchld_handler(int num)
{
sigset_t set, oldset;
pid_t pid;
int status, exitstatus;

/* block other incoming SIGCHLD signals */
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_BLOCK, &set, &oldset);

/* wait for child */
while((pid = waitpid((pid_t)-1, &status, WNOHANG)) > 0)
{
if(WIFEXITED(status))
{
exitstatus = WEXITSTATUS(status);

fprintf(stderr,
"Parent: child exited, pid = %d, exit status = %d/n",
(int)pid, exitstatus);
}
else if(WIFSIGNALED(status))
{
exitstatus = WTERMSIG(status);

fprintf(stderr,
"Parent: child terminated by signal %d, pid = %d/n",
exitstatus, (int)pid);
}
else if(WIFSTOPPED(status))
{
exitstatus = WSTOPSIG(status);

fprintf(stderr,
"Parent: child stopped by signal %d, pid = %d/n",
exitstatus, (int)pid);
}
else
{
fprintf(stderr,
"Parent: child exited magically, pid = %d/n",
(int)pid);
}
}

/* re-install the signal handler (some systems need this) */
signal(SIGCHLD, sigchld_handler);

/* and unblock it */
sigemptyset(&set);
sigaddset(&set, SIGCHLD);
sigprocmask(SIG_UNBLOCK, &set, &oldset);
}

gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
{
return(FALSE);
}

void destroy(GtkWidget *widget, gpointer data)
{
gtk_main_quit();
}

void fork_me(GtkWidget *widget, gpointer data)
{
pid_t pid;

pid = fork();

if(pid == -1)
{
/* ouch, fork() failed */
perror("fork");
exit(-1);
}
else if(pid == 0)
{
/* child */
fprintf(stderr, "Child: pid = %d/n", (int)getpid());

execlp("ls", "ls", "-CF", "/", NULL);

/* if exec() returns, there is something wrong */
perror("execlp");

/* exit child. note the use of _exit() instead of exit() */
_exit(-1);
}
else
{
/* parent */
fprintf(stderr, "Parent: forked a child with pid = %d/n", (int)pid);
}
}

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

gtk_init(&argc, &argv);

/* the basic stuff: make a window and set callbacks for destroy and
* delete events
*/
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

gtk_signal_connect(GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC(delete_event), NULL);

gtk_signal_connect(GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(destroy), NULL);

#if (GTK_MAJOR_VERSION == 1) && (GTK_MINOR_VERSION == 0)
gtk_container_border_width(GTK_CONTAINER (window), 10);
#else
gtk_container_set_border_width(GTK_CONTAINER (window), 10);
#endif

/* add a button to do something usefull */
button = gtk_button_new_with_label("Fork me!");

gtk_signal_connect(GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(fork_me), NULL);

gtk_container_add(GTK_CONTAINER(window), button);

/* show everything */
gtk_widget_show (button);
gtk_widget_show (window);


/* install a signal handler for SIGCHLD signals */
signal(SIGCHLD, sigchld_handler);


/* main loop */
gtk_main ();

exit(0);
}

5.7.如何捕获一个双击(double click)事件(event)(例如在一个列表控件中)?

如何捕获一个双击(double click)事件(event)(例如在一个列表控件中)?

Tim Janik在gtk邮件列表(gtk-list)上写道(稍做修改): 

定义一个信号处理函数:

gint
signal_handler_event(GtkWidget *widget, GdkEventButton *event, gpointer func_data)
{
if (GTK_IS_LIST_ITEM(widget) &&
(event->type==GDK_2BUTTON_PRESS ||
event->type==GDK_3BUTTON_PRESS) ) {
printf("I feel %s clicked on button %d/n",
event->type==GDK_2BUTTON_PRESS ? "double" : "triple",
event->button);
}

return FALSE;
}

将函数和你的控件连接:

{
/* list, list item init stuff */

gtk_signal_connect(GTK_OBJECT(list_item),
"button_press_event",
GTK_SIGNAL_FUNC(signal_handler_event),
NULL);

/* and/or */

gtk_signal_connect(GTK_OBJECT(list_item),
"button_release_event",
GTK_SIGNAL_FUNC(signal_handler_event),
NULL);

/* something else */
}

Owen Taylor 写道:

"注意:一个单击的信号将在之前被受到,如果你双击一个按钮,将会在之前收到一个单击("clicked")的信号(任何的工具都是这样,因为电脑无法读懂你的思想.)

 


5.8. 顺便问一下,信号(signals)和事件(events)的区别是什么?

顺便问一下,信号(signals)和事件(events)的区别是什么?

首先,Havoc Pennington在他的免费书(这里 http://www106.pair.com/rhp/sample_chapters.html )中对事件和信号的区别给出了一个完整的描述.

此外,Havoc在邮件列表上写道:事件Events是从X server收到的消息流.他们驱动着Gtk的主循环,"等待事件,然后处理它".(这还不太准确,它实际更加的复杂,它可以同时等待多个不同的输入流).事件(Event)是一个Gdk/Xlib概念.

"信号是GtkObject和它的子集 (subclasses)的特性,他们和任何的输入流都没有关系.实际上,信号只是保持了一个回调函数列表,然后调用回调函数(就是发出信号),当然,还 有很多其他的细节和特性.信号是对象(object)发出的,和Gtk的主循环一点关系都没有.按照常规,信号一般在对象"发生了一些改变"的时候发出.

"信号(Signals)和事件(events)有关是因 为GTK控件(GtkWidget)通常收到一个事件的时候发出一个信号.这纯粹是为了方便,所以你可以在控件收到一个事件的时候调用一个回调函数.当你 按下一个按钮的时候会发出一个信号,所以才让人认为信号和事件有天生的联系.

 


5.20. 如何向我的GTK+程序中添加一个弹出式菜单?

如何向我的GTK+程序中添加一个弹出式菜单?

GTK+ distribution发布中的examples/menu 目录下面,通过下面的技巧实现了一个弹出式菜单:

static gint button_press (GtkWidget *widget, GdkEvent *event)
{

if (event->type == GDK_BUTTON_PRESS) {
GdkEventButton *bevent = (GdkEventButton *) event;
gtk_menu_popup (GTK_MENU(widget), NULL, NULL, NULL, NULL,
bevent->button, bevent->time);
/* Tell calling code that we have handled this event; the buck
* stops here. */
return TRUE;
}

/* Tell calling code that we have not handled this event; pass it on. */
return FALSE;
}

5.24. 如何在不创建窗口或不显示窗口的情况下创建一个象素映射(pixmap)?

如何在不创建窗口或不显示窗口的情况下创建一个象素映射(pixmap)?

gdk_pixmap_create_from_xpm()这样的函数需要一个空的窗口作为参数,在一个程序的初始化阶段,窗口没有显示,空的窗口就不可用,这会导致一些问题.为了避免这样的问题, gdk_pixmap_colormap_create_from_xpm可以派上用场,象这样:

  char *pixfile = "foo.xpm";
GtkWidget *top, *box, *pixw;
GdkPixmap *pixmap, *pixmap_mask;

top = gtk_window_new (GKT_WINDOW_TOPLEVEL);
box = gtk_hbox_new (FALSE, 4);
gtk_conainer_add (GTK_CONTAINER(top), box);

pixmap = gdk_pixmap_colormap_create_from_xpm (
NULL, gtk_widget_get_colormap(top),
&pixmap_mask, NULL, pixfile);
pixw = gtk_pixmap_new (pixmap, pixmap_mask);
gdk_pixmap_unref (pixmap);
gdk_pixmap_unref (pixmap_mask);

第六章:用GTK+开发:控件专题

6.1. 在GtkList控件中如何找出选择项(selection)?

在GtkList控件中如何找出选择项(selection)?

这样可以得到选择项:

GList *sel;
sel = GTK_LIST(list)->selection;

这是GList如何定义的(引用自glist.h)

typedef struct _GList GList;

struct _GList
{
gpointer data;
GList *next;
GList *prev;
};

一个GList结构是一个用于双向链表(doubly linked list)的简单结构体.在glib.h有几个g_list_*()这样的函数来修改链表.但是GTK_LIST(MyGtkList)->selection是由gtk_list_*()函数维护的,而且不应被修改.

GtkList的选择模式(selection_mode)决定了一个GtkList控件的选择功能,所以也决定了GTK_LIST(AnyGtkList)->selection:

selection_mode GTK_LIST()->selection contents
GTK_SELECTION_SINGLE selection is either NULL or contains a GList* pointer for a single selected item.
GTK_SELECTION_BROWSE selection is NULL if the list contains no widgets, otherwise it contains a GList* pointer for one GList structure.
GTK_SELECTION_MULTIPLE selection is NULL if no listitems are selected or a a GList* pointer for the first selected item. that in turn points to a GList structure for the second selected item and so on.
GTK_SELECTION_EXTENDED selection is NULL.

GList 结构体中数据域(data field) GTK_LIST(MyGtkList)->selection指向第一个被选择的列表条目(GtkListItem),所以,如果你想知道那个列表条目被选中,你应该这样做:

 

{
gchar *list_items[]={
"Item0",
"Item1",
"foo",
"last Item",
};
guint nlist_items=sizeof(list_items)/sizeof(list_items[0]);
GtkWidget *list_item;
guint i;

list=gtk_list_new();
gtk_list_set_selection_mode(GTK_LIST(list), GTK_SELECTION_MULTIPLE);
gtk_container_add(GTK_CONTAINER(AnyGtkContainer), list);
gtk_widget_show (list);

for (i = 0; i < nlist_items; i++)
{
list_item=gtk_list_item_new_with_label(list_items[i]);
gtk_object_set_user_data(GTK_OBJECT(list_item), (gpointer)i);
gtk_container_add(GTK_CONTAINER(list), list_item);
gtk_widget_show(list_item);
}
}

得到选择项:

{
GList *items;

items=GTK_LIST(list)->selection;

printf("Selected Items: ");
while (items) {
if (GTK_IS_LIST_ITEM(items->data))
printf("%d ", (guint)
gtk_object_get_user_data(items->data));
items=items->next;
}
printf("/n");
}

6.5. 如何在菜单中定义分隔线(separation line)?

如何在菜单中定义分隔线(separation line)?

参看 Tutorial 关于如何创建菜单.创建分隔线只需要创建一个空的菜单项:

menuitem = gtk_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_show(menuitem);

6.7. 如何在菜单项中添加带下滑线的加速键?

如何在菜单项中添加带下滑线的加速键?

Damon Chaplin-- Glade项目的技术中坚,提供了下面的代码例子(这个代码是Glade输出的):它的File 中只定义了一个选项(New ),File 中的F和New 中的N都加了下划线,并创建了相关的加速键.

  menubar1 = gtk_menu_bar_new ();
gtk_object_set_data (GTK_OBJECT (window1), "menubar1", menubar1);
gtk_widget_show (menubar1);
gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0);

file1 = gtk_menu_item_new_with_label ("");
tmp_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (file1)->child),
_("_File"));
gtk_widget_add_accelerator (file1, "activate_item", accel_group,
tmp_key, GDK_MOD1_MASK, 0);
gtk_object_set_data (GTK_OBJECT (window1), "file1", file1);
gtk_widget_show (file1);
gtk_container_add (GTK_CONTAINER (menubar1), file1);

file1_menu = gtk_menu_new ();
file1_menu_accels = gtk_menu_ensure_uline_accel_group (GTK_MENU (file1_menu));
gtk_object_set_data (GTK_OBJECT (window1), "file1_menu", file1_menu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (file1), file1_menu);

new1 = gtk_menu_item_new_with_label ("");
tmp_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (new1)->child),
_("_New"));
gtk_widget_add_accelerator (new1, "activate_item", file1_menu_accels,
tmp_key, 0, 0);
gtk_object_set_data (GTK_OBJECT (window1), "new1", new1);
gtk_widget_show (new1);
gtk_container_add (GTK_CONTAINER (file1_menu), new1);

6.8. 如何从GtkMenuItem中重新找回文本?

如何从GtkMenuItem中重新找回文本?

你可以这样从一个特定的GtkMenuItem中重新得到标签.

    if (GTK_BIN (menu_item)->child)
{
GtkWidget *child = GTK_BIN (menu_item)->child;

/* do stuff with child */
if (GTK_IS_LABEL (child))
{
gchar *text;

gtk_label_get (GTK_LABEL (child), &text);
g_print ("menu item text: %s/n", text);
}
}

从一个GtkOptionMenu中得到活动的菜单选项:

if (GTK_OPTION_MENU (option_menu)->menu_item)
{
GtkWidget *menu_item = GTK_OPTION_MENU (option_menu)->menu_item;
}

但是,这里有一个例外,在这种特殊的情况下,你不能用上面的代码从menu_item 中得到标签控件.因为选项菜单(option menu)临时调整了菜单选项和子菜单的层次关系来显示当前活动的条目.所以你想得到一个选项菜单(option menu)当前活动的菜单选项的子菜单,应这样做:

    if (GTK_BIN (option_menu)->child)
{
GtkWidget *child = GTK_BIN (option_menu)->child;

/* do stuff with child */
}

6.9. 如何向右(或其他方向)对齐GtkLabel?

如何向右(或其他方向)对齐GtkLabel?

你确定你要调整 标签?菜单类提供了gtk_label_set_justify() 函数来对一个多行的标签进行调整

最重要的是设置对齐方式(alignment ),比如:向右对齐,居中或者向左对齐,如果你想调整它,你应该这样做:

void gtk_misc_set_alignment (GtkMisc *misc,
gfloat xalign,
gfloat yalign);

xalignyalign 的值为[0.00;1.00]之间的一个浮点数.

GtkWidget       *label;

/* horizontal : left align, vertical : top */
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.0f);

/* horizontal : centered, vertical : centered */
gtk_misc_set_alignment(GTK_MISC(label), 0.5f, 0.5f);

/* horizontal : right align, vertical : bottom */
gtk_misc_set_alignment(GTK_MISC(label), 1.0f, 1.0f);

6.13. 无法在GtkEntry中输入大于2000(大约)个字符,什么原因?

无法在GtkEntry中输入大于2000(大约)个字符,什么原因?

GtkEntry 控件中有一个大家都知道的问题,在gtk_entry_insert_text() 函数中,下面的程序段将字符的数量限制为2047.

  /* The algorithms here will work as long as, the text size (a
* multiple of 2), fits into a guint16 but we specify a shorter
* maximum length so that if the user pastes a very long text, there
* is not a long hang from the slow X_LOCALE functions. */

if (entry->text_max_length == 0)
max_length = 2047;
else
max_length = MIN (2047, entry->text_max_length);

6.15. 如何确认/限制/筛选GtkEntry中的输入?

如何确认/限制/筛选GtkEntry中的输入?

如果你想确认用户在GtkEntry控件中输入的文本,你可以连接"insert_text"信号,在回调函数中修改文本.下面的代码要求所有的字符为大写,并且字符的范围为A-Z,注意:当GtkEntry定义时,entry被转换成了GtkEditable类型的一个对象,

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

void insert_text_handler (GtkEntry *entry,
const gchar *text,
gint length,
gint *position,
gpointer data)
{
GtkEditable *editable = GTK_EDITABLE(entry);
int i, count=0;
gchar *result = g_new (gchar, length);

for (i=0; i < length; i++) {
if (!isalpha(text[i]))
continue;
result[count++] = islower(text[i]) ? toupper(text[i]) : text[i];
}

if (count > 0) {
gtk_signal_handler_block_by_func (GTK_OBJECT (editable),
GTK_SIGNAL_FUNC (insert_text_handler),
data);
gtk_editable_insert_text (editable, result, count, position);
gtk_signal_handler_unblock_by_func (GTK_OBJECT (editable),
GTK_SIGNAL_FUNC (insert_text_handler),
data);
}
gtk_signal_emit_stop_by_name (GTK_OBJECT (editable), "insert_text");

g_free (result);
}

int main (int argc,
char *argv[])
{
GtkWidget *window;
GtkWidget *entry;

gtk_init (&argc, &argv);

/* create a new window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (window), "GTK Entry");
gtk_signal_connect(GTK_OBJECT (window), "delete_event",
(GtkSignalFunc) gtk_exit, NULL);

entry = gtk_entry_new();
gtk_signal_connect(GTK_OBJECT(entry), "insert_text",
GTK_SIGNAL_FUNC(insert_text_handler),
NULL);
gtk_container_add(GTK_CONTAINER (window), entry);
gtk_widget_show(entry);

gtk_widget_show(window);

gtk_main();
return(0);
}

6.18. 如何在GtkText控件中设定光标位置(cursor position)?

如何在GtkText控件中设定光标位置(cursor position)?

注意:下面的回答对所有的从GtkEditable类中继承的对象都是有效的.

确信你要移动光标的位置?很多时候,当光标的位置合适时,插入点并不对应光标的位置.如果这正是你想要的效果,你应该使用gtk_text_set_point() 函数,如果你想在光标的位置设置插入点,这样做:

  gtk_text_set_point(GTK_TEXT(text),
gtk_editable_get_position(GTK_EDITABLE(text)));

如果你想插入点一直都跟随着光标,你应该捕获按钮按下事件(button press event ),然后移动插入点.小心:当控件改变光标的位置之后,你必须捕获这个事件. 建议使用下面的代码:

static void
insert_bar (GtkWidget *text)
{
/* jump to cursor mark */
gtk_text_set_point (GTK_TEXT (text),
gtk_editable_get_position (GTK_EDITABLE (text)));

gtk_text_insert (GTK_TEXT (text), NULL, NULL, NULL,
"bar", strlen ("bar"));
}

int
main (int argc, char *argv[])
{
GtkWidget *window, *text;

gtk_init (&argc, &argv);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
text = gtk_text_new (NULL, NULL);
gtk_text_set_editable (GTK_TEXT (text), TRUE);
gtk_container_add (GTK_CONTAINER (window), text);

/* connect after everything else */
gtk_signal_connect_after (GTK_OBJECT(text), "button_press_event",
GTK_SIGNAL_FUNC (insert_bar), NULL);

gtk_widget_show_all(window);
gtk_main();

return 0;
}

now,如果你想改变光标的位置,你应该可以使用gtk_editable_set_position() 函数了.

 


第七章 关于GDK


7.2. 如何使用颜色分配?

如何使用颜色分配?

有关GDK的一个很好的特性是它建立在Xlib之上,但这也是一个问题,特别是在颜色管理方面,如果你想在程序中使用颜色(例如画一个矩形等),你的代码可能象这样:

{
GdkColor *color;
int width, height;
GtkWidget *widget;
GdkGC *gc;

...

/* first, create a GC to draw on */
gc = gdk_gc_new(widget->window);

/* find proper dimensions for rectangle */
gdk_window_get_size(widget->window, &width, &height);

/* the color we want to use */
color = (GdkColor *)malloc(sizeof(GdkColor));

/* red, green, and blue are passed values, indicating the RGB triple
* of the color we want to draw. Note that the values of the RGB components
* within the GdkColor are taken from 0 to 65535, not 0 to 255.
*/
color->red = red * (65535/255);
color->green = green * (65535/255);
color->blue = blue * (65535/255);

/* the pixel value indicates the index in the colormap of the color.
* it is simply a combination of the RGB values we set earlier
*/
color->pixel = (gulong)(red*65536 + green*256 + blue);

/* However, the pixel valule is only truly valid on 24-bit (TrueColor)
* displays. Therefore, this call is required so that GDK and X can
* give us the closest color available in the colormap
*/
gdk_color_alloc(gtk_widget_get_colormap(widget), color);

/* set the foreground to our color */
gdk_gc_set_foreground(gc, color);

/* draw the rectangle */
gdk_draw_rectangle(widget->window, gc, 1, 0, 0, width, height);

...
}

第八章 关于GLib


8.2. 如何使用双向链表( doubly linked lists)?

如何使用双向链表( doubly linked lists)?

GList对象是这样定义的:

typedef struct _GList GList;

struct _GList
{
gpointer data;
GList *next;
GList *prev;
};

使用GList对象,只需:

GList   *list = NULL;
GList *listrunner;
gint array[] = { 1, 2, 3, 4, 5, 6 };
gint pos;
gint *value;

/* add data to the list */
for (pos=0;pos < sizeof array; pos++) {
list = g_list_append(list, (gpointer)&array[pos]);
}

/* run through the list */
listrunner = g_list_first(list);
while (listrunner) {
value = (gint *)listrunner->data;
printf("%d/n", *value);
listrunner = g_list_next(listrunner);
}

/* removing datas from the list */
listrunner = g_list_first(list);
list = g_list_remove_link(list, listrunner);
list = g_list_remove(list, &array[4]);

对单向链表(GSList 对象) 上面的代码也适用,只需用相应的g_slist_*函数(g_slist_append, g_slist_remove, ...)来代替g_list_*函数.请记住:单向链表中不能反向( go backward ),这里没有g_slist_first函数,你应该保留一个链表第一个节点的引用( reference ).

 


8.3. 当我释放分配的链表节点时,内存似乎没有被释放.

当我释放分配的链表节点时,内存似乎没有被释放.

在这个特殊的问题上,GLib努力的显得"智能化":它假设你将再次使用这个对象,所以分缓冲分配了的内存.如果你不想使用这个功能,你应该使用一个特殊的allocator.

引用自Tim Janik:

"如果你某些 部分的代码使用了很多GLists和GNodes,然后全部的释放他们,使用GAllocator.将一个allocator压入一个双向链表 (g_list)中,将会导致所有后来的对双向链表(glist)的操作对allocator来说都是私有的(private)(所以你必须在做任何的外 部调用之前小心的将allocator弹出,)

GAllocator *allocator;
GList *list = NULL;
guint i;

/* set a new allocation pool for GList nodes */
allocator = g_allocator_new ("list heap", 1024);
g_list_push_allocator (allocator);

/* do some list operations */
for (i = 0; i < 4096; i++)
list = g_list_prepend (list, NULL);
list = g_list_reverse (list);

/* beware to pop allocator befor calling external functions */
g_list_pop_allocator ();
gtk_label_set_text (GTK_LABEL (some_label), "some text");

/* and set our private glist pool again */
g_list_push_allocator (allocator);

/* do some list operations */
g_list_free (list);
list = NULL;
for (i = 0; i < 4096; i++)
list = g_list_prepend (list, NULL);

/* and back out (while freeing all of the list nodes in our pool) */
g_list_pop_allocator ();
g_allocator_free (allocator);

8.5. 什么是扫描器(GScanner),如何使用?

什么是扫描器(GScanner),如何使用?

一个扫描器(GScanner )能够符号化(tokenize )文本.就是说:它将会对输入流中的每一个字符和数字返回一个整数(integer ),当然是根据一定的规则(可由客户定制)来实现这种转换.但是你还是需要根据自己的需要来编写分析函数(parsing functions ).

这是由Tim Janik提供的一个小测试程序,将会这样符号化:

<SYMBOL> = <OPTIONAL-MINUS> <NUMBER> ;

跳过 "#/n" 和"/**/" 形式的注释.

#include <glib.h>

/* some test text to be fed into the scanner */
static const gchar *test_text =
( "ping = 5;/n"
"/* slide in some /n"
" * comments, just for the/n"
" * fun of it /n"
" *//n"
"pong = -6; /n"
"/n"
"# the next value is a float/n"
"zonk = 0.7;/n"
"# redefine ping/n"
"ping = - 0.5;/n" );

/* define enumeration values to be returned for specific symbols */
enum {
SYMBOL_PING = G_TOKEN_LAST + 1,
SYMBOL_PONG = G_TOKEN_LAST + 2,
SYMBOL_ZONK = G_TOKEN_LAST + 3
};

/* symbol array */
static const struct {
gchar *symbol_name;
guint symbol_token;
} symbols[] = {
{ "ping", SYMBOL_PING, },
{ "pong", SYMBOL_PONG, },
{ "zonk", SYMBOL_ZONK, },
{ NULL, 0, },
}, *symbol_p = symbols;

static gfloat ping = 0;
static gfloat pong = 0;
static gfloat zonk = 0;

static guint
parse_symbol (GScanner *scanner)
{
guint symbol;
gboolean negate = FALSE;

/* expect a valid symbol */
g_scanner_get_next_token (scanner);
symbol = scanner->token;
if (symbol < SYMBOL_PING ||
symbol > SYMBOL_ZONK)
return G_TOKEN_SYMBOL;

/* expect '=' */
g_scanner_get_next_token (scanner);
if (scanner->token != '=')
return '=';

/* feature optional '-' */
g_scanner_peek_next_token (scanner);
if (scanner->next_token == '-')
{
g_scanner_get_next_token (scanner);
negate = !negate;
}

/* expect a float (ints are converted to floats on the fly) */
g_scanner_get_next_token (scanner);
if (scanner->token != G_TOKEN_FLOAT)
return G_TOKEN_FLOAT;

/* make sure the next token is a ';' */
if (g_scanner_peek_next_token (scanner) != ';')
{
/* not so, eat up the non-semicolon and error out */
g_scanner_get_next_token (scanner);
return ';';
}

/* assign value, eat the semicolon and exit successfully */
switch (symbol)
{
case SYMBOL_PING:
ping = negate ? - scanner->value.v_float : scanner->value.v_float;
break;
case SYMBOL_PONG:
pong = negate ? - scanner->value.v_float : scanner->value.v_float;
break;
case SYMBOL_ZONK:
zonk = negate ? - scanner->value.v_float : scanner->value.v_float;
break;
}
g_scanner_get_next_token (scanner);

return G_TOKEN_NONE;
}

int
main (int argc, char *argv[])
{
GScanner *scanner;
guint expected_token;

scanner = g_scanner_new (NULL);

/* adjust lexing behaviour to suit our needs
*/
/* convert non-floats (octal values, hex values...) to G_TOKEN_INT */
scanner->config->numbers_2_int = TRUE;
/* convert G_TOKEN_INT to G_TOKEN_FLOAT */
scanner->config->int_2_float = TRUE;
/* don't return G_TOKEN_SYMBOL, but the symbol's value */
scanner->config->symbol_2_token = TRUE;

/* load symbols into the scanner */
while (symbol_p->symbol_name)
{
g_scanner_add_symbol (scanner,
symbol_p->symbol_name,
GINT_TO_POINTER (symbol_p->symbol_token));
symbol_p++;
}

/* feed in the text */
g_scanner_input_text (scanner, test_text, strlen (test_text));

/* give the error handler an idea on how the input is named */
scanner->input_name = "test text";

/* scanning loop, we parse the input until its end is reached,
* the scanner encountered a lexing error, or our sub routine came
* across invalid syntax
*/
do
{
expected_token = parse_symbol (scanner);

g_scanner_peek_next_token (scanner);
}
while (expected_token == G_TOKEN_NONE &&
scanner->next_token != G_TOKEN_EOF &&
scanner->next_token != G_TOKEN_ERROR);

/* give an error message upon syntax errors */
if (expected_token != G_TOKEN_NONE)
g_scanner_unexp_token (scanner, expected_token, NULL, "symbol", NULL, NULL, TRUE);

/* finsish parsing */
g_scanner_destroy (scanner);

/* print results */
g_print ("ping: %f/n", ping);
g_print ("pong: %f/n", pong);
g_print ("zonk: %f/n", zonk);

return 0;
}

你需要理解扫描器将会分析输入然后符号化,取决于你如何翻译这些符号,在被分析之前请不要定义它们的类型.例如分析一个字符串:

"hi i am 17"
| | | |
| | | v
| | v TOKEN_INT, value: 17
| v TOKEN_IDENTIFIER, value: "am"
v TOKEN_CHAR, value: 'i'
TOKEN_IDENTIFIER, value: "hi"

如果你这样配置扫描器:

scanner->config->int_2_float = TRUE;
scanner->config->char_2_token = TRUE;
scanner->config->scan_symbols = TRUE;

然后将"am"作为一个符号加入:

g_scanner_add_symbol (scanner, "am", "symbol value");

扫描器将会这样分析:

"hi i am 17"
| | | |
| | | v
| | v TOKEN_FLOAT, value: 17.0 (automatic int->float conversion)
| | TOKEN_SYMBOL, value: "symbol value" (a successfull hash table lookup
| | turned a TOKEN_IDENTIFIER into a
| | TOKEN_SYMBOL and took over the
| v  symbol's value)
v 'i' ('i' can be a valid token as well, as all chars >0 and <256)
TOKEN_IDENTIFIER, value: "hi"

你需要自己编程来匹配这些符号序列(token sequence ),如果你遇到一些不想要的东西,可以作为错误输出:

/* expect an identifier ("hi") */
g_scanner_get_next_token (scanner);
if (scanner->token != G_TOKEN_IDENTIFIER)
return G_TOKEN_IDENTIFIER;
/* expect a token 'i' */
g_scanner_get_next_token (scanner);
if (scanner->token != 'i')
return 'i';
/* expect a symbol ("am") */
g_scanner_get_next_token (scanner);
if (scanner->token != G_TOKEN_SYMBOL)
return G_TOKEN_SYMBOL;
/* expect a float (17.0) */
g_scanner_get_next_token (scanner);
if (scanner->token != G_TOKEN_FLOAT)
return G_TOKEN_FLOAT;

如果你这样做,可以分析"hi i am 17","dooh i am 42"和 "bah i am 0.75"也能接受,但是"hi 7 am 17"和 "hi i hi 17"就不能接受.

 


第九章 GTK+ FAQ 投稿,维护者和版权

    如果你想向FAQ投稿,请向我们其中之一发一封电子邮件.准确的写上内容(问题和回答),有了你的努力,这份文档会变得更加的有用.
    这份文档由这些人维护: Tony Gale mailto:gale@gtk.org Nathan Froyd mailto:maestrox@geocities.com , 和 Emmanuel Deloget mailto:logout@free.fr . 这份FAQ 由Shawn T. Amundson mailto:amundson@gimp.org 编写并继续提供支持. 投稿应该寄到 Tony Gale mailto:gale@gtk.org .

The GTK+ FAQ is Copyright (C) 1997-2000 by Shawn T. Amundson, Tony Gale, Emmanuel Deloget and Nathan Froyd.

Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.

Permission is granted to copy and distribute modified versions of this document under the conditions for verbatim copying, provided that this copyright notice is included exactly as in the original, and that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this document into another language, under the above conditions for modified versions.

If you are intending to incorporate this document into a published work, please contact one of the maintainers, and we will make an effort to ensure that you have the most up to date information available.

There is no guarentee that this document lives up to its intended purpose. This is simply provided as a free resource. As such, the authors and maintainers of the information provided within can not make any guarentee that the information is even accurate.

 
 

OpenSceneGraph FAQ

  • 2017年11月22日 10:53
  • 41KB
  • 下载

Wrodpress安装、使用及FAQ功能定制

  • 2014年10月12日 11:41
  • 1.22MB
  • 下载

[FAQ17700]cct2.0 常见问题总结

反馈issue请提交log: cct2.0安装路径下的CCT_Debug.log。操作cct时的kernel log 和android log。   Case1. 点击cct.exe...

android bsp faq

  • 2014年02月16日 03:27
  • 1.44MB
  • 下载

R-FAQ文档 135分钟学会R

  • 2013年11月03日 10:19
  • 370KB
  • 下载

C++11 FAQ中文版:类成员的内部初始化

三1 Year 2011陈 良乔C++11 FAQ 类内部成员的初始化 在C++98标准里,只有static const声明的整型成员能在类内部初始化,并且初始化值必须是常量表达式。这些限制...
  • fjb2080
  • fjb2080
  • 2012年05月02日 11:34
  • 7089

autocad_pdf_install_faq_chs.pdf )

  • 2013年10月21日 12:01
  • 636KB
  • 下载

业务框架应用FAQ

  • 2015年03月26日 08:47
  • 1005KB
  • 下载

[MySQL FAQ]系列 — 线上环境到底要不要开启query cache

Query Cache(查询缓存,以下简称QC)存储SELECT语句及其产生的数据结果,特别适用于:频繁提交同一个语句,并且该表数据变化不是很频繁的场景,例如一些静态页面,或者页面中的某块不经常发...

报表应用-报表FAQ-多余空白页

  • 2015年10月09日 10:43
  • 462KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章: GTK+ FAQ
举报原因:
原因补充:

(最多只允许输入30个字)