리눅스 기타 자료

제목	gtk 강좌 #1 1998/07/10 (17:25)
이름	김효원
번호	84
조회	264
본문	『리눅스 학당-번역물 (go LINUX)』 199번 제  목:[번역] gtk Tutorial, Chap1~3입니다.                          올린이:중앙자대(이훈    )    98/03/11 15:18    읽음:355 관련자료 없음 ----------------------------------------------------------------------------- *********** *** 1. 소개 ***********  GTK(GIMP Toolkit)은 원래 GIMP(General Image Manipulation Program)을 만들기 위한 툴킷으로 개발되었다.  GTK는 Xlib의 함수들에 대한 기본적인 wrapper인 GDK(GIMP Drawing Kit)를 기반으로 하고 있다.  원래 GIMP를 만들 목적으로 개발되었지만, 지금은 몇 가지 프리 소프트웨어의 제작에 쓰이게 되었다.  GTK의 제작자들은 다음과 같다.   Peter Mattis   petm@xcf.berkeley.edu Spencer Kimball spencer@xcf.berkeley.edu Josh MacDonald jmacd@xcf.berkeley.edu  GTK는 본질적으로 객체지향적인 어플 개발자 환경이다(API, Application Programmers Interface).  비록 완전히 C로 쓰여졌지만 클래스의 개념과 callback 함수(함수에 대한 포인터)가 갖추어진 것이다.  여기에는 연결리스트를 다루기 위한 몇 가지 함수들과 함께, glib라고 불리우며 몇 가지 표준함수들을 대치할 수 있는 함수들도 세번째 요소로 포함되어 있다.  g_strerror()처럼, 여기 쓰인 어떤 함수들은 다른 유닉스들에 대해 표준이 아니거나 쓰여질 수 없는 것이기 때문에, GTK의 이식성을 높이기 위해 여기에 대한 대치함수들도 쓰였다.  또한 g_malloc이 디버깅 기능을 강화했듯이 libc의 버전에 보강이 이루어지기도 했다.  이 문서는 단지 GTK를 위한 참고가 될 뿐이며, 완전한 것을 의미하지 않는다. 독자는 C언어를 잘 알며 C프로그램을 어떻게 만드는지 알고 있을 것이라고 가정 한다.  꼭 필요한 것은 아니겠지만, 독자가 이미 X 프로그램에 대한 경험이 있다면 매우 큰 도움이 될 것이다.  만약 당신이 widget 세트에 대해 GTK가 처음 접한 것이라면, 이 문서를 어떻게 발견하게 되었고 또 특별히 힘든 부분은 어떤 것이라는 것을 꼭 알려주기 바란다.  GTK를 위해 C++의 형식에 따른 API도 있다는 것을 참조할 것이며, 만약 C++을 더 선호한다면 이것 대신에 그걸 선택하기 바란다.  또한 Objective C, Guile과의 바인딩도 있지만, 어쨌든 여기서는 그것들을 따르지 않겠다.  당신이 이 문서를 통해 GTK를 공부하는 데 있어서 어떤 문제라도 나에게 알려 주기 바라며, 그것은 이 문서가 향상되는 것에 큰 도움이 될 것이라고 생각한다. ***************** *** 2. 시작하면서 *****************  먼저 할 일은 물론 GTK의 소스를 받아서 그것을 설치하는 것이다.  언제나 가장 최신 버전을 ftp.gimp.org의 /pub/gtk에서 가져올 수 있다.  GTK에 대한 또다른 소스들은 http://www.gimp.org/gtk에 있다.  GTK는 GNU autoconf를 이용한다.  일단 압축을 푼 다음에, ./configure --help를 쳐서 옵션들을 살펴 보기 바란다.  GTK에 대한 소개를 위해서, 가능한 한 간단한 프로그램부터 시작해 보자.  이 프로그램은 200x200 픽셀의 윈도를 만드는 것으로, 쉘을 이용하지 않고는 끝낼 수 없는 프로그램이다.  #include <gtk/gtk.h>  int main (int argc, char *argv[])  {      GtkWidget *window;      gtk_init (&argc, &argv);      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);      gtk_widget_show (window);      gtk_main ();      return 0;  }  모든 프로그램은 물론 GTK 어플에 쓰일 변수, 함수, 구조체 등이 선언되어 있는 gtk/gtk.h를 포함할 것이다.       gtk_init (&argc, &argv);  GTK로 쓰여지는 다른 모든 프로그램에서 부르게 되는 함수인 gtk_init(gint *argc, gchar ***argv) 를 부르고 있다.  이것은 디폴트로 쓸 비주얼과 칼라맵 등 몇가지를 세팅하며 그 이후 gdk_init(gint *argc, gchar ***argv)로 넘어간다. 이 함수는 쓰일 라이브러리를 초기화 하고, 디폴트로 시그널 핸들러를 셋업하며, 명령행을 통해 프로그램에 전해진 인자들 중 아래의 것들을 찾아 체크한다. --display --debug-level --no-xshm --sync --show-events --no-show-events  당신의 어플이 인식하지 않을 것들을 남겨두고, 위의 것들을 인자의 리스트에서 제거한다.  이것은 모든 GTK 어플에서 생략할 표준적인 인자들의 세트를 만든다.  다음의 두 줄에서는 윈도를 만들고 보여준다. window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_show (window);  GTK_WINDOW_TOPLEVEL이란 인자는 윈도 매니저의 장식과 위치설정에 따르게 한다.  0x0 크기의 윈도를 만들지 않고, child가 없는 윈도는 디폴트로 200x200 크기로 만들어져서 우리는 그것을 마음껏 다룰 수 있다.  gtk_widget_show() 함수는 이 widget의 속성에 대한 세팅이 끝났음을 GTK에 알려주는 것이고, 그래서 그 widget은 보여지게 된다.  마지막 줄은 GTK의 주 처리 루프에 들어가는 것이다.       gtk_main ();  gtk_main()은 GTK 어플 전반적으로 볼 수 있는 또 하나의 함수호출이다. 프로그램이 여기에 이르면, GTK는 X 이벤트, 타임아웃, 또는 파일 입출력 감지 등을 기다리며 대기하게 된다.  그러나 이 간단한 프로그램에서는 그런 것들이 무시되고 있다. *** *** 2-1. GTK에서의 Hello World 프로그램 ***  이제 하나의 widget(버튼)을 위한 프로그램이다, 그 유명한 hello world를 GTK로써 구현해 보자.  #include <gtk/gtk.h>  /* 이것은 callback함수다.  여기서는 데이터인자들이 무시되었다. */  void hello (GtkWidget *widget, gpointer data)  {      g_print ("Hello World\n");  }  gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)  {      g_print ("delete event occured\n");      /* "delete_event"라는 시그널핸들러에서 TRUE를 리턴하면,       * GTK는 "destroy" 시그널을 발생시킨다.  FALSE를 리턴하면       * 윈도가 진짜로 파괴되길 원하지 않는 것이다.  이것은       * '진짜로 끝내렵니까?' 같은 대화상자가 튀어나오게 할 때       * 유용하다. */             /* FALSE를 TRUE로 고치면 main 윈도는 "delete_event"와 함께       * 파괴될 것이다. */      return (FALSE);  }  /* 또다른 callback */  void destroy (GtkWidget *widget, gpointer data)  {      gtk_main_quit ();  }  int main (int argc, char *argv[])  {      /* GtkWidget은 widget들을 위한 기억장소 타입이다. */      GtkWidget *window;      GtkWidget *button;      /* 이것은 모든 GTK 어플들에서 호출된다.  인자들은 명령행 상으로부터       * 주어져 어플로 전해진다. */      gtk_init (&argc, &argv);      /* 새로운 윈도를 만든다. */      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);      /* 윈도가 "delete_event"를 받으면(이는 윈도매니저를 통한다), 우리는       * 위에서 정의한 함수 delete_event()를 호출할 것인지 확인한다.  이       * callback함수로 전해진 데이터는 NULL이고 따라서 여기서 무시된다. */      gtk_signal_connect (GTK_OBJECT (window), "delete_event",                          GTK_SIGNAL_FUNC (delete_event), NULL);      /* 여기서는 시그널핸들러에 "destroy" 이벤트를 연결해 준다.       * 이 이벤트는 우리가 윈도에 대해 gtk_widget_destroy()를 호출하거나,       * 또는 "delete_event" callback에서 'TRUE'를 리턴했을 때 발생한다. */      gtk_signal_connect (GTK_OBJECT (window), "destroy",                          GTK_SIGNAL_FUNC (destroy), NULL);      /* 윈도의 border width를 세팅한다. */      gtk_container_border_width (GTK_CONTAINER (window), 10);      /* "Hello World"라는 라벨이 있는 새로운 버튼을 만든다. */      button = gtk_button_new_with_label ("Hello World");      /* 버튼이 "clicked" 시그널을 받으면 NULL을 인자로 해서 hello()가       * 호출된다.  이 hello() 함수는 위에서 정의되었다. */      gtk_signal_connect (GTK_OBJECT (button), "clicked",                          GTK_SIGNAL_FUNC (hello), NULL);      /* 이것이 "clicked"되면 gtk_widget_destroy(window)가 호출, 그 윈도를       * 파괴하게 된다.  앞서 설명했듯이, 'destroy' 시그널은 여기서 이렇게       * 발생하거나, 또는 윈도매니저를 통해 발생한다. */      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",                                 GTK_SIGNAL_FUNC (gtk_widget_destroy),                                 GTK_OBJECT (window));      /* 이것은 버튼을 윈도, 즉 GTK 컨테이너의 하나로 패킹한다. */      gtk_container_add (GTK_CONTAINER (window), button);      /* 끝으로 새로 만든 widget인 버튼을 보여주는 것이다. */      gtk_widget_show (button);      /* 윈도 전체를 여기서 보여준다. */      gtk_widget_show (window);      /* 모든 GTK 어플은 꼭 gtk_main()을 하나씩 가지고 있다.  컨트롤은       * 여기서 끝나고 이제 어떤 이벤트(키를 누른다거나 마우스를 조작하는       * 등의)가 발생할 때까지 대기한다. */      gtk_main ();      return 0;  } *** *** 2-2. Hello world를 컴파일하기 ***  컴파일하기 위해 이렇게 하라.       gcc -Wall -g helloworld.c -o hello_world -L/usr/X11R6/lib \           -lgtk -lgdk -lglib -lXext -lX11 -lm  위의 라이브러리들은 디폴트 탐색경로에 있어야 하고, 그렇지 않을 때 -L<library directory> 를 더해주면 gcc가 필요한 라이브러리를 이 디렉토리에서 탐색하게 될 것이다.  예를들어, 내가 쓰는 Debian Linux 시스템에서는 X11 라이브러리를 찾을 수 있도록 -L/usr/X11R6/lib 라고 해주어야 한다.  라이브러리들의 순서 또한 중요하다.  링커는 실행되기 이전에 어떤 함수들이 쓰였는지 알고 있어야 한다.  만약 정적 라이브러리를 이용해 컴파일한다면 라이브러리의 순서는 특히 중요 해진다.  위에 보인 순서가 바로 이런 경우다.  우리가 링크시킨 라이브러리는 다음과 같은 것들이다. The glib library (-lglib), 다양한 함수를 포함하고 있으며, 여기서 쓰인 것은 g_print()함수다.  GTK는 glib를 기반으로 하고 있으므로 언제나 이 라이브러리가 필요할 것이다.  자세한 것은 glib에 대한 부분을 참조하라. The GDK library (-lgdk), Xlib를 감추어 둘러싼 wrapper다. The GTK library (-lgtk), GDK를 기반으로한 widget 라이브러리다. The Xlib library (-lX11), GDK에 의해 쓰여지게 된다. The Xext library (-lXext), 이것은 공유 메모리 pixmap과 다른 X 확장 들에 대한 코드를 위한 것이다. The math library (-lm), 이것은 여러 목적으로 GTK에서 쓰이게 된다.   *** *** 2-3. 시그널과 callback에 대한 이론 ***  Hello world 프로그램을 자세히 살펴보기에 앞서, 이벤트와 callback에 대해 집고 넘어가자.  GTK는 이벤트로 돌아가는 툴킷이며, 이것은 어떤 이벤트가 발생해서 적절한 다른 함수로 제어가 넘어가지 않는 한 계속 대기한다는 의미다.  이 제어를 넘긴다는 것은 "시그널"의 이용에 의해 이루어진다.  마우스 버튼을 누르는 것같이 어떤 이벤트가 있으면, 눌러졌다에 해당하는 적절한 시그널이 widget에 의해 "발생"하게 된다.  이것이 GTK가 하는 유용한 작업의 대부분이다. 버튼의 작용으로 어떤 동작을 시키려면, 우리는 이런 시그널들을 잡아내도록 시그널 핸들러를 셋업하고 이에 적당한 함수를 부르면 된다.  이것은 다음과 같은 함수를 이용함으로써 이루어진다.       gint gtk_signal_connect (GtkObject *object,                                gchar *name,                                GtkSignalFunc func,                                gpointer func_data);  첫번째 인자는 시그널을 발생시킬 widget이고, 두번째는 잡아내고자 하는 시그널의 이름이다.  세번째 인자는 그 시그널이 탐지되었을 때 호출할 함수며, 네번째는 이 함수에 넘겨줄 정보다.  세번째 인자로 나와있는 함수를 "callback함수"라고 부르며 다음처럼 이루어져 있다.       void callback_func(GtkWidget *widget, gpointer *callback_data);  이 함수의 첫번째 인자는 시그널을 발생시킨 widget을 향한 포인터가 되고, 두번째 인자는 위에 보인 gtk_signal_connect() 함수의 네번째 인자로 주어져 있는 정보에 대한 포인터다.  Hello world 예제에서 쓰인 또다른 호출은 이것이다.       gint gtk_signal_connect_object (GtkObject *object,                                       gchar  *name,                                       GtkSignalFunc func,                                       GtkObject *slot_object);  gtk_signal_connect_object()는 callback함수가 GTK object에 대한 포인터라는, 단 하나의 인자를 이용한다는 점만 빼고는 gtk_signal_connect()와 같다. 그러므로 시그널을 연결시킬 때 이 함수를 이용한다면 callback함수는 이런 모양을 해야 할 것이다.       void callback_func (GtkObject *object);  여기서의 object란 대개 widget을 말한다.  우리는 어쨌든 되도록 gtk_signal _connect_object를 이용해서 callback을 셋업하지는 않을 것이다.  그들은 우리의 hello world 예제에서처럼, 주로 인자로서 시그널 widget/object를 허용하는 GTK 함수들을 부를 때 쓰이고 있다.  시그널을 연결시키는 데 두 개의 함수를 가지고 있는 것은 단지 서로 다른 갯수의 인자를 가지고 있는 callback을 허용하기 위해서이다.  GTK 라이브러리에 있는 많은 함수들은 인자로서 오직 GtkWidget 포인터만을 허용하므로, 이런 경우 에는 gtk_signal_connect_object() 를 이용하면 될 것이다.  반면 자신의 함수에 대해서는, callback에 추가적인 정보를 가져야 할 필요가 있을 것이다. *** *** 2-4. Hello World를 따라 한걸음씩 ***  이제 적용된 이론에 대해 알았고, hello world 예제 프로그램을 따라 더 확실히 해두자.  이것은 버튼의 "눌림"이라는 이벤트에 대해 호출될 callback함수다.  이 예제 에서는 widget과 정보가 모두 무시되지만, 그것들을 다루는 것은 그다지 어렵지 않다.  이것 다음의 예제는 어떤 버튼이 눌러졌는가를 알려주기 위해 정보 인자를 이용하는 것이다.       void hello (GtkWidget *widget, gpointer *data)       {           g_print ("Hello World\n");       }  이 callback은 다소 특별하다.  윈도매니저가 어플에 이 이벤트를 보내면 "delete_event"가 발생하게 된다.  우리는 여기서 이런 이벤트들에 대해 무엇을 해줘야 할지 선택한다.  우리는 그것을 무시할 수도 있고, 이에 대한 반응을 정리할 수도 있으며, 또는 간단히 그 어플을 종료할 수도 있다.  이 callback의 리턴값을 통해 GTK는 어떤 일을 해야할 지 알게 된다.  FALSE를 리턴하면 GTK는 우리가 "destroy"시그널을 발생하는 것을 원하지 않는다고 판단 하게 된다.  그리고 TRUE를 리턴하는 것으로 우리는 "destroy"시그널이 발생함을 확인시키고, "destroy"시그널 핸들러를 호출하게 된다.       gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)       {           g_print ("delete event occured\n");           return (FALSE);       }  여기 단지 gtk_main_quit()을 호출하는 것으로 종료해 버리는, 또다른 callback 함수가 있다.  이것에 대해선 긴말 않겠다, 보면 알 수 있을 것이므로.       void destroy (GtkWidget *widget, gpointer *data)       {           gtk_main_quit ();       }  당신이 main() 란 것에 대해 알고 있으리라 생각한다, 다른 어플과 마찬가지로, 모든 GTK 어플 역시 main() 을 하나씩 가지고 있다.       int main (int argc, char *argv[])       {  이 부분에서, GtkWidget형의 구조체에 대한 포인터를 선언한다.  이것들은 윈도와 버튼을 만들기 위해 아래에서 쓰이게 된다.           GtkWidget *window;           GtkWidget *button;  여기 다시 gtk_init가 나온다.  전과 마찬가지로, 이것은 툴킷을 초기화하고, 명령행에서 주어진 인자들을 분석한다.  이것은 명령행에서 감지된 어떤 인자라도 인자의 리스트에서 삭제하고, argc와 argv를 변형시켜 그 인자들이 존재하지 않는 것처럼 보이게 해서, 당신의 어플이 남아있는 인자들만을 분석하도록 해준다.           gtk_init (&argc, &argv);  새 윈도를 하나 만든다.  이것은 꽤나 간단하다.  GtkWidget *window 가 가리 키는 구조체에 메모리가 할당되어 이제 실제로 존재하는 구조체를 가리키게 된 것이다.  새로운 윈도를 셋업하지만, 아직 gtk_widget_show(window)를 호출하지 않았기 때문에 실제로 보여지진 않고 있다.  이 윈도는 프로그램의 끝 근처에서야 보이게 될 것이다.           window = gtk_window_new (GTK_WINDOW_TOPLEVEL);  이 경우엔 윈도가 되겠지만, 여기 한 object에 시그널 핸들러를 연결시키는 예가 있다.  여기서는 "destory"시그널이 탐지된다.  이 시그널은 우리가 윈도를 없애기 위해서 윈도매니저의 기능을 이용했을 때(그리고 우리가 "delete_event" 핸들러에서 TRUE를 리턴했을 때), 또는 파괴할 object로 윈도widget을 선택하여 gtk_widget_destroy()를 호출했을 때 발생한다.  이것을 셋업하는 것으로 우리는 한 번의 호출로 두 경우 모두를 다룰 수 있다.  여기서, 그것은 앞에서 정의된 destroy() 함수를 NULL 인자로 호출하여 GTK를 종료하게 한다.  GTK_OBJECT와 GTK_SIGNAL_FUNC는 코드를 쉽게 분석할 수 있게 해주며 자료형 캐스팅과 체크를 해주는 매크로들이다.           gtk_signal_connect (GTK_OBJECT (window), "destroy",                               GTK_SIGNAL_FUNC (destroy), NULL);  이번 함수는 container object의 속성을 설정해 주기 위해 쓰였다.  이것은 윈도를 10 픽셀의 너비의 빈 영역으로 둘러쌓이게 한다.  우리는 앞으로 "Widget 속성 설정"이라는 section에서 유사한 기능을 가진 다른 함수들을 접하게 될 것이다.  그리고, GTK_CONTAINER는 역시 자료형 캐스팅을 해주는 매크로다.           gtk_container_border_width (GTK_CONTAINER (window), 10);  이 호출은 새 버튼을 하나 만든다.  이것은 새로운 GtkWidget 구조체를 위한 메모리 공간을 할당하고, 그것을 초기화하며, 그리고 button이라는 포인터가 그 영역을 가리키도록 한다.  이 버튼은 보여지게 되었을 때 "Hello World"라는 라벨을 가지게 될 것이다.           button = gtk_button_new_with_label ("Hello World");  우리는 여기서 이 버튼이 뭔가 유용한 일을 하도록 한다.  우리는 그것에 시그널 핸들러를 달아주고, "clicked"시그널이 발생했을 때 우리의 hello() 함수가 호출되도록 한다.  전해질 정보는 없고, 따라서 우리는 hello()라는 callback함수에 단순히 NULL을 전해준다.  분명히, 우리가 마우스 포인터로 그 버튼을 클릭했을 때 "clicked"시그널이 발생하게 된다.           gtk_signal_connect (GTK_OBJECT (button), "clicked",                               GTK_SIGNAL_FUNC (hello), NULL);  우리는 또한 프로그램을 끝내기 위해서도 이 버튼을 이용한다.  이것은 윈도 매니저를 통해서, 혹은 우리 프로그램을 통해서 "destroy"시그널이 어떻게 전해 오는지를 보여줄 것이다.  앞에서처럼 버튼이 눌려지면 먼저 hello() callback 함수가 불려지고, 뒤이어 그들이 셋업된 순서대로 이것이 호출된다. 필요하다면 얼마든지 callback함수를 쓸 수 있으며, 그것들 모두는 우리가 연결시켜놓은 순서대로 실행된다.  gtk_widget_destroy()함수가 오직 GtkWidget *widget만을 인자로 허용하기 때문에, 우리는 여기서 gtk_signal_connect()를 바로 쓰지 않고 gtk_signal_connect_object()를 쓴다.           gtk_signal_connect_object (GTK_OBJECT (button), "clicked",                                      GTK_SIGNAL_FUNC (gtk_widget_destroy),                                      GTK_OBJECT (window));  이것은 패킹호출이며 뒤에서 더 깊게 다룰 것이다.  하지만 상당히 쉽게 이해할 수 있다.  이것은 단지 GTK에게, 버튼은 그 버튼이 보여지게 될 윈도에 위치해야 된다는 걸 알려준다.           gtk_container_add (GTK_CONTAINER (window), button);  이제 우리는 필요한 모든 셋업을 마쳤다.  자리를 잡은 모든 시그널 핸들러와 함께, 모든 버튼이 각각 있어야 할 윈도에 자리를 잡았고, 우리는 GTK가 스크린 위에 widget들을 "보여주기"를 요구한다.  윈도widget이 가장 나중에 보여진다. 따라서 윈도가 먼저 보여지고 그 내부에 버튼 모양이 뒤이어 그려지는 게 아니라, 완전히 모양을 갖춘 윈도가 한꺼번에 보여지게 된다.           gtk_widget_show (button);           gtk_widget_show (window);  그리고 물론, 우리는 gtk_main()을 불러서 X 서버로부터 이벤트가 발생하기를 기다리게 하고, 이 이벤트가 탐지되었을 때 시그널을 내도록 widget을 호출할 것이다.           gtk_main ();  그리고 마지막 리턴.  gtk_quit()가 호출된 이후 제어는 여기서 끝나게 된다.           return 0;  이제, 우리가 GTK의 버튼 위에서 마우스 버튼을 클릭하면 widget은 "clicked" 시그널을 발생시킨다.  이런 정보를 이용하기 위해 우리 프로그램은 그 시그널을 잡아낼 시그널 핸들러를 셋업하고, 그것은 우리의 선택에 의한 함수들을 재빨리 부르게 된다.  우리의 예제에서는 우리가 만든 버튼이 눌려지면 hello()함수가 NULL 인자로 호출되고, 뒤이어 이 시그널을 위한 다음 핸들러가 호출된다. 이것은 윈도widget을 인자로 하여 gtk_widget_destroy()함수를 호출해서 윈도 widget을 없앤다.  이것은 윈도가 "destroy"시그널을 발생하게 해서 탐지되고, "destroy"에 해당하는 callback함수를 호출해서 GTK가 종료되게 하는 것이다.  비록 쓰임새는 거의 같은 것이지만, 유닉스 시스템의 시그널은 여기서 말하는 이런 시그널과 다른 것이며 사용되지도 않는다는 점을 기억하기 바란다. ********************** *** 3. 앞으로 나아가며 ********************** *** *** 3-1. 자료형 ***  앞서의 예제에서 주목했겠지만 설명이 필요한 것이 좀 있다.  gint, gchar 등은 각각 int와 char에 대한 typedef들이다.  이것은 계산을 할 때 간단한 자료형들의 크기에 대한 지저분한 의존성을 피하기 위한 것이다.  64비트의 알파든 32비트의 인텔이든 "gint32"는 플랫폼에 관계없이 32비트 정수로 typedef되어 있는 것이 좋은 예가 될 것이다.  이 typedef은 상당히 직관적이다.  그들은 모두 glib/ glib.h에서 정의되어 있다(이것은 gtk.h에서 포함시키게 된다.).  당신은 또한 함수가 GtkObject를 부를 때 GtkWidget을 이용하는 것에도 주목할 것이다.  GTK는 객체지향적으로 설계된 것이고, widget은 하나의 object이다. *** *** 3-2. 시그널 핸들러에 대해 좀 더 알아보기 ***  gtk_signal_connect의 선언을 또 다르게 살펴보자.       gint gtk_signal_connect (GtkObject *object, gchar *name,                                GtkSignalFunc func, gpointer func_data);  gint형의 리턴값?  이것은 callback함수를 확인하기 위한 꼬리표다.  앞서 얘기했듯이 우리는 시그널과 object에 대해 필요한 만큼의 많은 callback을 가질 수 있고, 그것들은 붙여져 있는 순서대로 각각 실행될 것이다.  이 꼬리표는 우리가 리스트에서 이런 callback을 제거하도록 해준다.       void gtk_signal_disconnect (GtkObject *object,                                   gint id);  그래서, 핸들러로부터 제거하고자 하는 widget과 signal_connect함수로부터 리턴된그 widget의 꼬리표 혹은 id를 넘겨줌으로써 시그널 핸들러를 끊어줄 수 있다.  Object에서 모든 시그널 핸들러를 제거하는 또다른 함수는 이것이다.       gtk_signal_handlers_destroy (GtkObject *object);  이 호출은 보이는 그대로다.  이것은 첫번째 인자로 넘겨받은 object에서, 단지 현재 설정된 모든 시그널 핸들러를 제거해 준다. *** *** 3-3. 향상된 Hello World 프로그램 ***  Callback함수에 대한 더 나은 예제가 될 약간 개선된 hello world를 보자. 이것은 또한 우리의 다음 절에서의 주제인 패킹 widget을 소개할 것이다.  #include <gtk/gtk.h>  /* 우리의 약간 개선된 callback.  이 함수로 전해진 데이터는 표준출력으로   * 보여진다. */  void callback (GtkWidget *widget, gpointer *data)  {      g_print ("Hello again - %s was pressed\n", (char *) data);  }  /* 다른 callback */  void delete_event (GtkWidget *widget, GdkEvent *event, gpointer *data)  {      gtk_main_quit ();  }  int main (int argc, char *argv[])  {      /* GtkWidget은 widget들을 위한 저장장소 타입이다. */      GtkWidget *window;      GtkWidget *button;      GtkWidget *box1;      /* 이것은 모든 GTK 어플에서 쓴다.  명령행에서 주어진 인자들은 이것을       * 통과해서 어플에 전달된다. */      gtk_init (&argc, &argv);      /* 새로운 윈도를 만든다. */      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);      /* 새로 접하는 함수로, 윈도에 "Hello Buttons!"라는 타이틀을 준다. */      gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!");      /* 여기서 우리는 GTK를 즉시 끝나게 하는 delete_event를 위한 핸들러를       * 세팅한다. */      gtk_signal_connect (GTK_OBJECT (window), "delete_event",                          GTK_SIGNAL_FUNC (delete_event), NULL);      /* 윈도의 border width를 세팅한다. */      gtk_container_border_width (GTK_CONTAINER (window), 10);      /* widget들이 패킹될 박스를 만든다.  이것은 패킹에 대한 부분에서       * 자세히 설명될 것이다.  박스는 실제로 보이는 건 아니며 단지       * widget들을 정렬해 놓을 도구로서 쓰인다. */      box1 = gtk_hbox_new(FALSE, 0);      /* 박스를 윈도 안에 놓는다. */      gtk_container_add (GTK_CONTAINER (window), box1);      /* "Button 1"이란 라벨을 가진 새로운 버튼을 만든다. */      button = gtk_button_new_with_label ("Button 1");      /* 이제 버튼이 클릭되면 우리는 이 버튼에 대한 포인터를 인자로 가지는       * "callback" 함수를 호출한다. */      gtk_signal_connect (GTK_OBJECT (button), "clicked",                         GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");      /* 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 ("Button 2");      /* 같은 callback을 호출한다.  물론 인자는 "button 2"에 대한       * 포인터다. */      gtk_signal_connect (GTK_OBJECT (button), "clicked",                        GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");      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;  }  이 프로그램을 우리의 첫번째 예제와 같은 링크 인자를 주고 컴파일하자.  역시 우리는 이 프로그램을 종료하기 위해서 윈도매니저를 이용하거나 명령행에서 죽이는 것 말고는 다른 방법이 없다는 걸 알 것이다.  연습삼아 세번째로 "Quit" 버튼을 만들어 추가해 보는 것도 좋을 것이다.  또한 다음 절을 읽어보며 gtk_box _pack_start()에 옵션을 주어볼 수도 있다.  윈도의 크기를 바꾸려고 시도도 해보고, 동작을 관찰해 보라.  참고로, gtk_window_new()를 위한 또다른 유용한 define으로 GTK_WINDOW_DIALOG 도 있다.  이것은 윈도매니저와 약간 다른 방식으로 상호작용하며, 일시적인 윈도 들에 대해 쓰여져야 한다.

1998 by swindler