GTK 1.x Tutorial
GTK 1.x Tutorial
1998년 5월 24일
1998년 5월 25일
지난 2월 말부터 조금씩 번역해 본 GTK Tutorial입니다. 출처는 GTK+의 공식
홈페이지인
http://www.gtk.org/입니다. 번역을 대충 끝마친 지금(3/??),
이 Tutorial은 1998/1/24 날짜로 올라온 것이 가장 새로운 것이네요. 물론 이
번역물도 그것을 기준으로 했습니다. 또 재활용성(?)을 위하여 처음부터 끝까지
일반적인 텍스트(plain text)의 포맷을 유지했습니다.
GTK+ Tutorial은 모두 24개의 장(Chapter)으로 이루어졌고 마지막 장인 24장을
비롯한 몇몇은 오히려 원문을 그대로 참고하는 것이 좋을 것이라고 판단, 거의
번역하지 않았습니다. 그리고 제가 번역했다고 주장(?)하는 나머지 장들도, 원래
상식이하의 영어실력과 수준이하의 Xlib/Widget Programming 경험으로 인해 꽤나
어지럽게 쓸 수밖에 없었습니다. 하지만 나름대로 신경은 썼으니깐, 알아서
받아들이시길 바랍니다. :) 번역한 내용의 정확성에 대해서도 책임 못 집니다.
또한 더 효과적인 이해를 위해서 예제를 직접 컴파일/실행해 보실 것을 권합니다.
이 Tutorial 번역문을 보는 데 있어서, 어지러움을 조금이나마 덜어 드리기
위해 전체적인 윤곽을 소개합니다.
- 소개
GTK(GTK+)의 설계와 소개입니다. 이미 나우 리동(go linux) 번역물
게시판에 올린 GTK+ FAQ이 참고가 될 것입니다.
- 시작하면서
GTK 어플의 전형적인 구조와, 그 유명한 helloworld.c 프로그램입니다.
그리고 다들 골치아파 하는 컴파일 옵션도 간단히 설명되어 있죠. 중요한 이론,
즉 시그널(signal)과 함수에 대한 포인터(callback function)를 GTK가 이용하는
방식에 대해서도 다룹니다.
- 앞으로 나아가며
helloworld.c를 조금 개선하면서 자료형들에 대한 잔소리 쪼금, 그리고
시그널 핸들러에 대한 보충설명이 있습니다. 시그널, 중요한 거죠.
- 패킹 Widget
패킹(packing)이라는 중요한 개념에 대해(저도 지긋지긋해졌습니다` :)
예제와 함께 설명하고 있습니다. 패킹은 사각형의 어떤 영역에 뭔가를 넣어
둔다는 의미로, GTK+처럼 윈도, 객체를 다루는 개발방식에서 굉장히 기본적이고
"자주 나오는" 놈입니다. 여기서는 하나씩 패킹하기 위한 박스(box)개념과,
여러개를 한꺼번에 패킹하기 위한 테이블(table)개념을 차례대로 소개합니다.
- Widget의 개요
FAQ에서도 언급했고, 이 문서의 본문에도 여러번 강조됐지만, GTK+은
C언어의 typedef struct{...} WidgetObject; 같은 이용으로 "객체지향기법"을
추구하고 있습니다. 물론 C++에서의 public member function을 흉내내기 위해
return_type (*func_pointer)(parameters,...) 으로 선언되는 callback 함수를
씁니다. 여기서 func_pointer의 정체를 알고, 그리고 잘 써먹을 수 있을 정도의
"C언어 실력(?)"만 있다면 GTK를 골려가며 이길 수 있을 겁니다. GTK+은 이렇게
그다지 어려운 게 아닙니다. :)
이 장에서는 GTK+ Object의 전부나 다름없는 widget에 대해, 일종의
공격 작전설명을 해주고 있습니다. 이미 다른 Widget 집단을 써본 경험 혹은
최소한 Xlib를 다뤄본 경험이 있다면 C언어에 능통한 것만큼이나 큰 도움이 될
것입니다. 참, 이 장에는 Gtk widget object들의 계층구조도 줄줄이 소개되어
있습니다. 매우 요긴한 정보죠.
- 버튼 widget
우선 제일 만만한 widget으로 버튼을 해치우고 있습니다. 그냥 버튼,
이쁜 버튼(픽스맵이 붙은 *), 특이한 버튼(토글, 체크, 라디오,..) 등 우리가
윈도용 응용어플들에서 많이 이용해 온 모든(?) 종류의 버튼들을 파헤칩니다.
- 다양한 widget들
자기 혼자 쓰이기보다 다른 widget을 꾸미기 위해 쓰이는 경향이 있는
몇가지 잡다한 widget을 소개합니다. 라벨(label), 풍선도움말(tooltip), 진행
막대(progress bar), 대화상자(dialog box), 픽스맵(pixmap) 등입니다. 특히
픽스맵에 대해서는 꽤 길고 자상하게(?) 다뤘군요.
Tooltip을 풍선도움말이라고 해석한 건, MacOS(한글판)에서 그런 걸
풍선도움말이라 부르는 데 익숙해졌기 때문입니다. 또다른 표현은 몰라요. :)
또, 간단하면서도 거의 모든 어플들에서 요긴하게 쓰일 파일선택 박스가
소개되어 있습니다. 그냥 '쉬어가는 페이지' 정도 될 듯 하네요. :) 예제를
컴파일해서 실행해 보면, 왜 너도나도 툴킷(toolkit)을 찾는지 알 수 있을
겁니다.
- 컨테이너 widget
노트북(notebook)과 스크롤된 윈도(scrolled window)를 다룹니다.
이들은 결과적으로 보여지게 될 다른 widget들을 조직적으로 관리하는 widget
들입니다. 웹써치엔진(Yahoo,Altavista,..)으로 흔한 단어, 예를들어 "girl"을
검색해보면 다들 알다시피 무지막지한 갯수의 링크가 쏟아지죠? 이때 화면을
관리하기 위해 웹브라우저 윈도는 스크롤됩니다. 즉, 스크롤바(scroll bar)가
생기죠. 하지만 "girl"의 경우처럼 수천 수만 개의 링크를 가졌다면 스크롤바
로도 감당못하죠? 그래서 그 페이지의 제일 아래쪽에 내려와보면 전체 링크를
1부터 20까지, 그리고 <더 있음(NEXT)>이라는, 페이지(page)로 관리하고 있음을
알 수 있습니다. 이렇게 페이지를 관리하는 게 노트북입니다.
- 리스트 widget
파일매니저(file manager)가 가장 좋은 예가 되겠네요. M$윈도그의
탐색기(explorer)나 TkDesk의 파일관리창을 보면, 각 파일의 이름과 속성들을
아이템(item)으로 하는 리스트(list)로 이루어져 있습니다. 이 장에서 다루는
것은 이런 리스트를 만드는 방법과, 마우스버튼의 좌우클릭을 적절히 끼워맞춰
선택(selection)을 관리하는 방법 등입니다. 간단한 예제 프로그램이 있으니
참고하세요.
- 메뉴 widget
메뉴(menu)를 만드는 방법을 소개하고 있습니다. GTK+ 역시 하나의
툴킷이니깐 나름대로 메뉴 하나 만들어 주는 함수 쯤은 제공합니다. 그리고
섬세함에선 약간 떨어지지만, 메뉴를 왕창 대량생산해주는 공장(factory)도
제공합니다. 메뉴에는 풀다운(pull-down)과 팝업(pop-up) 두가지가 있죠.
그리고 쉬운 방법과 "더" 쉬운 방법(메뉴공장)을 각각 이해할 수 있도록 두
예제 프로그램이 소개되었습니다.
- 텍스트 widget
많은 양의 텍스트를 다룰 때 편리한 텍스트 widget에 관해 설명하고 있습니다.
이 widget은 일반 텍스트 에디터나 뷰어와 비슷한 기능을 갖고 있습니다.
- 문서화되지 않은 widget들
'이런 것들에 대해서는 아직 튜토리얼이 없으니 당신이 한 번
만들어 봐!' -> 이러는군요. :) 누가 본보기로 Preview라는 widget에 대해
써놨다며 그 문서를 인용했더군요. 하지만 전 그 부분을 과감히(?!) 삭제하고
이 장 전체를 비워뒀습니다. (죄송 *)
www.gtk.org에 있는 원문을 참고하세요.
- 이벤트박스 widget
gtk+970916.tar.gz 이후의 배포본에서만 지원하는 widget이라는군요.
메뉴도 아니고 버튼도 아니고, 어쨌든 결과적으로 유용하게(?) 쓰인다네요. :)
- Widget의 속성을 세팅하기
제목은 그럴듯하지만, 실제로 이 장을 열어보니 함수원형(prototype)
몇 개 뿐이더군요. 하지만 GTK+에서도 역시 긴 함수이름은 그 자체가 설명입
니다. 첫 부분에 무슨 잔소리가 있던데, 그냥 있는 그대로 해석해 뒀습니다.
각 widget object들의 속성(property)을 관리하기 위한 함수들입니다.
- 타임아웃, 그리고 I/O와 Idle 함수들
주어진 시간(milliseconds)마다 호출되는 함수, 그냥 대기하는 함수,
데이터의 이동을 감시하는(monitoring) 함수 등이 소개되어 있습니다. 예제는
없지만 대충 보면 감이 잡힐 겁니다. ^^;
- Selection 관리하기
대부분의 터미널이나 에디터(editor)는 마우스로 본문을 찍 긁으면
그 선택된 영역이 반전되고, 메뉴에서 그 영역에 대해 카피(copy), 컷(cut),
페이스트(paste) 등의 작업을 할 수 있습니다. 그런데 어떤 에디터에서 뭔가
긁어놓고 곧바로 다른 에디터의 또 한 영역을 긁으면 보통 어떻게 되던가요?
제가 기억하는 거의 모든 어플의 경우, 먼저 긁었던 내용은 '무시'되더군요.
이런 문제를 selection이 관리합니다. 굉장히 어려운 단어도 있고 해서, 겨우
번역했습니다. (원문은 꽤 읽어줄 만 했는데, 제가 번역한 건 나도 읽기가
싫네요. :)
- glib
GTK+ FAQ에서도 간단히 밝혔지만, GTK+는 기존의 libc가 아닌, glib를
이용합니다. 당장 각 플랫폼에서 이 새로운 버전의 C 라이브러리를 설치해야
할 뿐만 아니라, 몇가지 표준함수들이 glib에서 어떻게 변했는지 대충 알아놔야
하겠죠. (일반적인 사용자 입장에서는 별로 변한 게 없습니다, 원래 printf가
g_print로 바뀐 식이니깐요. ;)
이 장에서는 기존의 libc에서는 제공하지 않는 새로운 것들을 위주로,
간단한 설명을 하고 있습니다. 각 자료형마다의 극한값(extrema)과, 아키텍쳐
(architecture)에 관계없이 typedef된 주요 자료형(data type)들, 그리고 말이
나온 김에 줄줄이 연결리스트(linked list)도 소개해 놨군요. 기존의 메모리
관리 함수 대신 쓰라면서 g_malloc/g_free를 비롯한, glib판의 메모리함수들도
있으며, 시스템 타이머(timer)함수, 문자열(string)함수까지 있네요. 그리고
끝으로 유틸리티 및 에러함수들을 소개했습니다.
- GTK의 rc 파일
유닉스 계열의 운영체제를 이용하는 분이라면 꿈에서도 이 rc파일을
편집하지나 않을지 모르겠네요. ^^; 이 장에서는 우리가 익숙해진 어플들처럼,
똑같은 바이너리(binary,executable)를 각 사용자의 입맛에 맞게 '환경설정'을
해서 이용할 수 있게 하는 걸 소개합니다. GTK+의 rc파일은 다른 대부분의 X용
어플들과 비슷한, 일관성 있는 심볼(simbol)을 이용합니다. 마지막 부분에
예제 rc파일이 있으니 참고하세요.
- 자신만의 widget 만들기
이 장의 내용은 "Creating Your Own Widgets", 즉 "자신만의 widget 만들기"
입니다. 실제 하는 역할도 그렇지만 이름도 Tictactoe라는 widget을 이렇게
저렇게 만들어 가는 과정에서 여러가지 주의꺼리/참고꺼리를 늘어놓았습니다.
Widget을 만든다는 건 이미 있는 widget을 이용하는 것과는 또다른
개념으로, 몇가지 집고 넘어갈 것이 있습니다. 우선, 진짜 허허벌판에서 시작
하는 게 아니라 "어디서 상속"받을 것인지를, 즉 그의 parent class를 선택해야
합니다. 그리고 이 widget이 처리해야할 시그널과 이벤트에 대해서도 목적에
맞게 "잘" 설정해야죠. 그리고 이 장의 마지막에서는, 이렇게 애써(?) 만든
widget들의 어설픈 문제점들을 지적하고, 그 해결방향을 제시하고 있군요.
- 낙서장, 간단한 그리기 예제
상당히 방대하고 잡다한(?) 내용을 다루는 장입니다. GIMP처럼, 진짜
그림을 다루기 위해서 알아야 할 것들이라고 하는군요.
먼저 마우스와 키보드의 미묘한 저수준 이벤트(low-level event)를
다루고 있습니다. Xlib에서 접할 수 있듯이 여러 #define 상수들을 비트연산
(bitwise operation)시키는 거죠. 이 상수들은 키보드와 마우스에서 일어나는
여러가지 이벤트들을 섬세하게 구별하기 위한 것이겠죠? 뒤를 잇는 놈들은
낙서를 할 도화지를 관리하는 방법입니다. 대부분의 widget과 함수들은 GTK의
베이스(base)를 이루는 GDK(General Drawing Kits) 라이브러리에서 온 것들
입니다. 윈도에 직접 그리는 것보다, 픽스맵이라는 가상의 도화지에 그려놓고
그 내용을 필요할 때 윈도로 복사해 주는 방식을 쓰죠, Xlib에서처럼.
다음엔 픽스맵에 그림을 그리는 도구들에 대해 잔소리가 이어집니다.
Xlib에서 GC(Graphics Context)란 놈을 구경해 봤다면 더 쉽게 이해할 수 있을
겁니다. 예를들어 사각형을 하나 그리는 도구는 gdk_draw_rectangle()이란 놈
인데, 사각형을 이루는 선의 굵기, 색깔, 종류(실선/점선/쇄선) 등 기본적인
속성들을 GC에 저장해 놓고, 실제로 그릴 때는 gdk_draw_rectangle이란 함수의
인자로서 해당하는 속성을 가지고 있는 GC를 넘겨줍니다. 물론 GTK+는 충분히
객체지향적이기 때문에 기본만 이해한다면 Xlib에서보다 더 직관적으로 즐길 수
있을 겁니다.
아직 끝나지 않았군요! -_-; 이 장에서는 더 섬세한 그림을 그리기
위해 마우스보다 더 좋은(더 비싼?) 입력장치를 이용할 것을, 은근히 부추기고
있습니다. Drawing tablet같은, 특수한 입력장치에서 발생하는 또다른 이벤트
들을 다루기 위해 확장이벤트(extended event)를 제공한다고 하네요. 마우스
에서 발생하는 몇가지 이벤트만으로도 머리가 아픈데 말입니다. :) 어쨌든
이 장의 마지막에서는, 마우스보다 더 좋은 장치(device)의 기능을 이용하는
방법에 대해 이야기하고 있습니다.
- GTK 어플을 개발하는 팁
너무 중요한 내용이라 꼭 직접 보라고밖에는 말할 수 없네요. ;)
- Contributing
역시 매우 중요한 겁니다.
- Credits
이 문서를 제작하는 데 도움이 된 사람들에게 감사의 말을 전하는,
역시 아주 중요한 장입니다. 일부 원문을 그대로 뒀습니다.
- Tutorial Copyright and Permissions Notice
GPL에 의한 모든 문서에서 볼 수 있는, 정말 중요한 글입니다.
일부러 원문을 그대로 놔뒀습니다.
제가 3월 26일에 입대를 하는 관계로
liberta@zeus.phys.cau.ac.kr, 그리고
liberta@cau.ac.kr 로 메일을
보내셔도 답이 없을 겁니다. :)
이 문서에 대한 추가와 수정, 그리고 어떤 곳으로의 업로드 등은
전적으로 자신에게 달려 있습니다. 그럼 GTK+과 함께 즐거운 여행을
하시길 바랍니다. :)
(서주태님이 번역하신 이 문서를 한지호가 다시 일반 text에서 SGML 형태로 바꾸고
최신 원문인 5월 24일자 Tutorial을 참조해서 달라진 부분을 보태어 수정했습니다.
이 문서를 읽으시다가 갑자기 번역이 열악해졌다고 느끼시는 부분이 있다면 아마
그 부분은 한지호가 새로 번역해서 추가한 곳일겁니다. ^^;
이 긴 문서를 번역하여 주시느라 수고하신 서주태님께 감사드립니다.
혹시 잘못 번역된 곳이나 실수, 오자를 발견하신 분은
hanjiho@penta.co.kr로
메일을 보내주시면 무척 고맙겠습니다. 서주태님 말씀대로 GTK+와 즐거운 여행을
하시길 바랍니다.)
GTK(GIMP Toolkit)은 원래 GIMP(General Image Manipulation Program)을 만들기
위한 툴킷으로 개발되었다. GTK는 Xlib의 함수들에 대한 기본적인 wrapper인
GDK(GIMP Drawing Kit)를 기반으로 하고 있다. 원래 GIMP를 만들 목적으로
개발되었지만, 지금은 몇 가지 프리 소프트웨어의 제작에 쓰이게 되었다. GTK의
제작자들은 다음과 같다.
GTK는 본질적으로 객체지향적인 어플 개발자 환경이다(API, Application
Programmers Interface). 비록 완전히 C로 쓰여졌지만 클래스의 개념과 callback
함수(함수에 대한 포인터)가 갖추어진 것이다.
여기에는 연결리스트(linked list)를 다루기
위한 몇 가지 함수들과 함께, glib라고 불리우며 몇 가지 표준함수들을 대치할 수
있는 함수들도 세번째 요소로 포함되어 있다. g_strerror()처럼, 여기 쓰인 어떤
함수들은 다른 유닉스들에 대해 표준이 아니거나 쓰여질 수 없는 것이기 때문에,
GTK의 이식성을 높이기 위해 여기에 대한 대치함수들도 쓰였다. 또한 g_malloc이
디버깅 기능을 강화했듯이 libc의 버전에 보강이 이루어지기도 했다.
이 문서는 단지 GTK를 위한 참고가 될 뿐이며, 완전한 것을 의미하지 않는다.
독자는 C언어를 잘 알며 C프로그램을 어떻게 만드는지 알고 있을 것이라고 가정
한다. 꼭 필요한 것은 아니겠지만, 독자가 이미 X 프로그램에 대한 경험이
있다면 매우 큰 도움이 될 것이다. 만약 당신이 widget 세트에 대해 GTK가 처음
접한 것이라면, 이 문서를 어떻게 발견하게 되었고 또 특별히 힘든 부분은 어떤
것이라는 것을 꼭 알려주기 바란다. GTK를 위해 C++의 형식에 따른 API도 있다는
것을 참조할 것이며, 만약 C++을 더 선호한다면 이것 대신에 그걸 선택하기
바란다. 또한 Objective C, Guile과의 바인딩도 있지만, 어쨌든 여기서는
그것들을 따르지 않겠다.
당신이 이 문서를 통해 GTK를 공부하는 데 있어서 어떤 문제라도 나에게 알려
주기 바라며, 그것은 이 문서가 향상되는 것에 큰 도움이 될 것이라고 생각한다.
먼저 할 일은 물론 GTK의 소스를 받아서 그것을 설치하는 것이다. 언제나
가장 최신 버전을 ftp.gtk.org의 /pub/gtk에서 가져올 수 있다. GTK에 대한
또다른 소스들은
http://www.gtk.org/에 있다.
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 이벤트, 타임아웃, 또는 파일 입출력 감지
등을 기다리며 대기하게 된다. 그러나 이 간단한 프로그램에서는 그런 것들이
무시되고 있다.
3.1 GTK에서의 Hello World 프로그램
이제 하나의 widget(버튼)을 위한 프로그램이다, 그 유명한 hello world를
GTK로써 구현해 보자.
/* helloworld.c */
#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;
}
3.2 Hello world를 컴파일하기
컴파일하기 위해 이렇게 하라.
gcc -Wall -g helloworld.c -o hello_world `gtk-config --cflags` \
`gtk-config --libs`
Gtk2.0에서는 gtk-config대신 pkg-config로 변경되었으므로, 컴파일하기 위해 이렇게 하라.
gcc -Wall -g helloworld.c -o hello_world `pkg-config --cflags --libs gtk+-2.0`
이렇게 하는 것은 gtk와 함께 딸려오는 gtk-config란 프로그램을
이용하는 것이다. 이 프로그램은 gtk를 쓰는 프로그램을 컴파일하기 위해서
어떤 컴파일러 스위치들이 필요한지 '알고'있다.
gtk-config --cflags 는 컴파일러가 header 파일들을 찾아보아야 하는
include 디렉토리들을 출력하고,
gtk-config --libs 는 링크되어야 하는 라이브러리들과
그 라이브러리들이 존재하는 디렉토리들을 출력한다.
보통 링크시키는 라이브러리들은 다음과 같은 것들이다.
- The GTK library (-lgtk), GDK를 기반으로한 widget 라이브러리다.
- The GDK library (-lgdk), Xlib를 감추어 둘러싼 wrapper다.
- The glib library (-lglib), 다양한 함수를 포함하고 있으며, 여기서
쓰인 것은 g_print()함수다. GTK는 glib를 기반으로 하고 있으므로
언제나 이 라이브러리가 필요할 것이다. 자세한 것은
glib을 참조하라.
- The Xlib library (-lX11), GDK에 의해 쓰여지게 된다.
- The Xext library (-lXext), 이것은 공유 메모리 pixmap과 다른 X 확장들에
대한 코드를 위한 것이다.
- The math library (-lm), 이것은 여러 목적으로 GTK에서 쓰이게 된다.
3.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에 추가적인 정보를 가져야 할 필요가 있을 것이다.
3.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가 종료되게 하는 것이다.
이벤트들의 또다른 사용방법은 윈도를 종료하는데 윈도 매니져를 쓰는 것이다.
이렇게 하면 "delete_event" 시그널이 발생하고 이는 우리의 "delete_event"
핸들러를 호출한다.
만일 우리가 여기서 TRUE를 리턴하면 윈도는 그대로 화면에 남고 아무일도
생기지 않는다. FALSE를 리턴하면 GTK는 "destroy" 시그널을 발생하고
"destroy" callback이 호출되어 GTK가 종료된다.
비록 쓰임새는 거의 같은 것이지만, 유닉스 시스템의 시그널은 여기서 말하는
이런 시그널과 다른 것이며 사용되지도 않는다는 점을 기억하기 바란다.
4.1 자료형
앞서의 예제에서 주목했겠지만 설명이 필요한 것이 좀 있다. gint, gchar 등은
각각 int와 char에 대한 typedef들이다. 이것은 계산을 할 때 간단한 자료형들의
크기에 대한 지저분한 의존성을 피하기 위한 것이다. 64비트의 알파든 32비트의
인텔이든 "gint32"는 플랫폼에 관계없이 32비트 정수로 typedef되어 있는 것이
좋은 예가 될 것이다. 이 typedef은 상당히 직관적이다. 그들은 모두 glib/
glib.h에서 정의되어 있다(이것은 gtk.h에서 포함시키게 된다.). 당신은 또한
함수가 GtkObject를 부를 때 GtkWidget을 이용하는 것에도 주목할 것이다. GTK는
객체지향적으로 설계된 것이고, widget은 하나의 object이다.
4.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에서, 단지
현재 설정된 모든 시그널 핸들러를 제거해 준다.
4.3 향상된 Hello World 프로그램
Callback함수에 대한 더 나은 예제가 될 약간 개선된 hello world를 보자.
이것은 또한 우리의 다음 절에서의 주제인 패킹 widget을 소개할 것이다.
/* helloworld2.c */
#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
도 있다. 이것은 윈도매니저와 약간 다른 방식으로 상호작용하며, 일시적인 윈도
들에 대해 쓰여져야 한다.
우리가 어떤 어플을 개발하면서, 하나의 윈도에 하나 이상의 버튼을 놓으려 할
것이다. 우리의 첫번째 hello world 예제는 하나의 widget만 썼고 따라서 우리는
그것을 윈도 내부에 "pack"하기 위해 gtk_container_add 함수를 썼다. 그러나
우리가 하나의 윈도에 더많은 widget을 놓으려 할 때, 어떻게 그들이 놓일 위치를
제어해야 할까? 여기서 바로 "packing"이란 것이 등장한다.
5.1 박스 packing의 원리
대부분의 패킹은 앞서의 예제에서처럼 박스를 만드는 것으로 이루어진다.
이들은 우리의 widget을 수평 혹은 수직 방향으로 패킹해 넣을 수 있는, 보이지
않는 widget 컨테이너들이다. 수평 박스로의 패킹widget인 경우, object는 호출
하는 방식에 따라 수평으로 왼쪽에서 오른쪽으로 혹은 오른쪽에서 왼쪽으로 삽입
된다. 수직 박스에서는 반대로 수직으로 삽입된다. 우리는 원하는 효과를 내기
위해 다른 박스들의 안팎에서 어떻게라도 조합해서 사용할 수 있다.
새로운 수평박스를 만들기 위해 우리는 gtk_hbox_new()를, 그리고 수직박스를
위해서는 gtk_vbox_new()를 이용한다. gtk_box_pack_start()와 gtk_box_pack_end
()는 이런 컨테이너의 내부에 object들을 위치시키기 위해 사용한다. gtk_box_
pack_start()함수는 수직박스에서는 위에서 아래쪽으로, 그리고 수평박스에서는
왼쪽에서 오른쪽으로 패킹할 것이다. 그리고 gtk_box_pack_end()는 이와 반대
방향으로 패킹한다. 이 함수들을 이용함으로써 우리는 오른쪽 또는 왼쪽으로
widget을 정렬할 수 있고, 원하는 효과를 낼 수 있다. 우리는 대부분의 예제에서
gtk_box_pack_start()를 이용할 것이다. Object는 또다른 컨테이너거나 widget이
될 수 있다. 그리고 사실, 많은 widget들은 실제로 버튼을 포함하고 있는 widget
이지만, 우리는 보통 버튼 안의 라벨만을 이용할 것이다.
이런 함수호출로써, GTK는 우리가 widget을 놓을 위치를 알게되고 따라서
자동적으로 크기를 조절한다든지 또다른 매력적인 일들을 할 수 있게 된다.
또한 우리의 widget이 어떻게 패킹되어야 하느냐에 따른 수많은 옵션들도 있다.
우리가 상상하듯이, 이런 방식은 widget을 놓고 만드는 데 있어서 상당한 유연성
을 제공해 준다.
5.2 박스에 대해 자세히 알아보자
이런 유연성 때문에, GTK에서 박스를 패킹하는 것은 처음엔 혼란스러울지
모른다. 많은 옵션들이 있으며, 그들이 어떻게 서로 꿰어 맞춰지는지 즉시 간파
할 수는 없을 것이다. 그러나 결국, 우리는 다섯 가지의 기본적인 스타일을
가지게 된다.
각각의 줄은 몇 개의 버튼을 가지고 있는 하나의 수평박스(hbox)를 포함한다.
함수호출 gtk_box_pack은 이 수평박스에 각각의 버튼을 패킹하는 것을 단축한
것이다. 각각의 버튼은 이 수평박스에 같은 방법으로 패킹된다(즉, gtk_box_pack
_start함수에 같은 인자를 준다는 말).
이것은 gtk_box_pack_start함수의 선언이다.
void gtk_box_pack_start (GtkBox *box,
GtkWidget *child,
gint expand,
gint fill,
gint padding);
첫번째 인자는 object를 패킹할 박스고 두번째는 그 object다. Object는
여기서 모두 버튼이 될 것이고, 따라서 우리는 박스안에 버튼들을 패킹하게 된다.
gtk_box_pack_start() 또는 gtk_box_pack_end()에서의 expand라는 인자가 TRUE
일 때, widget은 여백공간을 가득 채우며 박스에 들어가게 될 것이다. 그리고
그것이 FALSE라면 widget은 적절히 여백을 두게 된다. 이 expand를 FALSE로 두면
우리는 widget의 좌우 정렬을 결정할 수 있다. 그렇지 않으면 그들은 박스에
가득차서 gtk_box_pack_start 또는 gtk_box_pack_end 어느 쪽을 이용하든지 같은
효과를 가지게 된다.
인자 fill은 TRUE일 때 object 자신의 여백공간을 제어한다. 그리고 FALSE라면
object 자신의 여백공간을 두지 않는다. 이것은 expand 인자가 TRUE일 때만 효과
가 있다.
새로운 박스를 만들 때는 이런 함수가 있다(수평박스).
GtkWidget * gtk_hbox_new (gint homogeneous,
gint spacing);
여기서의 인자 homogeneous는 박스 안의 각 object들이 같은 크기를 가지도록
제어한다(즉 수평박스일 경우엔 같은 너비, 수직박스일 경우엔 같은 높이).
이것이 세팅되면, gtk_box_pack함수의 expand 인자는 언제나 TRUE가 된다.
여기서 spacing(박스가 만들어지며 세팅됨)와 padding(요소들이 패킹되며
세팅됨)의 차이점은 무엇일까? Spacing은 object들 사이에 생겨나는 것이며
padding은 한 object의 각 방향에서 생겨나는 것이다. 이것이 그 점을 명확히
해줄 것이다.
여기 이 이미지를 만들어 주는 코드가 있다. 나는 여러 번 강조했으므로
이것에서 별 문제는 없으리라 믿는다. 스스로 컴파일해서 가지고 놀아 보도록
한다.
5.3 패킹에 대한 예제 프로그램
/* packbox.c */
#include "gtk/gtk.h"
void
delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
{
gtk_main_quit ();
}
/* Button_label들로 이루어진 hbox를 만든다. 우리가 관심을 가진 변수들을
* 위한 인자들이 이 함수로 넘겨진다.
* 우리는 박스를 보이지 않고, 그 안에 있는 모든 것을 보일 것이다. */
GtkWidget *make_box (gint homogeneous, gint spacing,
gint expand, gint fill, gint padding)
{
GtkWidget *box;
GtkWidget *button;
char padstr[80];
/* 적당한 homogenous와 spacing을 가진 hbox를 만든다. */
box = gtk_hbox_new (homogeneous, spacing);
/* 적절히 세팅된 버튼들을 만든다. */
button = gtk_button_new_with_label ("gtk_box_pack");
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
gtk_widget_show (button);
button = gtk_button_new_with_label ("(box,");
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
gtk_widget_show (button);
button = gtk_button_new_with_label ("button,");
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
gtk_widget_show (button);
/* expand의 값에 따르는 라벨을 가진 한 버튼을 만든다. */
if (expand == TRUE)
button = gtk_button_new_with_label ("TRUE,");
else
button = gtk_button_new_with_label ("FALSE,");
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
gtk_widget_show (button);
/* 위의 경우와 같은 버튼을 만들지만, 더 단축된 표현이다. */
button = gtk_button_new_with_label (fill ? "TRUE," : "FALSE,");
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
gtk_widget_show (button);
sprintf (padstr, "%d);", padding);
button = gtk_button_new_with_label (padstr);
gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
gtk_widget_show (button);
return box;
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *separator;
GtkWidget *label;
GtkWidget *quitbox;
int which;
/* 언제나 이렇게 시작하는 것을 잊지 말 것! */
gtk_init (&argc, &argv);
if (argc != 2) {
fprintf (stderr, "usage: packbox num, where num is 1, 2, 3.\n");
/* GTK를 끝내는 부분이며, exit status는 1이다. */
gtk_exit (1);
}
which = atoi (argv[1]);
/* 우리의 윈도를 만든다. */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* Main 윈도에 destroy 시그널을 연결시켜 줘야 한다. 이것은 제대로 된
* 동작을 위해 매우 중요한 것이다. */
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
gtk_container_border_width (GTK_CONTAINER (window), 10);
/* 우리는 수평박스들을 패킹해 넣을 수직박스(vbox)를 만든다.
* 버튼이 들어있는 수평박스는 이 수직박스 안으로 순서대로 쌓인다.
* (스택 구조를 생각하면 될 것이다.) */
box1 = gtk_vbox_new (FALSE, 0);
switch (which) {
case 1:
/* 새로운 라벨을 만든다. */
label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
/* 라벨들을 왼쪽으로 정렬시킨다. 이것에 대해서 widget의 속성
* 세팅하기에서 다시 다룰 것이다. */
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
/* 라벨을 수직박스(vbox box1)에 패킹한다. 한 vbox에 패킹되는
* widget들은 순서대로 다른 것들의 위쪽으로 패킹된다. */
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
/* 라벨을 보여준다. */
gtk_widget_show (label);
/* make_box 함수를 적절한 인자로써 호출한다. */
box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
box2 = make_box (FALSE, 0, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
box2 = make_box (FALSE, 0, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
/* 하나의 separator를 만든다. 이들에 대해서 뒤에서 자세히
* 다룰 것이며, 꽤나 간단한 것이다. */
separator = gtk_hseparator_new ();
/* separator를 vbox 안으로 패킹한다. 이들 각각의 widget은
* vbox 안으로 패킹되므로, 수직 방향으로 쌓일 것이다. */
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
gtk_widget_show (separator);
/* 또다른 라벨을 만들어 그것을 보여준다. */
label = gtk_label_new ("gtk_hbox_new (TRUE, 0);");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
gtk_widget_show (label);
/* 각 인자는 homogeneous, spacing, expand, fill, padding이다. */
box2 = make_box (TRUE, 0, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
box2 = make_box (TRUE, 0, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
/* 또다른 separator */
separator = gtk_hseparator_new ();
/* gtk_box_pack_start 의 마지막 3가지 인자들은
* expand, fill, padding 이다. */
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
gtk_widget_show (separator);
break;
case 2:
/* 라벨을 새로 만든다. box1은 main()의 시작부분에서 만들어진
* 대로 vbox이다. */
label = gtk_label_new ("gtk_hbox_new (FALSE, 10);");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
gtk_widget_show (label);
box2 = make_box (FALSE, 10, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
box2 = make_box (FALSE, 10, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
gtk_widget_show (separator);
label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
gtk_widget_show (label);
box2 = make_box (FALSE, 0, TRUE, FALSE, 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
box2 = make_box (FALSE, 0, TRUE, TRUE, 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
gtk_widget_show (separator);
break;
case 3:
/* 이것은 gtk_box_pack_end()를 이용하여 widget을 오른쪽 정렬하는
* 걸 보여준다. 먼저, 앞에서처럼 새로운 박스를 하나 만든다. */
box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
/* 라벨을 하나 만든다. */
label = gtk_label_new ("end");
/* 그것을 gtk_box_pack_end()로써 패킹하므로, make_box()로 만들어진
* hbox의 오른쪽으로 놓여지게 된다.
gtk_box_pack_end (GTK_BOX (box2), label, FALSE, FALSE, 0);
/* 라벨을 보인다. */
gtk_widget_show (label);
/* box2를 box1 안으로 패킹한다. */
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
gtk_widget_show (box2);
/* bottom 쪽을 위한 separator. */
separator = gtk_hseparator_new ();
/* 이것은 400픽셀의 너비에 5픽셀의 높이(두께)로 separator를
* 세팅한다. 이것은 우리가 만든 hbox가 또한 400픽셀의 너비이기
* 때문이고, "end" 라벨은 hbox의 다른 라벨들과 구분될(separated)
* 것이다. 그렇지 않으면, hbox 내부의 모든 widget들은 가능한만큼
* 서로 빽빽히 붙어서 패킹될 것이다. */
gtk_widget_set_usize (separator, 400, 5);
/* main()함수의 시작부분에서 만들어진 vbox(box1)으로 separator를
* 패킹한다. */
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
gtk_widget_show (separator);
}
/* 또다른 hbox를 만든다.. 우리가 원하는 만큼 얼마든지 만들수 있다! */
quitbox = gtk_hbox_new (FALSE, 0);
/* 우리의 quit 버튼이다. */
button = gtk_button_new_with_label ("Quit");
/* 윈도를 파괴하기 시그널을 세팅한다. 이것은 위에서 정의된 우리의
* 시그널 핸들러에 의해 포착될, "destroy"시그널을 윈도로 보내준다. */
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (window));
/* quitbox로 버튼을 패킹한다. gtk_box_pack_start의 마지막 세 인자는
* expand, fill, padding이다. */
gtk_box_pack_start (GTK_BOX (quitbox), button, TRUE, FALSE, 0);
/* vbox(box1) 안으로 quitbox를 패킹한다. */
gtk_box_pack_start (GTK_BOX (box1), quitbox, FALSE, FALSE, 0);
/* 우리의 모든 widget을 포함하게 된 이 vbox를, main윈도로 패킹. */
gtk_container_add (GTK_CONTAINER (window), box1);
/* 그리고 남아있는 모든 것을 보여준다. */
gtk_widget_show (button);
gtk_widget_show (quitbox);
gtk_widget_show (box1);
/* 마지막에 윈도를 보여줘서 모든 것이 한번에 튀어나오며 보인다. */
gtk_widget_show (window);
/* 당연히 우리의 gtk_main이다. */
gtk_main ();
/* gtk_main_quit()을 호출했다면 제어는 이곳으로 온다. gtk_exit()를
* 호출하면 그렇지 않다. */
return 0;
}
5.4 테이블을 이용한 패킹
또다른 패킹 - 테이블을 이용한 것을 보자. 이것은 어떤 상황에서 아주 유용할
것이다.
테이블을 이용해서, 우리는 widget을 넣어둘 격자판을 만들게 된다. 그 widget
들은 우리가 설정하는대로 얼마든지 공간을 가지게 될 것이다.
물론 먼저 봐야 할 것은 gtk_table_new 함수다.
GtkWidget* gtk_table_new (gint rows,
gint columns,
gint homogeneous);
첫번째 인자는 테이블에 만들 행의 갯수고, 두번째는 당연히 열의 갯수다.
인자 homogeneous는 테이블의 박스들의 크기가 어떻게 되어야 하는지를 결정
한다. 이것이 TRUE라면 테이블의 박스들은 그 테이블에서 가장 큰 widget의
크기에 따르게 된다. 또 FALSE라면 각 박스들은 같은 행에서 가장 높은 widget의
높이를, 그리고 같은 열에서는 가장 넓은 widget의 너비를 따르게 된다.
각 행과 열은 0에서 n까지 차지하게 된다. 여기서 n은 gtk_table_new를 호출할
때 결정된 숫자다. 그래서, 만약 우리가 행=2 그리고 열=2, 이렇게 설정하게
되면 구조는 이렇게 된다.
0 1 2
0+----------+----------+
| | |
1+----------+----------+
| | |
2+----------+----------+
좌표계는 왼쪽 위에서 출발하는 것을 주의하자. 박스안에 widget을 놓으려면
다음 함수를 이용한다.
void gtk_table_attach (GtkTable *table,
GtkWidget *child,
gint left_attach,
gint right_attach,
gint top_attach,
gint bottom_attach,
gint xoptions,
gint yoptions,
gint xpadding,
gint ypadding);
첫번째 인자 table은 우리가 만든 테이블이고 두번째 child는 이 테이블에
놓으려고 하는 widget이다.
왼쪽과 오른쪽의 attach라는 인자들은 widget을 놓을 위치와 이용할 박스의
갯수를 결정한다. 만약 우리의 2x2 테이블의 오른쪽 아래 칸에 위치한 버튼을
원한다면, 그리고 그 요소만 가득채우기를 원한다면, left_attach=1, right_
attach=2, top_attach=1, bottom_attach=2, 이렇게 되어야 한다.
이제, 우리의 2x2 테이블의 첫번째 행 전체를 선택했다면, left_attach=0,
right_attach=2, top_attach=0, bottom_attach=1 이라고 하면 된다.
인자 xoption과 yoption은 패킹 옵션을 정하기 위한 것으로, 여러가지의 옵션을
주기 위해서 OR 연산자를 쓸 수 있다.
이 옵션들은 다음과 같다.
- GTK_FILL - GTK_FILL이 설정되면 테이블 박스가 widget보다 클 때 widget은
사용가능한 모든 공간으로 확대된다.
- GTK_SHRINK - 테이블 widget이 더 적은 공간을 차지하도록 되었을 때 widget
은 정상적으로 윈도의 아래쪽으로 밀려나서 일부가 보이지 않게 된다. 만약
GTK_SHRINK가 설정되면 widget은 자동으로 줄어들어 내부에 꼭 맞게 된다.
- GTK_EXPAND - 이것이 설정되면 테이블은 윈도의 남는 공간으로 꽉 차게
확대된다.
패딩은 박스 안에서처럼, 픽셀 단위로 뚜렷한 영역을 widget 주위에 만들어
준다.
gtk_table_attach()는 수많은 옵션을 가지고 있다. 그래서 이런 shortcut이
있다.
void gtk_table_attach_defaults (GtkTable *table,
GtkWidget *widget,
gint left_attach,
gint right_attach,
gint top_attach,
gint bottom_attach);
X와 Y 옵션은 디폴트로 GTK_FILL|GTK_EXPAND, 그리고 X와 Y의 패딩은 0이다.
나머지 인자들은 이전의 함수와 같다.
또한 gtk_table_set_row_spacing()과 gtk_table_set_col_spacing()이란 함수도
있다. 이것은 주어진 행 또는 열에 대해 spacing을 설정한다.
void gtk_table_set_row_spacing (GtkTable *table,
gint row,
gint spacing);
그리고
void gtk_table_set_col_spacing (GtkTable *table,
gint column,
gint spacing);
어떤 열에 대해서 space는 열의 오른쪽으로, 그래고 행에 대해서는 행의 아래쪽
으로 주어진다는 것을 염두에 두자.
모든 행과 열에 대한 일관된 spacing은 다음 두 함수를 사용한다.
void gtk_table_set_row_spacings (GtkTable *table,
gint spacing);
void gtk_table_set_col_spacings (GtkTable *table,
gint spacing);
이 두 함수는 마지막 행과 마지막 열에 대해서는 spacing을 하지 않는다는 것을
기억하라.
5.5 테이블 패킹 예제
여기서 우리는 2x2 테이블 안에 세개의 버튼이 있는 윈도를 하나 만든다.
처음 두 버튼은 윗행에 놓이고 세번째 quit 버튼은 두열을 차지하면서
아랫행에 놓인다. 그러므로 다음 그림처럼 보이게 된다.
소스 코드는 이렇다.
/* table.c */
#include <gtk/gtk.h>
/* 우리의 callback.
* 이 함수로 넘겨지는 데이타는 stdout으로 출력된다. */
void callback (GtkWidget *widget, gpointer data)
{
g_print ("Hello again - %s was pressed\n", (char *) data);
}
/* 이 callback 프로그램을 종료한다 */
void delete_event (GtkWidget *widget, gpointer data)
{
gtk_main_quit ();
}
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), "Table");
/* 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), 20);
/* 2x2의 테이블을 만든다. */
table = gtk_table_new (2, 2, TRUE);
/* 테이블을 윈도에 놓는다. */
gtk_container_add (GTK_CONTAINER (window), table);
/* 첫 버튼을 만든다. */
button = gtk_button_new_with_label ("button 1");
/* 버튼이 눌리면 "button 1"을 인수로 해서 "callback" 함수를
* 부른다. */
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");
/* 첫 버튼을 테이블 왼쪽 제일 위에 놓는다. */
gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 1, 0, 1);
gtk_widget_show (button);
/* 두번째 버튼을 만든다. */
button = gtk_button_new_with_label ("button 2");
/* 버튼이 눌리면 "button 2"을 인수로 해서 "callback" 함수를
* 부른다. */
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");
/* 두번째 버튼을 테이블 오른쪽 제일 위에 놓는다. */
gtk_table_attach_defaults (GTK_TABLE(table), button, 1, 2, 0, 1);
gtk_widget_show (button);
/* "Quit" 버튼을 만든다. */
button = gtk_button_new_with_label ("Quit");
/* 버튼이 눌리면 "delete_event" 함수를 호출해서
* 프로그램을 끝낸다. */
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (delete_event), NULL);
/* "Quit" 버튼을 테이블의 아랫행의 두열에 놓는다. */
gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 2, 1, 2);
gtk_widget_show (button);
gtk_widget_show (table);
gtk_widget_show (window);
gtk_main ();
return 0;
}
GTK에서 widget을 만드는 일반적인 절차는 다음과 같다.
- gtk_*_new - 새로운 widget을 만들기 위한 다양한 함수. 이것들 모두는
여기서 자세히 보여질 것이다.
- 적당한 핸들러에 사용할 모든 시그널을 결합시킨다.
- Widget의 속성을 세팅한다.
- gtk_container_add()나 gtk_box_pack_start()같은 적당한 함수를 써서
widget을 컨테이너 안으로 패킹한다.
- gtk_widget_show()로 widget을 보인다.
gtk_widget_show()는 우리가 widget의 속성을 모두 세팅했음을 GTK에게 알리고,
그것은 이제 보여질 준비가 다 된 것이다. 우리는 그것을 다시 보이지 않게 하기
위해 gtk_widget_hide를 이용할 수도 있다. Widget들이 보여지는 순서는 중요
하지 않다. 내가 말하려는 것은, 각각의 widget이 생겨나는 대로 스크린에
보여지게 하는 것보다는, 윈도를 가장 나중에 보여지게 해서 모든 구성요소가
한번에 튀어오르게 하는 것이 낫다는 것이다. gtk_widget_show()함수를 이용하게
되면 어떤 widget(윈도 역시 하나의 widget이다)의 구성요소들은 그 윈도 자체가
보여지기 전에 먼저 보여지지 않는다.
6.1 캐스팅(자료형의 강제변환)
계속하면서 알겠지만, GTK는 자료형의 강제변환 시스템을 쓴다. 이것은 주어진
대상을 캐스팅하는 능력을 테스트할 때나, 그리고 캐스팅을 실행할 때나, 언제나
매크로를 이용함으로써 이루어진다. 우리가 보게 될 몇몇은 다음과 같다.
- GTK_WIDGET(widget)
- GTK_OBJECT(object)
- GTK_SIGNAL_FUNC(function)
- GTK_CONTAINER(container)
- GTK_WINDOW(window)
- GTK_BOX(box)
이것들은 모두 함수의 인자들을 캐스트하기 위해 쓰였다. 우리는 이들을
예제들에서 볼 것이며, 함수의 선언부를 보는 것만으로 그들을 이용할 때를 말할
수 있을 것이다.
아래의 클래스 계층구조에서 볼 수 있듯이, 모든 GtkWidget들은 기반클래스인
GtkObject에서 파생된 것이다. 이것은 어떤 함수가 object를 요구할 때 어디서
든지 widget을 이용할 수 있음을 의미한다 - 단순히 GTK_OBJECT() 매크로를
이용해서. 예를 들어 보자.
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(callback_function), callback_data);
이것은 버튼을 하나의 object로 캐스트하고, 함수 포인터를 callback으로
캐스트한다.
많은 widget들은 또한 컨테이너다. 아래의 클래스 계층구조를 보면 상당수의
widget들이 GtkContainer에서 파생되었음을 알 수 있을 것이다. 그들 중 어떤
widget이라도 컨테이너를 요구하는 함수에 넘겨주기 위해 GTK_CONTAINER 매크로를
이용할 수 있다.
불행하게도 이런 매크로들은 이 문서에서 광범위하게 다루어지지 않았다. 나는
여러분이 GTK의 헤더파일들을 살펴보기를 권한다. 사실, 함수의 선언부를 보면서
widget이 어떻게 작용하는지 공부하는 것은 그리 어렵지 않다.
6.2 Widget의 계층구조
여러분이 참고할 수 있도록, 여기 widget들을 보충하기 위한 클래스 계층구조
트리가 있다.
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
6.3 윈도와 무관한 widget
여기의 widget들은 관련된 윈도가 없는 것들이다. 만약 어떤 이벤트를 포착
하려면 GtkEventBox를 이용해야 할 것이다.
The EventBox Widget에 대한 section을
참조하라.
GtkAlignment
GtkArrow
GtkBin
GtkBox
GtkImage
GtkItem
GtkLabel
GtkPaned
GtkPixmap
GtkScrolledWindow
GtkSeparator
GtkTable
GtkViewport
GtkAspectFrame
GtkFrame
GtkVPaned
GtkHPaned
GtkVBox
GtkHBox
GtkVSeparator
GtkHSeparator
우리는 각각의 widget을 차례로 시험하고 그들을 보일 수 있는 간단한 함수들을
만들어 가며 GTK에 대한 탐구를 계속할 것이다. 또다른 훌륭한 소스는 GTK와
함께 배포된 testgtk.c 이다. 그것은 gtk/testgtk.c 에서 찾을 수 있을 것이다.
7.1 보통의 버튼
우리는 버튼widget에 대해서는 거의 보아왔다. 그것은 상당히 간단하다.
그런데 버튼을 만드는데는 두가지 방법이 있다. 우리는 라벨이 있는 버튼을
만들기 위해 gtk_button_new_with_labe()을 이용할 수 있고, 빈 버튼을 만들기
위해 gtk_button_new()를 이용할 수도 있다. 그런 다음 그것에 라벨을 붙이든지
픽스맵을 붙이든지 하는 것은 여러분에게 달려있다. 그렇게 하려면 새로운
박스를 만들고 gtk_box_pack_start로써 이 박스 안에 우리의 object를 패킹하며,
그 다음엔 gtk_container_add로써 그 박스를 버튼 안으로 패킹하면 된다.
이 예제는 gtk_button_new를 이용하여 그림과 라벨이 있는 버튼을 만든다.
박스를 만드는 코드가 다른 것들로부터 떨어져 나와 있으며 여러분의 프로그램
에서 그것을 이용할 수 있을 것이다.
/* buttons.c */
#include <gtk/gtk.h>
/* 이미지와 그것에 패킹된 라벨을 가지고 있는 hbox를 하나 만든다.
* 그리고 그 박스를 리턴한다. */
GtkWidget *xpm_label_box (GtkWidget *parent, gchar *xpm_filename, gchar *label_text)
{
GtkWidget *box1;
GtkWidget *label;
GtkWidget *pixmapwid;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
/* xpm과 라벨을 위한 박스를 만든다. */
box1 = gtk_hbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (box1), 2);
/* 버튼의 스타일을 취한다.. background 색깔을 취하는 것 같은데,
* 아니라면 누군가 나에게 정정해 주길 바란다. */
style = gtk_widget_get_style(parent);
/* xpm 파일로부터 픽스맵을 만든다. */
pixmap = gdk_pixmap_create_from_xpm (parent->window, &mask,
&style->bg[GTK_STATE_NORMAL],
xpm_filename);
pixmapwid = gtk_pixmap_new (pixmap, mask);
/* 버튼을 위한 라벨을 만든다. */
label = gtk_label_new (label_text);
/* 박스 안으로 픽스맵과 라벨을 패킹해 넣는다. */
gtk_box_pack_start (GTK_BOX (box1),
pixmapwid, FALSE, FALSE, 3);
gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 3);
gtk_widget_show(pixmapwid);
gtk_widget_show(label);
return (box1);
}
/* 우리의 전형적인 callback 함수다. */
void callback (GtkWidget *widget, gpointer data)
{
g_print ("Hello again - %s was pressed\n", (char *) data);
}
int main (int argc, char *argv[])
{
/* GtkWidget은 widget들을 위한 기억장소 종류다. */
GtkWidget *window;
GtkWidget *button;
GtkWidget *box1;
gtk_init (&argc, &argv);
/* 윈도를 하나 만든다. */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Pixmap'd Buttons!");
/* 모든 윈도들에 대해 이렇게 해주는 것이 좋을 것이다. */
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_exit), NULL);
/* 윈도의 border width를 세팅한다. */
gtk_container_border_width (GTK_CONTAINER (window), 10);
/* 새로운 버튼을 하나 만든다. */
button = gtk_button_new ();
/* 이쯤에서 이 함수를 쓰는 것을 기억하라. */
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (callback), (gpointer) "cool button");
/* 박스를 만드는 함수다. */
box1 = xpm_label_box(window, "info.xpm", "cool button");
/* 우리 widget들을 패킹하고, 보여준다. */
gtk_widget_show(box1);
gtk_container_add (GTK_CONTAINER (button), box1);
gtk_widget_show(button);
gtk_container_add (GTK_CONTAINER (window), button);
gtk_widget_show (window);
/* 여기서부터는 뭔가 재미있는 일이 시작될 때까지 무작정 기다린다. */
gtk_main ();
return 0;
}
xpm_label_box 함수는 컨테이너가 될 수 있는 어떤 widget에라도 픽스맵과
라벨을 패킹하기 위하여 쓰여질 수 있을 것이다.
7.2 토글 버튼
토글버튼은 클릭에 의해 택일되는 두가지 중 어느 한 상태에 있어야 한다는
점만 뺀다면 보통 버튼과 매우 유사하다. 그것은 눌려진 상태로 있다가도,
우리가 다시 클릭해 주면 다시 튀어나오게 될 수 있다. 또 클릭하면 그것은
다시 눌러져 들어갈 것이다.
토글버튼에 쓰이는 많은 함수들이 라디오와 체크 버튼에 의해 상속되어
쓰이듯이, 토글버튼은 체크버튼과 라디오버튼의 기반이 된다. 이것들을 접하게
되면 이 점을 다시 지적할 것이다.
새로운 토글버튼을 만들려면 이것을 이용한다.
GtkWidget* gtk_toggle_button_new (void);
GtkWidget* gtk_toggle_button_new_with_label (gchar *label);
추측할 수 있겠지만, 이것은 보통버튼 widget의 호출과 똑같이 작용한다.
첫번째 것은 빈 토글버튼을, 그리고 두번째 것은 이미 라벨widget이 패킹되어
있는 버튼을 만든다.
토글버튼과 라디오버튼, 체크버튼의 상태를 되돌리기 위해, 우리는 아래의
예제에서 보여질 매크로를 이용한다. 이것은 어떤 callback에서 토글의 상태를
테스트한다. 토글버튼에 의해 발생하는 시그널은 (토글/체크/라디오 버튼
widget들) "toggled" 시그널이다. 이 버튼들의 상태를 체크하려면 이 toggled
시그널을 잡아내도록 시그널 핸들러를 셋업하고, 그것의 상태를 결정하기 위한
매크로를 이용한다. 그 callback은 이런 모양의 것이다.
void toggle_button_callback (GtkWidget *widget, gpointer data)
{
if (GTK_TOGGLE_BUTTON (widget)->active)
{
/* 컨트롤이 여기로 오면, 토글버튼의 상태는 up이다. */
} else {
/* 토글버튼은 down이다. */
}
}
void gtk_toggle_button_set_state (GtkToggleButton *toggle_button,
gint state);
위의 호출은 토글버튼과, 그것에서 파생되는 라디오와 체크버튼의 상태를
세팅하기 위해 쓰일 수 있다. 첫번째 인자로 우리가 만든 버튼을 넘겨주고,
그리고 그것이 눌린 상태인지 아닌지를 구별하기 위해 두번째 인자를 TRUE 또는
FALSE로 넘겨준다. 디폴트는 안 눌러진 상태, 즉 FALSE이다.
우리가 gtk_toggle_button_set_state()함수를 쓰면 버튼에서 "clicked"시그널이
발생해서 버튼의 상태가 실제로 변하게 됨을 기억하자.
void gtk_toggle_button_toggled (GtkToggleButton *toggle_button);
이것은 간단히 버튼을 토글하고, "toggled"시그널을 발생시킨다.
7.3 체크버튼
체크버튼은 위에 있는 토글버튼에서 많은 특성과 함수들을 상속받았지만 다소
다르게 보인다. 이것은 버튼과 그 안의 텍스트로 있다기보다는, 텍스트 옆에
있는 작은 사각형이라고 할 수 있다. 이들은 어떤 어플에서 토글되는 옵션으로서
많이 봤을 것이다.
이것을 만드는 두가지 함수는 보통버튼에서와 마찬가지다.
GtkWidget* gtk_check_button_new (void);
GtkWidget* gtk_check_button_new_with_label (gchar *label);
new_with_label함수는 옆에 텍스트 라벨을 가지고 있는 체크버튼을 만든다.
체크버튼의 상태를 체크하는 것은 토글버튼에서와 같다.
7.4 라디오버튼
라디오버튼은 그들이 그룹화되어 있어서 한 번에 오직 하나씩만 선택/복귀될 수
있다는 점만 빼고는 체크버튼과 유사하다. 이것은 어플이 옵션의 리스트에서
하나를 선택하도록 하는 경우에 쓰이면 좋을 것이다.
새로운 라디오버튼을 만드는 데 쓰는 함수들이다.
GtkWidget* gtk_radio_button_new (GSList *group);
GtkWidget* gtk_radio_button_new_with_label (GSList *group,
gchar *label);
이 호출들에는 다소 다른 인자가 있다는 것을 눈여겨 보자. 이들은 적절히
임무를 수행할 그룹을 필요로 한다. 첫번째 함수는 첫번째 인자로 NULL을 넘겨
줘야 한다. 그리고 우리는 이것을 이용하여 그룹을 만든다.
GSList* gtk_radio_button_group (GtkRadioButton *radio_button);
그리고는 이 그룹을 gtk_radio_button_new 또는 gtk_radio_button_new_with_
label에 첫번째 인자로 넘겨준다. 다음을 이용해서 어떤 버튼이 디폴트로
눌러지게 되는지를 분명히 해두는 것도 좋은 생각이다.
void gtk_toggle_button_set_state (GtkToggleButton *toggle_button,
gint state);
이것은 토글버튼에 대한 부분에서 설명되었으며, 정확히 같은 방법을 따른다.
다음 예는 세개의 버튼으로 이루어진 그룹을 만든다.
/* radiobuttons.c */
#include <gtk/gtk.h>
#include <glib.h>
void close_application( GtkWidget *widget, gpointer data ) {
gtk_main_quit();
}
main(int argc,char *argv[])
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *separator;
GSList *group;
gtk_init(&argc,&argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC(close_application),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "radio buttons");
gtk_container_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_vbox_new (FALSE, 10);
gtk_container_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, "button1");
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
button = gtk_radio_button_new_with_label(group, "button2");
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), TRUE);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
button = gtk_radio_button_new_with_label(group, "button3");
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_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");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(close_application),
GTK_OBJECT (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);
}
다음 문장과 같은 식으로 어떤 변수 하나가 버튼들의 리스트를 가지고 있어야할
필요가 없도록 줄여 쓸 수도 있다.
button2 = gtk_radio_button_new_with_label(
gtk_radio_button_group (GTK_RADIO_BUTTON (button1)),
"button2");
8.1 라벨(label)
라벨은 GTK에서 자주 쓰이고 비교적 간단한 것이다. 이들은 관련된 X윈도가
없으므로 시그널을 발생하지 않는다. 만약 시그널을 잡아내거나 클리핑을 할
목적이라면 EventBox widget을 이용하라.
새로운 라벨을 만들기 위해 이것을 이용한다.
GtkWidget* gtk_label_new (char *str);
하나의 인자는 우리가 나타내고자 하는 라벨의 문자열이다.
라벨을 만든 이후에 이 라벨의 텍스트를 바꾸려면 이것을 이용한다.
void gtk_label_set (GtkLabel *label,
char *str);
첫번째 인자는 이전에 만들어져 있는 라벨(GTK_LABEL()매크로로써 캐스트됨)
이고, 두번째는 새로운 문자열이다.
새로운 라벨을 위한 공간은 필요할 경우에 자동적으로 조절된다.
현재의 문자열을 되찾고 싶다면 이것을 이용한다.
void gtk_label_get (GtkLabel *label,
char **str);
첫번째 인자는 만들어졌던 라벨이고, 두번째는 되살리고자 하는 문자열이다.
8.2 풍선 도움말(tooltip widget)
마우스포인터를 어떤 버튼이나 다른 widget 위에 몇 초 머무르게 하면 작은
텍스트 문자열이 튀어나오는 경우가 있다. 이것은 간단한 것이며, 그래서
여기서 예제없이 설명하겠다. 실제로 코드를 보고싶다면 GDK와 함께 배포되는
testgtk.c 프로그램을 참조하라.
라벨 등 어떤 widget에는 이 tooltip이 쓰이지 않는다.
우리가 처음 이용할 함수는 새로운 tooltip을 만드는 것이다. 이것은 주어진
함수에서 한번만 해주면 된다. 이 함수가 리턴하는 GtkTooltip은
다중의 tooltip들을 만드는데도 이용될 수 있다.
GtkTooltips *gtk_tooltips_new (void);
일단 새로운 tooltip과 그것을 사용할 widget을 만들었으면, 그것을 세팅하기
위해 이 함수를 이용하라.
void gtk_tooltips_set_tip (GtkTooltips *tooltips,
GtkWidget *widget,
const gchar *tip_text,
const gchar *tip_private);
첫번째 인자는 우리가 만든 tooltip이고, 다음은 이 tooltip을 포함하게 될
widget이다. 세번째 인자인 텍스트는 우리가 tooltip에서 말하고자 하는
것이다. 마지막 인자는 NULL로 줄 수 있다.
이것은 짧은 예다.
GtkTooltips *tooltips;
GtkWidget *button;
...
tooltips = gtk_tooltips_new ();
button = gtk_button_new_with_label ("button 1");
...
gtk_tooltips_set_tip (tooltips, button, "This is button 1", NULL);
Tooltip에 쓰이는 다른 함수들도 있다. 여기서 그들을 간단히 소개하겠다.
void gtk_tooltips_destroy (GtkTooltips *tooltips);
만들어진 tooltip을 제거한다.
void gtk_tooltips_enable (GtkTooltips *tooltips);
Disable로 설정된 tooltip을 enable한다.
void gtk_tooltips_disable (GtkTooltips *tooltips);
Enable로 설정된 tooltip을 disable한다.
void gtk_tooltips_set_delay (GtkTooltips *tooltips,
gint delay);
Tooltip이 튀어오르기 위해 얼마나 마우스포인터를 widget위에 머무르게
해야하는 지를, millisecond단위로 세팅한다. 디폴트로 1000millisecond, 즉
1초다.
void gtk_tooltips_set_tips (GtkTooltips *tooltips,
GtkWidget *widget,
gchar *tips_text);
이미 만들어진 tooltip의 텍스트 내용을 바꾼다.
void gtk_tooltips_set_colors (GtkTooltips *tooltips,
GdkColor *background,
GdkColor *foreground);
Tooltip의 표현색과 배경색을 바꾼다. 어떻게 색깔을 설정하는지에 대해서는
모르겠다.
Tooltip에 관련된 함수는 이것이 전부다. 더이상 알 것도 없다. :)
8.3 진행막대(progress bar)
진행막대는 작업의 상황을 나타내기 위해 쓰인다. 이제 코드를 보면 알겠지만,
이것은 꽤 간단하다. 그러나 먼저 새로운 진행막대를 만들어주는 함수를 살펴
보는 것으로 시작하자.
GtkWidget *gtk_progress_bar_new (void);
이제 진행막대가 만들어졌고 우리는 그것을 이용할 수 있다.
void gtk_progress_bar_update (GtkProgressBar *pbar, gfloat percentage);
첫번째 인자는 동작시킬 진행막대가 되고, 두번째 인자는 '완료된' 분량을
나타낸다. 이것은 실제 숫자로 0부터 1까지고, 0부터 100퍼센트를 의미하는
것이다.
진행막대는 보통 타임아웃이나 또는 멀티태스킹하는 착각을 일으키게 하는
함수들과 함께 쓰인다.
(section
타임아웃, 그리고 I/O와 Idle 함수들을
참조하라.)
모든 경우에 gtk_progress_bar_update함수가 동일한 방식으로 쓰이게 된다.
이것은 타임아웃을 이용해 업데이트되는 진행막대를 보인 예제다. 이것은 또한
진행막대를 리셋, 즉 초기화하는 방법도 보여줄 것이다.
/* progressbar.c */
#include <gtk/gtk.h>
static int ptimer = 0;
int pstat = TRUE;
/* 이 함수는 진행막대를 증가시키고 업데이트한다. 또 pstat가 FALSE로 되면
* 진행막대를 리셋, 즉 초기화한다. */
gint progress (gpointer data)
{
gfloat pvalue;
/* 진행막대의 현재값을 알아낸다. */
pvalue = GTK_PROGRESS_BAR (data)->percentage;
if ((pvalue >= 1.0) || (pstat == FALSE)) {
pvalue = 0.0;
pstat = TRUE;
}
pvalue += 0.01;
gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
return TRUE;
}
/* 이 함수는 진행막대의 리셋을 위한 시그널을 낸다. */
void progress_r (void)
{
pstat = FALSE;
}
void destroy (GtkWidget *widget, gpointer data)
{
gtk_main_quit ();
}
int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *label;
GtkWidget *table;
GtkWidget *pbar;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (destroy), NULL);
gtk_container_border_width (GTK_CONTAINER (window), 10);
table = gtk_table_new(3,2,TRUE);
gtk_container_add (GTK_CONTAINER (window), table);
label = gtk_label_new ("Progress Bar Example");
gtk_table_attach_defaults(GTK_TABLE(table), label, 0,2,0,1);
gtk_widget_show(label);
/* 새로운 진행막대를 만들고, 그것을 테이블에 패킹하여 보여준다. */
pbar = gtk_progress_bar_new ();
gtk_table_attach_defaults(GTK_TABLE(table), pbar, 0,2,1,2);
gtk_widget_show (pbar);
/* 진행막대의 자동 업데이트를 위한 timeout을 설정한다. */
ptimer = gtk_timeout_add (100, progress, pbar);
/* 이 버튼이 진행막대를 리셋하는 시그널을 위한 것이다. */
button = gtk_button_new_with_label ("Reset");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (progress_r), NULL);
gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,2,3);
gtk_widget_show(button);
button = gtk_button_new_with_label ("Cancel");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (destroy), NULL);
gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,2,3);
gtk_widget_show (button);
gtk_widget_show(table);
gtk_widget_show(window);
gtk_main ();
return 0;
}
이 작은 프로그램에는 진행막대의 일반적인 동작과 관련된 네 개의 영역이
있다. 그들이 쓰여진 순서에 따라 알아보도록 하자.
pbar = gtk_progress_bar_new ();
이 코드는 pbar라는 이름의 새로운 진행막대를 만들고 있다.
ptimer = gtk_timeout_add (100, progress, pbar);
이 코드에서 일정한 시간간격의 타임아웃을 이용하는데, 진행막대의 이용에 꼭
타임아웃을 써야 되는 것은 아니다.
pvalue = GTK_PROGRESS_BAR (data)->percentage;
여기서 pvalue를 향한 percentage bar의 현재 값을 지정해 주고 있다.
gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
끝으로, pvalue의 값에 의해 진행막대를 업데이트한다.
그리고 진행막대에 대해 알 것은 이것이 전부다, 즐겨보기를 !
8.4 대화상자
대화상자 widget은 매우 간단한 것인데, 실제로 이것은 몇가지가 미리 패킹되어
있는 하나의 윈도일 뿐이다. Dialog를 위한 구조체는 이것이다.
struct GtkDialog
{
GtkWindow window;
GtkWidget *vbox;
GtkWidget *action_area;
};
보다시피 이것은 단순히 윈도를 만들고, 그리고는 vbox를 맨 위로 패킹하고,
다음으로 separator를, 그리고 나서 "action_area"를 위한 hbox를 패킹한다.
대화상자widget은 사용자에게 팝업 메시지를 보이거나 하는 등의 목적으로 쓰일
수 있다. 이것은 정말 기본적인 것으로, 대화박스를 위한 함수는 이것 하나
뿐이다.
GtkWidget* gtk_dialog_new (void);
그래서 새로운 대화박스를 만들려면 이렇게 한다.
GtkWidget *window;
window = gtk_dialog_new ();
이것은 대화상자를 만들 것이고, 어떻게 이용할지는 각자에게 달려있다.
우리는 이런 식으로 해서 action_area 안에 버튼을 패킹할 수 있다.
button = ...
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
TRUE, TRUE, 0);
gtk_widget_show (button);
그리고 우리는 패킹에 의하여 vbox 영역에 라벨 등을 추가할 수 있다. 아래와
같이 해보자.
label = gtk_label_new ("Dialogs are groovy");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, TRUE,
TRUE, 0);
gtk_widget_show (label);
대화상자를 이용한 예제에서처럼, 우리는 action_area에 Cancel과 Ok의 두
버튼을, 그리고 vbox영역엔 사용자에게 물어보거나 에러메시지를 내거나 하는
목적의 라벨을 만들 수 있을 것이다. 그리고 나서 사용자의 선택에 따라
작동하도록 버튼 각각에 서로 다른 시그널을 설정해 둘 수 있다.
8.5 픽스맵
픽스맵은 그림을 포함하고 있는 자료 구조이다. 이런 그림은 여러가지로 쓰일
수 있는데, 가장 눈에 띄는 이용은 X윈도 데스크톱의 아이콘이나 커서일 것이다.
비트맵이란 2색의 픽스맵이다.
GTK에서 픽스맵을 이용하기 위해, 우리는 먼저 GDK 수준의 함수들로써
GdkPixmap 구조체를 만들어야 한다. 픽스맵은 메모리의 자료 혹은 파일로부터
읽어들인 자료로부터 만들어질 수 있다. 우리는 픽스맵을 만들기 위한 각각의
함수를 지금부터 살펴볼 것이다.
GdkPixmap *gdk_bitmap_create_from_data( GdkWindow *window,
gchar *data,
gint width,
gint height );
이 함수는 메모리의 데이터로 2색의 single-plane 픽스맵을 만들기 위한 것으로,
데이터의 각각의 비트는 픽셀의 on/off 여부를 나타낸다. width/height는 픽셀
단위다. 픽스맵 리소스는 그것이 보여질 스크린의 배경에서만 의미가 있으므로,
GdkWindow 형 포인터는 현재의 윈도를 가리키게 된다.
GdkPixmap* gdk_pixmap_create_from_data( GdkWindow *window,
gchar *data,
gint width,
gint height,
gint depth,
GdkColor *fg,
GdkColor *bg );
이것은 주어진 비트맵 데이타로부터 임의의 depth(색의 갯수)를 가진 픽스맵을
만들 때 쓰인다. fg와 bg는 이용할 foreground 및 background 색깔이다.
GdkPixmap* gdk_pixmap_create_from_xpm( GdkWindow *window,
GdkBitmap **mask,
GdkColor *transparent_color,
const gchar *filename );
XPM 포맷은 X윈도시스템에서 읽어들일 수 있는 하나의 픽스맵 형태다. 이것은
널리 쓰이고 있으며 이미지 파일을 이 포맷으로 만들어 주는 수많은 유틸리티들이
있다. 파일이름으로 불리어진 이 파일은 그 포맷의 이미지를 포함하고 있어야
하고, 그것은 픽스맵 구조체 안으로 로드된다. 그 픽스맵의 어떤 비트가 불투명
해야 하는지는 mask가 결정한다. 나머지 모든 비트들은 transparent_color에
의해 정해진 색깔을 가지게 된다. 이것을 이용하는 예제가 아래에 뒤따를
것이다.
GdkPixmap* gdk_pixmap_create_from_xpm_d (GdkWindow *window,
GdkBitmap **mask,
GdkColor *transparent_color,
gchar **data);
작은 이미지는 XPM 포맷의 데이터로서 프로그램 내부에 포함되어 있을 수가
있다. 어떤 픽스맵은 파일로부터 데이터를 읽어들이는 대신 이런 데이터를
이용해 만들어진다. 이 데이터의 예는 이런 것이다.
/* XPM */
static const char * xpm_data[] = {
"16 16 3 1",
" c None",
". c #000000000000",
"X c #FFFFFFFFFFFF",
" ",
" ...... ",
" .XXX.X. ",
" .XXX.XX. ",
" .XXX.XXX. ",
" .XXX..... ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" ......... ",
" ",
" "};
void gdk_pixmap_destroy( GdkPixmap *pixmap );
우리가 어떤 픽스맵을 이용했고 또 당분간 다시 이용할 필요가 없을 경우, 이
리소스를 gdk_pixmap_destory로 메모리에 반납해주는 것도 좋은 생각이다.
픽스맵은 중요한 리소스로 간주되어야 한다.
우리가 일단 픽스맵을 만들면, 그것을 GTK widget처럼 보여줄 수 있다. 우리는
GDK 픽스맵을 포함시키기 위해서 픽스맵widget을 만들어야만 한다. 이것을 이용
해서 그렇게 할 수 있다.
GtkWidget* gtk_pixmap_new( GdkPixmap *pixmap,
GdkBitmap *mask );
또다른 픽스맵widget 함수들은 다음과 같다.
guint gtk_pixmap_get_type( void );
void gtk_pixmap_set( GtkPixmap *pixmap,
GdkPixmap *val,
GdkBitmap *mask);
void gtk_pixmap_get( GtkPixmap *pixmap,
GdkPixmap **val,
GdkBitmap **mask);
gtk_pixmap_set은 widget이 현재 다루고 있는 픽스맵을 변화시키기 위해
이용한다. 인자 val은 GDK를 이용해 만들어진 픽스맵이다.
이 예제는 버튼 안에 픽스맵을 넣는 예제이다.
#include <gtk/gtk.h>
/* Open-File 아이콘을 위한 XPM 데이터 */
static const char * xpm_data[] = {
"16 16 3 1",
" c None",
". c #000000000000",
"X c #FFFFFFFFFFFF",
" ",
" ...... ",
" .XXX.X. ",
" .XXX.XX. ",
" .XXX.XXX. ",
" .XXX..... ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" .XXXXXXX. ",
" ......... ",
" ",
" "};
/* 이것이 호출되면(delete_event 시그널을 통해) 어플이 종료된다. */
void close_application( GtkWidget *widget, GdkEvent *event, gpointer data )
{
gtk_main_quit();
}
/* 버튼이 클릭되면 호출되어 메시지를 프린트한다. */
void button_clicked( GtkWidget *widget, gpointer data )
{
printf( "button clicked\n" );
}
int main( int argc, char *argv[] )
{
/* GtkWidget은 widget을 위한 기억장소 타입이다. */
GtkWidget *window, *pixmapwid, *button;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
/* main 윈도를 만들고, 어플을 끝내기 위한 delete_event 시그널을
* 연결시켜 둔다. */
gtk_init( &argc, &argv );
window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_signal_connect( GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (close_application), NULL );
gtk_container_border_width( GTK_CONTAINER (window), 10 );
gtk_widget_show( window );
/* gdk함수로 픽스맵을 만들기 위한 것이다. */
style = gtk_widget_get_style( window );
pixmap = gdk_pixmap_create_from_xpm_d( window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
(gchar **)xpm_data );
/* 픽스맵을 다룰 pixmap widget이다. */
pixmapwid = gtk_pixmap_new( pixmap, mask );
gtk_widget_show( pixmapwid );
/* pixmap widget을 가지게 되는 버튼이다. */
button = gtk_button_new();
gtk_container_add( GTK_CONTAINER(button), pixmapwid );
gtk_container_add( GTK_CONTAINER(window), button );
gtk_widget_show( button );
gtk_signal_connect( GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(button_clicked), NULL );
/* 윈도를 보인다. */
gtk_main ();
return 0;
}
현재 디렉토리의 icon0.xpm 이라는 XPM 데이터파일을 불러오기 위해서, 우리는
픽스맵을 만들어야 한다.
/* 파일로부터 픽스맵을 불러온다. */
pixmap = gdk_pixmap_create_from_xpm( window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
"./icon0.xpm" );
pixmapwid = gtk_pixmap_new( pixmap, mask );
gtk_widget_show( pixmapwid );
gtk_container_add( GTK_CONTAINER(window), pixmapwid );
픽스맵을 이용할 때 단점 하나는 이미지에 관계없이 모든 대상이 직사각형
이라는 것이다. 우리는 데스크톱과 어플에서 아이콘이 좀더 자연스러운 모양을
가지도록 하고싶다. 예를들어 어떤 게임 인터페이스에서, 우리는 누를 버튼이
둥근 모양을 가지도록 하고 싶어한다. 이렇게 하기 위해서는 특정한 모양을 갖춘
윈도를 이용한다.
특정한 모양을 갖춘 윈도란 간단히 배경을 이루는 픽셀들이 투명한 것을 말한다.
배경 이미지가 여러 색을 띠고 있다면, 이렇게 우리는 우리의 아이콘을 둘러싼
들어맞지 않는 경계인 직사각형으로 겹쳐 그리지 않는다. 이번 예제는 이런
식으로 해서 데스크톱에 수레바퀴 이미지를 보여준다.
/* wheelbarrow.c */
#include <gtk/gtk.h>
/* XPM */
static char * WheelbarrowFull_xpm[] = {
"48 48 64 1",
" c None",
". c #DF7DCF3CC71B",
"X c #965875D669A6",
"o c #71C671C671C6",
"O c #A699A289A699",
"+ c #965892489658",
"@ c #8E38410330C2",
"# c #D75C7DF769A6",
"$ c #F7DECF3CC71B",
"% c #96588A288E38",
"& c #A69992489E79",
"* c #8E3886178E38",
"= c #104008200820",
"- c #596510401040",
"; c #C71B30C230C2",
": c #C71B9A699658",
"> c #618561856185",
", c #20811C712081",
"< c #104000000000",
"1 c #861720812081",
"2 c #DF7D4D344103",
"3 c #79E769A671C6",
"4 c #861782078617",
"5 c #41033CF34103",
"6 c #000000000000",
"7 c #49241C711040",
"8 c #492445144924",
"9 c #082008200820",
"0 c #69A618611861",
"q c #B6DA71C65144",
"w c #410330C238E3",
"e c #CF3CBAEAB6DA",
"r c #71C6451430C2",
"t c #EFBEDB6CD75C",
"y c #28A208200820",
"u c #186110401040",
"i c #596528A21861",
"p c #71C661855965",
"a c #A69996589658",
"s c #30C228A230C2",
"d c #BEFBA289AEBA",
"f c #596545145144",
"g c #30C230C230C2",
"h c #8E3882078617",
"j c #208118612081",
"k c #38E30C300820",
"l c #30C2208128A2",
"z c #38E328A238E3",
"x c #514438E34924",
"c c #618555555965",
"v c #30C2208130C2",
"b c #38E328A230C2",
"n c #28A228A228A2",
"m c #41032CB228A2",
"M c #104010401040",
"N c #492438E34103",
"B c #28A2208128A2",
"V c #A699596538E3",
"C c #30C21C711040",
"Z c #30C218611040",
"A c #965865955965",
"S c #618534D32081",
"D c #38E31C711040",
"F c #082000000820",
" ",
" .XoO ",
" +@#$%o& ",
" *=-;#::o+ ",
" >,<12#:34 ",
" 45671#:X3 ",
" +89<02qwo ",
"e* >,67;ro ",
"ty> 459@>+&& ",
"$2u+ ><ipas8* ",
"%$;=* *3:.Xa.dfg> ",
"Oh$;ya *3d.a8j,Xe.d3g8+ ",
" Oh$;ka *3d$a8lz,,xxc:.e3g54 ",
" Oh$;kO *pd$%svbzz,sxxxxfX..&wn> ",
" Oh$@mO *3dthwlsslszjzxxxxxxx3:td8M4 ",
" Oh$@g& *3d$XNlvvvlllm,mNwxxxxxxxfa.:,B* ",
" Oh$@,Od.czlllllzlmmqV@V#V@fxxxxxxxf:%j5& ",
" Oh$1hd5lllslllCCZrV#r#:#2AxxxxxxxxxcdwM* ",
" OXq6c.%8vvvllZZiqqApA:mq:Xxcpcxxxxxfdc9* ",
" 2r<6gde3bllZZrVi7S@SV77A::qApxxxxxxfdcM ",
" :,q-6MN.dfmZZrrSS:#riirDSAX@Af5xxxxxfevo",
" +A26jguXtAZZZC7iDiCCrVVii7Cmmmxxxxxx%3g",
" *#16jszN..3DZZZZrCVSA2rZrV7Dmmwxxxx&en",
" p2yFvzssXe:fCZZCiiD7iiZDiDSSZwwxx8e*>",
" OA1<jzxwwc:$d%NDZZZZCCCZCCZZCmxxfd.B ",
" 3206Bwxxszx%et.eaAp77m77mmmf3&eeeg* ",
" @26MvzxNzvlbwfpdettttttttttt.c,n& ",
" *;16=lsNwwNwgsvslbwwvccc3pcfu<o ",
" p;<69BvwwsszslllbBlllllllu<5+ ",
" OS0y6FBlvvvzvzss,u=Blllj=54 ",
" c1-699Blvlllllu7k96MMMg4 ",
" *10y8n6FjvllllB<166668 ",
" S-kg+>666<M<996-y6n<8* ",
" p71=4 m69996kD8Z-66698&& ",
" &i0ycm6n4 ogk17,0<6666g ",
" N-k-<> >=01-kuu666> ",
" ,6ky& &46-10ul,66, ",
" Ou0<> o66y<ulw<66& ",
" *kk5 >66By7=xu664 ",
" <<M4 466lj<Mxu66o ",
" *>> +66uv,zN666* ",
" 566,xxj669 ",
" 4666FF666> ",
" >966666M ",
" oM6668+ ",
" *4 ",
" ",
" "};
/* 이것이 호출되면(delete_event 시그널을 통해) 어플이 종료된다. */
void close_application( GtkWidget *widget, GdkEvent *event, gpointer data )
{
gtk_main_quit();
}
int main (int argc, char *argv[])
{
GtkWidget *window, *pixmap, *fixed;
GdkPixmap *gdk_pixmap;
GdkBitmap *mask;
GtkStyle *style;
GdkGC *gc;
/* main윈도를 만들고, 어플을 끝내기 위한 delete_event 시그널을 거기에
* 연결시켜 둔다. main 윈도는 우리가 popup만 되도록 만들었기 때문에
* 타이틀바를 가지지 않을 것이다. */
gtk_init (&argc, &argv);
window = gtk_window_new( GTK_WINDOW_POPUP );
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (close_application), NULL);
gtk_widget_show (window);
/* 픽스맵과 pixmap widget을 위한 것이다. */
style = gtk_widget_get_default_style();
gc = style->black_gc;
gdk_pixmap = gdk_pixmap_create_from_xpm_d( window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
WheelbarrowFull_xpm );
pixmap = gtk_pixmap_new( gdk_pixmap, mask );
gtk_widget_show( pixmap );
/* 픽스맵을 보이기 위해, 우리는 픽스맵을 놓아둘 fixed widget을
* 이용한다. */
fixed = gtk_fixed_new();
gtk_widget_set_usize( fixed, 200, 200 );
gtk_fixed_put( GTK_FIXED(fixed), pixmap, 0, 0 );
gtk_container_add( GTK_CONTAINER(window), fixed );
gtk_widget_show( fixed );
/* 이것은 이미지 자신을 제외한 다른 모든 것을 은폐한다. */
gtk_widget_shape_combine_mask( window, mask, 0, 0 );
/* 윈도를 보인다. */
gtk_widget_set_uposition( window, 20, 400 );
gtk_widget_show( window );
gtk_main ();
return 0;
}
수레바퀴 이미지를 더 섬세하게 만들기 위해, 우리는 버튼이 눌려진 이벤트의
시그널이 수레바퀴에 어떤 동작을 하도록 엮어줄 수 있다. 여기 보이는 몇 줄의
코드는 마우스버튼이 눌려졌을 때 어플이 끝나도록 해준다.
gtk_widget_set_events( window,
gtk_widget_get_events( window ) |
GDK_BUTTON_PRESS_MASK );
gtk_signal_connect( GTK_OBJECT(window), "button_press_event",
GTK_SIGNAL_FUNC(close_application), NULL );
8.6 룰러(ruler)
룰러 widget은 주어진 한 윈도에서 마우스 포인터의 위치를 가리키는데 쓰인다.
윈도는 폭을 가로지르는 수평 룰러와 높이를 가로지르는 수직룰러를 가질 수 있다.
룰러 위의 조그만 삼각형 표시기(indicator)가 룰러에 대한 포인터의
정확한 위치를 보여준다.
룰러는 반드시 미리 먼저 만들어져야만 한다. 수평 및 수직 룰러는 다음 함수들을
이용해서 만들어진다.
GtkWidget *gtk_hruler_new(void); /* 수평 룰러 */
GtkWidget *gtk_vruler_new(void); /* 수직 룰러 */
룰러가 한번 만들어지면 측정단위를 정의할 수 있다. 룰러의 측정단위는
GTK_PIXELS나 GTK_INCHES, GTK_CENTIMETERS 중의 하나가 된다.
void gtk_ruler_set_metric( GtkRuler *ruler,
GtkMetricType metric );
기본 설정 단위는 GTK_PIXELS이다.
gtk_ruler_set_metric( GTK_RULER(ruler), GTK_PIXELS );
또다른 중요한 룰러의 특성은 어떻게 크기 단위를 나타내느냐 하는 점과
표시기가 처음 어디에 놓이냐하는 점이다. 이들은 다음 함수로 결정한다.
void gtk_ruler_set_range (GtkRuler *ruler,
gfloat lower,
gfloat upper,
gfloat position,
gfloat max_size);
인자 lower와 upper는 룰러의 범위를 정의하고 max_size는 출력 가능한
가장 큰 수를 설정한다. Position은 룰러 내의 표시기 초기 위치이다.
800 픽셀의 수직 룰러는 이렇게 된다.
gtk_ruler_set_range( GTK_RULER(vruler), 0, 800, 0, 800);
0부터 800까지 매 100 픽셀마다 표지(marking)가 출력될 것이다.
만일 룰러의 범위를 7부터 16으로 바꾸려면 다음과 같이 한다.
gtk_ruler_set_range( GTK_RULER(vruler), 7, 16, 0, 20);
룰러의 표시기는 포인터의 상대적인 위치를 가리키는 조그만 삼각형 표지이다.
만일 룰러가 마우스 포인터를 따르게 하고 싶다면 motion_notify_event 시그널이
룰러의 motion_notify_event method와 연결되어야만 한다. 특정 윈도 영역 내의
모든 마우스 움직임을 따르게 하기 위해 다음과 같이 한다.
#define EVENT_METHOD(i, x) GTK_WIDGET_CLASS(GTK_OBJECT(i)->klass)->x
gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
(GtkSignalFunc)EVENT_METHOD(ruler, motion_notify_event),
GTK_OBJECT(ruler) );
다음 예제는 수평 룰러를 위에 수직 룰러를 왼쪽에 가진 drawing area를
만든다. 이 drawing area는 600 픽셀의 폭과 400 픽셀의 높이를 가진다.
수평 룰러는 7부터 13의 범위에 매 100 픽셀마다 표지를 하고
수직 루러는 0부터 400의 범위에 마찬가지로 매 100 픽셀마다 표지를 한다.
룰러들과 drawing area의 위치 설정은 테이블을 사용한다.
/* rulers.c */
#include <gtk/gtk.h>
#define EVENT_METHOD(i, x) GTK_WIDGET_CLASS(GTK_OBJECT(i)->klass)->x
#define XSIZE 600
#define YSIZE 400
/* 닫기 버튼(close button)이 눌러지면 이 함수가 불린다.
*/
void close_application( GtkWidget *widget, gpointer data ) {
gtk_main_quit();
}
/* 메인 함수
*/
int main( int argc, char *argv[] ) {
GtkWidget *window, *table, *area, *hrule, *vrule;
/* gtk를 초기화하고 메인 윈도를 만든다.*/
gtk_init( &argc, &argv );
window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC( close_application ), NULL);
gtk_container_border_width (GTK_CONTAINER (window), 10);
/* 룰러와 drawing area를 놓은 테이블을 만든다 */
table = gtk_table_new( 3, 2, FALSE );
gtk_container_add( GTK_CONTAINER(window), table );
area = gtk_drawing_area_new();
gtk_drawing_area_size( (GtkDrawingArea *)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 );
/* 수평 룰러는 가장 위에 놓인다. 마우스가 drawing area 위를 움직이면,
motion_notify_event 가 룰러의 적절한 이벤트 핸들러에게 전달된다.
*/
hrule = gtk_hruler_new();
gtk_ruler_set_metric( GTK_RULER(hrule), GTK_PIXELS );
gtk_ruler_set_range( GTK_RULER(hrule), 7, 13, 0, 20 );
gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
(GtkSignalFunc)EVENT_METHOD(hrule, motion_notify_event),
GTK_OBJECT(hrule) );
/* GTK_WIDGET_CLASS(GTK_OBJECT(hrule)->klass)->motion_notify_event, */
gtk_table_attach( GTK_TABLE(table), hrule, 1, 2, 0, 1,
GTK_EXPAND|GTK_SHRINK|GTK_FILL, GTK_FILL, 0, 0 );
/* 수직 룰러는 제일 왼쪽에 놓인다. 마우스가 drawing area 위를 움직이면,,
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 );
gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
(GtkSignalFunc)
GTK_WIDGET_CLASS(GTK_OBJECT(vrule)->klass)->motion_notify_event,
GTK_OBJECT(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;
}
8.7 상태표시줄(statusbar)
상태표시줄은 텍스트 메시지를 보여주는데 쓰이는 간단한 widget이다.
이 widget은 텍스트 메시지들을 스택에 보관한다. 따라서 현재의 메시지를 꺼내면
바로 이전의 메시지를 다시 보여주게 된다.
한 어플리케이션의 여러 부분들이 메시지를 표시하는데 같은 상태표시줄을
사용해야하는 경우, 상태표시줄 widget은 여러 '사용자'들을 구분하는데 쓰이는
Context Identifier를 발행한다. 어떤 context를 가졌느냐에 상관없이 스택
제일 위의 메시지가 보여진다.
메시지들은 Context Identifier의 순서가 아니라 나중에 들어간 것이 먼저
나오는 순서로 스택에 쌓인다.
상태표시줄은 다음 함수를 통해 만들어진다.
GtkWidget* gtk_statusbar_new (void);
새로운 Context Identifier는 간단한 context에 관한 설명과 함께 다음 함수를
호출하여 얻을 수 있다.
guint gtk_statusbar_get_context_id (GtkStatusbar *statusbar,
const gchar *context_description);
상태표시줄을 다루는 다음과 같은 함수들이 있다.
guint gtk_statusbar_push (GtkStatusbar *statusbar,
guint context_id,
gchar *text);
void gtk_statusbar_pop (GtkStatusbar *statusbar)
guint context_id);
void gtk_statusbar_remove (GtkStatusbar *statusbar,
guint context_id,
guint message_id);
먼저 gtk_statusbar_push는 상태표시줄에 새로운 메시지를 추가하는데 쓰인다.
이 함수는 나중에 gtk_statusbar_remove를 호출하는데 쓰일 수 있는
Message Identifier를 리턴한다. gtk_statusbar_remove는 주어진
Message와 Context Identifier의 메시지를 상태표시줄에서 제거한다.
gtk_statusbar_pop은 주어진 Context Identifier의 스택 제일 위 메시지를
꺼내 삭제한다.
다음 예제는 버튼 2개와 상태표시줄 하나를 만든다. 벼튼 하나는 상태표시줄에
새 메시지를 넣고 나머지 다른 버튼은 마지막으로 넣어진 메시지를 제거한다.
/* statusbar.c */
#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), (guint) &data, buff);
return;
}
void pop_item (GtkWidget *widget, gpointer data)
{
gtk_statusbar_pop( GTK_STATUSBAR(status_bar), (guint) &data );
return;
}
int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *button;
int context_id;
gtk_init (&argc, &argv);
/* 새 윈도를 하나 만든다 */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
gtk_window_set_title(GTK_WINDOW (window), "GTK Statusbar Example");
gtk_signal_connect(GTK_OBJECT (window), "delete_event",
(GtkSignalFunc) gtk_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");
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC (push_item), &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");
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC (pop_item), &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;
}
8.8 텍스트 입력(text entry)
텍스트 입력 widget은 한줄짜리 텍스트 상자 안에 문자를 타이프해 넣거나
또는 그냥 보여줄 수 있게 해준다. 텍스트는 현 입력 widget의 내용을
추가하거나 또는 완전히 대체하는 함수 호출들에 의해 결정된다.
텍스트 입력 widget을 만드는데는 다음 두 함수를 사용한다.
GtkWidget* gtk_entry_new (void);
GtkWidget* gtk_entry_new_with_max_length (guint16 max);
처음 것은 단순히 새로운 입력 widget을 하나 만든다. 그에 반해 두번째 것은
편집가능한 텍스트의 길이 제한을 가진 입력 widget을 만든다.
현 입력의 텍스트를 변경하는데 쓰이는 몇가지 함수가 존재한다.
void gtk_entry_set_text (GtkEntry *entry,
const gchar *text);
void gtk_entry_append_text (GtkEntry *entry,
const gchar *text);
void gtk_entry_prepend_text (GtkEntry *entry,
const gchar *text);
함수 gtk_entry_set_text은 입력된 내용을 완전히 변경한다.
함수 gtk_entry_append_text와 gtk_entry_prepend_text는 현 내용의 앞 또는
뒤에 원하는 텍스트를 덧붙인다.
다음 함수는 현재의 텍스트 입력 위치를 정한다.
void gtk_entry_set_position (GtkEntry *entry,
gint position);
입력 widget의 내용은 다음 함수 호출에 의해서 알 수 있다.
이것은 나중에 설명할 callback 함수 안에서 사용하는 것이 유용하다.
gchar* gtk_entry_get_text (GtkEntry *entry);
만일 입력된 내용이 타이핑에 의해서 변경되는 것을 원하지 않는다면
편집이 불가능하도록 상태를 바꿀 수 있다.
void gtk_entry_set_editable (GtkEntry *entry,
gboolean editable);
이 함수의 editable 인자에 TRUE나 FALSE를 주어 입력 widget이 편집 가능하게 되거나
또는 가능하지 않도록 변경할 수 있다.
만약 패스워드를 입력할 때처럼 입력하는 텍스트가 보이지 않아야 한다면
boolean flag를 갖는 다음 함수를 사용한다.
void gtk_entry_set_visibility (GtkEntry *entry,
gboolean visible);
다음 함수를 써서 텍스트의 일정 부분을 선택(selected)되도록 만들 수 있다.
이 기능은 미리 기본 텍스트를 정해 출력하고 이를 사용자가 새로운 입력을 위해서
간단히 지울 수 있게 하는데 자주 쓰인다.
void gtk_entry_select_region (GtkEntry *entry,
gint start,
gint end);
만약에 사용자가 텍스트를 입력하는 것을 알아채고 싶다면,
activate나 changed 시그널을 연결할 수 있다.
Activate는 사용자가 엔터키를 타이프하면, Changed는 텍스트가 전부 다른 것으로
바뀌면 발생한다.(모든 문자가 입력되었거나 지워졌을 때 등)
다음은 텍스트 입력 widget의 한 예이다.
/* entry.c */
#include <gtk/gtk.h>
void enter_callback(GtkWidget *widget, GtkWidget *entry)
{
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_entry_set_editable(GTK_ENTRY(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;
gtk_init (&argc, &argv);
/* create a new window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
gtk_window_set_title(GTK_WINDOW (window), "GTK Entry");
gtk_signal_connect(GTK_OBJECT (window), "delete_event",
(GtkSignalFunc) gtk_exit, NULL);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
entry = gtk_entry_new_with_max_length (50);
gtk_signal_connect(GTK_OBJECT(entry), "activate",
GTK_SIGNAL_FUNC(enter_callback),
entry);
gtk_entry_set_text (GTK_ENTRY (entry), "hello");
gtk_entry_append_text (GTK_ENTRY (entry), " world");
gtk_entry_select_region (GTK_ENTRY (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);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
gtk_toggle_button_set_state(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);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
gtk_widget_show (check);
button = gtk_button_new_with_label ("Close");
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(gtk_exit),
GTK_OBJECT (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);
}
8.9 색 선택(color selection)
색선택 widget은, 사실 전혀 놀랍지 않겠지만, 직접 색을 선택하는데 쓰인다.
이 복합적인 widget은 사용자로 하여금 RGB(Red, Green, Blue)와
HSV (Hue, Saturation, Value) 세 요소를 통해 색을 고르게 한다.
이는 슬라이더나 입력창을 이용해서 각 요소에 특정 값을 주게하거나 또는,
hue-saturation wheel에서 직접 색을 선택하게 함으로써
이루어진다. 필요에 따라서는 색의 투명도도 정해줄 수 있다.
이 색선택 widget은 외부에서 gtk_color_selection_set_color()을 통해
지정했거나 또는 사용자가 직접 현재 색을 변경할 때마다
"color_changed"이라는 단 한가지의 시그널만을 발생시킨다.
이 색선택 widget이 우리에게 무엇을 넘겨주어야 하는지 보자. 이 widget은
gtk_color_selection와 gtk_color_selection_dialog의 두 형태가 있다.
GtkWidget *gtk_color_selection_new(void);
대개 이 함수만을 직접 쓸 수는 없다. 이것은 나중에 어딘가로 연결을 시켜주어야만
하는 GtkColorSelection widget을 만들 따름이다.
이 GtkColorSelection widget은 GtkVBox widget에서 상속된 것이다.
GtkWidget *gtk_color_selection_dialog_new(const gchar *title);
대개 이 함수를 색선택 widget을 만드는 데 사용한다.
이는 GtkColorSelectionDialog라는 GtkDialog에서 상속된 widget을 만든다.
이 widget은 GtkColorSelection, GtkHSeparator와 "Ok", "Cancel", "Help"의
버튼 세개를 가진 GtkHBox들을 포함한 GtkFrame widget으로 이루어져있다.
GtkColorSelectionDialog structure에서 "ok_button", "cancel_button",
"help_button" widget에 접근해서 그 세 버튼들을 직접 다룰 수 있다.
(예 : GTK_COLOR_SELECTION_DIALOG(colorseldialog)->ok_button)
void gtk_color_selection_set_update_policy(GtkColorSelection *colorsel,
GtkUpdateType policy);
이 함수는 갱신 정책을 정한다. 기본 정책은 사용자가 무엇이든 변경하는
그때마다 바로 즉시 현재의 색을 거기에 따라 바꾸는 GTK_UPDATE_CONTINOUS이다.
성능문제가 발생하면 GTK_UPDATE_DISCONTINOUS나 GTK_UPDATE_DELAYED로
바꾸어 줄 수 있다.
void gtk_color_selection_set_opacity(GtkColorSelection *colorsel,
gint use_opacity);
색선택 widget은 색의 투명도(알파채널이라고도 알려진)를 조정하는 기능도 지원한다.
이 기능은 기본 설정에서는 꺼져있다. 이것을 사용하려면 위의 함수를
use_opacity를 TRUE로 해서 호출한다.
마찬가지로 use_opacity를 FALSE로 해서 호출하면 투명도 조정 기능이 꺼진다.
void gtk_color_selection_set_color(GtkColorSelection *colorsel,
gdouble *color);
색상 array(gdouble)와 함께 위 함수를 호출하여 외부에서 현재 색을
지정해 줄 수 있다. 이 array의 길이는 색 투명도 조정 기능을 켜놓았는지
꺼놓았는지에 따라 달라진다. 위치 0은 빨간색, 1은 녹색, 2는 파란색이며
3은 투명도이다.(투명도는 이 기능을 켜놓았을 때만 의미가 있다.
앞에서 나온 gtk_color_selection_set_opacity()에 대한 부분을 보라.)
모든 값은 0.0과 1.0 사이에 있다.
void gtk_color_selection_get_color(GtkColorSelection *colorsel,
gdouble *color);
만일 'color_changed" 시그널을 받았을 때, 현재 색이 어떤 것이지 알고 싶다면
위의 함수를 사용하면 된다. Color는 색 array이다. 이 색 array에 대한 것은
gtk_color_selection_set_color() 함수에 대한 부분을 보라.
다음은 GtkColorSelectionDialog을 사용하는 간단한 예이다. 이 프로그램은
drawing area를 가진 윈도 하나를 만든다. 이것을 클릭하면
color selection dialog가 뜬다. 이를 조정해서 배경색을 바꿀 수 있다.
#include <glib.h>
#include <gdk/gdk.h>
#include <gtk/gtk.h>
GtkWidget *colorseldlg = NULL;
GtkWidget *drawingarea = NULL;
/* 색이 바뀌면 이 함수를 부른다. */
void color_changed_cb (GtkWidget *widget, GtkColorSelection *colorsel)
{
gdouble color[3];
GdkColor gdk_color;
GdkColormap *colormap;
/* drawing area의 colormap을 얻는다 */
colormap = gdk_window_get_colormap (drawingarea->window);
/* 현재 색을 얻는다 */
gtk_color_selection_get_color (colorsel,color);
/* unsigned 16 bit 정수(0..65535)로 바꿔서 GdkColor에 넣는다 */
gdk_color.red = (guint16)(color[0]*65535.0);
gdk_color.green = (guint16)(color[1]*65535.0);
gdk_color.blue = (guint16)(color[2]*65535.0);
/* 색을 할당한다 */
gdk_color_alloc (colormap, &gdk_color);
/* 윈도의 배경색을 정한다 */
gdk_window_set_background (drawingarea->window, &gdk_color);
/* 윈도를 지운다 */
gdk_window_clear (drawingarea->window);
}
/* Drawingarea event handler */
gint area_event (GtkWidget *widget, GdkEvent *event, gpointer client_data)
{
gint handled = FALSE;
GtkWidget *colorsel;
/* 버튼이 눌러졌는지 확인한다 */
if (event->type == GDK_BUTTON_PRESS && colorseldlg == NULL)
{
/* Yes, we have an event and there's no colorseldlg yet! */
handled = TRUE;
/* color selection dialog를 만든다 */
colorseldlg = gtk_color_selection_dialog_new("Select background color");
/* GtkColorSelection widget을 구한다 */
colorsel = GTK_COLOR_SELECTION_DIALOG(colorseldlg)->colorsel;
/* "color_changed" 시그널을 widget에 연결한다. */
gtk_signal_connect(GTK_OBJECT(colorsel), "color_changed",
(GtkSignalFunc)color_changed_cb, (gpointer)colorsel);
/* color seclection dialog를 보인다 */
gtk_widget_show(colorseldlg);
}
return handled;
}
/* 윈도를 닫고 핸들러에서 빠져나간다 */
void destroy_window (GtkWidget *widget, gpointer client_data)
{
gtk_main_quit ();
}
/* Main */
gint main (gint argc, gchar *argv[])
{
GtkWidget *window;
/* 툴킷을 초기화하고 gtk와 관련된 명령입력 요소들을 없앤다. */
gtk_init (&argc,&argv);
/* toplevel 윈도를 만들고 제목과 policy를 정한다 */
windo
|
