23.4.1. Рождение, смерть и состояния виджита
После создания виджита управление ресурсами и памятью, необходимыми ему, выполняется автоматически. Виджиты уничтожаются также автоматически — при разрушении главного окна. Но иногда бывает нужно самостоятельно уничтожить виджит. Сделать это можно с помощью функции:
void gtk_widget_destroy(GtkWidget *widget);
Эта функция объявлена в файле gtk/gtkwidget.h. При уничтожении виджита также уничтожаются все его дочерние виджиты.
Если вы освобождаете виджит из контейнера функцией:
void gtk_container_remove(GtkContainer *cont, GtkWidget *w);
то виджит также будет разрушен.
Иногда нужно переместить виджит из одного контейнера в другой без его уничтожения. Это можно сделать так (мы будем перемещать надпись):
gtk_widget_ref(GTK_WIDGET(label));
gtk_container_remove(GTK_CONTAINER(cont1), label);
gtk_container_add(GTK_CONTAINER(cont2), label);
«Спрятать» виджит можно с помощью функции
void gtk_widget_hide(GtkWidget *w);
Отобразить виджит снова поможет функция gtk_widget_show().
Виджит может находиться в одном из состояний:
♦ GTK_STATE_NORMAL — нормальное;
♦ GTK_STATE_ACTIVE — активное (например, нажата кнопка);
♦ GTK_STATE_PRELIGTH — над виджитом находится указатель мыши;
♦ GTK_STATE_SELECTED — виджит выбран (установлен фокус ввода);
♦ GTK_STATE_INSENSITIVE — виджит не реагирует на ввод (сигналы).
Определить состояние виджита можно так:
GTK_WIDGET(w)->state
или с помощью макроса:
GTK_WIDGET_STATE(wid)
описанного в файле gtk/gtkwidget.h.
Сделать виджит неактивным можно так:
gtk_widget_set_sensitive(widget, FALSE);
Если второй параметр функции gtk_widget_set_sensitive() будет равен TRUE, виджит widget станет активным.
Чтобы наш виджит получил фокус ввода, нужно использовать функцию:
gtk_widget_grab_focus(widget);
23.4.2. Упаковка виджитов, поля ввода и кнопки
Для размещения (упаковки) виджита в окне используются контейнеры. Существуют два основных вида контейнеров. Первый вид в качестве прародителя использует объект класса GtkBin, а второй — объект класса GtkContainer. Контейнеры первого вида могут иметь только один дочерний виджит, поэтому они используются для создания специфических интерфейсов: одной кнопки, рамки, окна.
Контейнеры второго вида более функциональны — они могут иметь много дочерних виджитов. Чаще всего используются контейнеры:
♦ GtkHBox — позволяет размещать виджиты горизонтально;
♦ GtkVBox — используется для вертикального размещения виджитов;
♦ GtkFixed — позволяет размещать виджиты в фиксированных координатах;
♦ GtkTable — позволяет упаковывать виджиты в виде таблицы.
Наиболее удачным, на мой взгляд, является контейнер GtkTable, поэтому в этом параграфе мы рассмотрим именно его. GtkTable может с успехом заменить и горизонтальный, и вертикальный контейнеры — что нам стоит задать таблицу, состоящую или одной строки или одного столбца?
Кроме контейнера GtkTable, в этом параграфе будут рассмотрены:
♦ поля для ввода текста и обработка введенной информации;
♦ кнопки;
♦ файловый ввод/вывод.
Сейчас мы напишем небольшой конфигуратор, который будет вносить изменения в файл
/etc/resolv.conf
. Напомню вам формат этого файла:domain firma.ru
nameserver 192.168.0.1
nameserver 192.168.0.2
Директива domain определяет наш домен, а две директивы nameserver — первый и второй DNS-серверы, соответственно. Наш конфигуратор не будет вносить изменения в настоящий файл
/etc/resolv.conf
— для этого нужны права суперпользователя. При желании можно будет потом скопировать файл resolv.conf
, сгенерированный нашей программой, в каталог /etc
.На рисунке 23.2 изображена уже готовая программа. Работает она так. Когда пользователь введет что-нибудь в поле ввода и нажмет Enter, программа отобразит введенный им текст на консоли. Когда пользователь нажмет OK, введенная им информация будет еще раз выведена на консоль и записана в файл. При нажатии кнопки Quit программа завершит свою работу. Она должна также завершить работу при нажатии кнопки закрытия окна — в GTK программист сам определяет реакции на стандартные кнопки.
Рис. 23.3. Учебный конфигуратор
Как видно из рисунка, нам понадобятся три поля ввода, три надписи и две кнопки. Поля ввода мы будем хранить в массиве:
GtkWidget *edit[3];
Создать поле для ввода можно с помощью функции gtk_entry_new():
edit[i] = gtk_entry_new();
После создания поля необходимо вызвать функцию gtk_entry_set_editable(), иначе пользователь ничего не сможет ввести в это поле.
gtk_entry_set_editable(GTK_ENTRY(edit[i]), 1);
Ну и, само собой разумеется, нужно установить реакцию на нажатие клавиши Enter — сигнал activate:
gtk_signal_connect(GTK_OBJECT(edit[i]), "activate",
GTK_SIGNAL_FUNC(enter_callback), edit[i]);
Весьма желательно на этапе отладки программы видеть введенную информацию на консоли. Для этого нужно написать такую функцию enter_callback(), которая выводила бы содержимое поля на консоль. Получить введенную пользователем информацию очень легко:
domain = gtk_entry_get_text(GTK_ENTRY(edit[0]));
dns1 = gtk_entry_get_text(GTK_ENTRY(edit[1]));
dns2 = gtk_entry_get_text(GTK_ENTRY(edit[2]))?
Реакция на нажатие кнопки OK будет следующей:
void writetofile(GtkWidget *widget, gpointer data) {
/* С помощью функции gtk_entry_get_text() мы получаем
введенный пользователем текст из полей ввода */
domain = gtk_entry_get_text(GTK_ENTRY(edit[0]));
dns1 = gtk_entry_get_text(GTK_ENTRY(edit[1]));
dns2 = gtk_entry_get_text(GTK_ENTRY(edit[2]));
/* Выводим прочитанный текст на консоль */
g_print("Domain %s\n", domain);
g_print("DNS1 %s\n", dns1);
g_print("DNS2 %s\n", dns2);
/* Перезаписываем файл resolv.conf в текущем каталоге */
if ((resolv = fopen("resolv.conf","w")) == NULL) {
/* Наверное, нет места на диске или прав маловато... */
g_print("ERR: Cannot open resolve.conf file\n");
gtk_main_quit();
}
/* Запись в файл */
fprintf(resolv,"domain %s\n",domain);
fprintf(resolv, "nameserver %s\n",dns1);
fprintf(resolv,"nameserver %s\n*,dns2);
fclose(resolv);
}
Если ваше окно должно содержать много надписей, то я рекомендую вам поступать так: объявить всего одну переменную, затем создать надпись, поместить ее в контейнер, затем опять создать надпись с использованием этой же переменной, поместить ее в контейнер и т.д. Примерно так:
label = gtk_label_new("Domain: ");
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
gtk_widget_show(label);
label = gtk_label_new("DNS #1; ");
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
gtk_widget_show (label);
label = gtk_label_new("DNS #2: ");
gtk_table_attach_defaults (GTK_TABLE(table), label, 0, 1, 2, 3);
gtk_widget_show (label);
Листинг 23.6 содержит полный код конфигуратора Resolver.
Листинг 23.6. Файл resolver.c
#include
#include
#include
gchar *domain, *dns1, *dns2;
/* Массив из трех полей ввода. Первое предназначено для
ввода имени домена, два вторых - [1] и [2] - для ввода
IP-адресов серверов DNS */
GtkWidget *edit[3];
/* Наш файл */
FILE *resolv;
/* Функция записи в файл */
void writetofile(GtkWidget *widget, gpointer data) {
/* С помощью функции gtk_entry_get_text() мы получаем
введенный пользователем текст из полей ввода */
domain = gtk_entry_get_text(GTK_ENTRY(edit[0]));
dns1 = gtk_entry_get_text(GTK_ENTRY(edit[1]));
dns2 = gtk_entry_get_text(GTK_ENTRY(edit[2]));
/* Выводим прочитанный текст на консоль */
g_print("Domain %s\n", domain);
g_print("DNS1 %s\n", dns1);
g_print("DNS2 %s\n", dns2);
/* Перезаписываем файл resolv.conf в текущем каталоге */
if ((resolv = fopen("resolv.conf","w")) == NULL) {
/* Наверное, нет места на диске или прав маловато... */
g_print("ERR: Cannot open resolve.conf file\n");
gtk_main_quit();
}
/* Запись в файл */
fprintf(resolv,"domain %s\n",domain);
fprintf(resolv,"nameserver %s\n",dns1);
fprintf(resolv,"nameserver %s\n",dns2);
fclose(resolv);
}
/* Эта функция будет запущена, когда пользователь нажмет
кнопку закрытия окна или кнопку Quit */
gint delete_event(GtkWidget *widget, GdkEvent *event,
gpointer data) {
/* Функция gtk_main_quit() используется для завершения
работы GTK-программы. Не нужно для этого использовать
exit() */
gtk_main_quit();
return(FALSE);
}
/* Когда пользователь введет текст и нажмет Enter,
введенный им текст будет выведен на консоль */
void enter_callback(GtkWidget *widget,
GtkWidget *entry) {
domain = gtk_entry_get_text(GTK_ENTRY(entry));
printf("Domain: %s\n", domain);
}
int main(int argc, char *argv[]) {
GtkWidget *window; /* Окно */
GtkWidget *button; /* Кнопка */
GtkWidget *table; /* Таблица для размещения виджитов */
GtkWidget *label; /* Надпись */
/* Как видите, все виджиты одного типа — GtkWidget,
поэтому мы могли бы обойтись даже тремя виджитами — для
окна, таблицы и для всех остальных элементов GUI*/
int i;
/* Инициализация любой GTK-программы */
gtk_init (&argc, &argv);
/* Создаем новое окно */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/* Устанавливаем заголовок окна */
gtk_window_set_title (GTK_WINDOW(window), "Resolver");
/* Устанавливаем реакцию на кнопку закрытия окна.
Сигнал - delete_event. Вызываем функцию delete_event(),
которая описана выше */
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC(delete_event), NULL);
/* Устанавливаем рамку окна */
gtk_container_set_border_width(GTK_CONTAINER (window), 20);
/* Создаем таблицу 3x3 */
table = gtk_table_new (3, 3, TRUE);
/* Помещаем таблицу в контейнер. Обязательно! */
gtk_container_add(GTK_CONTAINER (window), table);
/* Рисуем надписи, помещаем их в таблицу и отображаем.
Обратите внимание, что в этом случае нам не нужно объявлять
отдельную переменную для каждой надписи */
label = gtk_label_new("Domain: ");
/* О координатах ячеек поговорим после этого листинга */
gtk_table_attach_defaults(GTK_TABLE(table),
label, 0, 1, 0, 1);
gtk_widget_show(label);
label = gtk_label_new("DNS #1: ");
gtk_table_attach_defaults(GTK_TABLE(table),
label, 0, 1, 1, 2);
gtk_widget_show(label);
label = gtk_label_new("DNS #2: ");
gtk_table_attach_defaults(GTK_TABLE(table),
label, 0, 1, 2, 3);
gtk_widget_show (label);
/* Заполняем наш массив полей ввода. По аналогии с Delphi,
я назвал массив edit[]*/
for (i=0; i<3; i++) {
/* Новое поле */
edit[i] = gtk_entry_new();
/* Если забыть этот оператор, пользователь ничего не
сможет ввести */
gtk_entry_set_editable(GTK_ENTRY(edit[i]), 1);
/* Определяем одну для всех реакцию на сигнал activate -
нажатие Enter*/
gtk_signal_connect(GTK_OBJECT(edit[i]), "activate",
GTK_SIGNAL_FUNC(enter_callback), edit[i]);
/* Помещаем edit[i] в таблицу */
gtk_table_attach_defaults (GTK_TABLE(table),
edit[i], 1, 2, i, i+1);
/* Показываем */
gtk_widget_show(edit[i]);
}
/* Создаем кнопку "OK", помещаем в таблицу,
определяем реакцию на нажатие и показываем */
button = gtk_button_new_with_label("OK");
gtk_table_attach_defaults(GTK_TABLE(table),
button, 2, 3, 0, 1);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(writetofile), NULL);
gtk_widget_show(button);
/* То же самое для кнопки Quit */
button = gtk_button_new_with_label("Quit");
gtk_table_attach_defaults(GTK_TABLE(table),
button, 2, 3, 2, 3);
gtk_signal_connect(GTK_OBJECT(button),"clicked",
GTK_SIGNAL_FUNC(delete_event), NULL);
gtk_widget_show(button);
gtk_widget_show(table); /* Показываем таблицу */
gtk_widget_show(window); /* Показываем окно */
/* Запускаем GTK-программу */
gtk_main();
return 0;
}
Я старался писать подробные комментарии, но все же кое-что осталось в тумане. Это координаты ячеек. Рассмотрим нашу таблицу 3×3:
table = gtk_table_new(3, 3, TRUE);
0 1 2 3
Domain Поле OK
1
DNS1 Поле
2
DNS2 Поле Quit
3
Сначала указываются координаты по X, затем — по Y. Вот координаты кнопки OK: 2, 3, 0, 1. Это означает, что кнопка будет расположена в последнем столбце (между 2 и 3), но в первой строке (между 0 и 1).
gtk_table_attach_defaults(GTK_TABLE(table), button,
2, 3, 0, 1);
Подробнее рассматривать контейнер GtkTable я не вижу смысла: основные операции, я думаю, вам понятны — это создание таблицы с указанием ее размерности и добавление в таблицу виджита функцией gtk_table_attach_defaults(). Еще раз напомню о необходимости отображения виджитов, помещенных в таблицу, и самой таблицы:
gtk_widget_show (table);
Теперь откомпилируем нашу программу:
$ gcc resolv.с -о resolv `gtk-config --cflags` `gtk-config --libs`
Программа gtk-config сообщает компилятору всю необходимую информацию о библиотеке GTK.
Обратите внимание на директиву
#include
Обычно файлы заголовков GTK находятся в другом каталоге, например, gtk-1.2, но это не имеет значения — все необходимые параметры укажет программа gtk-config.
В заключение этого пункта перечислим события, характерные для кнопок (таблица 23.3).
События кнопок Таблица 23.3
Событие Описание clicked Щелчок pressed Кнопка нажата мышью (и пока не отпущена) released Кнопка отпущена enter Указатель мыши в пределах кнопки leave Указатель мыши вышел за пределы кнопки
23.4.3. Переключатели
Переключатели бывают двух типов: зависимые (radio buttons) и независимые (checkbuttons). Переключатели являются кнопками, поэтому для них характерны те же события, что и для кнопок.
Начнем с независимых переключателей, так как они проще в реализации. Создать такой переключатель можно с помощью одной из функций:
GtkWidget *gtk_check_button_new(void);
GtkWidget *gtk_check_button_new_with_label(gchar * label);
Первая создает переключатель без надписи (если вы хотите указать надпись отдельно), а вторая — с надписью, которая обычно отображается справа от переключателя. Затем нужно, как всегда, поместить виджиты в контейнер и отобразить.
Зависимые переключатели можно создать тоже с помощью двух аналогичных функций:
GtkWidget *gtk_radio_button_new(GSList *group);
GtkWidget *gtk_radio_button_new_with_label(GSList *group,
gchar *label);
Параметр group указывает на принадлежность переключателя к группе. В пределах группы активным может быть только один переключатель. Группу можно создать функцией:
GSList *gtk_radio_button_group(
GtkRadioButton *radio_button);
Однако существует другой способ, позволяющий обойтись без переменной группы — так мы сэкономим память, если групп много:
button2 = gtk_radio_button_new_with_label(
gtk_radio_button_group(GTK_RADIO_BUTTON(button1)),
"button2");
С помощью функции
void gtk_toggle_button_set_active(
GtkToggleButton *toggle_button, gint state);
можно сделать одну из кнопок активной.
Следующий листинг демонстрирует работу с тремя зависимыми переключателями и вертикальным контейнером GtkVBox.
Листинг 23.7. Зависимые переключатели
#include
#include
gint close_application( GtkWidget *widget,
GdkEvent * event, gpointer data) {
gtk_main_quit();
return(FALSE);
}
int main(int argc, char *argv[]) {
GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *separator;
GSList *group;
gtk_init(&argc,&argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(close_application), NULL);
gtk_window_set_title(GTK_WINDOW(window),
"Выберите дистрибутив");
gtk_container_set_border_width(GTK_CONTAINER(window), 0);
box1 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), box1);
gtk_widget_show(box1);
box2 = gtk_vbox_new(FALSE, 10);
gtk_container_set_border_width(GTK_CONTAINER (box2), 10);
gtk_box_pack_start(GTK_BOX(box1), box2, TRUE, TRUE, 0);
gtk_widget_show(box2);
button = gtk_radio_button_new_with_label(NULL, "Red Hat");
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, "Mandrake");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
TRUE);
gtk_box_pack_start(GTK_BOX(box2), button,
TRUE, TRUE, 0);
gtk_widget_show(button);
button = gtk_radio_button_new_with_label(
gtk_radio_button_group(GTK_RADIO_BUTTON(button)),
"ALT Linux");
gtk_box_pack_start(GTK_BOX(box2), button,
TRUE, TRUE, 0);
gtk_widget_show(button);
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(box1), separator,
FALSE, TRUE, 0);
gtk_widget_show(separator);
box2 = gtk_vbox_new(FALSE, 10);
gtk_container_set_border_width(GTK_CONTAINER(box2), 10);
gtk_box_pack_start(GTK_BOX(box1), box2, FALSE, TRUE, 0);
gtk_widget_show(box2);
button = gtk_button_new_with_label("OK");
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);
}
Рис. 23.4. Зависимые переключатели
23.4.4. Список
Виджит CList представляет собой список, состоящий из нескольких колонок. Ячейки такого списка могут содержать текстовые значения. Мы можем обратиться отдельно к каждой ячейке списка. Создать список можно одной из функций:
GtkWidget *gtk_clist_new(gint columns);
GtkWidget *gtk_clist_new_with_titles(gint columns,
gchar *titles[]);
Первая функция создает список без заголовков, а вторая с заголовками. Параметр columns задает число колонок.
Добавить элемент в список позволяют функции:
gint gtk_clist_prepend(GtkCList *clist, gchar *text[]);
gint gtk_clist_append(GtkCList *clist, gchar *text[]);
Первая функция добавляет новый элемент в начало списка, а вторая — в его конец. Если вам необходимо вставить элемент в определенную позицию, вам нужно использовать функцию:
void gtk_clist_insert(GtkCList *clist, gint row, gchar *text[]);
Она позволяет вставить новый элемент в строку row. Нумерация строк списка начинается с 0.
Для удаления элементов списка можно использовать одну из функций:
void gtk_clist_remove(GtkCList *clist, gint row);
void gtk_clist_clear(GtkCList *clist);
Первая удаляет строку row, а вторая очищает весь список.
Рассмотрим листинг 23.8, в котором демонстрируется работа со списком CList. Программа снабжена подробными комментариями, поэтому рекомендую внимательно читать исходный код.
Листинг 23.8. Применение виджита CList
#include
/* Нужен для функции setlocale() */
#include
/* Добавляет список - обработчик кнопки Добавить */
void button_add_clicked(gpointer data) {
int indx;
/* Простой список */
gchar *dist[4][2] = { { "1", "Red Hat Linux" },
{ "2", "Mandrake Linux" },
{ "3", "ALT Linux" },
{ "4", "ASP Linux" } };
for(indx=0; indx < 4; indx++)
gtk_clist_append((GtkCList *) data, dist[indx]);
return;
}
/* Обработчик нажатия кнопки Очистить */
void button_clear_clicked(gpointer data) {
/* Очищаем список */
gtk_clist_clear((GtkCList *)data);
return;
}
/* Функция прячет/отображает заголовки */
void button_hide_show_clicked(gpointer data) {
/* 0 = сейчас видим заголовки */
static short int flag = 0;
if (flag == 0) {
/* прячем заголовки */
gtk_clist_column_titles_hide((GtkCList *)data);
flag++;
} else {
/* Отображаем заголовки */
gtk_clist_column_titles_show((GtkCList *)data);
}
return;
}
/* Данная функция будет вызвана, если пользователь выберет
элемент */
void selection_made(GtkWidget *clist, gint row,
gint column, GdkEventButton *event, gpointer data) {
gchar *text;
/* Получаем выбранный текст (элемент списка) */
gtk_clist_get_text(GTK_CLIST(clist), row, column, &text);
/* Просто выводим информацию на консоль */
g_print(
"Вы выбрали ряд %d. Колонка %d, текст в ячейке %s\n\n",
row, column, text);
return;
}
int main(int argc, gchar *argv[]) {
GtkWidget *window;
GtkWidget *vbox, *hbox;
GtkWidget *scrolled_window, *clist;
GtkWidget *button_add, *button_clear, *button_hide_show;
gchar *titles[2] = { "Номер", "Дистрибутив" };
setlocale(LC_ALL, "ru_RU.KOI8-R");
// Нужно вызвать ДО gtk_init()
gtk_init(&argc, &argv);
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize(GTK_WIDGET(window), 300, 150);
gtk_window_set_title(GTK_WINDOW(window), "Список");
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
vbox=gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
/* Создаем окно с полосками прокрутки и упаковываем в
него список */
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(
GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC,
GTK_POLIСY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox), scrolled_window,
TRUE, TRUE, 0);
gtk_widget_show(scrolled_window);
/* Создаем список с двумя колонками */
clist = gtk_clist_new_with_titles(2, titles);
/* Обработка выделения */
gtk_signal_connect(GTK_OBJECT(clist), "select_row",
GTK_SIGNAL_FUNC(selection_made), NULL);
/* Устанавливаем тень для рамки списка */
gtk_clist_set_shadow_type(GTK_CLIST(clist),
GTK_SHADOW_OUT);
/* Устанавливаем ширину для колонки. Колонки нумеруются
с 0 */
gtk_clist_set_column_width(GTK_CLIST(clist), 0, 150);
/* Помещаем список в контейнер */
gtk_container_add(GTK_CONTAINER(scrolled_window), clist);
gtk_widget_show(clist);
/* Создаем и размещаем кнопки Добавить список,
Очистить, Спрятать/отобразить заголовок */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_widget_show(hbox);
button_add = gtk_button_new_with_label("Добавить");
button_clear = gtk_button_new_with_label("Очистить");
button_hide_show = gtk_button_new_with_label("Спрятать/отобразить");
gtk_box_pack_start(GTK_BOX(hbox), button_add,
TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button_clear,
TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button_hide_show,
TRUE, TRUE, 0);
/* Связываем обработчики */
gtk_signal_connect_object(GTK_OBJECT(button_add),
"clicked",
GTK_SIGNAL_FUNC(button_add_clicked), (gpointer) clist);
gtk_signal_connect_object(GTK_OBJECT(button_clear),
"clicked",
GTK_SIGNAL_FUNC(button_clear_clicked),(gpointer)clist);
gtk_signal_connect_object(GTK_OBJECT(button_hide_show),
"clicked", GTK_SIGNAL_FUNC(button_hide_show_clicked),
(gpointer)clist);
gtk_widget_show(button_add);
gtk_widget_show(button_clear);
gtk_widget_show(button_hide_show);
gtk_widget_show(window);
gtk_main();
return(0);
}
Программа работает так: при нажатии кнопки Добавить создается список, состоящий из названий четырех популярных дистрибутивов Linux. Кнопка Очистить очищает список, а Спрятать/отобразить прячет или отображает заголовки списка. При щелчке на определенной ячейке списка на консоль выводится соответствующее сообщение — координаты ячейки и ее текст.
Рис 23.5.
< … стр. 639–640 … >
void destroy(GtkWidget *widget, gpointer data);
static void button_click(GtkWidget *widget, gpointer data);
int main(int argc, char *argv[]) {
GtkWidget *window;
GtkWidget *button;
GtkWidget *label;
w_ctrl ctrl;
gchar *caption;
setlocale(LC_ALL, "ru_RU.KOI8-R");
caption = g_strdup_printf("Доброго времени суток!");
gtk_init(&argc, &argv);
window = gtk_window_new( GTK_WINDOW_TOPLEVEL);
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(delete_event), NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC(destroy), &ctrl);
gtk_window_set_title(GTK_WINDOW(window), caption);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
button = gtk_button_new();
label = gtk_label_new(" -== Нажмите кнопку ==- " );
ctrl.app_window = window;
ctrl.label = label;
gtk_container_add(GTK_CONTAINER(button), label);
gtk_container_add(GTK_CONTAINER(window), button);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(button_click), &ctrl);
gtk_widget_show_all(window);
gtk_main();
return(0);
}
// ****************************************************
void quit_confirm(GtkWidget *widget) {
GtkWidget *quit_form;
GtkWidget *label;
GtkWidget *yes_button, *no_button;
quit_form = gtk_dialog_new();
gtk_window_set_position(GTK_WINDOW(quit_form),
GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(quit_form),
10);
label =
gtk_label_new("\n Вы действительно хотите выйти? \n*);
yes_button = gtk_button_new_with_label("Да");
no_button = gtk_button_new_with_label("Нет");
gtk_signal_connect_object(GTK_OBJECT(yes_button),
"clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy), (gpointer)widget);
gtk_container_add(
GTK_CONTAINER(GTK_DIALOG(quit_form)->action_area), yes_button);
gtk_signal_connect_object(GTK_OBJECT(no_button),
"clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
(gpointer)quit_form);
gtk_container_add(
GTK_CONTAINER(GTK_DIALOG(quit_form)->action_area), no_button);
gtk_container_add(
GTK_CONTAINER(GTK_DIALOG(quit_form)->vbox), label);
gtk_window_set_modal(GTK_WINDOW(quit_form), TRUE);
gtk_widget_show_all(quit_form);
}
gint delete_event(GtkWidget *widget, GdkEvent *event,
gpointer data) {
quit_confirm(widget);
return(TRUE);
}
void destroy(GtkWidget *widget, gpointer data) {
printf{"GOOD-BYE!");
gtk_main_quit();
}
static void button_click(GtkWidget *widget,
gpointer data ) {
static gint i = 0;
GtkWidget *app_window;
GtkWidget *label;
gchar msg[256];
app_window = GTK_WIDGET(((w_ctrl *)data)->app_window);
label = GTK_WIDGET(((w_ctrl*)data)->label);
i++;
sprintf(msg, "Вы нажали кнопку: %d раз(а)", i);
gtk_label_set_text(GTK_LABEL(label), msg);
}
Думаю, текст программы ясен без лишних комментариев. Нужно лишь пояснить один очень важный момент. Обратите внимание на то, что мы переопределили обработчик для события
delete_event
.gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC(delete_event), NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC(destroy), &ctrl);
Если данный обработчик возвращает FALSE, то будет вызвана функция destroy(), которая уничтожит окно. Мы переписали функцию delete_event() так, чтобы она всегда возвращала TRUE, то есть функция destroy() вообще не будет вызвана. Но в таком случае наше окно вообще никогда не закроется, поэтому нужно, чтобы кто-то позаботился о закрытии окна. Это будет функция quit_confirm(), отображающая диалог завершения работы.
gint delete_event(GtkWidget *widget, GdkEvent *event,
gpointer data) {
quit_confirm(widget);
return(TRUE);
}
Рис. 23.6. Программа только запущена
Рис. 23.7. Пользователь нажал на кнопку 4 раза
Рис. 23.8. Диалог завершения работы
Теперь рассмотрим обработчики событий кнопок Да и Нет диалога:
gtk_signal_connect_object(GTK_OBJECT(yes_button),
"clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy),
(gpointer)widget);
gtk_signal_connect_object(GTK_OBJECT(no_button), "clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),(gpointer)quit_form);
Кнопка
yes_button
вызывает функцию gtk_widget_destroy() и передает ей параметр (gpointer)widget, то есть уничтожает главное окно приложения, а кнопка no_button
передает функции gtk_widget_destroy() параметр (gpointer)quit_form. который указывает на окно диалога, то есть при нажатии этой кнопки будет закрыто само окно нашего диалога.23.4.7. Меню
Меню программы вручную писать довольно неудобно, поэтому для разработки меню воспользуемся студией разработки графического интерфейса Glade.
23.4.8. Иерархия виджитов
GtkObject
+GtkWidget
| +GtkMisc
| | +GtkLabel
| | | +GtkAccelLabel
| | | `GtkTipsQuery
| | +GtkArrow
| | +GtkImage
| | `GtkPixmap
| +GtkContainer
| | +GtkBin
| | | +GtkAlignment
| | | +GtkFrame
| | | | `GtkAspectFrame
| | | +GtkButton
| | | | +GtkToggleButton
| | | | | `GtkCheckButton
| | | | | `GtkRadioButton
| | | | `GtkOptionMenu
| | | +GtkItem
| | | | +GtkMenuItem
| | | | | +GtkCheckMenuItem
| | | | | | `GtkRadioMenuItem
| | | | | `GtkTearoffMenuItem
| | | | +GtkListItem
| | | | `GtkTreeItem
| | | +GtkWindow
| | | | +GtkColorSelectionDialog
| | | | +GtkDialog
| | | | | `GtkInputDialog
| | | | +GtkDrawWindow
| | | | +GtkFileSelection
| | | | +GtkFontSelectionDialog
| | | | `GtkPlug
| | | +GtkEventBox
| | | +GtkHandleBox
| | | +GtkScrolledWindow
| | | `GtkViewport
| | +GtkBox
| | | +GtkButtonBox
| | | | +GtkHButtonBox
| | | | `GtkVButtonBox
| | | +GtkVBox
| | | | +GtkColorSelection
| | | | `GtkGammaCurve
| | | `GtkHBox
| | | +GtkCombo
| | | `GtkStatusbar
| | +GtkCList
| | | `GtkCTree
| | +GtkFixed
| | +GtkNotebook
| | | `GtkFontSelection
| | +GtkPaned
| | | +GtkHPaned
| | | `GtkVPaned
| | +GtkLayout
| | +GtkList
| | +GtkMenuShell
| | | +GtkMenuBar
| | | `GtkMenu
| | +GtkPacker
| | +GtkSocket
| | +GtkTable
| | +GtkToolbar
| | `GtkTree
| +GtkCalendar
| +GtkDrawingArea
| | `GtkCurve
| +GtkEditable
| | +GtkEntry
| | | `GtkSpinButton
| | `GtkText
| +GtkRuler
| | +GtkHRuler
| | `GtkVRuler
| +GtkRange
| | +GtkScale
| | | +GtkHScale
| | | `GtkVScale
| | `GtkScrollbar
| | +GtkHScrollbar
| | `GtkVScrollbar
| +GtkSeparator
| | +GtkHSeparator
| | `GtkVSeparator
| +GtkPreview
| `GtkProgress
| `GtkProgressBar
+GtkData
| +GtkAdjustment
| `GtkTooltips
`GtkItemFactory
Глава 24