Eclipse. Podręcznik programisty (ebook)(audiobook)(audiobook)

Spis treści

O Autorach (17)


Przedmowa (19)


Wstęp (21)


• Geneza książki (21)
• Cele (21)
• Czytelnicy (22)
• Organizacja (23)
• Konwencje stosowane w książce (24)
• Zawartość płyty CD-ROM (24)

Część I Eclipse jako środowisko programistyczne (25)


Rozdział 1. Poznajemy Eclipse (27)


• Eclipse a nowe wyzwania twórców aplikacji (28)
• Czym właściwie jest Eclipse? (30)
• Eclipse jako narzędzie do tworzenia aplikacji w Javie (30)
• Eclipse jako platforma integracyjna (32)
• Eclipse jako społeczność (34)
• Licencja CPL (35)
• Pobranie i instalacja (36)
• Pierwszy rzut oka na środowisko (36)
• Organizacja projektów (38)
• Słów kilka do użytkowników IBM VisualAge (39)
• Podsumowanie (39)
• Bibliografia (40)

Rozdział 2. Używamy Eclipse (41)


• Pierwsze kroki (41)
• Ojej! (42)
• Tworzenie pierwszego projektu (42)
• Organizacja interfejsu użytkownika (45)
• Parametry środowiska (46)
• Posługiwanie się interfejsem użytkownika (47)
• Podstawowe operacje (48)
• Lista zadań (53)
• Fiszki (ang. bookmarks) (55)
• System pomocy (55)
• Zarządzanie składnikami projektów (60)
• Przestrzeń projektów (60)
• Inne właściwości projektów (66)
• Import i eksport zasobów (68)
• Przenoszenie zasobów (70)
• Edytor (71)
• Drukowanie (71)
• Konfiguracja Eclipse (71)
• Perspektywy (72)
• Wiele kopii Eclipse (74)
• Konfiguracja JRE (75)
• Eclipse a inne aplikacje (76)
• System pomocy (79)
• Wydajność (81)
• Inne parametry konfiguracyjne (82)
• Pozycja Workbench (83)
• Pozycja External Tools (84)
• Ćwiczenia (84)
• Podsumowanie (85)

Rozdział 3. Java Development Tools (87)


• Pierwsze kroki z JDT (88)
• Interfejs użytkownika JDT (88)
• Podstawowe operacje (89)
• Wyszukiwanie (91)
• Pisanie kodu źródłowego (93)
• Asystent wprowadzania (96)
• Generowanie kodu (99)
• Nawigacja wśród komunikatów o błędach (101)
• Szybka naprawa błędów (101)
• Refaktoring (102)
• Przeglądanie dokumentacji projektu (105)
• Szablony kodu (106)
• Wydzielenie łańcuchów tekstowych (108)
• Generowanie dokumentacji Javadoc (111)
• Korzystanie z alternatywnego JRE (112)
• Uruchamianie programów (114)
• Polecenie Run (115)
• Konfiguracja uruchomieniowa (116)
• Strona brudnopisu (117)
• Składniki projektów JDT (118)
• Dalsze szczegóły dotyczące projektów (118)
• Tworzenie projektów Java (120)
• Tworzenie folderów (123)
• Tworzenie klas i interfejsów (123)
• Import projektów Java (124)
• Lokalna historia plików źródłowych Java (124)
• Poprawa wydajności narzędzi JDT (125)
• Inne cechy widoków i perspektyw JDT (126)
• Filtrowanie zawartości widoków (126)
• Przeglądarka pakietów (127)
• Widok hierarchii (127)
• Widok Tasks (128)
• Widok Search (129)
• Perspektywa Java Type Hierarchy (129)
• Perspektywa Java Browsing (130)
• Ćwiczenia (131)
• Podsumowanie (131)

Rozdział 4. Śledzenie działania aplikacji (133)


