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

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