ITU - MDD - Eclipse Plug-ins

ITU - MDD - Eclipse Plug-ins
This presentation shows how Eclipse plug-ins are developed. It has two purposes:
Introduce you to the architecture and techniques of a major component based application
Introduce you to basic Eclipse plug-in development – this will hopefully ease the needed programming in the rest of the course
This presentation is developed for MDD 2010 course at ITU, Denmark.

Equipment and Groups
Today's lecture will include a bit of Java development!
So…
You need your laptop
You need the following installed and tested – please – on your laptop
Eclipse 3.6 Modelling Edition
Java SDK 6
You need to be in a group of people (3-4) with some knowledge of
Eclipse IDE as a development platform
Java development
User interface development – if possible

Agenda
Eclipse Architecture
The basic plug-in
What is a plug-in?
Standard Widget Toolkit – SWT

Agenda
What are the drivers for the Eclipse architecture
What are the requirements for the architecture

Some Numbers on Eclipse
The Eclipse Modeling Tools
1099 plug-ins
229 features
All Eclipse Projects
>45 projects in the Galileo release train
29 MLoC
>500 active committers
>25 countries
>140 locations

Project Activity

So…
We need an architecture that supports distributed development over a large number of autonomous development groups
We need a component concept where components are loosely coupled and can be started (and stopped) independently
We need a way to describe external interfaces of components and dependencies between components
We need a way to only start the components as they are needed – also known as late activation
We need all this to work over multiple generations of components

Goals for the Eclipse architecture
Be able to host any number of 3 rd party applications
Scalability in terms of size and complexity of hosted applications
Alignment with native UI look-n-feel
Flexible architecture, structured around
Plug-ins – the basic unit of functionality
Extension points – the defined interfaces between plug-ins
This architecture allows for
Implementation of 3 rd party applications on top of the basic platform (Eclipse RCP)
Additional tools to be integrated in the platform
Integrated tools to be further extended

Eclipse Architectural Components JDT CVS WTP Datatools VE BIRT Mylyn PDE CDT Eclipse Platform Resources Workspace Help Update Team Web Server Filesystems Apache Search Navigator Intro Text Editors Eclipse RCP Run-time/OSGi SWT JFace Workbench Preferences Jobs ICU Commands Registry

The Basic RCP Components
In the Eclipse, everything is a plug-in including the run-time platform itself
It is a small kernel that represents the base of the platform
Built on top of OSGi
All subsystems built on the run-time platform follows the rules of plug-ins:
They are plug-ins themselves
RCP includes:
Component Management
Resources Management
Preferences
Workbench (include SWT and JFace)
RCP does not include functionality that are not commonly needed:
Update
Help
This can be included from the Eclipse platform
Eclipse RCP Run-time/OSGi SWT JFace Workbench Preferences Jobs ICU Commands Registry

Your Typical RCP Application Application Platform Comm. Logging Help Update Auth. Auditing Apache Intro Base Add-on Add-on Add-on Add-on Debug Tools Data Model Eclipse RCP Run-time/OSGi SWT JFace Workbench Preferences Jobs ICU Commands Registry Add-on

Organizing the Platform
The software of an Eclipse system is based on the following terms:
Plug-ins – a plug-in is the basic unit of software
Fragments – a fragment is an add-on to an existing plug-in with additional functionality
Features – a feature is a number of plug-ins that is distributed and updated as a whole
Applications – an application is a Java class that implements a specific interface and is declared as such in the plug-in
Products – a product is a set of features or plug-ins along with the appropriate branding

Extension Points
Describe additional functionality that could be integrated with the platform
External tools extend the platform to bring specific functionality
Java Development Tooling (JDT) and Plug-in Development Environment (PDE) are external tools integrated with the platform
Extension points are used to
Add an implementation for a generic feature
Extend the workbench
Extend common object factory
Advantages:
Allows for late load and startup of plug-ins
Provides a common “registry” for most extensions like views, perspectives, commands, etc
Disadvantages:
Makes it harder to understand flow of control
ID Hell!
Extension points may have corresponding API interface
Describes what should be provided in the extension

The Role of Run-Time/OSGi
Dynamic module system for Java
Solves many of the problems of big applications
Late activation of code
Multiple versions of the same library
Eclipse is the reference implementation!

Workbench
Represents the desktop development environment
It contains set of tools for resource management
It provides common way of navigating through the resources
Multiple workbenches can be opened at the same time in individual windows