• Perspektywa Debug (134)
• Podstawowe operacje (135)
• Wstawienie punktu kontrolnego (135)
• Rozpoczęcie sesji usuwania błędów (135)
• Sterowanie wykonywaniem programu (135)
• Analiza bieżącego stanu programu (136)
• Dodatkowe możliwości debugera (137)
• Wyrażenia (137)
• Modyfikacja wartości zmiennej (138)
• Edytor w perspektywie Debug (138)
• Śledzony cel (ang. debug target) (139)
• Punkty kontrolne (140)
• Punkty kontrolne dotyczące wyjątku (143)
• Punkty kontrolne dotyczące metody (143)
• Punkty kontrolne dotyczące pola (144)
• Widok konsoli (144)
• Konfiguracja uruchomieniowa debugera (144)
• Podłączanie kodu źródłowego (145)
• Modyfikacja kodu "na gorąco" (146)
• Zdalne usuwanie błędów (147)
• Ćwiczenia (149)
• Podsumowanie (149)

Rozdział 5. Eclipse a praca zespołowa (151)


• Obsługa CVS w Eclipse (152)
• Podstawy pracy zespołowej w Eclipse (154)
• Obsługa pracy zespołowej w Eclipse (154)
• Organizacja pracy zespołowej (155)
• CVS dla początkujących (155)
• Najważniejsze pojęcia CVS (156)
• Wersje składników projektu (156)
• Aktualizacja (157)
• Zatwierdzanie zmian (157)
• Zarządzanie wersjami projektu (157)
• Rozgałęzianie projektu (158)
• Numery wersji w ramach gałęzi projektu (159)
• Pliki binarne (159)
• Interfejs obsługi CVS z poziomu Eclipse (159)
• Perspektywa CVS Repository Exploring (159)
• Widok CVS Repositories (160)
• Widok CVS Resource History (163)
• Widok CVS Console (163)
• Wygląd elementów projektów znajdujących się w repozytorium (164)
• Polecenia menu Team (165)
• Widok Synchronize (165)
• Równoległa modyfikacja plików (167)
• Typowe scenariusze (168)
• Zmiana nazwy, przesunięcie i usunięcie składnika projektu (168)
• Wycofanie zmiany (169)
• Gałęzie projektu (170)
• Inne funkcje (171)
• Plik aktualizacyjny (171)
• Zestaw projektów (171)
• Odłączanie i ponowne definiowanie połączenia (172)
• Ćwiczenia (172)
• Podsumowanie (173)
• Bibliografia (173)

Rozdział 6. Zarządzanie konfiguracją Eclipse (175)


• Struktura instalacji Eclipse (176)
• Katalog macierzysty Eclipse (176)
• Rola pluginów (177)
• Rola pakietów (177)
• Menedżer aktualizacji (178)
• Identyfikacja zainstalowanych pakietów (178)
• Menedżer aktualizacji - wprowadzenie (180)
• Źródła instalacji i aktualizacji pakietów (180)
• Podgląd bieżącej konfiguracji (182)
• Widok Install Configuration (183)
• Widok Preview (184)
• Widok Feature Updates (185)
• Procesy dotyczące konfiguracji (185)
• Pierwsze uruchomienie Eclipse (186)
• Kolejne uruchomienia platformy (186)
• Ustalenie konfiguracji domyślnej (187)
• Lista domyślnych pakietów (188)
• Współdzielenie instalacji Eclipse (189)
• Ćwiczenia (189)
• Podsumowanie (190)

Część II Rozbudowa Eclipse (191)


Rozdział 7. Architektura Eclipse (193)


• Punkty rozszerzenia (194)
• Platforma Eclipse (197)
• Szablony składników interfejsu użytkownika (197)
• Biblioteka Standard Widget Toolkit (198)
• Biblioteka JFace (199)
• Obszar roboczy (202)
• Dostęp do przestrzeni projektów i zasobów (203)
• Podsumowanie (204)
• Bibliografia (204)

