Eclipse 4 RCP: The complete guide to Eclipse application development (Converted)

✍ Scribed by Lars Vogel, Mike Milinkovich

• Publisher: Lars Vogel
• Year: 2013
• Tongue: English
• Leaves: 1226
• Series: Vogella
• Category: Library

✦ Table of Contents

Foreword
Preface
1. Welcome
2. About the Author
3. How this book is organized
4. Prerequisites
5. Errata
6. Exercises and examples
7. Long lines
8. Example code
9. Acknowledgment
I. Overview of Eclipse
1. Introduction into Eclipse
1.1. What is Eclipse?
1.2. Eclipse Foundation
1.3. Eclipse Public License
1.4. What are Eclipse RCP applications?
1.5. Advantages of Eclipse based applications
2. Eclipse 4
2.1. What is Eclipse 4?
2.2. Eclipse 4 vs. Eclipse 3.x
2.3. Terminology
3. Important Eclipse projects for RCP
3.1. The Eclipse Platform project
3.2. What is the Eclipse e4 project?
3.3. The e4 tools project
4. Architecture of Eclipse
4.1. Eclipse based applications
4.2. Core components of the Eclipse platform
4.3. Compatibility layer for Eclipse 3.x plug-ins
4.4. Eclipse RCP
4.5. Provisional API
4.6. Important configuration files
II. Setting up Eclipse 4
5. Using the update manager
5.1. Purpose of this chapter
5.2. Eclipse update manager
5.3. Performing an update and install new features
5.4. See the installed components
5.5. Uninstalling components
5.6. Restarting Eclipse
6. Installation of the required tools
6.1. Prerequisites
6.2. Download and install the Eclipse SDK
6.3. Install the e4 tools
6.4. Eclipse e4 tools update site
7. Exercise: Start Eclipse and use new workspace
7.1. About the Eclipse IDE
7.2. Workspace
8. Exercise: IDE preference settings
8.1. Configuration
8.2. Link Java editor with the Package Explorer view
8.3. Java editor settings
8.4. Bracket highlighting
8.5. Launch configuration
8.6. Use Type Filters
8.7. Activate Save Actions
III. Develop and deploy Eclipse RCP applications
9. Exercise: Wizard to create RCP application
9.1. Create project
9.2. Launch
10. Product configuration file and branding
10.1. Product and application
10.2. Feature or plug-in based products
10.3. Splash screen
10.4. Icons, launcher name and program arguments
10.5. Eclipse 4 product configuration limitations
11. The usage of run configurations
11.1. What are run configurations?
11.2. Launch configuration and Eclipse products
11.3. Launch arguments
12. Common launch problems
12.1. Launch problem number #1: missing plug-ins
12.2. Checklist for other common problems
13. Features and feature projects
13.1. What are feature projects and features?
13.2. Advantages of using features
13.3. Creating a feature
14. Deployment of your RCP application
14.1. Exporting via the product file
14.2. Which artifacts are included in the export?
14.3. Export for multiple platforms via the delta pack
14.4. More about the target platform
14.5. Including the required JRE into the export
14.6. Headless build
15. Common problems while exporting your product
15.1. Export problem number #1: export folder is not empty
15.2. Checklist for common export problems
16. Exercise: Export your product
16.1. Export your product
16.2. Add a splash screen
16.3. Include splash screen into the exported application
16.4. Change launcher name
16.5. Create feature project
16.6. Change product configuration file to use features
IV. Application model
17. Eclipse application model
17.1. What is the application model?
17.2. Scope of the application model
17.3. How do you define the application model?
18. Important user interface model elements
18.1. Window
18.2. Views and editors - parts
18.3. Perspective
18.4. PartStack and PartSashContainer
18.5. Using layout weight data for children elements
19. Connecting model elements to classes and resources
19.1. Connect model elements to classes
19.2. Connect model elements to resources
19.3. URI patterns
19.4. Model objects
19.5. Runtime application model
20. Model addons
20.1. What are addons?
20.2. Addons from the Eclipse framework
20.3. Additional SWT addons
20.4. Relationship to other services
20.5. More about the event service and renderer framework
21. Supplementary model data
21.1. Supplementary data
21.2. Tags
21.3. Persisted state
21.4. Transient data
22. IDs and suggested naming conventions
22.1. Identifiers for model elements
22.2. Conventions for defining IDs
22.3. Naming conventions for projects packages and classes
23. Exercise: Create an Eclipse plug-in
23.1. Target
23.2. Create a plug-in project
23.3. Validate the result
24. Exercise: Enable IDE access to all plug-ins
24.1. Java tools filter
24.2. Include all plug-ins in Java search
25. Exercise: From plug-in to Eclipse 4 application
25.1. Create product configuration file
25.2. Create a feature project
25.3. Enter feature dependencies in product
25.4. Remove version dependency from features in product
25.5. Create application model
25.6. Add model elements to the application model
25.7. Start application
26. Exercise: Enter bundle and package dependencies
26.1. Add plug-in dependencies
26.2. Add package dependency
26.3. Remove warnings for provisional API access
27. Exercise: Modeling a user interface
27.1. Configure the deletion of persisted model data
27.2. Desired user interface
27.3. Open the Application.e4xmi
27.4. Add perspective
27.5. Add PartSashContainer and PartStacks
27.6. Create the parts
27.7. Validate user interface
27.8. Create Java classes
27.9. Connect the Java classes with your parts
27.10. Validate
V. Annotations and dependency injection
28. The concept of dependency injection
28.1. What is dependency injection?
28.2. Using annotations to describe dependencies
28.3. Where can values be injected?
28.4. Order in which injection is done
29. Dependency injection in Eclipse
29.1. Define dependencies in Eclipse
29.2. On which objects does Eclipse perform dependency injection?
29.3. Re-injection
30. Objects available for dependency injection
30.1. Eclipse context
30.2. Context relationship
30.3. Which model elements have a local context?
30.4. How are objects selected for dependency injection
30.5. Default objects for dependency injection
30.6. Creation process of the Eclipse context
30.7. Getting the active part or shell
30.8. Tracking a child context with @Active
VI. Behavior annotations
31. Using annotations to define behavior
31.1. API definition via inheritance
31.2. API definition via annotations
32. Exercise: Using dependency injection
32.1. Getting a Composite
32.2. Validation
33. Exercise: Using @PostConstruct
33.1. Why using @PostConstruct?
33.2. Implement @PostConstruct
33.3. Implement @Focus and test your application
33.4. Validate
VII. OSGi modularity
34. OSGi Overview
34.1. What is OSGi
34.2. Bundle vs. plug-in
34.3. Implementations
34.4. Eclipse Equinox
35. OSGi bundles and dependency management
35.1. OSGi bundles
35.2. Bundle-SymbolicName and Version
35.3. Semantic Versioning with OSGi
35.4. Field identifier in MANIFEST.MF
35.5. Bundle dependencies and public API
35.6. Provisional API and friends
35.7. Dynamic imports of packages
35.8. OSGi dependency management
35.9. Bundle life cycle
35.10. Find plug-in for a certain class
36. OSGi console
36.1. OSGi console
36.2. Required bundles
36.3. Telnet
36.4. Access to the Eclipse OSGi console
37. Exercise: Data model and service bundle
37.1. Target of the exercise
37.2. Naming convention: simple plug-in / bundle
37.3. Create plug-in
37.4. Create base class
37.5. Generate constructors
37.6. Generate getter and setter methods
37.7. Validation
37.8. Generate toString, hashCode and equals methods
37.9. Write a copy method
37.10. Create model interface
37.11. Export the model
37.12. Create data model provider plug-in
37.13. Prepare service plug-in
37.14. Create factory and export package
38. Exercise: Use the new bundles
38.1. Update plug-in dependencies
38.2. Update product configuration
38.3. Using the data model provider in your parts
38.4. Review your implementation
39. OSGi fragments and fragment projects
39.1. What are fragments in OSGi?
39.2. Using fragments
VIII. OSGi Services
40. OSGi service introduction
40.1. What are OSGi services?
40.2. Best practices for defining services
40.3. Service properties
40.4. Selection of OSGi services
41. Declarative OSGi services
41.1. Defining declarative services
41.2. Required bundles
41.3. Definition of a DS service
41.4. Defining Auto-Start
41.5. Low-level OSGi service API
41.6. Start level in Eclipse products
41.7. OSGi services and Eclipse dependency injection
42. Exercise: Define and use an OSGi service
42.1. Define a declarative OSGi service
42.2. Set start level in the product
42.3. Set the lazy activation flag for the service plug-in
42.4. Clean-up the service implementation
42.5. Test your new setup
42.6. Delete factory implementation
42.7. Review the service implementation
43. Exercise: Create an image loader service
43.1. Create bundle and interface
43.2. Create service implementation
43.3. Define a new service
43.4. Add new bundle to your feature project
43.5. Export API and enter dependencies
43.6. Using the new service
43.7. Review implementation
IX. User Interface Development with SWT
44. Standard Widget Toolkit
44.1. What is SWT?
44.2. Eclipse plug-in development and SWT
44.3. Display and Shell
44.4. Event loop
44.5. Using SWT in Java projects
44.6. Using SWT in a plug-in project
45. Using SWT widgets
45.1. Available widgets in the SWT library
45.2. Memory management
45.3. Constructing widgets
45.4. Basic containers
45.5. Event Listener
46. SWT layouts
46.1. The role of a layout manager
46.2. Layout Data
46.3. FillLayout
46.4. RowLayout
46.5. GridLayout
46.6. Tab order of elements
46.7. Example: Using layout manager
47. SWT widget examples and controls
47.1. SWT snippets, examples and more widgets
47.2. Relationship to JFace
48. SWT Designer
48.1. SWT Designer
48.2. Install SWT Designer
48.3. Using SWT Designer
49. Exercise: Getting started with SWT Designer
49.1. Installation
49.2. Building an user interface
49.3. Creating an event handler
49.4. Review the generated code
50. Exercise: Build an SWT user interface
50.1. TodoOverviewPart
50.2. TodoDetailsPart
50.3. Implement @Focus
50.4. Validate
51. Exercise: Prepare TodoDetailsPart for data
51.1. Preparing for data
51.2. Add dependency
51.3. Prepare for dependency injection
52. Exercise: Using the SWT Browser widget
52.1. Implementation
52.2. Solution
X. User Interface Development with JFace
53. JFace
53.1. What is Eclipse JFace?
53.2. JFace resource manager for Colors, Fonts and Images
53.3. ControlDecoration
53.4. User input help with field assistance
53.5. Purpose of the JFace viewer framework
53.6. Standard JFace viewer
53.7. JFace ComboViewer
54. Exercise: Using ComboViewer
54.1. Target
54.2. Implementation
54.3. Validation
55. JFace TableViewer
55.1. TableViewer
55.2. ContentProvider for TableViewer
55.3. Columns and label provider
55.4. Reflect data changes in the viewer
55.5. Selection change listener
55.6. Column editing support
55.7. Filtering data
55.8. Sorting data with ViewerComparator
55.9. TableColumnLayout
55.10. StyledCellLabelProvider and OwnerDrawLabelProvider
55.11. Table column menu and hiding columns
55.12. Tooltips for viewers
55.13. Virtual tables with LazyContentProvider
55.14. Alternative table implementations
56. Exercise: Using TableViewer
56.1. Create a JFace TableViewer for the Todo items
56.2. Validate
57. Exercise: Using more JFace functionality
57.1. Add a filter to the table
57.2. Add a ControlDecoration to the TodoDetailsPart
58. JFace TreeViewer
58.1. Using viewers to display a tree
58.2. Selection and double-click listener
59. Exercises: Using TreeViewer
59.1. Create a new application
59.2. Add an image file
59.3. Create a part
59.4. Validate
XI. Defining menus and toolbars
60. Menu and toolbar application objects
60.1. Adding menu and toolbar entries
60.2. What are commands and handlers?
60.3. Mnemonics
60.4. Standard commands
60.5. Naming schema for command and handler IDs
61. Dependency injection for handler classes
61.1. Handler classes and their behavior annotations
61.2. Which context is used for a handler class?
61.3. Evaluation of @CanExecute
61.4. Scope of handlers
62. Exercise: Adding menus and toolbars
62.1. Target of this exercise
62.2. Create command model elements
62.3. Creating the handler classes
62.4. Creating handler model elements
62.5. Adding a menu
62.6. Adding a toolbar
62.7. Implement handler class for exit
62.8. Validate
63. View, popup and dynamic menus
63.1. View menus
63.2. Popup menu
63.3. Dynamic menu and toolbar entries
63.4. Creating dynamic menu entries
64. Exercise: Add a context menu to a table
64.1. Target
64.2. Dependencies
64.3. Implementation
65. Toolbars, ToolControls and drop-down tool items
65.1. Adding toolbars to parts
65.2. ToolControls
65.3. Drop-down tool items
66. More on commands and handlers
66.1. Passing parameters to commands
66.2. Usage of core expressions
66.3. Evaluate your own values in core expressions
XII. Using key bindings
67. Key bindings
67.1. Using key bindings in your application
67.2. JFace default values for binding contexts
67.3. Define Shortcuts
67.4. Key bindings for a part
67.5. Activate bindings
68. Exercise: Define key bindings
68.1. Create binding context entries
68.2. Create key bindings for a BindingContext
68.3. Live model editor
XIII. Dialogs and wizards
69. Dialogs
69.1. Dialogs in Eclipse
69.2. SWT dialogs
69.3. JFace Dialogs
70. Exercise: Dialogs
70.1. Confirmation dialog at exit
70.2. Create a password dialog
71. Wizards
71.1. Usage of wizards
71.2. Wizards and WizardPages
71.3. Starting the Wizard
71.4. Changing the page order
71.5. Working with data in the wizard
71.6. Updating the Wizard buttons from a WizardPage
72. Exercise: Create a wizard
72.1. Create classes for the wizard
72.2. Adjust part
72.3. Adjust handler implementation
72.4. Validate
XIV. Data Binding with JFace
73. Data Binding with JFace
73.1. What are Data Binding frameworks?
73.2. JFace Data Binding
73.3. Reacting to changes via property change listeners
74. Creating bindings
74.1. Java POJO vs Java Bean
74.2. Data Binding and POJOs
74.3. Observable
74.4. How to observe properties
74.5. Observing nested properties
74.6. DataBindingContext
74.7. JFace Data Binding Plug-ins
75. More on bindings
75.1. UpdateValueStrategy
75.2. Converter and Validator
75.3. ControlDecorators
75.4. Placeholder binding with WritableValue
75.5. Listening to all changes in the binding
75.6. More information on Data Binding
76. Exercise: Data Binding for SWT widgets
76.1. Add plug-in dependencies
76.2. Implement property change support
76.3. Remove the modification listeners in your code
76.4. Implement data binding
76.5. Validate
77. Data Binding for JFace viewer
77.1. Binding Viewers
77.2. Observing list details
77.3. ViewerSupport
77.4. Master Detail binding
77.5. Chaining properties
78. Exercise: Data Binding for viewers
78.1. Implement Data Binding for the viewer
78.2. Clean up old code
78.3. Validate
XV. Overview of Eclipse services
79. Eclipse platform services
79.1. What are Eclipse platform services?
79.2. Overview of the available platform services
80. Implementation
80.1. How are Eclipse platform services implemented?
80.2. References
XVI. Selection Service
81. Selection service
81.1. Usage of the selection service
81.2. Changing the current selection
81.3. Getting the selection
82. Exercise: Selection service
82.1. Target of this exercise
82.2. Retrieving the selection service
82.3. Setting the selection in TodoOverviewPart
82.4. Review TodoDetailsPart
82.5. Validate selection propagation
83. Exercise: Selection service for deleting data
83.1. Implement the RemoveTodoHandler handler
83.2. Validate that the deletion works
83.3. Test the context menu for deletion
XVII. Model service and model modifications at runtime
84. Model service
84.1. What is the model service?
84.2. How to access the model service
84.3. Cloning elements or snippets
84.4. Searching model elements
85. Modifying the application model at runtime
85.1. Creating model elements
85.2. Modifying existing model elements
86. Example for application model modifications
86.1. Example: Search perspective and change attributes
86.2. Example: Dynamically create a new window
86.3. Example: Dynamically create a new part
XVIII. Part service and implementing editors
87. Using the part service
87.1. What is the part service?
87.2. PartDescriptors
87.3. How to access the part service
87.4. Example: Showing and hiding parts
87.5. Example: Switching perspectives
87.6. Example: PartDescriptor and creating parts dynamically
88. Implementing editors
88.1. Parts which behave similar to editors
88.2. MDirtyable and @Persist
88.3. Use part service to trigger save in editors
88.4. MPart and multiple editors
88.5. MInputPart
88.6. Code examples for editor implementations
89. Exercise: Implement an editor
89.1. Convert TodoDetailsPart to an editor
89.2. Implement the save handler
89.3. Validate
89.4. Confirmation dialog for modified data
90. Exercise: Enable handlers and switching perspectives
90.1. Enable the save handler only if necessary
90.2. Avoid data loss in your ExitHandler
90.3. Switching perspectives
90.4. Using shared parts between perspectives
91. Exercise: Dynamic creation of parts based on PartDescriptors
91.1. Create PartDescriptor
91.2. Handler for creating new parts
92. Exercise: Implement multiple editors
92.1. Prerequisites
92.2. New menu entries
92.3. Validate ID of the PartStack
92.4. Add handler and part implementation
92.5. Validate multiple editor implementation
XIX. Handler and command services
93. Command and Handler service
93.1. Purpose of the command and handler service
93.2. Access to command and handler service
93.3. Example
94. Exercise: Using handler service
94.1. Delete Todos only via the handler
94.2. Implementation
XX. Asynchronous processing
95. Threading in Eclipse
95.1. Concurrency
95.2. Main thread
95.3. Using dependency injection and UISynchronize
95.4. Eclipse Jobs API
95.5. Priorities of Jobs
95.6. Blocking the UI and providing feedback
96. Progress reporting
96.1. IProgressMonitor
96.2. Reporting progress in Eclipse RCP applications
97. Exercise: Using asynchronous processing
97.1. Simulate delayed access
97.2. Use asynchronous processing
97.3. Validate
XXI. Event service for message communication
98. Eclipse event notifications
98.1. Event based communication
98.2. Event service
98.3. Required plug-ins to use the event service
98.4. Sending and receiving events
98.5. Usage of the event system
98.6. Asynchronous processing and the event bus
99. Exercise: Event notifications
99.1. Create plug-in for event constants
99.2. Add new plug-in to your product
99.3. Enter plug-in dependency
99.4. Send out notifications
99.5. Receive updates in your parts
99.6. Validate
99.7. Review the implementation
XXII. Extending and modifying the Eclipse context
100. Accessing and extending the Eclipse context
100.1. Accessing the context
100.2. Objects and context variables
100.3. Replacing existing objects in the IEclipseContext
100.4. OSGi services
100.5. Model addons
100.6. RunAndTrack
101. Using dependency injection for your Java objects
101.1. Creating and injecting custom objects
101.2. Using the Eclipse framework to create your custom objects
101.3. Create objects in the application context
101.4. Using dependency injection to create objects
XXIII. Eclipse context functions
102. Context functions
102.1. What are context functions?
102.2. Creation of a context function
102.3. Evaluation of context functions
103. Exercises: Create context function
103.1. Target
103.2. Add dependencies to service plug-in
103.3. Create class for context function
103.4. Register context function
103.5. Deactivate your ITodoService OSGi service
103.6. Notifications from the ITodoService
103.7. Clean-up your user interface code
103.8. Validate
103.9. Review implementation
XXIV. Application model modularity
104. Contributing to the application model
104.1. Modularity support in Eclipse RCP
104.2. Contributing to the application model
104.3. Constructing the runtime application model
104.4. Fragment extension elements
105. Exercise: Contributing via model fragments
105.1. Target
105.2. Create new plug-in
105.3. Add dependencies
105.4. Create a handler class
105.5. Create a model fragment
105.6. Adding model elements
105.7. Register the fragment via extension
105.8. Update product via feature
105.9. Validate
105.10. Exercise: Contributing a part
106. Exercise: Implementing model processors
106.1. Target
106.2. Enter dependencies
106.3. Create Java classes
106.4. Register processor via extension
106.5. Validate
XXV. Eclipse application life cycle
107. Registering for the application life cycle
107.1. Connecting to the Eclipse application life cycle
107.2. Accessing application startup parameters
107.3. Close static splash screen
107.4. How to implement a life cycle class
107.5. Example life cycle implementation
108. Exercises: Life cycle hook and a login screen
108.1. Target
108.2. Create new class
108.3. Register life cycle hook
108.4. Validate
XXVI. Preferences for persisting data
109. Eclipse Preferences
109.1. Preferences and scopes
109.2. Storage of the preferences
109.3. Eclipse preference API
109.4. Setting preferences via plugin_customization.ini
110. Dependency injection and annotations
110.1. Persisting data with dependency injection
110.2. Persistence of part state
111. Exercise: Preferences
111.1. Target
111.2. Dependency
111.3. Storing data via preferences
111.4. Validate menu entry
111.5. Using preferences in the life cycle class
111.6. Validate life cycle handling
XXVII. Eclipse declarative styling
112. Introduction into CSS styling
112.1. Cascading Style Sheets
112.2. Styling Eclipse applications
112.3. Limitations
113. How to style in Eclipse
113.1. Fixed styling in Eclipse
113.2. Dynamic styling using themes
114. More details on Eclipse styling
114.1. CSS attributes and selectors
114.2. Styling based on identifiers and classes
114.3. Colors and gradients
114.4. CSS support for custom widgets
114.5. CSS Tools
115. Exercise: Styling with CSS files
115.1. Target
115.2. Create CSS file
115.3. Define applicationCSS property
115.4. Validate
115.5. Adjust build.properties
116. Exercise: Using the theme service
116.1. Target
116.2. Add dependencies
116.3. Create CSS file
116.4. Remove the applicationCSS property
116.5. Create theme extensions
116.6. Validate
116.7. Implement a new menu entry
116.8. Validate theme switching
116.9. Adjust build.properties
XXVIII. Internationalization
117. Internationalization
117.1. Translation of Java applications
117.2. Property files
117.3. Relevant files for translation
117.4. Best practices
117.5. Setting the language in the launch configuration
117.6. OSGi resource bundles
117.7. Translating plugin.xml
117.8. Translating the application model
117.9. Using translations in source code
117.10. Exporting Plug-ins and Products
117.11. Eclipse 4 internationalization
117.12. Common problems with i18n
118. Exercise: Internationalization
118.1. Target
118.2. Dependencies
118.3. Translate your application
118.4. Test your translation
118.5. Create translation plug-in
XXIX. Eclipse 4 testing
119. Introduction to JUnit
119.1. Unit testing with JUnit
119.2. Available JUnit annotations
119.3. Assert statements
119.4. Create a JUnit test suite
119.5. Run your test outside Eclipse
120. Testing Eclipse 4 applications
120.1. General testing
120.2. Fragment projects
120.3. Testing user interface components
120.4. Testing dependency injection
121. UI testing with SWTBot
121.1. User interface testing with SWTBot
121.2. Installation
121.3. SWTBot API
XXX. Eclipse application updates
122. Eclipse application updates
122.1. Eclipse application updates
122.2. Creating p2 update sites
123. Using the p2 update API
123.1. Required plug-ins for updates
123.2. Updating Eclipse RCP applications
124. Exercises: Performing an application update
124.1. Preparation: Ensure the exported product works
124.2. Select update location
124.3. Add dependencies
124.4. Add feature to product
124.5. Create user interface
124.6. Enter version in your product configuration file
124.7. Create initial product export
124.8. Start export application and check for updates
124.9. Make change and export product again
124.10. Update application
XXXI. Using target platforms
125. Target Platform
125.1. Defining available plug-ins for development
125.2. Using the IDE as target platform
125.3. Defining a target platform
126. Exercise: Defining a target platform
126.1. Creating a target definition file
126.2. Activate
126.3. Validate
126.4. Solving potential issues
XXXII. Defining custom annotations
127. Usage of custom annotations
127.1. Custom annotations
127.2. Restrictions
127.3. Example usage
128. Exercise: Defining custom annotations
128.1. Target
128.2. Plug-in creating
128.3. Define and export annotations
128.4. Create class
128.5. Register annotation processor
128.6. Add plug-in as dependency
128.7. Update product
128.8. Validate: Use your custom annotation
128.9. Update build.properties
XXXIII. Using custom extension points
129. Creating and evaluating extension points
129.1. Eclipse extensions and extension points
129.2. Creating an extension point
129.3. Adding extensions to extension points
129.4. Accessing extensions
129.5. Extension Factories
130. Exercise: Create and evaluate extension point
130.1. Target for this exercise
130.2. Create a plug-in for the extension point definition
130.3. Create an extension point
130.4. Export package
130.5. Add dependencies
130.6. Evaluating the registered extensions
130.7. Create menu entry and add to your product
130.8. Providing an extension
130.9. Add plug-in to your product
130.10. Validate
XXXIV. The renderer framework
131. The usage of renderer
131.1. Renderer
131.2. Renderer factory and renderer objects
131.3. Context creation of model objects
131.4. Using a custom renderer
132. Existing alternative renderer implementations
132.1. Alternatives to SWT
132.2. Vaadin renderer - Vaaeclipse
132.3. JavaFX renderer - e
132.4. Eclipse RAP
132.5. Additional UI toolkits
133. Exercise: Defining a renderer
133.1. Target
133.2. Create plug-in
133.3. Enter dependencies
133.4. Create renderer implementation
133.5. Register renderer
133.6. Validate
133.7. Exercise: A custom part renderer
XXXV. Other advanced use cases
134. Custom persistence for the application model
134.1. Specifying the location of the application model file
134.2. Custom application model persistence handler
135. Extend the structure of the application model
135.1. Application model extensibility
135.2. More information
XXXVI. Development practices
136. Eclipse development good practices
136.1. Create isolated components
136.2. Usage of your custom extension points
136.3. Avoid releasing unnecessary API
136.4. Packages vs. plug-in dependencies
137. Application communication and context usage
137.1. Application communication
137.2. Example: Using events together with the IEclipseContext
137.3. Dependency injection
XXXVII. Migrating Eclipse 3.x application
138. Why migrate an Eclipse 3.x RCP application?
138.1. Support for Eclipse 3.x API
138.2. Technical reasons for migrating to Eclipse 4 RCP
138.3. Future development is based on Eclipse 4
139. Running Eclipse 3.x plug-ins on top of Eclipse 4
139.1. Using the compatibility layer
139.2. How to use the compatibility layer
139.3. Value of using the compatibility layer
140. Using the Eclipse 4 programming model in 3.x applications
140.1. Wrapper classes for Eclipse 3.x
140.2. Validation
141. Using Eclipse 3.x components in Eclipse 4
141.1. Officially not supported
141.2. Workaround
142. Full source migration to Eclipse 4
142.1. Migration to Eclipse 4
142.2. Reuse of platform components
XXXVIII. Questions, feedback and closing words
143. Questions and feedback
143.1. Eclipse Bugs
143.2. Asking
143.3. Eclipse 4 feedback
144. Closing words
XXXIX. Appendix
A. Eclipse annotations, extension points and tags
A.1. Standard annotations in Eclipse
A.2. Relevant extension points for Eclipse 4
A.3. Relevant tags in the application model
B. Solutions for the exercises
B.1. Getting the example implementation
B.2. More information about Git and Eclipse
C. Receipts
C.1. Reading resources from plug-ins
C.2. Loading images from a plug-in
C.3. Getting the command line arguments
D. Architectural background of the application model
D.1. Main areas of the model
D.2. Advantages of using mix-ins
E. OSGi low level service API
E.1. Using the service API
E.2. BundleContext
E.3. Registering services via API
E.4. Accessing a service via API
E.5. Low-level API vs OSGi declarative services
F. Eclipse platform development
F.1. Eclipse platform Git repositories
F.2. Download and install Eclipse development build
F.3. Creating a custom Eclipse IDE build
G. Live model editor
G.1. Testing model dynamics with the live model editor
G.2. Exercise: Integrating the live model editor
H. Links and web resources
H.1. Eclipse RCP resources
H.2. Eclipse product and export resources
H.3. OSGi Resources
H.4. OSGi Resources
H.5. Eclipse SWT resources
H.6. JFace resources
H.7. Eclipse Data Binding resources
H.8. Eclipse i18n resources
H.9. CSS styling resources
H.10. Eclipse p2 updater resources
H.11. Logging
Index