Eclipse Development Model
Yearly releases
Always released around 27. June – just before the start of the Canadian holidays
Many diverse and highly independent development teams
More than 25 countries involved in Eclipse 3.5 Galileo
Many milestones and release candidates
5 monthly milestones (August to February)
4 release candidates (May and early June)
Still room for integration of other mayor projects
Many projects are released with other release schedules

Agenda
The Basic Plug-In
How to build a basic Eclipse plug-in and get it included in Eclipse IDE

Show and Tell
You will be shown how to create a new plug-in with
A new perspective
A new view
A new command for the view
The new plug-in will be included in Eclipse
If you need to do this again, have a look at the two tutorials listed in the last slides

Basic Eclipse UI Information Model Workbench Window Workbench Page Editors Views Perspective Top-level menu Top-level toolbar Status line Perspective switcher Drop-down menu Local toolbar Workbench 0..n 1..n 0..n 0..n

Lab Exercise
Create 4 views altogether
Add the views to the perspective
The way to position views in a perspective have not be discussed in details, but…
Add the Help->About command to one of the views

Agenda
What is a plug-in?
What makes up a plug-in? How are they managed and developed?

What is an Eclipse Plug-in
A plug-in is the smallest functionality that is managed in the Eclipse platform
Plug-ins are described via a number of configuration files
Plug-ins have different forms under development and runtime
Plug-ins are sometimes deployed individually
If you need update support, plug-ins must always be deployed as parts of a feature
A fragment has the same structure as a plug-in with very few changes

Runtime Files of a Plug-in
OSGi files
META-INF/MANIFEST.MF – description of OSGi bundle
.options – options for this specific plug-in
General plug-in files
plugin.xml and fragment.xml – description of extension points and extensions of a plug-in
plugin.properties and fragment.properties – localized strings for the previous files

Development Time Files of a Plug-in
.project – basic description of Eclipse project
.classpath – the Java class path for a Java Eclipse project (and thus also a PDE project)
.settings – preference store for project level preferences – includes all property settings for the project
*.product – product declaration files
build.properties – build information for Ant with content of the resulting jar files for the project
*.exsd – extension point declaration files

MANIFEST.MF File
The OSGi manifest file describes the identify of the plug-in and the dependencies on other plug-ins
Manifest files are very seldom edited directly!
Manifest-Version: 1.0 Bundle-ManifestVersion: 2 Bundle-Name: %pluginName Bundle-SymbolicName: com.rcpcompany.training.cm33.core; singleton:=true Bundle-Version: 2.1.0 Bundle-ClassPath: . Bundle-Vendor: %providerName Bundle-Localization: plugin Bundle-RequiredExecutionEnvironment: J2SE-1.5 Export-Package: com.rcpcompany.training.cm33.core, com.rcpcompany.training.cm33.core.util Require-Bundle: org.eclipse.core.runtime, org.eclipse.emf.ecore;visibility:=reexport Bundle-ActivationPolicy: lazy

plugin.xml File
plugin.xml describes extension points and extensions
<extension point="org.eclipse.ui.commands"> <command id="com.rcpcompany.demo.menu33.commands.HelloWorld" name=”&Sample Action” /> </extension> <extension point="org.eclipse.ui.commandImages"> <image commandId="com.rcpcompany.demo.menu33.commands.HelloWorld" icon="icons/sample.gif” /> </extension> <extension point="org.eclipse.ui.handlers"> <handler class="demo.actions.SampleHandler" commandId="com.rcpcompany.demo.menu33.commands.HelloWorld” /> </extension> <extension point="org.eclipse.ui.menus"> <menuContribution locationURI="menu:org.eclipse.ui.main.menu"> <menu id="sampleMenu" label="Sample Menu" mnemonic="M"> <command commandId="com.rcpcompany.demo.menu33.commands.HelloWorld" id="com.rcpcompany.demo.menu33.commands.HelloWorld.mc.sampleMenu” /> </menu> </menuContribution> </extension>

Plug-in Editor
Double-click on the plugin.xml or MANIFEST.MF opens the editor
Almost all plug-in details can be changed in the editor
Overview page displays basic plug-in information

Dependencies Page
Displays dependant plug-ins
Created by tools when the plug-in type is chosen
New dependences can be added

Runtime Page
Displays runtime information such as plug-in classpath
Populated by the tools based on inputs from wizards
Additional libraries can be added to the classpath

Extensions Page
Displays plug-in extensions
Created by the tool based on the plug-in type
Extensions can be added