Rozdział 8. Podstawy tworzenia pluginów (205)


• Pierwsze kroki (206)
• Scenariusze integracji (207)
• Rozpowszechnianie własnego narzędzia (209)
• Rozszerzenia i punkty rozszerzenia (209)
• Podstawowe kroki implementacji pluginu (212)
• Plik manifestu pluginu (214)
• Klasa pluginu (216)
• Instalacja pluginu (218)
• Środowisko PDE (219)
• Edytor i widoki PDE (220)
• Platforma testowa (222)
• Tworzenie i uruchomienie pluginu (223)
• Praca na jednym stanowisku a praca zespołowa (225)
• Ćwiczenia (225)
• Podsumowanie (225)
• Bibliografia (226)

Rozdział 9. Źródła akcji (227)


• Punkty rozszerzenia definiujące źródła akcji (228)
• Podstawy definiowania źródeł akcji (229)
• Interfejs programowy obsługujący akcje (229)
• Źródła akcji w pliku manifestu (231)
• Dodanie akcji do menu i listwy narzędziowej (232)
• Filtrowanie wyświetlanych akcji (234)
• Filtrowanie związane z typem obiektu (234)
• Filtrowanie oparte na warunkach (235)
• Dodawanie akcji do menu i listwy narzędziowej obszaru roboczego (237)
• Menu i listwa narzędziowa niezależna od perspektywy (239)
• Dodawanie akcji do menu i listwy narzędziowej widoku (239)
• Dodawanie akcji związanej z edytorem (241)
• Dodawanie akcji do menu kontekstowego widoku i edytora (241)
• Menu kontekstowe widoku (242)
• Menu kontekstowe edytora (242)
• Menu kontekstowe elementu widoku (243)
• Podsumowanie (244)
• Bibliografia (244)

Rozdział 10. Biblioteka Standard Widget Toolkit (245)


• Struktura aplikacji SWT (246)
• Podstawowe komponenty SWT (248)
• Określanie stylu komponentu (249)
• Obsługa zdarzeń (250)
• Rozmieszczenie komponentów za pomocą menedżerów układu (252)
• Menedżer układu FillLayout (254)
• Menedżer układu RowLayout (254)
• Menedżer układu GridLayout (255)
• Menedżer układu FormLayout (258)
• Obsługa błędów (261)
• Konieczność zwalniania zasobów (262)
• Wątki obsługujące interfejs użytkownika i pozostałe zadania (263)
• Pakiety SWT (265)
• Ćwiczenia (266)
• Podsumowanie (267)
• Bibliografia (267)

Rozdział 11. Okna dialogowe i kreatory (269)


• Okna dialogowe - powszechny element aplikacji (269)
• Punkt wyjścia, czyli szablon (270)
• Punkty rozszerzenia dla okien dialogowych i kreatorów (271)
• Okna dialogowe ogólnego zastosowania (274)
• Tworzenie własnej strony parametrów (275)
• Definicja rozszerzenia dotyczącego strony parametrów (276)
• Implementacja strony parametrów (277)
• Przygotowanie interfejsu użytkownika strony (278)
• Określenie sposobu zapisu i odczytu własności (279)
• Ustalenie domyślnych wartości parametrów (280)
• Dodawanie kodu zarządzającego wartościami parametrów (281)
• Obsługa zdarzeń na stronie parametrów (284)
• Edytor pól jako typ strony parametrów (284)
• Tworzenie własnej strony właściwości (287)
• Definicja rozszerzenia dotyczącego strony właściwości (288)
• Implementacja klasy strony (290)
• Definicja wyglądu strony (291)
• Kod odpowiadający za logikę strony (291)
• Zasady przyporządkowywania właściwości (293)
• Implementacja własnego okna dialogowego Properties (293)
• Kreatory tworzenia nowych zasobów, importu oraz eksportu (294)
• Definicja rozszerzenia (295)
• Implementacja klasy kreatora (296)
• Implementacja strony (stron) kreatora (297)
• Dopasowanie wyglądu strony (stron) kreatora (299)
• Nawigacja wśród stron kreatora (300)
• Predefiniowane strony kreatora (301)
• Wywoływanie kreatora z poziomu kodu źródłowego (304)
• Zapis cech okna dialogowego (304)
• Ćwiczenia (305)
• Podsumowanie (305)
• Bibliografia (306)

