BPMN2 Modeler Runtime Specialization

Identifier:

Since:

Description:

This extension point is used to customize and extend the BPMN2 Modeler UI as well as the BPMN2 model itself. The following aspects of the editor can be customized; note that some extension points may affect more than one of these aspects:

• Tabbed Property Sheets
  • propertyTab is used to define additional Property Sheet tabs, or replacements for existing default tabs provided by the editor. A Java class may be provided by the extension plug-in to control the behavior of these tabs.
  • modelEnablement controls which BPMN2 model elements and attributes are visible in Property Sheets and dialogs.
  • propertyExtension allows the extension plug-in to define the visual presentation of BPMN2 model attributes and elements by overriding the BPMN2 Modeler core functionality. This extension point may also be used to override the default BPMN2 model object creation behavior. A Java class that implements this behavior must be provided by the extension plug-in.
• Graphical Editing Tool Palette
  • toolPalette is used to define custom Tool Palettes, Tool Drawers and Creation Tools. A simple composition language allows the creation of arbitrarily complex elements and workflow fragments.
  • modelEnablement controls which BPMN2 model elements are available in Tool Palettes.
  • customTask is used to define extended BPMN2 model elements that can be made available as Creation Tools in the Tool Palette. A Java class that manages the custom element lifecycle may also be provided by the extension plug-in.
• Visual presentation of graphical elements
  • featureContainer allows the extension plug-in to override the creation and drawing behavior of BPMN2 elements on the editing canvas. A Java class that implements the override behavior must be provided by the extension plug-in.
  • style is used to define colors, line styles and label fonts of graphical elements on the editing canvas.
• BPMN2 model
  • model is used by an extension plug-in to define a model that augments the BPMN2 model elements. This may be either a traditional EMF model defined by an .ecore file and generated Java implementation classes, or simply a namespace URI for dynamically creating elements and attributes.
  • modelExtension is used to dynamically extend BPMN2 elements. The extension elements and attributes must provide their own namespace URI (i.e. they may not use the BPMN2 model namespace "http://www.omg.org/spec/BPMN/20100524/MODEL") The extension point may also be used to populate existing BPMN2 attributes and elements with non-default values during object creation.
  • customTask is similar to modelExtension except that these objects appear on the Tool Palette.
  • dataType may be used by an extension plug-in to define its own EMF data types and conversion delegates. These data types can then be used in model extension attributes.

<?xml version="1.0" encoding="UTF-8"?>
 <runtime id="org.foo.runtime">
  <modelExtension
   id="org.foo.runtime.my.endpoint.extension"
   uri="http://org.foo/extensions"
   name="My Webservice EndPoint Extension"
   type="EndPoint">
   <property name="serviceAddress" type="ServiceAddress">
    <value>
     <property name="port" type="EString" />
     <property name="binding" type="BindingType:EEnum" value="SOAP HTTP" />
    </value>
   </property>
  </modelExtension>
 </runtime>

  <bpmn2:endPoint id="EndPoint_1">
    <bpmn2:extensionElements>
      <extensions:serviceAddress extensions:port="RequestPortType" extensions:binding="HTTP"/>
    </bpmn2:extensionElements>
  </bpmn2:endPoint>

• Existing process files may no longer be readable if model extension definitions are removed from configuration files; these extension elements may have to be removed from process files "by hand" using a text or XML editor.
• The BPMN2 editor may have to be closed and reopened for some of these configuration file changes to take effect.
• Your configuration files will have to be distributed along with your bpmn2 process files if you are collaborating on a process definition.

Configuration Markup:

<!ELEMENT extension (runtime | model | propertyTab* | customTask* | modelExtension* | modelEnablement* | propertyExtension* | featureContainer* | style* | toolPalette* | dataType* | typeLanguage* | expressionLanguage* | serviceImplementation)+>

<!ATTLIST extension

point CDATA #REQUIRED

id    CDATA #IMPLIED

name  CDATA #IMPLIED>

<!ELEMENT runtime EMPTY>

<!ATTLIST runtime

name        CDATA #REQUIRED

versions    CDATA #IMPLIED

id          CDATA #REQUIRED

description CDATA #IMPLIED

class       CDATA #REQUIRED>

This element defines a namespace for a specific execution engine, referred to as a "Target Runtime" in this documentation.

