Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: [email protected]
PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£
IDZ DOIDZ DO
ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG
KATALOG KSI¥¯EKKATALOG KSI¥¯EK
TWÓJ KOSZYKTWÓJ KOSZYK
CENNIK I INFORMACJECENNIK I INFORMACJE
ZAMÓW INFORMACJEO NOWO�CIACH
ZAMÓW INFORMACJEO NOWO�CIACH
ZAMÓW CENNIKZAMÓW CENNIK
CZYTELNIACZYTELNIA
FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE
SPIS TRE�CISPIS TRE�CI
DODAJ DO KOSZYKADODAJ DO KOSZYKA
KATALOG ONLINEKATALOG ONLINE
Zaawansowane programowaniew systemie Linux
Autorzy: Neil Matthew, Richard Stones
T³umaczenie: Robert Gêbarowski, Zygmunt Wereszczyñski
ISBN: 83-7197-495-7
Tytu³ orygina³u: Professional Linux Programming
Format: B5, stron: 1288
Przyk³ady na ftp: 1780 kB
Linux nieustannie umacnia swoj¹ obecno�æ w �wiecie jako platforma systemowa
przeznaczona dla zaawansowanych aplikacji. Dojrzewanie i szybki rozwój tego
wszechstronnego systemu, zapewniaj¹cego ca³e bogactwo bezp³atnych narzêdzi
programowania, pozwala mieæ pewno�æ, co do jego ugruntowanej pozycji w przysz³o�ci.
Przy niewielkim nak³adzie si³ i �rodków, system Linux udostêpnia szeroki wachlarz
narzêdzi oraz obs³ugê nowych lub dopiero powstaj¹cych technologii. Dziêki temu
system Linux, pozwala wybraæ i zastosowaæ w³a�ciwe rozwi¹zania w procesie
tworzenia aplikacji.
Niniejsza ksi¹¿ka pozwala czerpaæ z praktycznej wiedzy i bogatego do�wiadczenia
autorów w zakresie tworzenia oprogramowania dla systemu Linux. Czytelnik zostanie
poprowadzony poprzez proces tworzenia przyk³adowej aplikacji dla wypo¿yczalni
filmów DVD — tematycznie opracowane rozdzia³y podejmuj¹ ró¿ne aspekty
implementacji tej aplikacji. Z kolei samodzielne rozdzia³y o charakterze dygresyjnym
omawiaj¹ wa¿ne tematy, które wykraczaj¹ poza zakres motywu przewodniego, jakim
jest przyk³adowa aplikacja. Niniejsza monografia podkre�la wagê praktycznych
aspektów programowania, pokazuje, jak wa¿ny jest w³a�ciwy dobór narzêdzi
programisty dla okre�lonego zadania, uczy ich poprawnego u¿ycia oraz wskazuje
najkrótsz¹ drogê do upragnionego celu.
Zarówno do�wiadczeni programi�ci, jak te¿ i ambitni przyszli twórcy oprogramowania
w systemie Linux znajd¹ tutaj mnóstwo praktycznych informacji na tematy takie jak:
biblioteki oprogramowania, techniki, narzêdzia oraz aplikacje. Od Czytelnika wymaga siê
znajomo�ci podstaw systemu Linux, dobrej praktycznej znajomo�ci programowania
w jêzyku C. Ponadto, zak³ada siê w niektórych rozdzia³ach zrozumienie zasad
programowania zorientowanego obiektowo w jêzyku C++.
W ksi¹¿ce omówiono miêdzy innymi :
• Przechowywanie danych w systemie Linux ze szczególnym uwzglêdnieniem
PostgreSQL, MySQL i XML.
• Implementacja interfejsów graficznych u¿ytkownika w systemie Linux -
omówienie KDE i GNOME.
• Interfejsy WWW — zastosowanie modu³u PHP dla serwera Apache.
• Zastosowanie jêzyka Python — rozszerzanie i wbudowywanie tego jêzyka.
• astosowanie RPC oraz CORBA do konstrukcji rozproszonych aplikacji
obiektowych.
• Oznaczanie wersji (za pomoc¹ CVS), dokumentacja, internacjonalizacja
i dystrybucja projektów.
• Rozproszone rozwi¹zania sprzêtowe, takie jak bezdyskowy system Linux i klastry
Beowulf.
Spis treści
O Autorach 23
Wstęp 33
Dla kogo jest przeznaczona ta książka?......................................................................33Tematyka książki ......................................................................................................33Czego wymagamy od czytelnika książki?.....................................................................37Kod źródłowy............................................................................................................38Oznaczenia stosowane w książce...............................................................................38
Rozdział 1. Projekt aplikacji 39
Informacje ogólne.....................................................................................................39Formułowanie założeń...............................................................................................41Modele tworzenia kodu .............................................................................................43
Opracowanie wczesnego prototypu .......................................................................44Wczesne i częste testy ........................................................................................45
Wypożyczalnia DVD...................................................................................................45Założenia wstępne ..............................................................................................46Analiza wymagań klienta ......................................................................................47
Spis wymagań..........................................................................................................52Przypadki użycia ..................................................................................................54
Architektura aplikacji ................................................................................................56Projekt szczegółowy.............................................................................................58Funkcje dostępu do danych..................................................................................59Funkcje związane z danymi klientów......................................................................59Funkcje związane z filmami ..................................................................................62Funkcje opisujące płytę DVD ................................................................................63Funkcje związane z wypożyczaniem .......................................................................63Przykładowa implementacja .................................................................................65
Materiały dodatkowe.................................................................................................65Podsumowanie.........................................................................................................66
Rozdział 2. CVS 67
Narzędzia dla systemu Linux .....................................................................................68Terminologia ............................................................................................................69Repozytorium ...........................................................................................................69Obsługa CVS przez jednego użytkownika.....................................................................70
Format polecenia CVS .........................................................................................71Zmienne środowiskowe .......................................................................................71Import nowego projektu .......................................................................................72Początek prac nad projektem w CVS .....................................................................74Porównywanie zmian z zawartością repozytorium....................................................75
4 Zaawansowane programowanie w systemie Linux
Aktualizacja repozytorium.....................................................................................76Wydanie projektu.................................................................................................77Przeglądanie zmian .............................................................................................78Dodawanie i usuwanie plików z projektu................................................................79Rozwinięcia słów kluczowych................................................................................79
Korekty, znaczniki i rozgałęzienia ...............................................................................80Korekty...............................................................................................................80Znaczniki ............................................................................................................81Rozgałęzienia projektu .........................................................................................84
CVS dla wielu użytkowników ......................................................................................89Praca zespołowa .................................................................................................90Śledzenie zmian..................................................................................................92
Więcej zabawy z CVS ................................................................................................92Pliki binarne........................................................................................................92Poprawianie błędnych adnotacji ............................................................................93
Sieciowy dostęp do CVS............................................................................................93Klienty CVS z interfejsem graficznym..........................................................................96Materiały dodatkowe.................................................................................................97Podsumowanie.........................................................................................................98
Rozdział 3. Bazy danych 101
Wybór bazy danych .................................................................................................102mSQL...............................................................................................................102MySQL .............................................................................................................103PostgreSQL ......................................................................................................103Jaki wybór będzie odpowiedni? ...........................................................................103
PostgreSQL............................................................................................................104Instalacja i uruchamianie ...................................................................................104
Tworzenie użytkowników ...............................................................................106Tworzenie baz danych...................................................................................107Tworzenie zapasowych kopii bazy danych .......................................................107Zdalny dostęp..............................................................................................108
Podstawy teorii baz danych .....................................................................................109Pierwsza postać normalna .................................................................................110Druga postać normalna .....................................................................................111Trzecia postać normalna....................................................................................111Denormalizacja .................................................................................................112Prosta baza danych ...........................................................................................112
Korzystanie z psql ..................................................................................................117Polecenia dla psql.............................................................................................117Polecenia do definicji danych .............................................................................118
Tworzenie i usuwanie tabel ...........................................................................119Typy danych w PostgreSQL............................................................................123
Polecenia do manipulacji danymi ........................................................................123Wstawianie danych ......................................................................................124Pobieranie danych z pojedynczej tabeli...........................................................125Kombinowane pobieranie danych z wielu tabel ...............................................127Aktualizacja danych w tabeli..........................................................................129Usuwanie danych.........................................................................................129
Transakcje........................................................................................................130
Spis treści 5
Wskazówki dla projektu bazy danych ........................................................................132Materiały dodatkowe...............................................................................................134Podsumowanie.......................................................................................................134
Rozdział 4. Interfejsy PostgreSQL 135Dostęp do PostgreSQL z kodu programu...................................................................135
Biblioteka libpq .................................................................................................136Funkcje do obsługi połączeń z bazą danych ....................................................137Uruchamianie poleceń SQL...........................................................................139Uzyskiwanie wyników zapytań........................................................................142
Biblioteka ecpg .................................................................................................155Jaką metodę zastosować? .................................................................................166
Aplikacja................................................................................................................167Podsumowanie.......................................................................................................174
Rozdział 5. MySQL 175Instalacja i zarządzanie ...........................................................................................175
Pakiety skompilowane .......................................................................................175Budowanie z plików źródłowych ..........................................................................177Konfiguracja poinstalacyjna................................................................................178
Zarządzanie bazą MySQL.........................................................................................179Polecenia .........................................................................................................179
isamchk ......................................................................................................180mysql..........................................................................................................180mysqladmin.................................................................................................181mysqlbug ....................................................................................................181mysqldump..................................................................................................181mysqlimport ................................................................................................182mysqlshow ..................................................................................................182
Tworzenie użytkowników i nadawanie uprawnień ..................................................183grant...........................................................................................................183with grant ....................................................................................................184revoke, delete .............................................................................................185
Hasła ...............................................................................................................185Tworzenie bazy danych ......................................................................................186
Obsługa standardu SQL przez PostgreSQL i MySQL ...................................................187Dostęp do danych MySQL z języka C ........................................................................188
Inicjalizacja połączenia ......................................................................................189Obsługa błędów ................................................................................................193Wykonywanie poleceń SQL.................................................................................194
Polecenia SQL niezwracające danych.............................................................194Polecenia zwracające dane ...........................................................................197Przetwarzanie zwróconych danych..................................................................202
Funkcje dodatkowe............................................................................................207Materiały dodatkowe...............................................................................................208Podsumowanie.......................................................................................................208
Rozdział 6. Zmagania z błędami 209Typy błędów ...........................................................................................................209Zgłaszanie błędów ..................................................................................................210Wykrywanie błędów w oprogramowaniu.....................................................................214Rodzaje błędów w oprogramowaniu ..........................................................................214
6 Zaawansowane programowanie w systemie Linux
Instrukcje diagnostyczne .........................................................................................215Weryfikacja założeń ...........................................................................................220Gdzie jesteś?....................................................................................................222Ślad wsteczny (backtrace)..................................................................................226
Usuwanie błędów — czynności wstępne...................................................................228Użycie programu uruchomieniowego ...................................................................229Proste polecenia GDB........................................................................................230Inne możliwości GDB .........................................................................................234
Zasoby ..................................................................................................................234Podsumowanie.......................................................................................................235
Rozdział 7. Usługi katalogowe LDAP 237Co to jest usługa katalogowa?.................................................................................237
X.500 i LDAP ....................................................................................................238Struktura serwera katalogowego ..............................................................................239
Nazwy części... .................................................................................................240Nadawanie nazw dn...........................................................................................241
Schemat nazewnictwa X.500 ........................................................................241X.500 ze schematem nazewnictwa domen.....................................................241Schemat nazewnictwa oparty na składniku domeny ........................................241
Składniki obiektów ............................................................................................242Standardowe typy i atrybuty ..........................................................................243
Drzewo katalogowe LDAP...................................................................................244Pliki LDIF ..........................................................................................................245
Instalacja i konfiguracja serwera LDAP .....................................................................247Instalacja OpenLDAP .........................................................................................248Konfiguracja OpenLDAP .....................................................................................248
Uruchomienie serwera ............................................................................................251Dostęp do LDAP z poziomu języka C.........................................................................253
Inicjalizacja biblioteki LDAP ................................................................................253Powiązanie z serwerem LDAP .............................................................................254Obsługa błędów LDAP........................................................................................255Pierwszy program kliencki LDAP..........................................................................256Wyszukiwanie ...................................................................................................257
Wybór zakresu .............................................................................................257Filtracja wyników ..........................................................................................257Wyszukiwanie przy użyciu API ........................................................................260Sortowanie zwróconych obiektów...................................................................266
Zmiana danych.......................................................................................................266Nowy wpis ........................................................................................................266Modyfikacja wpisu .............................................................................................270Usuwanie wpisu ................................................................................................272
Aplikacja................................................................................................................273Materiały dodatkowe...............................................................................................273Podsumowanie.......................................................................................................274
Rozdział 8. Programowanie graficznych interfejsów użytkownika (GUI)za pomocą GNOME-GTK+ 275
Biblioteki GTK+ i GNOME ........................................................................................276glib277GTK+ ...............................................................................................................277
Spis treści 7
GDK.................................................................................................................277Imlib ................................................................................................................278ORBit ...............................................................................................................278libGnorba..........................................................................................................278
Biblioteka glib ........................................................................................................278Typy .................................................................................................................279Makrodefinicje ..................................................................................................280
Makrodefinicje diagnostyczne .......................................................................280Funkcje obsługujące napisy................................................................................282Przydzielanie pamięci.........................................................................................284Listy.................................................................................................................285
GTK+.....................................................................................................................287Widżety ............................................................................................................287
Utworzenie widżetu ......................................................................................287Pojemniki ....................................................................................................288Tabele ........................................................................................................290Sygnały .......................................................................................................292Ukazanie, aktywność i ukrycie .......................................................................293Zniszczenie .................................................................................................293
gtk_init i gtk_main.............................................................................................293Przykładowa aplikacja GTK+ ...............................................................................293
Podstawy GNOME...................................................................................................295gnome_init ..................................................................................................295GnomeApp ..................................................................................................296
Menu i paski narzędziowe ..................................................................................296GnomeAppbar..............................................................................................299Pasek postępu ............................................................................................300
Okna dialogowe ................................................................................................300Tworzenie widżetu GnomeDialog....................................................................301Pokazywanie widżetu GnomeDialog................................................................302GnomeAbout ...............................................................................................304GnomePropertyBox.......................................................................................305GnomeMessageBox .....................................................................................306
Przykładowa aplikacja GNOME............................................................................307Drzewo kodu źródłowego GNOME.............................................................................309
configure.in .................................................................................................310Makefile.am ................................................................................................312
Zapis konfiguracji ..............................................................................................313Przechowywanie danych................................................................................314Odczyt zachowanych danych .........................................................................315
Zarządzanie sesją .............................................................................................315GnomeClient ...............................................................................................316
Analiza składniowa wiersza poleceń z użyciem popt .............................................319Materiały dodatkowe...............................................................................................322Podsumowanie.......................................................................................................323
Rozdział 9. Tworzenie GUI za pomocą Glade i GTK+/GNOME 325Ogólne omówienie Glade.........................................................................................326
Uwagi na temat projektowania GUI .....................................................................326Samouczek Glade...................................................................................................327
Okno główne.....................................................................................................328Paleta ..............................................................................................................329
8 Zaawansowane programowanie w systemie Linux
Okno właściwości..............................................................................................332Kod źródłowy utworzony za pomocą Glade ...........................................................335lookup_widget...................................................................................................337Dopisywanie kodu .............................................................................................338libglade ............................................................................................................340
GUI do obsługi wypożyczalni płyt DVD.......................................................................343Projekt .............................................................................................................344Kompilacja i uruchamianie dvdstore....................................................................344Struktura ..........................................................................................................350Kod..................................................................................................................351
main.c ........................................................................................................351callbacks.c ..................................................................................................353member_dialog.c oraz title_dialog.c...............................................................354rent_dialog.c oraz return_dialog.c ..................................................................358search_window.c .........................................................................................364misc.c.........................................................................................................374
Podsumowanie.......................................................................................................379
Rozdział 10. Flex i Bison 381
Struktura danych wejściowych .................................................................................382Skanery i analizatory składni ..............................................................................383Jak działają generatory?.....................................................................................384
Skanery .................................................................................................................385Prosty skaner....................................................................................................386Specyfikacje skanera.........................................................................................386Zasada najdłuższego dopasowania .....................................................................391Wyrażenia regularne ..........................................................................................392
Łączenie wyrażeń regularnych .......................................................................393Działania ..........................................................................................................395Przekierowanie wejścia i wyjścia skanera ............................................................396Zwracanie elementów........................................................................................397Skanery kontekstowe ........................................................................................398Opcje programu flex ..........................................................................................398
Analizatory składni (parsery) ....................................................................................399Tworzenie parserów...........................................................................................401
Definicje......................................................................................................404Reguły.........................................................................................................405Kod dodatkowy ............................................................................................406
Tworzenie testera składni ..................................................................................406Typy elementów ................................................................................................410Działania w regułach..........................................................................................411Opcje programu bison........................................................................................418Konflikty gramatyczne........................................................................................419Wyrażenia arytmetyczne.....................................................................................420
Materiały dodatkowe...............................................................................................421Podsumowanie.......................................................................................................422
Rozdział 11. Narzędzia do testowania 423
Testowanie wymagań..............................................................................................423Architektura aplikacji .........................................................................................424Etapy testowania...............................................................................................425
Spis treści 9
Testy ogólne .....................................................................................................425Testy regresyjne................................................................................................426Program testujący .............................................................................................428
Nagłówki i deklaracje....................................................................................429main() .........................................................................................................429show_result()...............................................................................................430Interfejsy programisty (API) ...........................................................................430
Testowanie programu dvdstore...........................................................................433Testy w postaci skryptów ...................................................................................434expect..............................................................................................................434Problemy z pamięcią..........................................................................................436
Pamięć statyczna.........................................................................................437Stos ...........................................................................................................437Pamięć dynamiczna......................................................................................442
Instalacja programu mpatrol...............................................................................444Zastosowanie programu mpatrol ........................................................................445Testy pokrycia...................................................................................................450
Pokrycie instrukcji ........................................................................................450Pokrycie rozgałęzień programu i pokrycie danych ............................................451GCOV — narzędzie do testów pokrycia instrukcji.............................................452
Testowanie wydajności ......................................................................................458Podsumowanie.......................................................................................................461
Rozdział 12. Bezpieczne programowanie 463
Czym jest bezpieczne programowanie?.....................................................................463Dlaczego tak trudno bezpiecznie programować?........................................................464
Błędy utajone....................................................................................................464Pochwała paranoi..............................................................................................465
Bezpieczeństwo systemu plików ..............................................................................467Standardowe uprawnienia ..................................................................................467Lepki bit ...........................................................................................................468Atrybuty setuid i setgid ......................................................................................469
Atrybuty setuid i setgid dla plików wykonywalnych...........................................469Atrybut setgid dla katalogów .........................................................................470
Bezpieczne używanie setguid i setgid..................................................................470Potwierdzanie tożsamości użytkowników...................................................................471
Tradycyjne uwierzytelnianie w UNIX-ie ..................................................................471Podstawowe techniki....................................................................................472Ograniczenia................................................................................................472
Dynamiczne moduły uwierzytelniające PAM..........................................................473PAM w teorii ................................................................................................473Etapy sprawdzania tożsamości za pomocą PAM..............................................473
Rejestracja wywołań zwrotnych ...........................................................................478Przykład ......................................................................................................479
Zarządzanie uprawnieniami ................................................................................483Porzucanie i odzyskiwanie uprawnień.............................................................483Funkcje get*id i set*id .................................................................................484
Strategie zarządzania uprawnieniami ..................................................................485Bezpieczne korzystanie z kryptografii........................................................................486
Krótkie wprowadzenie do kryptografii .............................................................487Kryptografia z kluczem publicznym.................................................................487
10 Zaawansowane programowanie w systemie Linux
Bezpieczne algorytmy jednostronne ...............................................................488O pisaniu własnych algorytmów.....................................................................488
Niektóre powszechnie stosowane techniki...........................................................489Cyfrowe podpisy...........................................................................................489Uwierzytelnianie za pomocą hasła .................................................................490Szyfrowanie sesji .........................................................................................491
Generowanie liczb losowych w Linuksie...............................................................492Zarządzanie kluczem .........................................................................................493
Bezpieczne programowanie sieciowe........................................................................494Opracowywanie protokołów......................................................................................495
Jeśli jest to możliwe, należy stosować standardy .................................................495Przyjazne zapory sieciowe ..................................................................................496Zagadnienia bezpieczeństwa aplikacji WWW........................................................497Zagadnienia związane z zarządzaniem sesją ........................................................497
Skrypty zewnętrzne.......................................................................................498Standardowe sieciowe narzędzia kryptograficzne.......................................................500
SSL-TLS ...........................................................................................................500ssh ..................................................................................................................500Ogólne wskazówki i techniki zabezpieczeń...........................................................501
Problemy ze środowiskiem ......................................................................................502Specjalne zmienne środowiskowe.......................................................................502
LD_*...........................................................................................................503IFS..............................................................................................................503PATH...........................................................................................................504Użycie plików tymczasowych .........................................................................504Użycie „chroot”............................................................................................505
Zagadnienia specyficzne dla języka.....................................................................507Jak działa przepełnienie bufora?....................................................................507Jak unikać problemów z przepełnieniem bufora?.............................................509
Sprawdzanie błędów i wyjątków ..........................................................................510Perl ..................................................................................................................510Skrypty setuid i setgid w Perlu............................................................................511
Python...................................................................................................................511PHP.......................................................................................................................512Materiały dodatkowe...............................................................................................512Podsumowanie.......................................................................................................513
Rozdział 13. Programowanie GUI za pomocą KDE/Qt 515Wprowadzenie........................................................................................................515
Informacje o Qt .................................................................................................515Informacje o KDE ..............................................................................................516Instalacja Qt .....................................................................................................517Instalacja KDE ..................................................................................................518Biblioteki ..........................................................................................................519
Programowanie aplikacji przy użyciu Qt .....................................................................519Na początek: „Witaj świecie”..............................................................................519Uproszczenie zarządzania plikiem MakefileMakefile za pomocą tmake ..................521Sygnały i odbiorniki ...........................................................................................522„Witaj świecie” ponownie...................................................................................525Dziedziczenie z klas podstawowych.....................................................................525Widżety ............................................................................................................528Układy..............................................................................................................530
Spis treści 11
Programowanie aplikacji przy użyciu KDE ..................................................................534Prosty edytor tekstowy.......................................................................................534
Materiały dodatkowe...............................................................................................542Podsumowanie.......................................................................................................542
Rozdział 14. Interfejs GUI dla wypożyczalni płyt DVD — implementacja w KDE i Qt 545
Projekt aplikacji ......................................................................................................546Okno główne.....................................................................................................549
Elementy menu............................................................................................550Pasek narzędzi ............................................................................................551Widżet główny..............................................................................................552Rejestr transakcji .........................................................................................553Okno dialogowe klienta ................................................................................554
Okno dialogowe wypożyczeń...............................................................................558Wykaz wypożyczeń........................................................................................558
Raport wypożyczenia..........................................................................................559Okno wyszukiwań ..............................................................................................560
Strona wyszukiwania filmów..........................................................................561Strona wyszukiwań klientów..........................................................................564Strona wyszukiwania płyt ..............................................................................565
Menedżer ustawień ...........................................................................................566Dostosowanie kodu do KDE ....................................................................................568
Kconfig i SettingsManager .................................................................................574Materiały dodatkowe...............................................................................................574Podsumowanie.......................................................................................................575
Rozdział 15. Python 577
Wprowadzenie........................................................................................................577Cechy...............................................................................................................578
Język bardzo wysokiego poziomu (Very High Level Language — VHLL) ..............579Interpretowany.............................................................................................579Czysta, prosta i użyteczna składnia ...............................................................580Obiektowy ...................................................................................................581Dynamiczne określanie typu..........................................................................581Duża biblioteka standardowa ........................................................................581Obsługa wielu platform.................................................................................581Mnogość implementacji................................................................................581Duże możliwości rozbudowy ..........................................................................582Otwarty dostęp do kodu źródłowego...............................................................582Rozrywka!....................................................................................................582
Python: odpowiednie narzędzie pracy ..................................................................583...ale nie każdej! ...............................................................................................583
Instalacja Pythona ..................................................................................................583Uruchomienie Pythona ............................................................................................585
Interaktywny interpreter .....................................................................................586Polecenie jako argument....................................................................................587Skrypt jako argument.........................................................................................587„Samodzielnie” wykonywalny program.................................................................587
Szczegóły...............................................................................................................588Interpreter i kompilacja bajtowa..........................................................................588Składnia komentarzy .........................................................................................588
12 Zaawansowane programowanie w systemie Linux
Znaczenie wielkości liter ....................................................................................589Wbudowane typy danych i operatory....................................................................589
Nic..............................................................................................................589Liczby całkowite ...........................................................................................590Długie liczby całkowite..................................................................................593Liczby zmiennoprzecinkowe...........................................................................593Liczby zespolone..........................................................................................593Listy ...........................................................................................................594Napisy ........................................................................................................596Krotki..........................................................................................................598Słowniki ......................................................................................................598
Zmienne...........................................................................................................599Składnia struktury blokowej................................................................................600Składnia instrukcji.............................................................................................601
Instrukcje z wyrażeniami ...............................................................................601Przypisanie..................................................................................................602Instrukcje proste..........................................................................................602Instrukcje złożone ........................................................................................605
Funkcje ............................................................................................................607Funkcje wbudowane ..........................................................................................609Przestrzenie nazw..............................................................................................610Moduły i pakiety ................................................................................................610Niektóre moduły ze standardowej dystrybucji .......................................................611Klasy i obiekty ..................................................................................................611
Metody........................................................................................................612self.............................................................................................................612Dziedziczenie...............................................................................................612Metody specjalne.........................................................................................613
Rozszerzenia Pythona ........................................................................................614Program przykładowy „co do grosza” ........................................................................614Materiały dodatkowe...............................................................................................620Podsumowanie.......................................................................................................621
Rozdział 16. Tworzenie interfejsu WWW za pomocą PHP 623
PHP i skrypty wykonywane po stronie serwera...........................................................624Skrypty wykonywane po stronie serwera ..............................................................624
Skrypty CGI..................................................................................................624Aktywne strony serwera ................................................................................625Strony Java i serwlety ...................................................................................625Pisanie skryptów w PHP................................................................................625
Możliwości PHP.................................................................................................626Instalacja i konfiguracja PHP ...................................................................................627
Budowa i instalacja PHP jako interpretera CGI .....................................................628Budowa i instalacja PHP z Apache i jako moduł Apache........................................629Instalacja PHP z pliku RPM.................................................................................631Konfiguracja PHP...............................................................................................631
Wprowadzenie do składni PHP.................................................................................633Zmienne, stałe i typy danych ..............................................................................633Operatory w PHP ...............................................................................................635
Operatory arytmetyczne ................................................................................635Operatory porównań .....................................................................................635
Spis treści 13
Operatory logiczne .......................................................................................635Inne operatory .............................................................................................636
Instrukcje .........................................................................................................636Funkcje ............................................................................................................637Tablice .............................................................................................................638
Realizacja projektu DVD za pomocą PHP ..................................................................639HTTP, HTML i PHP .............................................................................................639Aplikacja...........................................................................................................641
Rejestracja w systemie (Login) ......................................................................641Stan rezerwacji ............................................................................................642Wyszukiwanie tytułów ...................................................................................642Rezerwacja filmów........................................................................................642Odwołanie rezerwacji ....................................................................................642dvdstoredbfunctions.php ..............................................................................643dvdstorecommon.php...................................................................................650dvdstorelogin.php ........................................................................................653dvdstoresearch.php .....................................................................................654dvdstorestatus.php ......................................................................................656dvdstorecancel.php......................................................................................657dvdstorereserve.php ....................................................................................658
Materiały dodatkowe...............................................................................................659Podsumowanie.......................................................................................................660
Rozdział 17. Wbudowywanie i rozszerzanie Pythona za pomocą C/C++ 661
Rozszerzenie Pythona za pomocą modułu rozszerzenia C/C++..............................662Wbudowanie Pythona do programu macierzystego................................................662
Opracowanie modułów rozszerzenia w C/C++ ...........................................................663Wymagane oprogramowanie narzędziowe ............................................................663
Interpreter Pythona ......................................................................................663Biblioteki do opracowywania oprogramowania w Pythonie................................664SWIG — uproszczony generator interfejsu otoczki...........................................664
Rozszerzenie Pythona przy użyciu SWIG...............................................................664Proste funkcje .............................................................................................665Kompilacja i test pliku otoczki utworzonego przez SWIG ..................................668Testowanie modułu rozszerzenia ...................................................................669Dostęp do tablic przy użyciu wskaźników SWIG...............................................670Dodanie metod wirtualnych do struktur ..........................................................671Zgłaszanie i obsługa wyjątków przy użyciu odwzorowań typów ..........................672Tworzenie nowych typów obiektów za pomocą SWIG .......................................678
Rozszerzanie Pythona przy użyciu C API ....................................................................692Typy obiektów Pythona.......................................................................................693Zliczanie odsyłaczy oraz prawo własności ............................................................694Przegląd metod opracowywania modułów rozszerzenia w języku C .........................695
Struktura modułu rozszerzenia ......................................................................695Funkcja init..................................................................................................696
Proste funkcje...................................................................................................697Trochę bardziej złożona funkcja ..........................................................................698Globalna blokada interpretera ............................................................................700Tworzenie nowych typów obiektów Pythona..........................................................700
Minimalny typ obiektu ..................................................................................701Obsługa getattr............................................................................................704
14 Zaawansowane programowanie w systemie Linux
Obsługa setattr............................................................................................705Obsługa wywołań metod ...............................................................................706Inicjalizacja obiektu......................................................................................707
Hermetyzacja obiektów C++ za pomocą interfejsu C API .......................................708Wbudowywanie Pythona do programów C/C++..........................................................711
Środowisko programowania dla wbudowywania....................................................711Wbudowywanie Pythona przy użyciu funkcji wysokiego poziomu .............................712Statyczna konsolidacja programu macierzystego z modułem rozszerzenia ..............714Wbudowywanie Pythona przy użyciu wywołań niższego poziomu.............................716
Uruchamianie napisów .................................................................................716Zastępowanie wewnętrznych funkcji Pythona ..................................................717Wywoływanie funkcji Pythona ........................................................................719Tworzenie egzemplarza obiektu w Pythonie oraz wywoływanie jego metody........720Przetwarzanie wielowątkowe .........................................................................722tdemo.c ......................................................................................................722
Ogólne sugestie .....................................................................................................728Materiały dodatkowe...............................................................................................729Podsumowanie.......................................................................................................729
Rozdział 18. Zdalne wywołania procedur 731
Omówienie.............................................................................................................731Prosta sieciowa baza danych wypożyczalni DVD ........................................................732
Gniazda BSD ....................................................................................................732Prosty serwer gniazd (Simple Socket Server) ..................................................733Prosty klient gniazd (Simple Socket Client).....................................................736
Programowanie przy użyciu interfejsu gniazd BSD......................................................738Architektura ONC-RPC i związane z tym pojęcia .........................................................739
Datagramy (bez połączenia) lub strumienie (zorientowane na połączenie)...............740Rozszerzona reprezentacja danych (XDR).............................................................740
Korzyści wynikające z użycia RPC w aplikacji obsługującej wypożyczalnię DVD..............741Narzędzia i programy użytkowe RPC .........................................................................742
rpcgen — kompilator protokołu RPC ...................................................................742Struktura pliku definiującego protokół RPC.....................................................743portmap — odwzorowanie adresu portu na numer programu RPC ....................743rpcinfo — zapytanie o informację RPC ...........................................................744
Zastosowanie zdalnych wywołań procedur w aplikacji dla wypożyczalni DVD.................745Funkcje bez argumentów lub typów zwracanych....................................................746Funkcje z prostymi argumentami i prostymi typami zwracanymi .............................755Bardziej złożone przykłady ..................................................................................757Zwracanie tablic ................................................................................................760Ograniczenia czasowe dla klienta .......................................................................764
Uwierzytelnianie .....................................................................................................765AUTH_NONE .....................................................................................................765AUTH_UNIX.......................................................................................................765Obsługa uwierzytelniania po stronie klienta .........................................................766Obsługa uwierzytelniania po stronie serwera........................................................767
Użycie serwerów RPC wraz z /etc/inetd.conf.............................................................769Inne metody ułatwiające programowanie sieciowe.....................................................770Materiały dodatkowe...............................................................................................771Podsumowanie.......................................................................................................772
Spis treści 15
Rozdział 19. Multimedia i Linux 773Stan obecny...........................................................................................................773Integracja programowa............................................................................................775Dźwięk...................................................................................................................775
Urządzenia........................................................................................................776Obsługa standardowych formatów dźwiękowych ...................................................778
Nieupakowany surowy format dźwiękowy........................................................778Upakowany format dźwiękowy .......................................................................779WAV............................................................................................................780AIFF ............................................................................................................780Konwersja pomiędzy formatami dźwiękowymi — sox .......................................780
Zrób to sam......................................................................................................781/sys/soundcard.h........................................................................................781soundtest.c .................................................................................................782Ocena możliwości urządzenia karty dźwiękowej...............................................784Możliwości urządzenia ..................................................................................786Obsługiwane formaty....................................................................................788Soundtest — test dźwięku, czyli poskładajmy wszystko razem.........................790Odtwarzanie rzeczywistych danych dźwiękowych .............................................795Porządkowanie.............................................................................................798
Ruchome obrazy.....................................................................................................798Odtwarzacze programowe...................................................................................799
xanim..........................................................................................................799RealPlayer ...................................................................................................800Inne formaty ................................................................................................800
Odtwarzacze sprzętowe......................................................................................800Hybrydy ............................................................................................................801
OMS — otwarty system mediów....................................................................801Kwestie polityczne i prawne.....................................................................................803Materiały dodatkowe...............................................................................................803Podsumowanie.......................................................................................................804
Rozdział 20. CORBA 805Język definicji interfejsu (IDL)...................................................................................806Pośrednik żądań obiektowych (ORB).........................................................................806Umowny adres obiektu (IOR)....................................................................................807Adapter obiektu......................................................................................................807Serwery .................................................................................................................808Usługi nazewnicze i usługi wymiany..........................................................................808Ogólna ocena architektury CORBA............................................................................809CORBA i RPC..........................................................................................................810CORBA i gniazda sieciowe .......................................................................................812Systemy podobne do CORBA ...................................................................................812
DCOM lub COM+...............................................................................................813Metoda zdalnych wezwań (RMI) w języku Java......................................................813Enterprise JavaBeans ........................................................................................814MQSeries firmy IBM...........................................................................................814SOAP ...............................................................................................................815
IDL: definiowanie interfejsu .....................................................................................815Moduły .............................................................................................................816
Pułapki........................................................................................................816
16 Zaawansowane programowanie w systemie Linux
Interfejsy ..........................................................................................................817Podstawowe typy danych ...................................................................................817Typy szablonowe ...............................................................................................818
Typ sequence ..............................................................................................818Typy string i wstring......................................................................................819Typ fixed .....................................................................................................819Złożone typy danych .....................................................................................819Operacje .....................................................................................................821Wyjątki ........................................................................................................823Atrybuty.......................................................................................................824
Przykład aplikacji obsługującej wypożyczalnię DVD ...............................................824Odwzorowania języków ............................................................................................828
Składniki odwzorowania języka ...........................................................................829Odwzorowania dla języka C ................................................................................829
Podstawowe odwzorowania typów danych IDL.................................................830Złożone i szablonowe typy danych .................................................................830Odwołania do stałych ...................................................................................833Wywoływanie operacji ...................................................................................834Obsługa wyjątków ........................................................................................834
Przykład wprowadzający — prosty system powiadamiania ..........................................836Prosta wymiana komunikatów ............................................................................836Zastosowanie ORBit z IDL ..................................................................................837Klient komunikatów...........................................................................................837Serwer komunikatów .........................................................................................839Kompilowanie aplikacji ORBit .............................................................................840Uruchamianie przykładowej aplikacji ...................................................................841
Materiały dodatkowe...............................................................................................842Podsumowanie.......................................................................................................842
Rozdział 21. Implementacja CORBA z pośrednikiem ORBit 843
CORBA w aplikacji obsługującej wypożyczalnię płyt DVD.............................................844Klient DVD........................................................................................................844Serwer DVD ......................................................................................................845Serwer obsługi logów.........................................................................................845Serwer weryfikacji..............................................................................................845Kod klienta .......................................................................................................846Kod serwera obsługi logów.................................................................................846Kod serwera DVD ..............................................................................................847
Odwzorowanie API w języku C na operatory CORBA .........................................857Montaż całości..................................................................................................862
Zastosowanie libgnorba ..........................................................................................863Konfiguracja ORBit do pracy w sieci .........................................................................864GOAD — rejestr aktywacji obiektów GNOME .............................................................865Zastosowanie CORBA w GNOME..............................................................................865Zaawansowane właściwości CORBA .........................................................................867
Dynamiczne wezwania interfejsu.........................................................................867Usługi CORBAServices.......................................................................................867
Usługi nazewnicze........................................................................................868Usługi wymiany ............................................................................................868Obsługa zdarzeń ..........................................................................................868Usługa powiadamiania .................................................................................868
Spis treści 17
Kontrola pracy równoczesnej.........................................................................869Usługa wymiany komunikatów.......................................................................869Usługi związane z czasem.............................................................................869Obsługa cyklu życia obiektu ..........................................................................870Usługi relacyjne ...........................................................................................870Usługi utrwalania obiektów ...........................................................................870Usługi transakcyjne ......................................................................................870Usługi związane z bezpieczeństwem ..............................................................871Usługa uzewnętrzniania ................................................................................872Obsługa właściwości obiektów ......................................................................872Obsługa zapytań o obiekty ............................................................................872Obsługa licencjonowania ..............................................................................872
Usługi CORBAFacilities ......................................................................................872Projektowanie i uruchamianie skalowalnych usług CORBA.....................................873
Zarządzanie równoczesnym dostępem ...........................................................874Wątki ..........................................................................................................874Rozdzielanie wielu obiektów..........................................................................874Przetwarzanie asynchroniczne i wywołania zwrotne..........................................875Zarządzanie odpornością ..............................................................................876Interfejsy do zarządzania systemem ..............................................................876
Materiały dodatkowe...............................................................................................877Podsumowanie.......................................................................................................878
Rozdział 22. Systemy bezdyskowe 879Trochę historii ........................................................................................................879Co takiego!? Nie ma dysku?....................................................................................881Dlaczego bez dysku? ..............................................................................................882Jak to działa?.........................................................................................................883
Uruchamianie systemu bezdyskowego ................................................................884Identyfikacja maszyn bezdyskowych w sieci .........................................................885Uruchamianie systemu operacyjnego ..................................................................886
Konfiguracja serwera ..............................................................................................888Tworzenie obrazu startowego...................................................................................890Jądro Linuksa dla systemu bezdyskowego ................................................................892Główny system plików.............................................................................................895Problemy ...............................................................................................................898Aplikacje klienckie ..................................................................................................899Podsumowanie.......................................................................................................900
Rozdział 23. XML i libxml 903Struktura dokumentu XML.......................................................................................904
Składnia XML....................................................................................................905Dobrze uformowany dokument XML ....................................................................905
Sekcje ........................................................................................................906Elementy .....................................................................................................907Zagnieżdżanie elementów.............................................................................908Komentarze.................................................................................................909
Poprawność XML...............................................................................................910Definicja typu dokumentu (DTD) ....................................................................911Tworzenie DTD.............................................................................................911Schematy....................................................................................................914Powiązania DTD z dokumentem XML .............................................................915
18 Zaawansowane programowanie w systemie Linux
Rozbiór XML...........................................................................................................915DOM ................................................................................................................915SAX..................................................................................................................916Biblioteka libXML (gnome-xml) ............................................................................916
Tworzenie i wywoływanie parsera...................................................................917Informacja o dokumencie..............................................................................920Zastosowanie wywołań zwrotnych..................................................................921Przykład wywołania zwrotnego .......................................................................926Utrzymywanie informacji o stanie parsera.......................................................929
Ostateczna wersja parsera.................................................................................930Materiały dodatkowe...............................................................................................937Podsumowanie.......................................................................................................938
Rozdział 24. Klastry Beowulf 939
Konfiguracja sprzętowa ...........................................................................................939Konfiguracja oprogramowania..................................................................................940Programowanie klastra Beowulf ...............................................................................941Programowanie z wykorzystaniem MPI ......................................................................941
Podstawowe właściwości programów MPI............................................................943Kompilacja i uruchamianie prostego programu MPI ..............................................945Rozproszony koder MP3.....................................................................................946Wydajność komunikacyjna klastra Beowulf ..........................................................948Przegląd zaawansowanych możliwości MPI ..........................................................952
Procedury obsługujące komunikację między dwoma węzłami............................952Typy danych definiowane przez użytkownika ...................................................954Operacje kolektywne ....................................................................................955Bariera (barrier) ...........................................................................................959
Przykłady programów korzystających z MPI ..........................................................959Obliczanie wartości liczby „pi”.......................................................................960Obliczanie zbioru Mandelbrota ......................................................................962Transponowanie macierzy .............................................................................966
Programowanie stosujące PVM................................................................................970Porównanie PVM z MPI ......................................................................................970Pobieranie i instalacja PVM................................................................................971Omówienie funkcji biblioteki PVM .......................................................................971Przykładowy program PVM..................................................................................974
Kompilacja i uruchamianie programu PVM na klastrze Beowulf ........................975Materiały dodatkowe...............................................................................................976Podsumowanie.......................................................................................................977
Rozdział 25. Dokumentacja 979
Określenie odbiorców pracy.....................................................................................980Dokumentacja użytkownika: interfejs graficzny ..........................................................980
Dokumentacja dla lokalnych GUI.........................................................................980Pomoc kontekstowa .....................................................................................981Pomoc kontekstowa „dla ubogich” ................................................................981
Dokumentacja dla interfejsów WWW ...................................................................983Dokumentacja dla zaawansowanego użytkownika lub administratora systemu.............984
Opcje wiersza poleceń: możliwość użycia --help....................................................984Strony podręcznika systemowego .......................................................................985
Sekcje podręcznika systemowego .................................................................986
Spis treści 19
Utrzymywanie porządku......................................................................................987Najczęściej spotykane elementy strony podręcznika systemowego ...................987Podręcznik systemowy za zasłoną: troff .........................................................989Tworzenie własnej strony podręcznika systemowego .......................................989
Kroje pisma ......................................................................................................991Akapity .............................................................................................................992Tabele..............................................................................................................992
Instalacja strony podręcznika systemowego ...................................................993Przykładowa strona podręcznika systemowego ...............................................993
Tworzenie stron podręcznika dla API ...................................................................995Nowsza generacja stron podręcznika — pliki info.................................................995
Wszystko o strukturze: od pojedynczego programu do systemów rozproszonych...........997Narzędzia dokumentacyjne ......................................................................................998
Stare, ale jare: TeX i LaTeX ................................................................................999Sposób działania programów TeX i LaTeX.......................................................999Produkt końcowy........................................................................................1001Oglądanie wyniku przetwarzania ..................................................................1002Tworzenie lepiej wyglądających dokumentów ................................................1002Ponowne spojrzenie na pliki info .................................................................1003
Nowy gatunek: HTML, XML i DocBook ...............................................................1003HTML........................................................................................................1004Rzut oka na DocBook .................................................................................1004
Ostatnie pociągnięcia pędzlem: pliki HOWTO i FAQ.............................................1005Dokumentacja dla programisty...............................................................................1009
Zastosowanie metody „POD” w języku Perl........................................................1010Programowanie literackie .................................................................................1011
Jak to działa? ............................................................................................1012Lekkostrawne programowanie literackie ............................................................1015Wymiana dokumentów.....................................................................................1016Pliki PDF.........................................................................................................1017
Podsumowanie.....................................................................................................1017
Rozdział 26. Sterowniki urządzeń 1019
Kontekst działania................................................................................................1020Moduł i kod inicjalizujący.......................................................................................1021Sekcje konsolidatora ............................................................................................1022
Przykładowy kod modułu ..................................................................................1022Urządzenia i sterowniki magistrali PCI ....................................................................1023
Struktura pci_dev ............................................................................................1023Wyszukiwanie urządzeń PCI..............................................................................1025
Przeszukiwanie ręczne................................................................................1025Sterowniki PCI.................................................................................................1026Funkcje dostępu do urządzeń PCI .....................................................................1028Przydział zasobów ...........................................................................................1028Obsługa przerwań............................................................................................1030
Kod sterownika PCI modułu Applicom ..........................................................1031Dostęp do pamięci w obszarze użytkownika.......................................................1033Architektura kiobuf ..........................................................................................1034
Kod obsługi kiobuf dla karty firmy Applicom..................................................1036
20 Zaawansowane programowanie w systemie Linux
Podstawowe funkcje blokujące .........................................................................1039Semafory ..................................................................................................1039Blokady pętlowe.........................................................................................1040Wielka blokada jądra..................................................................................1040
Szeregowanie zadań i kolejki............................................................................1041schedule() .................................................................................................1041set_current_state().....................................................................................1042schedule_timeout() ....................................................................................1042wake_up() .................................................................................................1042add_wait_queue().......................................................................................1043remove_wait_queue() .................................................................................1044sleep_on() i „wyścigi” .................................................................................1044Powrót do sterownika karty Applicom...........................................................1045
Licznik wywołań w module................................................................................1047Budowanie sterownika.....................................................................................1049
Opcje konfiguracyjne ..................................................................................1049Pliki Makefile.............................................................................................1050
Co zrobić z nowym sterownikiem?..........................................................................1051Jak zgłosić nowy sterownik?.............................................................................1052
Podsumowanie.....................................................................................................1054
Rozdział 27. Rozprowadzanie aplikacji 1055
Pakiety RPM.........................................................................................................1057Użytkownik RPM..............................................................................................1057Co naprawdę zostało zainstalowane?................................................................1058Baza danych RPM ...........................................................................................1059
Co znajduje się w pakiecie? ........................................................................1059Usuwanie pakietu ......................................................................................1060Status pakietu...........................................................................................1060Instalowanie pakietów ................................................................................1061Aktualizacja pakietu ...................................................................................1062Instalatory graficzne ...................................................................................1062Sprawdzanie zależności ..............................................................................1063Pomijanie zależności ..................................................................................1065Inne opcje .................................................................................................1065Pakiety, które nie są zainstalowane.............................................................1067
Anatomia pakietu RPM ....................................................................................1068Pakiety źródłowe .............................................................................................1069
configure, autoconf i automake .............................................................................1070Pakiety źródłowe RPM......................................................................................1075
Budowanie pakietu RPM .......................................................................................1076Łatki....................................................................................................................1081
Tworzenie łatki ................................................................................................1081Użycie łatki .....................................................................................................1083
GNATS.................................................................................................................1084Podsumowanie.....................................................................................................1084
Rozdział 28. Wersje międzynarodowe 1085
Terminologia I18N ................................................................................................1087Czy Unicode nie jest rozwiązaniem? .......................................................................1088
Spis treści 21
Unicode..........................................................................................................1088Co to jest? ................................................................................................1088Co umożliwia Unicode?...............................................................................1093A czego nie umożliwia?...............................................................................1094
Problem kodowania znaków...................................................................................1095ISO 2022: Techniki poszerzania zakodowanych zestawów znaków.......................1095Programowanie z użyciem Unicode....................................................................1097
Modele I18N i środowisko systemowe ...................................................................1104Model lokalizacji POSIX....................................................................................1104Przewodnik X/Open dotyczący przenośności (XPG) .............................................1108
Rozszerzenia GNU libc dla modeli POSIX i X/Open........................................1110Formatowanie danych wyjściowych i przetwarzanie danych wejściowych ....................1112
X Window System............................................................................................1112Formatowanie danych wyjściowych ..............................................................1112Wprowadzanie danych przez użytkownika .....................................................1113
Praktyczne aspekty programowania I18N................................................................1117I18N i wewnętrzne przetwarzanie tekstu............................................................1119Programowanie przy użyciu lokalizacji................................................................1120I18N i programowanie z zastosowaniem Xlib .....................................................1132I18N i interfejsy graficzne w Linuksie ................................................................1139Rola I18N w oprogramowaniu dla systemu Linux................................................1141
I18N w rzeczywistych projektach ............................................................................1142Programowanie obiektowe i I18N......................................................................1143I18N w pakietach do budowy aplikacji ...............................................................1144Co dalej z I18N w systemie Linux?....................................................................1146
Odnośniki z komentarzami ..........................................................................1146
Dodatek A Opis obiektów GTK+ i GNOME 1149
Widżety i funkcje GTK+..........................................................................................1149GtkButton.......................................................................................................1149GtkCheckButton ..............................................................................................1150GtkCList .........................................................................................................1150GtkCombo ......................................................................................................1156GtkEntry .........................................................................................................1157GtkFrame .......................................................................................................1159GtkHBox .........................................................................................................1159GtkHButtonBox ...............................................................................................1159GtkHSeparator ................................................................................................1160GtkLabel.........................................................................................................1160GtkMenu ........................................................................................................1161GtkMenuBar ...................................................................................................1162GtkMenuItem..................................................................................................1163GtkNotebook...................................................................................................1164GtkOptionMenu...............................................................................................1166GtkPixmapMenuItem .......................................................................................1167GtkScrolledWindow..........................................................................................1167GtkSpinButton ................................................................................................1168GtkTable.........................................................................................................1170GtkText ..........................................................................................................1171GtkVBox .........................................................................................................1172GtkWindow .....................................................................................................1173
22 Zaawansowane programowanie w systemie Linux
Widżety i funkcje GNOME ......................................................................................1173GnomeAbout...................................................................................................1173GnomeApp......................................................................................................1174GnomeAppBar.................................................................................................1175GnomeDateEdit...............................................................................................1176GnomeDialog ..................................................................................................1176GnomeDock....................................................................................................1178GnomeDockItem .............................................................................................1178GnomeEntry....................................................................................................1179GnomePropertyBox..........................................................................................1180
Materiały dodatkowe.............................................................................................1181
Dodatek B Definicja protokołu RPC dla wypożyczalni płyt DVD 1183
Dodatek C Licencje oprogramowania otwartego 1191
Ogólna Licencja Publiczna GNU..............................................................................1191Ogólna licencja publiczna GNU dla bibliotek............................................................1199Licencja Wolnej Dokumentacji GNU........................................................................1209Publiczna licencja Q..............................................................................................1216
Skorowidz 1219
Programowanie graficznych
interfejsów użytkownika (GUI)
za pomocą GNOME-GTK+
Środowisko GNOME (w dosłownym tłumaczeniu: „środowisko modelu obiektów sie-ciowych GNU”, GNU Network Object Model Enviroment) to rozwijająca się gałąź dar-mowego oprogramowania GNU. Celem projektu GNOME jest zbudowanie wszechstron-nego i łatwego w obsłudze środowiska pulpitowego dla użytkownika oraz wydajnychi skutecznych komponentów aplikacyjnych dla programistów. Biblioteki GNOME i GTK+(na których w dużej mierze oparte są elementy graficzne GNOME) za pomocą ścisłegopołączenia narzędzi pulpitu z wydajną i elastyczną konstrukcją oprogramowania uatrak-cyjniają bogactwem możliwości opracowywanie w Linuksie profesjonalnych GUI, czyligraficznych interfejsów użytkownika (graphical user interface).
Zestawy narzędzi graficznych, takie jak Tk, Qt, Motif i inne, są obecne od dawna dlaukrycia przed programistą GUI interfejsu API systemu X Window. Co zatem wyróżniabiblioteki GNOME i GTK+?
� Dzięki licencji GPL biblioteki GNOME i GTK+ są, były i zawsze będą całkowiciedarmowym oprogramowaniem. Podstawową ich zaletą w stosunku np. do KDE(K Desktop Environment środowisko pulpitowe K) jest to, że (w odróżnieniuod KDE) w swojej wewnętrznej strukturze nie wykorzystują żadnegooprogramowania objętego choćby tylko w części prawami własności.
� Aby ułatwić przenoszenie na różne platformy, biblioteki te są napisanew języku C. Implementują one wyrafinowany, w pełni obiektowy systemtypów danych. Taka konstrukcja zachęca do przenoszenia API na inne języki.Do programowania z GNOME-GTK+ można już używać C, C++, Python,Guile i Perl.
276 Zaawansowane programowanie w systemie Linux
� Podstawowym elementem strukturalnym w nowym i następnych wydaniachGNOME jest Bonobo. Ta technologia umożliwia stosowanie możliwychdo wbudowania komponentów wielokrotnego użytku, podobnych do ActiveXi Java Beans. To pozwoli na przykład na włączenie komponentu graficznegoczy też edytora tekstu do programu arkusza kalkulacyjnego.
Pulpit GNOME jest przyjazny w użyciu i niezwykle łatwo dostosowuje się do indywi-dualnych potrzeb. Menu są wstępnie skonfigurowane do intuicyjnie najwłaściwszegoukładu, mają dobrze zaprojektowane i atrakcyjne ikony. GNOME jest niezależny od me-nedżera okien, ale dostarcza mu „wskazówek”, aby prawidłowo współpracował z takimielementami GNOME, jak na przykład panel.
Zakładając podstawową wiedzę o GNOME-GTK+, w tym rozdziale omówimy funda-mentalne zagadnienia dotyczące GNOME-GTK+. Przypomnimy znane tematy i poru-szymy w zarysie pojęcia zaawansowane. Celem jest osiągnięcie poziomu, na którymbędzie można w komfortowy sposób zrealizować za pomocą GNOME-GTK+ interfejsGUI dla aplikacji obsługującej wypożyczalnię płyt DVD. Będziemy pracować wyłącz-nie w języku C, co, jak zobaczymy, pasuje zaskakująco dobrze do obiektowej strukturyGNOME-GTK+.
Wszyscy, dla których GNOME-GTK+ jest całkowitą nowością, mogą najpierw
zapoznać się z materiałami o charakterze wprowadzającym, które są podane
na końcu tego rozdziału.
Omówimy:
� biblioteki GTK+ i GNOME,
� glib — bibliotekę narzędziową C,
� GTK+ — podstawowy zestaw narzędzi,
� podstawy GNOME,
� drzewo kodu źródłowego GNOME,
� zapis konfiguracji,
� analizę składniową wiersza poleceń,
� zarządzanie sesją,
� źródła dodatkowej informacji o GNOME-GTK+.
Biblioteki GTK+ i GNOME
W tym i następnym podrozdziale zajmować się będziemy prawie wyłącznie następują-cymi bibliotekami:
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 277
� glib,
� GTK+ (wraz z GDK),
� GNOME.
glib
Biblioteka glib zawiera szkielet konstrukcyjny większości struktur bibliotek GTK+i GNOME. Jest to wszechstronna biblioteka, oferująca wszelakie akcesoria dla programi-stów języka C, włączając w to: zarządzanie pamięcią, przechowywanie danych i funkcjesortujące. Zawiera również wiele ulepszonych wariantów standardowych funkcji syste-mowych oraz funkcji bibliotecznych C. Omówimy to szczegółowo w kolejnym podroz-dziale, gdzie wyjaśnimy, co oznacza określenie „ulepszone warianty”.
GTK+
GTK+ (GIMP ToolKit), czyli zestaw narzędzi GIMP (GNU Image Manipulation Pro-gram — uniwersalny program do edycji grafiki bitmapowej) jest zestawem narzędziGUI używanym przez GNOME, udostępniającym warstwę abstrakcji między programi-stą a odnośnym systemem okien (system X Window czy też Win32). Dzięki temu pro-gramowanie aplikacji GUI jest łatwiejsze. Zwolennicy zestawu GTK+ wskazują na jegowspaniały system układu pojemników (zobacz podrozdział Pojemniki w dalszej częścitego rozdziału) do projektowania okien, jak też na przejrzysty system łączenia zdarzeńgenerowanych przez użytkownika z kodem.
W systemie X Window zdarzenia nazywa się sygnałami. Takie sygnały różnią sięcałkowicie od sygnałów niskiego poziomu w UNIX-ie, więc nie należy ich mylić ze sobą.
GDK
GDK (GIMP Drawing Kit) jest zestawem narzędzi do rysowania, który udostępnia cienkąwarstwę pomiędzy aplikacjami a elementarnymi procedurami Xlib do rysowania. W cza-sie opracowywania oprogramowania przy użyciu GTK+ w istocie używa się nakładki naGDK, który z kolei stanowi nakładkę na system X. Oznacza to, że biblioteka GDK jestniezbędnym składnikiem w opracowywaniu aplikacji dla Linuksa przy użyciu narzędziGTK+ i GNOME.
Istnieją jeszcze inne, bardzo rozbudowane biblioteki związane z GNOME. Ich opis sta-nowczo wykracza poza zakres tej książki. Jednak z uwagi na to, że w środowisku użyt-kowników GNOME powszechnie się je stosuje i do nich odwołuje, grzechem byłobyo nich nie wspomnieć. Są to:
� Imlib,
� ORBit,
� libGnorba.
278 Zaawansowane programowanie w systemie Linux
Imlib
Imlib jest rozbudowaną biblioteką do obsługi grafiki, zdolną do operowania dużą liczbą for-matów graficznych, jak np. JPG i PNG. GNOME używa wersji GDK tej biblioteki. W przy-szłości biblioteka Imlib będzie zastąpiona przez doskonalszą bibliotekę ��������.
ORBit
ORBit jest nieodpłatnie udostępnianą implementacją CORBA 2.2 ORB, zaprojektowanąz myślą o szybkości i prostocie. ORBit także obsługuje język C, a zatem jest właściwymwyborem obiektowego pośrednika zapytań ORB dla GNOME. W rozdziałach 20. i 21.podamy więcej wiadomości o implementacji CORBA.
libGnorba
Biblioteka libGnorba zaopatruje GNOME w łącza z ORBit, włącznie z mechanizmamiaktywacji obiektów i systemem zabezpieczeń.
Biblioteka glib
Jest biblioteką narzędzi C ogólnego przeznaczenia, która dostarcza solidnych elementówniskiego poziomu i ma zasadnicze znaczenie dla operacji przenoszenia oprogramowaniamiędzy różnymi typami systemów UNIX i Windows. Biblioteka glib wnosi standardo-wy zestaw funkcji narzędziowych i typów danych do wykorzystania przez programistówwszystkich platform. Dzięki temu nie trzeba wyważać otwartych drzwi i można skrócićzarówno czas opracowania aplikacji, jak i zużycie pamięci. Co więcej, biblioteka możezwiększyć stabilność opracowywanego kodu, ponieważ nie trzeba poznawać nowychstandardów dla każdej platformy, na której się programuje. I jest cudownie użyteczna —nawet przy zwykłym opracowywaniu aplikacji dla Linuksa.
Zestaw funkcji udostępnianych przez glib wywiera imponujące wrażenie niezależnie odprzyjętych standardów. Szczegółowe ich omówienie wykracza znacznie poza ramy tegorozdziału. Na szczęście, podobnie jak każdy typowy projekt GNU, biblioteka glib jestbardzo dobrze opisana zarówno na swojej witrynie http://www.gtk.org, jak i w pliku na-główkowym ����� . Nawet jeśli ktoś nie należy do miłośników czytania plików na-główkowych, powinien docenić skarbnicę wiedzy tam zawartą. Nierzadko okazuje się,że szybciej można odnaleźć potrzebną informację w pliku nagłówkowym niż podczasprzeglądania plików pomocy lub stron WWW.
GNOME i GTK+ same znacząco polegają na typach, funkcjach i makrodefinicjach diagno-stycznych udostępnionych przez glib. Tak więc, należyte opanowanie wiedzy na temat glibpowinno być zasadą każdego kursu programowania w GNOME-GTK+.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 279
W tym podrozdziale zostaną scharakteryzowane:
� typy danych biblioteki glib,
� makrodefinicje,
� procedury obsługi pamięci (memory routines),
� funkcje obsługi napisów,
� listy.
Typy
Jeden ważny, aczkolwiek często zaniedbywany aspekt języka C, to zależność rozmiarupewnych elementarnych typów od platformy systemowej. Na przykład ��� zwykle zajmie32 bity pamięci, ale komputery mogą zarezerwować dla ��� mniej lub więcej. Oczywi-ście istnieją względnie proste metody programowania, które pozwalają wykluczyć tegorodzaju problemy, niemniej jednak pomyłki się zdarzają.
Dlatego też, aby uczynić nasze życie łatwiejszym, glib definiuje własny zbiór elemen-tarnych typów o gwarantowanej długości oraz nowe typy �������, ������ i typ wskaź-nika na ����. I tak na przykład ������ jest typem całkowitym ze znakiem o długości 16bitów, a ������ jest jego odpowiednikiem bez znaku.
Typ zdefiniowany w glib Opis
�������������������������� liczba całkowita o gwarantowanej długości, ze znakiem
� ������� ������� ������� ���� liczba całkowita o gwarantowanej długości, bez znaku
�������� typ boole’owski, ���� i ����� także zdefiniowane w glib
���� odpowiednik ���
������ odpowiednik �����
����� odpowiednik ����
������ odpowiednik �����
� � ��� odpowiednik � ���
�!������ odpowiednik "�� �#
Zauważmy, że ������ i ������ istnieją jedynie wtedy, gdy platforma systemowa możeje obsłużyć. Jeśli tak, to glib zdefiniuje ���������� ��.
Typy ����, �� ���, �! ��, ����� i ������ to otoczki istniejących typów języka C i sąwłączone jedynie dla zachowania zgodności. Biorąc pod uwagę ich identyczną naturę,można zapytać, jakie korzyści płyną z użycia ���� w miejsce ���, czy też �! �� zamiast! ��. Faktem jest, że z technicznego punktu widzenia nie ma żadnej różnicy. Jednakrozważając to w kategoriach stylu dobrego programowania, zachowamy spójność, a ten
280 Zaawansowane programowanie w systemie Linux
nawyk powinniśmy ćwiczyć przy każdej okazji. Użycie jednolitego stylu kodowania i za-chowanie spójności jest szczególnie istotne w czasie pisania kodu dla wielu platformsystemowych. Choć skompilowany kod nie ma różnicy spowodowanej zastąpieniem ���przez ����, to taka zamiana może jednak pomóc programiście w bardziej subtelny sposób.
Makrodefinicje
Biblioteka glib definiuje kilka makrodefinicji pomocnych w ogólnym programowaniui usuwaniu błędów. Większość z nich jest zapewne znana programistom języka C. Dlauzupełnienia typu �������� załączono makrodefinicje "#� oraz $�%&�. �#%% jest zdefi-niowane w ANSI C jako pusty wskaźnik (void pointer): '����()*+.
Istnieje także kilka prostych makrodefinicji ułatwiających żonglowanie liczbami. Wszystkopo to, by przyspieszyć kodowanie i zwiększyć czytelność kodu
Makrodefinicja Opis
����� $ ������������%&'.
���� $ �����������%(�����'.
)��� $ ������)����%%"�� �#'�&'.
�*�%+' Zwraca wartość bezwzględną +.
,-)%���' Zwraca mniejszą z liczb � i �.
,�.%���' Zwraca większą z liczb � i �.
/��,0%+��1���2�34��5��6�34' Zwraca +, jeśli + jest pomiędzy 1���2�34 i 5��6�34; zwraca 1���2�34,jeśli(+71���2�34 oraz 5��6�34, jeśli +85��6�34.
W zależności od procesora komputera, makrodefinicja ��,- ��."/�" przyjmuje wartość��%� %����/���, ��,�����/��� lub ��0/0���/��� (odpowiednio, kolejność bajtów 4321,1234 i 3412).
Makrodefinicje diagnostyczne
Biblioteka glib dostarcza zbioru makrodefinicji, które mogą być użyte do sprawdzeniazałożeń w kodzie. Dzięki nim błędy w programach mogą być szybciej wykryte. Należymakrodefinicje umieścić we wrażliwych miejscach kodu, aby sprawdzały konieczne wa-runki. W razie niepowodzenia weryfikacji warunku, makrodefinicje wydrukują ostrze-żenie na konsoli. Mogą wymusić natychmiastowy powrót do funkcji wywołującej, a nawetzakończenie aplikacji.
Makrodefinicje dzielą się na dwa typy: te, które są powszechnie używane do sprawdza-nia poprawności argumentów dostarczonych przez funkcję wywołującą, oraz na te, któreweryfikują warunki w obrębie funkcji.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 281
Sprawdzenie poprawności argumentów jest często pierwszą czynnością przy rozpoczę-ciu funkcji. Są to tzw. sprawdzenia warunków koniecznych. Dwie makrodefinicje:�����������������'1�����231��!����1���* oraz �������������'1�����* drukująostrzeżenie, jeśli '1�����45 "#�* i powracają z funkcji. Podczas gdy pierwsza z tychfunkcji zwraca 31��!����1��� i jako taka musi być użyta dla funkcji, które nie są dekla-rowane w pustym kontekście (void), druga jest używana w funkcjach, które nie przeka-zują wartości (void functions).
Nie trzeba długo szukać, aby znaleźć przykłady w kodach źródłowych GNOME — otowycinek z implementacji panelu w GNOME:
"�� !����9�����9�!!���%�!!���-����#����':������9��� ��9��9����%�����(;�)���'<
�������%����=85� ���'�:������������%����=8�4!��;;��00���9������'�:������������������� �9�!!���9! �9���������%����= ���'<����������>������������695� ���9 �����4%����=85� ���'<�����>>
Bez �������������, gdyby w ��� przekazano �#%%, funkcja ������!�����������wpadłaby w tarapaty. W obecności makrodefinicji weryfikującej warunek ������������� zwraca komunikat o błędzie:
##�/�-�-/���##?������!����@�?��������A�%!����9�����9�!!���'?��������������������������B�����(;�)���B������ @
który bezpośrednio wskazuje na przyczynę kłopotów. Sprawdzenie wewnętrznej zgod-ności w obrębie funkcji jest najczęściej przeprowadzane za pomocą makrodefinicjiweryfikacji warunku:
�9������%5�� ��6'
Jeśli warunek nie jest spełniony, to wywoływana jest funkcja ����� i generowany zrzutpamięci:
##����C��##?����������@�?������D�%������9����'?�������������������������������� ?�%!�������(;�)���'��������@@@������ �%����� 1!� 'E
Ponieważ �������� kończy wykonywanie programu, zaleca się użycie �������������w obrębie funkcji w przypadkach, w których niepowodzenie nie byłoby krytyczne.
Do oznaczenia obszaru kodu, który nigdy nie powinien być wykonany, glib dostarczamakrodefinicji:
�9������9���9������ %'
282 Zaawansowane programowanie w systemie Linux
która powoduje przerwanie połączone z komunikatem o błędzie, jeśli kiedykolwiek takifragment kodu zostanie osiągnięty.
##����C��##?������������95�� �5@�?������A�% ! ���9������9�����'?�������������������� � �������������� ��������@@@������ �%����� 1!� 'E
Okazuje się to użyteczne w instrukcjach warunkowych, gdzie jeden lub więcej warun-ków nigdy nie powinno być spełnionych. Na przykład w tym fragmencie kodu:
� �����9!����;���69�������69���9� �����9!����%F�G9)C��*CCG�%������9�������6''<
���5�����%� �����9!���'����:����������-���90�F�?������������;����6 !95� ����%F�G9H-IF���%� ����'��J�����9������9�����J'<����������6<���������,�,*��90�F�?������������;����6 !95� ����%F�G9H-IF���%� ����'��J1�1���9������9�����J'<����������6<���������I-�G90�F�?������������;����6 !95� ����%F�G9H-IF���%� ����'��J ��69������9�����J'<����������6<���� ��� ��?�������9������9���9������ %'<����>
zapewniamy, że !���������� jest równa albo � %��0���, 6�6,�"�0���, albo też /�&7�0���w instrukcji �1��! .
Biblioteki GNOME i GTK+ często wykorzystują te makrodefinicje w swoich kodachźródłowych. Z tego m.in. powodu programowanie i wykrywanie błędów przy użyciutych bibliotek jest łatwe i oczywiste. Użycie makrodefinicji diagnostycznych skróci o po-łowę czas, jaki poświęcamy na szukanie wskaźników �#%%( i innych irytujących błędóww programach — warto spróbować.
Funkcje obsługujące napisy
Operowanie napisami w języku C jest kłopotliwym zadaniem, o czym wie każdy pro-gramista pracujący w tym języku. Postępowanie z tablicami znakowymi, wskaźnikamido znaków, wskaźnikami do tablic, tablicami wskaźników itd. wymaga konsekwentnegoi bezbłędnego programowania.
Wykroczenie poza zakres pamięci oraz niepoprawne użycie wskaźników to podstawowebłędy wykonania. Nie pomaga też to, że standardowe funkcje obsługujące napisy zawartew ������� nie tolerują pomyłek. Biblioteka glib udostępnia alternatywne funkcje, któresą bardziej przejrzyste, bezpieczniejsze i wygodne do przenoszenia pomiędzy różnymiplatformami. Oferuje również dodatkowe funkcje, które są pomocne w sytuacji, gdy po-trzebne będzie pocięcie napisu na kawałki, wymiana czy zwykłe manipulacje na napisach.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 283
Dobrym przykładem solidności biblioteki obsługującej napisy w glib jest ���������.Ta funkcja jest równoważna ������, ale kopiuje tylko pierwszych � znaków sformato-wanego napisu do � i gwarantuje zakończenie napisu wartością �#%%. Warto zapamię-tać, że w � znaków mieści się też ogranicznik �#%%.
������9��!�����%������#� ���� ��������������������#���1����@@@'
Przed użyciem( ��������� należy zadbać o zapewnienie sformatowanemu napisowiwystarczającej ilości miejsca.
������#1���;��91�����%K&'<�9��!�����%1����K&��J*�� �L �54���!��@�L�J�������������'<
W takim przypadku wygodniejsza metoda polega na użyciu �������������:
������#��9��� !9!�����%������������#����1����@@@'
Przydziela ona poprawną ilość miejsca do przechowywania sformatowanego napisu,wykluczając potrzebę zgadywania czy obliczania potrzebnej długości.
������#1���;��9��� !9!�����%JH4���!������ �L @�L�J�������������'<
W obu przypadkach przydzielona pamięć musi być po wykorzystaniu uwolniona zapomocą �����:
�9����%1��'<
Do funkcji zarządzania pamięcią występujących w glib jeszcze powrócimy.
Na wszystkich platformach systemowych funkcje ���!���!8� i ����!���!8� mają swojeodpowiedniki w bibliotece glib w postaci:
������9��������1!%������������#����������������#��'������9���������1!%������������#����������������#����� �����'
gdzie �����!���!8� porównuje dwa podane napisy, a ������!���!8� pierwsze � znakówdwóch napisów. Zwraca 0, jeśli się zgadzają, wartość ujemną, jeśli ��(9(�: oraz wartośćdodatnią, jeśli ��(;(�:. Porównanie nie rozróżnia małych i wielkich liter.
Biblioteka glib udostępnia również funkcje modyfikujące napis. Aby zamienić wielkośćliter w napisie na wielkie lub małe, trzeba wywołać odpowiednio ���� i �����1�. Kolej-ność znaków w napisie jest odwracana za pomocą ������������, tak więc ������������'<����<* zamieni napis na <����<.
"�� ��9��� !%������#������'"�� ��9��� �5�%������#������'"�� ��9�����"����%������#������'
Funkcja �����! � usuwa wiodące spacje w napisie, a �����! �8� usuwa spacje końcowe.
������#��9����� �%������#������'������#��9������1!%������#������'
284 Zaawansowane programowanie w systemie Linux
Do utworzenia świeżo zaalokowanej kopii napisu potrzebne będą wspomniane wcze-śniej �������, �������� i �������������. Jak wiadomo, ������� kopiuje pełny na-pis, a �������� kopiuje pierwszych �(znaków:
������#��9��� !%������������#���'������#��9���� !%������������#����1����� �����'
Na koniec naszego krótkiego przeglądu najchętniej stosowanych funkcji obsługującychnapisy docieramy do dwóch funkcji przeznaczonych do łączenia napisów:
������#��9���������%������������#����@@@'������#��9���2���%������������#���!��������@@@'
Funkcja(�����!��!�� zwraca świeżo alokowany napis zawierający połączenie argu-mentów (jako ostatni parametr przekazujemy wskaźnik NULL), natomiast �����=���działa w podobny sposób, ale umieszcza ��������� pomiędzy elementami łączonymi.
Przydzielanie pamięci
Biblioteka glib neutralizuje wszelkie potencjalne problemy związane z funkcjami C obsługipamięci 8����! i ��� za pomocą zawinięcia ich we własne odpowiedniki: ��8����!i �����. Te dwie funkcje użyte w bibliotece glib skompilowanej z opcją >?������?8�8?������ dokonują pożytecznej charakterystyki pamięci. Wywołanie ��8�8������� drukujena konsoli potrzebną informację o wykorzystaniu pamięci przez program. Uściślając,��8�8������� podaje częstotliwość przydziału pamięci o różnych rozmiarach, całkowitąliczbę bajtów, które zostały zarezerwowane, całkowitą liczbę bajtów uwolnionych orazróżnicę pomiędzy tymi wartościami, czyli liczbę bajtów ciągle używanych. Wycieki pa-mięci stają się łatwe do spostrzeżenia.
W przeciwieństwie do(8����!, ��8����! rozsądnie obsłuży zlecenie przydziału o roz-miarze 0, zwracając wskaźnik �#%%. ��8����! natychmiast przerwie program, jeśli przy-dział się nie powiedzie, a to pozwoli na pominięcie sprawdzania obecności wskaźnika�#%%. Można to oceniać negatywnie, gdyż w razie niepowodzenia brakuje awaryjnej zmia-ny trybu pracy. W przeciwieństwie do ���, ����� zupełnie ignoruje wskaźniki �#%% doniej przekazane.
Ponieważ dwie funkcje przydzielające 8����! i ��8����! mogą używać oddzielnych obsza-rów pamięci, koniecznie trzeba używać ich parami: ����� z ��8����!, a ��� z 8����!.
�!��������91�����%� �������3�'"�� ��9����%�!�������1�1'
Funkcja( ��������! jest w glib wiernym odbiciem znanej funkcji ������! służącej dopowtórnego przydziału bufora z nowym rozmiarem. Podobnie jak ��8����!, ��������!zwraca wskaźnik �#%%, jeśli został przekazany bufor o zerowej długości. Funkcja��8�8�� kopiuje blok pamięci do świeżo przydzielonego bufora.
�!��������9�������%�!�������1�1��� �������3�'�!��������91�1 !%������!�������1�1��� �����4����3�'
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 285
Listy
Bardzo często chcemy przechowywać dane jako listę jedno- lub dwukierunkową. Bi-blioteka glib udostępnia wyśmienite sposoby implementacji obu rodzajów list w sposóbprzejrzysty i wydajny.
Struktura ����� listy dwukierunkowej (doubly-linked list) zawiera wskaźniki zarównodo poprzedniego (����), jak i następnego elementu (����):
M#�I� ��4����6� ������N������� 5 6��� �6�5��#M��� ���F����:���!������� ���<��F�����#��+�<��F�����#!��"<><
W odróżnieniu od listy jednokierunkowej (singly-linked list) �&%���, lista �%��� uaktyw-nia możliwość przeglądania zarówno w przód, jak i w tył.
M#������4����6� ������N�������2� ��6��� �6�5��#M��� ���F�����:���!������� ���<��F������#��+�<><
Warto zauważyć, że dane w obu rodzajach list są zachowane jako dane typu ��������,ale możemy bez problemu zachować liczby całkowite, korzystając z makrodefinicji ��� � .�0.�� �", �0.�� �"� .��� , �#�� � .�0.�� �" i �0.�� �"� .�#�� .
Aby utworzyć pustą listę jednokierunkową, wystarczy zainicjalizować wskaźnik �#%%:
F�����#�������9�����;�)���<
Podobnie jest utworzona lista dwukierunkowa:
F�����# � ���9�����;�)���<
Obie listy używają identycznego zestawu funkcji API, z tą tylko różnicą, że nazwy funkcjidla listy jednokierunkowej poprzedza litera „s”, co jest o tyle sensowne, że zbiór listjednokierunkowych jest podzbiorem zbioru list dwukierunkowych. Na przykład �������������� dodaje element do listy jednokierunkowej, podczas gdy ������������� dodajeelement do listy dwukierunkowej. Nie ma jednak odpowiednika polecenia �������������� dla listy jednokierunkowej.
W celu dodania elementów do listy używa się ��������������, pamiętając o uaktualnie-niu wskaźnika �&%��� wartością zwróconą, co ma znaczenie w przypadku zmianypoczątku listy.
F������#��9�����9�!!�� �%F������#�������!������� ���'<
286 Zaawansowane programowanie w systemie Linux
Na przykład napis i liczba całkowita dodane jako elementy do końca listy wyglądałyby tak:
F������#������9�����;�)���<������9�����;��9�����9�!!�� %������9������JC !�5�� O���31�?J'<������9�����;��9�����9�!!�� %������9������F-)�9�C90C-)����%��''<
Jeśli ta sama lista zawiera elementy różnego typu, trzeba zachować ostrożność w dalszejczęści kodu.
Aby dodać elementy do początku listy, używa się ���������������:
������9�����;��9�����9!��!�� %������9������J���!�2�5�����P����!��3Q�6 J'<
I wreszcie do uwolnienia listy wywołuje się �����������:
�9�����9����%������9����'<
Polecenie to zwalnia pamięć zajętą przez komórki listy, ale nie usuwa zawartości komó-rek. Jeśli zajdzie taka potrzeba, należy ręcznie usunąć zawartość listy, aby zapobiec wy-ciekom pamięci.
W celu odczytania zawartości jakiejś komórki trzeba bezpośrednio dotrzeć do właściwegoelementu danych w strukturze GSList:
�!������� ����;�������9����=8 ���<
Żeby przejść do następnej komórki w liście, wywołuje się ������������:
������9�����;��9�����9��+�%������9����'<
Rzecz jasna, można poruszać się do tyłu wzdłuż listy dwukierunkowej:
� ���9�����;��9����9!��"�� �% � ���9����'<
Często musimy dodać element w określonej pozycji listy. Może też pojawić się potrzebaprzechwycenia danych z określonej pozycji na liście. Do tego celu wykorzystuje się:
F������#��9�����9������%F������#�������!������� ����������!�������'�!��������9�����9���9 ���%F������#������� �����'
Bardzo przydatna jest również funkcja ����������8���, która usuwa element zawierają-cy dane ����:
F������#��9�����9��1�"�%F������#�������!������� ���'
Inne funkcje do przechwytywania danych z listy zwracają listę w miejscu określonymprzez podany element. Trzy niżej podane funkcje pozwalają określić element kolejno zapomocą jego zawartości, pozycji liczonej od początku lub też oczywistego faktu, że jestto ostatni element z listy:
F������#��9�����9��� %F������#�������!������� ���'F������#��9�����9���%F������#������� �����'F������#��9�����9����%F������#����'
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 287
GTK+
Zestaw narzędzi GIMP (GIMP ToolKit), GTK+ bierze swój początek w udostępnieniuinterfejsu użytkownika dla sztandarowego programu graficznego GNU (GNU Image Ma-nipulation Program, w skrócie GIMP). GTK+ od tego czasu rozrósł się i obecnie jest bo-gato wyposażonym, łatwym w użyciu, oszczędnym, niezależnym od pulpitu zestawem na-rzędzi. Nie ma też żadnych wymagań dotyczących istniejącego środowiska pulpitowego.Nie może oddziaływać z systemami menu pulpitu ani nie ma zdolności zapisu stanu po-między sesjami. Jest to całkowicie zamierzony wynik projektowania, który umożliwiaprzenoszenie zestawu narzędzi GTK+ między platformami systemowymi. Przykłady sys-temów, do których przeniesiono go z powodzeniem, to Windows, Solaris i BeOS.
GNOME opiera się na GTK+, dlatego znajomość jego działania jest warunkiem wstęp-nym dla tych, którzy zamierzają programować w GNOME. Zawartość tego podrozdziałujest zaledwie ułamkiem wiedzy na ten temat i, jak się okaże, klucz do zrozumieniaGNOME/GTK+ leży w przyswojeniu pojęć ogólnych, a nie w szczegółach związanychz poszczególnymi widżetami.
Widżety
Widżet (widget) to termin, którym określa się każdy element interfejsu użytkownika.Nazwa pochodzi z systemu X Window; została ona oryginalnie ukuta w projekcie MITAthena. Widżetami mogą być etykiety (labels), ramki (frames), pola wejściowe (entryboxes), okna (windows), przyciski (buttons) i wszystko to, co można wykorzystać jakoelement graficzny interfejsu. GTK+ jest obiektowo zorientowanym zestawem narzędzi,a wszystkie widżety w GTK+ są pochodnymi bazowej klasy ���@����� (ta z kolei jestpochodną obiektu bazowego ���.�=�!�). Jak wspomniano wcześniej, narzędzia GTK+są napisane w języku C i zawierają wszechstronny system obiektów i typów zawiadują-cy własnościami klas, dziedziczeniem, definiowaniem typów, przechowywaniem i od-zyskiem danych dotyczących dowolnego obiektu.
Typowy cykl życiowy widżetu zawiera pięć etapów:
Utworzenie widżetu
Widżet jest zazwyczaj tworzony za pomocą funkcji ���@�����()������31�1���������1,która zwraca wskaźnik typu ���@�����.
������;���69�����9��5%JH���2����5�34��4J'<
288 Zaawansowane programowanie w systemie Linux
Aby użyć ����� w funkcji specyficznej dla widżetu etykiety, takiej jak ������������������,należałoby użyć makrodefinicji rzutującej typ na � 7�%�,�%:
��69�����9���9��+�%F�G9��*��%�����'��JI��3����3����J'<
Pełny opis systemu obiektów i typów wraz z przykładami pomocnymi podczas pisaniawłasnych widżetów można znaleźć w GTK+/GNOME Application Development —szczegóły na końcu tego rozdziału.
Pojemniki
Pojemnik GTK+ to widżet, który może fizycznie zawierać inny widżet. ���A��������jest przykładem takiego widżetu, którego celem jest poszerzenie zestawu funkcji dlajego widżetów potomnych, co oznacza, że widżety wyprowadzone z ���A��������posiadają zdolność „zawierania” innych.
To właśnie z tej cechy GTK+ korzysta podczas rozmieszczania widżetów na ekra-nie. Zamiast rozmieszczać je w oknie przy użyciu ustalonego układu odniesienia, każdywidżet jest dodany do macierzystego pojemnika za pomocą funkcji:
"�� ���69���������9� %F�6/���������#�����������F�6H� ����#5� ���'
Pozycja i rozmiar widżetu na ekranie są określone przez właściwości pojemnika. Takiepodejście jest ogromnie elastyczne, dlatego rozmiary widżetów w oknie są odpowiedniodobrane, niezależnie od rozmiaru okna.
Patrząc na hierarchię obiektów powyżej, można zauważyć, że widżety okna ���@����1i przycisku ���,���� znajdują się wśród pochodnych widżetu ���A��������. Zatem, aby���@����1 zawierał widżet ���,����, a ���,���� zawierał ���%����, napiszemy:
F�6H� ����#5�� �5�;���695�� �59��5%F�G9H-)ICH9�C0��R��'<F�6H� ����#� �����;���69� ����9��5%'<F�6H� ����#������;���69�����9��5%JH���2����H�34��4J'<
��69���������9� %F�G9/C)��-)��%� ����'�������'<��69���������9� %F�G9/C)��-)��%5�� �5'��� ����'<
���@����1 i ���,���� są widżetami potomnymi ���,��, kolejną abstrakcyjną klasąwidżetów, która została zaprojektowana do przechowywania pojedynczego widżetupotomnego. Aby rozmieścić je w sposób bardziej złożony, używa się bezpośrednich klaspotomnych klasy ���A��������, które mogą zawierać wiele widżetów w dowolnymformacie spośród kilku dostępnych.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 289
Paczki (elementy zbiorcze)
Widżety o charakterze pojemników ����,�� i ����,�� w zajętej części okna tworząodpowiednio poziome (H) wiersze i pionowe (V) kolumny. Każdy z nich, będąc swoistąpaczką (packing box), może zawierać wszystkie zwykłe widżety, w tym także więcejpaczek. Jest to klucz do swobodnego rozmieszczenia widżetów w oknach. Pozwala napodział prostego okna na części składowe w sposób złożony, ale jasno określony. Względ-ny rozmiar i odstępy widżetów w paczce są nadzorowane przez właściwości widżetów���� i ����.
Odpowiednie funkcje tworzące obiekt wymagają podania dwóch ogólnych właściwości:jednorodności �8������� — ustalającej, czy widżetom potomnym przydziela się jed-nakową ilość miejsca, oraz odstępu ���!��� — odległości w pikselach pomiędzyprzylegającymi widżetami.
F�6H� ����#��69���+9��5%�����������1������ ���������!�����'F�6H� ����#��69"��+9��5%�����������1������ ���������!�����'
Właściwości odstępu poszczególnych widżetów są określone przez dodanie widżetu po-tomnego do ���� lub ����:
"�� ���69��+9!��69�����%F�6*�+�#��+��F�6H� ����#���� ������������+!�� ���������������������!� ���'
"�� ���69��+9!��69�� %F�6*�+�#��+��F�6H� ����#���� ������������+!�� ���������������������!� ���'
����������!������� doda widżet potomny u góry ����,�� lub z lewej strony ����,��,podczas gdy ����������!����� dodaje odpowiednio u dołu lub z prawej strony.
Pomiędzy paczką i widżetami potomnymi zachodzą dość złożone oddziaływania zmie-rzające do ustalenia wzajemnych odstępów. Trzy argumenty przekazane z chwilą doda-wania nowego widżetu potomnego wydają się łatwe do zrozumienia.
Argument Typ Opis
�+!�� �������� Jeśli ����, to widżet potomny powiększa się do zapełnienia dostępnego
miejsca; w przeciwnym razie pozostaje jego rozmiar domyślny.
���� �������� Jeśli ����, to widżet potomny powiększa się do zapełnienia
zarezerwowanego miejsca; w przeciwnym razie dodaje więcej
wypełnienia (padding) wokół siebie.
!� ��� ���� Odstęp w pikselach, który ma otaczać widżet potomny.
Dla jednorodnej paczki parametr ������ nie ma zastosowania.
Warto poeksperymentować z tymi właściwościami najlepiej za pomocą programu Glade,który omówimy pokrótce w następnym rozdziale.
290 Zaawansowane programowanie w systemie Linux
Tabele
W oknach dialogowych (dialog boxes) wykorzystuje się powszechnie wiersze widżetówetykiet i widżetów pola wprowadzania tekstu przez użytkownika. Metodą utworzenia takie-go rozmieszczenia byłoby zapakowanie każdej pary napis-pole wprowadzania w ����,��,a następnie upakowanie utworzonych wierszy w ����,��. Jednakże wyrównanie kolumnnapisów i pól wprowadzania okazuje się zajęciem raczej męczącym, chyba że wszystkienapisy mają tę samą długość.
Okazuje się, że w tym przypadku łatwiej użyć widżetu z klasy ��� ����. Jak sama nazwawskazuje, widżet z klasy ��� ���� składa się z tabeli rozmieszczenia (layout table)z komórkami podzielonymi na wiersze i kolumny, do których widżet może być dołączony.W razie potrzeby można widżety rozciągnąć na więcej niż jeden wiersz lub kolumnę.��� ���� wyrównuje rzędy i kolumny, podnosząc estetykę, nadaje także poszczególnymwidżetom umieszczanym w widżetach ����,�� i ����,�� podobną swobodę.
F�6H� ����#��69�����9��5%� ������5���� ������� 1���������������1������ �'
Pierwsze dwa argumenty w ������������1 podają początkową liczbę wierszy i kolumntabeli, choć i tak tabela powiększy się automatycznie, gdy jakiś widżet będzie dodanypoza bieżące granice wyznaczające tabelę. Jak w przypadku paczek �8������� określi,czy każda komórka tabeli będzie zajmować taki sam obszar.
Dodanie widżetu do tabeli wymaga wywołania funkcji ��������������! , której należypodać wiersz i kolumnę krawędzi bocznych, dwie opcje �������! .������ i wielkośćwypełnienia wokół widżetu.
F�6H� ����#���69�����9������%F�6������#�������F�6H� ����#���� ������������������������������� ��������9��� 1���� ���������9��� 1�������������������������������� ������!9��5������� ���������19��5������������������������������F�6������C!������+�!�����������������������������������F�6������C!������4�!������������������������������������ ����+!� ��������� ����4!� ���'
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 291
Pozycja każdego widżetu potomnego w tabeli jest określona liniami wierszy i kolumn,które tworzą ramkę brzegową widżetu. Na przykład w tabeli z 3 kolumnami i 2 wier-szami znajdują się 4 linie pionowe-kolumnowe (numerowane od 0 do 3) i 3 linie pozio-me-wierszowe (numerowane od 0 do 2).
Aby umieścić widżet potomny w pokazanej pozycji, ustawilibyśmy wartość ����!��8�na 1, ��� ��!��8� na 3, a ������1 i �����8���1 odpowiednio na 1 i 2.
Argumenty �������! .������ pobierają jedną lub więcej spośród trzech wyszczególnio-nych poniżej wartości w celu uzupełnienia informacji o położeniu widżetu w obrębietabeli. Te wartości to maski bitowe. Tak więc aby określić dwie lub więcej jednocze-śnie, trzeba użyć alternatywy bitowej .": na przykład � 7��B0��/C� 7�$�%%.
GtkAttachOptions Opis
F�G9�.0�)I Ta sekcja tabeli rozszerza się do zapełnienia dostępnej przestrzeni.
F�G9�-�� Widżet potomny rozszerzy się do zapełnienia przestrzeni zarezerwowanej,
jeśli jest użyty wraz z F�G9�.0�)I; bez F�G9�.0�)I nie wywołuje żadnego efektu.
F�G9�S�-)G Jeśli nie ma wystarczająco dużo miejsca dla widżetu potomnego i opcja
F�G9�S�-)G jest ustawiona, to tabela wymusi zmniejszenie się tego widżetu
potomnego; jeśli nie jest ustawiona, widżet potomny otrzyma swoje żądane
rozmiary, ale może to spowodować obcięcie na brzegach.
Moglibyśmy napisać:
�������;���69�����9��5%����������'<�������;���69�����9��5%J��46�����T� ��J'<�������;���69�����9��5%J��46�����I5�J'<
��69�����9������%F�G9��*��%�����'��������������&���������&���������F�G9�-��������F�G9�-��������&������&'<
292 Zaawansowane programowanie w systemie Linux
��69�����9������%F�G9��*��%�����'��������������&�������������������F�G9�-���U�F�G9�.0�)I�U�F�G9�S�-)G������F�G9�-���U�F�G9�.0�)I�U�F�G9�S�-)G������&������&'<
i dodać samą tabelę ����� do jakiegoś pojemnika.
Ręczne pisanie kodu rozmieszczenia jest niewątpliwie zajęciem żmudnym i nużącym,zwłaszcza dla okien złożonych. W celu zaprojektowania interfejsu należy rozważyćużycie konstruktora interfejsów użytkownika (takiego jak Glade). Nie tylko otrzyma siędokładnie to, co widać (WYSIWYG, What You See Is What You Get), ale też zyskuje sięwięcej możliwości, takich jak choćby możliwość dynamicznego ładowania wzorów GUI(GUI designs).
Sygnały
Generowanie odpowiedzi na działania użytkownika stanowi integralną część progra-mowania GUI. Kiedy dzieje się coś ciekawego, np. użytkownik klika widżet lub wpisujecoś do pola wprowadzania tekstu, wtedy widżet ten wyemituje w odpowiedzi sygnał(jak już wspomniano wyżej, sygnały w GTK+ są całkowicie różne od sygnałów UNIX-aniskiego poziomu). Każdy widżet potrafi emitować sygnały charakterystyczne dla swo-jego typu oraz wszystkie sygnały charakterystyczne dla widżetów nadrzędnych wobecniego w hierarchii.
Sygnały identyfikujemy przez podanie ich nazwy w postaci napisu. Na przykład, kiedykliknie się przycisk ���,����, wtedy emituje on sygnał <!��!���< („kliknięty”). Abyzareagować na ten sygnał, kojarzymy z nim funkcję zwrotną (callback function), którabędzie wykonana z chwilą wyemitowania tego sygnału:
������ �;���69������9�������%F�G9C*T�/�%� ����'������������������������������J����6� J������������������������������F�G9�-F)��9��)/%� ����9����6� 9�������6'������������������������������)���'<
Tutaj �����������!����!� łączy funkcję ������!��!����!�����!� z sygnałem <!��!���<wyemitowanym przez przycisk �����. Istnieje opcja przekazania dowolnych danychużytkownika jako czwartego parametru w postaci ��������. W powyższym przykładzienie skorzystaliśmy z tej opcji i przekazaliśmy wskaźnik �#%% zamiast tej zmiennej. Funk-cja �����������!����!� zwraca unikatowy identyfikator (ID) skojarzenia sygnałowego.Jest on rzadko używany, ale okazuje się niezbędny do odłączenia sygnału od funkcji.
Pierwowzór typowej funkcji zwrotnej wygląda następująco:
"�� �� ����9����69�������6%�F�6* �����#� �������!������� ���'<
Niektóre sygnały wymagają nieco innej postaci funkcji zwrotnej, co zobaczymy dalej przyoknach dialogowych GNOME. Zawsze jako pierwszy argument przekazywany jestwskaźnik do widżetu emitującego sygnał.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 293
Aby odłączyć sygnał, trzeba przekazać obiekt ���.�=�!� oraz identyfikator (ID) połączenia:
��69������9 ���������%F�G9C*T�/�%� ����'��� '<
Ukazanie, aktywność i ukrycie
Pojedynczy widżet pojawi się na ekranie po jego wywołaniu przez ����1������� �1 dlakażdego z nich. Wygodniej wywołać ����1������� �1���� dla widżetu najwyższegopoziomu, co spowoduje rekurencyjne pokazanie wszystkich jego potomnych:
"�� ���695� ���9���5%F�6H� ����#5� ���'"�� ���695� ���9���59���%F�6H� ����#5� ���'
W celu zdezaktywowania widżetu, co przejawia się w pocieniowanym (shaded) czy po-szarzałym (gray out, czyli widżet zrobiony na szaro) jego wyglądzie, należy zgodniez terminologią GTK ustawić aktywność (sensitivity) na $�%&�. Aktywność można włą-czyć lub wyłączyć, wywołując następującą funkcję:
"�� ���695� ���9���9�������"�%F�6H� ����#5� ���������������������'
Widżet może być również czasowo ukryty za pomocą wywołania funkcji ����1������ ���:
"�� ���695� ���9�� �%F�6H� ����#5� ���'
Zniszczenie
Zniszczenie niepotrzebnych już widżetów minimalizuje zużycie pamięci:
"�� ���695� ���9 �����4%F�6H� ����#5� ���'
gtk_init i gtk_main
Inicjalizacja programów GTK+ następuje wskutek pojedynczego wywołania funkcji ��������, które łączy się z serwerem X i analizuje specyficzne opcje GTK+ podane w wier-szu polecenia. Przekazanie ���! i ���� powoduje usunięcie przez �������� rozpozna-nych opcji z ���� i zmniejszenie odpowiednio liczby ���!:
��69����%V������V���"'<
Po utworzeniu i rozplanowaniu okna podstawowego typowa aplikacja GTK+ przekazujesterowanie do pętli obsługi zdarzeń przez wywołanie funkcji ����8���, nieprzyjmującejżadnych argumentów. Podczas działania funkcji ����8��� program oddziaływuje z użyt-kownikiem jedynie za pośrednictwem sygnałów i funkcji wywołania zwrotnego dla zda-rzeń, aż do chwili wywołania funkcji ����8����D��:
��691���9W ��%'<
Przykładowa aplikacja GTK+
Poniżej przedstawiona jest bardzo prosta aplikacja wykorzystująca omówione dotych-czas zasady:
294 Zaawansowane programowanie w systemie Linux
M#�#���������5��� ��!!��������� �����F�GX�#M
$���� ��7��6M��6@�8
�������"�� ��9� ����9����6� %F�6H� ����#� �������!������� ���':���9!����%J����� �����5�������6� �=�S�����H��� (Y�J'<>
�������������9 �����9�"���%F�6H� ����#5�� �5��F 6�"�����4�#�"������!������� ���':����691���9W ��%'<����� ��������<>
����1���%�����������������#���"Z[':��F�6H� ����#5�� �5<��F�6H� ����#"��+<��F�6H� ����#�����<��F�6H� ����#� ����<
����69����%V������V���"'<
��5�� �5�;���695�� �59��5%F�G9H-)ICH9�C0��R��'<��"��+�;���69"��+9��5%�������&'<��������;���69�����9��5%J��������������!���� ����������������R*�+J'<��� �����;���69� ����9��595���9�����%J/���6�,�(J'<
����69��+9!��69�����%F�G9*C.%"��+'�����������������������&'<����69��+9!��69�����%F�G9*C.%"��+'��� ��������������������&'<����69���������9� %F�G9/C)��-)��%5�� �5'��"��+'<
����695�� �59���9�����%F�G9H-)ICH%5�� �5'��J���������J'<
����69������9�������%F�G9C*T�/�%5�� �5'��J �����9�"���J����������������F�G9�-F)��9��)/%��9 �����9�"���'����������������)���'<
����69������9�������%F�G9C*T�/�%� ����'��J����6� J����������������F�G9�-F)��9��)/%��9� ����9����6� '����������������)���'<
����695� ���9���59���%5�� �5'<
����691���%'<
����� ���&<
>
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 295
Plik 6������ dla aplikacji ����!���������! wygląda następująco:
//;���
���?������9��69�!!@������E%//'�\��6=�������==�����N������\�=�������9��69�!!������9��69�!!@�
Podstawy GNOME
W tym podrozdziale omówimy niektóre ważne aspekty GNOME i programowaniaw GNOME, uwzględniając:
� widżety GNOME,
� budowę struktur menu i pasków narzędziowych za pomocą GNOME,
� okna dialogowe w GNOME.
Jak wspominaliśmy we wstępie do tego rozdziału, GNOME korzysta z GTK+ na dwasposoby. Pierwszy polega na dodawaniu widżetów, rozszerzających zestaw możliwościistniejących już widżetów GTK+ — na przykład ���8������E jest ulepszonym ��������E.Sposób drugi to zamiana podprogramów GTK+, służących do budowania różnych menu,pasków narzędziowych i okien dialogowych, na zestaw nowych funkcji, które są nietylko skuteczniejsze, ale i łatwiejsze w użyciu.
Wszystkie pliki nagłówkowe GNOME, GTK+, GDK itd. są włączane dyrektywą F��!���:
$���� ��7���1�@�8
gnome_init
Ta funkcja jest analogiczna do �������� — aplikacja musi przekazać krótką wersję swojejnazwy i numeru wersji (wraz ze zwykłymi parametrami z wiersza poleceń) do ���8������ w celu równoczesnej inicjacji GNOME i GTK+. W programach GNOME nie trze-ba więc wywoływać ��������. Funkcja ta w przyszłości powinna zwracać wartość nie-zerową, jeśli wywołanie skończy się niepowodzeniem. Bieżące wersje GNOME w razieniepowodzenia przerywają działanie.
��������1�9����%�����������#�!!9� �������������#�!!9"�����������������������������������������������������������##���"'
Funkcja(���8������ nie zmieni ���! i ���� w sposób właściwy dla ��������. Analizaskładniowa wiersza poleceń w aplikacjach GNOME powinna być przeprowadzonaprzy użyciu ���8�������1�� �����������.
Biblioteka popt jest wyspecjalizowaną biblioteką analizy składniowej wiersza poleceń,którą omówimy nieco później.
296 Zaawansowane programowanie w systemie Linux
GnomeApp
Prawie wszystkie aplikacje GNOME wykorzystują widżet ���8���� dla swojego głównegookna. ���8���� jest podklasą ���@����1 i umożliwia tworzenie prostego menu, paskanarzędziowego i paska stanu. Najwspanialsze jest to, że ���8����, bez żadnych dodatko-wych nakładów, zapewnia aplikacjom mnóstwo dodatkowych funkcji i możliwości.
� Menu i paski narzędziowe mogą być odłączone i zadokowane w poziomeji pionowej pozycji na widżecie ���8����. GNOME automatycznie zapisujekonfigurację dokowania pomiędzy sesjami.
� Użytkownicy mogą konfigurować ustawienia globalne określające właściwościmenu i pasków narzędziowych.
Do utworzenia widżetu ���8���� potrzebne jest: wywołanie do ���8��������1, przekazanie������, identycznego jak dla funkcji ���8������ i napis do umieszczenia w tytule okna.
F�6H� ����#���1�9�!!9��5%������#�!!9� ��������#�����'
Dodanie menu, paska narzędziowego i paska stanu do już istniejącego widżetu ���8����jest jedynie kwestią ustawienia struktur żądanego menu i paska narzędziowego, utwo-rzenia paska stanu, a następnie wywołania:
"�� ����1�9�!!9���91�� �%F��1��!!�#�!!��F�6,�� *���#1�� ���'"�� ����1�9�!!9���9�������%F��1��!!�#�!!��F�6��������#�������'"�� ����1�9�!!9���9���� ����%F��1��!!�#�!!��F�6H� ����#���� ����'
Menu i paski narzędziowe
Tworzenie menu i pasków narzędziowych w GNOME polega na zdefiniowaniu każdegoelementu menu czy też paska narzędziowego przy użyciu struktury ���8�#����:
�4!� ������ ���:�F��1��--�����4!�<�������#������<�������#�����<���!�������1�������<���!������� ���9 ���<���!������� � �� 9 ���<��F��1��-0�+1�!�4!��!�+1�!9�4!�<���!�������!�+1�!9����<��� ���������������96�4��F 6,� �������4!����91� �<��F�6H� ���#�5� ���<>�F��1��-���<
W rzeczywistości rzadko pojawia się potrzeba samodzielnego wypełnienia parametrówtej struktury, bo GNOME posiada liczne wstępnie zdefiniowane struktury ���8�#����.Mimo to warto zapoznać się z jego wnętrzem.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 297
� �E�� jest znacznikiem (marker) odnoszącym się do jednegoz wyszczególnionych poniżej typów ���8�#���� E��. Jego wartość określainterpretację czwartego parametru, 8������, w sposób wymieniony poniżej.
type moreinfo interpretowane jako Opis
F)C,�9�009�-9-��, funkcja wywołania zwrotnego
(callback)
standardowy element menu
oraz paska narzędziowego
F)C,�9�009�-9�CFF��9-��, funkcja wywołania zwrotnego element do przełączania (toggle)
lub zaznaczania (check)
F)C,�9�009�-9��I-C-��,� tablica pól wyboru (tzw.
„przycisków radiowych”
— radio items) w grupie
grupa „przycisków radiowych”
F)C,�9�009�-9��*���� tablica F��1��--��� tworząca
drzewo podrzędne (subtree)
menu podrzędne (submenu)
F)C,�9�009�-9��0����C� )��� separator pomiędzy elementami
F)C,�9�009�-9S��0 strona pomocy do załadowania element Pomocy
F)C,�9�009�-9�)IC�-)�C )��� zakończenie tablicy F��1��--���
� ����� (etykieta) zawiera tekst elementu menu lub paska narzędziowego.
� ��� (wskazówka) wskazuje na dodatkowy opis. W przypadku przyciskuwskazówka będzie wyświetlona jako etykietka narzędzia (tooltip), a dlaelementu menu może pojawić się w pasku stanu. Etykietki narzędzi mogą byćdowolnie długie, aby wyczerpująco opisać funkcję elementu. W każdym razienie wolno ograniczyć się tylko do powtórzenia tekstu z �����.
� 8������ jest zależne od typu �E��, jak pokazano powyżej. Jeśli zawiera funkcjęwywołania zwrotnego, to wtedy następny parametr ...
� ...�������� jest przekazany do funkcji wywołania zwrotnego.
� ��������� jest zarezerwowane do wykorzystania w przeszłości i powinnobyć ustawione na �#%%.
� ���8����E�� i ���8������ określają obrazek — bitmapę (pixmap), któryma zostać użyty w elemencie menu lub paska narzędziowego. Interpretacja���8������ jest uzależniona od ���8����E��.
� �!!�����������E i �!�8��� definiują skróty klawiaturowe, które znajdujązastosowanie dla danego elementu. Pierwszy z tych parametrów może byćznakiem, takim jak G�G, lub wartością wziętą z ���H�����E�8�� . Drugi z tychparametrów jest maską (podobnie jak �/7�A.� ".%�6�&7*, nadzorującąklawisze modyfikujące lub ich kombinacje, które mogą być użyte z tym skrótem.
298 Zaawansowane programowanie w systemie Linux
pixmap_type pixmap_info interpretowane jako Znaczenie
F)C,�9�0090-.,�09��C/G Nazwa bitmapy dostarczonej
przez GNOME.
Użyj bitmapy dostarczonej
przez GNOME.
F)C,�9�0090-.,�09I��� Wskaźnik do F 60�+1�!. Użyj bitmapy specyficznej
dla aplikacji.
F)C,�9�0090-.,�09�-��)�,� Nazwa pliku z bitmapą. Użyj bitmapy znalezionej
pod nazwą pliku ������1�.
F)C,�9�0090-.,�09)C)� )��� Brak bitpamy.
� 1����� powinien być pozostawiony jako �#%%. Przy przekazaniu ���8�#����do ���8������!������8��� GNOME wypełni 1����� wskaźnikiem do faktycznegowidżetu dla tego elementu menu czy też paska narzędziowego. Wskaźnik tenjest użyty do określenia elementu menu lub paska narzędziowego w trakciewykonywania programu. Powszechnym przykładem użycia byłoby „przerobieniena szaro” elementu przez przekazanie widżetu do funkcji GTK+ ����1�������������������.
Oto konkretny przykład wpisu dla elementu Undo (Cofnij):
F��1��--���� � ��;�:F)C,�9�009�-9-��,���������������������)9%J9�� �J'���������������������)9%J�� �����������������J'�����������������������9 � �9����6� ���������������������)������������������������F)C,�9�0090-.,�09I������������������������ � �9!�+1�!����������������������B3B���������������������FIG9/C)��C�9,��G><
Makrodefinicja N_ otaczająca napisy wyprowadzane na ekran ułatwia
umiędzynarodowienie (przekład na inne języki); temat ten zostanie
omówiony w rozdziale 28.
Menu i paski narzędziowe budujemy z tablic struktur ���8�#����, a potem następujewywołanie odpowiednio do ���8������!������8��� lub też do ���8������!�������������.
"�� ����1�9�!!9������91�� �%F��1��!!�#�!!��F��1��--����# �����'"�� ����1�9�!!9������9�������%F��1��!!�#�!!��F��1��--����# �����'
Mimo że struktury ���8�#���� zapewniają pełną kontrolę nad definicjami menu i paskanarzędzi, to jednak nie zawsze jest to potrzebne czy nawet pożądane. Wiele aplikacji GUIprzyjmuje menu najwyższego poziomu w stylu File (Plik), Edit (Edycja), View (Widok),Help (Pomoc), a większość tych, które nie przyjmują, powinny. Wewnątrz menu naj-wyższego poziomu jest jeszcze więcej konwencji, określających położenie i kolejnośćelementów menu. Na przykład New (Nowy), Open (Otwórz) i Exit (Zakończ) są zgodniez konwencją umieszczane jako pierwszy, drugi i ostatni element menu File (Plik).
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 299
Mając na uwadze standaryzację, GNOME udostępnia cały zbiór makrodefinicji, któredefiniują struktury ���8�#���� dla powszechnie używanych elementów menu. Mogąone wstawić etykietę, etykietkę narzędzia, bitmapę lub klawisz skrótu. Standardowy wy-strój menu jest zatem bardzo łatwy i szybki do zdefiniowania.
Każde menu najwyższego poziomu na pasku menu składa się z tablicy struktur ���8�?#����, a pełne jego drzewo tworzą definicje menu w połączeniu ze wskaźnikami dotych tablic, włączanymi za pomocą makrodefinicji ��.6�#���$.�&#, "��. Definicje temożna znaleźć w ������8��H���8�?���? ���� .
GnomeAppbar
Widżet ���8���� może opcjonalnie zawierać pasek stanu. Jest to taki pasek, jakie częstosą ułożone wzdłuż dolnej krawędzi okna i przekazują informację o stanie, w jakim znaj-duje się aplikacja. ���8����� może zawierać także pasek postępu (progress bar) poka-zujący graficznie postęp czasochłonnej operacji. Na przykład Netscape używa swojegopaska postępu dla oszacowania na bieżąco załadowanego już procentu strony WWWczy poczty elektronicznej, które są właśnie w trakcie odbierania z sieci.
Tworząc ���8�������, używa się zmiennych logicznych (boole’owskich) do określenia,czy pasek składa się z paska stanu, paska postępu czy też ich obu. Na implementacjęczeka jeszcze ������!�����E (interakcja), która w przyszłych wersjach GNOME powin-na umożliwić lepsze oddziaływanie z użytkownikiem. Do czasu opracowania tej funkcjizalecane ustawienie to ��.6��0"�$�"��A�&�#&�".
F�6H� ����#���1�9�!!���9��5%������������9!������������������������������������������������9���� ������������������������������F��1�0�����������4!�����������"��4'
W ten sposób tworzy się widżet ���8�������. Aby dodać go do okna ���8����, posłu-żymy się funkcją:
"�� ����1�9�!!9���9���� ����%F��1��!!�#�!!��F�6H� ����#���� ����'
Tekst w pasku stanu jest traktowany na zasadzie stosu. Dodanie tekstu oznacza umiesz-czenie go na stosie za pomocą:
"�� ����1�9�!!���9! ��%F��1��!!*����!!�����������������#��+�'
Tekst umieszczony na wierzchołku stosu pozostaje widoczny do momentu, kiedy nowytekst umieścimy na wierzchołku stosu albo kiedy wierzch stosu zostanie usunięty po-przez wywołanie ���8������������. W tym drugim przypadku zobaczymy tekst umiesz-czony na stosie o jedną warstwę niżej.
"�� ����1�9�!!���9!�!%F��1��!!*���#�!!�����������������#���� �'
Gdyby okazało się, że stos będzie pusty, to wtedy zostanie pokazany tekst domyślny —jest to zwykle pusty napis. Można zmienić ten napis przy użyciu:
"�� ����1�9�!!���9���9 ��� ��%F��1��!!*���#�!!�����������������# ��� ��9��+�'
300 Zaawansowane programowanie w systemie Linux
Cały stos może być szybko i łatwo oczyszczony za pomocą funkcji ���8���������!��������!�. Mimo że stos umożliwia różnym częściom aplikacji jednoczesne używanie paskastanu bez ryzyka interferencji pomiędzy nimi, często pojawia się potrzeba pokazania je-dynie tymczasowej informacji bez uciekania się do pomocy stosu. Używając ���8�����?�������������, można dodać tekst przejściowy, który pozostaje widoczny do chwilidodania nowego tekstu albo uzupełnienia, opróżnienia, wyczyszczenia czy odświeżeniastosu przez wywołanie ���8�������������� .
"�� ����1�9�!!���9�����9����6%F��1��!!*���#�!!���'"�� ����1�9�!!���9���9���� �%F��1��!!*���#�!!�����������������#���� �'"�� ����1�9�!!���9�������%F��1��!!*���#�!!���'
W czasie kiedy wskaźnik myszy zaznacza elementy menu, GNOME pozwala pokazaćetykietkę narzędzia dla menu na pasku stanu kosztem jednego wywołania:
"�� ����1�9�!!9�������91�� 9�����%F��1��!!�#�!!��F��1��--����# �����'
Struktura ���8�#���� musiała być uprzednio utworzona przy użyciu wywołania do jed-nej z funkcji tworzenia menu, tak aby pole 1�����u zostało zapełnione.
Pasek postępu
Pasek postępu składa się z widżetu ���0�������. Zakładając, że ���8����,�� zostałutworzony z opcjonalnym paskiem postępu, wskaźnik do ���0������� może być zwró-cony wraz z
F�60��������#���1�9�!!���9���9!�������%F��1��#�!!���'
Wreszcie, co najważniejsze, można do widżetu ���8���� dodać zawartość za pomocą
"�� ����1�9�!!9���9��������%F��1��!!�#�!!��F�6H� ����#��������'
Jest to równoważne z użyciem ����!������������ z konwencjonalnym ����1����1.
Okna dialogowe
Okna dialogowe stanowią zasadniczą część każdej aplikacji GUI. Pozwalają użytkownikowina wybór lub wprowadzenie danych, jak również przekazują mu komunikaty o błędach,komunikaty ogólne czy teksty pomocy. W typowej aplikacji jest więcej okien dialogo-wych niż okien głównych. Tak więc prostota programowania dialogów jest zasadniczymwymogiem stawianym przed nowoczesnym zestawem narzędzi.
Okna dialogowe mają pewne cechy odróżniające je od zwykłych okien.
� Mają zawsze jeden lub więcej przycisków, które sygnalizują aplikacjiwywołanie lub anulowanie operacji dialogu.
� Nie mają zakładki minimalizującej na ramce dekoracyjnej okna.
� Opcjonalnie dialogi mogą być modalne, to znaczy zapobiegają dalszemuużyciu aplikacji aż do chwili zakończenia dialogu.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 301
Mając na uwadze te cechy wyróżniające, GNOME implementuje dialogi, rozszerzając���@����1 do klasy podstawowej ���8�/�����. To stwarza gotowy szablon dialogu wrazz różnorodnymi funkcjami. Zatem kreowanie dialogów za pomocą GNOME jest całko-wicie „ucywilizowaną” czynnością.
Jednakże historia nie kończy się na ���8�/�����. Istnieją jeszcze przecież trzy specjalnetypy dialogów:
� ���8�����,
� ���8�0������E,��,
� ���8�6������,��.
Dzięki nim tworzenie powszechnie stosowanych okien dialogowych jest dla pewnychcelów szybsze i łatwiejsze. Co więcej, jako pochodne widżetu ���8�/�����, współdzieląjego możliwości i pomagają utrzymać spójność aplikacji GNOME.
Tworzenie widżetu GnomeDialog
Aby utworzyć widżet ���8�/�����, należy wywołać ���8�����������1 i przekazać jakoargumenty tytuł okna oraz listę przycisków zakończoną wartością �#%% (do umieszcze-nia wewnątrz okna dialogowego).
F�6H� ����#���1�9 �����9��5%������������#�������@@@'
Lista przycisków jest listą napisów używanych jako etykiety przycisków. Zamiast prze-kazywać prosty napis, znacznie lepszym sposobem jest użycie makrodefinicji GNOMEdla powszechnie stosowanych przycisków. Podobnie jak w przypadku makrodefinicjidla menu i pasków narzędziowych, makrodefinicja GNOME dostarcza bitmap w celuujednolicenia interfejsu graficznego.
Lista makrodefinicji jest zawarta w ������8��H���8�?���!�� i obejmuje:
� ��.6��& .A7�,# .��.7,
� ��.6��& .A7�,# .��A��A�%,
302 Zaawansowane programowanie w systemie Linux
� ��.6��& .A7�,# .��-�&,
� ��.6��& .A7�,# .���.,
� ��.6��& .A7�,# .��A%.&�,
� ��.6��& .A7�,# .���00%-,
� ��.6��& .A7�,# .����%0,
� ��.6��& .A7�,# .����B ,
� ��.6��& .A7�,# .��0"��,
� ��.6��& .A7�,# .��#0,
� ��.6��& .A7�,# .��/.@�,
� ��.6��& .A7�,# .��$.� .
Te makrodefinicje są równoważne z prostymi napisami. Tak więc, jeśli tworzymy
przycisk z jednym z tych napisów, to prawdopodobnie otrzymamy i ikonę, i tekst.
Utworzenie prostego dialogu z przyciskami OK i Cancel (Anuluj) mogłoby wyglądaćnastępująco:
F�6H� ����# ������;����1�9 �����9��5%�������������������������9%JF��1�I������3�!�34���6�1��C6���/�����J'��������������������������F)C,�9��C/G9*���C)9CG��������������������������F)C,�9��C/G9*���C)9/�)/����������������������������)���'<
Przyciski wypełniają dialog od lewej do prawej. Przydzielane są im numery, począwszyod 0, co oznacza przycisk położony najbardziej z lewej.
Widżety ���8�/����� są automatycznie tworzone za pomocą widżetu ����,�� w głównejczęści okna i dostępne jako element ���� struktury ������. Dodanie widżetów do nowoutworzonego widżetu ���8�/����� jest jedynie kwestią ich upakowania w ����,��:
F�6H� ����#������;���69�����9��5%9%J�����46�����2����5��6���� ����� J''<
��69��+9!��69�����%F�G9*C.%F)C,�9I-��CF% �����'=8"��+''���������������������&'<
Pokazywanie widżetu GnomeDialog
Utworzony i wypełniony dialog trzeba uaktywnić, pokazując go na ekranie. Mechani-zmy wyświetlania dialogu i oczekiwania na odpowiedź użytkownika są bardzo różne dladialogów modalnych i niemodalnych. Powinno się zatem ustawić modalność dialoguprzed jego pokazaniem, wywołując ����1����1�����8����. Domyślnie okna i dialogi niesą modalne.
��695�� �59���91� ��%F�6H�� �5�#5�� �5�����������1� ����4'
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 303
Dialogi niemodalne
Dialogi niemodalne są typem, który nie ogranicza użycia innych okien. Ponieważ umożli-wiają one normalne działanie reszty aplikacji, trzeba do widżetu ���8�/����� dołączyćfunkcje zwrotne, które poinformują o kliknięciu przycisku lub zamknięciu dialogu. Gdyniemodalny widżet ���8�/����� zostanie utworzony i wypełniony, można użyć w zwy-kły sposób ����1������� �1, aby wyświetlić dialog na ekranie.
��695� ���9���5% �����'<
Najlepiej użyć własnych sygnałów widżetu ���8�/�����, zamiast łączyć obsługę z poszcze-gólnymi przyciskami. Poza sygnałami dostarczonymi przez widżety nadrzędne widżet���8�/����� emituje dodatkowo dwa sygnały: "clicked" (kliknięto) i "close" (zamknięto).To właśnie te sygnały należy przyłączyć dla zapewnienia dialogowi pełnych możliwości.
� Sygnał "clicked" jest emitowany, kiedy kliknięto przycisk dialogu. Funkcjawywołania zwrotnego połączona do "clicked" otrzymuje trzy argumenty:wskaźnik do dialogu, numer klikniętego przycisku i dane użytkownika. Uświadomićsobie należy, że sygnał widżetu ���8�/����� "clicked" jest różny od sygnału"clicked" emitowanego przez same przyciski.
� Sygnał "close" jest emitowany z funkcji ���8���������!����. Ma domyślnąobsługę dostarczoną przez GNOME. Domyślnie niszczy ona dialog, wywołując����1������������E, chyba że funkcja ���8��������!����� ���� jest wywołanaz argumentem ������� określonym jako "#�.
"�� ����1�9 �����9�����9�� ��%F��1�I������# �����������������������'
W tym przypadku obsługa "close" ukryje dialog za pomocą ����������� ���. To oznacza,że nie trzeba będzie ponownie go tworzyć, gdy pojawi się potrzeba ponownego pokazaniatego dialogu. Jest to świetne rozwiązanie dla skomplikowanych dialogów lub w takichsytuacjach, w których trzeba zachować stan widżetu w dialogu pomiędzy operacjamidialogowymi.
Można również skojarzyć "close" z własną obsługą — funkcja obsługi mogłaby umie-ścić komunikat w rodzaju „Czy jesteś pewien?”, a wartość zwrócona przez nią przekażedo GNOME informację, czy wykonać jakieś domyślne działanie.
Wygodnie byłoby otrzymywać sygnał "close" przy kliknięciu przycisku, bo zapobiegłobyto konieczności ręcznego niszczenia lub ukrycia samego dialogu. Aby widżet ���8�/�����emitował zarówno sygnał "close", jak i "clicked" przy kliknięciu przycisku, należy przeka-zać funkcji ���8�������������!���� wartość "#�.
"�� ����1�9 �����9���9�����%F��1�I������# �����������������������'
Dialogi modalne
Dialogi modalne zapobiegają interakcji użytkownika z innymi oknami aż do chwili zakoń-czenia dialogu. Użycie dialogu modalnego jest nieuniknione, kiedy np. trzeba zapobiecdokonywaniu przez użytkownika zmian krytycznych ustawień w czasie trwania dialogulub też by skłonić użytkownika do podjęcia natychmiastowej decyzji. Ponieważ reszta
304 Zaawansowane programowanie w systemie Linux
aplikacji jest zamrożona w czasie pokazywania dialogu, można spowodować, aby, beznaruszenia zestawu funkcji reszty aplikacji, kod czekał na dane wprowadzone przezużytkownika. Innymi słowy, nie trzeba używać wywołań zwrotnych, ponieważ dialogjest wyświetlany i czeka na pojawienie się jakiegoś zdarzenia.
Z tego powodu tworzenie dialogów modalnych jest znacznie prostsze niż kreowanie ichodpowiedników niemodalnych. Dlatego też dialogi modalne są bardzo lubiane przezprogramistów i wykorzystywane nawet w takich sytuacjach, w których dialog niemodalnybyłby bardziej odpowiedni. Do opracowania dialogu modalnego należy, jak zwykle, utwo-rzyć i pokazać dialog ���8�/����� oraz wywołać albo ���8�����������, albo ���8�����?�����������!����. Obie funkcje pokazują ���8�/����� i zwracają numer wciśniętego przy-cisku (lub ?�, jeśli dialog został zamknięty przez menedżera okien). Wariant �������!����niszczy dialog podczas zwrotu, jeśli nie został unicestwiony zwykłymi środkami.
��������1�9 �����9� �%F��1�I������# �����'��������1�9 �����9� �9���9�����%F��1�I������# �����'
Te wywołania tworzą automatycznie dialog modalny — nie trzeba na wstępie używaćdo tego celu ����1����1�����8����. Musimy pamiętać, że przyciski są numerowane,począwszy od 0, w kolejności nadanej im przez ���8�����������1:
F�6H� ����# �����<�������� ��<
�� ������;����1�9 �����9��5%�9%J/34���!��5 �������3�3�6���34�]J'����������������������F)C,�9��C/G9*���C)9^������������������������F)C,�9��C/G9*���C)9)C����������������������)����'<
����695� ���9���5% �����'<����� ���;����1�9 �����9� �9�� 9������%�F)C,�9I-��CF�% �����'�'<���5�����%��� ��'�����:�����������&?��9!����%JG��6������^��Y�J'<����������6<������������?��9!����%JG��6������)�Y�J'<����������6<������ ��� ��?��9!����%J_�16������ �����Y�J'<�����>
GnomeAbout
Przy okazji omawiania widżetu ���8�/����� zauważyliśmy, że ma on trzy widżety potomne,które zapewniają dalszą specjalizację. Pierwszym z nich jest ���8�����, szablon wszędo-bylskiego dialogu About, który podaje informację o wersji aplikacji, autorach, prawachautorskich i inne komentarze. Aby zrobić większe wrażenie, można dodać nawet logo!
F�6H� �������1�9��� �9��5%������������#��������������������������������������������#"���������������������������������������������#��!4��������������������������������������������##� ��������������������������������������������#��11�������������������������������������������#����'
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 305
Jedynym obowiązkowym polem jest tablica napisów(�� ���. Widżet ���8����� zawieraprzycisk OK, który po wciśnięciu niszczy dialog.
Dialog ���8����� powinien być ustawiony tak, by pojawił się, kiedy element Aboutw menu Help został kliknięty.
GnomePropertyBox
Widżet ���8�0������E,�� jest ważniejszym rozszerzeniem ���8�/����� niż ���8�����.Jak sama nazwa sugeruje, jest to szablon okna dialogowego dla funkcji Properties (Wła-ściwości) lub Preferences (Ustawienia). Zawiera widżet ���������� (w celu umożliwie-nia podziału Preferences na strony) oraz cztery przyciski: OK, Apply, Cancel i Help.
Widżet( ���8�0������E,�� pomaga w kodowaniu dialogu, emitując sygnały "apply"(zastosuj) i "help" (pomoc). Zamyka też automatycznie dialog, jeśli przyciski OK lubCancel są wciśnięte. Utworzenie widżetu ���8�0������E,�� wymaga wywołania funkcji���8���������E���1, która nie pobiera argumentów. Podobnie jak ���8�����, tytułdialogu jest ustawiony domyślnie, a ustawienie to odpowiada nazwie aplikacji.
F�6H� ����#����1�9!��!���49��+9��5%'
306 Zaawansowane programowanie w systemie Linux
Przycisk Apply jest nieaktywny — to znaczy jest „zrobiony na szaro” w celu wskazania,że nie ma znaczących zmian w ustawieniach. Jeśli zawartość jakiegoś widżetu na którejśze stron została zmodyfikowana, wtedy programista jest odpowiedzialny za uaktywnie-nie przycisku Apply. W tym celu wywołuje ���8���������E�����! ����� w odpowiedzina sygnał "changed" (zmieniony), wysłany przez widżety z ���8�0������E,���
"�� ����1�9!��!���49��+9������ %F��1�0��!���4*�+�#��+'
Oczywiście najpierw trzeba dodać strony do dialogu, używając funkcji(���8���������E����������������, która zwraca numer właśnie dodanej strony:
��������1�9!��!���49��+9�!!�� 9!���%F��1�0��!���4*�+�#��+�������������������������������������F�6H� ����#!�����F�6H� ����#���'
Widżet(���� jest tym, który ma być dodany do nowej strony dla nadania jej estetycznegowyglądu, nawet jeśli zawiera tylko jeden widżet. Będzie to najprawdopodobniej ���$��8�lub widżet-pojemnik. Z kolei ��� jest widżetem umieszczanym w zakładce notatnika, któ-ry pozwala na użycie zarówno bitmapy, jak i tekstu do identyfikacji każdej strony.
���8�0������E,�� emituje sygnał "apply", kiedy kliknięto albo przycisk Apply, albo OK.W odpowiedzi kod powinien odczytać stan widżetów na stronie i zastosować odpo-wiednie ustawienia. Jeśli kliknięto przycisk Apply, to ���8�0������E,�� ustawia tenprzycisk na nowo jako nieaktywny.
W mało prawdopodobnej sytuacji, gdy zajdzie konieczność ręcznego ustawienia stanuznacznika „oczekujących zmian”, można użyć ���8��������������������������, gdzieprzekazanie ������� jako "#� wskazuje, że istotnie dokonane są zmiany, które oczekująna potwierdzenie:
"�� ����1�9!��!������9��+9���9�����%F��1�0��!���4*�+�#��+������������������'
Pierwowzór funkcji wywołania zwrotnego dla sygnałów "apply" i "help" powinien wyglą-dać następująco:
"�� �!��!���49��+9��� ���%F�6H� ����#��+�������!���9� 1���!������� ���'<
Do obsługi sygnału "help" ������8 zawiera numer aktualnie otwartej strony, pozwalająctym samym na wyświetlenie pomocy zależnej od kontekstu. Dla sygnału "apply" sytuacjanie jest równie oczywista. W istocie sygnał "apply" jest emitowany jednokrotnie dla każ-dej strony i jeszcze dodatkowo, na koniec, przekazuje ������8 jako >�. Procedura obsługitego sygnału nie musi rozróżniać stron. Wystarczy, że zaczeka na emisję strony o nume-rze >�, a następnie uaktualni ustawienia odnoszące się do wszystkich stron.
GnomeMessageBox
Ostatnim potomkiem widżetu ���8�/����� jest ���8�6������,�� — prosta podklasadialogu, wyświetlająca krótkie komunikaty wraz z odpowiednimi tytułami i ikonami okre-ślonymi przez typ okna komunikatu. Funkcja tworząca widżet jest jedyną funkcją spe-cjalną w ���8�6������,��. Przy jej wywołaniu podaje się treść, typ i listę przyciskówzakończoną �#%%.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 307
F�6H� ����#����1�91�������9��+9��5%������������#1������������������������������������������������������#1��������+9�4!�������������������������������������@@@'
GNOME udostępnia makrodefinicje dla 8�����������E��, których nazwy mówią sameza siebie1:
� ��.6��6�&&����,.B���$.,
� ��.6��6�&&����,.B�@�"����,
� ��.6��6�&&����,.B��"".",
� ��.6��6�&&����,.B�I#�& �.�,
� ��.6��6�&&����,.B�����"�A.
Oto przykład typu pytania z zastosowaniem ���8�6������,��:
F�6H� ����# �����<�������!�4<
������;����1�91������9��+9��5%9%J�� ���� ����6������]J'��������������������������������F)C,�9,����F�9*C.9`����-C)��������������������������������F)C,�9��C/G9*���C)9CG��������������������������������F)C,�9��C/G9*���C)9/�)/����������������������������������)���'<������695� ���9���5% �����'<������!�4�;����1�9 �����9� �%F)C,�9I-��CF% �����''<
�������%��!�4�;;�F)C,�9CG'�����:���������M#��34�6�5��6�6��6����CG�#M�����>
Przykładowa aplikacja GNOME
Zanim przejdziemy dalej, wypróbujmy w działaniu to, co już zostało omówione. Wy-próbujmy prostą aplikację GNOME. W tym przykładzie widżet ���8���� zostanie utwo-rzony, zapełniony kilkoma elementami menu i paska narzędziowego oraz skojarzony z od-powiednimi funkcjami zwrotnymi, wskazującymi kliknięty element:
$���� ��7���1�@�8
�������������������#�!!9� �;�JF��1���+�1!��J<�������������������#"�������;�J&@�J<
�������"�� ��91�� 9���19����6� %F�6H� ����#� �������!������� ���':��������#��+��;�%�����#'� ���<���9!����%J����L��1�� ����1�5�������6� Y�J����+�'<>
1Typy komunikatów, odpowiednio: informacja, ostrzeżenie, błąd, pytanie, ogólny — przyp. tłum.
308 Zaawansowane programowanie w systemie Linux
M#������1�� ���� �� ����#M�������F��1��--��������1�� Z[�;�:�����F)C,��--)�C9,�)�9)�H9-��,�%�J)�5J��J������������S���J����91�� 9���19����6� �������J)�5J'������F)C,��--)�C9,�)�9C0�)9-��,�%���91�� 9���19����6� ��JC!��J�'������F)C,��--)�C9�)I�����><
�������F��1��--����� ���191�� Z[�;�:�����:F)C,�9�009�-9-��,��J-��1�C��J��J-��1�C���S���J��)�����)�����&��&>������:F)C,�9�009�-9-��,��J-��1��5�J��J-��1��5��S���J��)�����)�����&��&>������F)C,��--)�C9�)I�����><
�������F��1��--����1�� Z[�;�:�����F)C,��--)�C9,�)�9�-��9�����%����1�� '������F)C,��--)�C9��*�����%J/ ���1J��� ���191�� '������F)C,��--)�C9�)I�����><
�������������9 �����9�"���%F�6H� ����#5�� �5��F 6�"�����4�#�"������!������� ���':����691���9W ��%'<����� ��������<>
�����1���%�����������������#���"Z[':��F�6H� ����#5�� �5<
�����1�9����%�!!9� ��"�����������������"'<
��5�� �5�;����1�9�!!9��5�%�!!9� ��J������������5�� �5������J'<����695�� �59���9 ��� ��9��3�%F�G9H-)ICH%5�� �5'��&&��&&'<
����69������9�������%F�G9C*T�/�%5�� �5'��J �����9�"���J����������������F�G9�-F)��9��)/%��9 �����9�"���'����������������)���'<�����1�9�!!9������91�� �%F)C,�9�00%5�� �5'��1�� '<�����1�9�!!9������9�������%F)C,�9�00%5�� �5'��� ���191�� '<����695� ���9���5%5�� �5'<����691���%'<����� ���&<>
Plik 6������ dla tego przykładu GNOME jest równie prosty:
//;���
���?������9���1�9�!!@������E%//'�\���1�=�������==�����==����������1� �\�=�������9���1�9�!!�����������9���1�9�!!@�
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 309
Drzewo kodu źródłowego GNOME
Opracowanie kodu źródłowego dla aplikacji GNOME może wydawać się jednym z bar-dziej czasochłonnych etapów cyklu programowania. Najistotniejsze na tym etapie jestupewnienie się, czy aplikacja ma pod każdym względem dobrze określoną strukturę. Je-śli przewiduje się dystrybucję aplikacji na całym świecie lub tylko na innym kompute-rze, niezbędne jest zbudowanie drzewa kodu źródłowego aplikacji. Najlepiej to zrobić,jeszcze zanim napisze się pierwszy wiersz kodu.
Elementy drzewa kodu źródłowego GNOME stosują się do pewnych konwencji,
które nieco różnią się od konwencji typowych drzew kodu źródłowego
oprogramowania GNU. Pomimo że drzewo składa się z wielu plików
i podkatalogów, to większość z nich może być zwyczajnie przekopiowana
bez zmian z innej aplikacji GNOME. Pozostałe pliki tworzy się samodzielnie
przy użyciu szablonów.
1. Pierwszym krokiem w ręcznym kreowaniu drzewa kodu źródłowego GNOMEjest utworzenie struktury katalogów, składającej się z katalogu najwyższegopoziomu (nazwanego stosownie dla danej aplikacji) i podkatalogów ��!, 8�!���,��!� i ���8��� (przy założeniu, że aplikacja GNOME będzie rozprowadzanarazem z bitmapami).
310 Zaawansowane programowanie w systemie Linux
2. Następnie tworzy się pliki tekstowe �# �."&, ��@&, A.0-���, "��/6� i A ����%��.Każdy z nich powinien zawierać adekwatną, odpowiednio sformatowanąinformację tego samego rodzaju, co w innych aplikacjach GNOME. Na tym etapiewarto znaleźć i sprawdzić zawartość innych plików źródłowych. Pliki takienależy wypełnić i umieścić w katalogu najwyższego poziomu.
3. Teraz trzeba utworzyć pusty plik o nazwie ���8�� ���, który będziewykorzystany z makrodefinicją �6�A.�$������/�" przez !���������.
4. W tej chwili napiszemy pliki !��������� i �!!����� i umieścimy je w katalogunajwyższego poziomu. Napiszemy także plik 6��������8 dla katalogunajwyższego poziomu, obejmujący wykaz każdego katalogu zawierającegokod źródłowy. Następnie trzeba napisać odrębny plik 6��������8 dla każdegotakiego katalogu z osobna.
5. Należy uruchomić plik wykonywalny ���������3�, który jest częścią pakietuGNU — �������. To utworzy katalogi ���� oraz ��, które odgrywają dużą rolęprzy umiędzynarodowieniu. W ��H0. $�%�&��� należy umieścić wykaz plikówźródłowych zawierających napisy, które powinny być przetłumaczone.
6. Należy teraz skopiować zawartość katalogu 8�!��� oraz plik �������� z innejaplikacji GNOME.
7. I wreszcie uruchomić �������� w celu wywołania ���8���, ���!��,��� �����, �!��!�� i ��������3�.
Teraz pora na pliki, które trzeba napisać samodzielnie: !��������� oraz 6��������8.
configure.in
Plik !��������� to szablon używany przez ���!�� do tworzenia skryptu konfigura-cyjnego (configure script), który składa się z makrodefinicji języka m4, rozwijanychprzez autoconf do postaci skryptów powłoki.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 311
Przykładowy !��������� jest jednym ze skryptów używanych przez nakładkę gra-ficzną GNOME dla naszej aplikacji obsługującej wypożyczalnię płyt DVD. Występujątu tylko trzy specyficzne dla GNOME makrodefinicje: ��.6����� , ��.6��A.60�%��@�"?����& i ��.6��B�A��A7&, które są rozwinięte do postaci skryptów powłoki na podstawieplików zawartych w katalogu 8�!���.
���0�����������������5����� ����������!�� ����������� �������!�@�/9-)-�%������ ��@��'�,9-)-�9���C,�G�% " �������&@�'�,9/C)�-F9S��I��%������@�'
���0��6� !�����F��1��1�����@�,9�C/��9-)/��I�%1�����'
F)C,�9-)-��/9-�/90C�-.�/90�CF9//�,90�CF9//9��I/�/9S��I��9��I/
F)C,�9/C,0-��9H��)-)F�F)C,�9.9/S�/G�
���� ��������� ������5�����4� ���!!���������� !!���������@���9�-)F���;JJ�,9F)�9F����.�
�������0�/G�F�9�C/���9I-�����������@�@��������J+E:!����+>J�;�J+)C)�J<��������/9I��-)�9�)`�C��I%0�/G�F�9�C/���9I-��JE:��9 ��� ��9!����+>ME:I���I-�)�,�>M������J'�������/9I��-)�9�)`�C��I%0�/G�F�9�C/���9I-���JE:!����+>ME:I���I-�)�,�>M������J��
���� ����0�/G�F�90-.,�0�9I-�@0�/G�F�90-.,�0�9I-�;J\���1�=�������== ��� ��\M!�+1�!�ME:0�/G�F�>J�/9��*��%0�/G�F�90-.,�0�9I-�'
�/9C��0��%Z,�6�����1�����M,�6��������M,�6���������M,�6�����!�M,�6�����@��['
� ��.6����� odpowiada za dodanie do skryptu konfiguracyjnego specyficznychdla GNOME argumentów wiersza poleceń, wykorzystując do tego celuintensywnie program ���8�?!����.
� ��.6��A.60�%��@�"����& włącza wszystkie właściwe opcje diagnostycznekompilatora.
312 Zaawansowane programowanie w systemie Linux
� ��.6��B�A��A7& przeprowadza proste testy serwera X11 i sprawdza obecnośćbiblioteki B�8.
Skrypt !��������� także tworzy i eksportuje zmienną środowiskową 0�A7����0�B?6�0&�/�" (używając do tego makrodefinicji �A�&#,& ), która umożliwia aplikacji odnale-zienie każdej zainstalowanej bitmapy.
Makefile.am
Polecenie ���8��� czyta pliki 6��������8 z katalogu najwyższego poziomu i każdegoz jego podkatalogów zawierających pliki źródłowe. Przetwarza je następnie do postaci6���������. Należy pamiętać, że ���8��� jest wywoływane w trakcie wykonywania�������� . Plik 6��������8 najwyższego poziomu może zawierać jedynie wskaźnik&#,/�"& do podkatalogów. W pliku 6������ graficznej nakładki GNOME dla aplikacji ob-sługującej wypożyczalnię płyt DVD, pokazanym niżej, znajduje się również wpis dla in-stalacji pliku �������� i dwie dodatkowe opcje 8���: �������?����?��!�� oraz ����? ���.
$$0������������������5����� ��1�6�����!�� ���,�6����@��
��*I-���;������!��1���������
�.���9I-���;�Y����� " �����@ ��6��!
�!!��������� ���;�E%���1� ��� ��'M���1�M�!!�M�!!����������!!���������9I����;� " �����@ ��6��!
�������= ���=�����?�����aE%)C�,��9-)�����'�������������N �E%��� ��'M!�+1�!�<������Y�������E%16������ ���'�E%I���I-�'a0�/G�F�90-.,�0�9I-�a<�Y�����������!�+1�!����E%��� ��'�M!�+1�!�M#<� ��Y�����������������N��EE!�+1�!<������Y�����������E%-)�����9I���'�EE!�+1�!�E%I���I-�'a0�/G�F�90-.,�0�9I-�a<�Y������������Y������� ����Y�������
���=���6?�������������N �!�+1�!�<������Y�������16 ���E% ��� ��'M!�+1�!�<�Y�����������!�+1�!����!�+1�!�M#<� ��Y�����������������N��EE!�+1�!<������Y������������!�N!�EE!�+1�!�E% ��� ��'M!�+1�!�<�Y������������Y������� ����Y�������
Plik typu �������� przekazuje do GNOME informację, jak i gdzie umieścić wpis dlaaplikacji w menu GNOME. Plik ���������������� wygląda następująco:
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 313
ZI��6��!�����4[)�1�;IRI�����/�11���;IRI�������F�-�+��; " �����-���; " �����@!�����1����;&�4!�;�!!��������
Plik typu ��������(składa się z szeregu par klucz-wartość.
� ��8� jest nazwą aplikacji — w tej postaci, w której występuje w domyślnymjęzyku.
� A�88��� pojawia się jako etykietka narzędzia.
� ���! określa instrukcję wiersza poleceń używanego do uruchomienia programu.
� �!�� jest ikoną do umieszczenia obok wpisu w menu GNOME.
� ��8���� jest wartością logiczną. Jeśli ma wartość niezerową, to aplikacjauruchomi się w oknie terminala.
� E�� powinien być ustawiony na �����!�����.
Plik 6��������8 w katalogu ��! dla �������� informuje ���8��� o plikach źródłowychi bibliotekach, które muszą być skompilowane i skonsolidowane.
$$�0�����������������5����� ��1�6�����!�� ���,�6�����@��
-)/��I���;�Y�����=-E%��!9��� ��'M�����Y�����E%F)C,�9-)/��I�I-�'
���90�CF��,��;� " �����
" �����9�C��/���;�Y�������������@�� " @��Y�����1���@��Y������ !!���@��� !!���@��Y��������������@�����������@��Y������������6�@���������6�@��Y�������� " 9� �@�� " 9� �@�
" �����9�I�II�;�E%F)C,�9�-*I-�'�E%F)C,��-9�-*�'�E%-)���-*�'
Schemat procesu tworzenia i kompilacji drzewa kodu źródłowego zawiera rysunekumieszczony na następnej stronie.
Zapis konfiguracji
Ważną cechą każdej aplikacji GUI jest jej zdolność do zapisu konfiguracji i ustawieńużytkownika. GNOME bardzo ułatwia przechowywanie i odzyskiwanie danych wszystkichpowszechnie używanych typów. Udostępnia w tym celu wszechstronny interfejs API
314 Zaawansowane programowanie w systemie Linux
w przestrzeni nazw ���8��!����. Dane konfiguracyjne są przechowywane jako paryklucz-wartość w zwykłym pliku tekstowym, który znajduje się domyślnie w katalogu����H����8�.
Przechowywanie danych
Zapisywanie danych do pliku konfiguracyjnego wiąże się z przekazaniem do odpowied-niej funkcji ���8��!�������� ścieżki ��E wraz z danymi, które mają być zachowane.Ścieżka ��E składa się z trzech sekcji oddzielonych znakiem ukośnika GHG:
� nazwa pliku !���� jest zgodnie z konwencją nazwą aplikacji,
� sekcja, dowolna etykieta opisująca kategorię klucza,
� i wreszcie sam klucz: �H9�����8�;H9��!����;H9��E;.
Zatem, aby zapisać wartość całkowitą do ścieżki �����!�����H�������H�8���, należywywołać ���8��!�������������, a potem ���8��!������E�!, by faktycznie zapisaćdane na dysku.
�����"�� ��;���<���1�9������9���9���%JM�!!��������M�������M� 1���J��"�� �'<���1�9������9�4��%'<
Dla innych typów danych istnieją podobne funkcje:
"�� ����1�9������9���9������%������������#!�����������������#"�� �'"�� ����1�9������9���9�����%������������#!������ � ����"�� �'"�� ����1�9������9���9����%������������#!��������������"�� �'"�� ����1�9������9���9���%������������#!����������"�� �'"�� ����1�9������9���9��������� 9������%������������#!���������������������������������������������������������#"�� �'"�� ����1�9������9���9"�����%������������#!��������������������������������������������������������#���������"Z['
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 315
Istnieje też równoważny zestaw funkcji z nazwami rozpoczynającymi się od ���8��!����������������, zapisujących dane w katalogu JH����8���������. Ten katalogpowinien być dostępny do odczytu tylko dla użytkownika. Tak więc funkcje ���8��!��?���������� mogą być użyte do zapisu danych poufnych, takich jak np. hasła.
Odczyt zachowanych danych
Zachowane dane możemy wygodnie odebrać w postaci wartości zwracanych funkcji���8��!����:
������#���1�9������9���9������%������������#!���'� � �������1�9������9���9�����%������������#!���'������������1�9������9���9����%������������#!���'��������1�9������9���9���%������������#!���'������#���1�9������9���9��������� 9������%������������#!���'"�� ����1�9������9���9"�����%������������#!����������#����!��������###���"!'
Łatwo więc odzyskać uprzednio zachowaną liczbę całkowitą ��� za pomocą:
�9!����%JC !�5�� O���31��L Y�J������������1�9������9���9���%JM�!!��������M�������M� 1���J''<
co daje:
C !�5�� O���31����
Jeśli plik konfiguracyjny nie został utworzony lub klucz jeszcze nie istnieje, to funkcje���8��!�������� zwrócą +, �#%% lub $�%&�, zależnie od typu. Dołączając 5����� dościeżki, można dostarczyć wartość domyślną, która będzie zwrócona, jeśli klucz nie zo-stanie znaleziony. To również wykluczy możliwość zwrócenia przez funkcję ���8��!���� wskaźnika �#%%.
������#1��1���;����1�9������9���9������%JM�!!��������M�������M������;I��� ��9��+�J'<�9!����%J_����5��4����� ������L�Y�J�1��'<�9����%1��'<
Funkcja ���8�?!���� udostępnia funkcje ���8��!������� ������ oraz ���8��!��������������, dzięki którym unika się podawania pełnej ścieżki przy każdym wywołaniu.Poza tym, menedżer sesji może przekazać prefiks (przedrostek) do odpowiedniegopliku, aby zachować dane konfiguracyjne pomiędzy sesjami — opiszemy to w następ-nym podrozdziale.
���1�9������9! ��9!����+%JM�!!��������M�������J'<���1�9������9���9���%J� 1���;��J'<���1�9������9!�!9!����+%'<
Zarządzanie sesją
Zarządzanie sesją to proces zapisu stanu pulpitu pod koniec sesji i jego odtworzenie napoczątku nowej sesji.
316 Zaawansowane programowanie w systemie Linux
Stan pulpitu odnosi się do aktualnie otwartych aplikacji, pozycji i rozmiaru ich
okien, otwartych dokumentów itd., jak również do komponentów pulpitu, takich
jak np. pozycja panelu.
Odpowiedzialnością za zapewnienie poprawnej współpracy z menedżerem sesji obar-czony jest programista, który, poproszony, powinien zapisać wystarczającą informacjęo stanie utworzonej przez siebie aplikacji tak, aby umożliwić innym jej ponowne uru-chomienie (lub sklonowanie) w tym samym stanie.
Menedżer sesji GNOME, ���8�?�������, używa specyfikacji zarządzania sesją X dozapewnienia kompatybilności z innymi środowiskami pulpitowymi, takimi jak CDE i KDE.Menedżer ���8�?������� komunikuje się z aplikacjami GNOME za pomocą następują-cych sygnałów:
� "save_yourself" („zapisz się”2) emitowany, kiedy aplikacja musi zachować swójstan bieżący,
� "die" („giń”) emitowany, kiedy aplikacja powinna natychmiast się zakończyć.
Choć GNOME generuje sygnały GTK w obrębie aplikacji, te, użyte przez
menedżera sesji, nie są sygnałami GTK.
Ilość informacji, jaką aplikacja powinna zachować pomiędzy sesjami, będzie zależeć odtypu aplikacji. Edytor tekstu np. mógłby zapisać aktualnie otwarty dokument, pozycjękursora, stos zdarzeń cofnij-powtórz itd., itd., podczas gdy jakiś mały program na-rzędziowy mógłby nic nie zachowywać. W pewnych sytuacjach, takich jak np. programz bazą danych chronioną hasłem, zapis stanu może mieć konsekwencje dotyczące bezpie-czeństwa.
W GNOME użytkownik musi zazwyczaj sam wyraźnie zażyczyć sobie, aby sesja zostałazachowana za pomocą zaznaczenia przycisku przełączania w oknie wylogowania.
GnomeClient
W celu połączenia sygnałów z ���8�?!����� najpierw należy przechwycić wskaźnik doobiektu klienta nadrzędnego, a następnie zwyczajnie przyłączyć funkcję wywołaniazwrotnego.
F��1�/������#�������;����1�91�����9�������%'<
��69������9�������%F�G9C*T�/�%������'��J��"�94� �����J������������F�G9�-F)��9��)/%��9�������9��"�'�����"Z&['<
��69������9�������%F�G9C*T�/�%������'��J ��J������������F�G9�-F)��9��)/%��9�������9 ��'��)���'<
2„Save yourself” w języku angielskim oznacza raczej „ratuj się” — więc pod koniec pracy
aplikacja Gnome albo dostaje od menedżera sesji szansę ratunku, bądź też jest przez niego
bezlitośnie likwidowana.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 317
W funkcji wywołania zwrotnego �����E����� aplikacja musi zachować odpowiedniąinformację do ponownego uruchomienia w następnej sesji. Istnieją dwie standardowemetody zachowania danych.
Argumenty wiersza poleceń
Argumenty potrzebne do uruchomienia aplikacji w żądanym stanie mogą być przekaza-ne do ���8�?�������, o ile jest to niewielka ilość informacji dająca się zamknąć w ra-mach wiersza poleceń.
Poniżej znajduje się przykład, w którym dwa parametry, ??�����8� (nazwa użytkowni-ka) i >?����1��� (hasło) wraz z ich bieżącymi wartościami, ��� i ����1�, są przekazanedo ���8�?������� w tablicy ����. Przy rozpoczęciu następnej sesji ���8�?������� uru-chomi ponownie aplikację, przekazując >?�����8�(���(>?����1���(����1� jako argu-menty. Aplikacja powinna wtedy podjąć odpowiednie działanie: w tym przypadku zapewneotworzy interfejs GUI wraz z charakterystycznymi dla tej aplikacji nazwą użytkownikai hasłem, wprowadzonymi uprzednio.
�������������9�������9��"�%F��1�/������#�������������!������F��1���"���4�����"�9��4����������9�� � �5���F��1�-���������4�����������9��4�����������9������!�������������9 ���':��������##���"<��� ��������<
�����%�(%���"�;�1�����%���3���%�����#'�#��''�:���!�����%J1�����%'������ J'�<����+��%������'<��>��1�1���%����"��&��%��3���%�����#'�#��'�'�<�����"Z&[�;�������9 ���<�������;��<��-��%�������� '�����:�����"Z�[�;�Jb= �����1�J<�����"Z�[�;� ��������"Z[�;�Jb=!���5�� J<�����"Z�[�;�!���5 <�������;�K<��>�����1�9������9���9�����9��11�� %�����������������"'<�����1�9������9���9�������9��11�� %�����������������"'<
����� �������<>
318 Zaawansowane programowanie w systemie Linux
API gnome-config
Użycie argumentów wiersza poleceń do przechowania informacji pomiędzy sesjami mawtedy tylko praktyczne zastosowanie, kiedy ilość informacji jest niewielka. Przy większejilości wykorzystuje się alternatywnie API ���8�?!����, nakazując ���8�?������� dostar-czenie odpowiedniego prefiksu. Odzyskanie informacji przy ponownym uruchomieniu niewymaga analizy składniowej argumentów wiersza poleceń. Spróbujmy więc.
Do przechwycenia prefiksu trzeba użyć ���8��!����������!�����������
�������������"�94� ������%F��1�/������#�������������!������F��1���"���4�����"�9��4������������������������9�� � �5���F��1�-���������4�����������9��4�������������������������9�������!�������������9 ���':�������������#�����Z�[�;�Z�J�1J��J=�J��)�����)����[<
�����������1�9������9! ��9!����+�%���1�9������9���9������9!����+�%������''<
�����������1�9������9���9������%JM �����1�J�� ���'<�����������1�9������9���9������%JM!���5�� J��!���5 '<
�����������1�9������9!�!9!����+�%'<
������������Z�[�;����1�9������9���9����9!�����������������������%���1�9������9���9������9!����+�%������''<�����������1�9������9���9 ����� 9��11�� �%��������������'<
����������� �������<>
Używając ���8��!�������������!����!�88���, usuwa się każdą informację zachowanąjako część sesji, która była w toku, kiedy polecenie usunięcia zostało wydane.
Funkcja zwrotna dla sygnału "die" jest o wiele prostsze — celem jest „schludne” zakończe-nie sesji.
�������������9�������9 ��%F��1�/������#���������!�������������9 ���':���������691���9W ��<���������� �������<>
Podczas rozpoczęcia nowej sesji aplikacje GNOME wznowią się bez kłopotów auto-matycznie, jeśli dwa powyższe sygnały będą poprawnie obsługiwane. Wyczerpujące mate-riały źródłowe dotyczące ���8�?������� można odnaleźć w plikach �������?8�����?8������� oraz ���8�?!������ , będących częścią bibliotek GNOME. Pliki zawierają in-formacje na temat współpracy z użytkownikiem w czasie zachowywania sesji i o sposo-bach unikania warunku wyścigu3 (race condition) podczas uruchamiania sesji z użyciempoziomów priorytetu. 3Często spotykany błąd programisty, dokładniej opisany w rozdziale 12 — przyp. red.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 319
Analiza składniowa wiersza poleceń z użyciem popt
Rozsądną metodą analizy składniowej opcji wiersza poleceń przekazanych do aplikacjiGNOME jest użycie biblioteki popt. Domyślnie obsługuje ona wiele opcji GNOMEi GTK+. Indywidualnie dostosowane opcje można dodać, używając tablic popt, które skła-dają się z tablicy struktur ����.�����.
Analiza składniowa ���� i ���! za pomocą popt jest związana z zastąpieniem ���8������ przez ���8�������1�� �����������:
��������1�9����95���9!�!�9�����%�����������#�!!9� ���������������������������������������������#�!!9"����������������������������������������������������������������������������������������##���"������������������������������������������� ���!�!�C!�����#�!�����������������������������������������������������������������������������������!�!�/����+��#��� ��9��+'
������, �����������, ���! i ���� mają identyczne znaczenie jak ich odpowiednikiw ���8������. Tablica struktur ����.����� jest zakończona pustą opcją (o wszystkichelementach równych + lub �#%%). Każdy element wyszczególnia nazwę i właściwości ar-gumentu wiersza poleceń. Tablica ����.����� jest zdefiniowana w sposób następujący:
��� ���!�!�C!�����:����������������#����)�1�<���������������)�1�<������������-���<�����"�� �#���<���������"��<����������# �����!<����������#���I�����!<><
Pierwszymi dwoma elementami są długa i krótka nazwa opcji, dające użytkownikowijednocześnie skrótową i bardziej opisową nazwę. Kolejny element ������ określa typopcji i może mieć postać jednej z siedmiu makrodefinicji.
argInfo Opis
0C0�9��F9)C)� Opcja jest zwykłym przełącznikiem, takim jak N=���! i nie pobiera argumentu.
0C0�9��F9���-)F Opcja przyjmuje wartość będącą napisem, taką jak N= �����1�;<�� �3�2<.
0C0�9��F9-)� Opcja przyjmuje wartość typu ���.
0C0�9��F9�C)F Opcja przyjmuje wartość typu ��������.
0C0�9��F9-)/��I�9��*�� To nie jest opcja, ale wskaźnik do innej tablicy.
0C0�9��F9/���*�/G Określa, że wszystkie opcje w tablicy !�!� mają być obsługiwane przez
funkcję zwrotną; opcja ta, jeśli jest użyta, powinna być umieszczona na
początku tablicy.
0C0�9��F9-)��9IC,�-) Wskazuje (o ile jest określona) język przekładu tekstu na ekranie.
320 Zaawansowane programowanie w systemie Linux
Znaczenie ��� zależy od typu ������.
Dla 0.0 ��"���.�� — ���� ustawia ��� tak, by wskazywał zmienną boole’owską,stwierdzając tym samym obecność lub nieobecność tej opcji w wierszu poleceń.
Dla 0.0 ��"��& "���, 0.0 ��"���� i 0.0 ��"��%.��(— ��� powinien wskazywać na zmien-ną o tym samym typie, co typ argumentu. Następnie ���� wypełnia wskaźnik argumen-tem przekazanym w wierszu poleceń.
Dla 0.0 ��"����A%#/�� �,%� — ��� jest wskaźnikiem do tablicy ����.����� niższegorzędu, która ma zostać włączona.
Dla 0.0 ��"��A�%%,�A7 i 0.0 ��"���� %�/.6��� — ��� powinien być wskaźnikiem dofunkcji wywołania zwrotnego i napisu określającego domenę przekładu.
Pole ��� jest identyfikatorem opcji, który może się przydać w funkcji zwrotnej,z reguły jednak nie jest używany i pozostawia się go z wartością +.
Ostatnimi elementami struktury ����.����� są ���!��� i ���/��!���. Zawierają one opisopcji używany podczas przetwarzania opcji ?? ���, którą domyślnie obsługuje ����;���!��� zawiera opis opcji, a ���/��!��� jest przykładową wartością. Dla opcji określa-jących nazwę użytkownika i hasło, tablica ����.����� wyglądałaby tak:
��� ���!�!�C!������!�����Z[�;�:���:����������J �����1�J�����������B B������������0C0�9��F9���-)F������������V ���������������&������������)9%J�!����4��� �����1�J'������������)9%J����)�,�J'���>����:�����������J!���5�� J������������B!B�������������0C0�9��F9���-)F�������������V!���5 �������������&�������������)9%J�!����4���!���5�� J'�������������)9%J0���HC�IJ'���>����:������������)����������������BY&B�������������)����������������&�������������)����������������&�������������)����������������)������>><
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 321
Wydruk opcji ?? ��� będzie wyglądał tak:
E������������������?� " ������ZC0�-C)@@@[
F)C,��C!�������== ������=�� � I��������� � ����"��� ������==������=�� � ��������� � ����"��� ������==��!��6��;SC��)�,�?0C�� S���?!�������5����������� � ����"������ �����
� �������=="������
S��!��!�������=]��==���! ���5���������!�1��������== ���� I��!��4������� �����1������
F�G��!�������==� 6= �� �;���F� F 6� �� ��������������������==� 6=��= �� �;���F� F 6� �� ��������������� ������== ��!��4;I-�0��^ .� ��!��4���� ����==�4�� ,�6��.��������4������� ���==��=+��1 I��B�� ���.������ �1�1��4��+���������==��1�;)�,� 0�����1���1����� �� ��4�����5�� �5�1��������==�����;/���� 0�����1���������� �� ��4�����5�� �5�1��������==�+� 9����;SC����==�+� 9!���;0C����==+�1=!��� ��;��^����==+�1=���� �;��^����==��6= �� �;���F� F�6X� �� ��������������������==��6=��= �� �;���F� F�6X� �� ��������������� ������==�=�����=5������� ,�6������5���������������==��6=1� ��;,CI��� ��� ����� ��������F�6�1� ��
F)C,��F�-��!�������== ������=�����= �����
��������1����1�����!�������==�1=������=� ;-I �!����4���������1�����1����-I��==�1=������=!����+;0���-. �!����4�!����+������"� ������� ��������==�1= ������ I�����������������������������1������
" �������!�������= ��== �����1�;����)�,� �!����4��� �����1���=!��==!���5�� ;0���HC�I �!����4���!���5�� E
Na dole wydruku pojawia się opis niestandardowych opcji określających nazwę użyt-kownika (�����8�) i hasło (����1���). Większość z pozostałych opcji jest wspólna dlawszystkich aplikacji GNOME.
Na koniec wracamy do pozostałych dwóch parametrów ���8�������1�� �����������.I tylko jeden z nich, ������!��, jest naprawdę interesujący. Parametr ���� możnazignorować, bo nie jest przydatny w aplikacjach GNOME.
Parametr(������!�� dostarcza wskaźnika do bieżącego kontekstu, który umożliwia ana-lizę składniową pozostałych argumentów wiersza poleceń — to znaczy argumentów nie-związanych z żadną opcją, takich jak nazwy plików, bibliotek itd. W celu przechwycenia
322 Zaawansowane programowanie w systemie Linux
tablicy argumentów, zakończonej przez �#%%, trzeba jedynie wywołać ����������� w bie-żącym kontekście. Nie należy zapomnieć o uwolnieniu kontekstu za pomocą ����$���?A������ po zakończeniu pracy.
!�!/����+�������+�<������<�����##����<
���1�9����95���9!�!�9�����%�00��R���-C)�����������"���!�������&��V�����+�'<
�����;�!�!�F������%�����+�'<
���%�����(;�)���'�����:����������5�����%����Z�[�(;)���'������������:��XX<�������������>�����>
!�!�����/����+�%�����+�'<
Materiały dodatkowe
Rosnąca popularność GNOME zapewnia powiększanie zasobów wysokiej jakości doku-mentacji, wykładów wprowadzających, zestawów FAQ (zawierających pytania i odpo-wiedzi dotyczące GNOME), przewodników dla początkujących zarówno w wersjidostępnej w sieco, jak i w postaci drukowanej.
� Najlepszym miejscem szukania nowości i uzyskiwania informacji jest stronagłówna projektu GNOME http://www.gnome.org/. Warto również sprawdzićstronę programistów http://developer.gnome.org/. Można tam znaleźć wszelkierodzaje łączy do dokumentacji, wykaz bibliografii do API oraz mapęoprogramowania GNOME/GTK+ wraz z łączami do najbardziejpopularnych aplikacji.
� Nie należy zapominać, że pliki nagłówkowe GNOME/GTK+ zawierają sporoużytecznych informacji. Podstawową zasadą jest sprawdzanie kodu źródłowegow razie jakichkolwiek wątpliwości.
Istnieją również książki poświęcone GNOME/GTK+, chociaż większość podejmujetemat na poziomie dla początkujących. Dwie godne polecenia pozycje to:
� Peter Wright: „Beginning GTK+/GNOME”, Wrox Press (ISBN 1-861003-81-1).Książka podaje wyczerpujące wprowadzenie w świat GTK+ i GNOME.
� Havoc Pennington: „GTK+/GNOME Application Development”, New Riders(ISBN 0-7357-0078-8), najbardziej zaawansowana książka dostępna na tentemat. To ostatnie słowo w programowaniu GNOME, napisane przez „rdzennego”hakera GNOME. Książka ta jest wydana na licencji GPL (General PublicLicence) i można pobrać jej tekst za darmo z http://www.gnome.org/.
Rozdział 8. � Programowanie graficznych interfejsów użytkownika (GUI) ... 323
Podsumowanie
W tym rozdziale zostały omówione najpopularniejsze zagadnienia programowania GNO-ME/GTK+. Najpierw opisaliśmy bibliotekę glib i pełny zestaw przenośnych typówzmiennych, makrodefinicji, funkcji do obsługi napisów i przydziału pamięci oraz obsłu-gi przechowywania list.
Następnie, podczas omawiania GTK+, wprowadzono pojęcie widżetów, opisano uży-cie pojemników i sygnałów obsługujących proste i sprawne budowanie interfejsów.Temat zakończono krótkim, ale użytecznym przykładem.
W dalszej części opisano GNOME, omawiając podstawowe funkcje i widżety tej biblio-teki oraz ich zastosowanie w budowie menu, pasków narzędziowych i okien dialogo-wych. Na zakończenie ukazano budowę drzewa kodu źródłowego GNOME, zapis konfi-guracji i zarządzanie sesją.