Rozdział 12. Widoki (307)


• Architektura i działanie widoku (307)
• Podstawowe etapy implementacji widoku (311)
• Definicja wyglądu widoku (311)
• Dodanie rozszerzenia w pliku plugin.xml (312)
• Utworzenie klasy widoku (312)
• Definicja dostawcy treści (313)
• Definicja dostawcy prezentacji (315)
• Połączenie przeglądarki z modelem (316)
• Synchronizacja modelu i widoku (317)
• Obsługa zdarzeń polegających na wyborze elementu (318)
• Filtrowanie widoku (319)
• Sortowanie widoku (321)
• Dodawanie opcji widoku (322)
• Obsługa poleceń globalnych (326)
• Dekoratory (326)
• Współpraca między widokami (328)
• Widok Properties (328)
• Ćwiczenia (332)
• Podsumowanie (333)
• Bibliografia (333)

Rozdział 13. Edytory (335)


• Architektura i zachowanie edytora (335)
• Podstawowe etapy implementacji edytora (336)
• Definicja wyglądu edytora (337)
• Definicja kreatora odpowiadającego za tworzenie nowych zasobów danego typu (opcjonalnie) (337)
• Deklaracja rozszerzenia dodana do pliku manifestu plugin.xml (338)
• Utworzenie klasy edytora (339)
• Ustanowienie modelu odpowiadającego za edytowane dane (340)
• Definicja dostawcy treści (341)
• Definicja dostawcy prezentacji (341)
• Obsługa modyfikacji treści znajdującej się w edytorze (341)
• Obsługa zapisu treści edytora (341)
• Połączenie edytora z modelem (342)
• Synchronizacja modelu i edytora (342)
• Obsługa zaznaczania fragmentu treści (343)
• Dodawanie akcji edytora (343)
• Połączenie edytora z widokiem Outline (347)
• Ćwiczenia (349)
• Podsumowanie (349)
• Bibliografia (349)

Rozdział 14. Perspektywy (351)


• Perspektywy (351)
• Tworzenie perspektywy (352)
• Rozszerzanie perspektywy (353)
• Ćwiczenia (354)
• Podsumowanie (354)
• Bibliografia (354)

Rozdział 15. Obsługa zasobów przestrzeni projektów (355)


• Pojęcia podstawowe (355)
• Model fizyczny (356)
• Model logiczny (357)
• Współpraca modelu zasobów i systemu plików (358)
• API przestrzeni projektów (359)
• Katalog główny przestrzeni projektów (360)
• Kontenery zasobów (ang. resource containers) (361)
• Synchronizacja modelu i systemu plików (361)
• Obiekt projektu (363)
• Obiekt zasobu (364)
• Obiekt ścieżki (365)
• Obiekty folderu i pliku (368)
• Przeglądanie drzewa zasobów (369)
• Własności zasobów (370)
• Własności tymczasowe (371)
• Własności trwałe (371)
• Obsługa zdarzeń przestrzeni projektów (372)
• Śledzenie zmian za pomocą API przestrzeni projektów (373)
• Dodanie słuchacza zdarzeń (374)
• Przeglądanie informacji o zmienionych zasobach (376)
• Szczegóły modyfikacji zasobu (378)
• Zarządzanie zdarzeniami modyfikacji zasobów (379)
• Korzystanie ze zdarzeń w celu zapisywania dodatkowych danych (380)
• Zdarzenia związane z zapisem (380)
• Definicja obiektu zapisu danych (381)
• Ćwiczenia (383)
• Podsumowanie (383)
• Bibliografia (384)

