Leseprobe
Bernhard Steppan
Eclipse Rich Clients und Plug-ins
Modulare Desktop-Anwendungen mit Java entwickeln
ISBN (Buch): 978-3-446-43172-0
ISBN (E-Book): 978-3-446-43316-8
Weitere Informationen oder Bestellungen unter
http://www.hanser-fachbuch.de/978-3-446-43172-0
sowie im Buchhandel.
© Carl Hanser Verlag, München Inhalt
Vorwort ...... XVII
Teil I: RCP-Grundlagen ...... 1
1 Entwicklungsumgebung ...... 3 1.1 Einleitung ...... 3 1.2 Software-Voraussetzungen ...... 3 1.3 Java Runtime Environment ...... 3 1.4 Entwicklungsumgebung ...... 4 1.5 Eclipse e4 Tooling ...... 5 1.6 UI-Toolkits ...... 7 1.7 WindowBuilder ...... 8 1.8 Beispielprojekte ...... 9 1.9 Zusammenfassung ...... 11 1.10 Quellcode ...... 12 Links & Literatur ...... 12
2 Eclipse Rich Client Platform ...... 13 2.1 Einleitung ...... 13 2.2 Software-Voraussetzungen ...... 13 2.3 Historie ...... 13 2.4 Programmiermodell ...... 16 2.5 Module...... 17 2.6 Workspace...... 21 2.7 UI-Toolkits ...... 24 2.8 Workbench...... 24 2.9 Softwareaktualisierung ...... 26 2.10 Hilfesystem...... 27 VI Inhalt
2.11 Remote Application Platform...... 27 2.12 Zusammenfassung ...... 28 2.13 Quellcode ...... 29 Links & Literatur ...... 29
3 UI-Toolkits ...... 31 3.1 Einleitung ...... 31 3.2 Software-Voraussetzungen ...... 31 3.3 Programmiermodell ...... 31 3.4 PortableUIs...... 33 3.5 Abstract Window Toolkit ...... 34 3.6 Swing...... 35 3.7 Standard Widget Toolkit ...... 35 3.8 JFace ...... 42 3.9 Alternative UI-Toolkits ...... 44 3.10 Zusammenfassung ...... 44 3.11 Quellcode ...... 45 Links & Literatur ...... 45
4 Standard Widget Toolkit ...... 47 4.1 Einleitung ...... 47 4.2 Software-Voraussetzungen ...... 47 4.3 Programmiermodell ...... 47 4.4 Klasse »Display« ...... 48 4.5 Klasse »Shell« ...... 50 4.6 Dialoge...... 51 4.7 Control-Widgets ...... 52 4.8 Zusammenfassung ...... 66 4.9 Quellcode ...... 66 Links & Literatur ...... 66
5 JFace ...... 67 5.1 Einleitung ...... 67 5.2 Software-Voraussetzungen ...... 67 5.3 Programmiermodell ...... 67 5.4 Fenster...... 69 5.5 Dialoge...... 72 5.6 Mehrseitige Dialoge...... 79 5.7 Beispielprojekt...... 81 Inhalt VII
5.8 Zusammenfassung ...... 99 5.9 Quellcode ...... 99 Links & Literatur ...... 99
6 Layoutmanager...... 101 6.1 Einleitung ...... 101 6.2 Software-Voraussetzungen ...... 101 6.3 Programmiermodell ...... 101 6.4 Klasse »FillLayout« ...... 103 6.5 Klasse »GridLayout« ...... 105 6.6 Zusammenfassung ...... 110 6.7 Quellcode ...... 110 Links & Literatur ...... 111
Teil II: Eclipse RCP 3 ...... 113
7 Application...... 115 7.1 Einleitung ...... 115 7.2 Software-Voraussetzungen ...... 115 7.3 Programmiermodell ...... 115 7.4 UI-Entwurf...... 116 7.5 Core-Plug-in ...... 117 7.6 Plug-in-Konfiguration ...... 121 7.7 Run-Konfiguration ...... 125 7.8 Architektur der RCP-Anwendung ...... 127 7.9 Konfiguration der RCP-Anwendung ...... 134 7.10 Willkommensseite ...... 140 7.11 Refactoring ...... 142 7.12 Zusammenfassung ...... 143 7.13 Quellcode ...... 143 Links & Literatur ...... 143
8 Programmlogik ...... 145 8.1 Einleitung ...... 145 8.2 Software-Voraussetzungen ...... 145 8.3 Programmiermodell ...... 145 8.4 Entwurf der Programmlogik ...... 146 8.5 Model-Plug-in ...... 148 8.6 Zusammenfassung ...... 155 8.7 Quellcode ...... 155 Links & Literatur ...... 155 VIII Inhalt
9 Datenbankzugriff ...... 157 9.1 Einleitung ...... 157 9.2 Software-Voraussetzungen ...... 157 9.3 Programmiermodell ...... 158 9.4 Hypersonic DBMS ...... 158 9.5 Integration DBMS ...... 159 9.6 Logisches Datenmodell ...... 161 9.7 Physisches Datenmodell ...... 163 9.8 DAO-Plug-in ...... 163 9.9 Zusammenfassung ...... 179 9.10 Quellcode ...... 179 Links & Literatur ...... 179
10 Actions ...... 181 10.1 Einleitung ...... 181 10.2 Software-Voraussetzungen ...... 181 10.3 Programmiermodell ...... 181 10.4 UI-Entwurf...... 183 10.5 Menüleiste ...... 183 10.6 Symbolleiste ...... 184 10.7 Menü»Datei« ...... 184 10.8 Befehl »Neue Vokabel«...... 185 10.9 Befehl »Programm beenden« ...... 188 10.10 Menü »Training«...... 189 10.11 Befehl »Training starten« ...... 189 10.12 Menü »Fenster« ...... 191 10.13 Befehl »Neues Fenster« ...... 191 10.14 Befehl »Perspektive wählen«...... 192 10.15 Befehl »Trainingserfolg« ...... 194 10.16 Befehl »Trainingsstatistik« ...... 196 10.17 Befehl »Fenster auswählen« ...... 199 10.18 Menü»Hilfe«...... 199 10.19 Befehl »Willkommen« ...... 200 10.20 Befehl »Über Vocat« ...... 201 10.21 Zusammenfassung ...... 202 10.22 Quellcode ...... 202 Links & Literatur ...... 202 Inhalt IX
11 Commands und Handler ...... 203 11.1 Einleitung ...... 203 11.2 Software-Voraussetzungen ...... 203 11.3 Programmiermodell ...... 203 11.4 UI-Entwurf...... 206 11.5 Menüleiste ...... 206 11.6 Symbolleiste ...... 207 11.7 Menü»Datei« ...... 208 11.8 Befehl »Neue Vokabel«...... 208 11.9 Befehl »Programm beenden« ...... 212 11.10 Menü »Training«...... 213 11.11 Befehl »Training starten« ...... 213 11.12 Menü »Fenster« ...... 216 11.13 Befehl »Neues Fenster« ...... 216 11.14 Befehl »Perspektive wählen«...... 217 11.15 Befehl »Trainingserfolg« ...... 219 11.16 Befehl »Trainingsstatistik« ...... 222 11.17 Befehl »Fenster auswählen« ...... 226 11.18 Menü»Hilfe«...... 227 11.19 Befehl »Willkommen« ...... 227 11.20 Befehl »Über Vocat« ...... 228 11.21 Zusammenfassung ...... 228 11.22 Quellcode ...... 228 Links & Literatur ...... 228
12 Dialoge ...... 229 12.1 Einleitung ...... 229 12.2 Software-Voraussetzungen ...... 229 12.3 Programmiermodell ...... 229 12.4 UI-Entwurf...... 230 12.5 Dialog »Neue Vokabel« ...... 230 12.6 Dialog »Trainingsrichtung« ...... 235 12.7 Dialog »Training« ...... 238 12.8 Dialog »Über Vocat« ...... 246 12.9 Zusammenfassung ...... 247 12.10 Quellcode ...... 248 Links & Literatur ...... 248 X Inhalt
13 Views ...... 249 13.1 Einleitung ...... 249 13.2 Software-Voraussetzungen ...... 249 13.3 Programmiermodell ...... 249 13.4 View »LessonView«...... 252 13.5 View »Trainingserfolg«...... 258 13.6 View »Trainingsstatistik« ...... 260 13.7 View »Vokabular«...... 264 13.8 Zusammenfassung ...... 270 13.9 Quellcode ...... 270 Links & Literatur ...... 270
14 Editoren ...... 271 14.1 Einleitung ...... 271 14.2 Software-Voraussetzungen ...... 271 14.3 Programmiermodell ...... 271 14.4 Importdatei-Editor...... 273 14.5 Zusammenfassung ...... 281 14.6 Quellcode ...... 281 Links & Literatur ...... 281
15 Perspektiven ...... 283 15.1 Einleitung ...... 283 15.2 Software-Voraussetzungen ...... 283 15.3 Programmiermodell ...... 283 15.4 Standardperspektive ...... 284 15.5 Perspektive »Training« ...... 284 15.6 Perspektive »Administration« ...... 286 15.7 Klasse »AdminPerspective« ...... 287 15.8 Klasse »VocatWorkbenchAdvisor« ...... 288 15.9 Zusammenfassung ...... 289 15.10 Quellcode ...... 289 Links & Literatur ...... 289
16 Preferences ...... 291 16.1 Einleitung ...... 291 16.2 Software-Voraussetzungen ...... 291 16.3 Programmiermodell ...... 291 16.4 UI-Entwurf...... 292 Inhalt XI
16.5 Klasse »DatabasePreferenceConstants«...... 293 16.6 Klasse »DatabasePreferenceInitializer« ...... 294 16.7 Klasse »DatabasePreferencePage« ...... 295 16.8 Konfiguration ...... 296 16.9 Menüerweiterung ...... 298 16.10 Screenshot ...... 298 16.11 Zusammenfassung ...... 299 16.12 Quellcode ...... 299 Links & Literatur ...... 299
17 Modularisierung...... 301 17.1 Einleitung ...... 301 17.2 Software-Voraussetzungen ...... 301 17.3 Programmiermodell ...... 301 17.4 Admin-Plug-in ...... 302 17.5 Contributions ...... 304 17.6 Features...... 307 17.7 Zusammenfassung ...... 310 17.8 Quellcode ...... 310 Links & Literatur ...... 310
18 Internationalisierung ...... 311 18.1 Einleitung ...... 311 18.2 Software-Voraussetzungen ...... 311 18.3 Programmiermodell ...... 311 18.4 Selbstentwickelte Plug-ins ...... 312 18.5 Plug-ins von Drittanbietern ...... 316 18.6 Plattform-Plug-ins ...... 316 18.7 Formate...... 317 18.8 Zusammenfassung ...... 317 18.9 Quellcode ...... 318 Links & Literatur ...... 318
19 Verteilung ...... 319 19.1 Einleitung ...... 319 19.2 Software-Voraussetzungen ...... 319 19.3 Programmiermodell ...... 319 19.4 Exportfunktionen ...... 320 19.5 Softwareaktualisierung ...... 324 XII Inhalt
19.6 Zusammenfassung ...... 326 19.7 Quellcode ...... 326 Links & Literatur ...... 326
Teil III: Eclipse RCP 4 ...... 327
20 Application...... 329 20.1 Einleitung ...... 329 20.2 Software-Voraussetzungen ...... 329 20.3 Programmiermodell ...... 329 20.4 UI-Entwurf...... 335 20.5 Core-Plug-in ...... 336 20.6 Projektbestandteile ...... 338 20.7 Refactoring ...... 339 20.8 Zusammenfassung ...... 340 20.9 Quellcode ...... 340 Links & Literatur ...... 340
21 Programmlogik ...... 341 21.1 Einleitung ...... 341 21.2 Software-Voraussetzungen ...... 341 21.3 Programmiermodell ...... 341 21.4 Model-Plug-in importieren ...... 342 21.5 Zusammenfassung ...... 343 21.6 Quellcode ...... 343 Links & Literatur ...... 343
22 Datenbankzugriff ...... 345 22.1 Einleitung ...... 345 22.2 Software-Voraussetzungen ...... 345 22.3 Programmiermodell ...... 345 22.4 DAO-Plug-in importieren ...... 346 22.5 HSQLDB-Plug-in importieren...... 347 22.6 Zusammenfassung ...... 348 22.7 Quellcode ...... 348 Links &Literatur...... 348 Inhalt XIII
23 Commands und Handler ...... 349 23.1 Einleitung ...... 349 23.2 Software-Voraussetzungen ...... 349 23.3 Programmiermodell ...... 349 23.4 UI-Entwurf...... 350 23.5 Menüleiste ...... 351 23.6 Symbolleiste ...... 351 23.7 Menü»Datei« ...... 351 23.8 Befehl »Neue Vokabel«...... 352 23.9 Befehl »Programm beenden« ...... 354 23.10 Menü »Training«...... 356 23.11 Befehl »Training starten« ...... 356 23.12 Menü »Fenster« ...... 358 23.13 Befehl »Neues Fenster« ...... 358 23.14 Befehl »Perspektive« ...... 359 23.15 Befehl »Trainingserfolg« ...... 361 23.16 Befehl »Trainingsstatistik« ...... 362 23.17 Menü»Hilfe«...... 363 23.18 Befehl »Über Vocat« ...... 364 23.19 Zusammenfassung ...... 365 23.20 Quellcode ...... 365 Links & Literatur ...... 365
24 Dialoge ...... 367 24.1 Einleitung ...... 367 24.2 Software-Voraussetzungen ...... 367 24.3 Programmiermodel ...... 367 24.4 Dialog »Auswahl einer Perspektive« ...... 369 24.5 Dialog »Auswahl eines Fensters« ...... 373 24.6 Dialog »Über Vocat« ...... 375 24.7 Zusammenfassung ...... 377 24.8 Quellcode ...... 377 Links & Literatur ...... 378 XIV Inhalt
25 Views ...... 379 25.1 Einleitung ...... 379 25.2 Software-Voraussetzungen ...... 379 25.3 Programmiermodell ...... 379 25.4 SWT-Chart-Plug-in importieren ...... 380 25.5 Klasse »LessonView« ...... 380 25.6 Klasse »TrainingStatisticTableView« ...... 384 25.7 Klasse »TrainingSuccessChartView« ...... 387 25.8 Klasse »VocabularyView«...... 389 25.9 Zusammenfassung ...... 392 25.10 Quellcode ...... 393 Links & Literatur ...... 393
26 Editoren ...... 395 26.1 Einleitung ...... 395 26.2 Software-Voraussetzungen ...... 395 26.3 Programmiermodell ...... 395 26.4 UI-Entwurf...... 396 26.5 Klasse »ImportFileEditor« ...... 396 26.6 Konfiguration »ImportFileEditor« ...... 397 26.7 Befehl »Neue Importdatei«...... 398 26.8 Befehl »Importdatei öffnen« ...... 399 26.9 Befehl »Importdatei speichern« ...... 400 26.10 Zusammenfassung ...... 401 26.11 Quellcode ...... 401 Links & Literatur ...... 402
27 Perspektiven ...... 403 27.1 Einleitung ...... 403 27.2 Software-Voraussetzungen ...... 403 27.3 Programmiermodell ...... 403 27.4 Trainingsperspektive ...... 404 27.5 Administrationsperspektive ...... 407 27.6 Zusammenfassung ...... 409 27.7 Quellcode ...... 410 Links & Literatur ...... 410 Inhalt XV
28 Preferences ...... 411 28.1 Einleitung ...... 411 28.2 Software-Voraussetzungen ...... 411 28.3 Programmiermodell ...... 411 28.4 Klasse »ShowPreferencesHandler«...... 412 28.5 Zusammenfassung ...... 414 28.6 Quellcode ...... 414 Links & Literatur ...... 415
29 Modularisierung...... 417 29.1 Einleitung ...... 417 29.2 Software-Voraussetzungen ...... 417 29.3 Programmiermodell ...... 417 29.4 Admin-Plug-in ...... 418 29.5 Zusammenfassung ...... 421 29.6 Quellcode ...... 421 Links & Literatur ...... 422
30 Internationalisierung ...... 423 30.1 Einleitung ...... 423 30.2 Software-Voraussetzungen ...... 423 30.3 Programmiermodell ...... 423 30.4 Plug-in-Manifest ...... 425 30.5 Applikationsmodell-Komponenten ...... 425 30.6 Applikationsmodell-fremde Komponenten ...... 427 30.7 Zusammenfassung ...... 427 30.8 Quellcode ...... 427 Links & Literatur ...... 427
31 Verteilung ...... 429 31.1 Einleitung ...... 429 31.2 Software-Voraussetzungen ...... 429 31.3 Programmiermodell ...... 429 31.4 Exportfunktionen ...... 430 31.5 Softwareaktualisierung ...... 430 31.6 Zusammenfassung ...... 430 31.7 Quellcode ...... 431 Links & Literatur ...... 431 XVI Inhalt
Teil IV: Anhang ...... 433
A Migration...... 435 A.1 Einleitung ...... 435 A.2 Software-Voraussetzungen ...... 435 A.3 Programmiermodell ...... 435 A.4 Application ...... 436 A.5 Applikationsmodell ...... 437 A.6 Plug-in-Erweiterungen ...... 438 A.7 Migration der Oberfläche ...... 439 A.8 Zusammenfassung ...... 441 A.9 Quellcode ...... 441 Links & Literatur ...... 441
B Häufige Fehler ...... 443 B.1 Einleitung ...... 443 B.2 No application id has been found ...... 443 B.3 Eclipse-Klassen werden nicht gefunden ...... 445 B.4 UnsatisfiedLinkError ...... 446 B.5 Probleme nach Refactoring ...... 447 B.6 Unerwünschte Plug-ins ...... 447 B.7 Veraltete Beispiele...... 447 B.8 Bundle Exception ...... 448 B.9 Unable to load class . . . from bundle...... 449 B.10 Leere Perspektive...... 449 Links & Literatur ...... 449
C Glossar ...... 451
Stichwortverzeichnis ...... 455 Vorwort
Eclipse – Finsternis, Verdunklung. Hinter diesem geheimnisvollen Namen verbirgt sich ei- ne der leistungsfähigsten Softwareplattformen. Mit ihr lassen sich modulare Desktop-Pro- gramme für Windows, Unix und Mac OS X entwickeln. Dieses Buch stellt Ihnen die Eclipse Rich Client Platform (RCP) in drei Teilen vor. Das Buch startet mit den »RCP-Grundlagen«. Dort geht es um die grundlegenden Eclipse- Konzepte sowie um die UI-Toolkits »SWT« und »JFace«. Im Buchteil »Eclipse RCP 3« dreht sich alles um den schrittweisen Aufbau einer Datenbankanwendung für Eclipse RCP 3. Hier werden die eingangs vorgestellten UI-Bausteine zu einer RCP-Anwendung zusammenge- setzt. Die neue Welt der Eclipse-Programmierung heißt »Eclipse RCP 4«. In diesem Teil steht die neue Eclipse-Plattform im Mittelpunkt. Hier wird gezeigt, wie die zuvor entwickelte RCP- Datenbankanwendung mit Eclipse RCP 4 aussieht. Der Anhang beendet das Buch mit ei- nem Kapitel zur Fehlersuche sowie einem Glossar.
Teil 2: Eclipse RCP 3 Teil 3: Eclipse RCP 4
Teil 1: RCP-Grundlagen
Das Buch deckt Grundlagen und beide Versionen der Eclipse-Softwareplattform ab.
Zielgruppe
Dieses Buch richtet sich an professionelle Softwareentwickler, die die Programmierung mit der Eclipse Rich Client Platform von Grund auf erlernen wollen. Da die Konzepte der Platt- form sehr eng mit der Entwicklungsumgebung und Java verbunden sind, sollten Sie die Eclipse-Entwicklungsumgebung kennen und über gute Java-Kenntnisse verfügen. XVIII Vorwort
Schriftkonventionen
Um verschiedene Textteile hervorzuheben, setzt dieses Buch folgende Schriftkonventio- nen ein:
Textteil Darstellung Variablen im Fließtext Object Variablen in Überschriften »Object« Befehle Menu File Open Dateien splash.bmp Verzeichnispfade e3_Application URL http://eclipse.org (. . . ) Hier fehlt ein Teil des Quellcodes Verweise auf Literatur oder Internetquellen [BS1]
Danksagung
Hiermit möchte ich mich bei allen bedanken, die mich beim Schreiben dieses Buchs unter- stützt haben: Dem Carl Hanser Verlag und meiner Lektorin Brigitte Bauer-Schiewek für das Vertrauen in meine Arbeit und die große Geduld, der Herstellung des Verlags für die pro- fessionelle LATEX-Vorlage und der Firma Adobe für die Leihstellung des Adobe Illustrators, mit dem sämtliche Grafiken dieses Buchs entstanden sind. Meine Frau Christiane hat mich wie immer sehr bei diesem Projekt unterstützt. Herzli- chen Dank für Deine Hilfe! Danken möchte ich zudem Angéline Feldkamp, die mir bei der Übersetzung der grafischen Oberfläche des RCP-Beispielprojekts »Vocat« ins Französische geholfen hat, und Jürgen Dubau, der das Manuskript sorgfältig Korrektur gelesen hat. Nicht zuletzt geht mein besonderer Dank an die Entwickler der Eclipse Rich Client Plat- form. Viele davon arbeiten seit Jahren unentgeltlich an der Verbesserung und Erweiterung der Plattform.
Kontakt
Trotz größter Sorgfalt lässt sich nicht immer verhindern, dass der eine oder andere Feh- ler in einem Buch übersehen wird. Wenn Sie Fehler finden, Verbesserungsvorschläge oder Fragen haben, senden Sie mir einfach eine Mail an [email protected]. Ich werde Ih- re Fragen möglichst schnell beantworten und versuchen, Ihre Verbesserungsvorschläge in kommenden Auflagen zu berücksichtigen. Die jeweils aktuellsten Ergänzungen und wei- tere Informationen finden Sie unter http://www.steppan.net. Nun wünsche ich viel Spaß beim Lesen und Entwickeln Ihrer Eclipse-Programme und Plug-ins!
Bernhard Steppan Wiesbaden im Juni 2015 2 Eclipse Rich Client Platform
2.1 Einleitung
Die Eclipse Rich Client Platform (RCP) ist für die Entwicklung portabler Desktop-Anwen- dungen aufgrund ihrer einzigartigen Konzeption konkurrenzlos. Das folgende Kapitel gibt Ihnen einen Überblick über die Besonderheiten der Eclipse RCP 3 und RCP 4.
2.2 Software-Voraussetzungen
Bitte kontrollieren Sie, ob Sie alle für dieses Kapitel erforderliche Software installiert haben. Dieses Kapitel setzt folgende Software voraus:
■ Java Runtime Environment ab Version 7.0
■ Eclipse-IDE for RCP and RAP Developers ab Version 4.4
■ Beispiele des Verzeichnisses e2_Rich_Client_Platform Die Installationshinweise stehen in Kapitel 1,»Entwicklungsumgebung«, unter dem Ab- schnitt 1.4 und dem Abschnitt 1.8.
2.3 Historie
Der Name Eclipse steht für viele Dinge, zum Beispiel für die bekannte Java-Entwicklungs- umgebung oder die Open-Source-Foundation. Eines der wichtigsten Projekte dieser Eclip- se Foundation ist die Eclipse Rich Client Platform. Diese Plattform wurde nicht von Anfang der Eclipse-Geschichte geplant, sondern entwickelte sich aus der Eclipse-Entwicklungs- umgebung (siehe Abbildung 2.1). Diese integrierte Entwicklungsumgebung (IDE) wurde 2001 von der IBM als Nachfolger der VisualAge-Produktfamilie vorgestellt. Die Eclipse-IDE sollte einige grundsätzliche Mängel von VisualAge beseitigen und wurde daher architekto- nisch offener ausgerichtet. VisualAge gehörte zur ersten Generation von integrierten Java- Entwicklungsumgebungen. Diese erste IDE-Generation war ein Meilenstein für die Java- Entwicklung. Sie löste die mühevolle Arbeit mit diversen Editoren und den vollkommen unzureichenden JDK-Werkzeugen wie dem JDK-Debugger ab. 14 2 Eclipse Rich Client Platform
Vorstellung RCP 1.0 Vorstellung RCP 2.0 Eclipse 3.x (Eclipse e3) (Eclipse e4) End of Life
Einführung des Command-Frameworks
Eclipse RCP 4
IDE-Plattform Eclipse RCP 3
Command-Framework
Action-Framework Eclipse 1.0 Eclipse 2.0 Eclipse 2.1 Eclipse 3.0 Eclipse 3.1 Eclipse 3.2 Eclipse 3.3 Eclipse 3.4 Eclipse 3.5 Eclipse 4.3 Eclipse 4.4 Eclipse 4.5 Eclipse 4.6 Eclipse 3.6/4.0 Eclipse 3.7/4.1 Eclipse 3.8/4.2
2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 ... BILD 2.1 Die Geschichte der Rich Client Platform
2.3.1 Vorläufer VisualAge
IBM entwickelte mit VisualAge eine nahezu monolithische Umgebung mit fest eingebau- tem Editor, proprietärem Compiler, Debugger, Versionskontrolle und Team-Repository. Dieser ganzheitliche Ansatz hatte viele Vorteile. Er brachte aber vor allem bei dem Ver- such, externe Werkzeuge zu integrieren, eine Fülle von Schwierigkeiten. Das führte dazu, dass VisualAge immer mehr Marktanteile an offen ausgelegte Entwicklungsumgebungen wie zum Beispiel Borlands JBuilder verlor.
2.3.2 IDE-Plattform
IBM reagierte auf diese Marktentwicklung mit einem Strategiewechsel und der Konzep- tion der Eclipse-Entwicklungsumgebung. Die neue IDE brach mit dem bisherigen, mo- nolithischen Ansatz der VisualAge-Entwicklungsumgebung, übernahm aber deren positi- ve Eigenschaften wie den speziellen Build-Prozess und die verschiedenen Sichten auf die Java-Sourcen. Wie radikal die Abkehr von traditionellen Umgebungen war, zeigt Abbildung 2.2. Links ist ein herkömmliches Programm abgebildet, rechts ein RCP-Programm. Ein herkömmliches Programm wie VisualAge besteht aus einem großen, unveränderlichen Kern. Im Gegensatz dazu kann bei einem RCP-Programm wie der Eclipse-IDE fast alles ausgetauscht werden. Die Grenzen bestimmt nur das Plug-in-Design der RCP-Anwendung. 2.3 Historie 15
Plug-ins Plug-ins
Plug-in-API Editor Debugger ...
... Plug-in-API Editor Debugger
Kern des Programms Plug-in-Loader
Konventionell aufgebaute Anwendung RCP-Programm
BILD 2.2 Vergleich zwischen einem konventionellen und einem RCP-Programm
2.3.3 Eclipse RCP 3
Nach der Vorstellung des VisualAge-Nachfolgers hat IBM die Eclipse-IDE als Open Source freigegeben und die Eclipse Foundation gegründet. Diese Community koordiniert die Eclipse-Entwicklung und verwaltet die Sourcen. Eclipse war in der Anfangszeit also ledig- lich eine Plattform für Entwicklungstools – die Eclipse Rich Client Platform lag noch in weiter Ferne. Erst im Lauf der Zeit hat die Eclipse Foundation erkannt, dass die Eclipse-Frameworks und Eclipse-Konzepte viel zu schade sind, um sie ausschließlich Entwicklungswerkzeugen zu überlassen. Sie lassen sich – wenn man einiges an der damaligen Tool-Plattform Eclipse ändern würde – auch sehr gut in normalen Java-Desktop-Anwendungen verwenden. Man begann daher, die damalige Eclipse-Plattform von der Entwicklungsumgebung zu trennen. Diese gigantische Umstrukturierung des Projekts dauerte einige Jahre. Mit der Eclipse-Entwicklungsumgebung 3.0 veröffentlichte die Eclipse Foundation dann das Ergebnis: die erste Version der Eclipse Rich Client Platform – kurz Eclipse RCP genannt. Diese 2004 vorgestellte RCP-Version bezeichnet man heute meistens als Eclipse RCP 3 oder einfach Eclipse 3.x. Eclipse RCP 3 bezieht sich darauf, dass diese Version auf der Eclipse 3.x-API aufbaut. Der Großteil der Eclipse-Plug-ins, die heute eingesetzt werden, sind nach diesem RCP-Programmiermodell entstanden. Es wird seit Eclipse 4.3 (Kepler) offiziell nicht mehr weiterentwickelt. Sie erfahren im Buchteil II »Eclipse RCP 3« alles Wesentliche über diese klassische Rich Client Platform.
2.3.4 Eclipse RCP 4
Auf der EclipseCon im Jahr 2008 kündigte die Eclipse-Community Eclipse RCP 4 als nächste Generation der Eclipse Rich Client Platform an. Unter Eclipse RCP 4 ist ein neues, verein- fachtes RCP-Programmiermodell zu verstehen, das auch weiterhin Eclipse RCP 3 unter- 16 2 Eclipse Rich Client Platform
Eclipse RCP 3 nativ Eclipse RCP 3/4 hybrid Eclipse RCP 4 nativ (Eclipse 3.x-API) (Eclipse 3.x- und 4.x-API) (Eclipse 4.x-API)
Eclipse-3.x-Kompatibilitätslayer
Eclipse RCP 4 (Eclipse 4.x-API)
BILD 2.3 Es existieren mehrere Möglichkeiten, ein RCP-Programm zu entwickeln.
stützt (siehe Abbildung 2.3). Wie im Vorwort bereits erwähnt, nenne ich diese Version der Plattform zur besseren Unterscheidung Eclipse RCP 4 oder einfach Eclipse e4. Der Name wurde gewählt, weil das neue Programmiermodell auf der Eclipse 4.x-API aufbaut. Eclipse RCP 4 ist angetreten, die Attraktivität der Rich Client Platform durch folgende Verbesserun- gen zu steigern:
■ UI-Modell: Die grafische Oberfläche wird in einem Applikationsmodell definiert.
■ UI-Toolkit: RCP 4 ist unabhängig vom UI-Toolkit. Es lassen sich statt SWT/JFace auch andere UI-Toolkits verwenden.
■ UI-Komponenten: Die im Modell enthaltenen UI-Komponenten werden nur deklariert.
■ Style Sheets: Das Aussehen der Oberfläche kann, wie bei Webanwendungen, durch Style Sheets (CSS) bestimmt werden.
■ JavaScript: RCP-Anwendungen sind in der Lage, JavaScript-Code auszuführen.
■ Ressourcenmodell: Entwicklungstools können auf ein flexibleres Ressourcenmodell zu- rückgreifen. Für viele RCP-Entwickler kam die neue RCP-Version vollkommen überraschend (sie- he [BS01]). Sie fragten sich, welche Möglichkeiten der Entwicklung durch Eclipse RCP 4 bestehen. Es gibt drei (sinnvolle) Modelle, wie ein RCP-Programm heute aussehen kann: entweder als native Anwendung auf Basis der 3.x-API, als Hybridanwendung unter Ver- wendung der Eclipse 3.x-API und Eclipse 4.x-API oder als native Anwendung auf Basis der Eclipse 4.x-API. Wie eine Hybridanwendung und eine native Eclipse-4.x-Anwendung aussieht, erfahren Sie im Buchteil III,»Eclipse RCP 4«.
2.4 Programmiermodell
Ob Eclipse RCP 3 oder Eclipse RCP 4 – RCP-Anwendungen wie die Eclipse-IDE bestehen fast nur aus Plug-ins. Plug-in ist die Bezeichnung in der Eclipse-Community für das, was die Software-Plattform OSGi (siehe Abschnitt 2.5) als Bundle bezeichnet. Wie revolutionär der Ansatz war, eine Anwendung fast nur noch aus solchen Modulen aufzubauen, sehen Sie an der Architektur der Eclipse-IDE (siehe Abbildung 2.4). 2.5 Module 17
IDE User Interface Workspace/ Compare / Team Resources Search
Workspace based Document Editors
Java Rich Client Platform Development Tools (JDT) Workbench Help
JFace Plug-in Development SWT Environment (PDE)
Eigene Workspace Plug-ins OSGi-Runtime (Equinox)
BILD 2.4 Die Architektur einer RCP-Anwendung am Beispiel der Eclipse-IDE
Die Eclipse-IDE ist nichts anderes als eine sehr große Anwendung auf Basis der Eclipse Rich Client Platform. Die Abbildung 2.4 zeigt am Beispiel der Eclipse-IDE für RCP- und RAP-Ent- wickler, dass eine solche Anwendung im Wesentlichen aus einem sehr kleinen RCP-Kern und diversen Plug-ins wie den Java Development Tools sowie der Plug-in Development Environment besteht. Eigene Plug-ins können Sie installieren, um das Programm nach Ih- ren Wünschen zu ergänzen. Um die Entwicklung von solchen komplexen Desktop-Anwen- dungen wie der Eclipse-IDE so einfach wie möglich zu halten, beinhaltet die Eclipse Rich Client Platform eine ganze Reihe von architektonischen Besonderheiten, allen voran das eingangs erwähnte Modulsystem.
2.5 Module
2.5.1 OSGi und Equinox
2.5.1.1 Java-Standard Jigsaw Über ein dynamisches Modulsystem wird in Java-Kreisen seit Jahren kontrovers diskutiert. Vielleicht ist Ihnen der Begriff »Jigsaw« (engl.: Stichsäge) daher bekannt. Es ist der Codena- me des zukünftigen Java-Modulsystems. Dieser wichtige Modulmechanismus fehlt zum Zeitpunkt der Drucklegung dieses Buchs noch in Java. Er ist für Java 9 angekündigt (sie- he [JIGS]). Warum ist ein solcher Mechanismus so wichtig, und was steckt hinter einem dynamischen Modulsystem? 18 2 Eclipse Rich Client Platform
Ein dynamischer Modulmechanismus ist dazu da, unterschiedliche Versionen eines Mo- duls (= Bundles, Plug-ins) in einem Programm zu verwalten, Module kontrolliert zur Lauf- zeit zu laden und auch wieder zu entfernen. Mit reinen Java-Sprachmitteln wie Packages ist so etwas nur über zusätzliche Programmierung möglich. Sie können durch das Package- Konzept zwar beispielsweise mehrere String-Klassen in einem Programm einsetzen wie zum Beispiel java.util.String und java.lang.String. Es kommt zu keinen Konflikten, weil sich die Klasse String in unterschiedlichen Packages befindet. Daher ist es nicht ohne Weiteres möglich, die Klasse java.lang.String in mehreren Versionen innerhalb einer Java- Anwendung zu verwenden.
2.5.1.2 Versionskonflikte Gerade in größeren Enterprise-Anwendungen kommt es daher häufig zu Versionskonflik- ten, die durch Programmbibliotheken ausgelöst werden, die man verwenden muss, in de- nen sich aber gleichnamige Klassen mit unterschiedlichen Versionsständen befinden. Ein Beispiel: Gesetzt den Fall, Sie verwenden mehrere Bibliotheken in einer Anwendung, weil sie funktional notwendig sind. Mehrere dieser Bibliotheken benötigen eine Klasse mit ex- akt dem gleichen vollqualifizierten Namen – aber sie setzen unterschiedliche Versionen voraus. Angenommen, wie in Abbildung 2.5 dargestellt, die Klasse c1.class in der Version 0.3.1 wird zuerst vom Java-Classloader geladen. Je nach Implementierung des Java-Classloaders steht ausschließlich diese Version der Klasse ab diesem Zeitpunkt allen Verbrauchern zur Verfü- gung, die ein Objekt dieser Klasse erzeugen möchten. Das gilt auch für den Fall, dass diese Verbraucher eine Klasse in der Version 1.0.1 erwarten, da es keine Möglichkeit gibt, vom Classloader genau diese Version anzufordern. Wenn sich die Implementierung von c1-0.3.1 und c1-1.0.1 deutlich geändert hat, kommt es zu einem schwer verständlichen Fehlverhalten des Programms. Diese »Anomalien« kön-
lib-v0.3.1.jar lib-v1.0.1.jar
c1.class c2.class c3.class c1.class c2.class c3.class
Unterschiedliche Implementierungen
BILD 2.5 Versionskonflikte bei gleichen Klassen mit unterschiedlicher Implementierung 2.5 Module 19
nen nur durch aufwendige Tests gefunden werden. Sie sind für jeden Tester ein Albtraum. Daher ist ein dynamischer Modulmechanismus mit einer Beherrschung von Versionskon- flikten und dem dynamischen Laden und Entfernen von Bundles für komplexere Program- me ein Muss. So sahen das auch die Entwickler der Eclipse-IDE.
2.5.1.3 Equinox Als die Eclipse-IDE – und somit auch die Eclipse Rich Client Platform – entstand, konnte man nicht warten, bis die Java-Community sich auf eine Implementierung für einen dy- namischen Modulmechanismus geeinigt hatte. Stattdessen gab es eine Spezifikation für eine solche Modulplattform namens OSGi. OSGi stand früher für »Open Services Gateway Initiative« und ist heute ein internationaler Standard für Modulplattformen. Es gibt eine Implementierung der Apache Group namens »Felix« und eine Implementierung der Eclip- se Foundation namens »Equinox«. Die Eclipse Rich Client Platform setzt Equinox ein. Das Laufzeitsystem auf Equinox-Basis lässt zu, dass Bundles (Plug-ins) in unterschiedli- chen Versionen innerhalb eines Programms koexistieren, dynamisch geladen und entfernt werden können (Abbildung 2.6). Sie fordern einfach in ihrem Programm oder Plug-in eine bestimmte Version an oder legen fest, was die Mindestversion sein soll. Damit ist gewähr- leistet, dass das Programm exakt so funktioniert, wie es auch getestet wurde.
OSGi-Container
org.eclipse.core.runtime (3.9.0)
org.eclipse.e4.ui.model.workbench (1.0.0)
org.eclipse.jface (3.9.0)
net.steppan.vocat.dao (1.0.0)
net.steppan.vocat.admin (1.0.0)
BILD 2.6 In einem OSGi-Container können Plug-ins unterschiedlicher Versionen koexistieren.
2.5.1.4 Service Registry Damit ein OSGi-Framework Plug-ins unterschiedlicher Versionen verwalten kann, verfügt es über eine Service Registry. Das ist eine Art von Datenbank, wo Bundles mit ihrer Ver- sion eingetragen werden. Im Fall von Eclipse registriert sich eine RCP-Anwendung oder ein 20 2 Eclipse Rich Client Platform
Eclipse-Plug-in in einer solchen Datenbank. Sie befindet sich normalerweise in dem Ver- zeichnis des RCP-Programms wie zum Beispiel der Eclipse-IDE. Ein Plug-in wird nicht einfach in einen Container geworfen und verharrt dort ein Leben lang ohne Änderungen. Es verfügt über einen Lebenszyklus mit einem definierten Beginn und Ende. Jedes RCP-Plug-in verfügt normalerweise über eine Klasse mit Methoden, um ein Modul zu starten und zu stoppen. Im Plug-in-Lebenszyklus gibt es folgende sechs Zu- stände: Installed, Resolved, Starting, Stopping, Active and Uninstalled (Abbildung 2.7).
update/refresh
Installed Starting
resolve update/refresh start activate
uninstall Resolved Active stop
uninstall resolve stop
Uninstalled Stopping
BILD 2.7 Plug-ins durchlaufen einen Life Cycle (Quelle: Eclipse Foundation/Virgo).
Installed bedeutet, dass das Plug-in bisher lediglich zum Container hinzugefügt wurde. Es ist weder im Resolved- noch im Starting-Zustand. Wenn sich der Zustand dieses Plug-ins nicht verändert, kann das bedeuten, dass Abhängigkeiten noch nicht aufgelöst wurden oder ein anderes Plug-in mit dem gleichen Namen bereits ausgewählt wurde. In diesem Zustand können keine Packages oder Extensions dieses Plug-ins genutzt werden. Der Zustand Resolved bedeutet, dass alle Voraussetzungen für das Plug-in erfüllt wurden, es aber noch nicht gestartet wurde. Das Plug-in kann der Rich Client Platform Packages, Ex- tensions und Extension Points zur Verfügung stellen. Wenn verlangt wurde, dass das Plug- in starten soll, bekommt es den Zustand Starting. Das passiert beim Programmstart. Ist es betriebsbereit und gestartet, nimmt es den Zustand Active ein. Beim Beenden eines Programms wird das Plug-in gestoppt und bekommt den Zustand Stopping. Danach liegt es wieder als Resolved im Container. Wird es nicht benötigt, kann es deinstalliert werden und bekommt den Zustand Uninstalled. In diesem Zustand kann es nicht vom Programm aus verwendet werden.
2.5.2 Eclipse-Plug-ins
OSGi-Plug-ins wurden eingeführt, um Eclipse-Programme flexibel aufbauen und erwei- tern zu können. Solche Modulsysteme gab es in Anwendungen schon früher, aber selten so durchdacht. Während normale Anwendungen immer einen Grundanteil fest integrier- 2.6 Workspace 21
ter Funktionen mitschleppen müssen, ist bei einem RCP-Programm fast alles austausch- bar. Wie gut das funktioniert, hängt nur vom Design der Plug-ins ab. Die Modularisierung geht so weit, dass RCP-Entwickler den Spruch geprägt haben: »Alles ist ein Plug-in«. Das stimmt fast. Der Plug-in-Loader ist zum Beispiel eine Ausnahme. Er ist der Minikern, der zuerst ausgeführt wird, wenn Sie eine Eclipse-Anwendung wie zum Beispiel den Vokabeltrainer dieses Buchs starten. Der Plug-in-Loader hat die Aufgabe, alle erforderlichen Plug-ins zu laden. Hierbei kann er erkennen, ob Plug-ins »zusammenpas- sen«. Das Modulsystem ist also in der Lage, Versionskonflikte zu erkennen. Dieser durchdachte Mechanismus ist viel zu schade, um ihn ausschließlich für Entwick- lungswerkzeuge zu nutzen. Daher kam die Eclipse-Community auf die Idee, die Eclipse- Plattform als Grundlage »normaler« (Geschäfts-) Anwendungen und nicht nur als Grund- lage für Eclipse-Entwicklungswerkzeuge zu nutzen: Eine universelle Java-Plattform für Desktop-Anwendungen war entstanden, die im Laufe der Zeit immer weiter verbessert wurde. Mit der Eclipse-Entwicklungsumgebung 3.0 und der Vorstellung der ersten Versi- on der Rich Client Platform haben sich viele Firmen entschlossen, ihre Rich Clients auf Basis von Eclipse 3.x zu entwickeln. Diese erste Version der Eclipse Rich Client Platform bezeichnet man daher als Eclipse RCP 3 bzw. Eclipse 3.x (siehe Teil II,»Eclipse RCP 3«)). Heute lassen sich mithilfe der Rich Client Platform Anwendungen entwickeln, denen nur Fachleute ansehen, dass sie diese Plattform als Grundlage verwendet haben. Den Kunst- griff erreichten die Eclipse-Entwickler dadurch, dass sie die Teile der Rich Client Platform, die für die Entwicklungsumgebung benötigt werden, und die allgemein verwendbaren Tei- le der Rich Client Platform im Laufe der Zeit konsequent getrennt haben. Zudem können viele UI-Komponenten der Plattform über CSS in Farbe und Form verändert werden.
2.6 Workspace
Wie speichert man Programmeinstellungen dauerhaft? Hier gibt es verschiedene Konzep- te: Der Eclipse-Vorläufer VisualAge verwendete zum Beispiel ein zentrales Repository, eine Art Archivdatenbank für alle Projektbestandteile. Der Vorteil war, dass damit auch Teams zusammenarbeiten konnten, weil eine Versionierung des Quellcodes automatisch sicher- gestellt war. Man erkaufte sich damit aber den Nachteil, dass man nicht gleichzeitig mit anderen Werkzeugen auf Projektdateien zugreifen konnte, die in diesem datenbankähnli- chen, monolithischen Speicher auf einem Server lagen. Man musste den Inhalt exportie- ren, bearbeiten und wieder importieren – ein umständliches Verfahren. Ein flexibleres Konzept ist es, die Programmeinstellungen in einer oder mehreren Dateien auf dem Arbeitsplatzrechner zu speichern, wie es bei verschiedenen Entwicklungsumge- bungen der Fall ist. Eine RCP-Anwendung wie die Eclipse-IDE organisiert ihre Programm- einstellungen in einem kompliziert strukturierten Verzeichnis auf der lokalen Festplatte, dem sogenannten »Workspace« (Abbildung 2.8). Der Workspace eines RCP-Programms ist wie bei der VisualAge-IDE als Repository orga- nisiert. Im Gegensatz zum Repository-Konzept von Visual Age hat dieses RCP-Repository jedoch den Vorteil, dass es offen für andere Werkzeuge ist. Es hat allerdings den Nachteil, dass es ohne weitere Ergänzungen nicht geeignet ist, mit mehreren Anwendern gleichzeitig 22 2 Eclipse Rich Client Platform
Workspace
.metadata
.plugins
.org.eclipse.core.resources
.projects
.root
.safetable
.snap
.org.eclipse.core.runtime
.settings
.org.eclipse.e4.workbench
workbench.xmi
.lock
.log
version.ini
net.steppan.projekt01
X .project
src BILD 2.8 Der Aufbau des Eclipse-Arbeitsbereichs
an einem Projekt zu arbeiten. Um eine solche Teamfähigkeit zu erreichen, ist ein zusätzli- cher Server für die Versionierung von Projektdateien notwendig, zum Beispiel CVS oder SVN. Mit ihm lassen sich Änderungen, die an einem Projekt lokal auf den einzelnen Work- stations vorgenommen werden, mit anderen Teammitgliedern austauschen. Der Workspace enthält unter anderem ein verstecktes Verzeichnis mit Metadaten. Der In- halt dieses Verzeichnisses ist abhängig von der Konfiguration des Eclipse-Programms. In der Regel besteht das Verzeichnis aus den drei Dateien .lock, .log und version.ini so- wie dem Verzeichnis .plug-ins. Die versteckte Lock-Datei innerhalb des Arbeitsbereichs zeigt der Eclipse-Anwendung an, ob sich der Workspace bereits im Zugriff eines anderen Eclipse-Programms befindet, während die Log-Datei die vom Programm gespeicherten Logging-Informationen bereithält. 2.6 Workspace 23
LISTING 2.1 Ermittlung der Projekte innerhalb eines Workspaces
1 ArrayList
Der Inhalt des Plug-in-Verzeichnisses variiert sehr stark in Abhängigkeit der Konfigurati- on des RCP-Programms. Hier finden Sie die Einstellungen der einzelnen Eclipse-Module in Ordnern, deren Namen der Bezeichnung des jeweiligen Plug-ins entsprechen. Wenn Sie ein Plug-in installieren, wird es im Workspace ein neues Verzeichnis anlegen und seine Informationen speichern. Zum Beispiel speichert die RCP-Laufzeitumgebung ihre Infor- mationen in dem Verzeichnis org.eclipse.core.runtime. Die Eclipse Rich Client Platform stellt jedem RCP-Programm Java-Klassen zum Zugriff auf den Arbeitsbereich zur Verfügung, sodass die RCP-Anwendung die Struktur des Workspace nicht im Detail kennen muss. Das Listing 2.1 zeigt ein Programmfragment, das den Work- space mit seinen Projekten einliest und einem Array zuordnet. In Zeile 3 ermittelt das Programm den gesetzten Workspace. Er kann über den Parameter -data in der Ini-Datei des RCP-Programms übermittelt werden. Danach holt sich das Programm die Wurzel des Workspaces und von dort alle Projekte. In der nachfolgenden Schleife werden diese Projek- te samt Projektnamen, Pfad und Kommentar ausgelesen. Eine RCP-Anwendung ist in der Lage, mehrere Workspaces zu verwalten. Sie kann den Spei- cherort auf der Festplatte selbst bestimmen oder vom Anwender bestimmen lassen. Beim Wechsel des Workspaces ist bisher jedoch ein Neustart erforderlich. Aufgrund der Struktur des Arbeitsbereichs kann nicht jedes RCP-Programm immer den Workspace eines anderen Programms vollständig auslesen. Das funktioniert nur dann, wenn die Konfiguration des RCP-Programms, das ihn einlesen möchte, kompatibel zu dem Programm ist, das ihn ge- schrieben hat. Ist das nicht der Fall, können nicht alle Informationen interpretiert werden, und es kommt zu einem Fehler. Die Daten bleiben hierbei aber erhalten. 24 2 Eclipse Rich Client Platform
2.7 UI-Toolkits
Im Gegensatz zu traditionellen Java-Programmen verwendeten die Eclipse-Erfinder bei der Konzeption der Eclipse-Entwicklungsumgebung nicht die UI-Bibliotheken AWT und Swing der Java-Plattform für die grafischen Oberflächen von Eclipse-Programmen, sondern ent- wickelten zwei neue UI-Toolkits: das Standard Widget Toolkit (SWT) und das darauf auf- bauende JFace. Die Gründe für diesen nicht unumstrittenen Schritt liegen in der Unzufrie- denheit mit dem Zeitverhalten und dem Speicherkonsum der Swing-Bibliothek. Während die Swing-Bibliothek alle Oberflächenbausteine selbst zeichnet, ist das Eclipse- Framework SWT eine sehr systemnahe GUI-Bibliothek: Es delegiert das Zeichnen der Wid- gets über das Java Native Interface (JNI) an das Betriebssystem. Dieser andere Ansatz führt natürlich zu einem wirklich nativen Erscheinungsbild – auch dann, wenn das Look and Feel des Betriebssystems sich durch eine neue Version ändert. Zudem wird in der Regel die Oberfläche einer Eclipse-Anwendung schneller aufgebaut, weil die Zeichenfunktionen des Betriebssystems denen der Swing-Bibliothek überlegen sind. Wenn Sie RCP-3-Programme und RCP-3-Plug-ins entwickeln, müssen Sie die UI-Toolkits SWT und JFace einsetzen. Das gilt nicht für Eclipse RCP 4, wo Sie zum Beispiel auch aus- schließlich JavaFX oder Swing verwenden können. Die nachfolgenden vier Kapitel »UI- Toolkits«, »Standard Widget Toolkit«, »JFace« und »Layoutmanager« geben Ihnen einen tie- fen Einblick in die Einzelheiten der beiden klassischen RCP-Toolkits SWT und JFace.
2.8 Workbench
Wenn Sie mit der Eclipse-Entwicklungsumgebung oder einer anderen RCP-Anwendung arbeiten, ist Ihnen das spezielle Layout der Oberfläche aufgefallen, das sich von traditio- nellen Desktop-Anwendungen durch einige Neuerungen unterscheidet. Im Eclipse-Jargon spricht man von der Workbench, von Views (Sichten), Editoren (Eingabefenster) und Per- spektiven. Die Workbench ist der zentrale Teil einer RCP-Anwendung (siehe Abbildung 2.9). Sie fasst die einzelnen Workbench-Bestandteile wie Fenster, Menüs, Symbolleisten und Statusleisten zusammen. Diese Workbench lässt sich dynamisch über Plug-ins erweitern.
2.8.1 Parts
Fast jede Anwendung benötigt Fenster, die den Inhalt lediglich anzeigen (Views) und Fens- ter, deren Inhalt man verändern kann (Editoren). Diese Fenster bezeichnet Eclipse RCP als Parts. Eclipse RCP 3 gibt vor, dass solche Views von der Basisklasse ViewPart und Editoren von der Basisklasse EditorPart abgeleitet werden müssen. Unter Eclipse RCP 4 sind Parts lediglich Basisklassen und können beide Rollen einnehmen. Views und Editoren ist gemeinsam, dass man solche Fenster vom Hauptfenster abreißen und an anderer Stelle neu platzieren kann. RCP-Fenster lassen sich in einem Fensterbe- reich übereinander anordnen, sodass von ihnen nur die Register zu sehen sind. Solche Fenster können geschlossen oder auch so konfiguriert werden, dass man sie nicht schlie- ßen kann. Zudem lassen sie sich zu Perspektiven zusammenstellen. 2.8 Workbench 25
Workbench
Workbench Window
Workbench Page
Parts Menüs Views Editoren Coolbar Toolbar
Perspektiven
BILD 2.9 Die Workbench ist die Arbeitsoberfläche einer RCP-Anwendung.
2.8.2 Perspektiven
Sie kennen Perspektiven sicher bereits von der Eclipse-Entwicklungsumgebung. Eine Per- spektive ist nichts anderes als ein festgelegtes Fensterlayout mit einer Auswahl bestimmter Parts. Eine RCP-Anwendung wie das Programmierbeispiel dieses Buchs kann verschiede- ne Perspektiven für unterschiedliche Arbeiten mit dem Programm definieren (siehe Abbil- dung 2.10). Das Programm speichert nicht nur, welche Parts verwendet werden. Es spei- chert auch die Position und Anordnung der Fenster in dem schon erwähnten Arbeitsbe- reich auf der Festplatte (siehe Abschnitt 2.6,»Workspace«). Ein Eclipse-Programm wird mit mindestens einer Perspektive ausgeliefert. Sie sind der Vor- schlag der Anwendungsentwickler, welche Parts (Views und Editoren) zusammenpassen und wie sie sinnvoll angeordnet werden. Von der Wahl des Layouts ist abhängig, ob Parts übereinander oder nebeneinander liegen und veränderbar in ihrer Größe sind. Viele RCP- Programme erlauben dem Anwender darüber hinaus, Perspektiven nach Belieben zu ver- ändern, Parts zu schließen und andere Parts hinzuzufügen. Zudem lassen sich eigene Per- spektiven erzeugen und unter einem Namen dauerhaft speichern. Dadurch, dass sich die Änderungen am Fensterlayout dauerhaft auf der Festplatte spei- chern und auf Knopfdruck wieder aktivieren lassen, kann ein Anwender sein RCP-Pro- gramm sehr flexibel an seine bevorzugte Arbeitsweise anpassen. Da diese Einstellungen im Workspace gespeichert werden, sind sie normalerweise unabhängig von einer bestimm- ten Version eines RCP-Programms. Das heißt, selbst wenn der Anwender eine komplett neue Version seines RCP-Programms installiert, kann er in der Regel wieder sofort mit der vertrauten Anordnung seines Programms arbeiten, wenn er den gleichen Arbeitsbereich wählt. 26 2 Eclipse Rich Client Platform
Schalter für Perspektiven Coolbar Menüs Toolbar
Trainings- erfolg
Views Lektionen
Trainings- statistik
Perspektive BILD 2.10 Vocat 2.0 – das Eclipse-RCP-4-Beispiel dieses Buchs
2.8.3 Features
Features könnte man wörtlich als fachliche Besonderheit oder Charakteristikum eines Pro- gramms übersetzen. Rein technisch versteht man darunter im Rahmen der RCP-Program- mierung eine Gruppe von zusammengehörigen Plug-ins. Features helfen vor allem bei wirklich großen Projekten, die Fülle von Plug-ins sinnvoll zu strukturieren und später auf dem Computer des Endanwenders zu verteilen. Das ist nützlich, um sehr große Programm- erweiterungen, zum Beispiel für die Eclipse-Entwicklungsumgebung, überschaubar zu halten. Über Features wird zudem die Softwareaktualisierung gesteuert.
2.9 Softwareaktualisierung
Um Eclipse-Anwendungen nach der Installation auf dem neuesten Stand zu halten, stellt die Rich Client Platform bzw. die OSGi-Implementierung Equinox einen Update-Mecha- nismus (auch kurz »p2« genannt) bereit. Die Bezeichnung p2 steht hierbei für Provisio- ning 2.x (engl. Provisioning: Versorgung, Beschaffung). Die Version 2.x kommt dadurch zu- stande, dass es schon einen Vorläufer gab. Durch diese Update-Funktion lassen sich neue Versionen von Plug-ins (Bundles) oder vollständig neue Plug-ins automatisch oder ma- nuell nachladen und wieder entfernen. Das geschieht entweder über eine Update-Website (Cloud), ein Laufwerk oder über ein Archiv. Mehr dazu in Kapitel 19,»Verteilung«, für Eclip- se RCP 3 und in Kapitel 31,»Verteilung«, für Eclipse RCP 4. 2.10 Hilfesystem 27
2.10 Hilfesystem
Ein weiterer wichtiger Pluspunkt der Eclipse Rich Client Platform ist das plattformüber- greifende Hilfesystem. Eclipse-Anwendungen können mit einer globalen Hilfeunterstüt- zung ausgeliefert werden, die wie eine eigenständige Webanwendung im Browser ange- zeigt wird. Zudem lässt sich jeder Dialog mit einer kontextbezogenen Hilfe ausstatten. Eine weitere Möglichkeit der Hilfeunterstützung sind Willkommensseiten mit Tutorien (soge- nannte »Intro«), die man ebenfalls sehr einfach in eine RCP-Anwendung integrieren kann.
2.11 Remote Application Platform
2.11.1 Webprogrammierung
Als Abschluss dieses Kapitels möchte ich Ihnen noch einen Ausblick auf die Webprogram- mierung nach dem RCP-Programmiermodell geben. RCP für das Web hört sich erst einmal völlig abwegig an. Alle Bibliotheken, die im RCP zum Einsatz kommen, sind auf die client- seitige Programmierung für Desktop-Anwendungen zugeschnitten. Mit serverseitiger Pro- grammierung hat RCP also nichts zu tun. Bei der Programmierung mit der Remote Application Platform geht es auch nicht darum, die Rich Client Platform eins zu eins auf das Web zu übertragen. Es geht vielmehr darum, das RCP-Programmiermodell für Webanwendungen zu nutzen und im Gegensatz zu Java- Server Faces eine sehr hohen Abstraktion von der üblichen Webprogrammierung zu erzie- len. Das relativ neue Eclipse-Projekt nannten die Entwickler zunächst Rich Ajax Platform (RAP), da die verwendeten Widgets Ajax einsetzen. Später wurde die Plattform in Remote Application Platform umbenannt (siehe [BS02]).
2.11.2 RAP Widget Toolkit
Um die Rich Client Platform auf das Web zu übertragen, musste neben vielen anderen RCP-Funktionen das Standard Widget Toolkit (SWT) gegen ein Framework ausgetauscht werden, das die Low-Level-Kommunikation mit dem Servlet-Container übernimmt (Ab- bildung 2.11). Dieses Framework heißt RAP Widget Toolkit (RWT). SWT und RWT sind sich sehr ähnlich, aber im Detail verschieden. Zum Beispiel verwen- den RWT-Komponenten den Namespace org.eclipse.rap.rwt statt org.eclipse.swt. Da es be- stimmte Stile der SWT-Widgets in einer Webanwendung nicht gibt, unterscheiden sich auch hier die beiden Komponentenbibliotheken. RAP verfügt ebenfalls über eine spezielle JFace-Version. Sie stellt Viewer, Webdialoge, Actions und eine Image Registry zur Verfü- gung. 28 2 Eclipse Rich Client Platform
Remote Application Platform
RAP-Anwendung
Workbench
JFace
RWT
Equinox (OSGi-Runtime) Servlet-Container
BILD 2.11 Die Architektur der Remote Application Platform
2.11.3 Modulare Webanwendungen
Teil der RAP-Architektur ist – wie bei RCP – eine OSGi-Runtime sowie die Workbench als Klammer der Web-UI. Der Aufbau eines RCP- und eines RAP-Programms ist sehr ähn- lich (siehe Abbildung 2.11). Dort ist zu sehen, dass die OSGi-Runtime das Modulsystem der Webanwendung übernimmt und oberhalb des Servlet-Containers sitzt. Vorhandene Bibliotheken wie Eclipse BIRT können relativ leicht übernommen werden. Auch die Werkzeugunterstützung ist verbessert worden. Während RAP in der Anfangszeit eine Sammlung von Plug-ins war, die man in seine Eclipse-IDE installieren musste, gibt es seit einiger Zeit eine gemeinsame Eclipse-IDE für RCP- und RAP-Entwickler. Unter den Wizards zur Erzeugung eines Eclipse-Plug-ins finden sich mehrere Vorlagen zur Generie- rung einer RAP-Anwendung. Sie können damit neue RAP-Anwendungen entwickeln und mit vergleichbar überschaubarem Aufwand vorhandene RCP-Programme in das Web über- tragen.
2.12 Zusammenfassung
Die Eclipse Rich Client Platform ist eine sehr leistungsfähige Plattform für Java-Desktop- Anwendungen. Eclipse-RCP-Anwendungen sind modular aufgebaut und basieren auf dem Modulsystem OSGi. Sie können dank der OSGi-Infrastruktur ohne die Gefahr von Versions- konflikten erweitert werden. Durch die Workbench mit ihren Views, Editoren und Perspek- tiven lässt sich die Oberfläche eines RCP-Programms sehr leicht und flexibel konfigurieren. 2.13 Quellcode 29
2.13 Quellcode
Sie finden den Quellcode der in diesem Kapitel vorgestellten Beispiele im Verzeichnis e2_Rich_Client_Platform der Downloads.
Links & Literatur
[BS01] Steppan, B.: Eclipse e4 – Architekturwandel löst Zweifel aus. http://www.heise.de/artikel-archiv/ix/2010/08/082_Zwischenwelt [BS02] Steppan, B.: Ajax-Entwicklung erobert Eclipse. http://www.cowo.de/a/578598 [JIGS] Oracle streicht Project Jigsaw aus Java 8. http://www.cowo.de/a/2518150 [MILE] Key Milestones Over 10 Years of Eclipse. http://eclipse.dzone.com/articles/key-milestones-over-10-years [OSGI] OSGi-Homepage. http://www.osgi.org [WP01] Eclipse (IDE). https://de.wikipedia.org/wiki/Eclipse_%28IDE%29 Stichwortverzeichnis
@Active 333 – @PersistState 333 @CanExecute 333 – @PostConstruct 333 @Creatable 333 – @PostContextCreate 333 @Execute 333 – @PreDestroy 333 @Inject 333 – @PreSave 333 @Inject Logging 368 – @ProcessAdditions 333 @Named 333 – @ProcessRemovals 333 @Optional 333 API 451 @Persist 333 API Analysis 119 @PersistState 333 Application 129 @PostConstruct 333 – Eclipse RCP 3 115 @PostContextCreate 333 – Eclipse RCP 4 329 @PreDestroy 333 ApplicationActionBarAdvisor 133 @PreSave 333 Application Model 24, 329, 330, 451 @ProcessAdditions 333 – Add-ons 330 @ProcessRemovals 333 – Binding Contexts 330, 354 – Binding Tables 330, 354 About – Command Categories 330, 352 – Eclipse RCP 3 204 – Commands 330, 352 – Eclipse RCP 4 356 – HandledMenuItem 353 Abstract Window Toolkit 34, 451 – Handlers 330 Actions – Menu Contributions 330 – Eclipse RCP 3 181 – Part Descriptors 330 – JFace 97 – Snippets 330 ActionBarAdvisor 133 – Toolbar Contributions 330 – fillMenuBar() 134 – Trim Contributions 330 – makeActions() 134 – TrimmedWindow 353 Activator 115, 119, 127 – Windows and Dialogs 330 Active (Bundle-Lifecycle) 20 ApplicationWindow Add a lifecycle class 337 – ApplicationWindow(), Konstruktor 93 Admin-Plug-in 302 – createContents() 93 Alwis, Brian de 411 – createCoolBarManager 93 Anbieter des Plug-ins – createMenuManager() 93 – Eclipse RCP 3 119 – createStatusLineManager() 93 Annotationen – getInitialSize() 93 – @Active 333 ApplicationWindow (JFace) 69 – @CanExecute 333 ApplicationWindow(), Klasse ApplicationWindow – @Creatable 333 93 – @Execute 333 ApplicationWorkbenchAdvisor 131 – @Inject 333 ApplicationWorkbenchWindowAdvisor 132 – @Named 333 Applikationsmodell 24, 330, 451 – @Optional 333 – Add-ons 330 – @Persist 333 – Binding Contexts 330 456 Stichwortverzeichnis
– Binding Tables 330 – Resolved 20 – Command Categories 330 – Starting 20 – Commands 330 – Stopping 20 – Handlers 330, 352 – Uninstalled 20 – MAddon 331 Button 52 – MApplication 331 – MDirtyable 331 Check Button 53 – Menu Contributions 330 Classpath nicht korrekt gesetzt 445 – MPart 331 ColorDialog 51 – MPartDescriptor 331 Combo 60 – MPerspective 331 Commands – MTrimmedWindow 331 – Eclipse RCP 3 137, 203 – MWindow 331 – Eclipse RCP 4 349 – Snippets 330, 331 Composite 56, 59 – Symbolleiste 353 Configuration – Toolbar 353 – Produkt) 321 – Toolbar Contributions 330, 353 configureShell(), Klasse »Dialog« 240 – Trim Contributions 330, 353 configureShell(), Klasse – TrimBars 353 org.eclipse.jface.window.Window 232, 240 – Windows and Dialogs 330 Contributions ApplikationsmodellPart Descriptors 330 – Eclipse e4 417 Arbeitsbereich 21 – Eclipse RCP 3 301, 304 Arbeitspakete – Eclipse RCP 4 417 Control 52 – Eclipse RCP 3 117 CoolBar 60 Arguments 126 – Eclipse RCP 3 (Actions) 184 Arrow Button 53 Copy Attribute »TrainingStatisticDao« 175 – Eclipse RCP 3 204 Attribute »VocabularyDao« 166 – Eclipse RCP 4 356 Automatische Softwareaktualisierung createActionBarAdvisor(), – Eclipse e4 430 WorkbenchWindowAdvisor 133 – Eclipse RCP 3 324 createButtonsForButtonBar() 241 – Einführung 26 – Klasse org.eclipse.jface.dialogs.Dialog 233 AWT 34, 451 createContents(), Klasse ApplicationWindow 93 createCoolBarManager, Klasse Beispielprogramme 9 ApplicationWindow 93 Beispielprojekte 9 createDialogArea(), Klasse TitleAreaDialog 232 Benutzervoreinstellungen createMenuManager(), Klasse ApplicationWindow – Eclipse RCP 3 291 93 – Eclipse RCP 4 411 createStatusLineManager(), Klasse Benutzervorgaben ApplicationWindow 93 – Eclipse RCP 3 291 createWindowContents(), – Eclipse RCP 4 411 WorkbenchWindowAdvisor 133 Bindings 203, 349, siehe auch Key Bindings createWorkbenchWindowAdvisor(), – Eclipse RCP 3 (Actions) 181 WorkbenchAdvisor 131 – Eclipse RCP 3 (allgemein) 137 CSS 38, 452 Branding Cut – Produkt 322 – Eclipse RCP 3 204 Build 123 – Eclipse RCP 4 356 – Eclipse RCP 3 121 Build-Konfiguration DAO 163 – Eclipse RCP 3 140 Data Binding build.properties 125 – Eclipse RCP 3 265 – Eclipse RCP 3 121 – JFace 80 Bundle 16, 451 Database Access Objects 163 Bundle-Lifecycle 20 Datenbankzugriff – Active 20 – Eclipse RCP 3 157 – Installed 20 – Eclipse RCP 4 345 Stichwortverzeichnis 457
Defekter Workspace 445 Exit Delete – Eclipse RCP 3 204 – Eclipse RCP 3 204 – Eclipse RCP 4 356 – Eclipse RCP 4 356 Export Dependencies – Eclipse RCP 3 204 – Eclipse RCP 3 121 – Eclipse RCP 3) 319 – Produkt 321 – Eclipse RCP 4 356, 429 Dependency Injection 452 Extension Points 24, 123 Deployment – Eclipse RCP 3 121 – Eclipse RCP 3 319 Extensions 122 – Eclipse RCP 4 429 – Eclipse RCP 3 121 DI 452 – org.eclipse.core.runtime.applications 135 Dialoge 51 – org.eclipse.core.runtime.product 135 – createButtonsForButtonBar() 233 – org.eclipse.ui.bindings 135 – Eclipse RCP 3 229 – org.eclipse.ui.commands 135 – Eclipse RCP 4 367 – org.eclipse.ui.intro 135 – SWT 51 – org.eclipse.ui.perspectives 135 DirectoryDialog 51 – org.eclipse.ui.views 135 Display 40, 48 dispose() 40 Fauth, Dirk 423 dispose(), SWT 49 Feature-Export DOM 452 – Eclipse RCP 3 322 Download der Beispielprogramme 9 Features 26, 307 Download der Beispielprojekte 9 Fehlende Bibliotheken 445 Dynamisches Modulsystem 17 Fehlende Plug-ins 444 Fehlerhafte Importe 447 Fenster auswählen e3 452 – Eclipse RCP 3 (Actions) 199 e4 15, 329, 452, 453 FileDialog 51 Eclipse 3.x (Einführung) 15 fillMenuBar(), Klasse ActionBarAdvisor 134 Eclipse 4 TranslationService 423 FilteredPreferenceDialog 411 Eclipse 4.5 5 FontDialog 51 Eclipse 4.5 »Mars« 4, 5 Eclipse-Committer 452 Eclipse e3 452 getCurrent(), SWT 49 Eclipse e4 329, 453 getDefault(), SWT 49 – Einführung 15 getInitialSize(), Klasse ApplicationWindow 93 – Tooling 5 getInitialWindowPerspectiveId(), Eclipse-Entwicklungsumgebung 4, 24 WorkbenchAdvisor 131 Eclipse-IDE 4, 453 Glossar 451 Eclipse-Klassen werden nicht gefunden 445 Group 61 Eclipse Modeling Framework 330 Eclipse-Plug-ins 20 Handler Eclipse RCP 3 115 – Eclipse RCP 3 (Commands) 203 – Einführung 15 – Eclipse RCP 4 349 Eclipse RCP 4 329 HDBMS 158 Eclipse Rich Client Platform 13 – Eclipse RCP 3 158 Editoren 24 – Eclipse RCP 4 347 – Eclipse RCP 3 271 Headless Plug-in – Eclipse RCP 4 395 – Eclipse RCP 3 119 EMF 330 Hilfe Entwicklungsumgebung 3 – Einführung 27 Equinox 17, 19 Hilfesystem Ereignisschleife 40, 48 – Einführung 27 Executive Environment Hypersonic DBMS 158 – Eclipse RCP 3 119 – Eclipse RCP 4 347 458 Stichwortverzeichnis
IDE 453 – getAllVocablesByCompartment() 168, 169 Import – getFillingLevel() 169 – Eclipse RCP 3 204 – getLastFreeVocablePosition() 170 – Eclipse RCP 4 356 – getNumberOfLessons() 171 initialize(), WorkbenchAdvisor 131 – getOldestVocables() 171 Installation Eclipse e4 Tooling 5 – getVocableById() 170 Installation Eclipse-IDE 4, 5 – getVocabulary() 167 Installed (Bundle-Lifecycle) 20 – insertVocable() 172 Integrated Development Environment 453 – isUpdatable() 173 Internationalisierung – moveVocable() 174 – Eclipse RCP 3 311 – moveVocableAndRenumberVocablePositions() – Eclipse RCP 4 423 173 Intro – renumberVocablePositions() 174, 175 – Eclipse RCP 3 138, 140 – updateEnglishTranslation() 175 – Einführung 27 Klasse VocableDialog (Eclipse RCP 3 230 isDisposed(), SWT 49 Konfiguration – Eclipse RCP 3 134 JAR in OSGi-Bundle konvertieren 160 Konfiguration SWT/JFace 38 JAR-Integration als OSGi-Bundle 160 Language Packs 316 Java Runtime Environment 3 Launching JavaFX 44, 453 – Produkt 321 JDBC 163 Layoutmanager 101 JFace 24, 42, 67 LCD-Ansatz 34 – Actions 97 Leitner-Methode 146 – ApplicationWindow 69 Leitner, Sebastian 146 – ApplicationWindow() 93 Licensing – createContents() 93 – Produkt 322 – createCoolBarManager 93 List 55 – createMenuManager() 93 Location – createStatusLineManager() 93 – Eclipse RCP 3 117 – Dialog 73 Logging 368 – getInitialSize() 93 Look & Feel 35, 38 – MenuManager 98 Lowest Common Denominator 34 – TitleAreaDialog 231, 236, 239 – Window 69 MAddon 331 – WindowManager 69 Main 125 Jigsaw 17 makeActions(), Klasse ActionBarAdvisor) 134 JPA 163 MANIFEST.MF 124 JSE 453 – Eclipse RCP 3 121 MApplication 331 Key Bindings Mars (Eclipse 4.5) 4, 5 – Eclipse RCP 3 (Actions) 181 MDirtyable 331 – Eclipse RCP 3 (allgemein) 137 Menüs – Eclipse RCP 3 (Commands) 203 – Eclipse RCP 3 (Commands) 203 – Eclipse RCP 4 349 – Eclipse RCP 4 349 Klasse »Database« 164 Menü »Datei« Klasse »TrainingDialog« 238 – Commands 208 Klasse »TrainingStatisticDao« 175 Menü »Fenster« – getAllTrainingStatistics() 176 – Eclipse RCP 3 (Actions) 191 – getTrainingStatistic() 177 – Eclipse RCP 3 (Commands) 216 – insertTrainingStatistic() 177 Menü »Hilfe« – isUpdatable() 178 – Eclipse RCP 3 (Actions) 199 – saveTrainingStatistic() 178 Menü »Training« – updateEnglishTranslation() 176 – Commands 213 – updateTrainingStatistic() 178 – Eclipse RCP 3 (Commands) 227 Klasse »VocabularyDao« 166 MenuBar – createObjectFromRow() 167 – Eclipse RCP 3 (Commands) 206 Stichwortverzeichnis 459
Menübefehl »Neues Fenster« org.eclipse.swt.widgets.Coolbar 59 – Eclipse RCP 3 (Actions) 191 org.eclipse.swt.widgets.Display 48 – Eclipse RCP 3 (Commands) 216 org.eclipse.swt.widgets.Group 59, 61 Menübefehl »Neue Vokabel« org.eclipse.swt.widgets.Shell 50 – Commands 210, 215, 228 org.eclipse.swt.widgets.Spinner 59 Menübefehl »Trainingserfolg« org.eclipse.swt.widgets.TabFolder 59, 63 – Commands 221 org.eclipse.swt.widgets.Table 59, 62 Menübefehl »Trainingsstatistik« org.eclipse.swt.widgets.ToolBar 59, 65 – Commands 224 org.eclipse.swt.widgets.Tree 59, 65 Menüleiste org.eclipse.ui.bindings 135 – Eclipse RCP 3 (Actions) 183 org.eclipse.ui.commands 135 – Eclipse RCP 3 (Commands) 206 org.eclipse.ui.edit.copy MenuManager (JFace) 98 – Eclipse RCP 3 204 MessageBox 51 – Eclipse RCP 4 356 Migration von Eclipse RCP 3 nach RCP 4 435 org.eclipse.ui.edit.cut Model View Controller 42, 80 – Eclipse RCP 3 204 Modularisierung – Eclipse RCP 4 356 – Eclipse e4 417 org.eclipse.ui.edit.delete – Eclipse RCP 3 301 – Eclipse RCP 3 204 Module 17, 453 – Eclipse RCP 4 356 Modulmechanismus 17 org.eclipse.ui.edit.export Modulsystem 17 – Eclipse RCP 3 204 MPart 331 – Eclipse RCP 4 356 MPartDescriptor 331 org.eclipse.ui.edit.import MPerspective 331 – Eclipse RCP 3 204 MTrimmedWindow 331 – Eclipse RCP 4 356 MVC 42, 80 org.eclipse.ui.edit.paste MWindow 331 – Eclipse RCP 3 204 – Eclipse RCP 4 356 Name des Plug-ins org.eclipse.ui.edit.redo – Eclipse RCP 3 119 – Eclipse RCP 3 204 Native Widgets 36 – Eclipse RCP 4 356 net.steppan.vocat.dialogs.TrainingDialog 238 org.eclipse.ui.edit.selectAll Neues Dateimenü – Eclipse RCP 3 204 – RCP 3 208 – Eclipse RCP 4 356 Neues Menü org.eclipse.ui.edit.undo – RCP 3 213 – Eclipse RCP 3 204 Neuer Menübefehl – Eclipse RCP 4 356 – Eclipse RCP 4 353 org.eclipse.ui.file.exit NLS 453 – Eclipse RCP 3 204 No application id has been found 443 – Eclipse RCP 4 356 NON-NLS 453 org.eclipse.ui.file.save – Eclipse RCP 3 204 openIntro(), WorkbenchWindowAdvisor 133 – Eclipse RCP 4 356 org.eclipse.core.runtime.applications 135 org.eclipse.ui.file.saveAll org.eclipse.core.runtime.product 135 – Eclipse RCP 3 204 org.eclipse.jface.dialogs.Dialog – Eclipse RCP 4 356 – createButtonsForButtonBar() 233 org.eclipse.ui.help.aboutAction org.eclipse.jface.dialogs.MessageDialog 244 – Eclipse RCP 3 204 org.eclipse.jface.window.ApplicationWindow 69 – Eclipse RCP 4 356 org.eclipse.jface.window.Window org.eclipse.ui.intro 135 – configureShell() 232, 240 org.eclipse.ui.perspectives 135 org.eclipse.jface.window.WindowManager 69 org.eclipse.ui.views 135 org.eclipse.swt.custom.SashForm 65 org.eclipse.ui.window.preferences org.eclipse.swt.widgets.Button 53 – Eclipse RCP 3 204 org.eclipse.swt.widgets.Combo 59, 60 – Eclipse RCP 4 356 org.eclipse.swt.widgets.CoolBar 60 OSGi 17, 19 460 Stichwortverzeichnis
OSGi-Manifest Product – Eclipse RCP 3 139 – Eclipse RCP 3 138, 320 Overview Produktexport – Eclipse RCP 3 121 – Eclipse RCP 3 319 – Produkt 320 – Eclipse RCP 4 429 Programmeinstellungen p2 – Eclipse RCP 3 291 – Eclipse RCP 3 324 – Eclipse RCP 4 411 – Eclipse RCP 4 430 Programmlogik – Einführung 26 – Eclipse RCP 3 145 parentShell 239 – Eclipse RCP 4 341 Parts Project Settings – Allgemein 24 – Eclipse RCP 3 117 – Eclipse RCP 4 379, 395 Projekt Name Paste – Eclipse RCP 3 117 – Eclipse RCP 3 204 Projekteinstellungen – Eclipse RCP 4 356 – Eclipse RCP 3 117 PDE 454 Projektimport 446 Perspektive Projektname – Allgemein 25 – Eclipse RCP 3 117 – Eclipse RCP 3 135, 283 Provisioning 2.x – Eclipse RCP 4 403 – Eclipse RCP 3 324 Perspektive auswählen – Eclipse RCP 4 430 – Eclipse e4 359 – Einführung 26 – Eclipse RCP 4 359, 369 Push Button 53 Plug-in 17, 126 Radio Button 53 Plug-in (Definition) 454 RAP 27 Plug-in Development Environment 454 RAP Widget Toolkit 27 Plug-in-Export RCP 13, 454 – Eclipse RCP 3 322 RCP 2.x (Einführung) 15 Plug-in ID RCP 3 115 – Eclipse RCP 3 119 – Einführung 15 Plug-in-Konfiguration 134 RCP-Architektur 16 – Eclipse RCP 3 121 readAndDispatch(), SWT 49 Plug-in-Lifecycle 20 Redo – Active 20 – Eclipse RCP 3 204 – Installed 20 – Eclipse RCP 4 356 – Resolved 20 Refactoring 303 – Starting 20 Registerkarte »Arguments« 126 – Stopping 20 Registerkarte »Main« 125 – Uninstalled 20 Registerkarte »Plug-ins« 126 Plug-in-Manifest 134 Remote Application Platform 27 Plug-in-System 17 Resolved (Bundle-Lifecycle) 20 Plug-in.xml Restrukturierung 303 – Command Categories 209 Rich Client Platform 13, 454 – Commands 209 Run-Konfiguration 125 plugin.xml 125 Runtime – Eclipse RCP 3 121 – Eclipse RCP 3 121 Portierungsprobleme 36 RWT 27 Preferences – Eclipse RCP 3 204, 291 SashForm 65, 82 – Eclipse RCP 4 356, 411 Save PreferenceDialog 411 – Eclipse RCP 3 204 preWindowOpen(), WorkbenchWindowAdvisor – Eclipse RCP 4 356 133 Save All PrintDialog 51 – Eclipse RCP 3 204 Probleme nach einem Refactoring 447 – Eclipse RCP 4 356 Stichwortverzeichnis 461
Schaller, Beat 430 – getCurrent() 49 Schindl, Thomas (Tom) 423 – getDefault() 49 Schwache Abstraktion 40 – Group 59, 61 Scrollable 55 – isDisposed() 49 Select All – List 55 – Eclipse RCP 3 204 – MessageBox 51 – Eclipse RCP 4 356 – PrintDialog 51 Separator – Push Button 53 – Eclipse RCP 3 (Actions) 192 – Radio Button 53 – Eclipse RCP 3 (Commands) 217 – readAndDispatch() 49 Services – SashForm 65, 82 – ECommandService 331 – Scrollable 55 – EHandlerService 331 – Shell 50 – EModelService 331 – sleep() 49 – EPartService 331 – Spinner 59 – ESelectionService 331 – TabFolder 59, 63 – IEclipseContext 331 – Table 59, 62 – IServiceConstants 331 – Text 57 – IWorkbench 331 – Toggle Button 54 – Logger 331 – ToolBar 59, 65 – TranslationService 331 – Tree 59, 65 Service Registry 19 SWT- und JFace-Bibliotheken 7 Shell 40, 50 SWT-Architektur 31 Short Cuts SWT-Chart-Plug-in 251 – Eclipse RCP 3 (Commands) 203 SWT-Designer 8 – Eclipse RCP 4 349 SWT-Dialoge 51 Sichten 24 SWT-Klassen werden nicht gefunden 445 sleep(), SWT 49 Symbolbefehl »Neue Vokabel« Snippets 331 – Commands 211 Softwareaktualisierung Symbolbefehl »Training starten« – Eclipse RCP 3 324 – Commands 215 – Eclipse RCP 4 430 Symbolbefehl »Trainingserfolg« – Einführung 26 – Commands 221 Span 107 Symbolbefehl »Trainingsstatistik« Speicherort – Commands 225 – Eclipse RCP 3 117 Symbolleiste Splash – Eclipse RCP 3 (Actions) 184 – Produkt 321 – Eclipse RCP 3 (Commands) 203, 207 Standard Widget Toolkit 35, 47, 454 – Eclipse RCP 4 349 Starting (Bundle-Lifecycle) 20 Symbolleiste hinzufügen Stopping (Bundle-Lifecycle) 20 – JFace 98 Swing 35 SWT 24, 35, 47, 454 TabFolder 63 – Arrow Button 53 Table 62 – Button 52, 53 Target Platform – Check Button 53 – Eclipse RCP 3 117 – ColorDialog 51 Tastaturbefehl »Neue Vokabel« – Combo 59, 60 – Commands 211 – Composite 56, 59 Tastaturbefehl »Training starten« – Control 52 – Commands 216 – Coolbar 59, 60 Tastaturbefehl »Trainingserfolg« – Dialog 51 – Commands 222 – DirectoryDialog 51 Tastaturbefehl »Trainingsstatistik« – Display 48 – Commands 225 – dispose() 49 Tastenkombinationen – FileDialog 51 – Eclipse RCP 3 (Commands) 203 – FontDialog 51 – Eclipse RCP 4 349 462 Stichwortverzeichnis
Tastenkürzel Views 24 – Eclipse RCP 3 (Actions) 181 – Eclipse e4 379 – Eclipse RCP 3 (Commands) 203 – Eclipse RCP 3 136, 249 Text 57 VisualAge 14 TitleAreaDialog 231, 236, 239 VocableDialog 230 – createDialogArea() 232 Vocat 129 – getInitialSize() 245 Vogel, Lars 430 – setMessage() 232 Vokabeltrainer – setTitle() 232 – Programmlogik (Eclipse RCP 3) 145 Toggle Button 54 ToolBar 65 Widget 454 – Eclipse RCP 3 (Actions) 184 Willkommensseite – Eclipse RCP 3 (Commands) 203, 207 – Eclipse RCP 3 138, 140 – Eclipse RCP 4 349 – Einführung 27 ToolBarManager 98 Window (JFace) 69 TrainingDialog 238 WindowBuilder 8, 38 TrainingStatistic 162 WindowManager (JFace) 69 TranslationService 423 Wizards 79 Tree 65 Workbench 24, 129, 454 Workbench-Fenster 24 Workbench-Modell 330, 454 UI 454 – Add-ons 330 UI-Plug-in 303 – Binding Contexts 330 UI-Toolkits 7, 24, 31 – Binding Tables 330 Unable to load class . . . 449 – Command Categories 330 Undo – Commands 330 – Eclipse RCP 3 204 – Handlers 330 – Eclipse RCP 4 356 – Menu Contributions 330 Unerwünschte Plug-ins 447 – Snippets 330 Uninstalled (Bundle-Lifecycle) 20 – Toolbar Contributions 330 UnsatifiedLinkError 446 – Trim Contributions 330 Updates – Windows and Dialogs 330 – Produkt 322 Workbench-Modell Descriptors 330 Update-Funktion WorkbenchAdvisor 131 – Eclipse RCP 3 324 – createWorkbenchWindowAdvisor() 131 – Eclipse RCP 4 430 – getInitialWindowPerspectiveId() 131 – Einführung 26 – initialize() 131 Update-Mechanismus WorkbenchWindowAdvisor 132 – Eclipse RCP 3 324 – createActionBarAdvisor() 133 – Eclipse RCP 4 430 – createWindowContents() 133 – Einführung 26 – openIntro() 133 – preWindowOpen() 133 Vendor des Plug-ins Working Sets – Eclipse RCP 3 119 – Eclipse RCP 3 117 Veraltete Beispiele 447 Workspace 21 Version des Plug-ins Write once, run anywhere 36 – Eclipse RCP 3 119 Verteilung XWT 44 – Eclipse RCP 3 319 – Eclipse RCP 4 429 Zielplattform – Einführung 26 – Eclipse RCP 3 117