• name - Descriptive name for this Target Runtime implementation. This text will be displayed in the BPMN2 Modeler Preference Pages under "Target Runtimes".
• versions - A comma-separated list of versions of the runtime that are supported by this plug-in's contributions. This feature is not currently implemented, but is planned for a future version.
• id - Unique ID for this Target Runtime.
• description - Tooltip text displayed for this Target Runtime.
• class - The class that implements the org.eclipse.bpmn2.modeler.core.IBpmn2RuntimeExtension interface for the Target Runtime. This class provides hooks for plug-in lifecycle events, bpmn2 file content type definition, and Runtime-specific target namespace, data type and expression language URIs.

<!ELEMENT model EMPTY>

<!ATTLIST model

runtimeId       CDATA #IMPLIED

uri             CDATA #REQUIRED

resourceFactory CDATA #IMPLIED>

This element specifies an extension model URI that will be used by the Target Runtime plug-in. The model extension may refer to an actual Java implementation, generated the traditional way from an EMF ecore file, or it may just define a namespace URI which will be used to create dynamic classes and features from modelExtension and customClass definitions.

• runtimeId - Identifies one of the previously defined runtime extensions for which this model definition will be used.
• uri - The namespace URI of the model EPackage. This may refer to an acutal EMF model implemented with Java classes, or it may simply be a namespace URI.
• resourceFactory - The fully qualified EMF Resource Factory class name for the extension model. This must subclass org.eclipse.emf.ecore.resource.impl.ResourceFactoryImpl. The Resource Factory provides Target Runtime-specific hooks for model serialization, proxy resolution, object customization, etc.

<!ELEMENT propertyTab EMPTY>

<!ATTLIST propertyTab

id         CDATA #REQUIRED

runtimeId  CDATA #IMPLIED

label      CDATA #IMPLIED

category   CDATA #IMPLIED

afterTab   CDATA #IMPLIED

indented   (true | false)

image      CDATA #IMPLIED

replaceTab CDATA #IMPLIED

class      CDATA #REQUIRED

features   CDATA #IMPLIED

type       CDATA #IMPLIED

popup      (true | false) >

Defines contributions to the Tabbed Property Sheet Page for a selected BPMN2 element.

• id - Unique ID for this propertyTab.
• runtimeId - Identifies one of the previously defined runtime extensions for which this propertyTab definition will be used.
• label - A label to be displayed on the tab.
• category - The category used to group tabs. This feature is not yet implemented.
• afterTab - The ID of the propertyTab after which this tab will be inserted
• indented - If true, then this tab is indented. This is meant to indicate subtabs or categories of a parent tab.
• image - If an image is provided, the icon image is displayed on the tab when the tab is active. This feature is not yet implemented.
• replaceTab - The ID of a propertyTab that will be replaced by this one. Typically this is used to override default tabs provided by the generic BPMN2 Modeler.
• class - The class that implements the property section. This must extend AbstractBpmn2PropertySection and should provide a customized "section root" class which renders the desired BPMN2 element attributes. The section root must extend org.eclipse.bpmn2.modeler.core.merrimac.clad.AbstractBpmn2PropertySection or one of the subclasses from the BPMN2 Modeler. This may also be set to the string "default" to indicate that the DefaultDetailComposite implementation will be used. The list of BPMN2 element attributes that will be rendered is then specified with the features attribute.
• features - A space separated list of model object features to be rendered by the default property tab. This is only used if the class attribute is set to "default".
• type - A space-delimited list of BPMN2 element classes or interfaces that will enable the display of this property sheet tab. These must be fully qualified class names. For example:

  
   type="org.eclipse.bpmn2.di.BPMNDiagram org.eclipse.bpmn2.Process"
   

  will activate the property tab whenever the editor canvas is selected, or when a Process element is selected.
• popup - If "false", this propertyTab will be excluded from popup dialogs. This allows incidental property tabs, such as the Description to be hidden from configuration dialogs. The default value is "true".

<!ELEMENT modelExtension (property)+>

<!ATTLIST modelExtension

id          CDATA #REQUIRED

runtimeId   CDATA #IMPLIED

name        CDATA #IMPLIED

description CDATA #IMPLIED

type        CDATA #REQUIRED

decorator   CDATA #IMPLIED

uri         CDATA #IMPLIED>

Defines extension attributes and elements to the BPMN2 model. Any BPMN2 class that derives from "BaseElement" may be extended. The extension features and classes are defined by property elements contained in this modelExtension.

