Jonathan Lindo (Replay Solutions)

Abstract:

See a Live Demonstration of an innovative new Eclipse-based automation feature:

Users are resolving defects 60% faster
Reproduce bugs in minutes in Eclipse
No database or appl…

Adobe Ajax Android Anwendung Apache API C++ Community Developer Eclipse Eclipse Foundation Embedded English Enterprise Entwickler Equinox Galileo Google Handy IBM IDE Individual Java Member Microsoft Mobile Modeling NetBeans News Open …

Recently I have seen a couple of improvements making Eclipse a more welcome place, especially for newcomers, but also for everyone else. Here is my personal New and Noteworthy of the category Easy Access:

Get Involved!

It’s amazing that Eclipse has existed for so long without a Get involved web site which lists different possibilities of how to contribute. I’m very happy with it, especially since I’m one of the authors and my proposal for the header image was chosen (maybe because nobody spotted my bank’s proposal):

Add comments to bug 280730: something missing?, wording, design, etc.

Marketplace

At the end of last year the new Marketplace replaced the Eclipse Plug-in Central. Marketplace looks nice and I also like the new transparent voting system. Maybe we could find a better logo for it. And what about the feature “People who viewed this plug-in also have viewed these plug-ins: …”?

Xtext – New web site design

Xtext was the first project to use the new Nova template. Both newcomers and developers are addressed by for example a one minute intro movie and also a commits statistics. I’m looking forward for more projects adapting Nova.

Continuous integration with Hudson

A continuous integration server for example runs all JUnit or computes some metrics. I’m happy that my favorite one, Hudson, works for me at Eclipse. If you do not know it or want to know more about Hudson and you understand German and live near Stuttgart you should attend Dr. Simon Wiest’s talk show about Hudson next Thursday (see slides from last year but you have to see him live).

Mylyn Connector discovery

Since Mylyn 3.2 it has been possible to install a new connector within the New Repository Query dialog. This feature will become a generic P2 function (see bug 295273). That’s really cool!

Eclipse Labs

Eclipse Labs has been announced to become a kind of Forge where Eclipse-based projects will be hosted without the need to be a real Eclipse project (so why not call it Eclipse Forge instead of Eclipse Labs?). Sad to hear Oracle is going to stop Kenai. Sun with Netbeans is a great competitor and hopefully will not be weakened by business decisions.

Distributed revision control

Since two weeks EGit builds have been available and the first writeable GIT repositories have been set up. I have tested Mercurial which is just another distributed revision control system with HgEclipse. If you believe the network must slow down all your version control actions then you will have to change your mind like me. Great that there are already open source Eclipse plug-ins available for both GIT and Mercurial.

The next big improvement of the category Easy Access may hopefully be bug 243582: Importing bundles into the workspace gets a 4th option, “Import with Source from Repository”.

The future is bright. The obstacles are lowered. Come in and explore the Eclipse universe:

 

<!–

–>

<!–

–>

The Eclipse RCP became a prominent platform for building client software. One of the delivery mechanisms supported by Eclipse RCP is Sun’s Java Web Start (JWS). Since Galileo Edition some changes has been introduced in the platform. This article provides some hints for creation of the RCP delivered by Java Web Start.

Packaging

In order to package the RCP I suggest to use feature-based products as described in
a previous article. Following it, you should have a top-level plug-in (also refered as product-defining plug-in) and top-level feature, which is called “wrap”-feature in the context of the Java Web Start.

Exporting the product

Before you start with Java Web Start (JWS), export the product and make sure it starts as a standalone application. In doing so, you have to ensure that your references to the plug-ins are correct. One of the way of doing it is to hit the Validate button in the top left of the product editor. If the validation is successful, try to export the product. The PDE builder will run and create a distribution. The errors of the compiler/builder/assembler, if any, are reported to files zipped to the logs.zip file in the distribution directory. A prominent error is

Compliance level '1.3' is incompatible with source level '1.6'. A compliance level '1.6' or better is required.

Which actually means that the plug-in classes has not been compiled at all. In order to avoid this error make sure to set the following properties in the build.properties file of the corresponding plug-in:

javacSource=1.3
javacTarget=1.3

Exporting the wrap-feature

After a successful export of the product, just export the top-level feature (the wrap-feature). Make sure to provide the signing information, since JWS requires all resources to be signed. If you are aiming to deliver for different platforms, make sure to define a target platform (Window > Preferences > Plug-in Development > Target Platform) which contains a Delta Pack. A Delta Pack is a set of plug-ins which can be downloaded separately on the
Eclipse Homepage. Also, don’t forget to switch over to the Java Web Start tab of the Feature Export Wizard, activate the checkbox “Create JNLP manifest for the JAR archives” and specify the site URL where the resulting JNLP will be located. Make sure all your features has the provider attribute set, since it is used as the “vendor” inside of the JNLP file, which is a mandatory attribute.

Creating the main JNLP

The PDE build will run and create a distribution in the specified directory. Along with the exported JARs in features and plug-ins, the packaging script will generate the JNLP descriptors for every feature. Still, the main JNLP file required for launching the application is missing and has to be provided separately. Here is, how it looks like:

<?xml version="1.0" encoding="UTF-8"?>
<jnlp spec="1.0+" codebase="http://localhost/app/" href="app.jnlp">
    <information>
        <title>application titel</title>
        <vendor>provider</vendor>
        <offline-allowed/>
    </information>

    <security>
        <all-permissions/>
    </security>

    <application-desc main-class="org.eclipse.equinox.launcher.WebStartMain">
	<argument>-product</argument>
	<argument>de.techjava.app.webstart.productid</argument>
	<argument>-application</argument>
	<argument>de.techjava.app.webstart.appid</argument>
    </application-desc>

    <resources>
        <j2se version="1.4+" ax-heap-size="128m" />
	<jar href="plugins/org.eclipse.equinox.launcher_1.0.201.R35x_v20090715.jar"/>
	<extension name="wrap feature" href="features/wrap_feature_1.0.0.jnlp" />
	<!-- OSGI setup -->
        <property name="osgi.instance.area" value="@user.home/app"/>
        <property name="osgi.configuration.area" value="@user.home/app"/>
    </resources>
</jnlp>