Rozdział 16. Natura projektu i przekształcanie zasobów (385)


• Dodanie nowych funkcji przetwarzających projekt (385)
• Rozszerzanie obsługi zasobów przestrzeni projektów (386)
• Projekt i jego opis (386)
• Definiowanie i implementacja natury (388)
• Tworzenie natury rozszerzającej konfigurację projektu (388)
• Dodawanie natury do projektu (389)
• Relacje pomiędzy naturą a budowniczym (391)
• Obrazek symbolizujący naturę projektu (392)
• Implementacja budowniczego (393)
• Proces transformacji zasobów (393)
• Kiedy korzystać z budowniczego? (394)
• Definicja budowniczego realizującego transformację przyrostową (396)
• Ćwiczenia (399)
• Podsumowanie (400)
• Bibliografia (400)

Rozdział 17. Znaczniki zasobów (401)


• Pojęcie znacznika (401)
• Nadawanie cech zasobom za pomocą znaczników (403)
• Tworzenie nowych znaczników (404)
• Znaczniki pomocy i asystenta wprowadzania (406)
• Ćwiczenia (406)
• Podsumowanie (407)
• Bibliografia (407)

Rozdział 18. Źródła akcji - uzupełnienie (409)


• Przykłady źródeł akcji i ich obsługa (409)
• Dodatkowe wskazówki (421)
• Podsumowanie (424)

Rozdział 19. Zaawansowane tworzenie pluginów (425)


• Ładowarka klas pluginów (425)
• Wykrywanie w czasie działania i opóźnione ładowanie pluginów (426)
• "Ziarnistość" pluginów (428)
• Fragmenty pluginów (429)
• Fragmenty i pakiety językowe (430)
• Fragmenty jako zawartość zależna od platformy (430)
• Podsumowanie (431)
• Bibliografia (432)

Rozdział 20. Tworzenie nowych punktów rozszerzeń - w jaki sposób inni mogą rozbudowywać Twoje pluginy? (433)


• Przegląd architektury Eclipse - raz jeszcze (434)
• Zależności pomiędzy punktami rozszerzenia i rozszerzeniami (434)
• Rejestr pluginów - oficjalna lista aktywnych pluginów, rozszerzeń i punktów rozszerzeń (436)
• Jak definiować nowe punkty rozszerzeń? (437)
• Wybór istniejącego kodu, który inni będą mogli rozbudowywać lub konfigurować (437)
• Deklarowanie nowego punktu rozszerzenia (439)
• Definiowanie interfejsu określającego oczekiwane zachowanie (440)
• Przetwarzanie informacji dotyczących punktu rozszerzenia, zgromadzonych w rejestrze pluginów (443)
• Wywoływanie odpowiednich metod zgodnie ze zdefiniowanym wcześniej kontraktem (interfejsem) (445)
• Jak skorzystać z opartego na schematach kreatora nowych rozszerzeń? (447)
• Dlaczego warto definiować schemat? (448)
• Edytor schematów (448)
• Ćwiczenia (449)
• Podsumowanie (450)
• Bibliografia (450)

Rozdział 21. W razie problemów (451)


• Diagnostyka pluginów - informacje systemowe i konfiguracyjne (453)
• Obiekty stanu - kolektor stanu (ang. status collector) (453)
• Przykład wykorzystania obiektu MultiStatus (454)
• Obsługa wyjątków - wykrywanie błędów (455)
• Okna dialogowe błędów - dostarczanie szczegółowego stanu w komunikatach o błędach (455)
• Przykład okna dialogowego błędu (456)
• Śledzenie wykonywania - narzędzie diagnostyki działania (457)
• Przykład zastosowania mechanizmów śledzenia (459)
• Wykorzystanie śledzenia w środowisku produkcyjnym (460)
• Diagnostyka - obszerny dziennik błędów (461)
• Rejestracja błędów - zapisywanie informacji w dzienniku błędów (461)
• Dodawanie komunikatów o błędach (462)
• Ćwiczenia (462)
• Podsumowanie (462)