• id - Unique ID for this modelExtension.
• runtimeId - Identifies one of the previously defined runtime extensions for which this modelExtension definition will be used.
• name - Descriptive text label that will be displayed in the UI.
• description - Long description that will be displayed in the UI.
• type - Name of a BPMN2 model type on which this modelExtension is based. This must be the name of a class that is derived from the BPMN2 "BaseElement" class.
• decorator - An optional decorator class provided by a contributing plugin for this modelExtension. This class must implement the org.eclipse.bpmn2.modeler.core.runtime.IObjectDecorator interface. This class can be used to filter extension objects or perform additional intiailzation of the extended model object.
• uri - The namespace URI of a model EPackage. If the EPackage does not exist it will be created dynamically. This namespace URI will be included in the BPMN2 file when it is saved.

<!ELEMENT customTask (property)*>

<!ATTLIST customTask

id               CDATA #REQUIRED

runtimeId        CDATA #IMPLIED

name             CDATA #REQUIRED

description      CDATA #IMPLIED

type             CDATA #REQUIRED

featureContainer CDATA #REQUIRED

category         CDATA #IMPLIED

propertyTabs     CDATA #IMPLIED

icon             CDATA #IMPLIED

uri              CDATA #IMPLIED>

Defines extension attributes and elements for BPMN2 objects. The difference between this and the modelExtension extension element is that that customTask extensions will appear in the Tool Palette.

• id - Unique ID for this customTask.
• runtimeId - Identifies one of the previously defined runtime extensions for which this customTask definition will be used.
• name - Descriptive text label that will be displayed in the Tool Palette.
• description - Long description used in dialogs and tooltips.
• type - Name of a BPMN2 model type on which this customTask is based. This must be a concrete activity, event, gateway or connection type, for example "BusinessRuleTask", "ExclusiveGateway", "StartEvent" or "SequenceFlow".
• featureContainer - The Graphiti Feature Container that provides create, add and update functionality in the editor for this customTask. This class must implement the org.eclipse.bpmn2.modeler.core.features.ICustomElementFeatureContainer interface.
• category - The Tool Palette Drawer name for this customTask.
• propertyTabs - The Property Tabs to be displayed when one of the graphical elements represented by this customTask is selected. This is a space-separated list of propertyTab IDs.
• icon - An image that is associated with this customTask entry in the TooTool Palettehe string value represents a plugin-relative path to an image file.
• uri - The namespace URI of a model EPackage. If the EPackage does not exist it will be created dynamically. Any property elements defined within this customTask will be used to extend the BPMN2 model type defined by the type attribute.

<!ELEMENT property (value)*>

<!ATTLIST property

name        CDATA #REQUIRED

value       CDATA #IMPLIED

label       CDATA #IMPLIED

description CDATA #IMPLIED

ref         CDATA #IMPLIED

type        CDATA #IMPLIED>

Describes an extension to a BPMN2 model feature. If the feature already exists in an EMF model, then this property element can be used to initialize the feature's value when a new instance of the object is created. If the feature does not exist, it is created using dynamic EMF and extends the existing type, but in a different namespace.

• name - The feature name.
• value - String representation of the default value for this feature. Type conversion is done based on the type attribute.
• label - An optional label to use for this feature in Property Sheets and dialogs.
• description - Description used in dialogs and tooltips.
• ref - Identifies a reference to a previously defined property (no forward references supported at this time). The reference string is a slash-separated name of a property followed by an optional #number used to index list objects; for example:

  
     <property name="ioSpecification">
      <value>
       <property name="dataInputs">
        <value>
         <property name="name" value="TaskName" type="EString"/>
        </value>
       </property>
       <property name="dataInputs">
        <value>
         <property name="name" value="Priority" type="EInt"/>
        </value>
       </property>
  
       <property name="inputSets">
        <value>
         <property name="dataInputRefs" ref="ioSpecification/dataInputs#0"/>
         <property name="dataInputRefs" ref="ioSpecification/dataInputs#1"/>
        </value>
       </property>
      </value>
     </property>
  

  This is interpreted as follows:
  
  1. create an InputOutputSpecification object
  2. create two DataInput objects, and set their "name" attributes to "TaskName" and "Priority" respectively
  3. insert these into the InputOutputSpecification's "dataInputs" list
  4. create an InputSet object and add the two references to the previously created DataInput objects
  5. insert the new InputSet object into the InputOutputSpecification object's "inputSets" list
