The document discusses Eclipse 4.0 and its new application platform. It introduces key building blocks of Eclipse 4.0 like the modeled workbench, rendering engine, declarative styling, and dependency injection. The modeled workbench uses EMF to define the application UI in an XML file rather than code. Renderers then translate the model into actual UI components. Dependency injection simplifies programming by auto-wiring classes with their dependencies. Overall, Eclipse 4.0 aims to make RCP development easier and more visually appealing compared to prior Eclipse platforms.

1. Eclipse 4.0 Application Platform The unexpected simplicity of Eclipse RCP and Eclipse plugin development 26. August for JUG Saxony Lars Vogel http://www.vogella.de Twitter: @vogella

2. Eclipse 4.0 Application Platform -Agenda What is Eclipse 4.0? Whom does try to help? Building blocks of Eclipse 4.0 Q&A

3. What is an Eclipse RCP application? Local running application using the native widget toolkit Based on the Eclipse runtime and technology

4. Your first RCP app in < 10 secs

5. Eclipse e4 Scope Make developmentfor Eclipseeasier

6. Eclipse e4 Eclipse e4 is the incubator project which did produce the Eclipse 4.0 SDK

7. How does Eclipse e4 help me?

8. from Eclipse Developer Eclipse E4 to Eclipse Developer

9. So, what’s wrong with plugin and RCP development in Eclipse 3.X?

10. Eclipse 3.x programming model Complex Lots of API Platform functionality via singletons / static methods Not easy to test Not a consistent way to define the UI

11. Inheritance in Eclipse 3.X Object EventManager WorkbenchPart ViewPart View

12. The smallest Eclipse RCP app in Eclipse 3.X Already looks like the Eclipse IDE Lots of boilerplate code

13. If only Eclipse development would be easier, more visual appealing and easier to test. 13

14. The first amazing change Eclipse e4 uses Java 1.5 language features! AAbout time I would say….

15. Eclipse e4 – Building blocks Modeled Workbench Rendering Engine Declarative Styling Dependecy Injection Context Core Services

16. The Modeled Workbench

17. The e4 Workbench Model e4 Workbench Model EMF inside

18. The e4 Workbench Model Workbench window Menu with menu items Window Trim, e.g. toolbar with toolbar items Parts Sash Container Parts Part Stack (CTabFolder) Parts Handlers Key Bindings Commands

19. Model is Flexible No distinction between View and Editor Perspectives are optional Stack / Sash are optional Several windows possible Flexible Toolbars

20. Model removes the need for boilerplate code Minimal Eclipse e4 app: zero classes

21. Model URI’s The Part in the Model The Part’s URI

22. Lessions learned from Java Web deelopment The POJO* has won! * Plain Old Java Objects

23. Model Elements in e4 POJO‘s

24. Usage of annotations Annotations are used To indicate which methods are called

25. Model available at runtime

26. Change the model at runtime

27. Limits of the e4 application model Only models the Application (frame) Modeled Workbench Content of the individual Parts not included in the model

28. How is this model translated into UI components? © Lars Vogel and others, Licensed under Creative Commons by-nc-nd-3.0 (de)

29. Model and UI Renderers Model I don’t care who draws me The Workbench model is independent of a specific UI toolkit

30. Renderers Widget Renderer Renderer Factory Returns for every model element Standard SWT renderer can be exchanged

31. Renderer: flexible but complex

32. e4 CSS Styling

33. In reality all RCP apps look like the an IDE

35. Table headers e4 supports theme switching during runtime

36. How to enable CSS Styling Extension point "org.eclipse.e4.ui.css.swt.theme“ defines the style sheet <extension point="org.eclipse.e4.ui.css.swt.theme"> <theme basestylesheeturi="css/styles.css" id="org.eclipse.e4.minimal.theme.standard" label=“Standard"> </theme> </extension>

