Poznaj praktyczne przyklady programowania Linuksa z użyciem Kyliksa.

Kylix, pierwsze narzędzie typu RAD (Rapid Application Development) dla systemu operacyjnego Linux jest środowiskiem projektowym dla programowania aplikacji graficznego interfesju użytkownika (GUI), aplikacji WWW oraz baz danych. Napisana przez doświadczonych programistów, ta książka jest po prostu obowiązkową pozycją dla każdego programisty Kyliksa.

Kylix Power Solutions ma dwa główne cele: jak najszybciej zapoznać cię z programowaniem Linuksa oraz dostarczyć gotowych, sprawdzonych rozwiązań najczęściej występujących programistycznych problemów. Przedstawione przykłady obejmują szeroki zakres zagadnień, od kontrolowania KDE po wzajemną komunikację między procesami. Każdy przyklad obejmuje szczegółowe omówienie zagadnienie i zawiera kod źrodlowy programu wykorzystującego omawianą strategię.

Ta książka pomoże Ci w:

• Jak najlepszym wykorzystaniu Kyliksa, bezpośrednio po wyjęciu z opakowania.
• Poznaniu zasadniczych różnic pomiędzy programowaniem w Linuksie i w Windows -- i to w rekordowo krótkim czasie.
• Uruchamianiu, kontrolowaniu, zamykaniu i komunikowaniu się z innymi aplikacjami z wnętrza swoich programów.
• Programowym ustawianiu i modyfikowaniu systemowych uprawnień Linuksa.
• Monitorowaniu procesów w systemie.
• Użyciu systemowego programu cron do układania harmonogramów zadań administracyjnych.
• Implementowaniu wspólnych bibliotek obiektów.
• Tworzenie modułów interfejsu Pascala dla istniejących bibliotek języka C.
• Tworzeniu własnego systemu pomocy -- włącznie z własną przeglądarką.
• Rozwiązywaniu codziennych programistycznych problemów w Kyliksie.

• Przegląd systemu operacyjnego Linux, w porównaniu z Windows.
• Wprowadzenie do języka C dla programistów Pascala.
• Przykłady rozwiązań różnorodnych programistycznych problemów Linuksa i Kyliksa, wraz z omówieniami i przykładami kodu.

• Programistów Delphi przenoszących się do Kyliksa.
• Programistów Visual Basica chcących przenieść swoje programy do Linuksa.
• Obecnych programistów Linuksa chcących tworzyć aplikacje graficznego interfejsu użytkownika.

Osoby które kupowały "Kylix. Czarna księga", wybierały także:

• Superinteligencja. Scenariusze, strategie, zagro 66,67 zł, (14,00 zł -79%)
• Poradnik design thinking - czyli jak wykorzysta 48,28 zł, (14,00 zł -71%)
• Kosymulacja. Elastyczne projektowanie i symulacja wielodomenowa 38,39 zł, (11,90 zł -69%)
• F# 4.0 dla zaawansowanych. Wydanie IV 96,45 zł, (29,90 zł -69%)
• Systemy reaktywne. Wzorce projektowe i ich stosowanie 65,31 zł, (20,90 zł -68%)

Spis treści

Kylix. Czarna księga -- spis treści

O Autorach (11)

Wprowadzenie (13)

Część I Z Delphi do Kyliksa (17)

Rozdział 1. Porównanie środowisk (19)

• Różnice pomiędzy środowiskami (19)
  
  • Różnice systemowe (20)
  • Różnice występujące w środowisku programowania (22)
  • Open Source (23)
• Okna w Linuksie (24)
  
  • System X Window (24)
  • Menedżer okien (25)
• Gdzie znaleźć więcej informacji (27)

Rozdział 2. Krótki wykład na temat Linuksa (29)

• Pliki i katalogi (29)
  
  • Nazwy plików i katalogów (30)
  • Łącza do plików (32)
  • Własność plików i katalogów (33)
  • Do czego służą te katalogi? (35)
• Techniki programowania Linuksa (36)
  
  • Koncepcja wywołań systemowych (37)
  • Procesy i sygnały (38)
  • Programowanie wątków (39)
  • Komunikacja pomiędzy procesami (40)
• System plików /proc (43)
  
• Gdzie znaleźć więcej informacji (44)

Rozdział 3. Korzystanie z bibliotek (45)

• Tworzenie obiektu wspólnego i korzystanie z niego (46)
  
  • Tworzenie grupy projektów (46)
  • Biblioteka Hello (47)
  • Wywoływanie funkcji bibliotecznych (48)
  • Udostępnianie bibliotek (49)