• type - Specifies the attribute's data type. All of the primitive data types defined by EMF are supported, i.e.:
  • EBoolean
  • EEnum
  • EFloat
  • EDouble
  • EDate
  • EInt
  • ELong
  • EString
  • etc.
  If special data type conversion is required, a converter can be contributed with the dataType element. This attribute is optional and will default to "EString".

<!ELEMENT value (property)*>

<!ATTLIST value

id CDATA #IMPLIED>

If a property represents a complex element instead of a simple attribute, then a value may be used to define and populate the contents of the property. For example:

  <property name="device" type="Device" label="Device Definition">
   <value>
    <property name="type" type="DeviceType:EEnum" value="Phone Tablet Computer Banana" label="Device Type"/>
    <property name="deviceID" type="DeviceIdentifier" label="Device Details">
     <value>
      <property name="carrier" type="EString" value="" label="Carrier or Service Provider"/>
      <property name="identifier" type="EInt" value="0" label="Device Identifier"/>
     </value>
    </property>
   </value>
  </property>

1. create a dynamic EClass structure called "Device"
2. create a dynamic EEnum called "DeviceType"
3. create the EEnum literal values "Phone", "Tablet", "Computer" and "Banana". These will be the only valid values for the DeviceType EEnum
4. create a DeviceType feature in the Device class called "type"
5. create a dynamic EClass structure called "DeviceIdentifier"
6. create two features in DeviceIdentifier called "carrier" (a string) and "identifier" (an integer) and initialize them with an empty string and 0, respectively
7. create a DeviceIdentifier feature in the Device class called "deviceID"

• id - Unique ID for this value.

<!ELEMENT modelEnablement (enable* | disable*)>

<!ATTLIST modelEnablement

id          CDATA #REQUIRED

runtimeId   CDATA #IMPLIED

profile     CDATA #REQUIRED

ref         CDATA #IMPLIED

description CDATA #IMPLIED>

This element is used to select which model classes and features are visible in the editor Tool Palette and Property Sheets. This allows the editor to be tailored to a subset of BPMN2 language elements supported by a particular BPMN2 execution engine.

• id - Unique ID for this modelEnablement profile. The ID is used by the "ref" attribute and also to sort the Tool Palette profiles.
• runtimeId - Identifies one of the previously defined runtime extensions for which this modelEnablement definition will be used.
• profile - Required Tool Profile name that can be used to define different BPMN 2 language subsets (enablements) within each Diagram Type. See the toolPalette element for more information about Tool Profiles.
• ref - Initializes this modelEnablement set from a different Target Runtime, DiagramType and Tool Profile. This simplifies Model Enablement definitions by referencing a base set of enablements already defined. The value of this attribute string must be the referenced Target Runtime ID, and Tool Profile ID defined in the referenced runtime, separated by a colon (:), for example:

  
   ref="org.eclipse.bpmn2.modeler.runtime.none:default.full"
  

• description - Long description used in dialogs and tooltips.

<!ELEMENT enable EMPTY>

<!ATTLIST enable

object  CDATA #REQUIRED

feature CDATA #IMPLIED>

Enables visibility of a specific BPMN2 model class and feature.

• object - Name of the BPMN2 model element to enable. All references made by this element to other BPMN2 elements are enabled also (note: if necessary, the referenced element types can subsequently be disabled). The special object name "all" is used to refer to all BPMN2 elements. The value "default" is used by contributing plugins to refer to enablements in the Default Target Runtime defined in the editor core plugin.
• feature - The name of a structural feature defined by the BPMN2 element named in object. If object has the value "default", then this refers to a diagram type in the modelEnablement section.

<!ELEMENT disable EMPTY>

<!ATTLIST disable

object  CDATA #REQUIRED

feature CDATA #IMPLIED>

Disables visibility of a specific BPMN2 model class and feature.

• object - Name of the BPMN2 element to disable. All references made by this element to other BPMN2 elements are also disabled (note: if necessary, the referenced element types can subsequently be re-enabled). The special object name "all" is used to refer to all BPMN2 elements. The value "default" is used by contributing plugins to refer to enablements in the Default Target Runtime defined in the editor core plugins.
• feature - The name of a structural feature defined by the BPMN2 element named in object. If object has the value "default", then this refers to a diagram type in the modelEnablement section.

<!ELEMENT propertyExtension EMPTY>

<!ATTLIST propertyExtension

id        CDATA #REQUIRED

runtimeId CDATA #IMPLIED

class     CDATA #REQUIRED

type      CDATA #REQUIRED>