Important is to specify both, the product id and the applciation id, otherwise you will see the “Application id not found” exception. Of course you can specify
additional options as command-line arguments of the launcher itself. I found it useful to be able to let the OSGi running and then connect to it and query for loaded bundles. You can do it by adding the following arguments:

	<argument>-console</argument>
	<argument>1234</argument>
	<argument>-noExit</argument>

This will allow to connect via telnet with running OSGi, even after the application finishes.
This is basically it.

As Jens mentioned in his recent blog post, parts of the Draw3D renderer have been rewritten in the past weeks. The initial motivation was to improve the visual rendering quality of 2D content (embedded GEF editors) and text, but during development it turned out that a lot of optimization would be necessary to keep the performance at acceptable levels. Eventually, I rewrote the renderer to take advantage of some advanced OpenGL features and now the performance is a lot better than it ever was.

In this blog post I will briefly explain how the 2D rendering system was redesigned over the course of GEF3D’s existence and how it was possible to achieve both a gain in the visual quality and the rendering performance at the same time.

First, let me introduce the initial 2D rendering system that Jens designed before I came on board. GEF uses an instance of the abstract class Graphics to draw all figures. Actually, figures draw themselves using their paint method whose only parameter is an instance of Graphics (this is defined in the IFigure interface). The Graphics class provides a lot of methods to draw graphical primitives like lines, rectangles, polygons and so forth, as well as methods to manage the state of a graphics object. Usually, GEF passes an instance of SWTGraphics to the root of the figure subtree that needs redrawing. SWTGraphics uses a graphics context to draw graphical primitives, and the graphics context usually draws directly onto some graphics resource like an image or a canvas.

So what Jens did when he wanted to allow 2D content in GEF3D was that he simply passed an instance of SWTGraphics to the 2D figures that rendered into an image in memory. This image was then transferred to the graphics card and used as a texture. This system was very simple and required hardly any additional coding at all. The problem with this approach however is that whenever the 2D content needed redrawing (after some model change for example), the entire image had to be redrawn and uploaded to the graphics card again, which is a very costly process. First, the image has to be converted into a ByteBuffer and that buffer must then be uploaded from system to video memory through the bus. For normal-sized image, this can take up to 500ms.

To alleviate this problem, I wrote another Graphics subclass that uses OpenGL to render the 2D primitives directly into a texture image in video memory. This eliminates the uploading step and thus improved performance considerably, especially the delay after any model change when the texture image had to be uploaded into video memory. But it did not help with the second major problem: It still used textures. The problem with using textures to display 2D content in 3D is that while the texture image may look sharp and very good by itself, it gets blurry and distorted when it is projected into 3D space due to all the filtering that has to take place. Especially images that contain text become very hard to read in this approach, as you can see in this screenshot:

Another approach to rendering 2D content in 3D is not to use textures at all, but to render all 2D primitives directly into 3D space in every frame (so far, only the texture had to be redrawn only after a model change occurred). This eliminates all problems related to texture filtering and blurring once and for all. Combined with vector fonts (to be described in another blog post), direct rendering results in the best possible visual quality. The problem is that everything needs to be rendered in every frame all the time. I quickly discovered that simply sending all geometry data to OpenGL in every frame (this is also called OpenGL immediate mode) would kill performance – even in small diagrams, navigation became sluggish.

Essentially, the FPS in GEF3D are limited not by the triangle throughput of the video card (how many triangles can be rendered per second?), but by the bus speed (how much data can we send to the video card in a second?). If you send all your geometry, color and texture data to the video card on every frame, your performance will be very bad because sending large amounts of data to the video card is very expensive. The more data you can store permanently in video memory, the better your performance will be (until you get limited by triangle throughput). So we had to find a way to store as much data as possible in video memory and just execute simple drawing instructions on every frame.

Of course, OpenGL provides several ways to do this. The first and oldest approach is to use display lists, which is basically a way to tell OpenGL to compile a number of instructions and data into a function that resides in video memory. It’s like a stored procedure that we can call every time we need some stuff rendered. The problem with display lists is that they are fine for small stuff like rendering a cube or something. 2D diagrams however consist of large amounts of arbitrary geometry, which cannot be compiled into display lists at all. So this approach was not useful for us.

The best way to store geometry data in video memory is called a vertex buffer object (VBO) in OpenGL. Essentially, a VBO is one (or more) buffer that contains vertices (and other data like colors and texture coordinates). These buffers only need to be uploaded into video memory once (or when some geometry changes) and can then be drawn by issuing as little as five commands in every frame. We decided to adopt this approach and try it for our 2D diagrams by storing the 2D primitives in vertex buffers in video memory. Rendering a 2D diagram would then be very fast and simple, because hardly any data must be sent to the video card per frame. This is how the pros do it, so it should work for us too!

In theory, that is correct. But in practice, it is very hard to actually create a vertex buffer out of the 2D content of a 2D diagram. Since a vertex buffer can only contain a series of graphical primitives (triangles, quadrilaterals, lines) of the same type and the primitives that make up the 2D diagram are drawn in random order, the primitives need to be sorted properly so that we can create large vertex buffers from them. Unfortunately, the primitives cannot simply be sorted by their type and then converted into vertex buffers because there are dependencies between such primitives that intersect. To cut a long story short, I had to think of a way to sort primitives into disjunct sets. Each set contains only primitives of the same type and each set should be maximal so that you end up with a small number of large buffers because that’s how you achieve maximum performance.

The end result is impressive: We used to have performance problems with diagrams that contain more than 2000 2D nodes, and now we can display 4000 2D nodes at 120 FPS, and all that with much better visual quality. To get an idea of how much better the quality of the 2D diagrams is in this version, check out the following screenshot:

Preamble: This is the first post of the new Eclipse category of BonitaSoft’s community blog. As soon as we find something interesting to talk about when developing Bonita Studio, we will try to share what we learnt with our communities: BonitaSoft and Eclipse. We are also pleased to see this category aggregated to Planet Eclipse knowledge feed. We hope you’ll enjoy reading these posts!
The Bonita Studio developers crew

I found some time recently to take a look at SWTBot to check whether we should use it while developing Bonita Studio (part of Bonita Open Solution, based on Eclipse Gelileo 3.5.1). After a few minutes of reading wiki pages and trying it, I was convinced that SWTBot (and its GEF extension, that also works for GMF) is a must-use project for anyone who has ever it found difficult and time-consuming to write plugin tests.