• Konwencje wspólnych bibliotek (50)
  
  • Konwencje nazywania bibliotek (50)
  • Gdzie umieścić biblioteki? (52)
  • Gdzie Linux szuka bibliotek? (52)
  • Kylix a zgodność z konwencją bibliotek (53)
  • Zabawa z nazwami funkcji (54)
• Dynamiczne ładowanie bibliotek (55)
  
  • Inicjalizacja i końcowe działania bibliotek (58)
  • Gdzie szuka bibliotek funkcja dlopen (58)
• Przenoszenie bibliotek pomiędzy platformami (58)
  
  • Konwencje wywołań (59)
  • Nazwa biblioteki (59)
  • Typ uchwytu biblioteki (60)
  • Moduł ShareMem (60)
  • Kod startowy biblioteki (60)
  • Moduł interfejsu dla różnych platform (61)
• Gdzie znaleźć więcej informacji (63)

Rozdział 4. Podstawy C dla programistów Kyliksa (65)

• Podręcznik C dla programisty Pascala (66)
  
  • Typy danych C i Pascala (66)
  • Zmienne, struktury, unie oraz typy (68)
  • Operatory języka C (70)
  • Instrukcje sterujące i pętle (73)
  • Wskaźniki (75)
  • Funkcje i "procedury" (78)
  • Pozostałe zagadnienia (79)
  • Elementy C++ (81)
• Używanie bibliotek C w Kyliksie (83)
  
  • Tworzenie programów za pomocą polecenia make (84)
  • Tworzenie modułu interfejsu (86)
• Gdzie znaleźć więcej informacji (92)

Część II Przykłady programowania Kyliksa (95)

Rozdział 5. Kontrolowanie procesów (97)

• 5.1 Zastępowanie bieżącego procesu nowym programem (98)
  
  • Przykład: program execTest (100)
• 5.2 Uruchamianie procesu potomnego (104)
  
  • Przykład: tworzenie procesu potomnego z programu konsolowego (105)
  • Przykład: tworzenie procesu potomnego w aplikacji graficznego interfejsu użytkownika (106)
• 5.3 Uruchamianie programu i czekanie na zakończenie jego działania (107)
  
  • Przykład: program forkWait (107)
• 5.4 Tworzenie procesu działającego w tle (109)
  
  • Przykład: program bgTest (109)
• 5.5 Niszczenie procesu (110)
  
  • Przykład: program CrashTestDummy (110)
  • Przykład: moduł ProcStuff (112)
  • Przykład: program KillerApp (116)
• 5.6 Ustalanie priorytetów procesów (118)
  
  • Przykład: program priTest (120)
• 5.7 Zmniejszanie obciążenia systemu (121)
  
  • Przykład: program Sleeper (122)
• 5.8 Uzyskiwanie informacji na temat identyfikatora procesu oraz użytkownika (124)
  
  • Przykład: program GetPID (125)
• 5.9 Uzyskiwanie szczegółowych informacji na temat procesu (127)
  
  • Przykład: wyliczanie procesów (128)
  • Przykład: uzyskiwanie linii polecenia procesu (129)
  • Przykład: uzyskiwanie środowiska procesu (131)
  • Przykład: uzyskiwanie pliku wykonywalnego, katalogu głównego oraz katalogu roboczego procesu (131)
  • Przykład: uzyskiwanie informacji na temat plików otwartych przez proces (132)
  • Przykład: uzyskiwanie szczegółowych informacji na temat procesu (134)
• 5.10 Ograniczanie działania procesu do pojedynczej instancji (136)
  
  • Przykład: program OneInst (137)
• 5.11 Ustalanie harmonogramu działania procesu (140)
  
  • Przykład: skrypt startdummy (141)
  • Przykład: program RunAt (141)
  • Przykład: program RunScheduled (144)
• 5.12 Uruchamianie procesu przez superużytkownika (149)

Rozdział 6. Obsługa komunikacji między procesami (151)

• 6.1 Podstawowa komunikacja przeprowadzana z użyciem sygnałów (152)
  
  • Przykład: program SigSender (154)
• 6.2 Uzyskiwanie opisów poprawnych sygnałów systemowych (157)
  
  • Przykład: program SigNames (157)
• 6.3 Tworzenie procedur obsługi sygnałów (158)
  
  • Przykład: program HndSender (158)
  • Funkcja sigaction oraz obiekt TSigAction (159)
  • Zarządzanie zestawami sygnałów (161)
  • Przykład: program HndRecvr (162)
• 6.4 Zabezpieczanie przed procesami zombie (165)
  
  • Przykład: program KillAllZombies (165)
