• Korzystanie ze środowiska Eclipse
• Tworzenie programów w Javie w środowisku Eclipse
• Rozbudowa możliwości Eclipse za pomocą dodatkowych modułów

Eclipse to nie tylko doskonałe zintegrowane środowisko do tworzenia aplikacji w języku Java. To także platforma do tworzenia i integracji narzędzi programistycznych, umożliwiająca zbudowanie kompletnego warsztatu pracy zarówno dla pojedynczego programisty, jak i dla całego zespołu pracującego nad wspólnym projektem. Idea środowiska Eclipse została zainicjowana przez giganty rynku IT -- firmy, które zdecydowały się na stworzenie uniwersalnego narzędzia, umożliwiającego dostosowanie sposobu pracy z nim do wymagań różnych typów projektów. Eclipse to narzędzie zbudowane w oparciu o potrzeby programistów.

Książka "Eclipse. Przewodnik programisty" opisuje nie tylko środowisko Eclipse i sposoby zastosowania go w codziennej pracy twórcy oprogramowania. Przedstawia również metody rozbudowania go o dodatkowe moduły zwiększające jego możliwości i przydatność do konkretnego zadania. Autorzy książki, wykorzystując swoje doświadczenie zarówno w stosowaniu, jak i w nauczaniu Eclipse, pokazują, jak można dostosowywać platformę w celu zwiększenia efektywności i wydajności pracy oraz jak unikać najczęściej pojawiających się błędów i problemów.

• Podstawowe wiadomości o Eclipse -- interfejs, konfiguracja i połączenie z innymi aplikacjami
• Pakiet Java Development Tools
• Testowanie i usuwanie błędów aplikacji stworzonych za pomocą Eclipse
• Praca zespołowa -- współpraca Eclipse z systemem CVS
• Zarządzanie konfiguracją Eclipse
• Architektura środowiska Eclipse
• Tworzenie modułów rozszerzających
• Okna dialogowe, kreatory i widoki
• Architektura projektów
• Tworzenie pakietów i systemów pomocy dla użytkowników
• Wykorzystanie technologii COM i OLE

Dodatkowe ćwiczenia przedstawiają sposoby wykonania najbardziej typowych zadań związanych z obsługą środowiska Eclipse.

O Autorach:
Sherry Shavor, Jim D'Anjou, Scott Fairbrother, Dan Kehn oraz Pat McCarthy są projektantami oprogramowania zatrudnionymi w firmie IBM. Są również członkami IBM Eclipse Jumpstart Team -- zespołu, którego zadaniem jest promocja Eclipse i nauczanie sposobów wykorzystania tej platformy wśród społeczności programistów oraz partnerów biznesowych firmy IBM.
John Kellerman jest jednym z twórców projektu Eclipse oraz szefem zespołu pracującego nad Eclipse w firmie IBM.

Osoby które kupowały "Eclipse. Podręcznik programisty", wybierały także:

• DevOps w praktyce. Kurs video. Jenkins, Ansible, Terraform i Docker 190,00 zł, (39,90 zł -79%)
• Wyrażenia regularne od podstaw 39,67 zł, (11,90 zł -70%)
• Projektowanie systemów rozproszonych. Wzorce i paradygmaty dla skalowalnych, niezawodnych usług 39,67 zł, (11,90 zł -70%)
• Zrozum struktury danych. Algorytmy i praca na danych w Javie 39,67 zł, (11,90 zł -70%)
• Kosymulacja. Elastyczne projektowanie i symulacja wielodomenowa 38,39 zł, (11,90 zł -69%)

Spis treści

Eclipse. Podręcznik programisty -- 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)