Rozdział 22. Tworzenie pakietów (463)


• Wszystko na temat pakietów (464)
• Typy pakietów (464)
• Określanie struktury przy użyciu pakietów (465)
• Definicja pakietu (466)
• Manifest pakietu (466)
• Określanie wymaganych pluginów oraz pakietów wewnętrznych (467)
• Reguły dopasowujące pluginy na podstawie numeru wersji (470)
• Obsługa serwisowa pakietów (471)
• Identyfikacja pakietów (472)
• Treści identyfikujące pakietów i pluginów (472)
• Określanie pakietu głównego (473)
• Prezentacja w interfejsie użytkownika informacji identyfikujących pakiet i produkt (474)
• Rozszerzanie możliwości Eclipse (476)
• Tworzenie pakietu nadającego się do instalacji (477)
• Tworzenie własnego produktu opierającego się na platformie Eclipse (478)
• Tworzenie rozszerzeń do innych produktów (479)
• Udostępnianie pakietów instalowanych za pomocą menedżera aktualizacji (480)
• Zastosowanie PDE do tworzenia i rozpowszechniania pakietów (482)
• Ćwiczenia (485)
• Podsumowanie rozdziału (485)
• Bibliografia (485)

Rozdział 23. Dostarczanie pomocy (487)


• Integracja dokumentacji (488)
• Tworzenie dokumentacji w formacie HTML (490)
• Deklarowanie rozszerzenia (490)
• Tworzenie plików spisu treści (491)
• Dokumentacja dołączona do Eclipse (494)
• Tworzenie pomocy kontekstowej (494)
• Deklarowanie rozszerzenia pomocy kontekstowej (495)
• Definiowanie zawartości okienka Infopop (495)
• Kojarzenie okienka Infopop z kontekstem interfejsu użytkownika (495)
• Uruchamianie systemu pomocy w innych programach (497)
• Dostosowywanie systemu pomocy do własnych wymagań (498)
• Ćwiczenia (499)
• Podsumowanie (499)
• Bibliografia (499)

Rozdział 24. Współdziałanie z technologiami OLE i ActiveX (501)


• Obsługa technologii COM (502)
• Bezpośrednie dokumenty OLE (503)
• Bezpośrednie elementy sterujące ActiveX (503)
• Obsługa kontenera COM (503)
• Tworzenie obiektu OleFrame (504)
• Tworzenie obiektu OleClientSite (504)
• Aktywacja obiektu OLE (505)
• Deaktywacja obiektu OLE (506)
• Obsługa edytorów OLE (506)
• Tworzenie obiektu OleControlSite (507)
• Aktywacja obiektu OleControlSite (508)
• Automatyzacja OLE - dostęp do rozszerzonych zachowań (508)
• Polecenie exec (508)
• Interfejs IDispatch (510)
• Metody (511)
• Wywołanie bez parametrów (511)
• Typy Variant (512)
• Wywołanie z przekazaniem parametrów (513)
• Właściwości (513)
• Słuchacze zdarzeń oraz słuchacze zdarzeń dotyczących właściwości (515)
• Ćwiczenia (516)
• Podsumowanie (516)
• Bibliografia (517)

Rozdział 25. Współpraca z biblioteką Swing (519)


• Wprowadzenie do zagadnień integracji biblioteki Swing i SWT (520)
• Integracja uruchamiania i edycji (520)
• Tryby wywołań (521)
• Zwiększanie atrakcyjności produktów (522)
• Przykładowy edytor ABCEditor - wywołanie wewnątrzprocesowe (523)
• Szczegóły implementacji - wywołanie wewnątrzprocesowe (523)
• Ćwiczenia (527)
• Podsumowanie (528)
• Bibliografia (528)