• 6.5 Komunikacja z aplikacjami konsoli poprzez potoki (168)
  
  • Przykład: program PipeRead (169)
  • Przykład: program RunAt (jeszcze raz) (171)
• 6.6 Przekazywanie danych pomiędzy potomnym a nadrzędnym procesem GUI (172)
  
  • Przykład: PipeParent (173)
  • Przykład: PipeChild (176)
• 6.7 Przekazywanie danych pomiędzy niezależnymi procesami GUI (178)
  
  • Przykład: FIFOSender (179)
  • Przykład: FIFORecvr (181)
• 6.8 Koordynowanie procesów za pomocą semaforów (183)
  
  • Praca z obiektami IPC (184)
  • Semafory (185)
  • Funkcje semaforów (185)
  • Tworzenie i otwieranie zestawów semaforów (186)
  • Kontrolowanie semaforów za pomocą funkcji semctl (187)
  • Przykład: program OneAtATime (192)
• 6.9 Wysoko wydajna komunikacja przeprowadzona z użyciem pamięci wspólnej (195)
  
  • Funkcje pamięci wspólnej (195)
  • Tworzenie i otwieranie obiektów pamięci wspólnej (196)
  • Kontrolowanie obiektów pamięci wspólnej (197)
  • Przykład: program shmTalk (198)
• 6.10 Komunikowanie się poprzez kolejki komunikatów (202)
  
  • Funkcje kolejek komunikatów (202)
  • Tworzenie i otwieranie kolejek komunikatów (203)
  • Kontrolowanie kolejek komunikatów (203)
  • Wysyłanie komunikatów (205)
  • Odbieranie komunikatów (206)
  • Praca z różnymi rodzajami komunikatów (207)
  • Kolejki komunikatów i wskaźniki (209)
  • Przykład: prosty dziennik debugowania (209)

Rozdział 7. Korzystanie z systemu plików (213)

• 7.1 Sprawdzanie uprawnień dla pliku (213)
  
  • Przykład: program GetPermissions (214)
• 7.2 Definiowanie uprawnień dla pliku (216)
  
  • Przykład: program SetPermissions (216)
• 7.3 Implementacja blokowania plików danych na poziomie plików (218)
  
  • Przykład: program LockFile (219)
• 7.4 Implementacja blokowania plików danych na poziomie rekordów (222)
  
  • Polecenia blokowania pliku (222)
  • Przypadek hipotetyczny (224)
  • Przykład: program LockWriter (224)
  • Przykład: program LockReader (228)
• 7.5 Uzyskiwanie atrybutów i informacji na temat pliku (234)
  
  • Przykład: program FileInfo (236)
• 7.6 Montowanie innych systemów plików (239)
  
  • Przykład: program MountTool (242)

Rozdział 8. Pomoc online (247)

• Architektura systemu pomocy (247)
  
• 8.1 Tworzenie prostej przeglądarki pomocy (248)
  
  • Przykład: klasa TSimpleHelpViewer (250)
• 8.2 Dodawanie pomocy do aplikacji (255)
  
  • Przykład: dodawanie pomocy do aplikacji (257)
• 8.3 Współpraca z zewnętrznym systemem pomocy (258)
  
  • Formularze SimpleHelp (259)
  • Format plików pomocy (259)
  • Przykład: implementowanie systemu pomocy SimpleHelp (260)
  • Przyszłość pomocy w Kyliksie (267)

Rozdział 9. Szuflada (269)

• 9.1 Uzyskiwanie listy zalogowanych użytkowników (270)
  
  • Przykład: program LogUser (272)
• 9.2 Sprawdzanie nie odczytanej poczty (274)
  
  • Przykład: program CheckMail (275)
• 9.3 Wysyłanie poczty pod adresy lokalne (283)
  
  • Przykład: program PipeMail (284)
• 9.4 Użycie programu sendmail z aplikacji (287)
  
  • Wysyłanie za pomocą programu sendmail (287)
  • Przykład: program FileMail (288)
• 9.5 Posługiwanie się ósemkowymi maskami uprawnień (292)
  
  • Przykład: program OctalConv (292)
• 9.6 Uruchamianie programu jako superużytkownik (ponownie) (296)
  
  • Dziedziczenie i środowisko (297)
  • Przykład: zmiana konfiguracji użytkownika (299)
  • Przykład: skrypt runsu1 (299)
  • Przykład: skrypt runsu2 (300)
• 9.7 Wykorzystanie dzienników systemowych do debugowania (301)
  
  • Systemowe procedury dzienników (302)
  • Ukryty demon (303)
  • Przykład: program SysLog (305)

Skorowidz (309)