PRZYK ADOWY ROZDZIA SPIS TRE CI Zaawan L - Helion · Zarówno do wiadczeni programi ci, jak te¿ i ambitni przyszli twórcy oprogramowania w systemie Linux znajd¹ tutaj mnóstwo

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.

http://helion.pl

http://helion.pl/zamow_katalog.htm

http://helion.pl/katalog.htm

http://helion.pl/zakupy/add.cgi?id=zaprli

http://helion.pl/emaile.cgi

http://helion.pl/cennik.htm

http://helion.pl/online.htm

mailto:[email protected]

http://helion.pl/ksiazki/zaprli.htm

http://www.amazon.com/exec/obidos/ASIN/1861003013

ftp://ftp.helion.pl/przyklady/zaprli.zip

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


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


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


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


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


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


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


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


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


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


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


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


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


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.


� 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.


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+.


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 "�� #

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


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.


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�� %'


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.


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!%��#��'


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�'


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��#��!�� '<


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��#��'


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'<


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.


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.


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!� ��'


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�-��&��&'<


��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ł.


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:


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��%'<

�� &<

>


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.


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.


� �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.


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).


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��+�'


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.


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�%,


� ��.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'


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


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��#��'


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%'


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ą �#%%.


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.


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�!!@�


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).


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.


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.


� ��.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:


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


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['


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.


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.


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�� %��"'<

�� <>


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.


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.


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��)��&��)��&��)��)��>><


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


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/.


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ą.

Documents

PRZYK ADOWY ROZDZIA SPIS TRE CI Zaawan L - Helion · Zarówno do wiadczeni programi ci, jak te¿ i ambitni przyszli twórcy oprogramowania w systemie Linux znajd¹ tutaj mnóstwo