37. How to enable CSS Styling Property "cssTheme” for extension point "org.eclipse.core.runtime.products" selects the initial theme <extension id="product" point="org.eclipse.core.runtime.products"> <product application="org.eclipse.e4.ui.workbench.swt.E4Application" name="E4 Contacs Demo"> .... <property name="cssTheme" value="org.eclipse.e4.demo.contacts.themes.darkgradient"> </property> ....

38. Example CSS Label { font: Verdana 8px; color: rgb(240, 240, 240); } Table { background-color: gradient radial #575757 #101010 100%; color: rgb(240, 240, 240); font: Verdana 8px; } ToolBar { background-color: #777777 #373737 #202020 50% 50%; color: white; font: Verdana 8px; }

39. Java Label label = new Label(parent, SWT.NONE); label.setData("org.eclipse.e4.ui.css.id", "SeparatorLabel"); CSS #SeparatorLabel { color: #f08d00; } Assign custom attributes

40. The e4 Programming Model

41. Dependency Injection Inversion of control: The necessary functionality is injected into the class Java Class

42. Dependency Injection in e4 JSR 330 compatible injection implementation @javax.inject.Inject – Field, Constructor and Method injection @javax.inject.Named – Specify a custom qualifier to context object (default is fully qualified classname of the injected type) e4 specific annotations, e.g. @Optional

43. Java Class Services are injected via the the e4 framework publicclassListView { @Inject privateIEclipseContextcontext; @Inject private Loggerlogger; @Inject publicListView(Composite parent) { // ...

44. Java Class Model elements participate automatically in DI AddOn as non visual model elements Inject your own object is as simple as ContextInjectionFactory.make(YourObject.class, context);

47. IEclipseContext Stores information of possible Injection Values OSGi Services part of the Context Define your own services and use DI for them

48. Example: Writing Handlers Method identified via @Execute annotation Can have any number of arguments Use IServiceConstants for general context informations public class AboutHandler { @Execute public void execute(@Named(IServiceConstants.ACTIVE_SHELL) Shell shell){ MessageDialog.openInformation( shell, "About", "e4 Application example."); } }

50. Progress reporting

51. Error handling

52. Navigation model

53. Resource management

54. Status line

55. Drag and drop

56. Undo/Redo

57. Accessing preferences

58. Preferences

59. Editor lifecycle

60. Receiving input

61. Producing selection

62. Standard dialogs

63. Persisting UI state

64. Logging

65. Interface to help system

66. Menu contributions

67. Authentication

68. Authorization

70. Contributions Extension point “org.eclipse.e4.workbench.model” Fragments – XMI snippets Processor - Code

71. Context Communication Change the context context.modify("selection", selection.getFirstElement()); Get Notified @Inject public voidsetPerson(@Named("selection") @Optional Person person) { master.setValue(person); }

72. Eclipse e4 – There is more XWT Open Social Gadgets Toolkit Model JDT ???

73. Summary

74. Eclipse: Where to go from here: Eclipse 4.0 SDK Tutorial http://www.vogella.de/articles/EclipseE4/article.html Tom Schindl’s Eclipse 4.0 SDK Tutorial http://tomsondev.bestsolution.at/2010/07/28/eclipse-4-0-and-tutorial-on-writing-e4-rcp-application-released/ Eclipse Wiki http://wiki.eclipse.org/ Eclipse RCP Tutorial http://www.vogella.de/articles/RichClientPlatform/article.html

76. Thank you For further questions: Lars.Vogel@gmail.com http://www.vogella.de http://www.twitter.com/vogella

78. Thinking guy II 130484

79. Renderer 1211480

80. Factory 1255482

81. Painter 976984

82. Holding hands 607988

83. Beautiful eyes 933394

84. Funny Puppet 812138

85. Gummibärchen 191472

86. Tools / Programming model 1197009

87. Dependency injection 510413

88. Life cycle 1265027

89. File Drawer 613683

90. Books 1184809

91. Party people 1062451

92. Chart 963825

93. Wheat 939151

94. Summary http://www.sxc.hu/photo/1184807

95. Question http://www.sxc.hu/photo/418215

96. Reading material http://www.sxc.hu/photo/406547