Defines a provider class for model object and feature properties. The provider class allows extension plug-ins to define specialized behaviors and properties for BPMN2 model objects. Property Extensions are typically used to define custom labels for objects and features, convert values to and from different types, manage related objects, etc.

• id - Unique ID for this propertyExtension.
• runtimeId - Identifies one of the previously defined runtime extensions for which this propertyExtension definition will be used.
• class - The class that implements the property extension adapter inteface org.eclipse.bpmn2.modeler.core.adapters.ExtendedPropertiesAdapter.
• type - The model type to which this propertyExtension applies. This must be a fully qualified class name, e.g. org.eclipse.bpmn2.SequenceFlow. Note that this may also refer to an extension model class if the Target Runtime defines a Java implementation for an extension model.

<!ELEMENT featureContainer EMPTY>

<!ATTLIST featureContainer

runtimeId CDATA #IMPLIED

class     CDATA #REQUIRED

type      CDATA #REQUIRED>

Defines custom behavior for graphical components managed by the editor. FeatureContainers are the providers of lifecycle behavior for all graphical components, including creation of a component, adding a component to a diagram, updating the visual presentation of a component, resizing and moving the component, etc.

• runtimeId - Identifies one of the previously defined runtime extensions for which this featureContainer definition will be used.
• class - The class that implements the Graphiti Feature Container class. The class must implement the org.eclipse.bpmn2.modeler.core.features.IFeatureContainer interface.
• type - The BPMN2 model element to which this featureContainer applies. This must be a fully qualified class name, e.g. org.eclipse.bpmn2.SequenceFlow

<!ELEMENT style EMPTY>

<!ATTLIST style

object          CDATA #REQUIRED

shapeForeground CDATA #IMPLIED

shapeBackground CDATA #IMPLIED

labelFont       CDATA #IMPLIED

labelForeground CDATA #IMPLIED

labelBackground CDATA #IMPLIED

runtimeId       CDATA #IMPLIED

labelPosition   CDATA #IMPLIED

routingStyle    CDATA #IMPLIED

useDefaultSize  (true | false)

defaultHeight   CDATA #IMPLIED

defaultWidth    CDATA #IMPLIED>

Defines the visual properties of a BPMN2 element, including colors and text fonts.

• object - Name of the model element to which this style applies.
• shapeForeground - The foreground color of the graphical element. For shapes, this is the border and text color; for connections, this is the line color. Colors are a string of six hexadecimal digits representing the red, green and blue color components respectively. For example 00FF00 represents the fully saturated color green.
• shapeBackground - The background or fill color of the graphical element. Connection lines do not use a background color.
• labelFont - The font style and size for text labels. Fonts are encoded as:

  
   fontFamilyName,pointSize,italic,bold
  

  where:
  • fontFamilyName = the system name of a font for example "arial" or "times"
  • pointSize = the size of the font
  • italic = the letter "I" if italic font should be used, or a dash ("-") if roman
  • bold = the letter "B" if a bold font should be used, or a dash ("-") if normal
• labelForeground - The foreground color of the Label.
• labelBackground - The background or fill color of the Label.
• runtimeId - Identifies one of the previously defined runtime extensions for which this style definition will be used.
• labelPosition - The position of the Label relative to the graphical element. This can be one of the following:
  • NORTH - above the figure
  • SOUTH - below the figure
  • WEST - left of figure
  • EAST - right of figure
  • TOP - top inside the figure
  • BOTTOM - bottom inside the figure
  • CENTER - centered inside the figure
  • LEFT - left inside the figure
  • RIGHT - right inside the figure
  • MOVABLE - the Label may be moved independently of its figure. Moving the figure will keep the Label's relative position the same.
• routingStyle - This only applies to Connections. The routing style determines how the editor will layou out connections between figures. This can be one of the following:
  • ManualBendpoint - Connections are initially drawn as straight lines between the source and target figure, but they can be adjust by dragging sections of the figure, thereby manually creating bendpoints.
  • AutomaticBendpoint - Connections are drawn as straight lines between the source and target if possible, but bendpoints will be inserted to avoid collisions with other figures.
  • Manhattan - Connections are drawn as orthogonal line segments, and bendpoints will be inserted to avoid collisions.
• useDefaultSize - This can be used to override the size specifications contained in the BPMN2 file, with default values. See defaultHeight and defaultWidth.
• defaultHeight - The height of the figure when a new one is created, or the default height used if useDefaultSize is "true".
• defaultWidth - The width of the figure when a new one is created, or the default width used if useDefaultSize is "true".

