Skip to main content

Notice: This Wiki is now read only and edits are no longer possible. Please see: for the plan.

Jump to: navigation, search

Modeling Project Releng/Plugin And Feature Files

Plugin and Feature Files

The contents of your features and plugins directories should mimic what is available in the EMF and UML2 projects. Although this section tries to summarize the important points, "learning by example" is the recommended approach.

Incubation Status

New components must be tagged as "incubating", until such time as they graduate. This is mandatory. To conform to incubation rules and learn more about component graduation, see Incubation Status.

Directory Structure


We will ask you to organize your files as we've done for EMF and UML2. Basically you will need to create the following directory structure for each subdirectory you own under the EMFT module:

OLD Style -- features intermixedNEW Style -- features separated

  1. plugins:
    • the plugins that provide the function
    • the features that include these plugins + the branding plugins for these features
    • the SDK feature (to generate a bundle that includes source + the plugins)
  2. doc:
    • the doc plugins (with the build scripts)
    • the features that include these plugins + the branding plugins for these features
  3. tests:
    • the test plugins (with the Eclipse test framework artifacts - such as this one)
    • the features that include these plugins + the branding plugins for these features
  4. examples:
    • any plugin you want to use as example
    • the features that include these plugins + the branding plugins for these features
  1. plugins:
    • the plugins that provide the function
  2. doc:
    • the doc plugins (with the build scripts)
  3. tests:
    • the test plugins (with the Eclipse test framework artifacts - such as this one)
  4. examples:
    • any plugin you want to use as example
  5. features:
    • the SDK feature (to generate a bundle that includes source + the plugins)
    • all main, source, test, doc, and example features

The directories containing features and fragments must be suffixed by -feature and -fragment respectively.

If you want source plugins and features, you will have to create them.

General Recommendations

  • Each feature and plugin directory should be also an Eclipse project, containing all the necessary files such as, for example, .project.
  • The .project must only refer to builders available to the open-source community. Also, since Eclipse 3M2, it should not refer to other plugin projects. <example>
  • We use CVS to backup the files, so...
    • You can, and probably should, use the $Id$ CVS tag. For more details and other tags read the CVS documentation
    • Add a .cvsignore file to keep unnecessary files (such as the output directory) out of CVS. <example>
  • Don't add unnecessary files to your plugins and features. If you use a "non-Eclipse standard" file, please ensure that it has a purpose and that that purpose is clear.
  • All plugins should provide the following files:
  • The file is extremely important and must be accurate to allow PDE to build your plugins and features. Please review other components' files for plugins with code, documentation and branding plugins, and features. To learn more about how to configure this file, search the help system.

Features <example>

  • The PDE build process is based on features, so all your plugins must be referenced by a feature.
  • A feature directory can contain the definition of other features and plugins. As you can see in the example, we use this to define "derived" elements, like EMF's SDK feature, source feature and source plugin.
  • A feature's file can specify that the source plugin and feature should be generated. In EMF, this is done in the SDK feature's

Qualifiers (1.0.0.qualifier)

  • To add qualifiers to features and plugins, you must have 3 (or more) pieces set up correctly.
1. Plugins <example>
  • Append .qualifier as the 4th field of the plugin version in every MANIFEST.MF file.
2. Features <example>
  • Append .qualifier as the 4th field of the feature version in every feature.xml file.
  • Ensure that if you have comments before the <feature> tag, they do NOT include the word "feature". If they do, 1.0.0.qualifier will not be replaced by PDE with the build's timestamp/id. This is documented in bug 129868.
  • Change the versions in all plugins included in feature.xml files to 0.0.0. PDE will replace 0.0.0 by the appropriate version during the build.
3. Doc
  • Ensure that org.eclipse.[subproject].doc/build.xml uses ${pluginVersion}.${forceContextQualifier} instead of ${pluginVersion} or a hard-coded version like 1.0.0. You may need to add a new property. <example>