Rozdział 26. Rozbudowa narzędzi do pisania programów w Javie (529)


• Do czego służy JDT? (530)
• Model elementów Javy (532)
• Wykorzystanie możliwości JDT (534)
• Klasa JavaCore (534)
• Klasa JavaUI (538)
• Klasa ToolFactory (539)
• Kompilacja kodu źródłowego Javy (540)
• Analiza kodu źródłowego Javy (540)
• Abstrakcyjne drzewo składni (541)
• Szczegółowa analiza kodu źródłowego Javy (546)
• Operacje na kodzie źródłowym Javy (550)
• Proste modyfikacje kodu źródłowego elementów Javy (550)
• Bardziej złożone modyfikacje kodu źródłowego (551)
• W jakich miejscach JDT rozbudowuje możliwości Eclipse? (554)
• Rozbudowa interfejsu użytkownika JDT (554)
• Dodawanie akcji do widoków (555)
• Dodawanie akcji do edytora (557)
• Rozbudowa menu kontekstowego elementów Javy (558)
• Rozbudowa menu kontekstowych konkretnego widoku lub edytora (558)
• Rozbudowa akcji globalnych (559)
• Stosowanie okien dialogowych JDT (559)
• Ćwiczenia (560)
• Podsumowanie (560)
• Bibliografia (560)

Rozdział 27. Tworzenie edytora tekstów przy użyciu komponentu JFace Text (561)


• Standardowe funkcje edytora tekstów (562)
• Edycja i przeglądanie tekstu (562)
• Standardowe opcje menu i przyciski paska narzędzi (563)
• Standardowa reprezentacja znaczników (563)
• Konfiguracja edytora - punkty dostosowywania (564)
• Czym jest asystent wprowadzania? (564)
• Czym jest kolorowanie składni? (565)
• Czym jest formatowanie zawartości? (566)
• Inne możliwości dostosowywania edytora (566)
• Tajniki wykorzystania edytora tekstów (567)
• Klasa AbstractTextEditor (567)
• Klasa TextViewer (568)
• Zależności klasy AbstractTextEditor (569)
• Klasa Document (569)
• Klasa DocumentProvider (571)
• Zależności typu model-widok-kontroler (572)
• Klasa DocumentPartitioner (572)
• Klasa SourceViewerConfiguration (573)
• Jak stworzyć prosty edytor kodu źródłowego? (574)
• Etap 1. Tworzenie prostego edytora (574)
• Etap 2. Dodawanie asystenta wprowadzania (580)
• Etap 3. Dodawanie kolorowania składni (584)
• Etap 4. Definiowanie formatowania zawartości (589)
• Ćwiczenia (592)
• Podsumowanie (592)
• Bibliografia (592)

Część III Ćwiczenia (593)


Rozdział 28. Ćwiczenie 1. Obsługa Eclipse (595)


• Punkt 1. Pierwszy projekt (595)
• Punkt 2. Edytory i widoki (600)
• Punkt 3. Posługiwanie się zasobami (607)
• Punkt 4. Perspektywy (610)
• Punkt 5. Posługiwanie się wieloma oknami Eclipse (612)
• Punkt 6. System pomocy (614)

Rozdział 29. Ćwiczenie 2. Posługiwanie się narzędziami Java Development Tools (619)


• Punkt 1. Hello World (620)
• Punkt 2. Mechanizm Quick Fix (621)
• Punkt 3. Tworzenie kodu (628)
• Punkt 4. Refaktoring (632)
• Punkt 5. Konfiguracje uruchomieniowe (639)
• Punkt 6. Kod JRE 1.4 (645)

Rozdział 30. Ćwiczenie 3. Uruchamianie programów w języku Java (649)