<!ELEMENT toolPalette (category*)>

<!ATTLIST toolPalette

id        CDATA #REQUIRED

runtimeId CDATA #IMPLIED

profile   CDATA #REQUIRED>

Defines a custom Tool Palette for the BPMN2 editor. Tool Palettes are associated with a diagram type and a tool profile name combination. An extension plug-in may define any number of tool profiles and hence, Tool Palettes.

• id - Unique ID for this toolPalette.
• runtimeId - Identifies one of the previously defined runtime extensions for which this toolPalette definition will be used.
• profile - A profile ID that references one of the modelEnablement entries. This can be used to define different Tool Palettes for a selected modelEnablement profile.This may be a space-separated list to indicate that this tool palette should be included in more than one profile.

<!ELEMENT category (tool*)>

<!ATTLIST category

id          CDATA #REQUIRED

name        CDATA #IMPLIED

description CDATA #IMPLIED

icon        CDATA #IMPLIED

before      CDATA #IMPLIED

after       CDATA #IMPLIED

fromPalette CDATA #IMPLIED>

Defines a "category" or Tool Palette Drawer. A toolPalette may have any number of category elements.

• id - Unique ID for this category.
• name - Tool Palette drawer label.
• description - Description used in dialogs and tooltips.
• icon - Tool Palette drawer icon.
• before - Inserts this category before the category whose name is equal to this attribute's value.
• after - Inserts this category after the category whose name is equal to this attribute's value.
• fromPalette - This can be used to reference another toolPalette by its id. The toolPalette definition may be in any contributing plug-in. If used, then the id attribute in this category must reference a category in the fromPalette Tool Palette definition.

<!ELEMENT tool (object*)>

<!ATTLIST tool

id          CDATA #IMPLIED

name        CDATA #REQUIRED

description CDATA #IMPLIED

icon        CDATA #IMPLIED

object      CDATA #IMPLIED

fromPalette CDATA #IMPLIED>

Defines a Tool Palette "tool" which may be used to construct arbitrarily complex sequences of BPMN2 elements. A tool definition may define just a simple object:

 <tool name="Create a Task" object="Task[$name='My Simple Task']"/>

 <tool name="Two Tasks" description="Two Tasks connected by a SequenceFlow">
  <object type="Task" id="task1"/>
  <object type="Task" id="task2"/>
  <object type="SequenceFlow[source='task1',target='task2']"/>
 </tool>

• id - Unique ID for this tool.
• name - Tool label.
• description - Description used in dialogs and tooltips.
• icon - Tool icon.
• object - Definition of the object to be created by this tool. See the description of object for more information: the "object" attribute of this tool definition is the same as the "type" attribute of the object definition.
• fromPalette -

<!ELEMENT object EMPTY>

<!ATTLIST object

type     CDATA #REQUIRED

id       CDATA #IMPLIED

optional (true | false) >

Used to create compound objects and templates.