<property name="pluginVersion" value="1.0.0"/>
  • Add these lines to the end of the target in org.eclipse.[subproject].doc/build.xml (line break added in path attribute). <example>
OPTIONAL: If you want all your features and plugins to have the SAME qualifier, eg., v200804251234, rather than qualifiers specific to the released tags in your map file(s), add the following lines to the target of releng/[subproject]/buildAll.xml. <example>
<property name="forceContextQualifier" value="v${timestamp}"/>

<echo file="${buildDirectory}/" append="true" >
OPTIONAL: If you would like your features' versions to be suffixed with a dash followed by a random string of letters and numbers, you must also add a line to your files. Why would you want this? It is apparently calculated from the CVS tags to ensure that the version for the features will change if the source changes in the build.
  • Add generateFeatureVersionSuffix=true to all files in every releng/[subproject]/builder/ directory. <example>
  • If available, add generateFeatureVersionSuffix=true to any files in releng/[subproject]/templateFiles/.
  • NOTE: due to property file parser limitations in Eclipse, it is recommended that you always leave an empty line at the end of .properties (and .properties.template) files.
  • For more on plugin versioning, see

Branding Icon In About Eclipse Dialog

If you want to use the Eclipse Modeling icon in the About Eclipse dialog, you must reference it correctly in ALL your about.ini files, eg:

# Property "featureImage" contains path to feature image (32x32)

Note that the latest Eclipse Modeling icon is modeling32.png, as decided by bug 154906. You can copy this new icon from here: modeling32.png

Branding Plugin <example>

  • The "branding plugin" is the plugin that provides specific files to describe a feature - check the example to see what these files are.
  • It is recommended that the branding plugin be given the same name and id as the feature it describes.
  • The "branding plugin" may also contain source, so you don't need to create an additional plugin just to hold the branding files.

Core Plugins & Features <example>

Core Plugins

For plugins with code:

  • The EMF artifacts and model specifications (XML schema, for example) should be located in a models directory in the root of the plugin. Don't forget to include the genmodel to allow users to regenerate your code.
  • DO commit all generated code. This makes it easier to run your plugin from the workspace.
  • The source files should be placed in "source folders" and each "source folder" should have a different "output folder".
  • The plugins with code should be deployed as jarred plugins. In order to tip the PDE build to jar a plugin, you need to set the MANIFEST.MF's Bundle-ClassPath attribute to . and use . in the file. As an example, look at the ecore's manifest and mentally replacing ecore.jar by ..

Right now you are probably asking yourself why the ecore files are declaring a jar instead of using .. To make a long story short, this is necessary for EMF to bootstrap itself during development (required when you use EMF to develop EMF). When developing, we can easily zip the contents of the output folder into the appropriate jar and restart Eclipse. Our build "fixes" the files before the plugins are packaged. Btw, to jar your plugin, you will also need to add unpack="false" to the plugin reference in your feature. <example>

  • Almost all files should have a copyright. This is what is used for the Java files in EMF (please check the other types of files in the example):
 * <copyright>
 * Copyright (c) 2005 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * Contributors: 
 *   IBM - Initial API and implementation
 * </copyright>
  • The META-INF/MANIFEST.MF must end with an empty line. Also, don't forget to add the following line to the manifest to ensure the plugin classes are properly initialized:
Bundle-ActivationPolicy: lazy
  • The .classpath files should only contain references to the JDK and PDE container and the definition of the source and output folders.
  • In order to ensure that your files can be translated, you will need to add the following "directives" to them. All strings after a given directive are supposed to conform to its rules:
NLS_MESSAGEFORMAT_ALL Each string is assumed to be processed by the MessageFormat class (single quote must be coded as 2 consecutive single quotes '').
NLS_MESSAGEFORMAT_NONE All strings are assumed to NOT be processed by the MessageFormat class (single quote must be coded as 1 single quote ').
NLS_MESSAGEFORMAT_VAR Strings which contain replacement variables are processed by the MessageFormat class (single quote must be coded as 2 consecutive single quotes ''). Strings which do NOT contain replacement variables are NOT processed by the MessageFormat class (single quote must be coded as 1 single quote ').
  • Add a schema for each extension point you define in your plugin. <example>

Core Features

Features are used to group functionality. This can be very simple (runtime, sdk, doc, examples, tests) or very complex (see EMF).

For every group of functionality, you need a corresponding feature to collect that function, which must be in turn contributed (included) in its parent feature(s). For example, you might have a ui and a core feature, both of which are part of the runtime feature, and that runtime feature (along with doc, source, and optionally examples) needs to be included in your SDK feature. For more on how Update Manager behaves with respect to feature nesting, see this page.

This is a stub. Contribute to this wiki by adding content here.

Documentation Plugin & Feature

  • While the PDE build is able to automatically create the Ant build script for the plugins with source code, you will need to hard code and maintain the scripts for the documentation plugins.
UPDATE: Instead of using a custom build.xml (by marking it as such in, you can customize a particular build step. See #Customizing Doc Build.
  • If you don't already have a doc plugin/feature, you can use these templates as a starting point.
  • If you already have a doc plugin/feature, here's how to quickly creating your build.xml script:
    1. After adding all the files to the plugin directory and configuring the file, right click the plugin.xml file and select PDE Tools->Create Ant Build File.
    2. Open the build.xml file and delete the tasks in the; target.
    3. In the build.jars, use the zip ant tasks to zip up the content of the plugin - this is required since Eclipse expects the documentation files to be in an archive file.
    4. Open the editor and select the "Custom Build" check box at the top of the page
    5. Every time you start code a new release, you will need to manually update this build script. See the "Release Process" section for more details on new releases.

Customizing Doc Build

PDE Build provides a mechanism for customizing plugin build process. This allows you to perform custom actions during the build while letting PDE take care of the rest (i.e., you don't have to maintain the entire build.xml file). See Feature and Plug-in Custom Build Steps for more information.

In order to inject custom steps into your documentation plugin's build you must provide an Ant script with the required callbacks, such as Mint's Doc plugin. When building the doc plugin you need to invoke an external shell scripts to build your Javadoc content. You can do this before the plugin's bin parts are gathered:

<target name="">
   <property name="eclipseDir" location="../.."/>
   <chmod perm="754" file="build/"/>
   <exec executable="bash" dir="build">
      <arg line="./ ${eclipseDir}"/>
   <help.buildHelpIndex manifest="plugin.xml" destination="."/>

Note that the other callback targets must be defined but may remain empty.

Next, you must tell the builder that you wish to receive callbacks during the build. Add the following lines to your


That's it! If you are migrating from a custom build.xml, don't forget to remove it from CVS. Also, make sure you update your (see Mint's for an example).


  • Note that unless you have images, references, or tutorials at the time you're creating these files, you'll have to toss a placeholder into them so they won't be pruned (ignored) when extracting from CVS. A simple (blank) .cvsignore file will do nicely.

Javadoc Indexed By Eclipse Help

To get Eclipse to index your javadoc in the Help system, you must revise the following files (see also bug 142558):

1. Specify where extra topics_*.xml files are attached to the main table of contents entry: toc.xml

<topic label="Reference">
  <link toc="topics_Reference.xml"/>

2. Specify which files to include in the doc plugin (custom build script, not PDE-generated): build.xml

 <target name="" depends="init" if="destination.temp.folder">
   <fileset dir="${build.result.folder}" 

3. UPDATED Configure javadoc.xml.template, if required. Doclet is no longer used; instead, generation is done simply in

<target name="javadoc" depends="extractPlatformJavadoc">
<javadoc ...>
  <arg value="-J-Xmx256m"/>

4. Define extension points to allow extra topics_*.xml files to be seen in Eclipse Help: plugin.xml

 <!-- ============================= -->
 <!-- Define TOCs                   -->
 <!-- ============================= -->

 <extension point="">
   <toc file="topics_Reference.xml" />

 <!-- ============================= -->
 <!-- Define Javadoc locations      -->
 <!-- ============================= -->
  <extension point="org.eclipse.pde.core.javadoc">
      <javadoc path="references/javadoc"> <!-- defaults to reference/api -->

Tests Plugin & Feature

Until there is a test plugin/feature template, the best approach is to check out an existing working component's tests' plugin(s) and feature and clone what they have, replacing "query" in the above example with "foo", the name of your component.

This is a stub. Contribute to this wiki by adding content here.

Examples Plugin & Feature

Until there is an examples plugin/feature template, the best approach is to check out an existing working component's examples' plugin(s) and feature and clone what they have, replacing "query" in the above example with "foo", the name of your component.

This is a stub. Contribute to this wiki by adding content here.

SDK Feature

This is a stub. Contribute to this wiki by adding content here.

Source Plugin & Feature <example>

  • To create a source plugin and feature, you must have 5 pieces set up correctly.
1. org.eclipse.[subproject]-feature/feature.xml <example>
This will define which * files will be created - one per plugin include in the feature. If you want source for your examples, do the same in your [subproject].examples-feature.
[update] NOTE: you must include your branding plugin (eg., org.eclipse.net4j) in your branding feature (eg., org.eclipse.net4j-feature/feature.xml), even if it contains NO source, in order to properly suppress unpacking src/* in the .source plugin. Ensure that you've set that plugin to be unpack="false":
2. org.eclipse.[subproject]-feature/sourceTemplateFeature/* <example>
3. org.eclipse.[subproject]-feature/sourceTemplatePlugin/* <example>
These define the contents that will go into your source feature(s) and plugin(s).
4. org.eclipse.[subproject]-feature/org.eclipse.[subproject].sdk/feature.xml <example>
This connects your SDK to your .source plugins/features so that they will be included in the SDK. For more on match rules, see Matching Rules.
5. org.eclipse.[subproject].*/ (for ALL applicable plugins) <example>

Bundle-ClassPath With Dot

RECOMMENDED: jarred plugins w/ org/eclipse/.../*.class files


Bundle-ClassPath With Jar

NOT RECOMMENDED: jarred plugins with nested jars

# NLS_MESSAGEFORMAT_VAR source.. = src/ output.. = bin/

src.includes = about.html bin.includes = plugin.xml,\,\ icons/,\ .,\ META-INF/

Use . instead of a jar name; repeat in MANIFEST.MF files:

Bundle-ClassPath: .


# NLS_MESSAGEFORMAT_VAR source.[Bundle-ClassPath] = src/ output.[Bundle-ClassPath] = bin/

src.includes = about.html bin.includes = plugin.xml,\,\ icons/,\ [Bundle-ClassPath],\ META-INF/

Note that [Bundle-ClassPath] is the jar name defined in the matching MANIFEST.MF, such as:

Bundle-ClassPath: eodmeditor.jar

These define what gets packaged in the * files. You should NOT use src.includes = src/ unless you want your source plugin to include BOTH a * (containing *.java source files) and the unpacked *.java source files themselves.

Multiple Namespaces

  • If you want to contribute sources to your SDK, you must create a source plugin and feature for every feature that will contribute source. If you only have one main feature, eg, org.eclipse.emf.[subproject]-feature, there will be one created for every plugin listed in that feature's feature.xml. If you have more than one, as in the case with org.eclipse.emf.transaction, containing both org.eclipse.emf.transaction-feature and org.eclipse.emf.workspace-feature, each must contain its own sourceTemplateFeature and sourceTemplatePlugin. (???)
  • You can also use the generate.feature directive in your SDK's, if you have source for more than one namespace. (???)

Back to the top