• Punkt 1. Śledzenie (650)
• Punkt 2. Śledzenie wątków (657)
• Punkt 3. Śledzenie zdalnych programów (661)

Rozdział 31. Ćwiczenie 4. Eclipse i CVS (665)


• Konfiguracja ćwiczenia (666)
• Tworzenie projektu w lokalnej przestrzeni projektów (666)
• Punkt 1. Pierwsze kroki (668)
• Określenie preferencji pracy zespołowej i systemu CVS (668)
• Zdefiniowanie położenia repozytorium CVS (669)
• Przekazanie projektu pod kontrolę systemu CVS (670)
• Umieszczenie zawartości projektu w systemie CVS (673)
• Tworzenie wersji projektu (674)
• Punkt 2. Aktualizacja, zatwierdzanie zmian i rozwiązywanie konfliktów (675)
• Modyfikacja kodu projektu (675)
• Przekazywanie zmian do systemu CVS (677)
• Wprowadzanie dodatkowych zmian w projekcie (678)
• Rozwiązywanie konfliktów w systemie CVS (679)
• Punkt 3. Rozgałęzianie i scalanie (682)
• Proces rozgałęziania i scalania w Eclipse (682)
• Aktualizacja projektu i umieszczenie zmian w nowej gałęzi systemu CVS (683)
• Scalanie zmian przeprowadzonych w nowej gałęzi z gałęzią HEAD (686)
• Podsumowanie ćwiczenia (689)

Rozdział 32. Ćwiczenie 5. Modyfikacje konfiguracji za pomocą menedżera aktualizacji (691)


• Punkt 1. Instalacja nowych pakietów (691)
• Punkt 2. Wyłączanie pakietów (695)
• Punkt 3. Aktualizacje oczekujące i bezpośrednie modyfikacje konfiguracji (696)
• Punkt 4. Wyszukiwanie nowych lub zaktualizowanych pakietów (698)

Rozdział 33. Ćwiczenie 6. Tworzenie modułów rozszerzeń (703)


• Konfiguracja ćwiczenia (704)
• Przebieg ćwiczenia (705)
• Punkt 1. "Hello, World" w pięć minut lub nawet szybciej (705)
• Punkt 2. "Hello, World" krok po kroku (707)
• Punkt 3. Wykorzystanie uruchomieniowego obszaru roboczego (717)
• Punkt 4. Śledzenie działania pluginów w uruchomieniowym obszarze roboczym (719)
• Punkt 5. Eksploracja (a czasami także poprawianie) kodu platformy Eclipse (722)
• Punkt 6. Usuwanie typowych problemów (724)
• Podsumowanie ćwiczenia (727)

Rozdział 34. Ćwiczenie 7. Tworzenie i instalowanie pakietów Eclipse (729)


• Koncepcja ćwiczenia (729)
• Konfiguracja ćwiczenia (730)
• Sposób wykonania ćwiczenia (731)
• Punkt 1. Zadania twórcy pakietów Eclipse (731)
• Tworzenie plików JAR dla wybranych pluginów (731)
• Umieszczanie funkcji dostarczanych przez pluginy w pakiecie (735)
• Dodawanie informacji o marce produktu i pakietu (741)
• Przygotowanie dystrybucji pakietu (742)
• Wyodrębnienie pakietu instalacyjnego z przestrzeni projektów i implementacja źródła aktualizacji (744)
• Punkt 2. Zadania użytkownika platformy Eclipse (745)
• Instalacja nowego pakietu jako rozszerzenia istniejącego produktu (746)
• Dodawanie pakietu do istniejącej konfiguracji produktu ze źródła aktualizacji (750)
• Punkt 3. Zadania twórcy produktu (750)
• Implementacja produktu (751)
• Uruchamianie i kontrola instalacji własnego produktu (751)
• Podsumowanie ćwiczenia (752)

Skorowidz (753)

pokaż cały spis treści

ukryj recenzje