Extension Points Page
Displays plug-in extension points
This example is taken from the org.eclipse.ui plug-in

Build and build.properties Pages
Interface to the build.properties file
specifies which .jar files to generate
Also describes which non-Java files that are part of the generated .jar file

Agenda
The Standard Widget Toolkit - SWT
How to develop the UI parts of an Eclipse plug-.in

Eclipse User Interface Layers
4 Layers:
The Eclipse Workbench
Overall look-n-feel
JFace
Architecture-independent models
SWT
Platform independent API yet rather close to the metal
Native widgets
Platform dependent: Windows, Linux, Mac, Unix
The “Eclipse User Interface Guidelines” governs the look-n-feel of the workbench and JFace
Consequently (nearly) all Eclipse RCP based applications look the same!
Use the SWT Bible “The Definitive Guide to SWT and JFace” by Robert Harris and Rob Warner

SWT and the Native Widgets
SWT is short for ”The Standard Widget Toolkit”
SWT is a sub-project of the Eclipse project
SWT has a common API on all target platforms – the implementation is different
Base plug-in org.eclipse.swt contains only MANIFEST.MF plus some configuration files
A set of platform specific fragments implements all of SWT – org.eclipse.swt.win32.win32.x86 for 32-bit Windows on x86 (not Vista look-n-feel)
SWT is a thin layer on top of the native widgets
Windows
Mac
Motif
GTK
SWT can easily be used stand-alone

SWT on Different Platforms

Extended Branding Here IBM Lotus Notes version 8

Working with SWT
SWT API is not as regular as Swing
The SWT site contains a large repository of “SWT Snippets” that demonstrates most of the abilities of SWT
To find leaks with graphical resources use sleak
It is possible to integrate SWT and Swing to a very large degree
Though expect problems with shortcuts and focus management

SWT Widgets
Basic
Button , Combo , Composite , Group , Label , Link , List , Menu , ProgressBar , Shell , Slider , Scale , Spinner , TabFolder , Table , Text , ToolBar , and Tree
Advanced
Browser , Canvas , CBanner , CCombo , CLabel , CoolBar , CTabFolder , DateTime , ExpandBar , GLCanvas , Sash , SashForm , ScrolledComposite , StyledText , SWT_AWT , TableCursor , and Tray
Other Sources – e.g. Nebula, Sourceforge.net
FormattedText , Gallery , Grid , and many more
The C... versions of Label , Combo and TabFolder are emulated and should normally be avoided if possible

SWT Widgets

The Basic Widget Hierarchy Widget Control Menu Item Button Label Composite List MenuItem TableItem TabItem Canvas Combo Form OleSiteClient Table, …

Using SWT Widgets
Common constructor form – e.g. new Text(parent, SWT.PASSWORD)
The parent
The style argument specifies the basic sub-function of the widget
Use Text controls for data values event when read-only, as this makes it possible to select and copy the value

Using SWT Styles
Second argument of all widget constructions – e.g. new Text(parent, SWT.PASSWORD)
The most use styles are
SWT.NONE – no style needed
SWT.LEAD , SWT.CENTER , and SWT.TRAIL - the alignment of text in labels, menus and buttons
SWT.ARROW , SWT.CHECK , SWT.PUSH , SWT.RADIO , and SWT.TOGGLE - the sub-type of a button
SWT.PASSWORD - Text is used for password entry
SWT.V_SCROLL , SWT.H_SCROLL , and SWT.NO_SCROLL – Table or Tree has vertical, horizontal or no scroll bar (3.4)
Some special considerations regarding styles
Some style arguments cannot be changed once specified in the constructor (e.g. SWT.CHECK for a Button ), whereas others can (e.g. SWT.LEAD for Label )
Some style arguments have different meaning for different widgets –e.g. SWT.MULTI for Table and Text

SWT Layout Managers
The positioning and sizing of controls in a Composite (and subclasses) is performed using layout managers
SWT includes a rather complete set of standard layout managers
FillLayout and RowLayout : layout is a single row or column
GridLayout : layout in a grid with size constrains
FormLayout : layout in canvas with size and edge-to-edge constrains
Most GUI designer can handle these
A new layout manager can be created fairly easily created
computeSize : computes the “natural” size of the Composite
layout : lays out the controls of the Composite
public abstract class Layout { protected abstract Point computeSize(Composite composite, int wHint, int hHint, boolean flushCache); protected abstract void layout(Composite composite, boolean flushCache); }