Only a few hours later our continuous integration build welcomed our first SWTBot based test!

Here is the step-by-step of this awesome encounter:

1. Install SWTBot on your development platform by installing SWTBot from updatesite: http://download.eclipse.org/technology/swtbot/galileo/dev-build/update-site
   
2. Create a new plugin to host your test. Add these dependencies to your plugin.

   

3. Write your test

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

   package org.bonitasoft.diagram.test; import org.bonitasoft.studio.model.process.diagram.part.ProcessDiagramEditor; import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotEditor; import org.eclipse.swtbot.eclipse.gef.finder.SWTBotGefTestCase; import org.eclipse.swtbot.swt.finder.junit.SWTBotJunit4ClassRunner; import org.eclipse.swtbot.swt.finder.widgets.SWTBotMenu; import org.eclipse.ui.IEditorPart; import org.junit.Assert; import org.junit.Test; import org.junit.runner.RunWith; /** * @author Mickael Istria * */ @RunWith(SWTBotJunit4ClassRunner.class) public class DiagramTests extends SWTBotGefTestCase {     @Test     public void testDiagramTest() throws Exception {         SWTBotMenu menu = bot.menu(“Process”);         menu.menu(“New”).click(); // simulate a click on Process > New menu entry         SWTBotEditor botEditor = bot.activeEditor();         IEditorPart editor = botEditor.getReference().getEditor(false);         Assert.assertTrue(“New process should open a process editor”, editor instanceof ProcessDiagramEditor);     } }

4. Configure your test run
   
   1. Use JUnit4 as launcher, and don’t use UIThread (SWTBot tests won’t run in a UIThread)
      
   2. Set the product you want to test (leave default org.eclipse.platform.ide for “simple” plugins)
      
   3. Increase memory and set a language
      
5. Run and enjoy the high code coverage that you get with so few lines of code!
6. Ok, now let’s try the GEF extension of SWTBot to check some tricky behavior in a diagram editor. This test creates a new process and then activates a tool in the design palette to create a new step, and then does some checks (and all in about a dozen lines :

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   @RunWith(SWTBotJunit4ClassRunner.class) public class DiagramTests extends SWTBotGefTestCase {     @Test     public void testDiagramTest() throws ExecutionException {         SWTBotMenu menu = bot.menu(“Process”);         menu.menu(“New”).click();         SWTBotEditor botEditor = bot.activeEditor();         SWTBotGefEditor gmfEditor = bot.gefEditor(botEditor.getTitle());         gmfEditor.activateTool(“Step”);         gmfEditor.mouseMoveLeftClick(200, 200);         menu.menu(“Save”).click();         IGraphicalEditPart part = (IGraphicalEditPart)gmfEditor.mainEditPart().part();         MainProcess model = (MainProcess)part.resolveSemanticElement();         Pool pool = (Pool)model.getElements().get(0);         Assert.assertEquals(“Pool should contain 3 nodes”, 3, pool.getElements().size());     } }

7. Run again, and enjoy even more: SWTBot for GEF provides a lot of very high-level Methods to manipulate your diagram. Without it, writing tests for a GMF based editor was quite difficult, and did not mimic user actions very well. With this, you can test real usage scenarios with very little code.
8. The return on investment with SWTBot looks very good, so let’s adopt it and automate test execution in a continuous integration build, leveraging the SWTBot headless framework. The following requires you to be familiar with automated PDE or RCP build and testing.
   1. Install swtbot in the platform you use to build your plugins or your RCP app. For instance, you can use the P2 director commandline application to install it from updatesite:
      java -jar plugins/org.eclipse.equinox.launcher_1.0.201.R35x_v20090715.jar -application org.eclipse.equinox.p2.director -artifactRepository http://download.eclipse.org/technology/swtbot/galileo/dev-build/update-site -metadataRepository http://download.eclipse.org/technology/swtbot/galileo/dev-build/update-site -installIU org.eclipse.swtbot.eclipse.feature.group -installIU org.eclipse.swtbot.eclipse.gef.feature.group -consoleLog
   2. Install SWTBot headless test framework in your build platform: Download it from SWTBot download page, and expand it in your build platform directory.
   3. Add the SWTBot runtime and headless plugins and your new test plugin to your test feature.
      
      In our case, we prefered keeping only the org.eclipse.ant.optional.junit fragment and using new junit bundles to avoid conflicts between classes from org.junit and org.junit4 bundles. However, SWTBot provides some alternative fragments to support either junit3 or junit4 if you prefer.You can add the following entries in your map file for new junit bundles:
      !** Use newer JUnit as described in http://wiki.eclipse.org/Eclipse/Testing/JUnit4_Changes
      !** Should facilitate integration with SWTBot headless
      plugin@org.junit,4.8.1=GET,http://download.eclipse.org/tools/orbit/downloads/drops/S20100120144102/bundles/org.junit_4.8.1.v4_8_1_v20100114-1600.zip,unpack=true
      plugin@org.junit4=v20100104,:pserver:anonymous:@dev.eclipse.org:/cvsroot/eclipse,,org.junit4
      plugin@org.eclipse.jdt.junit.runtime=v20091201-0800,:pserver:anonymous:@dev.eclipse.org:/cvsroot/eclipse,,org.eclipse.jdt.junit.runtime
   4. In the piece of script that runs your test, add the following test invocation command:

      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

      <echo>SWTBot test</echo> <java dir=“${eclipse.test.home}” fork=“true” output=“${eclipse.test.home}/output.txt” logError=“true” classname=“org.eclipse.core.launcher.Main” failonerror=“false”>     <classpath>         <fileset dir=“${eclipse.test.home}/plugins”>             <include name=“org.eclipse.equinox.launcher_*.jar”/>         </fileset>     </classpath>     <arg line=“-application org.eclipse.swtbot.eclipse.junit4.headless.swtbottestapplication”/>     <arg line=“-testPluginName org.bonitasoft.studio.diagram.test”/>     <arg line=“-testApplication org.bonitasoft.studio.application.application”/>     <arg line=“-className org.bonitasoft.studio.diagram.test.DiagramTests”/>     <arg line=“formatter=org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter,junit-results.xml”/>     <arg line=“-nl fr”/>     <arg line=“-consoleLog”/>     <jvmarg line=“-Xms40m -Xmx348m -XX:MaxPermSize=256m -XX:+HeapDumpOnOutOfMemoryError”/>     </java>

9. At this point, when everything is working, you should be one of the happiest people in the world: You have not only reduced the difficulty and cost of writing tests, but also increased the coverage and the realism of your tests

Congrats and thanks to SWTBot developers for making this possible! We love playing with it when developing Bonita Open Solution!

If someone has a better solution for this integration, please tell me!

 

<!–

–>

<!–

–>

Wiedermal Spaß mit Java, Eclipse(galileo) scheint ein dickes Problem mit Mäusen zu haben. Diverse Dialoge lassen sich nicht mehr mit der Maus bedienen, die Buttons reagieren einfach nicht mehr auf Klicks und lassen sich nur noch per Tastatur betätigen. Das Problem scheint hier darin zu liegen, dass sich Eclipse Galileo und GTK2.0 nicht so gut [...]

 

<!–

–>

<!–

–>

Eclipse 3.6 (aka Helios) will run on OpenJDK on Mac when it’s released this year. This will free us from Apple’s oft-criticized and historically slow release cycle of the Java VM.

With a little persistence and help from some committers at Eclipse, the most glaring problems were resolved:

• bug 276564:Eclipse won’t launch using JDK 7 because SWT native libraries don’t load
• bug 276763: [launcher] launcher fails to use OpenJDK-based VM when -vm is specified

If you’re interested in trying it out, you’ll need to get an integration build of Eclipse (see 3.6 Stream Integration Builds) I20100119-0800 or newer, or a nighly build N20100117-2000 or newer. Prior to these builds, running Ecilpse on OpenJDK on a mac was only possible with some trickery. You’ll also need a working OpenJDK on your mac, which can be built from source using these instructions, or installed using mac ports.

Many thanks to the Eclipse team for helping, notably Andrew Niefer, Mike Wilson, Kevin Barnes, Grant Gayed, Felipe Heidrich, Thomas Watson, Steve Northover and Silenio Quarti.

A friend of mine asked me how to modelling with Eclipse. I gave him a quick tour, demonstrating how to create a model with EMF, how to create an instance of that model, how to query the model with OCL, and how to create a text editor for that model with Xtext. It’s pure modelling, i.e. no Java programming at all! I thought that maybe other people would be interested in that topic as well, so I created this little tutorial showing how all these Eclipse modelling “ingredients” can work together.

Preparations

Install Eclipse 3.5 (Galileo) with all the modelling tools, that is the Galileo Eclipse Modeling Tools package. Additionally, we will need the OCL interpreter console, which can be installed using the MDT update site:
http://download.eclipse.org/modeling/mdt/updates/releases/
The OCL console actually is an example, so you will have to install that specific example.

The Runtime Example

Let’s assume a small IT company. The employees of that company develop software for other companies. Of course, they use models for that purpose! In order to better organize their work, they want to document who is working on what. That is, they want to assign certain task to developers. A task could be the implementation of a use case or writing a test case for a class. Let’s see if we can use models for that…

Company Model with EMF

First of all, we have to create a model describing the company. Let’s start from scratch:

1. create a new project:
   File / New / Project… / Eclipse Modeling Framework /Empty EMF project
2. create a new ecore diagram (we want to graphically design the model) in the newly created model folder: Right click on model folder and select
   New / Other… / Ecore Tools / Ecore Diagram
3. enter the Domain file name:: company.ecore and press Finish.

Now, we can “draw” our model using the graphical editor. Create four classes (EClass), add a name attribute (EAttribute) to one of them, create references (EReference) between the classes, and set the properties (in the properties view, this view can be activated by right-clicking in the diagram and select Show Properties View. The result should look like Figure 1.

Figure 1: The domain model of a company

Some remarks:

• The model is an instance of the ecore model, which is quite similar to class models in UML. All elements in ecore start with an “E”, so it is EClass, EAttribute, or EString.
• The EType of the attribute name is EString.
• The upper bound of all references is “*” (you can enter “-1″, which actually is the same as “*”).
• You will need a class containing all your elements later. In the example, the Company serves as a container. Make sure the Is Containment flag is set for the two references employees and skills (see Fig. 1)

Now that we have created a model of our company, we can create an instance of that model. Later, we will generate an editor, but right now we want to quickly create an instance to get a feeling for our model. An instance of our model actually is an instance of our container element, that is the Company class. There is a generic editor available, which can create an instance of a model (or its elements) directly without the need of code generation. All you need is the ecore model. This is how to activate it:

4. Close the ecore diagram
5. Open the ecore model, this time use the Sample Ecore Model Editor. Usually, this editor is used if you double-click the ecore-file, but to be sure use the Open With… context menu entry.
6. Select the Company class (the class, not the package!), and select Create Dynamic Instance… from its context menu. This is shown in Figure 2.
   Figure 2: Create a dynamic instance.

7. enter the File name: Company.xmi and press Finish. The instance will be created in the model folder.
8. edit the model instance using the context menus New Child of the elements in the model.
9. edit the elements properties in the properties section of the editor, see Figure 3.
   Figure 3: Edit properties with the Generic EMF Form Editor

Now that we have create a model and an instance of that model, we want to “work” with that model instance. E.g., we can use OCL to query the model:

10. Activate the console view and open the Interactive OCL console with the button on the left of the console, see Figure 4.
    Figure 4: Open OCL interpreter console

11. Select an element in the editor, This selected element is the context of the OCL query.
12. Enter your OCL query in the console (in the lower section of the OCL interpreter console). E.g. query the name of the selected element with self.name. The result will be displayed in the upper section of the OCL console as shown in Figure 5. We will demonstrate other queries later on.
    Figure 5: Query the model instance with OCL

Task Model with Xtext

Now that we have a model of our company, we want to assign tasks to the employees. We could create a new ecore model just as demonstrated above, but we want to try something new. So, let’s try to not only create a model, but a text editor as well. For that, we will use Xtext. Based on a grammar, Xtext can create an ecore model and a text editor with nice features. The grammar is an annotated EBNF grammar, I do not want to go into the details here (otherwise it wouldn’t be a q’n d-tutorial ). So, we have to create a new project and enter a grammar:

13. Create a new Xtext project:
    File / New / Project… / Xtext /Xtext Project
14. SetMain project name, the Language name (to de.feu.Tasks), and the DSL-File extension (to tasks).
15. Open Tasks.xtext (this is the EBNF-like grammar) and enter your grammar according to Figure 6.
    Figure 6: Xtext grammar defining our task model along with a concrete textual syntax

    Here is the grammer (for copy & paste):

    grammar de.feu.Tasks with org.eclipse.xtext.common.Terminals
    
    import "http://www.eclipse.org/emf/2002/Ecore" as ecoreimport "platform:/resource/de.feu.company/model/company.ecore" as company
    
    generate tasks "http://www.feu.de/Tasks"
    
    Tasks : (developers+=Developers)* (domainmodels+=DomainModels)* (tasks+=Task)*;
    
    Developers : 'developer' importURI=STRING;
    
    DomainModels : 'domainmodel' importURI=STRING;
    
    Task: 'task' element=[ecore::EObject]    'by' developer=[company::Developer]    ':' description=STRING;

    This grammar defines a container element Tasks. Inside, we can “load” a list of developers and domain models. Eventually, tasks can be defined by assigning an element from a domain model (see element=[ecore::EObject]) to a developer (developer=[company::Developer]) and add a description of that task.

16. Save the gammar and generate the ecore model along with the text editor using the MWE-workflow. For that, select file GenerateTasks.mwe and run the workflow via its context menu Run As / MWE Workflow

Notes:

• In Xtext, a model is called a DSL. Experts like to use different names for “model”, sometimes it’s cooler to call a model “meta-model” (or, even cooler, “meta-meta-model”), sometimes they call it “domain specific language”, abbreviated with a nice TLA (three letter acronym): DSL. Of course, there are good (and sometimes not so good) reasons for doing so, but usually it’s easier to simply call a model a model (and an “instance of a model” an “instance of a model”) .
• The grammar shown in Figure 6 actually uses a lot of nice Xtext features and you will have to read the Xtext documentation for details. I only want to explain one thing here, which is a little bit advanced. You can import existing models into the grammar (import ...). In the example, we import the ecore model and our previously created company model. We import these models in order to be able to define inter-model references later on. Our Task element will refer to an element, which can be any ecore::EObject, and the developer is to one developer defined in our company model (company::Developer). EMF supports inter-model-references, and Xtext generated editors support that feature as well! The import statements in our grammar only import the models, but later on we want to actually import existing model instances. For that, we need the importURI feature of Xtext to define what instance to import in our actual task model instance.

Although we haven’t written a single line of Java code yet, a lot of code has been generated automatically. In order to “activate” that code, which actually defines a new Eclispe plugin, we have to start a new runtime instance of Eclipse, that is we start Eclipse from within Eclipse. In the long run, you will have to get used to Eclipse plugin development anyway…

As we have to run a new instance anyway, we can generate an editor for our company model as well. Instead of using a dynamically created instance using the “Generic EMF Form Editor”, EMF can generate a Java implementation of the model and an editor as well. We will do that now:

17. Select the company.ecore file and choose New / Other… / Eclipse Modeling Framework / EMF Generator Model from its context menu. Use the suggested file name, select Ecore Model in the next wizard page. Then, press Load in the next page, and eventually Finish on the last wizard page. This creates a generator model, which basically adds some information to the original ecore model which is necessary in order to actually generate code (e.g., the name of the plugins and so on). We do not want to change anything here, but we still need that model.
18. In that model, select the very first element (Company) and select Generate All from its context menu (see Figure 7).
    Figure 7 Generate the model and editor code

Work with Multiple Models

Now that we have generate a lot of code, we want to use the newly created tools. Start a new Eclipse runtime instance (e.g. by selecting Run As / Eclipse Application from a project context menu) and do the following:

19. Create a new project (in the runtime instance):
    File / New / Project… / General /Project
20. Select the project and choose from its context menu:
    New / Other… / Example EMF Model Creation Wizard / Company Model
    This activates our previously generated editor (and a wizard) for creating a company model instance. We can edit a company instance just as we did it with the generic editor. In the wizard, select the Model Object Company and then create a new company as shown in Figure 8. (Don’t forget to save the model ).
    Figure 8: A company model, edited with the generated editor

21. Now, create a new file (File / New / File) inside the project and call it project.tasks. The Xtext generated editor is opened automatically and we can now edit the task model instance.
22. In order to “simulate” a project, we create a simple UML use case model. Simply create a new use case diagram via File / New / Other… / UML 2.1 Diagrams / Use Case Diagram, give it a name (e.g. project_usecase) and draw some use cases, a sample is shown in Figure 9.
    Figure 9: A sample use case diagram

23. Switch back to project.tasks and “import” our company model and the sample use cases. Add a task using content assist (Ctrl-Space) just as shown in Figure 10. Just play around, add three or four tasks in order to be able to follow the next steps.
    Figure 10: Content assist, demonstrating access to imported models

24. Just as at the beginning, we want to execute some OCL queries on our model, but this time on our project.task model instance. For OCL, we always need a context, but unfortunately we cannot select a context (or model element) in the text editor. So we have to reopen the project.task with the generic EMF editor: Choose from its context menu Open With / Other… / Generic EMF Form Editor. You will now see the very same model as in the text editor, but this time you see a tree-based version of the model.
25. Open the OCL console just as above, select an element (here Tasks) and enter a query. For example, we want to know how much tasks are assigned to a specific developer: self.tasks->select(developer.name='Jens')->size(). You can see that in Figure 11
    Figure 11 A little more sensible OCL query

Conclusion

IMHO it is impressing what you can do with all these cool Eclipse modelling tools, without writing a single line of (Java) code. We saw how to

• create an EMF ecore model with the Ecore Tools diagram editor
• open the same ecore model with the Generic EMF Form Editor
• create instances of a model without the need to generate code and without starting a new runtime instance, using the “Create Dynamic Instance” feature (and the generic EMF editor again)
• generate a text editor and a model without a single line of Java code with Xtext
• generate a tree based editor and a Java based model implementation with EMF
• create a UML diagram with the UML Tools diagram editor
• query your models with OCL from the OCL project

We didn’t bothered about how to store our models or model intances (it’s all XMI), we were using OMG standards like UML (the EMF based implementation is provided by the UML2 project, EMF’s ecore is an EMOF-like model, we were using OCL, other implementations are available, too (e.g., BPMN2, SBVR, or SPEM used by EPF). And if you do not find an Eclipse project, you probably will find a third party project providing an EMF based implementation

With tools like GEF or GMF you can create (or generate) diagram editors for your models, and (well, I couldn’t resist) with GEF3D you can even create 3D diagram editors, e.g. for visualizing inter-model connections. And there are many more tools out there, partially for simplifying the use of existing tools, for model transformations and code generation and so on. And of course you can adapt and modify the code generated above to suit your need.

Warning: Thin Ice!

While it is very easy to do impressive things (with the help of a tutorial), it is very hard to get into all these frameworks and tools. There are a lot of traps hidden everywhere! Just two examples from the tutorial:

• In the Xtext grammar we used here, the ecore model was imported (see Fig. 6). I tried the very same using the UML2 model, and I got a weird error when generating the code (actually I couldn’t generate in that case).
• A NullPointer-Exception is thrown (you can see that in the console of the original Eclipse instance) when opening the project.tasks file with the Generic EMF Form Editor. Fortunately it still is possible to select an element (for the OCL query), but it’s a little bit weird.

Well, I probably should file a bug report at least for the first problem… So be warned: Even if the tutorial gives you the impression as if modelling with Eclipse tools is very easy, it sometimes isn’t.

In general, modifying generated code as well as using tools like GMF is not that simple. But at least there are the newgroups, tutorials, and even books (e.g. the EMF book (2nd edition!) or the GMF book).

Disclaimer

This is a quick and dirty tutorial article. I simply documented an example modelling session by taking some screenshots, and then wrote some explanations. So, there probably are some things I’ve missed to tell you or errors in my text. Please leave me a comment if you find a bug here (or if you like the tutorial). May the Model be with you!

Some time ago I blogged about running Eclipse (Ganymede) on SoyLatte. Since then there has been little improvement in the state of Java on the Mac. Apple has released a Java 6 for Mac, but it’s a 64-bit only VM which crashes regularly when running Eclipse. Having heard about recent improvements in performance for 64-bit VMs using pointer compression (PDF paper), I decided to have another look at launching Eclipse with an OpenJDK-based VM such as JDK7. After a few false starts I managed to get it working. Here’s what I did:

First, to get JDK7 on my machine. I followed these instructions to build JDK 7 from source. The instructions didn’t work perfectly for me — but they were pretty good. Basically followed everything verbatim with the exception that I had to install MacPorts and use it to get wget.

With a 32-bit JDK7 on my machine, now to use it to start Eclipse. I downloaded the latest I-build of 32-bit Eclipse 3.5 from here (Look for ‘3.5 Stream Integration Builds’).

Using a combination of jconsole and guesswork I came up with this shell script to start Eclipse:

JDKPATH=/Users/dgreen/Documents/packages/jdk7-32bit-2009-05-08DEBUG_OPTS=# DEBUG_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,address=1044,server=y,suspend=yMEM_OPTS=-Xms1024m\ -Xmx1536m\ -XX:MaxPermSize=256mECLIPSE_LOC=/Users/dgreen/Downloads/eclipseWORKSPACE=/Users/dgreen/Documents/workspace

$JDKPATH/bin/java $DEBUG_OPTS \-cp $ECLIPSE_LOC/plugins/org.eclipse.equinox.launcher_1.0.200.v20090429-1630.jar \-XstartOnFirstThread $MEM_OPTS \-Dorg.eclipse.swt.internal.carbon.smallFonts \-Djava.library.path=$ECLIPSE_LOC/Eclipse.app/Contents/MacOS/lib \-Dswt.library.path=$ECLIPSE_LOC/Eclipse.app/Contents/MacOS/lib \org.eclipse.equinox.launcher.Main \-os macosx -ws cocoa -arch x86 \-showsplash -launcher $ECLIPSE_LOC/Eclipse.app/Contents/MacOS/eclipse \-name Eclipse \--launcher.library $ECLIPSE_LOC/plugins/org.eclipse.equinox.launcher.cocoa.macosx_1.0.0.v20090429-1630  \-startup $ECLIPSE_LOC/plugins/org.eclipse.equinox.launcher_1.0.200.v20090429-1630.jar \-data $WORKSPACE \-keyring /Users/dgreen/.eclipse_keyring -consoleLog -showlocation \-vm $JDKPATH

Note that all of the above should appear on one line: your browser may split it into multiple lines.

After starting Eclipse as above I saw the following stack trace on startup:

java.lang.UnsatisfiedLinkError: no swt-pi-cocoa-3547 or swt-pi-cocoa in swt.library.path, java.library.path or the jar file at org.eclipse.swt.internal.Library.loadLibrary(Library.java:248) at org.eclipse.swt.internal.Library.loadLibrary(Library.java:159)       ... snip ...

To solve the problem I extracted all of the *.jnilib files from org.eclipse.equinox.launcher_*.jar and put them in a lib folder. I then renamed all of those *.jnilib files in the lib folder so that they had *.dylib file extensions. I ended up with a file structure as follows:

david-greens-macbook-pro:MacOS dgreen$ pwd/Users/dgreen/Downloads/eclipse/Eclipse.app/Contents/MacOS    <--- where I put the filesdavid-greens-macbook-pro:MacOS dgreen$ ls -l *.sh lib-rwxr-xr-x@ 1 dgreen  staff  1100  8 May 15:47 eclipse.sh    <--- the startup script

lib:        <---- the lib folder for shared librariestotal 2296-rw-r--r--  1 dgreen  staff   37104  8 May 14:20 libswt-awt-cocoa-3547.dylib-rw-r--r--  1 dgreen  staff  287116  8 May 14:20 libswt-cocoa-3547.dylib-rw-r--r--  1 dgreen  staff  539240  8 May 14:20 libswt-pi-cocoa-3547.dylib-rw-r--r--  1 dgreen  staff  300428  8 May 14:20 libswt-xulrunner-cocoa-3547.dylib

Trying the shell script again, Eclipse started up and ran beautifully! Once again I’m running Eclipse with a newer-than-Apple-will-give-me VM, this time JDK 7!! My next step is to compile a 64-bit JDK7 and see if it works too… I have high hopes.

• Updated 2009-05-15 see this issue (bug 276564) for the underlying cause of failure
• Updated 2010-01-19 see Eclipse 3.6 on OpenJDK on Mac OS X for an update

When we released JBoss Developer Studio 2.1 we also announced its updatesite at https://devstudio.jboss.com/updates which is for all customers to use. If you are a 2.1 user you have been able to use it to update to JBoss Developer Studio 2.1.1 which includes some minor bug fixes.

We also started an Early Access Program for existing customers of JBoss Developer Studio 3, and this is available from https://devstudio.jboss.com/earlyaccess using the same credentials as customers use for the updatesite.

This Early Access Program gives customers the chance to try out selected milestone builds for the upcoming JBoss Developer Studio 3 and give feedback on the complete JBoss Developer Studio package and not just on the standalone plugins available through the JBoss Tools project.

At the time of writing the release available from the Early Access is JBoss Developer Studio 3 CR1 which is based on Eclipse 3.5 (Galileo), most of the JBoss Tools 3.1.CR1 plugins and supported 3rd party plugins such as TestNG.

Have fun!

SAP hat zu Eclipse ein mächtiges Tool zur Analyse von Out-Of-Memory-Situationen in Java Anwendungen beigesteuert, den “Eclipse Memory Analyzer”. Mit Eclipse 3.5 (Galileo) ist dieser erstmals Teil der koordinierten Veröffentlichung verschiedener …

SAP hat zu Eclipse ein mächtiges Tool zur Analyse von Out-Of-Memory-Situationen in Java-Anwendungen beigesteuert, den “Eclipse Memory Analyzer”. Mit Eclipse 3.5 (Galileo) ist dieser erstmals Teil der koordinierten Veröffentlichung verschiedener …

Hi Leutz, wieso kann ich bei Eclipse Galileo, dass ja eigentlich eine neuere Version ist, nicht die jsf – api . jar v2.0 einbinden und auf Eclipse.

The Eclipse project Java Workflow Tooling (JWT) released version 0.7 which is now available for download. JWT aims to build design time, development time and runtime workflow tools and to foster an ecosystem of interoperable Business Process Management (BPM) platforms. JWT is integrated in the yearly release train of Eclipse and was already part of Eclipse Galileo.

The main features of the new release are:

• The meta model has been restructured: the project team separated the meta model that includes the business logic from the layout information. An independent meta model now allows developers to handle JWT workflows without causing unnecessary dependencies. View specific data like coordinates are now stored in a separate diagram file which makes the original files not only more robust, but also much lighter and easier to handle. Model transformations, like from and to BPMN, XPDL or the STP project’s Intermediate Model are therefore easier to implement and maintain. To improve the visual representation of workflows, multiple layout information can now be stored for each element in the model.

• Automatic layout algorithms, which have been included from the popular GEF Zest project, finally remove the need of tedious rearranging of positions. Simply using an horizontal, vertical, spring or tree-based theme, the workflow models can now easily be arranged to a preferred layout.

• New converter: Full support for workflow files from previous versions of JWT is now guaranteed by a new ATL-based converter. While the old converter transformed the model elements using Java code, the new converter allows an easy adaptation to future changes of the meta model, including migration of user developed model extensions.

Besides the mentioned changes, version 0.7 provides a better support for aspect-oriented model extensions and significant improvements in performance and stability.

Version 0.7 is a joint release by researchers and developers of the University of Augsburg (Institute of Software and Systems Engineering, group of Prof. Dr. Bernhard Bauer) and the French company OpenWide SA. The University of Augsburg is now also an official (associate) member of the Eclipse Foundation.

The SWT Browser widget makes it very easy to run HTML and JavaScript within Eclipse. This widget encapsulates a browser (system dependent) into a SWT widget.

The following screenshot is from the second example below. This example is based on a blog entry from Ian Bull and SWT Snippet 307.

The following coding will be defining views for Eclipse RCP or via Eclipse plugins so I assume you are familiar with these topics.

Lets start with a simple example. Via the following coding you can setup a View in your Eclipse RCP and inject some JavaScript from your Java Code.

package de.vogella.javascript.simple;

import org.eclipse.swt.SWT;
import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.browser.ProgressEvent;
import org.eclipse.swt.browser.ProgressListener;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.ViewPart;

public class View extends ViewPart {
	public static final String ID = "de.vogella.javascript.simple.view";

	public void createPartControl(Composite parent) {
		// You need XULRunner installed to use this line
//		final Browser b = new Browser(parent, SWT.MOZILLA);
		final Browser b = new Browser(parent, SWT.NONE); // Uses IE on MS Windows
		b.setUrl("http://www.vogella.de");
		b.addProgressListener(new ProgressListener() {
			@Override
			public void completed(ProgressEvent event) {
				System.out.println("Page loaded");
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// Execute JavaScript in the browser
				b.execute("alert(\"JavaScript, called from Java\");");
			}
			@Override
			public void changed(ProgressEvent event) {
			}
		});
	}

	/**
	 * Passing the focus request to the viewer's control.
	 */
	public void setFocus() {
	}
}

The next example is a bit more complex (it is the example from the screenshot). This demonstarte how JavaScript can also call back to your Java Code.

package de.vogella.javascript.maps;

import java.io.File;

import org.eclipse.swt.SWT;
import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.browser.BrowserFunction;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.List;
import org.eclipse.ui.part.ViewPart;

public class View extends ViewPart {

	public static final String ID = "de.vogella.javascript.maps.view";
	private static List list;

	public void createPartControl(Composite parent) {
		SashForm sash = new SashForm(parent, SWT.HORIZONTAL);

		File f = new File("C:/temp/demofile/map.html");
		final Browser browser = new Browser(parent, SWT.NONE); // Uses IE on MS

		browser.addControlListener(new ControlListener() {
			public void controlResized(ControlEvent e) {
				// Use Javascript to set the browser width and height
				browser
						.execute("document.getElementById('map_canvas').style.width= "
								+ (browser.getSize().x - 20) + ";");
				browser
						.execute("document.getElementById('map_canvas').style.height= "
								+ (browser.getSize().y - 20) + ";");
			}

			public void controlMoved(ControlEvent e) {
			}
		});

		 new CustomFunction (browser, "theJavaFunction");

		    Composite c = new Composite(sash, SWT.BORDER);
		    c.setLayout(new GridLayout(2, true));
		    Button b = new Button(c, SWT.PUSH);
		    b.setText("Where Am I ?");
		    b.addSelectionListener(new SelectionAdapter() {
		        public void widgetSelected(SelectionEvent e) {
		            double lat = ((Double) browser.evaluate("return map.getCenter().lat();")).doubleValue();
		            double lng = ((Double) browser.evaluate("return map.getCenter().lng();")).doubleValue();
		            list.add(lat + " : " + lng);
		        }
		    });

		    Button addMarker = new Button(c, SWT.PUSH);
		    addMarker.setText("Add Marker");
		    addMarker.addSelectionListener(new SelectionAdapter() {
		        public void widgetSelected(SelectionEvent e) {
		            browser.evaluate("createMarker();");

		        }
		    });
		    list = new List(c, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
		    GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
		    gridData.horizontalSpan=2;
		    list.setLayoutData(gridData);

		    browser.setUrl(f.toURI().toString());
//		    sash.setWeights(new int[] {4,1});
	}

	/**
	 * Passing the focus request to the viewer's control.
	 */
	public void setFocus() {

	}

	 // Called by JavaScript
	 class CustomFunction extends BrowserFunction {
	    CustomFunctionData data = new CustomFunctionData(null);

		CustomFunction (Browser browser, String name) {
	        super (browser, name);
	        this.data.browser = browser;
	    }
	    public Object function (Object[] arguments) {
	        double lat = ((Double) arguments[0]).doubleValue();
	        double lng = ((Double) arguments[1]).doubleValue();
	        list.add(lat + " : " + lng);
	        data.browser.execute("document.getElementById('map_canvas').style.width= "+ (data.browser.getSize().x - 20) + ";");
	        data.browser.execute("document.getElementById('map_canvas').style.height= "+ (data.browser.getSize().y - 20) + ";");
	        return null;
	    }
	 }
}

The coding above reads a HTML (with some JavaScript code) file “C:/temp/demofile/map.html”. If you save it somewhere else you need to adjust line 28 in the coding above.

<!DOCTYPE html "-//W3C//DTD XHTML 1.0 Strict//EN" 

 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

  <head>

    <meta http-equiv="content-type" content="text/html; charset=utf-8"/>

    <title>Google Maps JavaScript API Example</title>

    <script src="http://maps.google.com/maps?file=api&amp;v=2&amp;key=abcdefg&sensor=false"
            type="text/javascript"></script>
    <script type="text/javascript">

	var map;

    function initialize() {
      if (GBrowserIsCompatible()) {
        map = new GMap2(document.getElementById("map_canvas"));
        map.setCenter(new GLatLng(37.4419, -122.1419), 13);
        map.setUIToDefault();

		// Callback to Java from JavaScript
	    theJavaFunction(map.getCenter().lat(), map.getCenter().lng());

      }

    }

    function createMarker(){
		var lat = map.getCenter().lat();
		var lng = map.getCenter().lng();
        var point = new GLatLng(lat,lng);
		var d=new Date();

		var marker = new GMarker(point, {draggable: true});

		GEvent.addListener(marker, "dragstart", function() {
			map.closeInfoWindow();
		});

		GEvent.addListener(marker, "dragend", function() {
		});

		map.addOverlay(marker);
		addMassiveData();

    }

	function addMassiveData(){
	// Add 10 markers to the map at random locations
		var bounds = map.getBounds();
        var southWest = bounds.getSouthWest();
        var northEast = bounds.getNorthEast();
        var lngSpan = northEast.lng() - southWest.lng();
        var latSpan = northEast.lat() - southWest.lat();
        for (var i = 0; i < 100; i++) {
         var point = new GLatLng(southWest.lat() + latSpan * Math.random(),
               southWest.lng() + lngSpan * Math.random());
        map.addOverlay(new GMarker(point));
		}
	}

    </script>

  </head>

  <body onload="initialize()" >

    <div id="map_canvas" style="width: 600px; height: 400px"></div>

  </body>

</html>

This should demonstrate how easy you can integrate HTML and JavaScript into Eclipse. This is something the Eclipse E4 OpenSocial Gadget project also targets.

Check it out! The Open Social Gadgets with Eclipse E4 – Tutorial tries to give a little introduction.

A nice thing about Eclipse PDE is that it has mechanisms to make it very easy for developers to get started consuming your frameworks. Here are two of them.

Target Platform Templates

For runtime projects, such as Riena, RAP and Equinox, the first hurdle a developer faces is to set-up the appropriate target platform. A target platform is the collection of bundles that are available during compilation. Obviously if you ship runtime components they must end up in there to be available for compilation.

You can make this much easier for others by contributing a target platform template to the “New Target Definition” wizard. A developer can then select an entry in the “Template” drop-down and will instantly receive a pre-configured target definition. Much easier and less error-prone that recreating the target definition manually from step-by-step instructions.

Since the target definition’s payload can be provisioned over http, the developer only has to click on “Set as Target Platform” and is done. For details refer to the org.eclipse.pde.core.targets extension point.

Project Templates

Another way to help developers with their first steps is to provide a project template. This hooks into the last page of “New Plug-in Project” Wizard and pre-populates a new project with source code, binary content and appropriate plugin.xml and MANIFEST.MF files.

The templating mechanism has a lot of depth as you can manipulate data-models to dynamically craft the MANIFEST.MF and plugin.xml files. You can also define placeholder variables, such as $pluginId$ and use them in source templates. There are mechanisms to tie these variables to UI elements in the wizard pages. The developer documentation on the matter is somewhat superficial. At the moment your best bet is to check out and study the org.eclipse.pde.ui.templates project from the Eclipse CVS (/cvsroot/eclipse/pde/ui/org.eclipse.pde.ui.templates). It contains the templates that ship with the IDE and therefore plenty of examples. Complement this by reading the specification of the org.eclipse.pde.ui.pluginContent extension point and this introductory article on developer works.