• type - Object type definition. This consists of a sequence of BPMN2 element types with optional configuration parameters. The BNF is as follows:
  type = TypeList TypeDefList = TypeDef | TypeDefList ',' TypeDef | PushDef | PushDef PopDef PushDef = TypeDefList '+' TypeDefList PopDef = TypeDefList '-' TypeDefList TypeDef = TYPE | TYPE '[' ParamDefList ']' ParamDefList = ParamDef | ParamDefList ',' ParamDef ParamDef = Param '=' Value Param = '$' FEATURE | VAR TYPE = any BPMN2 element type, for example "Task", "StartEvent", "SequenceFlow", etc. FEATURE = the name of a simple data type feature in the BPMN2 element specified by TYPE, for example "name", "implementation", etc. VAR = a predefined variable used in the construction of the object. This may be one of the following: x = x-coordinate where the graphical object will be placed, relative to the mouse cursor position y = y-coordinate where the graphical object will be placed, relative to the mouse cursor position width = the width of the graphical object height = the height o the graphical object source = the ID of another object definition that will be used as the source of a connection target = the ID of another object definition that will be used as the target of a connection

  In its simplest form, a type is simply the name of a BPMN2 element type, for example:

  
   <object type="Task"/>
  

  To assign an initial value to the Task name:

  
   <object type="Task[$name='This is a new Task']"/>
  

  To set the initial size and location of the Task (relative to the mouse cursor):

  
   <object type="Task[x=100,y=100,width=200,height=150]"/>
  

  Multiple objects can be created by separating them with a comma:

  
   <object type="Task,IntermediateCatchEvent[x=200],Task[x=400]"/>
  

  Note that this requires the specification of some location offset to prevent all objects being created at the same location.
  
  The '+' or Push operator can be used within a type definition to create objects within objects, for example this:

  
   <object type="SubProcess+Task"/>
  

  will create a SubProcess that contains a single Task. This also works for adding EventDefinitions to Event objects, for example:

  
   <object type="IntermediateCatchEvent+MessageEventDefinition"/>
  

  Multiple objects can be constructed in the same container by separating them with a comma:

  
   <object type="SubProcess+Task,IntermediateCatchEvent[x=200],Task[x=400]"/>
  

  The Push operator '+' can be used to create additional objects inside the SubProcess. The Pop or '-' operator can be used to restore the target container of subsequent objects (in this case the diagram) like so:

  
   <object type="SubProcess+Task,IntermediateCatchEvent[x=200],Task[x=400]-ExclusiveGateway[x=600]"/>
   

  This is interpreted as follows: create a SubProcess in the Diagram, then within that SubProcess create a Task, an IntermediateCatchEvent and another Task, then pop back to the Diagram and create an ExclusiveGateway. The Push/Pop operators can be nested as deeply as required. Creating connections between objects can be done in two ways, the first method uses the previous two objects as source and target:

  
     <tool name="SubProcess Split" description="SubProcess containing two Tasks, and connected to an ExclusiveGateway">
      <object type="SubProcess+Task,Task,SequenceFlow-ExclusiveGateway[x=300],SequenceFlow"/>
     </tool>
  

  The second method references previous object definitions by their IDs:

  
   <tool name="Two Tasks" description="Two Tasks connected by a SequenceFlow">
    <object type="Task" id="task1"/>
    <object type="Task" id="task2"/>
    <object type="SequenceFlow[source='task1',target='task2']"/>
   </tool>
  

• id - Optional ID which may be referenced by other object definitions, for example when creating a connection between two shapes.
• optional - If "true", then this object may be substituted by a selected graphical element from the editor. This allows the user to select one or more Activities and have them "wired in" with other objects created by the tool.

<!ELEMENT dataType EMPTY>

<!ATTLIST dataType

name  CDATA #REQUIRED

class CDATA #REQUIRED>

Defines a Data Type Conversion delegate. This is used to convert a Target Runtime-specific data type to and from String representations.

• name - The name of the data type. This can be used as the "type" attrinbute in propertydefinitions.
• class - A class that handles the conversion of the data type to and from String types. This class must extend org.eclipse.bpmn2.modeler.core.DefaultConversionDelegate.

<!ELEMENT typeLanguage (type*)>

<!ATTLIST typeLanguage

runtimeId CDATA #IMPLIED

name      CDATA #IMPLIED

uri       CDATA #IMPLIED

prefix    CDATA #IMPLIED>

This extension element identifies a data type system supported by the Target Runtime. A Target Runtime may define any number of these type systems. The definition element that appears first is used as the default. The Default Target Runtime provides support for XSD Schema and Java types only.

• runtimeId - Identifies one of the previously defined runtime extensions for which this typeLanguage definition will be used.
• name - Descriptive text label that will be displayed in the UI.
• uri - A URI that identifies a specific data type system.
• prefix - Optional namespace prefix to use for creating QName references for the primitive data types (if any) defined by the type language.

<!ELEMENT expressionLanguage EMPTY>

<!ATTLIST expressionLanguage

runtimeId CDATA #IMPLIED

name      CDATA #IMPLIED

uri       CDATA #IMPLIED>

This extension element identifies an expression language supported by the Target Runtime. A Target Runtime may define any number of these expression languages. The definition element that appears first is used as the default. The Default Target Runtime provides support for XPath and Java only.

• runtimeId - Identifies one of the previously defined runtime extensions for which this expressionLanguage definition will be used.
• name - Descriptive text label that will be displayed in the UI.
• uri - A URI that identifies a specific expression language.

<!ELEMENT serviceImplementation EMPTY>

<!ATTLIST serviceImplementation

runtimeId CDATA #IMPLIED

name      CDATA #IMPLIED

uri       CDATA #IMPLIED>

This extension element identifies a Service Task implementation supported by the Target Runtime. A Target Runtime may define any number of these implementations. The definition element that appears first is used as the default. The Default Target Runtime provides support for ##WebService and ##Unspecified only.