Using the Grid Layout ( GridLayout )
Grid Layout is the most used layout manager in Eclipse
It works by adding the child widgets to the cells in a grid
Widgets are added in sequence
When using a Grid Layout, the parent uses the GridLayout and all children use GridData
final Composite composite = new Composite(parent, SWT.NONE); final GridLayout gridLayout = new GridLayout( 3, false ); composite.setLayout(gridLayout); label = new Label(composite, SWT.NONE); label.setText("Label"); text = new Text(composite, SWT.BORDER); text.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false , 2, 1 )); // …

Using the Grid Data ( Grid Data )
GridData specifies how a child widget is laid out in the parent grid
A GridData holds the following primary information
Grab Excess Space (horizontal and vertical) – describes whether the grid column or row should expand to grad any excess space (defaults to no grab)
Span (horizontal and vertical) – describes the number of cells the widget should span (defaults to 1 , 1 )
Alignment (horizontal and vertical) – placement of widget within the cells – one of SWT.BEGINNING , SWT.CENTER , SWT.END or SWT.FILL (defaults to BEGINNING , BEGINNING )
A GridData also contains information about indentation, minimum size and size hints
Don’t use the two-argument constructor!
1,1 2,1 2,2 C,C F,C E,E Horizontal grab No grab

SWT Events
SWT events and listeners exist in two versions:
A simple very light-weight version
One event format and listener interface
A type-safe version
Multiple event formats and listener interfaces tailored to the specific use
The difference is illustrated in the following example
filter.addListener(SWT.KeyDown, new Listener() { public void handleEvent(Event event) { if (event.type == SWT.KeyDown) { //... } } }); filter.addKeyListener(new KeyAdapter() { @Override public void keyPressed(KeyEvent e) { //... } });

SWT Events
Key
KeyDown , KeyUp , HardKeyDown , HardKeyUp
Mouse
MouseDown , MouseUp , MouseMove , MouseEnter , MouseExit , MouseDoubleClick , MouseHover , MouseWheel
Control
Paint , Move , Resize , Dispose
Selection
Selection , DefaultSelection
Focus
FocusIn , FocusOut
Tree and Table
Expand , Collapse , EraseItem , MeasureItem , PaintItem
Shell
Iconify , Deiconify , Close , Activate , Deactivate
Menu
Show , Hide , Arm , MenuDetect
Basic Controls
Modify , Verify , SetData , Settings
Drag-n-Drop
DragDetect
Misc
Help

Lab Exercise
Create a view with the following look using simple SWT controls
GridLayout , GridData
Label , Text , Button
… addSelectionListener(…)
Another extra lab for the fast ones:
add “stuff” to the lab to only allow “a” and “b” in the text field
and to only allow more “a” than “b”!
Use a Verify listener
public class View extends ViewPart { public void createPartControl(Composite parent) { Composite top = new Composite(parent, SWT.NONE); // Add something here… } public void setFocus() { } } GridLayout with 2 columns Label Text FILL aligned + grab Button spans two columns, RIGHT aligned SelectionListener that prints current text of Text control

More Information (Basic Plug-in)
“ Eclipse Plugin Development Tutorial”
http://www.eclipsepluginsite.com/
“ Eclipse Plugin Development Tutorial”
http:// www.vogella.de/articles/EclipsePlugIn/article.html
Eclipse Resources
http://www.eclipse.org/resources/

More Information (SWT)
“ Eclipse User Interface Guidelines: Version 2.1”
http:// www.eclipse.org/resources/resource.php?id =162
The Look-n-Feel guidelines for Eclipse – heavily influenced by the corresponding Microsoft Windows Look-n-Feel guidelines
SWT home
http:// www.eclipse.org/swt /
SWT versus Swing
http://www.developer.com/java/other/article.php/2179061
“ Using SwingRCP (instead of SWT) in RCP”
http://www.eclipsezone.com/eclipse/forums/t104467.rhtm l
A discussion of different ways to integrate Eclipse RCP and Swing
“ The Definitive Guide to SWT and JFace” by Robert Harris and Rob Warner (ISBN: 978-1590593257)
As it says – “The Definitive Guide…” – and needed due to the pure javadoc of SWT
“ SWT Snippet” Repository
http:// www.eclipse.org/swt/snippets /
A large repository of sample code for most uses of SWT!

ITU - MDD - Eclipse Plug-ins

by Tonny Madsen on Nov 15, 2010

Accessibility

Categories

Tags

Upload Details

Usage Rights

Statistics

ITU - MDD - Eclipse Plug-ins — Presentation Transcript