5 Tage | Softwareentwickler und -architekten |
Schulungsüberblick
In dieser intensiven Schulung lernen Sie die professionelle Entwicklung von Eclipse RCP-Anwendungen
auf dem neuesten Stand des aktuellen Eclipse-Releases kennen.
Der Praxisteil macht etwa 50 % der Schulung aus.
Durch viele optionale Inhalte eignet sich diese Schulung sowohl für Neulinge
als auch für Entwickler mit Vorkenntnissen in Eclipse RCP Programmierung.
Die Schulung basiert auf der aktuellen Eclipse Release. Auf Wunsch kann auch die Migration von Eclipse 3.X RCP-Anwendungen auf das aktuelle 4.x Release behandelt werden.
Schulungsvoraussetzungen
Vorausgesetzt werden Kenntnisse der Java-Programmierung
und Grundkenntnisse im Umgang mit der Eclipse IDE.
Optional kann auch Vorbereitungsmaterial zur Einarbeitung in die Java Programmierung vor dem Kurs bereitgestellt werden.
Kundenrezensionen
Online Training
Sprache | Preis | |||
---|---|---|---|---|
Eclipse RCP Entwicklung im vogella interaktiven Lernportal | Englisch | 490 EUR * | ||
* Jahresgebühr für das erste Jahr. Für jedes weitere Jahr beträgt die Jahresgebühr 110 EUR. Alle Preise zzgl. Mehrwertsteuer. |
Onsite oder virtuelle Training
Ort | Termin | Sprache | Schulungsgebühr | |
---|---|---|---|---|
Bei Ihnen Vorort oder virtuell | Nach Absprache | Deutsch / Englisch | Auf Anfrage |
Introduction into Eclipse and Eclipse 4
- Components of the Eclipse platform
- Eclipse 3.x in comparison with Eclipse 4.x
- Eclipse license
- Internet information sources
Eclipse architecture
- Software components
- Configuration files (plugin.xml, MANIFEST.MF)
- Extensions and extension points
- Important user interface components
Deployment of an Eclipse product
- Product configuration file
- Feature projects
- Branding and product export
- Run configuration
- Problem analysis during export
Eclipse 4 application model
- Application model and model components
- Model editor
- Naming schema for ID's
Dependency injection and annotations
- Overview dependency injection
- Dependency injection framework in Eclipse
- Field, method and constructor dependency injection
- Behavior annotations
- Application lifecycle annotations
Commands, Handlers, Menus and Toolbars
- Contributing to the menu and the toolbar
- Handling of popup menus
- Scope of handlers and core expressions
- Defining keybindings
Scope of injection
- IEclipseContext
- Injection search strategy
- Creation of injectable objects
- Model elements and dependency injection
Modularity of the Eclipse platform with OSGi
- Plug-ins and bundles
- Definition of dependencies between plug-ins
- Fragment projects
- OSGi framework start configuration and usage of the OSGi console
OSGi services
- Services and the OSGi service registry
- Publishing services via OSGi declarative services
- Usage of services in Eclipse 4
- OSGi declarative service definition with annotations
User interface development with SWT
- Overview Standard Widget Toolkit
- SWT event handling
- SWT layout manager: FillLayout, RowLayout and GridLayout
- User interface builder: SWT Designer
- Custom widgets and Nebula widgets
Introduction JFace
- Overview JFace components
- SWT resource management
- Control decorations for user feedback
- Introduction into the Viewer framework (LabelProvider, ContentProvider, ComboViewer)
- Handling Viewer selection
JFace TableViewer and TreeViewer
- ColumnLabelProvider and CellLabelProvider
- Editable tables
- Sorting, filtering, layouts and own label provider
Dialog and Wizards
- SWT standard dialogs
- JFace Dialogs
- JFace Wizards
Declarative styling with CSS
- Introduction into CSS
- Definition of styles and themes, colors and gradients
- Styling specific widgets
- Dynamic style switching at runtime
- Using the CSS Spy tooling
Platform services and interaction of components
- Service overview
- Part service
- Model service
- Selection service
- Command and Handler service
Editor handling in Eclipse 4
- Comparison Views and Editors
- Getting parts which behave as editors
- Using services to interact with parts
Accessing and extending the Eclipse context
- Accessing the context
- Extending the Eclipse context with own objects
- Using dependency injection to create own objects
Settings and preferences
- Configuration area and workspace
- Persistence of the Eclipse application
- Part persistence
- Dependency injection for preference values
Modularity for Eclipse 4 applications
- Contributing to the application model
- Static model contributions with fragments
- Dynamic model contributions with processors
Internationalization (i18n)
- Adding support for multiple languages
- Usage of fragment projects
- Outlook: translation services in Eclipse 4
Concurrent UIs
- SWT threading
- Avoiding invalid thread access
- Asynchronous processing with the Eclipse API
JFace Data Binding
- Introduction into databinding
- Observing properties
- Conversion, validation and update strategies
- Databinding for JFace Viewers
- Master / detail bindings
Target Platform
- Definition of development components
- Creation of target platform definitions
Migrating Eclipse 3.x applications
- Running Eclipse 3.x applications on top of Eclipse 4
- Mixing Eclipse 3.x and Eclipse 4.x components
- Discussion: Migration path for existing applications
Definition of own annotations for dependency injection
- Definition of new annotations
- Evaluation of new annotations
- Use cases
Creating and evaluating extension points
- Eclipse extensions and extension points
- Accessing existing extensions
- Creating and evaluating a new extension point
The Renderer framework
- Purpose of the Renderer framework
- Define your own renderer
- Outlook: Using an alternative renderer
- Outlook: Extending the application model
Building Eclipse applications with Maven
- High level overview of Tycho
- Building plug-ins, features, products and update sites
- Executing plug-in unit tests with Tycho