• runtimeId - Identifies one of the previously defined runtime extensions for which this serviceImplementation definition will be used.
• name - Descriptive text label that will be displayed in the UI.
• uri - A URI that identifies a specific service implementation.

<!ELEMENT type EMPTY>

<!ATTLIST type

name  CDATA #IMPLIED

qname CDATA #IMPLIED>

Specification of a data type supported by the type system.

• name - Name of the data type.
• qname - A fully qualified name for the data type. For example, if the type system implements Java types, this would be the fully qualified name of a primitive Java data type, e.g. "java.lang.String".

Examples:

 <extension point="org.eclipse.bpmn2.modeler.runtime">
  <!-- the runtime definition -->
  <runtime name="Sample Business Process Engine" versions="1.0"
   id="org.eclipse.bpmn2.modeler.examples.dynamic" class="org.eclipse.bpmn2.modeler.examples.dynamic.SampleRuntimeExtension"
   description="BPMN2 Modeler customizations for a sample runtime engine">
  </runtime>

  <!-- In this example, there is no extension model per-se. This model definition 
   only provides a default namespace URI for extension attributes and elements 
   that are defined in the <modelExtension> and <customTask> elements below. 
   We could have provided a namespace URI in each of those elements, but it's 
   more convenient to do so here.
  -->
  <model runtimeId="org.eclipse.bpmn2.modeler.examples.dynamic"
   uri="http://org.eclipse.bpmn2.modeler.examples.dynamic">
  </model>

  <!-- This <customTask> item extends the BPMN2 TextAnnotation element by adding 
   "name", "evaluate" and "cost" attributes. In addition, the "text" attribute 
   which is a feature of TextAnnotation, will be initialized to "Risk Task" 
   whenever a new instance of this item is created. This item will appear as 
   a tool entry in a tool palette drawer named "Risk & Mitigation".
  -->
  <customTask
   description="This task represents a risk that can occur in the connected Elements."
   featureContainer="org.eclipse.bpmn2.modeler.examples.dynamic.SampleCustomTaskFeatureContainer"
   id="org.eclipse.bpmn2.modeler.examples.dynamic.risk" name="Risk Task"
   category="Risk &amp; Mitigation" icon="risk.png"
   runtimeId="org.eclipse.bpmn2.modeler.examples.dynamic" type="TextAnnotation">
   <property name="name" value="Risk Task" type="EString" />
   <property name="text" value="Risk Task" type="EString" />
   <property name="evaluate" value="true" type="EBoolean" />
   <property name="cost" value="0" type="EInt" />
  </customTask>

  <!-- This <modelExtension> extends BPMN2 Activity elements and all subclasses 
   (Task, UserTask, etc.) Besides the boolean "isDevice", the extension adds 
   a new type called "Device" which contains a "type" attribute (an enum) and 
   a "DeviceIdentifier" type which itself contains two attributes, a String 
   and an Integer. Note that a specialized <propertyTab> is needed to display/edit 
   these extensions (see below).
  -->
  <modelExtension id="org.eclipse.bpmn2.modeler.examples.dynamic.activity"
   uri="http://org.eclipse.bpmn2/default" name="Activity Extension"
   type="Activity">
   <property name="isDevice" type="EBoolean" value="true"
    label="Is Device" />
   <property name="device" type="Device" label="Device Definition">
    <value>
     <property name="type" type="DeviceType:EEnum" value="Phone Tablet Computer Banana"
      label="Device Type" />
     <property name="deviceID" type="DeviceIdentifier" label="Device Details">
      <value>
       <property name="carrier" type="EString" value=""
        label="Carrier or Service Provider" />
       <property name="identifier" type="EInt" value="0"
        label="Device Identifier" />
      </value>
     </property>
    </value>
   </property>
  </modelExtension>

  <!-- This <propertyTab> will add a new tab to the Property Sheet called "Activity 
   Extensions". The tab will be visible for all BPMN2 Activity objects and their 
   subclasses (type="org.eclipse.bpmn2.Activity") In this case, the Default 
   property sheet page (class="default") is sufficient to display the attributes 
   and elements, although we could have supplied our own Java class to handle 
   these extensions.
  -->
  <propertyTab id="org.eclipse.bpmn2.modeler.examples.dynamic.activity.tab"
   afterTab="org.eclipse.bpmn2.modeler.description.tab" class="default"
   features="isDevice device carrier identifier" type="org.eclipse.bpmn2.Activity"
   label="Activity Extensions">
  </propertyTab>

 </extension>